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