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