~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/notifier.h

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *      Routines to manage notifier chains for passing status changes to any
  3  *      interested routines. We need this instead of hard coded call lists so
  4  *      that modules can poke their nose into the innards. The network devices
  5  *      needed them so here they are for the rest of you.
  6  *
  7  *                              Alan Cox <Alan.Cox@linux.org>
  8  */
  9  
 10 #ifndef _LINUX_NOTIFIER_H
 11 #define _LINUX_NOTIFIER_H
 12 #include <linux/errno.h>
 13 #include <linux/mutex.h>
 14 #include <linux/rwsem.h>
 15 #include <linux/srcu.h>
 16 
 17 /*
 18  * Notifier chains are of four types:
 19  *
 20  *      Atomic notifier chains: Chain callbacks run in interrupt/atomic
 21  *              context. Callouts are not allowed to block.
 22  *      Blocking notifier chains: Chain callbacks run in process context.
 23  *              Callouts are allowed to block.
 24  *      Raw notifier chains: There are no restrictions on callbacks,
 25  *              registration, or unregistration.  All locking and protection
 26  *              must be provided by the caller.
 27  *      SRCU notifier chains: A variant of blocking notifier chains, with
 28  *              the same restrictions.
 29  *
 30  * atomic_notifier_chain_register() may be called from an atomic context,
 31  * but blocking_notifier_chain_register() and srcu_notifier_chain_register()
 32  * must be called from a process context.  Ditto for the corresponding
 33  * _unregister() routines.
 34  *
 35  * atomic_notifier_chain_unregister(), blocking_notifier_chain_unregister(),
 36  * and srcu_notifier_chain_unregister() _must not_ be called from within
 37  * the call chain.
 38  *
 39  * SRCU notifier chains are an alternative form of blocking notifier chains.
 40  * They use SRCU (Sleepable Read-Copy Update) instead of rw-semaphores for
 41  * protection of the chain links.  This means there is _very_ low overhead
 42  * in srcu_notifier_call_chain(): no cache bounces and no memory barriers.
 43  * As compensation, srcu_notifier_chain_unregister() is rather expensive.
 44  * SRCU notifier chains should be used when the chain will be called very
 45  * often but notifier_blocks will seldom be removed.  Also, SRCU notifier
 46  * chains are slightly more difficult to use because they require special
 47  * runtime initialization.
 48  */
 49 
 50 struct notifier_block;
 51 
 52 typedef int (*notifier_fn_t)(struct notifier_block *nb,
 53                         unsigned long action, void *data);
 54 
 55 struct notifier_block {
 56         notifier_fn_t notifier_call;
 57         struct notifier_block __rcu *next;
 58         int priority;
 59 };
 60 
 61 struct atomic_notifier_head {
 62         spinlock_t lock;
 63         struct notifier_block __rcu *head;
 64 };
 65 
 66 struct blocking_notifier_head {
 67         struct rw_semaphore rwsem;
 68         struct notifier_block __rcu *head;
 69 };
 70 
 71 struct raw_notifier_head {
 72         struct notifier_block __rcu *head;
 73 };
 74 
 75 struct srcu_notifier_head {
 76         struct mutex mutex;
 77         struct srcu_struct srcu;
 78         struct notifier_block __rcu *head;
 79 };
 80 
 81 #define ATOMIC_INIT_NOTIFIER_HEAD(name) do {    \
 82                 spin_lock_init(&(name)->lock);  \
 83                 (name)->head = NULL;            \
 84         } while (0)
 85 #define BLOCKING_INIT_NOTIFIER_HEAD(name) do {  \
 86                 init_rwsem(&(name)->rwsem);     \
 87                 (name)->head = NULL;            \
 88         } while (0)
 89 #define RAW_INIT_NOTIFIER_HEAD(name) do {       \
 90                 (name)->head = NULL;            \
 91         } while (0)
 92 
 93 /* srcu_notifier_heads must be initialized and cleaned up dynamically */
 94 extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
 95 #define srcu_cleanup_notifier_head(name)        \
 96                 cleanup_srcu_struct(&(name)->srcu);
 97 
 98 #define ATOMIC_NOTIFIER_INIT(name) {                            \
 99                 .lock = __SPIN_LOCK_UNLOCKED(name.lock),        \
