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, 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(parent, (*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 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, 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(parent, 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 kernfs_node *kn; 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 kn = kernfs_create_dir(kobj->sd, grp->name, 104 S_IRWXU | S_IRUGO | S_IXUGO, kobj); 105 if (IS_ERR(kn)) { 106 if (PTR_ERR(kn) == -EEXIST) 107 sysfs_warn_dup(kobj->sd, grp->name); 108 return PTR_ERR(kn); 109 } 110 } else 111 kn = kobj->sd; 112 kernfs_get(kn); 113 error = create_files(kn, kobj, grp, update); 114 if (error) { 115 if (grp->name) 116 kernfs_remove(kn); 117 } 118 kernfs_put(kn); 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 kernfs_node *parent = kobj->sd; 209 struct kernfs_node *kn; 210 211 if (grp->name) { 212 kn = kernfs_find_and_get(parent, grp->name); 213 if (!kn) { 214 WARN(!kn, KERN_WARNING 215 "sysfs group %p not found for kobject '%s'\n", 216 grp, kobject_name(kobj)); 217 return; 218 } 219 } else { 220 kn = parent; 221 kernfs_get(kn); 222 } 223 224 remove_files(kn, kobj, grp); 225 if (grp->name) 226 kernfs_remove(kn); 227 228 kernfs_put(kn); 229 } 230 EXPORT_SYMBOL_GPL(sysfs_remove_group); 231 232 /** 233 * sysfs_remove_groups - remove a list of groups 234 * 235 * @kobj: The kobject for the groups to be removed from 236 * @groups: NULL terminated list of groups to be removed 237 * 238 * If groups is not NULL, remove the specified groups from the kobject. 239 */ 240 void sysfs_remove_groups(struct kobject *kobj, 241 const struct attribute_group **groups) 242 { 243 int i; 244 245 if (!groups) 246 return; 247 for (i = 0; groups[i]; i++) 248 sysfs_remove_group(kobj, groups[i]); 249 } 250 EXPORT_SYMBOL_GPL(sysfs_remove_groups); 251 252 /** 253 * sysfs_merge_group - merge files into a pre-existing attribute group. 254 * @kobj: The kobject containing the group. 255 * @grp: The files to create and the attribute group they belong to. 256 * 257 * This function returns an error if the group doesn't exist or any of the 258 * files already exist in that group, in which case none of the new files 259 * are created. 260 */ 261 int sysfs_merge_group(struct kobject *kobj, 262 const struct attribute_group *grp) 263 { 264 struct kernfs_node *parent; 265 int error = 0; 266 struct attribute *const *attr; 267 int i; 268 269 parent = kernfs_find_and_get(kobj->sd, grp->name); 270 if (!parent) 271 return -ENOENT; 272 273 for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr)) 274 error = sysfs_add_file(parent, *attr, false); 275 if (error) { 276 while (--i >= 0) 277 kernfs_remove_by_name(parent, (*--attr)->name); 278 } 279 kernfs_put(parent); 280 281 return error; 282 } 283 EXPORT_SYMBOL_GPL(sysfs_merge_group); 284 285 /** 286 * sysfs_unmerge_group - remove files from a pre-existing attribute group. 287 * @kobj: The kobject containing the group. 288 * @grp: The files to remove and the attribute group they belong to. 289 */ 290 void sysfs_unmerge_group(struct kobject *kobj, 291 const struct attribute_group *grp) 292 { 293 struct kernfs_node *parent; 294 struct attribute *const *attr; 295 296 parent = kernfs_find_and_get(kobj->sd, grp->name); 297 if (parent) { 298 for (attr = grp->attrs; *attr; ++attr) 299 kernfs_remove_by_name(parent, (*attr)->name); 300 kernfs_put(parent); 301 } 302 } 303 EXPORT_SYMBOL_GPL(sysfs_unmerge_group); 304 305 /** 306 * sysfs_add_link_to_group - add a symlink to an attribute group. 307 * @kobj: The kobject containing the group. 308 * @group_name: The name of the group. 309 * @target: The target kobject of the symlink to create. 310 * @link_name: The name of the symlink to create. 311 */ 312 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name, 313 struct kobject *target, const char *link_name) 314 { 315 struct kernfs_node *parent; 316 int error = 0; 317 318 parent = kernfs_find_and_get(kobj->sd, group_name); 319 if (!parent) 320 return -ENOENT; 321 322 error = sysfs_create_link_sd(parent, target, link_name); 323 kernfs_put(parent); 324 325 return error; 326 } 327 EXPORT_SYMBOL_GPL(sysfs_add_link_to_group); 328 329 /** 330 * sysfs_remove_link_from_group - remove a symlink from an attribute group. 331 * @kobj: The kobject containing the group. 332 * @group_name: The name of the group. 333 * @link_name: The name of the symlink to remove. 334 */ 335 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name, 336 const char *link_name) 337 { 338 struct kernfs_node *parent; 339 340 parent = kernfs_find_and_get(kobj->sd, group_name); 341 if (parent) { 342 kernfs_remove_by_name(parent, link_name); 343 kernfs_put(parent); 344 } 345 } 346 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group); 347