kobject.c 25.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
/*
 * kobject.c - library routines for handling generic kernel objects
 *
 * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org>
5 6
 * Copyright (c) 2006-2007 Greg Kroah-Hartman <greg@kroah.com>
 * Copyright (c) 2006-2007 Novell Inc.
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16
 *
 * This file is released under the GPLv2.
 *
 *
 * Please see the file Documentation/kobject.txt for critical information
 * about using the kobject interface.
 */

#include <linux/kobject.h>
#include <linux/string.h>
17
#include <linux/export.h>
L
Linus Torvalds 已提交
18
#include <linux/stat.h>
19
#include <linux/slab.h>
20
#include <linux/random.h>
L
Linus Torvalds 已提交
21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/**
 * kobject_namespace - return @kobj's namespace tag
 * @kobj: kobject in question
 *
 * Returns namespace tag of @kobj if its parent has namespace ops enabled
 * and thus @kobj should have a namespace tag associated with it.  Returns
 * %NULL otherwise.
 */
const void *kobject_namespace(struct kobject *kobj)
{
	const struct kobj_ns_type_operations *ns_ops = kobj_ns_ops(kobj);

	if (!ns_ops || ns_ops->type == KOBJ_NS_TYPE_NONE)
		return NULL;

37
	return kobj->ktype->namespace(kobj);
38 39
}

40 41 42
/*
 * populate_dir - populate directory with attributes.
 * @kobj: object we're working on.
L
Linus Torvalds 已提交
43
 *
44 45 46 47
 * Most subsystems have a set of default attributes that are associated
 * with an object that registers with them.  This is a helper called during
 * object registration that loops through the default attributes of the
 * subsystem and creates attributes files for them in sysfs.
L
Linus Torvalds 已提交
48
 */
49
static int populate_dir(struct kobject *kobj)
L
Linus Torvalds 已提交
50
{
51 52
	struct kobj_type *t = get_ktype(kobj);
	struct attribute *attr;
L
Linus Torvalds 已提交
53 54
	int error = 0;
	int i;
55

L
Linus Torvalds 已提交
56 57
	if (t && t->default_attrs) {
		for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
58 59
			error = sysfs_create_file(kobj, attr);
			if (error)
L
Linus Torvalds 已提交
60 61 62 63 64 65
				break;
		}
	}
	return error;
}

66
static int create_dir(struct kobject *kobj)
L
Linus Torvalds 已提交
67
{
68
	const struct kobj_ns_type_operations *ops;
69 70 71
	int error;

	error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj));
72 73 74 75 76 77 78
	if (error)
		return error;

	error = populate_dir(kobj);
	if (error) {
		sysfs_remove_dir(kobj);
		return error;
L
Linus Torvalds 已提交
79
	}
80 81 82 83 84 85 86

	/*
	 * @kobj->sd may be deleted by an ancestor going away.  Hold an
	 * extra reference so that it stays until @kobj is gone.
	 */
	sysfs_get(kobj->sd);

87 88 89 90 91 92 93 94 95 96
	/*
	 * If @kobj has ns_ops, its children need to be filtered based on
	 * their namespace tags.  Enable namespace support on @kobj->sd.
	 */
	ops = kobj_child_ns_ops(kobj);
	if (ops) {
		BUG_ON(ops->type <= KOBJ_NS_TYPE_NONE);
		BUG_ON(ops->type >= KOBJ_NS_TYPES);
		BUG_ON(!kobj_ns_type_registered(ops->type));

97
		sysfs_enable_ns(kobj->sd);
98 99 100
	}

	return 0;
L
Linus Torvalds 已提交
101 102 103 104 105
}

static int get_kobj_path_length(struct kobject *kobj)
{
	int length = 1;
106
	struct kobject *parent = kobj;
L
Linus Torvalds 已提交
107

108
	/* walk up the ancestors until we hit the one pointing to the
L
Linus Torvalds 已提交
109 110 111 112
	 * root.
	 * Add 1 to strlen for leading '/' of each level.
	 */
	do {
113 114
		if (kobject_name(parent) == NULL)
			return 0;
L
Linus Torvalds 已提交
115 116 117 118 119 120 121 122
		length += strlen(kobject_name(parent)) + 1;
		parent = parent->parent;
	} while (parent);
	return length;
}

