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