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