100                 .head = NULL }
101 #define BLOCKING_NOTIFIER_INIT(name) {                          \
102                 .rwsem = __RWSEM_INITIALIZER((name).rwsem),     \
103                 .head = NULL }
104 #define RAW_NOTIFIER_INIT(name) {                               \
105                 .head = NULL }
106 /* srcu_notifier_heads cannot be initialized statically */
107 
108 #define ATOMIC_NOTIFIER_HEAD(name)                              \
109         struct atomic_notifier_head name =                      \
110                 ATOMIC_NOTIFIER_INIT(name)
111 #define BLOCKING_NOTIFIER_HEAD(name)                            \
112         struct blocking_notifier_head name =                    \
113                 BLOCKING_NOTIFIER_INIT(name)
114 #define RAW_NOTIFIER_HEAD(name)                                 \
115         struct raw_notifier_head name =                         \
116                 RAW_NOTIFIER_INIT(name)
117 
118 #ifdef __KERNEL__
119 
120 extern int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
121                 struct notifier_block *nb);
122 extern int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
123                 struct notifier_block *nb);
124 extern int raw_notifier_chain_register(struct raw_notifier_head *nh,
125                 struct notifier_block *nb);
126 extern int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
127                 struct notifier_block *nb);
128 
129 extern int blocking_notifier_chain_cond_register(
130                 struct blocking_notifier_head *nh,
131                 struct notifier_block *nb);
132 
133 extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
134                 struct notifier_block *nb);
135 extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
136                 struct notifier_block *nb);
137 extern int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
138                 struct notifier_block *nb);
139 extern int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
140                 struct notifier_block *nb);
141 
142 extern int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
143                 unsigned long val, void *v);
144 extern int __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
145         unsigned long val, void *v, int nr_to_call, int *nr_calls);
146 extern int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
147                 unsigned long val, void *v);
148 extern int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
149         unsigned long val, void *v, int nr_to_call, int *nr_calls);
150 extern int raw_notifier_call_chain(struct raw_notifier_head *nh,
151                 unsigned long val, void *v);
152 extern int __raw_notifier_call_chain(struct raw_notifier_head *nh,
153         unsigned long val, void *v, int nr_to_call, int *nr_calls);
154 extern int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
155                 unsigned long val, void *v);
156 extern int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
157         unsigned long val, void *v, int nr_to_call, int *nr_calls);
158 
159 #define NOTIFY_DONE             0x0000          /* Don't care */
160 #define NOTIFY_OK               0x0001          /* Suits me */
161 #define NOTIFY_STOP_MASK        0x8000          /* Don't call further */
162 #define NOTIFY_BAD              (NOTIFY_STOP_MASK|0x0002)
163                                                 /* Bad/Veto action */
164 /*
165  * Clean way to return from the notifier and stop further calls.
166  */
167 #define NOTIFY_STOP             (NOTIFY_OK|NOTIFY_STOP_MASK)
168 
169 /* Encapsulate (negative) errno value (in particular, NOTIFY_BAD <=> EPERM). */
170 static inline int notifier_from_errno(int err)
171 {
172         if (err)
173                 return NOTIFY_STOP_MASK | (NOTIFY_OK - err);
174 
175         return NOTIFY_OK;
176 }
177 
178 /* Restore (negative) errno value from notify return value. */
179 static inline int notifier_to_errno(int ret)
180 {
181         ret &= ~NOTIFY_STOP_MASK;
182         return ret > NOTIFY_OK ? NOTIFY_OK - ret : 0;
183 }
184 
185 /*
186  *      Declared notifiers so far. I can imagine quite a few more chains
187  *      over time (eg laptop power reset chains, reboot chain (to clean 
188  *      device units up), device [un]mount chain, module load/unload chain,
189  *      low memory chain, screenblank chain (for plug in modular screenblankers) 
190  *      VC switch chains (for loadable kernel svgalib VC switch helpers) etc...
191  */
192  
193 /* CPU notfiers are defined in include/linux/cpu.h. */
194 
195 /* netdevice notifiers are defined in include/linux/netdevice.h */
196 
197 /* reboot notifiers are defined in include/linux/reboot.h. */
198 
199 /* Hibernation and suspend events are defined in include/linux/suspend.h. */
200 
201 /* Virtual Terminal events are defined in include/linux/vt.h. */
202 
203 #define NETLINK_URELEASE        0x0001  /* Unicast netlink socket released */
204 
205 /* Console keyboard events.
206  * Note: KBD_KEYCODE is always sent before KBD_UNBOUND_KEYCODE, KBD_UNICODE and
207  * KBD_KEYSYM. */
208 #define KBD_KEYCODE             0x0001 /* Keyboard keycode, called before any other */
209 #define KBD_UNBOUND_KEYCODE     0x0002 /* Keyboard keycode which is not bound to any other */
210 #define KBD_UNICODE             0x0003 /* Keyboard unicode */
211 #define KBD_KEYSYM              0x0004 /* Keyboard keysym */
212 #define KBD_POST_KEYSYM         0x0005 /* Called after keyboard keysym interpretation */
213 
214 extern struct blocking_notifier_head reboot_notifier_list;
215 
216 #endif /* __KERNEL__ */
217 #endif /* _LINUX_NOTIFIER_H */
218 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp