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