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  *
   7  * This file is released undert the GPL v2.
   8  *
   9  */
  10
  11 #include <linux/kobject.h>
  12 #include <linux/module.h>
  13 #include <linux/dcache.h>
  14 #include <linux/namei.h>
  15 #include <linux/err.h>
  16 #include "sysfs.h"
  17
  18
  19 static void remove_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
  20                          const struct attribute_group *grp)
  21 {
  22         struct attribute *const* attr;
  23         int i;
  24
  25         for (i = 0, attr = grp->attrs; *attr; i++, attr++)
  26                 sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name);
  27 }
  28
  29 static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
  30                         const struct attribute_group *grp, int update)
  31 {
  32         struct attribute *const* attr;
  33         int error = 0, i;
  34
  35         for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
  36                 umode_t mode = 0;
  37
  38                 /* in update mode, we're changing the permissions or
  39                  * visibility.  Do this by first removing then
  40                  * re-adding (if required) the file */
  41                 if (update)
  42                         sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name);
  43                 if (grp->is_visible) {
  44                         mode = grp->is_visible(kobj, *attr, i);
  45                         if (!mode)
  46                                 continue;
  47                 }
  48                 error = sysfs_add_file_mode(dir_sd, *attr, SYSFS_KOBJ_ATTR,
  49                                             (*attr)->mode | mode);
  50                 if (unlikely(error))
  51                         break;
  52         }
  53         if (error)
  54                 remove_files(dir_sd, kobj, grp);
  55         return error;
  56 }
  57
  58
  59 static int internal_create_group(struct kobject *kobj, int update,
  60                                  const struct attribute_group *grp)
  61 {
  62         struct sysfs_dirent *sd;
  63         int error;
  64
  65         BUG_ON(!kobj || (!update && !kobj->sd));
  66
  67         /* Updates may happen before the object has been instantiated */
  68         if (unlikely(update && !kobj->sd))
  69                 return -EINVAL;
  70         if (!grp->attrs) {
  71                 WARN(1, "sysfs: attrs not set by subsystem for group: %s/%s\n",
  72                         kobj->name, grp->name ? "" : grp->name);
  73                 return -EINVAL;
  74         }
  75         if (grp->name) {
  76                 error = sysfs_create_subdir(kobj, grp->name, &sd);
  77                 if (error)
  78                         return error;
  79         } else
  80                 sd = kobj->sd;
  81         sysfs_get(sd);
  82         error = create_files(sd, kobj, grp, update);
  83         if (error) {
  84                 if (grp->name)
  85                         sysfs_remove_subdir(sd);
  86         }
  87         sysfs_put(sd);
  88         return error;
  89 }
  90
  91 /**
  92  * sysfs_create_group - given a directory kobject, create an attribute group
  93  * @kobj:       The kobject to create the group on
  94  * @grp:        The attribute group to create
  95  *
  96  * This function creates a group for the first time.  It will explicitly
  97  * warn and error if any of the attribute files being created already exist.
  98  *
  99  * Returns 0 on success or error.
 100  */
 101 int sysfs_create_group(struct kobject *kobj,
 102                        const struct attribute_group *grp)
 103 {
 104         return internal_create_group(kobj, 0, grp);
 105 }
 106
 107 /**
 108  * sysfs_update_group - given a directory kobject, update an attribute group
 109  * @kobj:       The kobject to update the group on
 110  * @grp:        The attribute group to update
 111  *
 112  * This function updates an attribute group.  Unlike
 113  * sysfs_create_group(), it will explicitly not warn or error if any
 114  * of the attribute files being created already exist.  Furthermore,
 115  * if the visibility of the files has changed through the is_visible()
 116  * callback, it will update the permissions and add or remove the
 117  * relevant files.
 118  *
 119  * The primary use for this function is to call it after making a change
 120  * that affects group visibility.
 121  *
 122  * Returns 0 on success or error.
 123  */
 124 int sysfs_update_group(struct kobject *kobj,
 125                        const struct attribute_group *grp)
 126 {
 127         return internal_create_group(kobj, 1, grp);
 128 }
 129
 130
 131
 132 void sysfs_remove_group(struct kobject * kobj,
 133                         const struct attribute_group * grp)
 134 {
 135         struct sysfs_dirent *dir_sd = kobj->sd;
 136         struct sysfs_dirent *sd;
 137
 138         if (grp->name) {
 139                 sd = sysfs_get_dirent(dir_sd, NULL, grp->name);
 140                 if (!sd) {
 141                         WARN(!sd, KERN_WARNING "sysfs group %p not found for "
 142                                 "kobject '%s'\n", grp, kobject_name(kobj));
 143                         return;
 144                 }
 145         } else
 146                 sd = sysfs_get(dir_sd);
 147
 148         remove_files(sd, kobj, grp);
 149         if (grp->name)
 150                 sysfs_remove_subdir(sd);
 151
 152         sysfs_put(sd);
 153 }
 154
 155 /**
 156  * sysfs_merge_group - merge files into a pre-existing attribute group.
 157  * @kobj:       The kobject containing the group.
 158  * @grp:        The files to create and the attribute group they belong to.
 159  *
 160  * This function returns an error if the group doesn't exist or any of the
 161  * files already exist in that group, in which case none of the new files
 162  * are created.
 163  */
 164 int sysfs_merge_group(struct kobject *kobj,
 165                        const struct attribute_group *grp)
 166 {
 167         struct sysfs_dirent *dir_sd;
 168         int error = 0;
 169         struct attribute *const *attr;
 170         int i;
 171
 172         dir_sd = sysfs_get_dirent(kobj->sd, NULL, grp->name);
 173         if (!dir_sd)
 174                 return -ENOENT;
 175
 176         for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
 177                 error = sysfs_add_file(dir_sd, *attr, SYSFS_KOBJ_ATTR);
 178         if (error) {
 179                 while (--i >= 0)
 180                         sysfs_hash_and_remove(dir_sd, NULL, (*--attr)->name);
 181         }
 182         sysfs_put(dir_sd);
 183
 184         return error;
 185 }
 186 EXPORT_SYMBOL_GPL(sysfs_merge_group);
 187
 188 /**
 189  * sysfs_unmerge_group - remove files from a pre-existing attribute group.
 190  * @kobj:       The kobject containing the group.
 191  * @grp:        The files to remove and the attribute group they belong to.
 192  */
 193 void sysfs_unmerge_group(struct kobject *kobj,
 194                        const struct attribute_group *grp)
 195 {
 196         struct sysfs_dirent *dir_sd;
 197         struct attribute *const *attr;
 198
 199         dir_sd = sysfs_get_dirent(kobj->sd, NULL, grp->name);
 200         if (dir_sd) {
 201                 for (attr = grp->attrs; *attr; ++attr)
 202                         sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name);
 203                 sysfs_put(dir_sd);
 204         }
 205 }
 206 EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
 207
 208 /**
 209  * sysfs_add_link_to_group - add a symlink to an attribute group.
 210  * @kobj:       The kobject containing the group.
 211  * @group_name: The name of the group.
 212  * @target:     The target kobject of the symlink to create.
 213  * @link_name:  The name of the symlink to create.
 214  */
 215 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
 216                             struct kobject *target, const char *link_name)
 217 {
 218         struct sysfs_dirent *dir_sd;
 219         int error = 0;
 220
 221         dir_sd = sysfs_get_dirent(kobj->sd, NULL, group_name);
 222         if (!dir_sd)
 223                 return -ENOENT;
 224
 225         error = sysfs_create_link_sd(dir_sd, target, link_name);
 226         sysfs_put(dir_sd);
 227
 228         return error;
 229 }
 230 EXPORT_SYMBOL_GPL(sysfs_add_link_to_group);
 231
 232 /**
 233  * sysfs_remove_link_from_group - remove a symlink from an attribute group.
 234  * @kobj:       The kobject containing the group.
 235  * @group_name: The name of the group.
 236  * @link_name:  The name of the symlink to remove.
 237  */
 238 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
 239                                   const char *link_name)
 240 {
 241         struct sysfs_dirent *dir_sd;
 242
 243         dir_sd = sysfs_get_dirent(kobj->sd, NULL, group_name);
 244         if (dir_sd) {
 245                 sysfs_hash_and_remove(dir_sd, NULL, link_name);
 246                 sysfs_put(dir_sd);
 247         }
 248 }
 249 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group);
 250
 251 EXPORT_SYMBOL_GPL(sysfs_create_group);
 252 EXPORT_SYMBOL_GPL(sysfs_update_group);
 253 EXPORT_SYMBOL_GPL(sysfs_remove_group);