group.c 10.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * fs/sysfs/group.c - Operations for adding/removing multiple files at once.
 *
 * Copyright (c) 2003 Patrick Mochel
 * Copyright (c) 2003 Open Source Development Lab
6 7
 * Copyright (c) 2013 Greg Kroah-Hartman
 * Copyright (c) 2013 The Linux Foundation
L
Linus Torvalds 已提交
8
 *
9
 * This file is released undert the GPL v2.
L
Linus Torvalds 已提交
10 11 12 13 14 15
 *
 */

#include <linux/kobject.h>
#include <linux/module.h>
#include <linux/dcache.h>
16
#include <linux/namei.h>
L
Linus Torvalds 已提交
17 18 19 20
#include <linux/err.h>
#include "sysfs.h"


21
static void remove_files(struct kernfs_node *parent,
22
			 const struct attribute_group *grp)
L
Linus Torvalds 已提交
23
{
24 25
	struct attribute *const *attr;
	struct bin_attribute *const *bin_attr;
L
Linus Torvalds 已提交
26

27 28
	if (grp->attrs)
		for (attr = grp->attrs; *attr; attr++)
29
			kernfs_remove_by_name(parent, (*attr)->name);
30 31
	if (grp->bin_attrs)
		for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++)
32
			kernfs_remove_by_name(parent, (*bin_attr)->attr.name);
L
Linus Torvalds 已提交
33 34
}

35
static int create_files(struct kernfs_node *parent, struct kobject *kobj,
36
			const struct attribute_group *grp, int update)
L
Linus Torvalds 已提交
37
{
38 39
	struct attribute *const *attr;
	struct bin_attribute *const *bin_attr;
40
	int error = 0, i;
L
Linus Torvalds 已提交
41

42 43
	if (grp->attrs) {
		for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) {
44
			umode_t mode = (*attr)->mode;
45

46 47 48 49 50 51
			/*
			 * In update mode, we're changing the permissions or
			 * visibility.  Do this by first removing then
			 * re-adding (if required) the file.
			 */
			if (update)
52
				kernfs_remove_by_name(parent, (*attr)->name);
53 54 55 56 57
			if (grp->is_visible) {
				mode = grp->is_visible(kobj, *attr, i);
				if (!mode)
					continue;
			}
58 59 60 61 62 63

			WARN(mode & ~(SYSFS_PREALLOC | 0664),
			     "Attribute %s: Invalid permissions 0%o\n",
			     (*attr)->name, mode);

			mode &= SYSFS_PREALLOC | 0664;
64
			error = sysfs_add_file_mode_ns(parent, *attr, false,
65
						       mode, NULL);
66 67 68 69
			if (unlikely(error))
				break;
		}
		if (error) {
70
			remove_files(parent, grp);
71 72 73 74 75
			goto exit;
		}
	}

	if (grp->bin_attrs) {
76 77 78
		for (i = 0, bin_attr = grp->bin_attrs; *bin_attr; i++, bin_attr++) {
			umode_t mode = (*bin_attr)->attr.mode;

79
			if (update)
80 81
				kernfs_remove_by_name(parent,
						(*bin_attr)->attr.name);
82 83 84 85 86 87 88 89 90 91 92
			if (grp->is_bin_visible) {
				mode = grp->is_bin_visible(kobj, *bin_attr, i);
				if (!mode)
					continue;
			}

			WARN(mode & ~(SYSFS_PREALLOC | 0664),
			     "Attribute %s: Invalid permissions 0%o\n",
			     (*bin_attr)->attr.name, mode);

			mode &= SYSFS_PREALLOC | 0664;
93 94
			error = sysfs_add_file_mode_ns(parent,
					&(*bin_attr)->attr, true,
95
					mode, NULL);
96 97
			if (error)
				break;
98
		}
99
		if (error)
100
			remove_files(parent, grp);
101
	}
102
exit:
L
Linus Torvalds 已提交
103 104 105 106
	return error;
}


107 108
static int internal_create_group(struct kobject *kobj, int update,
				 const struct attribute_group *grp)
L
Linus Torvalds 已提交
109
{
110
	struct kernfs_node *kn;
L
Linus Torvalds 已提交
111 112
	int error;

113 114 115 116 117
	BUG_ON(!kobj || (!update && !kobj->sd));

	/* Updates may happen before the object has been instantiated */
	if (unlikely(update && !kobj->sd))
		return -EINVAL;
118 119
	if (!grp->attrs && !grp->bin_attrs) {
		WARN(1, "sysfs: (bin_)attrs not set by subsystem for group: %s/%s\n",
120
			kobj->name, grp->name ?: "");
121 122
		return -EINVAL;
	}
L
Linus Torvalds 已提交
123
	if (grp->name) {
124 125
		kn = kernfs_create_dir(kobj->sd, grp->name,
				       S_IRWXU | S_IRUGO | S_IXUGO, kobj);
126 127
		if (IS_ERR(kn)) {
			if (PTR_ERR(kn) == -EEXIST)
128
				sysfs_warn_dup(kobj->sd, grp->name);
129
			return PTR_ERR(kn);
130
		}
L
Linus Torvalds 已提交
131
	} else
132 133 134
		kn = kobj->sd;
	kernfs_get(kn);
	error = create_files(kn, kobj, grp, update);
135
	if (error) {
L
Linus Torvalds 已提交
136
		if (grp->name)
137
			kernfs_remove(kn);
L
Linus Torvalds 已提交
138
	}
139
	kernfs_put(kn);
L
Linus Torvalds 已提交
140 141 142
	return error;
}

