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 '%s' not found for kobject '%s'\n", 237 grp->name, 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); 412