static void fill_kobj_path(struct kobject *kobj, char *path, int length)
{
123
	struct kobject *parent;
L
Linus Torvalds 已提交
124 125 126 127 128 129

	--length;
	for (parent = kobj; parent; parent = parent->parent) {
		int cur = strlen(kobject_name(parent));
		/* back up enough to print this name with '/' */
		length -= cur;
130
		strncpy(path + length, kobject_name(parent), cur);
L
Linus Torvalds 已提交
131 132 133
		*(path + --length) = '/';
	}

134
	pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
135
		 kobj, __func__, path);
L
Linus Torvalds 已提交
136 137 138
}

/**
139
 * kobject_get_path - generate and return the path associated with a given kobj and kset pair.
L
Linus Torvalds 已提交
140 141 142
 *
 * @kobj:	kobject in question, with which to build the path
 * @gfp_mask:	the allocation type used to allocate the path
143 144
 *
 * The result must be freed by the caller with kfree().
L
Linus Torvalds 已提交
145
 */
A
Al Viro 已提交
146
char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
L
Linus Torvalds 已提交
147 148 149 150 151
{
	char *path;
	int len;

	len = get_kobj_path_length(kobj);
152 153
	if (len == 0)
		return NULL;
154
	path = kzalloc(len, gfp_mask);
L
Linus Torvalds 已提交
155 156 157 158 159 160
	if (!path)
		return NULL;
	fill_kobj_path(kobj, path, len);

	return path;
}
161
EXPORT_SYMBOL_GPL(kobject_get_path);
L
Linus Torvalds 已提交
162

163 164
/* add the kobject to its kset's list */
static void kobj_kset_join(struct kobject *kobj)
L
Linus Torvalds 已提交
165
{
166
	if (!kobj->kset)
167
		return;
168 169 170 171 172

	kset_get(kobj->kset);
	spin_lock(&kobj->kset->list_lock);
	list_add_tail(&kobj->entry, &kobj->kset->list);
	spin_unlock(&kobj->kset->list_lock);
L
Linus Torvalds 已提交
173 174
}

175 176 177 178 179
/* remove the kobject from its kset's list */
static void kobj_kset_leave(struct kobject *kobj)
{
	if (!kobj->kset)
		return;
L
Linus Torvalds 已提交
180

181 182 183 184 185
	spin_lock(&kobj->kset->list_lock);
	list_del_init(&kobj->entry);
	spin_unlock(&kobj->kset->list_lock);
	kset_put(kobj->kset);
}
L
Linus Torvalds 已提交
186

187
static void kobject_init_internal(struct kobject *kobj)
L
Linus Torvalds 已提交
188
{
189 190 191 192
	if (!kobj)
		return;
	kref_init(&kobj->kref);
	INIT_LIST_HEAD(&kobj->entry);
193 194 195 196
	kobj->state_in_sysfs = 0;
	kobj->state_add_uevent_sent = 0;
	kobj->state_remove_uevent_sent = 0;
	kobj->state_initialized = 1;
L
Linus Torvalds 已提交
197 198
}

199

200
static int kobject_add_internal(struct kobject *kobj)
L
Linus Torvalds 已提交
201 202
{
	int error = 0;
203
	struct kobject *parent;
L
Linus Torvalds 已提交
204

205
	if (!kobj)
L
Linus Torvalds 已提交
206
		return -ENOENT;
207

208
	if (!kobj->name || !kobj->name[0]) {
A
Arjan van de Ven 已提交
209
		WARN(1, "kobject: (%p): attempted to be registered with empty "
210
			 "name!\n", kobj);
211 212
		return -EINVAL;
	}
L
Linus Torvalds 已提交
213

214
	parent = kobject_get(kobj->parent);
L
Linus Torvalds 已提交
215

216
	/* join kset if set, use it as parent if we do not already have one */
L
Linus Torvalds 已提交
217
	if (kobj->kset) {
218
		if (!parent)
L
Linus Torvalds 已提交
219
			parent = kobject_get(&kobj->kset->kobj);
220
		kobj_kset_join(kobj);
221
		kobj->parent = parent;
L
Linus Torvalds 已提交
222 223
	}

224
	pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
225
		 kobject_name(kobj), kobj, __func__,
226
		 parent ? kobject_name(parent) : "<NULL>",
227
		 kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
228

229
	error = create_dir(kobj);
L
Linus Torvalds 已提交
230
	if (error) {
231 232 233
		kobj_kset_leave(kobj);
		kobject_put(parent);
		kobj->parent = NULL;
234 235 236

		/* be noisy on error issues */
		if (error == -EEXIST)
237 238 239 240
			WARN(1, "%s failed for %s with "
			     "-EEXIST, don't try to register things with "
			     "the same name in the same directory.\n",
			     __func__, kobject_name(kobj));
241
		else
242 243 244
			WARN(1, "%s failed for %s (error: %d parent: %s)\n",
			     __func__, kobject_name(kobj), error,
			     parent ? kobject_name(parent) : "'none'");
245 246
	} else
		kobj->state_in_sysfs = 1;
L
Linus Torvalds 已提交
247 248 249 250

	return error;
}