143 144 145 146 147 148 149 150
/**
 * sysfs_create_group - given a directory kobject, create an attribute group
 * @kobj:	The kobject to create the group on
 * @grp:	The attribute group to create
 *
 * This function creates a group for the first time.  It will explicitly
 * warn and error if any of the attribute files being created already exist.
 *
151
 * Returns 0 on success or error code on failure.
152 153 154 155 156 157
 */
int sysfs_create_group(struct kobject *kobj,
		       const struct attribute_group *grp)
{
	return internal_create_group(kobj, 0, grp);
}
158
EXPORT_SYMBOL_GPL(sysfs_create_group);
159

160 161 162 163 164 165 166 167 168 169 170
/**
 * sysfs_create_groups - given a directory kobject, create a bunch of attribute groups
 * @kobj:	The kobject to create the group on
 * @groups:	The attribute groups to create, NULL terminated
 *
 * This function creates a bunch of attribute groups.  If an error occurs when
 * creating a group, all previously created groups will be removed, unwinding
 * everything back to the original state when this function was called.
 * It will explicitly warn and error if any of the attribute files being
 * created already exist.
 *
171
 * Returns 0 on success or error code from sysfs_create_group on failure.
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
 */
int sysfs_create_groups(struct kobject *kobj,
			const struct attribute_group **groups)
{
	int error = 0;
	int i;

	if (!groups)
		return 0;

	for (i = 0; groups[i]; i++) {
		error = sysfs_create_group(kobj, groups[i]);
		if (error) {
			while (--i >= 0)
				sysfs_remove_group(kobj, groups[i]);
			break;
		}
	}
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_create_groups);

194
/**
195 196 197
 * sysfs_update_group - given a directory kobject, update an attribute group
 * @kobj:	The kobject to update the group on
 * @grp:	The attribute group to update
198 199 200 201 202 203 204 205 206 207 208
 *
 * This function updates an attribute group.  Unlike
 * sysfs_create_group(), it will explicitly not warn or error if any
 * of the attribute files being created already exist.  Furthermore,
 * if the visibility of the files has changed through the is_visible()
 * callback, it will update the permissions and add or remove the
 * relevant files.
 *
 * The primary use for this function is to call it after making a change
 * that affects group visibility.
 *
209
 * Returns 0 on success or error code on failure.
210 211 212 213 214 215
 */
int sysfs_update_group(struct kobject *kobj,
		       const struct attribute_group *grp)
{
	return internal_create_group(kobj, 1, grp);
}
216
EXPORT_SYMBOL_GPL(sysfs_update_group);
217

218 219 220 221 222 223 224 225
/**
 * sysfs_remove_group: remove a group from a kobject
 * @kobj:	kobject to remove the group from
 * @grp:	group to remove
 *
 * This function removes a group of attributes from a kobject.  The attributes
 * previously have to have been created for this group, otherwise it will fail.
 */
226 227
void sysfs_remove_group(struct kobject *kobj,
			const struct attribute_group *grp)
L
Linus Torvalds 已提交
228
{
229 230
	struct kernfs_node *parent = kobj->sd;
	struct kernfs_node *kn;
L
Linus Torvalds 已提交
231

232
	if (grp->name) {
233 234 235
		kn = kernfs_find_and_get(parent, grp->name);
		if (!kn) {
			WARN(!kn, KERN_WARNING
236 237
			     "sysfs group %p not found for kobject '%s'\n",
			     grp, kobject_name(kobj));
238 239
			return;
		}
240
	} else {
241 242
		kn = parent;
		kernfs_get(kn);
243
	}
L
Linus Torvalds 已提交
244

245
	remove_files(kn, grp);
L
Linus Torvalds 已提交
246
	if (grp->name)
247
		kernfs_remove(kn);
248

249
	kernfs_put(kn);
L
Linus Torvalds 已提交
250
}
251
EXPORT_SYMBOL_GPL(sysfs_remove_group);
L
Linus Torvalds 已提交
252

253 254 255
/**
 * sysfs_remove_groups - remove a list of groups
 *
256 257
 * @kobj:	The kobject for the groups to be removed from
 * @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 262 263 264 265 266 267 268 269 270 271 272
 */
