kobject.c 23.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
18
#include <linux/stat.h>
Tim Schmielau's avatar
Tim Schmielau committed
19
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
20

21 22 23
/*
 * populate_dir - populate directory with attributes.
 * @kobj: object we're working on.
Linus Torvalds's avatar
Linus Torvalds committed
24
 *
25 26 27 28
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
29
 */
30
static int populate_dir(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
31
{
32 33
	struct kobj_type *t = get_ktype(kobj);
	struct attribute *attr;
Linus Torvalds's avatar
Linus Torvalds committed
34 35
	int error = 0;
	int i;
36

Linus Torvalds's avatar
Linus Torvalds committed
37 38
	if (t && t->default_attrs) {
		for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
39 40
			error = sysfs_create_file(kobj, attr);
			if (error)
Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45 46
				break;
		}
	}
	return error;
}

47
static int create_dir(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
48 49
{
	int error = 0;
50 51 52 53 54
	error = sysfs_create_dir(kobj);
	if (!error) {
		error = populate_dir(kobj);
		if (error)
			sysfs_remove_dir(kobj);
Linus Torvalds's avatar
Linus Torvalds committed
55 56 57 58 59 60 61
	}
	return error;
}

static int get_kobj_path_length(struct kobject *kobj)
{
	int length = 1;
62
	struct kobject *parent = kobj;
Linus Torvalds's avatar
Linus Torvalds committed
63

64
	/* walk up the ancestors until we hit the one pointing to the
Linus Torvalds's avatar
Linus Torvalds committed
65 66 67 68
	 * root.
	 * Add 1 to strlen for leading '/' of each level.
	 */
	do {
69 70
		if (kobject_name(parent) == NULL)
			return 0;
Linus Torvalds's avatar
Linus Torvalds committed
71 72 73 74 75 76 77 78
		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)
{
79
	struct kobject *parent;
Linus Torvalds's avatar
Linus Torvalds committed
80 81 82 83 84 85

	--length;
	for (parent = kobj; parent; parent = parent->parent) {
		int cur = strlen(kobject_name(parent));
		/* back up enough to print this name with '/' */
		length -= cur;
86
		strncpy(path + length, kobject_name(parent), cur);
Linus Torvalds's avatar
Linus Torvalds committed
87 88 89
		*(path + --length) = '/';
	}

90
	pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
91
		 kobj, __func__, path);
Linus Torvalds's avatar
Linus Torvalds committed
92 93 94
}

/**
95
 * kobject_get_path - generate and return the path associated with a given kobj and kset pair.
Linus Torvalds's avatar
Linus Torvalds committed
96 97 98
 *
 * @kobj:	kobject in question, with which to build the path
 * @gfp_mask:	the allocation type used to allocate the path
99 100
 *
 * The result must be freed by the caller with kfree().
Linus Torvalds's avatar
Linus Torvalds committed
101
 */
Al Viro's avatar
Al Viro committed
102
char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
Linus Torvalds's avatar
Linus Torvalds committed
103 104 105 106 107
{
	char *path;
	int len;

	len = get_kobj_path_length(kobj);
108 109
	if (len == 0)
		return NULL;
110
	path = kzalloc(len, gfp_mask);
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116
	if (!path)
		return NULL;
	fill_kobj_path(kobj, path, len);

	return path;
}
117
EXPORT_SYMBOL_GPL(kobject_get_path);
Linus Torvalds's avatar
Linus Torvalds committed
118

119 120
/* add the kobject to its kset's list */
static void kobj_kset_join(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
121
{
122
	if (!kobj->kset)
123
		return;
124 125 126 127 128

	kset_get(kobj->kset);
	spin_lock(&kobj->kset->list_lock);
	list_add_tail(&kobj->entry, &kobj->kset->list);
	spin_unlock(&kobj->kset->list_lock);
Linus Torvalds's avatar
Linus Torvalds committed
129 130
}

131 132 133 134 135
/* remove the kobject from its kset's list */
static void kobj_kset_leave(struct kobject *kobj)
{
	if (!kobj->kset)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
136

137 138 139 140 141
	spin_lock(&kobj->kset->list_lock);
	list_del_init(&kobj->entry);
	spin_unlock(&kobj->kset->list_lock);
	kset_put(kobj->kset);
}
Linus Torvalds's avatar
Linus Torvalds committed
142

143
static void kobject_init_internal(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
144
{
145 146 147 148
	if (!kobj)
		return;
	kref_init(&kobj->kref);
	INIT_LIST_HEAD(&kobj->entry);
149 150 151 152
	kobj->state_in_sysfs = 0;
	kobj->state_add_uevent_sent = 0;
	kobj->state_remove_uevent_sent = 0;
	kobj->state_initialized = 1;
Linus Torvalds's avatar
Linus Torvalds committed
153 154
}

155

156
static int kobject_add_internal(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
157 158
{
	int error = 0;
159
	struct kobject *parent;
Linus Torvalds's avatar
Linus Torvalds committed
160

161
	if (!kobj)
Linus Torvalds's avatar
Linus Torvalds committed
162
		return -ENOENT;
163

164
	if (!kobj->name || !kobj->name[0]) {
Arjan van de Ven's avatar
Arjan van de Ven committed
165
		WARN(1, "kobject: (%p): attempted to be registered with empty "
166
			 "name!\n", kobj);
167 168
		return -EINVAL;
	}
Linus Torvalds's avatar
Linus Torvalds committed
169

170
	parent = kobject_get(kobj->parent);
Linus Torvalds's avatar
Linus Torvalds committed
171

172
	/* join kset if set, use it as parent if we do not already have one */
Linus Torvalds's avatar
Linus Torvalds committed
173
	if (kobj->kset) {
174
		if (!parent)
Linus Torvalds's avatar
Linus Torvalds committed
175
			parent = kobject_get(&kobj->kset->kobj);
176
		kobj_kset_join(kobj);
177
		kobj->parent = parent;
Linus Torvalds's avatar
Linus Torvalds committed
178 179
	}

180
	pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
181
		 kobject_name(kobj), kobj, __func__,
182
		 parent ? kobject_name(parent) : "<NULL>",
183
		 kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
184

185
	error = create_dir(kobj);
Linus Torvalds's avatar
Linus Torvalds committed
186
	if (error) {
187 188 189
		kobj_kset_leave(kobj);
		kobject_put(parent);
		kobj->parent = NULL;
190 191 192

		/* be noisy on error issues */
		if (error == -EEXIST)
193 194 195 196
			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));
197
		else
198 199 200
			WARN(1, "%s failed for %s (error: %d parent: %s)\n",
			     __func__, kobject_name(kobj), error,
			     parent ? kobject_name(parent) : "'none'");
201 202
	} else
		kobj->state_in_sysfs = 1;
Linus Torvalds's avatar
Linus Torvalds committed
203 204 205 206

	return error;
}

207 208 209 210 211 212
/**
 * 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.
 */
213
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
214 215
				  va_list vargs)
{
216 217
	const char *old_name = kobj->name;
	char *s;
218

219 220 221
	if (kobj->name && !fmt)
		return 0;

222 223 224
	kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
	if (!kobj->name)
		return -ENOMEM;
225

226
	/* ewww... some of these buggers have '/' in the name ... */
227
	while ((s = strchr(kobj->name, '/')))
228 229 230
		s[0] = '!';

	kfree(old_name);
231 232
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
233 234

/**
235
 * kobject_set_name - Set the name of a kobject
236
 * @kobj: struct kobject to set the name of
237
 * @fmt: format string used to build the name
Linus Torvalds's avatar
Linus Torvalds committed
238
 *
239 240 241
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
242
 */
243
int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
244
{
245
	va_list vargs;
246
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
247

248 249 250
	va_start(vargs, fmt);
	retval = kobject_set_name_vargs(kobj, fmt, vargs);
	va_end(vargs);
Linus Torvalds's avatar
Linus Torvalds committed
251

252
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
253 254 255
}
EXPORT_SYMBOL(kobject_set_name);

256
/**
257
 * kobject_init - initialize a kobject structure
258 259 260 261 262 263 264 265 266 267
 * @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.
 */
268
void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
269 270 271 272 273 274 275 276 277 278 279
{
	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;
	}
280
	if (kobj->state_initialized) {
281
		/* do not error out as sometimes we can recover */
282 283
		printk(KERN_ERR "kobject (%p): tried to init an initialized "
		       "object, something is seriously wrong.\n", kobj);
284 285 286
		dump_stack();
	}

287
	kobject_init_internal(kobj);
288 289 290 291
	kobj->ktype = ktype;
	return;

error:
292
	printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
293 294
	dump_stack();
}
295
EXPORT_SYMBOL(kobject_init);
296

297 298 299 300 301
static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
			    const char *fmt, va_list vargs)
{
	int retval;

302
	retval = kobject_set_name_vargs(kobj, fmt, vargs);
303 304 305 306 307
	if (retval) {
		printk(KERN_ERR "kobject: can not set name properly!\n");
		return retval;
	}
	kobj->parent = parent;
308
	return kobject_add_internal(kobj);
309 310 311
}