251 252 253 254 255 256
/**
 * kobject_set_name_vargs - Set the name of an kobject
 * @kobj: struct kobject to set the name of
 * @fmt: format string used to build the name
 * @vargs: vargs to format the string.
 */
257
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
258 259
				  va_list vargs)
{
260 261
	const char *old_name = kobj->name;
	char *s;
262

263 264 265
	if (kobj->name && !fmt)
		return 0;

266
	kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
267 268
	if (!kobj->name) {
		kobj->name = old_name;
269
		return -ENOMEM;
270
	}
271

272
	/* ewww... some of these buggers have '/' in the name ... */
273
	while ((s = strchr(kobj->name, '/')))
274 275 276
		s[0] = '!';

	kfree(old_name);
277 278
	return 0;
}
L
Linus Torvalds 已提交
279 280

/**
281
 * kobject_set_name - Set the name of a kobject
282
 * @kobj: struct kobject to set the name of
283
 * @fmt: format string used to build the name
L
Linus Torvalds 已提交
284
 *
285 286 287
 * This sets the name of the kobject.  If you have already added the
 * kobject to the system, you must call kobject_rename() in order to
 * change the name of the kobject.
L
Linus Torvalds 已提交
288
 */
289
int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
L
Linus Torvalds 已提交
290
{
291
	va_list vargs;
292
	int retval;
L
Linus Torvalds 已提交
293

294 295 296
	va_start(vargs, fmt);
	retval = kobject_set_name_vargs(kobj, fmt, vargs);
	va_end(vargs);
L
Linus Torvalds 已提交
297

298
	return retval;
L
Linus Torvalds 已提交
299 300 301
}
EXPORT_SYMBOL(kobject_set_name);

302
/**
303
 * kobject_init - initialize a kobject structure
304 305 306 307 308 309 310 311 312 313
 * @kobj: pointer to the kobject to initialize
 * @ktype: pointer to the ktype for this kobject.
 *
 * This function will properly initialize a kobject such that it can then
 * be passed to the kobject_add() call.
 *
 * After this function is called, the kobject MUST be cleaned up by a call
 * to kobject_put(), not by a call to kfree directly to ensure that all of
 * the memory is cleaned up properly.
 */
314
void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
315 316 317 318 319 320 321 322 323 324 325
{
	char *err_str;

	if (!kobj) {
		err_str = "invalid kobject pointer!";
		goto error;
	}
	if (!ktype) {
		err_str = "must have a ktype to be initialized properly!\n";
		goto error;
	}
326
	if (kobj->state_initialized) {
327
		/* do not error out as sometimes we can recover */
328 329
		printk(KERN_ERR "kobject (%p): tried to init an initialized "
		       "object, something is seriously wrong.\n", kobj);
330 331 332
		dump_stack();
	}

333
	kobject_init_internal(kobj);
334 335 336 337
	kobj->ktype = ktype;
	return;

error:
338
	printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
339 340
	dump_stack();
}
341
EXPORT_SYMBOL(kobject_init);
342

343 344 345 346 347
static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
			    const char *fmt, va_list vargs)
{
	int retval;

348
	retval = kobject_set_name_vargs(kobj, fmt, vargs);
349 350 351 352 353
	if (retval) {
		printk(KERN_ERR "kobject: can not set name properly!\n");
		return retval;
	}
	kobj->parent = parent;
354
	return kobject_add_internal(kobj);
355 356 357
}

/**
358
 * kobject_add - the main kobject add function
359 360 361 362 363 364 365 366 367
 * @kobj: the kobject to add
 * @parent: pointer to the parent of the kobject.
 * @fmt: format to name the kobject with.
 *
 * The kobject name is set and added to the kobject hierarchy in this
 * function.
 *
 * If @parent is set, then the parent of the @kobj will be set to it.
 * If @parent is NULL, then the parent of the @kobj will be set to the
368
 * kobject associated with the kset assigned to this kobject.  If no kset
369 370 371 372 373 374 375 376
 * is assigned to the kobject, then the kobject will be located in the
 * root of the sysfs tree.
 *
 * If this function returns an error, kobject_put() must be called to
 * properly clean up the memory associated with the object.
 * Under no instance should the kobject that is passed to this function
 * be directly freed with a call to kfree(), that can leak memory.
 *
377
 * Note, no "add" uevent will be created with this call, the caller should set
378 379 380 381
 * up all of the necessary sysfs files for the object and then call
 * kobject_uevent() with the UEVENT_ADD parameter to ensure that
 * userspace is properly notified of this kobject's creation.
 */
