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 * 7 * This file is released undert the GPL v2. 8 * 9 */ 10 11 #include <linux/kobject.h> 12 #include <linux/module.h> 13 #include <linux/dcache.h> 14 #include <linux/namei.h> 15 #include <linux/err.h> 16 #include "sysfs.h" 17 18 19 static void remove_files(struct sysfs_dirent *dir_sd, struct kobject *kobj, 20 const struct attribute_group *grp) 21 { 22 struct attribute *const* attr; 23 int i; 24 25 for (i = 0, attr = grp->attrs; *attr; i++, attr++) 26 sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name); 27 } 28 29 static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj, 30 const struct attribute_group *grp, int update) 31 { 32 struct attribute *const* attr; 33 int error = 0, i; 34 35 for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) { 36 umode_t mode = 0; 37 38 /* in update mode, we're changing the permissions or 39 * visibility. Do this by first removing then 40 * re-adding (if required) the file */ 41 if (update) 42 sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name); 43 if (grp->is_visible) { 44 mode = grp->is_visible(kobj, *attr, i); 45 if (!mode) 46 continue; 47 } 48 error = sysfs_add_file_mode(dir_sd, *attr, SYSFS_KOBJ_ATTR, 49 (*attr)->mode | mode); 50 if (unlikely(error)) 51 break; 52 } 53 if (error) 54 remove_files(dir_sd, kobj, grp); 55 return error; 56 } 57 58 59 static int internal_create_group(struct kobject *kobj, int update, 60 const struct attribute_group *grp) 61 { 62 struct sysfs_dirent *sd; 63 int error; 64 65 BUG_ON(!kobj || (!update && !kobj->sd)); 66 67 /* Updates may happen before the object has been instantiated */ 68 if (unlikely(update && !kobj->sd)) 69 return -EINVAL; 70 if (!grp->attrs) { 71 WARN(1, "sysfs: attrs not set by subsystem for group: %s/%s\n", 72 kobj->name, grp->name ? "" : grp->name); 73 return -EINVAL; 74 } 75 if (grp->name) { 76 error = sysfs_create_subdir(kobj, grp->name, &sd); 77 if (error) 78 return error; 79 } else 80 sd = kobj->sd; 81 sysfs_get(sd); 82 error = create_files(sd, kobj, grp, update); 83 if (error) { 84 if (grp->name) 85 sysfs_remove_subdir(sd); 86 } 87 sysfs_put(sd); 88 return error; 89 } 90 91 /** 92 * sysfs_create_group - given a directory kobject, create an attribute group 93 * @kobj: The kobject to create the group on 94 * @grp: The attribute group to create 95 * 96 * This function creates a group for the first time. It will explicitly 97 * warn and error if any of the attribute files being created already exist. 98 * 99 * Returns 0 on success or error. 100 */ 101 int sysfs_create_group(struct kobject *kobj, 102 const struct attribute_group *grp) 103 { 104 return internal_create_group(kobj, 0, grp); 105 } 106 107 /** 108 * sysfs_update_group - given a directory kobject, update an attribute group 109 * @kobj: The kobject to update the group on 110 * @grp: The attribute group to update 111 * 112 * This function updates an attribute group. Unlike 113 * sysfs_create_group(), it will explicitly not warn or error if any 114 * of the attribute files being created already exist. Furthermore, 115 * if the visibility of the files has changed through the is_visible() 116 * callback, it will update the permissions and add or remove the 117 * relevant files. 118 * 119 * The primary use for this function is to call it after making a change 120 * that affects group visibility. 121 * 122 * Returns 0 on success or error. 123 */ 124 int sysfs_update_group(struct kobject *kobj, 125 const struct attribute_group *grp) 126 { 127 return internal_create_group(kobj, 1, grp); 128 } 129 130 131 132 void sysfs_remove_group(struct kobject * kobj, 133 const struct attribute_group * grp) 134 { 135 struct sysfs_dirent *dir_sd = kobj->sd; 136 struct sysfs_dirent *sd; 137 138 if (grp->name) { 139 sd = sysfs_get_dirent(dir_sd, NULL, grp->name); 140 if (!sd) { 141 WARN(!sd, KERN_WARNING "sysfs group %p not found for " 142 "kobject '%s'\n", grp, kobject_name(kobj)); 143 return; 144 } 145 } else 146 sd = sysfs_get(dir_sd); 147 148 remove_files(sd, kobj, grp); 149 if (grp->name) 150 sysfs_remove_subdir(sd); 151 152 sysfs_put(sd); 153 } 154 155 /** 156 * sysfs_merge_group - merge files into a pre-existing attribute group. 157 * @kobj: The kobject containing the group. 158 * @grp: The files to create and the attribute group they belong to. 159 * 160 * This function returns an error if the group doesn't exist or any of the 161 * files already exist in that group, in which case none of the new files 162 * are created. 163 */ 164 int sysfs_merge_group(struct kobject *kobj, 165 const struct attribute_group *grp) 166 { 167 struct sysfs_dirent *dir_sd; 168 int error = 0; 169 struct attribute *const *attr; 170 int i; 171 172 dir_sd = sysfs_get_dirent(kobj->sd, NULL, grp->name); 173 if (!dir_sd) 174 return -ENOENT; 175 176 for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr)) 177 error = sysfs_add_file(dir_sd, *attr, SYSFS_KOBJ_ATTR); 178 if (error) { 179 while (--i >= 0) 180 sysfs_hash_and_remove(dir_sd, NULL, (*--attr)->name); 181 } 182 sysfs_put(dir_sd); 183 184 return error; 185 } 186 EXPORT_SYMBOL_GPL(sysfs_merge_group); 187 188 /** 189 * sysfs_unmerge_group - remove files from a pre-existing attribute group. 190 * @kobj: The kobject containing the group. 191 * @grp: The files to remove and the attribute group they belong to. 192 */ 193 void sysfs_unmerge_group(struct kobject *kobj, 194 const struct attribute_group *grp) 195 { 196 struct sysfs_dirent *dir_sd; 197 struct attribute *const *attr; 198 199 dir_sd = sysfs_get_dirent(kobj->sd, NULL, grp->name); 200 if (dir_sd) { 201 for (attr = grp->attrs; *attr; ++attr) 202 sysfs_hash_and_remove(dir_sd, NULL, (*attr)->name); 203 sysfs_put(dir_sd); 204 } 205 } 206 EXPORT_SYMBOL_GPL(sysfs_unmerge_group); 207 208 /** 209 * sysfs_add_link_to_group - add a symlink to an attribute group. 210 * @kobj: The kobject containing the group. 211 * @group_name: The name of the group. 212 * @target: The target kobject of the symlink to create. 213 * @link_name: The name of the symlink to create. 214 */ 215 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name, 216 struct kobject *target, const char *link_name) 217 { 218 struct sysfs_dirent *dir_sd; 219 int error = 0; 220 221 dir_sd = sysfs_get_dirent(kobj->sd, NULL, group_name); 222 if (!dir_sd) 223 return -ENOENT; 224 225 error = sysfs_create_link_sd(dir_sd, target, link_name); 226 sysfs_put(dir_sd); 227 228 return error; 229 } 230 EXPORT_SYMBOL_GPL(sysfs_add_link_to_group); 231 232 /** 233 * sysfs_remove_link_from_group - remove a symlink from an attribute group. 234 * @kobj: The kobject containing the group. 235 * @group_name: The name of the group. 236 * @link_name: The name of the symlink to remove. 237 */ 238 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name, 239 const char *link_name) 240 { 241 struct sysfs_dirent *dir_sd; 242 243 dir_sd = sysfs_get_dirent(kobj->sd, NULL, group_name); 244 if (dir_sd) { 245 sysfs_hash_and_remove(dir_sd, NULL, link_name); 246 sysfs_put(dir_sd); 247 } 248 } 249 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group); 250 251 EXPORT_SYMBOL_GPL(sysfs_create_group); 252 EXPORT_SYMBOL_GPL(sysfs_update_group); 253 EXPORT_SYMBOL_GPL(sysfs_remove_group); 254