/**
312
 * kobject_add - the main kobject add function
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
 * @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
 * kobject associted with the kset assigned to this kobject.  If no kset
 * 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.
 *
331
 * Note, no "add" uevent will be created with this call, the caller should set
332 333 334 335
 * 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.
 */
336 337
int kobject_add(struct kobject *kobj, struct kobject *parent,
		const char *fmt, ...)
338 339 340 341 342 343 344
{
	va_list args;
	int retval;

	if (!kobj)
		return -EINVAL;

345 346 347 348 349 350 351
	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;
	}
352 353 354 355 356 357
	va_start(args, fmt);
	retval = kobject_add_varg(kobj, parent, fmt, args);
	va_end(args);

	return retval;
}
358
EXPORT_SYMBOL(kobject_add);
359

360 361 362 363 364 365 366
/**
 * 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.
 *
367
 * This function combines the call to kobject_init() and
368 369
 * kobject_add().  The same type of error handling after a call to
 * kobject_add() and kobject lifetime rules are the same here.
370 371 372 373 374 375 376
 */
int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
			 struct kobject *parent, const char *fmt, ...)
{
	va_list args;
	int retval;

377
	kobject_init(kobj, ktype);
378 379 380 381 382 383 384 385 386

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

	return retval;
}
EXPORT_SYMBOL_GPL(kobject_init_and_add);

