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