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 "sysfs.h"
  17
  18
  19 static void remove_files(struct kernfs_node *parent,
  20                          const struct attribute_group *grp)
  21 {
  22         struct attribute *const *attr;
  23         struct bin_attribute *const *bin_attr;
  24
  25         if (grp->attrs)
  26                 for (attr = grp->attrs; *attr; attr++)
  27                         kernfs_remove_by_name(parent, (*attr)->name);
  28         if (grp->bin_attrs)
  29                 for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++)
  30                         kernfs_remove_by_name(parent, (*bin_attr)->attr.name);
  31 }
  32
  33 static int create_files(struct kernfs_node *parent, struct kobject *kobj,
  34                         const struct attribute_group *grp, int update)
  35 {
  36         struct attribute *const *attr;
  37         struct bin_attribute *const *bin_attr;
  38         int error = 0, i;
  39
  40         if (grp->attrs) {
  41                 for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
  42                         umode_t mode = (*attr)->mode;
  43
  44                         /*
  45                          * In update mode, we're changing the permissions or
  46                          * visibility.  Do this by first removing then
  47                          * re-adding (if required) the file.
  48                          */
  49                         if (update)
  50                                 kernfs_remove_by_name(parent, (*attr)->name);
  51                         if (grp->is_visible) {
  52                                 mode = grp->is_visible(kobj, *attr, i);
  53                                 if (!mode)
  54                                         continue;
  55                         }
  56
  57                         WARN(mode & ~(SYSFS_PREALLOC | 0664),
  58                              "Attribute %s: Invalid permissions 0%o\n",
  59                              (*attr)->name, mode);
  60
  61                         mode &= SYSFS_PREALLOC | 0664;
  62                         error = sysfs_add_file_mode_ns(parent, *attr, false,
  63                                                        mode, NULL);
  64                         if (unlikely(error))
  65                                 break;
  66                 }
  67                 if (error) {
  68                         remove_files(parent, grp);
  69                         goto exit;
  70                 }
  71         }
  72
  73         if (grp->bin_attrs) {
  74                 for (i = 0, bin_attr = grp->bin_attrs; *bin_attr; i++, bin_attr++) {
  75                         umode_t mode = (*bin_attr)->attr.mode;
  76
  77                         if (update)
  78                                 kernfs_remove_by_name(parent,
  79                                                 (*bin_attr)->attr.name);
  80                         if (grp->is_bin_visible) {
  81                                 mode = grp->is_bin_visible(kobj, *bin_attr, i);
  82                                 if (!mode)
  83                                         continue;
  84                         }
  85
  86                         WARN(mode & ~(SYSFS_PREALLOC | 0664),
  87                              "Attribute %s: Invalid permissions 0%o\n",
  88                              (*bin_attr)->attr.name, mode);
  89
  90                         mode &= SYSFS_PREALLOC | 0664;
  91                         error = sysfs_add_file_mode_ns(parent,
  92                                         &(*bin_attr)->attr, true,
  93                                         mode, NULL);
  94                         if (error)
  95                                 break;
  96                 }
  97                 if (error)
  98                         remove_files(parent, grp);
  99         }
 100 exit:
 101         return error;
 102 }
 103
 104
 105 static int internal_create_group(struct kobject *kobj, int update,
 106                                  const struct attribute_group *grp)
 107 {
 108         struct kernfs_node *kn;
 109         int error;
 110
 111         BUG_ON(!kobj || (!update && !kobj->sd));
 112
 113         /* Updates may happen before the object has been instantiated */
 114         if (unlikely(update && !kobj->sd))
 115                 return -EINVAL;
 116         if (!grp->attrs && !grp->bin_attrs) {
 117                 WARN(1, "sysfs: (bin_)attrs not set by subsystem for group: %s/%s\n",
 118                         kobj->name, grp->name ?: "");
 119                 return -EINVAL;
 120         }
 121         if (grp->name) {
 122                 kn = kernfs_create_dir(kobj->sd, grp->name,
 123                                        S_IRWXU | S_IRUGO | S_IXUGO, kobj);
 124                 if (IS_ERR(kn)) {
 125                         if (PTR_ERR(kn) == -EEXIST)
 126                                 sysfs_warn_dup(kobj->sd, grp->name);
 127                         return PTR_ERR(kn);
 128                 }
 129         } else
 130                 kn = kobj->sd;
 131         kernfs_get(kn);
 132         error = create_files(kn, kobj, grp, update);
 133         if (error) {
 134                 if (grp->name)
 135                         kernfs_remove(kn);
 136         }
 137         kernfs_put(kn);
 138         return error;
 139 }
 140
 141 /**
 142  * sysfs_create_group - given a directory kobject, create an attribute group
 143  * @kobj:       The kobject to create the group on
 144  * @grp:        The attribute group to create
 145  *
 146  * This function creates a group for the first time.  It will explicitly
 147  * warn and error if any of the attribute files being created already exist.
 148  *
 149  * Returns 0 on success or error code on failure.
 150  */
 151 int sysfs_create_group(struct kobject *kobj,
 152                        const struct attribute_group *grp)
 153 {
 154         return internal_create_group(kobj, 0, grp);
 155 }
 156 EXPORT_SYMBOL_GPL(sysfs_create_group);
 157
 158 /**
 159  * sysfs_create_groups - given a directory kobject, create a bunch of attribute groups
 160  * @kobj:       The kobject to create the group on
 161  * @groups:     The attribute groups to create, NULL terminated
 162  *
 163  * This function creates a bunch of attribute groups.  If an error occurs when
 164  * creating a group, all previously created groups will be removed, unwinding
 165  * everything back to the original state when this function was called.
 166  * It will explicitly warn and error if any of the attribute files being
 167  * created already exist.
 168  *
 169  * Returns 0 on success or error code from sysfs_create_group on failure.
 170  */
 171 int sysfs_create_groups(struct kobject *kobj,
 172                         const struct attribute_group **groups)
 173 {
 174         int error = 0;
 175         int i;
 176
 177         if (!groups)
 178                 return 0;
 179
 180         for (i = 0; groups[i]; i++) {
 181                 error = sysfs_create_group(kobj, groups[i]);
 182                 if (error) {
 183                         while (--i >= 0)
 184                                 sysfs_remove_group(kobj, groups[i]);
 185                         break;
 186                 }
 187         }
 188         return error;
 189 }
 190 EXPORT_SYMBOL_GPL(sysfs_create_groups);
 191
 192 /**
 193  * sysfs_update_group - given a directory kobject, update an attribute group
 194  * @kobj:       The kobject to update the group on
 195  * @grp:        The attribute group to update
 196  *
 197  * This function updates an attribute group.  Unlike
 198  * sysfs_create_group(), it will explicitly not warn or error if any
 199  * of the attribute files being created already exist.  Furthermore,
 200  * if the visibility of the files has changed through the is_visible()
 201  * callback, it will update the permissions and add or remove the
 202  * relevant files.
 203  *
 204  * The primary use for this function is to call it after making a change
 205  * that affects group visibility.
 206  *
 207  * Returns 0 on success or error code on failure.
 208  */
 209 int sysfs_update_group(struct kobject *kobj,
 210                        const struct attribute_group *grp)
 211 {
 212         return internal_create_group(kobj, 1, grp);
 213 }
 214 EXPORT_SYMBOL_GPL(sysfs_update_group);
 215
 216 /**
 217  * sysfs_remove_group: remove a group from a kobject
 218  * @kobj:       kobject to remove the group from
 219  * @grp:        group to remove
 220  *
 221  * This function removes a group of attributes from a kobject.  The attributes
 222  * previously have to have been created for this group, otherwise it will fail.
 223  */
 224 void sysfs_remove_group(struct kobject *kobj,
 225                         const struct attribute_group *grp)
 226 {
 227         struct kernfs_node *parent = kobj->sd;
 228         struct kernfs_node *kn;
 229
 230         if (grp->name) {
 231                 kn = kernfs_find_and_get(parent, grp->name);
 232                 if (!kn) {
 233                         WARN(!kn, KERN_WARNING
 234                              "sysfs group '%s' not found for kobject '%s'\n",
 235                              grp->name, kobject_name(kobj));
 236                         return;
 237                 }
 238         } else {
 239                 kn = parent;
 240                 kernfs_get(kn);
 241         }
 242
 243         remove_files(kn, grp);
 244         if (grp->name)
 245                 kernfs_remove(kn);
 246
 247         kernfs_put(kn);
 248 }
 249 EXPORT_SYMBOL_GPL(sysfs_remove_group);
 250
 251 /**
 252  * sysfs_remove_groups - remove a list of groups
 253  *
 254  * @kobj:       The kobject for the groups to be removed from
 255  * @groups:     NULL terminated list of groups to be removed
 256  *
 257  * If groups is not NULL, remove the specified groups from the kobject.
 258  */
 259 void sysfs_remove_groups(struct kobject *kobj,
 260                          const struct attribute_group **groups)
 261 {
 262         int i;
 263
 264         if (!groups)
 265                 return;
 266         for (i = 0; groups[i]; i++)
 267                 sysfs_remove_group(kobj, groups[i]);
 268 }
 269 EXPORT_SYMBOL_GPL(sysfs_remove_groups);
 270
 271 /**
 272  * sysfs_merge_group - merge files into a pre-existing attribute group.
 273  * @kobj:       The kobject containing the group.
 274  * @grp:        The files to create and the attribute group they belong to.
 275  *
 276  * This function returns an error if the group doesn't exist or any of the
 277  * files already exist in that group, in which case none of the new files
 278  * are created.
 279  */
 280 int sysfs_merge_group(struct kobject *kobj,
 281                        const struct attribute_group *grp)
 282 {
 283         struct kernfs_node *parent;
 284         int error = 0;
 285         struct attribute *const *attr;
 286         int i;
 287
 288         parent = kernfs_find_and_get(kobj->sd, grp->name);
 289         if (!parent)
 290                 return -ENOENT;
 291
 292         for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
 293                 error = sysfs_add_file(parent, *attr, false);
 294         if (error) {
 295                 while (--i >= 0)
 296                         kernfs_remove_by_name(parent, (*--attr)->name);
 297         }
 298         kernfs_put(parent);
 299
 300         return error;
 301 }
 302 EXPORT_SYMBOL_GPL(sysfs_merge_group);
 303
 304 /**
 305  * sysfs_unmerge_group - remove files from a pre-existing attribute group.
 306  * @kobj:       The kobject containing the group.
 307  * @grp:        The files to remove and the attribute group they belong to.
 308  */
 309 void sysfs_unmerge_group(struct kobject *kobj,
 310                        const struct attribute_group *grp)
 311 {
 312         struct kernfs_node *parent;
 313         struct attribute *const *attr;
 314
 315         parent = kernfs_find_and_get(kobj->sd, grp->name);
 316         if (parent) {
 317                 for (attr = grp->attrs; *attr; ++attr)
 318                         kernfs_remove_by_name(parent, (*attr)->name);
 319                 kernfs_put(parent);
 320         }
 321 }
 322 EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
 323
 324 /**
 325  * sysfs_add_link_to_group - add a symlink to an attribute group.
 326  * @kobj:       The kobject containing the group.
 327  * @group_name: The name of the group.
 328  * @target:     The target kobject of the symlink to create.
 329  * @link_name:  The name of the symlink to create.
 330  */
 331 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
 332                             struct kobject *target, const char *link_name)
 333 {
 334         struct kernfs_node *parent;
 335         int error = 0;
 336
 337         parent = kernfs_find_and_get(kobj->sd, group_name);
 338         if (!parent)
 339                 return -ENOENT;
 340
 341         error = sysfs_create_link_sd(parent, target, link_name);
 342         kernfs_put(parent);
 343
 344         return error;
 345 }
 346 EXPORT_SYMBOL_GPL(sysfs_add_link_to_group);
 347
 348 /**
 349  * sysfs_remove_link_from_group - remove a symlink from an attribute group.
 350  * @kobj:       The kobject containing the group.
 351  * @group_name: The name of the group.
 352  * @link_name:  The name of the symlink to remove.
 353  */
 354 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
 355                                   const char *link_name)
 356 {
 357         struct kernfs_node *parent;
 358
 359         parent = kernfs_find_and_get(kobj->sd, group_name);
 360         if (parent) {
 361                 kernfs_remove_by_name(parent, link_name);
 362                 kernfs_put(parent);
 363         }
 364 }
 365 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group);
 366
 367 /**
 368  * __compat_only_sysfs_link_entry_to_kobj - add a symlink to a kobject pointing
 369  * to a group or an attribute
 370  * @kobj:               The kobject containing the group.
 371  * @target_kobj:        The target kobject.
 372  * @target_name:        The name of the target group or attribute.
 373  */
 374 int __compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj,
 375                                       struct kobject *target_kobj,
 376                                       const char *target_name)
 377 {
 378         struct kernfs_node *target;
 379         struct kernfs_node *entry;
 380         struct kernfs_node *link;
 381
 382         /*
 383          * We don't own @target_kobj and it may be removed at any time.
 384          * Synchronize using sysfs_symlink_target_lock. See sysfs_remove_dir()
 385          * for details.
 386          */
 387         spin_lock(&sysfs_symlink_target_lock);
 388         target = target_kobj->sd;
 389         if (target)
 390                 kernfs_get(target);
 391         spin_unlock(&sysfs_symlink_target_lock);
 392         if (!target)
 393                 return -ENOENT;
 394
 395         entry = kernfs_find_and_get(target_kobj->sd, target_name);
 396         if (!entry) {
 397                 kernfs_put(target);
 398                 return -ENOENT;
 399         }
 400
 401         link = kernfs_create_link(kobj->sd, target_name, entry);
 402         if (IS_ERR(link) && PTR_ERR(link) == -EEXIST)
 403                 sysfs_warn_dup(kobj->sd, target_name);
 404
 405         kernfs_put(entry);
 406         kernfs_put(target);
 407         return PTR_ERR_OR_ZERO(link);
 408 }
 409 EXPORT_SYMBOL_GPL(__compat_only_sysfs_link_entry_to_kobj);