fs/sysfs/group.c

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