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