void sysfs_remove_groups(struct kobject *kobj,
			 const struct attribute_group **groups)
{
	int i;

	if (!groups)
		return;
	for (i = 0; groups[i]; i++)
		sysfs_remove_group(kobj, groups[i]);
}
EXPORT_SYMBOL_GPL(sysfs_remove_groups);

273 274 275 276 277 278 279 280 281 282 283 284
/**
 * sysfs_merge_group - merge files into a pre-existing attribute group.
 * @kobj:	The kobject containing the group.
 * @grp:	The files to create and the attribute group they belong to.
 *
 * This function returns an error if the group doesn't exist or any of the
 * files already exist in that group, in which case none of the new files
 * are created.
 */
int sysfs_merge_group(struct kobject *kobj,
		       const struct attribute_group *grp)
{
285
	struct kernfs_node *parent;
286 287 288 289
	int error = 0;
	struct attribute *const *attr;
	int i;

290 291
	parent = kernfs_find_and_get(kobj->sd, grp->name);
	if (!parent)
292 293 294
		return -ENOENT;

	for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
295
		error = sysfs_add_file(parent, *attr, false);
296 297
	if (error) {
		while (--i >= 0)
298
			kernfs_remove_by_name(parent, (*--attr)->name);
299
	}
300
	kernfs_put(parent);
301 302 303 304 305 306 307 308 309 310 311 312 313

	return error;
}
EXPORT_SYMBOL_GPL(sysfs_merge_group);

/**
 * sysfs_unmerge_group - remove files from a pre-existing attribute group.
 * @kobj:	The kobject containing the group.
 * @grp:	The files to remove and the attribute group they belong to.
 */
void sysfs_unmerge_group(struct kobject *kobj,
		       const struct attribute_group *grp)
{
314
	struct kernfs_node *parent;
315 316
	struct attribute *const *attr;

317 318
	parent = kernfs_find_and_get(kobj->sd, grp->name);
	if (parent) {
319
		for (attr = grp->attrs; *attr; ++attr)
320 321
			kernfs_remove_by_name(parent, (*attr)->name);
		kernfs_put(parent);
322 323 324 325
	}
}
EXPORT_SYMBOL_GPL(sysfs_unmerge_group);

326 327 328 329 330 331 332 333 334 335
/**
 * sysfs_add_link_to_group - add a symlink to an attribute group.
 * @kobj:	The kobject containing the group.
 * @group_name:	The name of the group.
 * @target:	The target kobject of the symlink to create.
 * @link_name:	The name of the symlink to create.
 */
int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
			    struct kobject *target, const char *link_name)
{
336
	struct kernfs_node *parent;
337 338
	int error = 0;

339 340
	parent = kernfs_find_and_get(kobj->sd, group_name);
	if (!parent)
341 342
		return -ENOENT;

343 344
	error = sysfs_create_link_sd(parent, target, link_name);
	kernfs_put(parent);
345 346 347 348 349 350 351 352 353 354 355 356 357 358

	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_link_to_group);

/**
 * sysfs_remove_link_from_group - remove a symlink from an attribute group.
 * @kobj:	The kobject containing the group.
 * @group_name:	The name of the group.
 * @link_name:	The name of the symlink to remove.
 */
void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
				  const char *link_name)
{
359
	struct kernfs_node *parent;
360

361 362 363 364
	parent = kernfs_find_and_get(kobj->sd, group_name);
	if (parent) {
		kernfs_remove_by_name(parent, link_name);
		kernfs_put(parent);
365 366 367
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group);
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411

/**
 * __compat_only_sysfs_link_entry_to_kobj - add a symlink to a kobject pointing
 * to a group or an attribute
 * @kobj:		The kobject containing the group.
 * @target_kobj:	The target kobject.
 * @target_name:	The name of the target group or attribute.
 */
int __compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj,
				      struct kobject *target_kobj,
				      const char *target_name)
{
	struct kernfs_node *target;
	struct kernfs_node *entry;
	struct kernfs_node *link;

	/*
	 * We don't own @target_kobj and it may be removed at any time.
	 * Synchronize using sysfs_symlink_target_lock. See sysfs_remove_dir()
	 * for details.
	 */
	spin_lock(&sysfs_symlink_target_lock);
	target = target_kobj->sd;
	if (target)
		kernfs_get(target);
	spin_unlock(&sysfs_symlink_target_lock);
	if (!target)
		return -ENOENT;

	entry = kernfs_find_and_get(target_kobj->sd, target_name);
	if (!entry) {
		kernfs_put(target);
		return -ENOENT;
	}

	link = kernfs_create_link(kobj->sd, target_name, entry);
	if (IS_ERR(link) && PTR_ERR(link) == -EEXIST)
		sysfs_warn_dup(kobj->sd, target_name);

	kernfs_put(entry);
	kernfs_put(target);
	return IS_ERR(link) ? PTR_ERR(link) : 0;
}
EXPORT_SYMBOL_GPL(__compat_only_sysfs_link_entry_to_kobj);