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