Linus Torvalds's avatar
Linus Torvalds committed
387
/**
388 389 390
 * kobject_rename - change the name of an object
 * @kobj: object in question.
 * @new_name: object's new name
391 392 393 394 395
 *
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
396
 */
397
int kobject_rename(struct kobject *kobj, const char *new_name)
Linus Torvalds's avatar
Linus Torvalds committed
398 399
{
	int error = 0;
400
	const char *devpath = NULL;
401
	const char *dup_name = NULL, *name;
402 403
	char *devpath_string = NULL;
	char *envp[2];
Linus Torvalds's avatar
Linus Torvalds committed
404 405 406 407

	kobj = kobject_get(kobj);
	if (!kobj)
		return -EINVAL;
408 409
	if (!kobj->parent)
		return -EINVAL;
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424

	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;

425 426 427 428 429 430
	name = dup_name = kstrdup(new_name, GFP_KERNEL);
	if (!name) {
		error = -ENOMEM;
		goto out;
	}

431
	error = sysfs_rename_dir(kobj, new_name);
432 433 434 435 436 437
	if (error)
		goto out;

	/* Install the new kobject name */
	dup_name = kobj->name;
	kobj->name = name;
438 439 440 441

	/* 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. */
442
	kobject_uevent_env(kobj, KOBJ_MOVE, envp);
443 444

out:
445
	kfree(dup_name);
446 447
	kfree(devpath_string);
	kfree(devpath);
448 449 450 451
	kobject_put(kobj);

	return error;
}
452
EXPORT_SYMBOL_GPL(kobject_rename);
453

454
/**
455 456 457
 * kobject_move - move object to another parent
 * @kobj: object in question.
 * @new_parent: object's new parent (can be NULL)
458 459 460 461 462 463 464 465 466 467 468 469 470 471
 */
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) {
472 473
		if (kobj->kset)
			new_parent = kobject_get(&kobj->kset->kobj);
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
	}
	/* 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;
	error = sysfs_move_dir(kobj, new_parent);
	if (error)
		goto out;
	old_parent = kobj->parent;
	kobj->parent = new_parent;
494
	new_parent = NULL;
495 496 497
	kobject_put(old_parent);
	kobject_uevent_env(kobj, KOBJ_MOVE, envp);
out:
498
	kobject_put(new_parent);
499 500 501 502 503 504
	kobject_put(kobj);
	kfree(devpath_string);
	kfree(devpath);
	return error;
}

Linus Torvalds's avatar
Linus Torvalds committed
505
/**
506 507
 * kobject_del - unlink kobject from hierarchy.
 * @kobj: object.
Linus Torvalds's avatar
Linus Torvalds committed
508
 */