382 383
int kobject_add(struct kobject *kobj, struct kobject *parent,
		const char *fmt, ...)
384 385 386 387 388 389 390
{
	va_list args;
	int retval;

	if (!kobj)
		return -EINVAL;

391 392 393 394 395 396 397
	if (!kobj->state_initialized) {
		printk(KERN_ERR "kobject '%s' (%p): tried to add an "
		       "uninitialized object, something is seriously wrong.\n",
		       kobject_name(kobj), kobj);
		dump_stack();
		return -EINVAL;
	}
398 399 400 401 402 403
	va_start(args, fmt);
	retval = kobject_add_varg(kobj, parent, fmt, args);
	va_end(args);

	return retval;
}
404
EXPORT_SYMBOL(kobject_add);
405

406 407 408 409 410 411 412
/**
 * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
 * @kobj: pointer to the kobject to initialize
 * @ktype: pointer to the ktype for this kobject.
 * @parent: pointer to the parent of this kobject.
 * @fmt: the name of the kobject.
 *
413
 * This function combines the call to kobject_init() and
414 415
 * kobject_add().  The same type of error handling after a call to
 * kobject_add() and kobject lifetime rules are the same here.
416 417 418 419 420 421 422
 */
int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
			 struct kobject *parent, const char *fmt, ...)
{
	va_list args;
	int retval;

423
	kobject_init(kobj, ktype);
424 425 426 427 428 429 430 431 432

	va_start(args, fmt);
	retval = kobject_add_varg(kobj, parent, fmt, args);
	va_end(args);

	return retval;
}
EXPORT_SYMBOL_GPL(kobject_init_and_add);

L
Linus Torvalds 已提交
433
/**
434 435 436
 * kobject_rename - change the name of an object
 * @kobj: object in question.
 * @new_name: object's new name
437 438 439 440 441
 *
 * It is the responsibility of the caller to provide mutual
 * exclusion between two different calls of kobject_rename
 * on the same kobject and to ensure that new_name is valid and
 * won't conflict with other kobjects.
L
Linus Torvalds 已提交
442
 */
443
int kobject_rename(struct kobject *kobj, const char *new_name)
L
Linus Torvalds 已提交
444 445
{
	int error = 0;
446
	const char *devpath = NULL;
447
	const char *dup_name = NULL, *name;
448 449
	char *devpath_string = NULL;
	char *envp[2];
L
Linus Torvalds 已提交
450 451 452 453

	kobj = kobject_get(kobj);
	if (!kobj)
		return -EINVAL;
454 455
	if (!kobj->parent)
		return -EINVAL;
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470

	devpath = kobject_get_path(kobj, GFP_KERNEL);
	if (!devpath) {
		error = -ENOMEM;
		goto out;
	}
	devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
	if (!devpath_string) {
		error = -ENOMEM;
		goto out;
	}
	sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
	envp[0] = devpath_string;
	envp[1] = NULL;

471 472 473 474 475 476
	name = dup_name = kstrdup(new_name, GFP_KERNEL);
	if (!name) {
		error = -ENOMEM;
		goto out;
	}

477
	error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
478 479 480 481 482 483
	if (error)
		goto out;

	/* Install the new kobject name */
	dup_name = kobj->name;
	kobj->name = name;
484 485 486 487

	/* This function is mostly/only used for network interface.
	 * Some hotplug package track interfaces by their name and
	 * therefore want to know when the name is changed by the user. */
488
	kobject_uevent_env(kobj, KOBJ_MOVE, envp);
489 490

out:
491
	kfree(dup_name);
492 493
	kfree(devpath_string);
	kfree(devpath);
494 495 496 497
	kobject_put(kobj);

	return error;
}
498
EXPORT_SYMBOL_GPL(kobject_rename);
499

500
/**
501 502 503
 * kobject_move - move object to another parent
 * @kobj: object in question.
 * @new_parent: object's new parent (can be NULL)
504 505 506 507 508 509 510 511 512 513 514 515 516 517
 */
