]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - lib/kobject.c
lib/test_bitops: do the full test during module init
[mirror_ubuntu-hirsute-kernel.git] / lib / kobject.c
CommitLineData
d9d16e16 1// SPDX-License-Identifier: GPL-2.0
1da177e4
LT
2/*
3 * kobject.c - library routines for handling generic kernel objects
4 *
5 * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org>
f0e7e1bd
GKH
6 * Copyright (c) 2006-2007 Greg Kroah-Hartman <greg@kroah.com>
7 * Copyright (c) 2006-2007 Novell Inc.
1da177e4 8 *
0c1bc6b8 9 * Please see the file Documentation/core-api/kobject.rst for critical information
1da177e4
LT
10 * about using the kobject interface.
11 */
12
13#include <linux/kobject.h>
14#include <linux/string.h>
8bc3bcc9 15#include <linux/export.h>
1da177e4 16#include <linux/stat.h>
4e57b681 17#include <linux/slab.h>
89c86a64 18#include <linux/random.h>
1da177e4 19
e34ff490 20/**
ed856349 21 * kobject_namespace() - Return @kobj's namespace tag.
e34ff490
TH
22 * @kobj: kobject in question
23 *
24 * Returns namespace tag of @kobj if its parent has namespace ops enabled
25 * and thus @kobj should have a namespace tag associated with it. Returns
26 * %NULL otherwise.
27 */
28const void *kobject_namespace(struct kobject *kobj)
29{
30 const struct kobj_ns_type_operations *ns_ops = kobj_ns_ops(kobj);
31
32 if (!ns_ops || ns_ops->type == KOBJ_NS_TYPE_NONE)
33 return NULL;
34
a1212d27 35 return kobj->ktype->namespace(kobj);
e34ff490
TH
36}
37
5f81880d 38/**
ed856349 39 * kobject_get_ownership() - Get sysfs ownership data for @kobj.
5f81880d
DT
40 * @kobj: kobject in question
41 * @uid: kernel user ID for sysfs objects
42 * @gid: kernel group ID for sysfs objects
43 *
44 * Returns initial uid/gid pair that should be used when creating sysfs
45 * representation of given kobject. Normally used to adjust ownership of
46 * objects in a container.
47 */
48void kobject_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
49{
50 *uid = GLOBAL_ROOT_UID;
51 *gid = GLOBAL_ROOT_GID;
52
53 if (kobj->ktype->get_ownership)
54 kobj->ktype->get_ownership(kobj, uid, gid);
55}
56
e374a2bf
GKH
57/*
58 * populate_dir - populate directory with attributes.
59 * @kobj: object we're working on.
1da177e4 60 *
e374a2bf
GKH
61 * Most subsystems have a set of default attributes that are associated
62 * with an object that registers with them. This is a helper called during
63 * object registration that loops through the default attributes of the
64 * subsystem and creates attributes files for them in sysfs.
1da177e4 65 */
e374a2bf 66static int populate_dir(struct kobject *kobj)
1da177e4 67{
e374a2bf
GKH
68 struct kobj_type *t = get_ktype(kobj);
69 struct attribute *attr;
1da177e4
LT
70 int error = 0;
71 int i;
e374a2bf 72
1da177e4
LT
73 if (t && t->default_attrs) {
74 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
e374a2bf
GKH
75 error = sysfs_create_file(kobj, attr);
76 if (error)
1da177e4
LT
77 break;
78 }
79 }
80 return error;
81}
82
e374a2bf 83static int create_dir(struct kobject *kobj)
1da177e4 84{
aa30f47c 85 const struct kobj_type *ktype = get_ktype(kobj);
c84a3b27 86 const struct kobj_ns_type_operations *ops;
e34ff490
TH
87 int error;
88
89 error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj));
c84a3b27
TH
90 if (error)
91 return error;
92
93 error = populate_dir(kobj);
94 if (error) {
95 sysfs_remove_dir(kobj);
96 return error;
1da177e4 97 }
26ea12de 98
aa30f47c
KB
99 if (ktype) {
100 error = sysfs_create_groups(kobj, ktype->default_groups);
101 if (error) {
102 sysfs_remove_dir(kobj);
103 return error;
104 }
105 }
106
26ea12de
TH
107 /*
108 * @kobj->sd may be deleted by an ancestor going away. Hold an
109 * extra reference so that it stays until @kobj is gone.
110 */
111 sysfs_get(kobj->sd);
112
c84a3b27
TH
113 /*
114 * If @kobj has ns_ops, its children need to be filtered based on
115 * their namespace tags. Enable namespace support on @kobj->sd.
116 */
117 ops = kobj_child_ns_ops(kobj);
118 if (ops) {
119 BUG_ON(ops->type <= KOBJ_NS_TYPE_NONE);
120 BUG_ON(ops->type >= KOBJ_NS_TYPES);
121 BUG_ON(!kobj_ns_type_registered(ops->type));
122
fa4cd451 123 sysfs_enable_ns(kobj->sd);
c84a3b27
TH
124 }
125
126 return 0;
1da177e4
LT
127}
128
1da177e4
LT
129static int get_kobj_path_length(struct kobject *kobj)
130{
131 int length = 1;
e374a2bf 132 struct kobject *parent = kobj;
1da177e4 133
e374a2bf 134 /* walk up the ancestors until we hit the one pointing to the
1da177e4
LT
135 * root.
136 * Add 1 to strlen for leading '/' of each level.
137 */
138 do {
b365b3da
CE
139 if (kobject_name(parent) == NULL)
140 return 0;
1da177e4
LT
141 length += strlen(kobject_name(parent)) + 1;
142 parent = parent->parent;
143 } while (parent);
144 return length;
145}
146
147static void fill_kobj_path(struct kobject *kobj, char *path, int length)
148{
e374a2bf 149 struct kobject *parent;
1da177e4
LT
150
151 --length;
152 for (parent = kobj; parent; parent = parent->parent) {
153 int cur = strlen(kobject_name(parent));
154 /* back up enough to print this name with '/' */
155 length -= cur;
77d2a24b 156 memcpy(path + length, kobject_name(parent), cur);
1da177e4
LT
157 *(path + --length) = '/';
158 }
159
9f66fa2a 160 pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
810304db 161 kobj, __func__, path);
1da177e4
LT
162}
163
164/**
8fd7c302 165 * kobject_get_path() - Allocate memory and fill in the path for @kobj.
1da177e4
LT
166 * @kobj: kobject in question, with which to build the path
167 * @gfp_mask: the allocation type used to allocate the path
72fd4a35 168 *
8fd7c302 169 * Return: The newly allocated memory, caller must free with kfree().
1da177e4 170 */
fd4f2df2 171char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
1da177e4
LT
172{
173 char *path;
174 int len;
175
176 len = get_kobj_path_length(kobj);
b365b3da
CE
177 if (len == 0)
178 return NULL;
4668edc3 179 path = kzalloc(len, gfp_mask);
1da177e4
LT
180 if (!path)
181 return NULL;
1da177e4
LT
182 fill_kobj_path(kobj, path, len);
183
184 return path;
185}
80fc9f53 186EXPORT_SYMBOL_GPL(kobject_get_path);
1da177e4 187
0f4dafc0
KS
188/* add the kobject to its kset's list */
189static void kobj_kset_join(struct kobject *kobj)
1da177e4 190{
0f4dafc0 191 if (!kobj->kset)
31b9025a 192 return;
0f4dafc0
KS
193
194 kset_get(kobj->kset);
195 spin_lock(&kobj->kset->list_lock);
196 list_add_tail(&kobj->entry, &kobj->kset->list);
197 spin_unlock(&kobj->kset->list_lock);
1da177e4
LT
198}
199
0f4dafc0
KS
200/* remove the kobject from its kset's list */
201static void kobj_kset_leave(struct kobject *kobj)
202{
203 if (!kobj->kset)
204 return;
1da177e4 205
0f4dafc0
KS
206 spin_lock(&kobj->kset->list_lock);
207 list_del_init(&kobj->entry);
208 spin_unlock(&kobj->kset->list_lock);
209 kset_put(kobj->kset);
210}
1da177e4 211
e374a2bf 212static void kobject_init_internal(struct kobject *kobj)
1da177e4 213{
0f4dafc0
KS
214 if (!kobj)
215 return;
216 kref_init(&kobj->kref);
217 INIT_LIST_HEAD(&kobj->entry);
a4573c48
GKH
218 kobj->state_in_sysfs = 0;
219 kobj->state_add_uevent_sent = 0;
220 kobj->state_remove_uevent_sent = 0;
221 kobj->state_initialized = 1;
1da177e4
LT
222}
223
0f4dafc0 224
9e7bbccd 225static int kobject_add_internal(struct kobject *kobj)
1da177e4
LT
226{
227 int error = 0;
e374a2bf 228 struct kobject *parent;
1da177e4 229
0f4dafc0 230 if (!kobj)
1da177e4 231 return -ENOENT;
0f4dafc0 232
af5ca3f4 233 if (!kobj->name || !kobj->name[0]) {
82d1f117
AS
234 WARN(1,
235 "kobject: (%p): attempted to be registered with empty name!\n",
236 kobj);
c171fef5
GKH
237 return -EINVAL;
238 }
1da177e4 239
0f4dafc0 240 parent = kobject_get(kobj->parent);
1da177e4 241
0f4dafc0 242 /* join kset if set, use it as parent if we do not already have one */
1da177e4 243 if (kobj->kset) {
0f4dafc0 244 if (!parent)
1da177e4 245 parent = kobject_get(&kobj->kset->kobj);
0f4dafc0 246 kobj_kset_join(kobj);
460f7e9a 247 kobj->parent = parent;
1da177e4 248 }
1da177e4 249
0f4dafc0 250 pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
810304db 251 kobject_name(kobj), kobj, __func__,
0f4dafc0 252 parent ? kobject_name(parent) : "<NULL>",
e374a2bf 253 kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
0f4dafc0 254
90bc6135 255 error = create_dir(kobj);
1da177e4 256 if (error) {
0f4dafc0
KS
257 kobj_kset_leave(kobj);
258 kobject_put(parent);
259 kobj->parent = NULL;
dcd0da00
GKH
260
261 /* be noisy on error issues */
262 if (error == -EEXIST)
3e14c6ab
DV
263 pr_err("%s failed for %s with -EEXIST, don't try to register things with the same name in the same directory.\n",
264 __func__, kobject_name(kobj));
dcd0da00 265 else
3e14c6ab
DV
266 pr_err("%s failed for %s (error: %d parent: %s)\n",
267 __func__, kobject_name(kobj), error,
268 parent ? kobject_name(parent) : "'none'");
0f4dafc0
KS
269 } else
270 kobj->state_in_sysfs = 1;
1da177e4
LT
271
272 return error;
273}
274
663a4743 275/**
ed856349 276 * kobject_set_name_vargs() - Set the name of a kobject.
663a4743
GKH
277 * @kobj: struct kobject to set the name of
278 * @fmt: format string used to build the name
279 * @vargs: vargs to format the string.
280 */
1fa5ae85 281int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
663a4743
GKH
282 va_list vargs)
283{
f773f32d 284 const char *s;
663a4743 285
8a577ffc
KS
286 if (kobj->name && !fmt)
287 return 0;
288
f773f32d 289 s = kvasprintf_const(GFP_KERNEL, fmt, vargs);
2abf114f 290 if (!s)
a4ca6617 291 return -ENOMEM;
663a4743 292
f773f32d
RV
293 /*
294 * ewww... some of these buggers have '/' in the name ... If
295 * that's the case, we need to make sure we have an actual
296 * allocated copy to modify, since kvasprintf_const may have
297 * returned something from .rodata.
298 */
299 if (strchr(s, '/')) {
300 char *t;
301
302 t = kstrdup(s, GFP_KERNEL);
303 kfree_const(s);
304 if (!t)
305 return -ENOMEM;
306 strreplace(t, '/', '!');
307 s = t;
308 }
309 kfree_const(kobj->name);
2abf114f 310 kobj->name = s;
9f255651 311
663a4743
GKH
312 return 0;
313}
1da177e4
LT
314
315/**
ed856349 316 * kobject_set_name() - Set the name of a kobject.
663a4743 317 * @kobj: struct kobject to set the name of
8c4606b1 318 * @fmt: format string used to build the name
1da177e4 319 *
8c4606b1
GKH
320 * This sets the name of the kobject. If you have already added the
321 * kobject to the system, you must call kobject_rename() in order to
322 * change the name of the kobject.
1da177e4 323 */
663a4743 324int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
1da177e4 325{
a4ca6617 326 va_list vargs;
663a4743 327 int retval;
1da177e4 328
a4ca6617
KS
329 va_start(vargs, fmt);
330 retval = kobject_set_name_vargs(kobj, fmt, vargs);
331 va_end(vargs);
1da177e4 332
663a4743 333 return retval;
1da177e4 334}
1da177e4
LT
335EXPORT_SYMBOL(kobject_set_name);
336
e86000d0 337/**
ed856349 338 * kobject_init() - Initialize a kobject structure.
e86000d0
GKH
339 * @kobj: pointer to the kobject to initialize
340 * @ktype: pointer to the ktype for this kobject.
341 *
342 * This function will properly initialize a kobject such that it can then
343 * be passed to the kobject_add() call.
344 *
345 * After this function is called, the kobject MUST be cleaned up by a call
346 * to kobject_put(), not by a call to kfree directly to ensure that all of
347 * the memory is cleaned up properly.
348 */
f9cb074b 349void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
e86000d0
GKH
350{
351 char *err_str;
352
353 if (!kobj) {
354 err_str = "invalid kobject pointer!";
355 goto error;
356 }
357 if (!ktype) {
358 err_str = "must have a ktype to be initialized properly!\n";
359 goto error;
360 }
0f4dafc0 361 if (kobj->state_initialized) {
e86000d0 362 /* do not error out as sometimes we can recover */
82d1f117
AS
363 pr_err("kobject (%p): tried to init an initialized object, something is seriously wrong.\n",
364 kobj);
e86000d0
GKH
365 dump_stack();
366 }
367
a4573c48 368 kobject_init_internal(kobj);
e86000d0
GKH
369 kobj->ktype = ktype;
370 return;
371
372error:
82d1f117 373 pr_err("kobject (%p): %s\n", kobj, err_str);
e86000d0
GKH
374 dump_stack();
375}
f9cb074b 376EXPORT_SYMBOL(kobject_init);
e86000d0 377
8db14860
NI
378static __printf(3, 0) int kobject_add_varg(struct kobject *kobj,
379 struct kobject *parent,
380 const char *fmt, va_list vargs)
244f6cee 381{
244f6cee
GKH
382 int retval;
383
a4ca6617 384 retval = kobject_set_name_vargs(kobj, fmt, vargs);
244f6cee 385 if (retval) {
82d1f117 386 pr_err("kobject: can not set name properly!\n");
244f6cee
GKH
387 return retval;
388 }
389 kobj->parent = parent;
9e7bbccd 390 return kobject_add_internal(kobj);
244f6cee
GKH
391}
392
393/**
ed856349 394 * kobject_add() - The main kobject add function.
244f6cee
GKH
395 * @kobj: the kobject to add
396 * @parent: pointer to the parent of the kobject.
397 * @fmt: format to name the kobject with.
398 *
399 * The kobject name is set and added to the kobject hierarchy in this
400 * function.
401 *
402 * If @parent is set, then the parent of the @kobj will be set to it.
403 * If @parent is NULL, then the parent of the @kobj will be set to the
9705710e 404 * kobject associated with the kset assigned to this kobject. If no kset
244f6cee
GKH
405 * is assigned to the kobject, then the kobject will be located in the
406 * root of the sysfs tree.
407 *
0f4dafc0 408 * Note, no "add" uevent will be created with this call, the caller should set
244f6cee
GKH
409 * up all of the necessary sysfs files for the object and then call
410 * kobject_uevent() with the UEVENT_ADD parameter to ensure that
411 * userspace is properly notified of this kobject's creation.
92067f84
TH
412 *
413 * Return: If this function returns an error, kobject_put() must be
414 * called to properly clean up the memory associated with the
415 * object. Under no instance should the kobject that is passed
416 * to this function be directly freed with a call to kfree(),
417 * that can leak memory.
418 *
70e16a62
GKH
419 * If this function returns success, kobject_put() must also be called
420 * in order to properly clean up the memory associated with the object.
421 *
422 * In short, once this function is called, kobject_put() MUST be called
423 * when the use of the object is finished in order to properly free
424 * everything.
244f6cee 425 */
b2d6db58
GKH
426int kobject_add(struct kobject *kobj, struct kobject *parent,
427 const char *fmt, ...)
244f6cee
GKH
428{
429 va_list args;
430 int retval;
431
432 if (!kobj)
433 return -EINVAL;
434
0f4dafc0 435 if (!kobj->state_initialized) {
82d1f117 436 pr_err("kobject '%s' (%p): tried to add an uninitialized object, something is seriously wrong.\n",
0f4dafc0
KS
437 kobject_name(kobj), kobj);
438 dump_stack();
439 return -EINVAL;
440 }
244f6cee
GKH
441 va_start(args, fmt);
442 retval = kobject_add_varg(kobj, parent, fmt, args);
443 va_end(args);
444
445 return retval;
446}
b2d6db58 447EXPORT_SYMBOL(kobject_add);
244f6cee 448
c11c4154 449/**
ed856349
TH
450 * kobject_init_and_add() - Initialize a kobject structure and add it to
451 * the kobject hierarchy.
c11c4154
GKH
452 * @kobj: pointer to the kobject to initialize
453 * @ktype: pointer to the ktype for this kobject.
454 * @parent: pointer to the parent of this kobject.
455 * @fmt: the name of the kobject.
456 *
1fd7c3b4
TH
457 * This function combines the call to kobject_init() and kobject_add().
458 *
459 * If this function returns an error, kobject_put() must be called to
460 * properly clean up the memory associated with the object. This is the
461 * same type of error handling after a call to kobject_add() and kobject
462 * lifetime rules are the same here.
c11c4154
GKH
463 */
464int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
465 struct kobject *parent, const char *fmt, ...)
466{
467 va_list args;
468 int retval;
469
f9cb074b 470 kobject_init(kobj, ktype);
c11c4154
GKH
471
472 va_start(args, fmt);
473 retval = kobject_add_varg(kobj, parent, fmt, args);
474 va_end(args);
475
476 return retval;
477}
478EXPORT_SYMBOL_GPL(kobject_init_and_add);
479
1da177e4 480/**
ed856349 481 * kobject_rename() - Change the name of an object.
e374a2bf
GKH
482 * @kobj: object in question.
483 * @new_name: object's new name
030c1d2b
EB
484 *
485 * It is the responsibility of the caller to provide mutual
486 * exclusion between two different calls of kobject_rename
487 * on the same kobject and to ensure that new_name is valid and
488 * won't conflict with other kobjects.
1da177e4 489 */
e374a2bf 490int kobject_rename(struct kobject *kobj, const char *new_name)
1da177e4
LT
491{
492 int error = 0;
ca2f37db 493 const char *devpath = NULL;
0b4a4fea 494 const char *dup_name = NULL, *name;
ca2f37db
JT
495 char *devpath_string = NULL;
496 char *envp[2];
1da177e4
LT
497
498 kobj = kobject_get(kobj);
499 if (!kobj)
500 return -EINVAL;
122f8ec7
LY
501 if (!kobj->parent) {
502 kobject_put(kobj);
b592fcfe 503 return -EINVAL;
122f8ec7 504 }
ca2f37db
JT
505
506 devpath = kobject_get_path(kobj, GFP_KERNEL);
507 if (!devpath) {
508 error = -ENOMEM;
509 goto out;
510 }
511 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
512 if (!devpath_string) {
513 error = -ENOMEM;
514 goto out;
515 }
516 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
517 envp[0] = devpath_string;
518 envp[1] = NULL;
ca2f37db 519
f773f32d 520 name = dup_name = kstrdup_const(new_name, GFP_KERNEL);
0b4a4fea
EB
521 if (!name) {
522 error = -ENOMEM;
523 goto out;
524 }
525
e34ff490 526 error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
0b4a4fea
EB
527 if (error)
528 goto out;
529
530 /* Install the new kobject name */
531 dup_name = kobj->name;
532 kobj->name = name;
ca2f37db
JT
533
534 /* This function is mostly/only used for network interface.
535 * Some hotplug package track interfaces by their name and
536 * therefore want to know when the name is changed by the user. */
0b4a4fea 537 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
ca2f37db
JT
538
539out:
f773f32d 540 kfree_const(dup_name);
ca2f37db
JT
541 kfree(devpath_string);
542 kfree(devpath);
b592fcfe
EB
543 kobject_put(kobj);
544
545 return error;
546}
8344b568 547EXPORT_SYMBOL_GPL(kobject_rename);
b592fcfe 548
8a82472f 549/**
ed856349 550 * kobject_move() - Move object to another parent.
e374a2bf
GKH
551 * @kobj: object in question.
552 * @new_parent: object's new parent (can be NULL)
8a82472f 553 */
8a82472f
CH
554int kobject_move(struct kobject *kobj, struct kobject *new_parent)
555{
556 int error;
557 struct kobject *old_parent;
558 const char *devpath = NULL;
559 char *devpath_string = NULL;
560 char *envp[2];
561
562 kobj = kobject_get(kobj);
563 if (!kobj)
564 return -EINVAL;
565 new_parent = kobject_get(new_parent);
566 if (!new_parent) {
c744aeae
CH
567 if (kobj->kset)
568 new_parent = kobject_get(&kobj->kset->kobj);
8a82472f 569 }
e34ff490 570
8a82472f
CH
571 /* old object path */
572 devpath = kobject_get_path(kobj, GFP_KERNEL);
573 if (!devpath) {
574 error = -ENOMEM;
575 goto out;
576 }
577 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
578 if (!devpath_string) {
579 error = -ENOMEM;
580 goto out;
581 }
582 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
583 envp[0] = devpath_string;
584 envp[1] = NULL;
e34ff490 585 error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj));
8a82472f
CH
586 if (error)
587 goto out;
588 old_parent = kobj->parent;
589 kobj->parent = new_parent;
9e993efb 590 new_parent = NULL;
8a82472f
CH
591 kobject_put(old_parent);
592 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
593out:
9e993efb 594 kobject_put(new_parent);
8a82472f
CH
595 kobject_put(kobj);
596 kfree(devpath_string);
597 kfree(devpath);
598 return error;
599}
24199d20 600EXPORT_SYMBOL_GPL(kobject_move);
8a82472f 601
079ad2fb 602static void __kobject_del(struct kobject *kobj)
1da177e4 603{
324a56e1 604 struct kernfs_node *sd;
3d378dc7 605 const struct kobj_type *ktype;
26ea12de 606
31b9025a
GKH
607 if (!kobj)
608 return;
0f4dafc0 609
26ea12de 610 sd = kobj->sd;
3d378dc7 611 ktype = get_ktype(kobj);
aa30f47c
KB
612
613 if (ktype)
614 sysfs_remove_groups(kobj, ktype->default_groups);
615
0e5596c5
GKH
616 /* send "remove" if the caller did not do it but sent "add" */
617 if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
618 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
619 kobject_name(kobj), kobj);
620 kobject_uevent(kobj, KOBJ_REMOVE);
621 }
622
1da177e4 623 sysfs_remove_dir(kobj);
26ea12de
TH
624 sysfs_put(sd);
625
0f4dafc0
KS
626 kobj->state_in_sysfs = 0;
627 kobj_kset_leave(kobj);
0f4dafc0 628 kobj->parent = NULL;
1da177e4 629}
079ad2fb
HK
630
631/**
632 * kobject_del() - Unlink kobject from hierarchy.
633 * @kobj: object.
634 *
635 * This is the function that should be called to delete an object
636 * successfully added via kobject_add().
637 */
638void kobject_del(struct kobject *kobj)
639{
640 struct kobject *parent = kobj->parent;
641
642 __kobject_del(kobj);
643 kobject_put(parent);
644}
fa40ae34 645EXPORT_SYMBOL(kobject_del);
1da177e4 646
1da177e4 647/**
ed856349 648 * kobject_get() - Increment refcount for object.
e374a2bf 649 * @kobj: object.
1da177e4 650 */
e374a2bf 651struct kobject *kobject_get(struct kobject *kobj)
1da177e4 652{
d82d54af
EZ
653 if (kobj) {
654 if (!kobj->state_initialized)
82d1f117
AS
655 WARN(1, KERN_WARNING
656 "kobject: '%s' (%p): is not initialized, yet kobject_get() is being called.\n",
657 kobject_name(kobj), kobj);
1da177e4 658 kref_get(&kobj->kref);
d82d54af 659 }
1da177e4
LT
660 return kobj;
661}
fa40ae34 662EXPORT_SYMBOL(kobject_get);
1da177e4 663
c70c176f 664struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
a49b7e82 665{
c70c176f
JK
666 if (!kobj)
667 return NULL;
a49b7e82
LT
668 if (!kref_get_unless_zero(&kobj->kref))
669 kobj = NULL;
670 return kobj;
671}
c70c176f 672EXPORT_SYMBOL(kobject_get_unless_zero);
a49b7e82 673
18041f47
GKH
674/*
675 * kobject_cleanup - free kobject resources.
676 * @kobj: object to cleanup
1da177e4 677 */
18041f47 678static void kobject_cleanup(struct kobject *kobj)
1da177e4 679{
079ad2fb 680 struct kobject *parent = kobj->parent;
0f4dafc0 681 struct kobj_type *t = get_ktype(kobj);
af5ca3f4 682 const char *name = kobj->name;
1da177e4 683
c817a67e
RK
684 pr_debug("kobject: '%s' (%p): %s, parent %p\n",
685 kobject_name(kobj), kobj, __func__, kobj->parent);
0f4dafc0
KS
686
687 if (t && !t->release)
0c1bc6b8 688 pr_debug("kobject: '%s' (%p): does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kobject.rst.\n",
0f4dafc0
KS
689 kobject_name(kobj), kobj);
690
0f4dafc0
KS
691 /* remove from sysfs if the caller did not do it */
692 if (kobj->state_in_sysfs) {
693 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
694 kobject_name(kobj), kobj);
079ad2fb
HK
695 __kobject_del(kobj);
696 } else {
697 /* avoid dropping the parent reference unnecessarily */
698 parent = NULL;
0f4dafc0
KS
699 }
700
ce2c9cb0 701 if (t && t->release) {
0f4dafc0
KS
702 pr_debug("kobject: '%s' (%p): calling ktype release\n",
703 kobject_name(kobj), kobj);
1da177e4 704 t->release(kobj);
0f4dafc0
KS
705 }
706
707 /* free name if we allocated it */
af5ca3f4 708 if (name) {
0f4dafc0 709 pr_debug("kobject: '%s': free name\n", name);
f773f32d 710 kfree_const(name);
ce2c9cb0 711 }
079ad2fb
HK
712
713 kobject_put(parent);
1da177e4
LT
714}
715
c817a67e
RK
716#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
717static void kobject_delayed_cleanup(struct work_struct *work)
718{
719 kobject_cleanup(container_of(to_delayed_work(work),
720 struct kobject, release));
721}
722#endif
723
1da177e4
LT
724static void kobject_release(struct kref *kref)
725{
c817a67e
RK
726 struct kobject *kobj = container_of(kref, struct kobject, kref);
727#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
89c86a64
BH
728 unsigned long delay = HZ + HZ * (get_random_int() & 0x3);
729 pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
730 kobject_name(kobj), kobj, __func__, kobj->parent, delay);
c817a67e 731 INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
89c86a64
BH
732
733 schedule_delayed_work(&kobj->release, delay);
c817a67e
RK
734#else
735 kobject_cleanup(kobj);
736#endif
1da177e4
LT
737}
738
739/**
ed856349 740 * kobject_put() - Decrement refcount for object.
e374a2bf 741 * @kobj: object.
1da177e4 742 *
e374a2bf 743 * Decrement the refcount, and if 0, call kobject_cleanup().
1da177e4 744 */
e374a2bf 745void kobject_put(struct kobject *kobj)
1da177e4 746{
c1ebdae5 747 if (kobj) {
d955c78a 748 if (!kobj->state_initialized)
82d1f117
AS
749 WARN(1, KERN_WARNING
750 "kobject: '%s' (%p): is not initialized, yet kobject_put() is being called.\n",
751 kobject_name(kobj), kobj);
1da177e4 752 kref_put(&kobj->kref, kobject_release);
c1ebdae5 753 }
1da177e4 754}
fa40ae34 755EXPORT_SYMBOL(kobject_put);
1da177e4 756
3f9e3ee9 757static void dynamic_kobj_release(struct kobject *kobj)
7423172a 758{
810304db 759 pr_debug("kobject: (%p): %s\n", kobj, __func__);
7423172a
JN
760 kfree(kobj);
761}
762
3f9e3ee9 763static struct kobj_type dynamic_kobj_ktype = {
386f275f
KS
764 .release = dynamic_kobj_release,
765 .sysfs_ops = &kobj_sysfs_ops,
7423172a
JN
766};
767
43968d2f 768/**
ed856349 769 * kobject_create() - Create a struct kobject dynamically.
3f9e3ee9
GKH
770 *
771 * This function creates a kobject structure dynamically and sets it up
772 * to be a "dynamic" kobject with a default release function set up.
773 *
774 * If the kobject was not able to be created, NULL will be returned.
43968d2f 775 * The kobject structure returned from here must be cleaned up with a
f9cb074b 776 * call to kobject_put() and not kfree(), as kobject_init() has
43968d2f 777 * already been called on this structure.
3f9e3ee9 778 */
43968d2f 779struct kobject *kobject_create(void)
3f9e3ee9
GKH
780{
781 struct kobject *kobj;
782
783 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
784 if (!kobj)
785 return NULL;
786
f9cb074b 787 kobject_init(kobj, &dynamic_kobj_ktype);
3f9e3ee9
GKH
788 return kobj;
789}
790
791/**
ed856349
TH
792 * kobject_create_and_add() - Create a struct kobject dynamically and
793 * register it with sysfs.
9ff1f838 794 * @name: the name for the kobject
3f9e3ee9
GKH
795 * @parent: the parent kobject of this kobject, if any.
796 *
f70701a3 797 * This function creates a kobject structure dynamically and registers it
3f9e3ee9 798 * with sysfs. When you are finished with this structure, call
78a2d906 799 * kobject_put() and the structure will be dynamically freed when
3f9e3ee9
GKH
800 * it is no longer being used.
801 *
802 * If the kobject was not able to be created, NULL will be returned.
803 */
804struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
805{
806 struct kobject *kobj;
807 int retval;
808
809 kobj = kobject_create();
810 if (!kobj)
811 return NULL;
812
b2d6db58 813 retval = kobject_add(kobj, parent, "%s", name);
3f9e3ee9 814 if (retval) {
82d1f117 815 pr_warn("%s: kobject_add error: %d\n", __func__, retval);
3f9e3ee9
GKH
816 kobject_put(kobj);
817 kobj = NULL;
818 }
819 return kobj;
820}
821EXPORT_SYMBOL_GPL(kobject_create_and_add);
822
1da177e4 823/**
ed856349 824 * kset_init() - Initialize a kset for use.
e374a2bf 825 * @k: kset
1da177e4 826 */
e374a2bf 827void kset_init(struct kset *k)
1da177e4 828{
e1543ddf 829 kobject_init_internal(&k->kobj);
1da177e4
LT
830 INIT_LIST_HEAD(&k->list);
831 spin_lock_init(&k->list_lock);
832}
833
23b5212c
KS
834/* default kobject attribute operations */
835static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
836 char *buf)
837{
838 struct kobj_attribute *kattr;
839 ssize_t ret = -EIO;
840
841 kattr = container_of(attr, struct kobj_attribute, attr);
842 if (kattr->show)
843 ret = kattr->show(kobj, kattr, buf);
844 return ret;
845}
846
847static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
848 const char *buf, size_t count)
849{
850 struct kobj_attribute *kattr;
851 ssize_t ret = -EIO;
852
853 kattr = container_of(attr, struct kobj_attribute, attr);
854 if (kattr->store)
855 ret = kattr->store(kobj, kattr, buf, count);
856 return ret;
857}
858
52cf25d0 859const struct sysfs_ops kobj_sysfs_ops = {
23b5212c
KS
860 .show = kobj_attr_show,
861 .store = kobj_attr_store,
862};
29dfe2dc 863EXPORT_SYMBOL_GPL(kobj_sysfs_ops);
1da177e4 864
1da177e4 865/**
ed856349 866 * kset_register() - Initialize and add a kset.
e374a2bf 867 * @k: kset.
1da177e4 868 */
e374a2bf 869int kset_register(struct kset *k)
1da177e4 870{
80f03e34
KS
871 int err;
872
31b9025a
GKH
873 if (!k)
874 return -EINVAL;
80f03e34 875
1da177e4 876 kset_init(k);
12e339ac 877 err = kobject_add_internal(&k->kobj);
80f03e34
KS
878 if (err)
879 return err;
880 kobject_uevent(&k->kobj, KOBJ_ADD);
881 return 0;
1da177e4 882}
fa40ae34 883EXPORT_SYMBOL(kset_register);
1da177e4 884
1da177e4 885/**
ed856349 886 * kset_unregister() - Remove a kset.
e374a2bf 887 * @k: kset.
1da177e4 888 */
e374a2bf 889void kset_unregister(struct kset *k)
1da177e4 890{
31b9025a
GKH
891 if (!k)
892 return;
35a5fe69 893 kobject_del(&k->kobj);
78a2d906 894 kobject_put(&k->kobj);
1da177e4 895}
fa40ae34 896EXPORT_SYMBOL(kset_unregister);
1da177e4 897
1da177e4 898/**
ed856349 899 * kset_find_obj() - Search for object in kset.
e374a2bf
GKH
900 * @kset: kset we're looking in.
901 * @name: object's name.
1da177e4 902 *
e374a2bf
GKH
903 * Lock kset via @kset->subsys, and iterate over @kset->list,
904 * looking for a matching kobject. If matching object is found
905 * take a reference and return the object.
1da177e4 906 */
e374a2bf 907struct kobject *kset_find_obj(struct kset *kset, const char *name)
1da177e4 908{
c6a2a3dc 909 struct kobject *k;
e374a2bf 910 struct kobject *ret = NULL;
1da177e4
LT
911
912 spin_lock(&kset->list_lock);
c25d1dfb 913
c6a2a3dc 914 list_for_each_entry(k, &kset->list, entry) {
e374a2bf 915 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
a49b7e82 916 ret = kobject_get_unless_zero(k);
1da177e4
LT
917 break;
918 }
919 }
c25d1dfb 920
1da177e4
LT
921 spin_unlock(&kset->list_lock);
922 return ret;
923}
2fe829ac 924EXPORT_SYMBOL_GPL(kset_find_obj);
1da177e4 925
b727c702
GKH
926static void kset_release(struct kobject *kobj)
927{
928 struct kset *kset = container_of(kobj, struct kset, kobj);
9f66fa2a 929 pr_debug("kobject: '%s' (%p): %s\n",
810304db 930 kobject_name(kobj), kobj, __func__);
b727c702
GKH
931 kfree(kset);
932}
933
7ab35a14 934static void kset_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
d028b6f7
DT
935{
936 if (kobj->parent)
937 kobject_get_ownership(kobj->parent, uid, gid);
938}
939
386f275f
KS
940static struct kobj_type kset_ktype = {
941 .sysfs_ops = &kobj_sysfs_ops,
d028b6f7
DT
942 .release = kset_release,
943 .get_ownership = kset_get_ownership,
b727c702
GKH
944};
945
946/**
ed856349 947 * kset_create() - Create a struct kset dynamically.
b727c702
GKH
948 *
949 * @name: the name for the kset
950 * @uevent_ops: a struct kset_uevent_ops for the kset
951 * @parent_kobj: the parent kobject of this kset, if any.
952 *
953 * This function creates a kset structure dynamically. This structure can
954 * then be registered with the system and show up in sysfs with a call to
955 * kset_register(). When you are finished with this structure, if
956 * kset_register() has been called, call kset_unregister() and the
957 * structure will be dynamically freed when it is no longer being used.
958 *
959 * If the kset was not able to be created, NULL will be returned.
960 */
961static struct kset *kset_create(const char *name,
9cd43611 962 const struct kset_uevent_ops *uevent_ops,
b727c702
GKH
963 struct kobject *parent_kobj)
964{
965 struct kset *kset;
d9cd8f37 966 int retval;
b727c702
GKH
967
968 kset = kzalloc(sizeof(*kset), GFP_KERNEL);
969 if (!kset)
970 return NULL;
b7165ebb 971 retval = kobject_set_name(&kset->kobj, "%s", name);
d9cd8f37
DY
972 if (retval) {
973 kfree(kset);
974 return NULL;
975 }
b727c702
GKH
976 kset->uevent_ops = uevent_ops;
977 kset->kobj.parent = parent_kobj;
978
979 /*
386f275f 980 * The kobject of this kset will have a type of kset_ktype and belong to
b727c702
GKH
981 * no kset itself. That way we can properly free it when it is
982 * finished being used.
983 */
386f275f 984 kset->kobj.ktype = &kset_ktype;
b727c702
GKH
985 kset->kobj.kset = NULL;
986
987 return kset;
988}
989
990/**
ed856349 991 * kset_create_and_add() - Create a struct kset dynamically and add it to sysfs.
b727c702
GKH
992 *
993 * @name: the name for the kset
994 * @uevent_ops: a struct kset_uevent_ops for the kset
995 * @parent_kobj: the parent kobject of this kset, if any.
996 *
997 * This function creates a kset structure dynamically and registers it
998 * with sysfs. When you are finished with this structure, call
999 * kset_unregister() and the structure will be dynamically freed when it
1000 * is no longer being used.
1001 *
1002 * If the kset was not able to be created, NULL will be returned.
1003 */
1004struct kset *kset_create_and_add(const char *name,
9cd43611 1005 const struct kset_uevent_ops *uevent_ops,
b727c702
GKH
1006 struct kobject *parent_kobj)
1007{
1008 struct kset *kset;
1009 int error;
1010
1011 kset = kset_create(name, uevent_ops, parent_kobj);
1012 if (!kset)
1013 return NULL;
1014 error = kset_register(kset);
1015 if (error) {
1016 kfree(kset);
1017 return NULL;
1018 }
1019 return kset;
1020}
1021EXPORT_SYMBOL_GPL(kset_create_and_add);
1022
bc451f20
EB
1023
1024static DEFINE_SPINLOCK(kobj_ns_type_lock);
1025static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
1026
1027int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
1028{
1029 enum kobj_ns_type type = ops->type;
1030 int error;
1031
1032 spin_lock(&kobj_ns_type_lock);
1033
1034 error = -EINVAL;
1035 if (type >= KOBJ_NS_TYPES)
1036 goto out;
1037
1038 error = -EINVAL;
1039 if (type <= KOBJ_NS_TYPE_NONE)
1040 goto out;
1041
1042 error = -EBUSY;
1043 if (kobj_ns_ops_tbl[type])
1044 goto out;
1045
1046 error = 0;
1047 kobj_ns_ops_tbl[type] = ops;
1048
1049out:
1050 spin_unlock(&kobj_ns_type_lock);
1051 return error;
1052}
1053
1054int kobj_ns_type_registered(enum kobj_ns_type type)
1055{
1056 int registered = 0;
1057
1058 spin_lock(&kobj_ns_type_lock);
1059 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
1060 registered = kobj_ns_ops_tbl[type] != NULL;
1061 spin_unlock(&kobj_ns_type_lock);
1062
1063 return registered;
1064}
1065
1066const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
1067{
1068 const struct kobj_ns_type_operations *ops = NULL;
1069
41fb96a4 1070 if (parent && parent->ktype && parent->ktype->child_ns_type)
bc451f20
EB
1071 ops = parent->ktype->child_ns_type(parent);
1072
1073 return ops;
1074}
1075
1076const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
1077{
1078 return kobj_child_ns_ops(kobj->parent);
1079}
1080
7dc5dbc8
EB
1081bool kobj_ns_current_may_mount(enum kobj_ns_type type)
1082{
730d7d33 1083 bool may_mount = true;
7dc5dbc8
EB
1084
1085 spin_lock(&kobj_ns_type_lock);
1086 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1087 kobj_ns_ops_tbl[type])
1088 may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
1089 spin_unlock(&kobj_ns_type_lock);
1090
1091 return may_mount;
1092}
bc451f20 1093
a685e089 1094void *kobj_ns_grab_current(enum kobj_ns_type type)
bc451f20 1095{
a685e089 1096 void *ns = NULL;
bc451f20
EB
1097
1098 spin_lock(&kobj_ns_type_lock);
1099 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1100 kobj_ns_ops_tbl[type])
a685e089 1101 ns = kobj_ns_ops_tbl[type]->grab_current_ns();
bc451f20
EB
1102 spin_unlock(&kobj_ns_type_lock);
1103
1104 return ns;
1105}
172856ea 1106EXPORT_SYMBOL_GPL(kobj_ns_grab_current);
bc451f20
EB
1107
1108const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
1109{
1110 const void *ns = NULL;
1111
1112 spin_lock(&kobj_ns_type_lock);
1113 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1114 kobj_ns_ops_tbl[type])
1115 ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
1116 spin_unlock(&kobj_ns_type_lock);
1117
1118 return ns;
1119}
1120
1121const void *kobj_ns_initial(enum kobj_ns_type type)
1122{
1123 const void *ns = NULL;
1124
1125 spin_lock(&kobj_ns_type_lock);
1126 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1127 kobj_ns_ops_tbl[type])
1128 ns = kobj_ns_ops_tbl[type]->initial_ns();
1129 spin_unlock(&kobj_ns_type_lock);
1130
1131 return ns;
1132}
1133
a685e089 1134void kobj_ns_drop(enum kobj_ns_type type, void *ns)
bc451f20 1135{
a685e089
AV
1136 spin_lock(&kobj_ns_type_lock);
1137 if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1138 kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
1139 kobj_ns_ops_tbl[type]->drop_ns(ns);
1140 spin_unlock(&kobj_ns_type_lock);
bc451f20 1141}
172856ea 1142EXPORT_SYMBOL_GPL(kobj_ns_drop);