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