int kobject_move(struct kobject *kobj, struct kobject *new_parent)
{
	int error;
	struct kobject *old_parent;
	const char *devpath = NULL;
	char *devpath_string = NULL;
	char *envp[2];

	kobj = kobject_get(kobj);
	if (!kobj)
		return -EINVAL;
	new_parent = kobject_get(new_parent);
	if (!new_parent) {
518 519
		if (kobj->kset)
			new_parent = kobject_get(&kobj->kset->kobj);
520
	}
521

522 523 524 525 526 527 528 529 530 531 532 533 534 535
	/* old object path */
	devpath = kobject_get_path(kobj, GFP_KERNEL);
	if (!devpath) {
		error = -ENOMEM;
		goto out;
	}
	devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
	if (!devpath_string) {
		error = -ENOMEM;
		goto out;
	}
	sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
	envp[0] = devpath_string;
	envp[1] = NULL;
536
	error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj));
537 538 539 540
	if (error)
		goto out;
	old_parent = kobj->parent;
	kobj->parent = new_parent;
541
	new_parent = NULL;
542 543 544
	kobject_put(old_parent);
	kobject_uevent_env(kobj, KOBJ_MOVE, envp);
out:
545
	kobject_put(new_parent);
546 547 548 549 550 551
	kobject_put(kobj);
	kfree(devpath_string);
	kfree(devpath);
	return error;
}

L
Linus Torvalds 已提交
552
/**
553 554
 * kobject_del - unlink kobject from hierarchy.
 * @kobj: object.
L
Linus Torvalds 已提交
555
 */
556
void kobject_del(struct kobject *kobj)
L
Linus Torvalds 已提交
557
{
558
	struct kernfs_node *sd;
559

560 561
	if (!kobj)
		return;
562

563
	sd = kobj->sd;
L
Linus Torvalds 已提交
564
	sysfs_remove_dir(kobj);
565 566
	sysfs_put(sd);

567 568 569 570
	kobj->state_in_sysfs = 0;
	kobj_kset_leave(kobj);
	kobject_put(kobj->parent);
	kobj->parent = NULL;
L
Linus Torvalds 已提交
571 572 573
}

/**
574 575
 * kobject_get - increment refcount for object.
 * @kobj: object.
L
Linus Torvalds 已提交
576
 */
577
struct kobject *kobject_get(struct kobject *kobj)
L
Linus Torvalds 已提交
578
{
579 580 581 582 583
	if (kobj) {
		if (!kobj->state_initialized)
			WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
			       "initialized, yet kobject_get() is being "
			       "called.\n", kobject_name(kobj), kobj);
L
Linus Torvalds 已提交
584
		kref_get(&kobj->kref);
585
	}
L
Linus Torvalds 已提交
586 587 588
	return kobj;
}

A
Anatol Pomozov 已提交
589
static struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
590 591 592 593 594 595
{
	if (!kref_get_unless_zero(&kobj->kref))
		kobj = NULL;
	return kobj;
}

596 597 598
/*
 * kobject_cleanup - free kobject resources.
 * @kobj: object to cleanup
L
Linus Torvalds 已提交
599
 */
600
static void kobject_cleanup(struct kobject *kobj)
L
Linus Torvalds 已提交
601
{
602
	struct kobj_type *t = get_ktype(kobj);
603
	const char *name = kobj->name;
L
Linus Torvalds 已提交
604

605 606
	pr_debug("kobject: '%s' (%p): %s, parent %p\n",
		 kobject_name(kobj), kobj, __func__, kobj->parent);
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626

	if (t && !t->release)
		pr_debug("kobject: '%s' (%p): does not have a release() "
			 "function, it is broken and must be fixed.\n",
			 kobject_name(kobj), kobj);

	/* send "remove" if the caller did not do it but sent "add" */
	if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
		pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
			 kobject_name(kobj), kobj);
		kobject_uevent(kobj, KOBJ_REMOVE);
	}

	/* remove from sysfs if the caller did not do it */
	if (kobj->state_in_sysfs) {
		pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
			 kobject_name(kobj), kobj);
		kobject_del(kobj);
	}

627
	if (t && t->release) {
628 629
		pr_debug("kobject: '%s' (%p): calling ktype release\n",
			 kobject_name(kobj), kobj);
L
Linus Torvalds 已提交
630
		t->release(kobj);
631 632 633
	}

	/* free name if we allocated it */
