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