fs/sysfs/group.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fs/sysfs/group.c - Operations for adding/removing multiple files at once.
   4  *
   5  * Copyright (c) 2003 Patrick Mochel
   6  * Copyright (c) 2003 Open Source Development Lab
   7  * Copyright (c) 2013 Greg Kroah-Hartman
   8  * Copyright (c) 2013 The Linux Foundation
   9  */
  10
  11 #include <linux/kobject.h>
  12 #include <linux/module.h>
  13 #include <linux/dcache.h>
  14 #include <linux/namei.h>
  15 #include <linux/err.h>
  16 #include <linux/fs.h>
  17 #include "sysfs.h"
  18
  19
  20 static void remove_files(struct kernfs_node *parent,
  21                          const struct attribute_group *grp)
  22 {
  23         struct attribute *const *attr;
  24         struct bin_attribute *const *bin_attr;
  25
  26         if (grp->attrs)
  27                 for (attr = grp->attrs; *attr; attr++)
  28                         kernfs_remove_by_name(parent, (*attr)->name);
  29         if (grp->bin_attrs)
  30                 for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++)
  31                         kernfs_remove_by_name(parent, (*bin_attr)->attr.name);
  32 }
  33
  34 static umode_t __first_visible(const struct attribute_group *grp, struct kobject *kobj)
  35 {
  36         if (grp->attrs && grp->attrs[0] && grp->is_visible)
  37                 return grp->is_visible(kobj, grp->attrs[0], 0);
  38
  39         if (grp->bin_attrs && grp->bin_attrs[0] && grp->is_bin_visible)
  40                 return grp->is_bin_visible(kobj, grp->bin_attrs[0], 0);
  41
  42         return 0;
  43 }
  44
  45 static int create_files(struct kernfs_node *parent, struct kobject *kobj,
  46                         kuid_t uid, kgid_t gid,
  47                         const struct attribute_group *grp, int update)
  48 {
  49         struct attribute *const *attr;
  50         struct bin_attribute *const *bin_attr;
  51         int error = 0, i;
  52
  53         if (grp->attrs) {
  54                 for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
  55                         umode_t mode = (*attr)->mode;
  56
  57                         /*
  58                          * In update mode, we're changing the permissions or
  59                          * visibility.  Do this by first removing then
  60                          * re-adding (if required) the file.
  61                          */
  62                         if (update)
  63                                 kernfs_remove_by_name(parent, (*attr)->name);
  64                         if (grp->is_visible) {
  65                                 mode = grp->is_visible(kobj, *attr, i);
  66                                 mode &= ~SYSFS_GROUP_INVISIBLE;
  67                                 if (!mode)
  68                                         continue;
  69                         }
  70
  71                         WARN(mode & ~(SYSFS_PREALLOC | 0664),
  72                              "Attribute %s: Invalid permissions 0%o\n",
  73                              (*attr)->name, mode);
  74
  75                         mode &= SYSFS_PREALLOC | 0664;
  76                         error = sysfs_add_file_mode_ns(parent, *attr, mode, uid,
  77                                                        gid, NULL);
  78                         if (unlikely(error))
  79                                 break;
  80                 }
  81                 if (error) {
  82                         remove_files(parent, grp);
  83                         goto exit;
  84                 }
  85         }
  86
  87         if (grp->bin_attrs) {
  88                 for (i = 0, bin_attr = grp->bin_attrs; *bin_attr; i++, bin_attr++) {
  89                         umode_t mode = (*bin_attr)->attr.mode;
  90                         size_t size = (*bin_attr)->size;
  91
  92                         if (update)
  93                                 kernfs_remove_by_name(parent,
  94                                                 (*bin_attr)->attr.name);
  95                         if (grp->is_bin_visible) {
  96                                 mode = grp->is_bin_visible(kobj, *bin_attr, i);
  97                                 mode &= ~SYSFS_GROUP_INVISIBLE;
  98                                 if (!mode)
  99                                         continue;
 100                         }
 101                         if (grp->bin_size)
 102                                 size = grp->bin_size(kobj, *bin_attr, i);
 103
 104                         WARN(mode & ~(SYSFS_PREALLOC | 0664),
 105                              "Attribute %s: Invalid permissions 0%o\n",
 106                              (*bin_attr)->attr.name, mode);
 107
 108                         mode &= SYSFS_PREALLOC | 0664;
 109                         error = sysfs_add_bin_file_mode_ns(parent, *bin_attr,
 110                                                            mode, size, uid, gid,
 111                                                            NULL);
 112                         if (error)
 113                                 break;
 114                 }
 115                 if (error)
 116                         remove_files(parent, grp);
 117         }
 118 exit:
 119         return error;
 120 }
 121
 122
 123 static int internal_create_group(struct kobject *kobj, int update,
 124                                  const struct attribute_group *grp)
 125 {
 126         struct kernfs_node *kn;
 127         kuid_t uid;
 128         kgid_t gid;
 129         int error;
 130
 131         if (WARN_ON(!kobj || (!update && !kobj->sd)))
 132                 return -EINVAL;
 133
 134         /* Updates may happen before the object has been instantiated */
 135         if (unlikely(update && !kobj->sd))
 136                 return -EINVAL;
 137
 138         if (!grp->attrs && !grp->bin_attrs) {
 139                 pr_debug("sysfs: (bin_)attrs not set by subsystem for group: %s/%s, skipping\n",
 140                          kobj->name, grp->name ?: "");
 141                 return 0;
 142         }
 143
 144         kobject_get_ownership(kobj, &uid, &gid);
 145         if (grp->name) {
 146                 umode_t mode = __first_visible(grp, kobj);
 147
 148                 if (mode & SYSFS_GROUP_INVISIBLE)
 149                         mode = 0;
 150                 else
 151                         mode = S_IRWXU | S_IRUGO | S_IXUGO;
 152
 153                 if (update) {
 154                         kn = kernfs_find_and_get(kobj->sd, grp->name);
 155                         if (!kn) {
 156                                 pr_debug("attr grp %s/%s not created yet\n",
 157                                          kobj->name, grp->name);
 158                                 /* may have been invisible prior to this update */
 159                                 update = 0;
 160                         } else if (!mode) {
 161                                 sysfs_remove_group(kobj, grp);
 162                                 kernfs_put(kn);
 163                                 return 0;
 164                         }
 165                 }
 166
 167                 if (!update) {
 168                         if (!mode)
 169                                 return 0;
 170                         kn = kernfs_create_dir_ns(kobj->sd, grp->name, mode,
 171                                                   uid, gid, kobj, NULL);
 172                         if (IS_ERR(kn)) {
 173                                 if (PTR_ERR(kn) == -EEXIST)
 174                                         sysfs_warn_dup(kobj->sd, grp->name);
 175                                 return PTR_ERR(kn);
 176                         }
 177                 }
 178         } else {
 179                 kn = kobj->sd;
 180         }
 181
 182         kernfs_get(kn);
 183         error = create_files(kn, kobj, uid, gid, grp, update);
 184         if (error) {
 185                 if (grp->name)
 186                         kernfs_remove(kn);
 187         }
 188         kernfs_put(kn);
 189
 190         if (grp->name && update)
 191                 kernfs_put(kn);
 192
 193         return error;
 194 }
 195
 196 /**
 197  * sysfs_create_group - given a directory kobject, create an attribute group
 198  * @kobj:       The kobject to create the group on
 199  * @grp:        The attribute group to create
 200  *
 201  * This function creates a group for the first time.  It will explicitly
 202  * warn and error if any of the attribute files being created already exist.
 203  *
 204  * Returns 0 on success or error code on failure.
 205  */
 206 int sysfs_create_group(struct kobject *kobj,
 207                        const struct attribute_group *grp)
 208 {
 209         return internal_create_group(kobj, 0, grp);
 210 }
 211 EXPORT_SYMBOL_GPL(sysfs_create_group);
 212
 213 static int internal_create_groups(struct kobject *kobj, int update,
 214                                   const struct attribute_group **groups)
 215 {
 216         int error = 0;
 217         int i;
 218
 219         if (!groups)
 220                 return 0;
 221
 222         for (i = 0; groups[i]; i++) {
 223                 error = internal_create_group(kobj, update, groups[i]);
 224                 if (error) {
 225                         while (--i >= 0)
 226                                 sysfs_remove_group(kobj, groups[i]);
 227                         break;
 228                 }
 229         }
 230         return error;
 231 }
 232
 233 /**
 234  * sysfs_create_groups - given a directory kobject, create a bunch of attribute groups
 235  * @kobj:       The kobject to create the group on
 236  * @groups:     The attribute groups to create, NULL terminated
 237  *
 238  * This function creates a bunch of attribute groups.  If an error occurs when
 239  * creating a group, all previously created groups will be removed, unwinding
 240  * everything back to the original state when this function was called.
 241  * It will explicitly warn and error if any of the attribute files being
 242  * created already exist.
 243  *
 244  * Returns 0 on success or error code from sysfs_create_group on failure.
 245  */
 246 int sysfs_create_groups(struct kobject *kobj,
 247                         const struct attribute_group **groups)
 248 {
 249         return internal_create_groups(kobj, 0, groups);
 250 }
 251 EXPORT_SYMBOL_GPL(sysfs_create_groups);
 252
 253 /**
 254  * sysfs_update_groups - given a directory kobject, create a bunch of attribute groups
 255  * @kobj:       The kobject to update the group on
 256  * @groups:     The attribute groups to update, NULL terminated
 257  *
 258  * This function update a bunch of attribute groups.  If an error occurs when
 259  * updating a group, all previously updated groups will be removed together
 260  * with already existing (not updated) attributes.
 261  *
 262  * Returns 0 on success or error code from sysfs_update_group on failure.
 263  */
 264 int sysfs_update_groups(struct kobject *kobj,
 265                         const struct attribute_group **groups)
 266 {
 267         return internal_create_groups(kobj, 1, groups);
 268 }
 269 EXPORT_SYMBOL_GPL(sysfs_update_groups);
 270
 271 /**
 272  * sysfs_update_group - given a directory kobject, update an attribute group
 273  * @kobj:       The kobject to update the group on
 274  * @grp:        The attribute group to update
 275  *
 276  * This function updates an attribute group.  Unlike
 277  * sysfs_create_group(), it will explicitly not warn or error if any
 278  * of the attribute files being created already exist.  Furthermore,
 279  * if the visibility of the files has changed through the is_visible()
 280  * callback, it will update the permissions and add or remove the
 281  * relevant files. Changing a group's name (subdirectory name under
 282  * kobj's directory in sysfs) is not allowed.
 283  *
 284  * The primary use for this function is to call it after making a change
 285  * that affects group visibility.
 286  *
 287  * Returns 0 on success or error code on failure.
 288  */
 289 int sysfs_update_group(struct kobject *kobj,
 290                        const struct attribute_group *grp)
 291 {
 292         return internal_create_group(kobj, 1, grp);
 293 }
 294 EXPORT_SYMBOL_GPL(sysfs_update_group);
 295
 296 /**
 297  * sysfs_remove_group: remove a group from a kobject
 298  * @kobj:       kobject to remove the group from
 299  * @grp:        group to remove
 300  *
 301  * This function removes a group of attributes from a kobject.  The attributes
 302  * previously have to have been created for this group, otherwise it will fail.
 303  */
 304 void sysfs_remove_group(struct kobject *kobj,
 305                         const struct attribute_group *grp)
 306 {
 307         struct kernfs_node *parent = kobj->sd;
 308         struct kernfs_node *kn;
 309
 310         if (grp->name) {
 311                 kn = kernfs_find_and_get(parent, grp->name);
 312                 if (!kn) {
 313                         pr_debug("sysfs group '%s' not found for kobject '%s'\n",
 314                                  grp->name, kobject_name(kobj));
 315                         return;
 316                 }
 317         } else {
 318                 kn = parent;
 319                 kernfs_get(kn);
 320         }
 321
 322         remove_files(kn, grp);
 323         if (grp->name)
 324                 kernfs_remove(kn);
 325
 326         kernfs_put(kn);
 327 }
 328 EXPORT_SYMBOL_GPL(sysfs_remove_group);
 329
 330 /**
 331  * sysfs_remove_groups - remove a list of groups
 332  *
 333  * @kobj:       The kobject for the groups to be removed from
 334  * @groups:     NULL terminated list of groups to be removed
 335  *
 336  * If groups is not NULL, remove the specified groups from the kobject.
 337  */
 338 void sysfs_remove_groups(struct kobject *kobj,
 339                          const struct attribute_group **groups)
 340 {
 341         int i;
 342
 343         if (!groups)
 344                 return;
 345         for (i = 0; groups[i]; i++)
 346                 sysfs_remove_group(kobj, groups[i]);
 347 }
 348 EXPORT_SYMBOL_GPL(sysfs_remove_groups);
 349
 350 /**
 351  * sysfs_merge_group - merge files into a pre-existing named attribute group.
 352  * @kobj:       The kobject containing the group.
 353  * @grp:        The files to create and the attribute group they belong to.
 354  *
 355  * This function returns an error if the group doesn't exist, the .name field is
 356  * NULL or any of the files already exist in that group, in which case none of
 357  * the new files are created.
 358  */
 359 int sysfs_merge_group(struct kobject *kobj,
 360                        const struct attribute_group *grp)
 361 {
 362         struct kernfs_node *parent;
 363         kuid_t uid;
 364         kgid_t gid;
 365         int error = 0;
 366         struct attribute *const *attr;
 367         int i;
 368
 369         parent = kernfs_find_and_get(kobj->sd, grp->name);
 370         if (!parent)
 371                 return -ENOENT;
 372
 373         kobject_get_ownership(kobj, &uid, &gid);
 374
 375         for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
 376                 error = sysfs_add_file_mode_ns(parent, *attr, (*attr)->mode,
 377                                                uid, gid, NULL);
 378         if (error) {
 379                 while (--i >= 0)
 380                         kernfs_remove_by_name(parent, (*--attr)->name);
 381         }
 382         kernfs_put(parent);
 383
 384         return error;
 385 }
 386 EXPORT_SYMBOL_GPL(sysfs_merge_group);
 387
 388 /**
 389  * sysfs_unmerge_group - remove files from a pre-existing named attribute group.
 390  * @kobj:       The kobject containing the group.
 391  * @grp:        The files to remove and the attribute group they belong to.
 392  */
 393 void sysfs_unmerge_group(struct kobject *kobj,
 394                        const struct attribute_group *grp)
 395 {
 396         struct kernfs_node *parent;
 397         struct attribute *const *attr;
 398
 399         parent = kernfs_find_and_get(kobj->sd, grp->name);
 400         if (parent) {
 401                 for (attr = grp->attrs; *attr; ++attr)
 402                         kernfs_remove_by_name(parent, (*attr)->name);
 403                 kernfs_put(parent);
 404         }
 405 }
 406 EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
 407
 408 /**
 409  * sysfs_add_link_to_group - add a symlink to an attribute group.
 410  * @kobj:       The kobject containing the group.
 411  * @group_name: The name of the group.
 412  * @target:     The target kobject of the symlink to create.
 413  * @link_name:  The name of the symlink to create.
 414  */
 415 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
 416                             struct kobject *target, const char *link_name)
 417 {
 418         struct kernfs_node *parent;
 419         int error = 0;
 420
 421         parent = kernfs_find_and_get(kobj->sd, group_name);
 422         if (!parent)
 423                 return -ENOENT;
 424
 425         error = sysfs_create_link_sd(parent, target, link_name);
 426         kernfs_put(parent);
 427
 428         return error;
 429 }
 430 EXPORT_SYMBOL_GPL(sysfs_add_link_to_group);
 431
 432 /**
 433  * sysfs_remove_link_from_group - remove a symlink from an attribute group.
 434  * @kobj:       The kobject containing the group.
 435  * @group_name: The name of the group.
 436  * @link_name:  The name of the symlink to remove.
 437  */
 438 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
 439                                   const char *link_name)
 440 {
 441         struct kernfs_node *parent;
 442
 443         parent = kernfs_find_and_get(kobj->sd, group_name);
 444         if (parent) {
 445                 kernfs_remove_by_name(parent, link_name);
 446                 kernfs_put(parent);
 447         }
 448 }
 449 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group);
 450
 451 /**
 452  * compat_only_sysfs_link_entry_to_kobj - add a symlink to a kobject pointing
 453  * to a group or an attribute
 454  * @kobj:               The kobject containing the group.
 455  * @target_kobj:        The target kobject.
 456  * @target_name:        The name of the target group or attribute.
 457  * @symlink_name:       The name of the symlink file (target_name will be
 458  *                      considered if symlink_name is NULL).
 459  */
 460 int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj,
 461                                          struct kobject *target_kobj,
 462                                          const char *target_name,
 463                                          const char *symlink_name)
 464 {
 465         struct kernfs_node *target;
 466         struct kernfs_node *entry;
 467         struct kernfs_node *link;
 468
 469         /*
 470          * We don't own @target_kobj and it may be removed at any time.
 471          * Synchronize using sysfs_symlink_target_lock. See sysfs_remove_dir()
 472          * for details.
 473          */
 474         spin_lock(&sysfs_symlink_target_lock);
 475         target = target_kobj->sd;
 476         if (target)
 477                 kernfs_get(target);
 478         spin_unlock(&sysfs_symlink_target_lock);
 479         if (!target)
 480                 return -ENOENT;
 481
 482         entry = kernfs_find_and_get(target, target_name);
 483         if (!entry) {
 484                 kernfs_put(target);
 485                 return -ENOENT;
 486         }
 487
 488         if (!symlink_name)
 489                 symlink_name = target_name;
 490
 491         link = kernfs_create_link(kobj->sd, symlink_name, entry);
 492         if (PTR_ERR(link) == -EEXIST)
 493                 sysfs_warn_dup(kobj->sd, symlink_name);
 494
 495         kernfs_put(entry);
 496         kernfs_put(target);
 497         return PTR_ERR_OR_ZERO(link);
 498 }
 499 EXPORT_SYMBOL_GPL(compat_only_sysfs_link_entry_to_kobj);
 500
 501 static int sysfs_group_attrs_change_owner(struct kernfs_node *grp_kn,
 502                                           const struct attribute_group *grp,
 503                                           struct iattr *newattrs)
 504 {
 505         struct kernfs_node *kn;
 506         int error;
 507
 508         if (grp->attrs) {
 509                 struct attribute *const *attr;
 510
 511                 for (attr = grp->attrs; *attr; attr++) {
 512                         kn = kernfs_find_and_get(grp_kn, (*attr)->name);
 513                         if (!kn)
 514                                 return -ENOENT;
 515
 516                         error = kernfs_setattr(kn, newattrs);
 517                         kernfs_put(kn);
 518                         if (error)
 519                                 return error;
 520                 }
 521         }
 522
 523         if (grp->bin_attrs) {
 524                 struct bin_attribute *const *bin_attr;
 525
 526                 for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) {
 527                         kn = kernfs_find_and_get(grp_kn, (*bin_attr)->attr.name);
 528                         if (!kn)
 529                                 return -ENOENT;
 530
 531                         error = kernfs_setattr(kn, newattrs);
 532                         kernfs_put(kn);
 533                         if (error)
 534                                 return error;
 535                 }
 536         }
 537
 538         return 0;
 539 }
 540
 541 /**
 542  * sysfs_group_change_owner - change owner of an attribute group.
 543  * @kobj:       The kobject containing the group.
 544  * @grp:        The attribute group.
 545  * @kuid:       new owner's kuid
 546  * @kgid:       new owner's kgid
 547  *
 548  * Returns 0 on success or error code on failure.
 549  */
 550 int sysfs_group_change_owner(struct kobject *kobj,
 551                              const struct attribute_group *grp, kuid_t kuid,
 552                              kgid_t kgid)
 553 {
 554         struct kernfs_node *grp_kn;
 555         int error;
 556         struct iattr newattrs = {
 557                 .ia_valid = ATTR_UID | ATTR_GID,
 558                 .ia_uid = kuid,
 559                 .ia_gid = kgid,
 560         };
 561
 562         if (!kobj->state_in_sysfs)
 563                 return -EINVAL;
 564
 565         if (grp->name) {
 566                 grp_kn = kernfs_find_and_get(kobj->sd, grp->name);
 567         } else {
 568                 kernfs_get(kobj->sd);
 569                 grp_kn = kobj->sd;
 570         }
 571         if (!grp_kn)
 572                 return -ENOENT;
 573
 574         error = kernfs_setattr(grp_kn, &newattrs);
 575         if (!error)
 576                 error = sysfs_group_attrs_change_owner(grp_kn, grp, &newattrs);
 577
 578         kernfs_put(grp_kn);
 579
 580         return error;
 581 }
 582 EXPORT_SYMBOL_GPL(sysfs_group_change_owner);
 583
 584 /**
 585  * sysfs_groups_change_owner - change owner of a set of attribute groups.
 586  * @kobj:       The kobject containing the groups.
 587  * @groups:     The attribute groups.
 588  * @kuid:       new owner's kuid
 589  * @kgid:       new owner's kgid
 590  *
 591  * Returns 0 on success or error code on failure.
 592  */
 593 int sysfs_groups_change_owner(struct kobject *kobj,
 594                               const struct attribute_group **groups,
 595                               kuid_t kuid, kgid_t kgid)
 596 {
 597         int error = 0, i;
 598
 599         if (!kobj->state_in_sysfs)
 600                 return -EINVAL;
 601
 602         if (!groups)
 603                 return 0;
 604
 605         for (i = 0; groups[i]; i++) {
 606                 error = sysfs_group_change_owner(kobj, groups[i], kuid, kgid);
 607                 if (error)
 608                         break;
 609         }
 610
 611         return error;
 612 }
 613 EXPORT_SYMBOL_GPL(sysfs_groups_change_owner);