634
	if (name) {
635
		pr_debug("kobject: '%s': free name\n", name);
636 637
		kfree(name);
	}
L
Linus Torvalds 已提交
638 639
}

640 641 642 643 644 645 646 647
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
static void kobject_delayed_cleanup(struct work_struct *work)
{
	kobject_cleanup(container_of(to_delayed_work(work),
				     struct kobject, release));
}
#endif

L
Linus Torvalds 已提交
648 649
static void kobject_release(struct kref *kref)
{
650 651
	struct kobject *kobj = container_of(kref, struct kobject, kref);
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
652 653 654
	unsigned long delay = HZ + HZ * (get_random_int() & 0x3);
	pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
		 kobject_name(kobj), kobj, __func__, kobj->parent, delay);
655
	INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
656 657

	schedule_delayed_work(&kobj->release, delay);
658 659 660
#else
	kobject_cleanup(kobj);
#endif
L
Linus Torvalds 已提交
661 662 663
}

/**
664 665
 * kobject_put - decrement refcount for object.
 * @kobj: object.
L
Linus Torvalds 已提交
666
 *
667
 * Decrement the refcount, and if 0, call kobject_cleanup().
L
Linus Torvalds 已提交
668
 */
669
void kobject_put(struct kobject *kobj)
L
Linus Torvalds 已提交
670
{
671
	if (kobj) {
A
Arjan van de Ven 已提交
672 673
		if (!kobj->state_initialized)
			WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
674 675
			       "initialized, yet kobject_put() is being "
			       "called.\n", kobject_name(kobj), kobj);
L
Linus Torvalds 已提交
676
		kref_put(&kobj->kref, kobject_release);
677
	}
L
Linus Torvalds 已提交
678 679
}

680
static void dynamic_kobj_release(struct kobject *kobj)
J
Jun'ichi Nomura 已提交
681
{
682
	pr_debug("kobject: (%p): %s\n", kobj, __func__);
J
Jun'ichi Nomura 已提交
683 684 685
	kfree(kobj);
}

686
static struct kobj_type dynamic_kobj_ktype = {
687 688
	.release	= dynamic_kobj_release,
	.sysfs_ops	= &kobj_sysfs_ops,
J
Jun'ichi Nomura 已提交
689 690
};

691
/**
692 693 694 695 696 697
 * kobject_create - create a struct kobject dynamically
 *
 * This function creates a kobject structure dynamically and sets it up
 * to be a "dynamic" kobject with a default release function set up.
 *
 * If the kobject was not able to be created, NULL will be returned.
698
 * The kobject structure returned from here must be cleaned up with a
699
 * call to kobject_put() and not kfree(), as kobject_init() has
700
 * already been called on this structure.
701
 */
702
struct kobject *kobject_create(void)
703 704 705 706 707 708 709
{
	struct kobject *kobj;

	kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
	if (!kobj)
		return NULL;

710
	kobject_init(kobj, &dynamic_kobj_ktype);
711 712 713 714 715 716
	return kobj;
}

/**
 * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
 *
717
 * @name: the name for the kobject
718 719
 * @parent: the parent kobject of this kobject, if any.
 *
720
 * This function creates a kobject structure dynamically and registers it
721
 * with sysfs.  When you are finished with this structure, call
722
 * kobject_put() and the structure will be dynamically freed when
723 724 725 726 727 728 729 730 731 732 733 734 735
 * it is no longer being used.
 *
 * If the kobject was not able to be created, NULL will be returned.
 */
struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
{
	struct kobject *kobj;
	int retval;

	kobj = kobject_create();
	if (!kobj)
		return NULL;

736
	retval = kobject_add(kobj, parent, "%s", name);
737 738
	if (retval) {
		printk(KERN_WARNING "%s: kobject_add error: %d\n",
739
		       __func__, retval);
740 741 742 743 744 745 746
		kobject_put(kobj);
		kobj = NULL;
	}
	return kobj;
}
EXPORT_SYMBOL_GPL(kobject_create_and_add);

L
Linus Torvalds 已提交
747
/**
748 749
 * kset_init - initialize a kset for use
 * @k: kset
L
Linus Torvalds 已提交
750
 */
751
void kset_init(struct kset *k)
L
Linus Torvalds 已提交
752
{
753
	kobject_init_internal(&k->kobj);
L
Linus Torvalds 已提交
754 755 756 757
	INIT_LIST_HEAD(&k->list);
	spin_lock_init(&k->list_lock);
}

