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 sysfs_dirent *dir_sd, struct kobject *kobj,
  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                         sysfs_hash_and_remove(dir_sd, (*attr)->name, NULL);
  30         if (grp->bin_attrs)
  31                 for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++)
  32                         sysfs_remove_bin_file(kobj, *bin_attr);
  33 }
  34
  35 static int create_files(struct sysfs_dirent *dir_sd, 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                                 sysfs_hash_and_remove(dir_sd, (*attr)->name,
  53                                                       NULL);
  54                         if (grp->is_visible) {
  55                                 mode = grp->is_visible(kobj, *attr, i);
  56                                 if (!mode)
  57                                         continue;
  58                         }
  59                         error = sysfs_add_file_mode_ns(dir_sd, *attr,
  60                                                        SYSFS_KOBJ_ATTR,
  61                                                        (*attr)->mode | mode,
  62                                                        NULL);
  63                         if (unlikely(error))
  64                                 break;
  65                 }
  66                 if (error) {
  67                         remove_files(dir_sd, kobj, grp);
  68                         goto exit;
  69                 }
  70         }
  71
  72         if (grp->bin_attrs) {
  73                 for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) {
  74                         if (update)
  75                                 sysfs_remove_bin_file(kobj, *bin_attr);
  76                         error = sysfs_create_bin_file(kobj, *bin_attr);
  77                         if (error)
  78                                 break;
  79                 }
  80                 if (error)
  81                         remove_files(dir_sd, kobj, grp);
  82         }
  83 exit:
  84         return error;
  85 }
  86
  87
  88 static int internal_create_group(struct kobject *kobj, int update,
  89                                  const struct attribute_group *grp)
  90 {
  91         struct sysfs_dirent *sd;
  92         int error;
  93
  94         BUG_ON(!kobj || (!update && !kobj->sd));
  95
  96         /* Updates may happen before the object has been instantiated */
  97         if (unlikely(update && !kobj->sd))
  98                 return -EINVAL;
  99         if (!grp->attrs && !grp->bin_attrs) {
 100                 WARN(1, "sysfs: (bin_)attrs not set by subsystem for group: %s/%s\n",
 101                         kobj->name, grp->name ? "" : grp->name);
 102                 return -EINVAL;
 103         }
 104         if (grp->name) {
 105                 error = sysfs_create_subdir(kobj, grp->name, &sd);
 106                 if (error)
 107                         return error;
 108         } else
 109                 sd = kobj->sd;
 110         sysfs_get(sd);
 111         error = create_files(sd, kobj, grp, update);
 112         if (error) {
 113                 if (grp->name)
 114                         sysfs_remove(sd);
 115         }
 116         sysfs_put(sd);
 117         return error;
 118 }
 119
 120 /**
 121  * sysfs_create_group - given a directory kobject, create an attribute group
 122  * @kobj:       The kobject to create the group on
 123  * @grp:        The attribute group to create
 124  *
 125  * This function creates a group for the first time.  It will explicitly
 126  * warn and error if any of the attribute files being created already exist.
 127  *
 128  * Returns 0 on success or error.
 129  */
 130 int sysfs_create_group(struct kobject *kobj,
 131                        const struct attribute_group *grp)
 132 {
 133         return internal_create_group(kobj, 0, grp);
 134 }
 135 EXPORT_SYMBOL_GPL(sysfs_create_group);
 136
 137 /**
 138  * sysfs_create_groups - given a directory kobject, create a bunch of attribute groups
 139  * @kobj:       The kobject to create the group on
 140  * @groups:     The attribute groups to create, NULL terminated
 141  *
 142  * This function creates a bunch of attribute groups.  If an error occurs when
 143  * creating a group, all previously created groups will be removed, unwinding
 144  * everything back to the original state when this function was called.
 145  * It will explicitly warn and error if any of the attribute files being
 146  * created already exist.
 147  *
 148  * Returns 0 on success or error code from sysfs_create_group on error.
 149  */
 150 int sysfs_create_groups(struct kobject *kobj,
 151                         const struct attribute_group **groups)
 152 {
 153         int error = 0;
 154         int i;
 155
 156         if (!groups)
 157                 return 0;
 158
 159         for (i = 0; groups[i]; i++) {
 160                 error = sysfs_create_group(kobj, groups[i]);
 161                 if (error) {
 162                         while (--i >= 0)
 163                                 sysfs_remove_group(kobj, groups[i]);
 164                         break;
 165                 }
 166         }
 167         return error;
 168 }
 169 EXPORT_SYMBOL_GPL(sysfs_create_groups);
 170
 171 /**
 172  * sysfs_update_group - given a directory kobject, update an attribute group
 173  * @kobj:       The kobject to update the group on
 174  * @grp:        The attribute group to update
 175  *
 176  * This function updates an attribute group.  Unlike
 177  * sysfs_create_group(), it will explicitly not warn or error if any
 178  * of the attribute files being created already exist.  Furthermore,
 179  * if the visibility of the files has changed through the is_visible()
 180  * callback, it will update the permissions and add or remove the
 181  * relevant files.
 182  *
 183  * The primary use for this function is to call it after making a change
 184  * that affects group visibility.
 185  *
 186  * Returns 0 on success or error.
 187  */
 188 int sysfs_update_group(struct kobject *kobj,
 189                        const struct attribute_group *grp)
 190 {
 191         return internal_create_group(kobj, 1, grp);
 192 }
 193 EXPORT_SYMBOL_GPL(sysfs_update_group);
 194
 195 /**
 196  * sysfs_remove_group: remove a group from a kobject
 197  * @kobj:       kobject to remove the group from
 198  * @grp:        group to remove
 199  *
 200  * This function removes a group of attributes from a kobject.  The attributes
 201  * previously have to have been created for this group, otherwise it will fail.
 202  */
 203 void sysfs_remove_group(struct kobject *kobj,
 204                         const struct attribute_group *grp)
 205 {
 206         struct sysfs_dirent *dir_sd = kobj->sd;
 207         struct sysfs_dirent *sd;
 208
 209         if (grp->name) {
 210                 sd = sysfs_get_dirent(dir_sd, grp->name);
 211                 if (!sd) {
 212                         WARN(!sd, KERN_WARNING
 213                              "sysfs group %p not found for kobject '%s'\n",
 214                              grp, kobject_name(kobj));
 215                         return;
 216                 }
 217         } else
 218                 sd = sysfs_get(dir_sd);
 219
 220         remove_files(sd, kobj, grp);
 221         if (grp->name)
 222                 sysfs_remove(sd);
 223
 224         sysfs_put(sd);
 225 }
 226 EXPORT_SYMBOL_GPL(sysfs_remove_group);
 227
 228 /**
 229  * sysfs_remove_groups - remove a list of groups
 230  *
 231  * @kobj:       The kobject for the groups to be removed from
 232  * @groups:     NULL terminated list of groups to be removed
 233  *
 234  * If groups is not NULL, remove the specified groups from the kobject.
 235  */
 236 void sysfs_remove_groups(struct kobject *kobj,
 237                          const struct attribute_group **groups)
 238 {
 239         int i;
 240
 241         if (!groups)
 242                 return;
 243         for (i = 0; groups[i]; i++)
 244                 sysfs_remove_group(kobj, groups[i]);
 245 }
 246 EXPORT_SYMBOL_GPL(sysfs_remove_groups);
 247
 248 /**
 249  * sysfs_merge_group - merge files into a pre-existing attribute group.
 250  * @kobj:       The kobject containing the group.
 251  * @grp:        The files to create and the attribute group they belong to.
 252  *
 253  * This function returns an error if the group doesn't exist or any of the
 254  * files already exist in that group, in which case none of the new files
 255  * are created.
 256  */
 257 int sysfs_merge_group(struct kobject *kobj,
 258                        const struct attribute_group *grp)
 259 {
 260         struct sysfs_dirent *dir_sd;
 261         int error = 0;
 262         struct attribute *const *attr;
 263         int i;
 264
 265         dir_sd = sysfs_get_dirent(kobj->sd, grp->name);
 266         if (!dir_sd)
 267                 return -ENOENT;
 268
 269         for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
 270                 error = sysfs_add_file(dir_sd, *attr, SYSFS_KOBJ_ATTR);
 271         if (error) {
 272                 while (--i >= 0)
 273                         sysfs_hash_and_remove(dir_sd, (*--attr)->name, NULL);
 274         }
 275         sysfs_put(dir_sd);
 276
 277         return error;
 278 }
 279 EXPORT_SYMBOL_GPL(sysfs_merge_group);
 280
 281 /**
 282  * sysfs_unmerge_group - remove files from a pre-existing attribute group.
 283  * @kobj:       The kobject containing the group.
 284  * @grp:        The files to remove and the attribute group they belong to.
 285  */
 286 void sysfs_unmerge_group(struct kobject *kobj,
 287                        const struct attribute_group *grp)
 288 {
 289         struct sysfs_dirent *dir_sd;
 290         struct attribute *const *attr;
 291
 292         dir_sd = sysfs_get_dirent(kobj->sd, grp->name);
 293         if (dir_sd) {
 294                 for (attr = grp->attrs; *attr; ++attr)
 295                         sysfs_hash_and_remove(dir_sd, (*attr)->name, NULL);
 296                 sysfs_put(dir_sd);
 297         }
 298 }
 299 EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
 300
 301 /**
 302  * sysfs_add_link_to_group - add a symlink to an attribute group.
 303  * @kobj:       The kobject containing the group.
 304  * @group_name: The name of the group.
 305  * @target:     The target kobject of the symlink to create.
 306  * @link_name:  The name of the symlink to create.
 307  */
 308 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
 309                             struct kobject *target, const char *link_name)
 310 {
 311         struct sysfs_dirent *dir_sd;
 312         int error = 0;
 313
 314         dir_sd = sysfs_get_dirent(kobj->sd, group_name);
 315         if (!dir_sd)
 316                 return -ENOENT;
 317
 318         error = sysfs_create_link_sd(dir_sd, target, link_name);
 319         sysfs_put(dir_sd);
 320
 321         return error;
 322 }
 323 EXPORT_SYMBOL_GPL(sysfs_add_link_to_group);
 324
 325 /**
 326  * sysfs_remove_link_from_group - remove a symlink from an attribute group.
 327  * @kobj:       The kobject containing the group.
 328  * @group_name: The name of the group.
 329  * @link_name:  The name of the symlink to remove.
 330  */
 331 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
 332                                   const char *link_name)
 333 {
 334         struct sysfs_dirent *dir_sd;
 335
 336         dir_sd = sysfs_get_dirent(kobj->sd, group_name);
 337         if (dir_sd) {
 338                 sysfs_hash_and_remove(dir_sd, link_name, NULL);
 339                 sysfs_put(dir_sd);
 340         }
 341 }
 342 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group);