Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/kobject.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us