758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
/* default kobject attribute operations */
static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
			      char *buf)
{
	struct kobj_attribute *kattr;
	ssize_t ret = -EIO;

	kattr = container_of(attr, struct kobj_attribute, attr);
	if (kattr->show)
		ret = kattr->show(kobj, kattr, buf);
	return ret;
}

static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
			       const char *buf, size_t count)
{
	struct kobj_attribute *kattr;
	ssize_t ret = -EIO;

	kattr = container_of(attr, struct kobj_attribute, attr);
	if (kattr->store)
		ret = kattr->store(kobj, kattr, buf, count);
	return ret;
}

783
const struct sysfs_ops kobj_sysfs_ops = {
784 785 786
	.show	= kobj_attr_show,
	.store	= kobj_attr_store,
};
787
EXPORT_SYMBOL_GPL(kobj_sysfs_ops);
L
Linus Torvalds 已提交
788 789

/**
790 791
 * kset_register - initialize and add a kset.
 * @k: kset.
L
Linus Torvalds 已提交
792
 */
793
int kset_register(struct kset *k)
L
Linus Torvalds 已提交
794
{
795 796
	int err;

797 798
	if (!k)
		return -EINVAL;
799

L
Linus Torvalds 已提交
800
	kset_init(k);
801
	err = kobject_add_internal(&k->kobj);
802 803 804 805
	if (err)
		return err;
	kobject_uevent(&k->kobj, KOBJ_ADD);
	return 0;
L
Linus Torvalds 已提交
806 807 808
}

/**
809 810
 * kset_unregister - remove a kset.
 * @k: kset.
L
Linus Torvalds 已提交
811
 */
812
void kset_unregister(struct kset *k)
L
Linus Torvalds 已提交
813
{
814 815
	if (!k)
		return;
816
	kobject_del(&k->kobj);
817
	kobject_put(&k->kobj);
L
Linus Torvalds 已提交
818 819 820
}

/**
821 822 823
 * kset_find_obj - search for object in kset.
 * @kset: kset we're looking in.
 * @name: object's name.
L
Linus Torvalds 已提交
824
 *
825 826 827
 * Lock kset via @kset->subsys, and iterate over @kset->list,
 * looking for a matching kobject. If matching object is found
 * take a reference and return the object.
L
Linus Torvalds 已提交
828
 */
829
struct kobject *kset_find_obj(struct kset *kset, const char *name)
L
Linus Torvalds 已提交
830
{
831
	struct kobject *k;
832
	struct kobject *ret = NULL;
L
Linus Torvalds 已提交
833 834

	spin_lock(&kset->list_lock);
835

836
	list_for_each_entry(k, &kset->list, entry) {
837
		if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
838
			ret = kobject_get_unless_zero(k);
L
Linus Torvalds 已提交
839 840 841
			break;
		}
	}
842

L
Linus Torvalds 已提交
843 844 845 846
	spin_unlock(&kset->list_lock);
	return ret;
}

847 848 849
static void kset_release(struct kobject *kobj)
{
	struct kset *kset = container_of(kobj, struct kset, kobj);
850
	pr_debug("kobject: '%s' (%p): %s\n",
851
		 kobject_name(kobj), kobj, __func__);
852 853 854
	kfree(kset);
}

855 856
static struct kobj_type kset_ktype = {
	.sysfs_ops	= &kobj_sysfs_ops,
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
	.release = kset_release,
};

/**
 * kset_create - create a struct kset dynamically
 *
 * @name: the name for the kset
 * @uevent_ops: a struct kset_uevent_ops for the kset
 * @parent_kobj: the parent kobject of this kset, if any.
 *
 * This function creates a kset structure dynamically.  This structure can
 * then be registered with the system and show up in sysfs with a call to
 * kset_register().  When you are finished with this structure, if
 * kset_register() has been called, call kset_unregister() and the
 * structure will be dynamically freed when it is no longer being used.
 *
 * If the kset was not able to be created, NULL will be returned.
 */
static struct kset *kset_create(const char *name,
876
				const struct kset_uevent_ops *uevent_ops,
877 878 879
				struct kobject *parent_kobj)
{
	struct kset *kset;
880
	int retval;
881 882 883 884

	kset = kzalloc(sizeof(*kset), GFP_KERNEL);
	if (!kset)
		return NULL;
885
	retval = kobject_set_name(&kset->kobj, "%s", name);
886 887 888 889
	if (retval) {
		kfree(kset);
		return NULL;
	}
890 891 892 893
	kset->uevent_ops = uevent_ops;
	kset->kobj.parent = parent_kobj;

