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