LCOV - code coverage report
Current view: top level - lkbce/include/linux - kobject.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 6 6 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * kobject.h - generic kernel object infrastructure.
       3             :  *
       4             :  * Copyright (c) 2002-2003 Patrick Mochel
       5             :  * Copyright (c) 2002-2003 Open Source Development Labs
       6             :  * Copyright (c) 2006-2008 Greg Kroah-Hartman <greg@kroah.com>
       7             :  * Copyright (c) 2006-2008 Novell Inc.
       8             :  *
       9             :  * This file is released under the GPLv2.
      10             :  *
      11             :  * Please read Documentation/kobject.txt before using the kobject
      12             :  * interface, ESPECIALLY the parts about reference counts and object
      13             :  * destructors.
      14             :  */
      15             : 
      16             : #ifndef _KOBJECT_H_
      17             : #define _KOBJECT_H_
      18             : 
      19             : #include <linux/types.h>
      20             : #include <linux/list.h>
      21             : #include <linux/sysfs.h>
      22             : #include <linux/compiler.h>
      23             : #include <linux/spinlock.h>
      24             : #include <linux/kref.h>
      25             : #include <linux/kernel.h>
      26             : #include <linux/wait.h>
      27             : #include <asm/atomic.h>
      28             : 
      29             : #define UEVENT_HELPER_PATH_LEN          256
      30             : #define UEVENT_NUM_ENVP                 32      /* number of env pointers */
      31             : #define UEVENT_BUFFER_SIZE              2048    /* buffer for the variables */
      32             : 
      33             : /* path to the userspace helper executed on an event */
      34             : extern char uevent_helper[];
      35             : 
      36             : /* counter to tag the uevent, read only except for the kobject core */
      37             : extern u64 uevent_seqnum;
      38             : 
      39             : /*
      40             :  * The actions here must match the index to the string array
      41             :  * in lib/kobject_uevent.c
      42             :  *
      43             :  * Do not add new actions here without checking with the driver-core
      44             :  * maintainers. Action strings are not meant to express subsystem
      45             :  * or device specific properties. In most cases you want to send a
      46             :  * kobject_uevent_env(kobj, KOBJ_CHANGE, env) with additional event
      47             :  * specific variables added to the event environment.
      48           3 :  */
      49             : enum kobject_action {
      50             :         KOBJ_ADD,
      51             :         KOBJ_REMOVE,
      52             :         KOBJ_CHANGE,
      53             :         KOBJ_MOVE,
      54             :         KOBJ_ONLINE,
      55             :         KOBJ_OFFLINE,
      56             :         KOBJ_MAX
      57             : };
      58             : 
      59             : struct kobject {
      60             :         const char              *name;
      61             :         struct list_head        entry;
      62             :         struct kobject          *parent;
      63             :         struct kset             *kset;
      64             :         struct kobj_type        *ktype;
      65             :         struct sysfs_dirent     *sd;
      66             :         struct kref             kref;
      67             :         unsigned int state_initialized:1;
      68             :         unsigned int state_in_sysfs:1;
      69             :         unsigned int state_add_uevent_sent:1;
      70             :         unsigned int state_remove_uevent_sent:1;
      71             :         unsigned int uevent_suppress:1;
      72             : };
      73             : 
      74             : extern int kobject_set_name(struct kobject *kobj, const char *name, ...)
      75             :                             __attribute__((format(printf, 2, 3)));
      76             : extern int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
      77             :                                   va_list vargs);
      78             : 
      79             : static inline const char *kobject_name(const struct kobject *kobj)
      80             : {
      81             :         return kobj->name;
      82             : }
      83             : 
      84             : extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
      85             : extern int __must_check kobject_add(struct kobject *kobj,
      86             :                                     struct kobject *parent,
      87             :                                     const char *fmt, ...);
      88             : extern int __must_check kobject_init_and_add(struct kobject *kobj,
      89             :                                              struct kobj_type *ktype,
      90             :                                              struct kobject *parent,
      91             :                                              const char *fmt, ...);
      92             : 
      93             : extern void kobject_del(struct kobject *kobj);
      94             : 
      95             : extern struct kobject * __must_check kobject_create(void);
      96             : extern struct kobject * __must_check kobject_create_and_add(const char *name,
      97             :                                                 struct kobject *parent);
      98             : 
      99             : extern int __must_check kobject_rename(struct kobject *, const char *new_name);
     100             : extern int __must_check kobject_move(struct kobject *, struct kobject *);
     101             : 
     102             : extern struct kobject *kobject_get(struct kobject *kobj);
     103             : extern void kobject_put(struct kobject *kobj);
     104             : 
     105             : extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);
     106           1 : 
     107             : struct kobj_type {
     108             :         void (*release)(struct kobject *kobj);
     109             :         struct sysfs_ops *sysfs_ops;
     110             :         struct attribute **default_attrs;
     111             : };
     112           1 : 
     113             : struct kobj_uevent_env {
     114             :         char *envp[UEVENT_NUM_ENVP];
     115             :         int envp_idx;
     116             :         char buf[UEVENT_BUFFER_SIZE];
     117             :         int buflen;
     118             : };
     119           1 : 
     120             : struct kset_uevent_ops {
     121             :         int (*filter)(struct kset *kset, struct kobject *kobj);
     122             :         const char *(*name)(struct kset *kset, struct kobject *kobj);
     123             :         int (*uevent)(struct kset *kset, struct kobject *kobj,
     124             :                       struct kobj_uevent_env *env);
     125             : };
     126             : 
     127             : struct kobj_attribute {
     128             :         struct attribute attr;
     129             :         ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
     130             :                         char *buf);
     131             :         ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
     132             :                          const char *buf, size_t count);
     133             : };
     134             : 
     135             : extern struct sysfs_ops kobj_sysfs_ops;
     136           1 : 
     137             : /**
     138             :  * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
     139             :  *
     140             :  * A kset defines a group of kobjects.  They can be individually
     141             :  * different "types" but overall these kobjects all want to be grouped
     142             :  * together and operated on in the same manner.  ksets are used to
     143             :  * define the attribute callbacks and other common events that happen to
     144             :  * a kobject.
     145             :  *
     146             :  * @list: the list of all kobjects for this kset
     147             :  * @list_lock: a lock for iterating over the kobjects
     148             :  * @kobj: the embedded kobject for this kset (recursion, isn't it fun...)
     149             :  * @uevent_ops: the set of uevent operations for this kset.  These are
     150             :  * called whenever a kobject has something happen to it so that the kset
     151             :  * can add new environment variables, or filter out the uevents if so
     152             :  * desired.
     153             :  */
     154             : struct kset {
     155             :         struct list_head list;
     156             :         spinlock_t list_lock;
     157             :         struct kobject kobj;
     158             :         struct kset_uevent_ops *uevent_ops;
     159             : };
     160             : 
     161             : extern void kset_init(struct kset *kset);
     162             : extern int __must_check kset_register(struct kset *kset);
     163             : extern void kset_unregister(struct kset *kset);
     164             : extern struct kset * __must_check kset_create_and_add(const char *name,
     165             :                                                 struct kset_uevent_ops *u,
     166             :                                                 struct kobject *parent_kobj);
     167             : 
     168             : static inline struct kset *to_kset(struct kobject *kobj)
     169             : {
     170             :         return kobj ? container_of(kobj, struct kset, kobj) : NULL;
     171             : }
     172             : 
     173             : static inline struct kset *kset_get(struct kset *k)
     174             : {
     175             :         return k ? to_kset(kobject_get(&k->kobj)) : NULL;
     176             : }
     177             : 
     178             : static inline void kset_put(struct kset *k)
     179             : {
     180             :         kobject_put(&k->kobj);
     181             : }
     182             : 
     183             : static inline struct kobj_type *get_ktype(struct kobject *kobj)
     184             : {
     185             :         return kobj->ktype;
     186             : }
     187             : 
     188             : extern struct kobject *kset_find_obj(struct kset *, const char *);
     189             : 
     190             : /* The global /sys/kernel/ kobject for people to chain off of */
     191             : extern struct kobject *kernel_kobj;
     192             : /* The global /sys/kernel/mm/ kobject for people to chain off of */
     193             : extern struct kobject *mm_kobj;
     194             : /* The global /sys/hypervisor/ kobject for people to chain off of */
     195             : extern struct kobject *hypervisor_kobj;
     196             : /* The global /sys/power/ kobject for people to chain off of */
     197             : extern struct kobject *power_kobj;
     198             : /* The global /sys/firmware/ kobject for people to chain off of */
     199             : extern struct kobject *firmware_kobj;
     200             : 
     201             : #if defined(CONFIG_HOTPLUG)
     202             : int kobject_uevent(struct kobject *kobj, enum kobject_action action);
     203             : int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
     204             :                         char *envp[]);
     205             : 
     206             : int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
     207             :         __attribute__((format (printf, 2, 3)));
     208             : 
     209             : int kobject_action_type(const char *buf, size_t count,
     210             :                         enum kobject_action *type);
     211             : #else
     212             : static inline int kobject_uevent(struct kobject *kobj,
     213             :                                  enum kobject_action action)
     214             : { return 0; }
     215             : static inline int kobject_uevent_env(struct kobject *kobj,
     216             :                                       enum kobject_action action,
     217             :                                       char *envp[])
     218             : { return 0; }
     219             : 
     220             : static inline int add_uevent_var(struct kobj_uevent_env *env,
     221             :                                  const char *format, ...)
     222             : { return 0; }
     223             : 
     224             : static inline int kobject_action_type(const char *buf, size_t count,
     225             :                                       enum kobject_action *type)
     226             : { return -EINVAL; }
     227             : #endif
     228           1 : 
     229             : #endif /* _KOBJECT_H_ */

Generated by: LCOV version 1.10