509
void kobject_del(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
510
{
511 512
	if (!kobj)
		return;
513

Linus Torvalds's avatar
Linus Torvalds committed
514
	sysfs_remove_dir(kobj);
515 516 517 518
	kobj->state_in_sysfs = 0;
	kobj_kset_leave(kobj);
	kobject_put(kobj->parent);
	kobj->parent = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521
}

/**
522 523
 * kobject_get - increment refcount for object.
 * @kobj: object.
Linus Torvalds's avatar
Linus Torvalds committed
524
 */
525
struct kobject *kobject_get(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
526 527 528 529 530 531
{
	if (kobj)
		kref_get(&kobj->kref);
	return kobj;
}

532 533 534
/*
 * kobject_cleanup - free kobject resources.
 * @kobj: object to cleanup
Linus Torvalds's avatar
Linus Torvalds committed
535
 */
536
static void kobject_cleanup(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
537
{
538
	struct kobj_type *t = get_ktype(kobj);
539
	const char *name = kobj->name;
Linus Torvalds's avatar
Linus Torvalds committed
540

541
	pr_debug("kobject: '%s' (%p): %s\n",
542
		 kobject_name(kobj), kobj, __func__);
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562

	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);
	}

563
	if (t && t->release) {
564 565
		pr_debug("kobject: '%s' (%p): calling ktype release\n",
			 kobject_name(kobj), kobj);
Linus Torvalds's avatar
Linus Torvalds committed
566
		t->release(kobj);
567 568 569
	}

	/* free name if we allocated it */
570
	if (name) {
571
		pr_debug("kobject: '%s': free name\n", name);
572 573
		kfree(name);
	}
Linus Torvalds's avatar
Linus Torvalds committed
574 575 576 577 578 579 580 581
}

static void kobject_release(struct kref *kref)
{
	kobject_cleanup(container_of(kref, struct kobject, kref));
}

/**
582 583
 * kobject_put - decrement refcount for object.
 * @kobj: object.
Linus Torvalds's avatar
Linus Torvalds committed
584
 *
585
 * Decrement the refcount, and if 0, call kobject_cleanup().
Linus Torvalds's avatar
Linus Torvalds committed
586
 */
587
void kobject_put(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
588
{
589
	if (kobj) {
Arjan van de Ven's avatar
Arjan van de Ven committed
590 591
		if (!kobj->state_initialized)
			WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
592 593
			       "initialized, yet kobject_put() is being "
			       "called.\n", kobject_name(kobj), kobj);
Linus Torvalds's avatar
Linus Torvalds committed
594
		kref_put(&kobj->kref, kobject_release);
595
	}
Linus Torvalds's avatar
Linus Torvalds committed
596 597
}

598
static void dynamic_kobj_release(struct kobject *kobj)
Jun'ichi Nomura's avatar
Jun'ichi Nomura committed
599
{
600
	pr_debug("kobject: (%p): %s\n", kobj, __func__);
Jun'ichi Nomura's avatar
Jun'ichi Nomura committed
601 602 603
	kfree(kobj);
}

604
static struct kobj_type dynamic_kobj_ktype = {
605 606
	.release	= dynamic_kobj_release,
	.sysfs_ops	= &kobj_sysfs_ops,
Jun'ichi Nomura's avatar
Jun'ichi Nomura committed
607 608
};

609
/**
610 611 612 613 614 615
 * 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.
616
 * The kobject structure returned from here must be cleaned up with a
617
 * call to kobject_put() and not kfree(), as kobject_init() has
618
 * already been called on this structure.
619
 */
620
struct kobject *kobject_create(void)
621 622 623 624 625 626 627
{
	struct kobject *kobj;

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

628
	kobject_init(kobj, &dynamic_kobj_ktype);
629 630 631 632 633 634
	return kobj;
}

/**
 * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
 *
635
 * @name: the name for the kobject
636 637
 * @parent: the parent kobject of this kobject, if any.
 *
Dave Young's avatar
Dave Young committed
638
 * This function creates a kobject structure dynamically and registers it
639
 * with sysfs.  When you are finished with this structure, call
640
 * kobject_put() and the structure will be dynamically freed when
641 642 643 644 645 646 647 648 649 650 651 652 653
 * 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;

654
	retval = kobject_add(kobj, parent, "%s", name);
655 656
	if (retval) {
		printk(KERN_WARNING "%s: kobject_add error: %d\n",
657
		       __func__, retval);
658 659 660 661 662 663 664
		kobject_put(kobj);
		kobj = NULL;
	}
	return kobj;
}
EXPORT_SYMBOL_GPL(kobject_create_and_add);

Linus Torvalds's avatar
Linus Torvalds committed
665
/**
666 667
 * kset_init - initialize a kset for use
 * @k: kset
Linus Torvalds's avatar
Linus Torvalds committed
668
 */
669
void kset_init(struct kset *k)
Linus Torvalds's avatar
Linus Torvalds committed
670
{
671
	kobject_init_internal(&k->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
672 673 674 675
	INIT_LIST_HEAD(&k->list);
	spin_lock_init(&k->list_lock);
}

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
/* 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;
}

701
const struct sysfs_ops kobj_sysfs_ops = {
702 703 704
	.show	= kobj_attr_show,
	.store	= kobj_attr_store,
};
Linus Torvalds's avatar
Linus Torvalds committed
705 706

/**
707 708
 * kset_register - initialize and add a kset.
 * @k: kset.
Linus Torvalds's avatar
Linus Torvalds committed
709
 */
710
int kset_register(struct kset *k)
Linus Torvalds's avatar
Linus Torvalds committed
711
{
712 713
	int err;

714 715
	if (!k)
		return -EINVAL;
716

Linus Torvalds's avatar
Linus Torvalds committed
717
	kset_init(k);
718
	err = kobject_add_internal(&k->kobj);
719 720 721 722
	if (err)
		return err;
	kobject_uevent(&k->kobj, KOBJ_ADD);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
723 724 725
}

/**
726 727
 * kset_unregister - remove a kset.
 * @k: kset.
Linus Torvalds's avatar
Linus Torvalds committed
728
 */
729
void kset_unregister(struct kset *k)
Linus Torvalds's avatar
Linus Torvalds committed
730
{
731 732
	if (!k)
		return;
733
	kobject_put(&k->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
734 735 736
}

/**
737 738 739
 * kset_find_obj - search for object in kset.
 * @kset: kset we're looking in.
 * @name: object's name.
Linus Torvalds's avatar
Linus Torvalds committed
740
 *
741 742 743
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
744
 */
745
struct kobject *kset_find_obj(struct kset *kset, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
746
{
747
	struct kobject *k;
748
	struct kobject *ret = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
749 750

	spin_lock(&kset->list_lock);
751

752
	list_for_each_entry(k, &kset->list, entry) {
753
		if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
Linus Torvalds's avatar
Linus Torvalds committed
754 755 756 757
			ret = kobject_get(k);
			break;
		}
	}
758

Linus Torvalds's avatar
Linus Torvalds committed
759 760 761 762
	spin_unlock(&kset->list_lock);
	return ret;
}

763 764 765
static void kset_release(struct kobject *kobj)
{
	struct kset *kset = container_of(kobj, struct kset, kobj);
766
	pr_debug("kobject: '%s' (%p): %s\n",
767
		 kobject_name(kobj), kobj, __func__);
768 769 770
	kfree(kset);
}

771 772
static struct kobj_type kset_ktype = {
	.sysfs_ops	= &kobj_sysfs_ops,
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
	.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,
792
				const struct kset_uevent_ops *uevent_ops,
793 794 795
				struct kobject *parent_kobj)
{
	struct kset *kset;
796
	int retval;
797 798 799 800

	kset = kzalloc(sizeof(*kset), GFP_KERNEL);
	if (!kset)
		return NULL;
801 802 803 804 805
	retval = kobject_set_name(&kset->kobj, name);
	if (retval) {
		kfree(kset);
		return NULL;
	}
806 807 808 809
	kset->uevent_ops = uevent_ops;
	kset->kobj.parent = parent_kobj;

	/*
810
	 * The kobject of this kset will have a type of kset_ktype and belong to
811 812 813
	 * no kset itself.  That way we can properly free it when it is
	 * finished being used.
	 */
814
	kset->kobj.ktype = &kset_ktype;
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
	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,
835
				 const struct kset_uevent_ops *uevent_ops,
836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852
				 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);

853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911

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;

	if (parent && parent->ktype->child_ns_type)
		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);
}


912
void *kobj_ns_grab_current(enum kobj_ns_type type)
913
{
914
	void *ns = NULL;
915 916 917 918

	spin_lock(&kobj_ns_type_lock);
	if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
	    kobj_ns_ops_tbl[type])
919
		ns = kobj_ns_ops_tbl[type]->grab_current_ns();
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
	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;
}

951
void kobj_ns_drop(enum kobj_ns_type type, void *ns)
952
{
953 954 955 956 957
	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);
958 959
}

Linus Torvalds's avatar
Linus Torvalds committed
960 961 962 963 964 965
EXPORT_SYMBOL(kobject_get);
EXPORT_SYMBOL(kobject_put);
EXPORT_SYMBOL(kobject_del);

EXPORT_SYMBOL(kset_register);
EXPORT_SYMBOL(kset_unregister);