	/*
894
	 * The kobject of this kset will have a type of kset_ktype and belong to
895 896 897
	 * no kset itself.  That way we can properly free it when it is
	 * finished being used.
	 */
898
	kset->kobj.ktype = &kset_ktype;
899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918
	kset->kobj.kset = NULL;

	return kset;
}

/**
 * kset_create_and_add - create a struct kset dynamically and add it to sysfs
 *
 * @name: the name for the kset
 * @uevent_ops: a struct kset_uevent_ops for the kset
 * @parent_kobj: the parent kobject of this kset, if any.
 *
 * This function creates a kset structure dynamically and registers it
 * with sysfs.  When you are finished with this structure, call
 * kset_unregister() and the structure will be dynamically freed when it
 * is no longer being used.
 *
 * If the kset was not able to be created, NULL will be returned.
 */
struct kset *kset_create_and_add(const char *name,
919
				 const struct kset_uevent_ops *uevent_ops,
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936
				 struct kobject *parent_kobj)
{
	struct kset *kset;
	int error;

	kset = kset_create(name, uevent_ops, parent_kobj);
	if (!kset)
		return NULL;
	error = kset_register(kset);
	if (error) {
		kfree(kset);
		return NULL;
	}
	return kset;
}
EXPORT_SYMBOL_GPL(kset_create_and_add);

937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983

static DEFINE_SPINLOCK(kobj_ns_type_lock);
static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];

int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
{
	enum kobj_ns_type type = ops->type;
	int error;

	spin_lock(&kobj_ns_type_lock);

	error = -EINVAL;
	if (type >= KOBJ_NS_TYPES)
		goto out;

	error = -EINVAL;
	if (type <= KOBJ_NS_TYPE_NONE)
		goto out;

	error = -EBUSY;
	if (kobj_ns_ops_tbl[type])
		goto out;

	error = 0;
	kobj_ns_ops_tbl[type] = ops;

out:
	spin_unlock(&kobj_ns_type_lock);
	return error;
}

int kobj_ns_type_registered(enum kobj_ns_type type)
{
	int registered = 0;

	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
		registered = kobj_ns_ops_tbl[type] != NULL;
	spin_unlock(&kobj_ns_type_lock);

	return registered;
}

const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
{
	const struct kobj_ns_type_operations *ops = NULL;

984
	if (parent && parent->ktype && parent->ktype->child_ns_type)
985 986 987 988 989 990 991 992 993 994
		ops = parent->ktype->child_ns_type(parent);

	return ops;
}

const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
{
	return kobj_child_ns_ops(kobj->parent);
}

995 996
bool kobj_ns_current_may_mount(enum kobj_ns_type type)
{
997
	bool may_mount = true;
998 999 1000 1001 1002 1003 1004 1005 1006

	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
	    kobj_ns_ops_tbl[type])
		may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
	spin_unlock(&kobj_ns_type_lock);

	return may_mount;
}
1007

1008
void *kobj_ns_grab_current(enum kobj_ns_type type)
1009
{
1010
	void *ns = NULL;
1011 1012 1013 1014

	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
	    kobj_ns_ops_tbl[type])
1015
		ns = kobj_ns_ops_tbl[type]->grab_current_ns();
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
	spin_unlock(&kobj_ns_type_lock);

	return ns;
}

const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
{
	const void *ns = NULL;

	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
	    kobj_ns_ops_tbl[type])
		ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
	spin_unlock(&kobj_ns_type_lock);

	return ns;
}

const void *kobj_ns_initial(enum kobj_ns_type type)
{
	const void *ns = NULL;

	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
	    kobj_ns_ops_tbl[type])
		ns = kobj_ns_ops_tbl[type]->initial_ns();
	spin_unlock(&kobj_ns_type_lock);

	return ns;
}

1047
void kobj_ns_drop(enum kobj_ns_type type, void *ns)
1048
{
1049 1050 1051 1052 1053
	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
	    kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
		kobj_ns_ops_tbl[type]->drop_ns(ns);
	spin_unlock(&kobj_ns_type_lock);
1054 1055
}

L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061
EXPORT_SYMBOL(kobject_get);
EXPORT_SYMBOL(kobject_put);
EXPORT_SYMBOL(kobject_del);

EXPORT_SYMBOL(kset_register);
EXPORT_SYMBOL(kset_unregister);
反馈
建议
客服 返回
顶部