edd: add default mode CONFIG_EDD_OFF=n, override with edd={on,off}
[linux-2.6.git] / kernel / notifier.c
1 #include <linux/kdebug.h>
2 #include <linux/kprobes.h>
3 #include <linux/module.h>
4 #include <linux/notifier.h>
5 #include <linux/rcupdate.h>
6 #include <linux/vmalloc.h>
7 #include <linux/reboot.h>
8
9 /*
10  *      Notifier list for kernel code which wants to be called
11  *      at shutdown. This is used to stop any idling DMA operations
12  *      and the like.
13  */
14 BLOCKING_NOTIFIER_HEAD(reboot_notifier_list);
15
16 /*
17  *      Notifier chain core routines.  The exported routines below
18  *      are layered on top of these, with appropriate locking added.
19  */
20
21 static int notifier_chain_register(struct notifier_block **nl,
22                 struct notifier_block *n)
23 {
24         while ((*nl) != NULL) {
25                 if (n->priority > (*nl)->priority)
26                         break;
27                 nl = &((*nl)->next);
28         }
29         n->next = *nl;
30         rcu_assign_pointer(*nl, n);
31         return 0;
32 }
33
34 static int notifier_chain_cond_register(struct notifier_block **nl,
35                 struct notifier_block *n)
36 {
37         while ((*nl) != NULL) {
38                 if ((*nl) == n)
39                         return 0;
40                 if (n->priority > (*nl)->priority)
41                         break;
42                 nl = &((*nl)->next);
43         }
44         n->next = *nl;
45         rcu_assign_pointer(*nl, n);
46         return 0;
47 }
48
49 static int notifier_chain_unregister(struct notifier_block **nl,
50                 struct notifier_block *n)
51 {
52         while ((*nl) != NULL) {
53                 if ((*nl) == n) {
54                         rcu_assign_pointer(*nl, n->next);
55                         return 0;
56                 }
57                 nl = &((*nl)->next);
58         }
59         return -ENOENT;
60 }
61
62 /**
63  * notifier_call_chain - Informs the registered notifiers about an event.
64  *      @nl:            Pointer to head of the blocking notifier chain
65  *      @val:           Value passed unmodified to notifier function
66  *      @v:             Pointer passed unmodified to notifier function
67  *      @nr_to_call:    Number of notifier functions to be called. Don't care
68  *                      value of this parameter is -1.
69  *      @nr_calls:      Records the number of notifications sent. Don't care
70  *                      value of this field is NULL.
71  *      @returns:       notifier_call_chain returns the value returned by the
72  *                      last notifier function called.
73  */
74 static int __kprobes notifier_call_chain(struct notifier_block **nl,
75                                         unsigned long val, void *v,
76                                         int nr_to_call, int *nr_calls)
77 {
78         int ret = NOTIFY_DONE;
79         struct notifier_block *nb, *next_nb;
80
81         nb = rcu_dereference(*nl);
82
83         while (nb && nr_to_call) {
84                 next_nb = rcu_dereference(nb->next);
85                 ret = nb->notifier_call(nb, val, v);
86
87                 if (nr_calls)
88                         (*nr_calls)++;
89
90                 if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)
91                         break;
92                 nb = next_nb;
93                 nr_to_call--;
94         }
95         return ret;
96 }
97
98 /*
99  *      Atomic notifier chain routines.  Registration and unregistration
100  *      use a spinlock, and call_chain is synchronized by RCU (no locks).
101  */
102
103 /**
104  *      atomic_notifier_chain_register - Add notifier to an atomic notifier chain
105  *      @nh: Pointer to head of the atomic notifier chain
106  *      @n: New entry in notifier chain
107  *
108  *      Adds a notifier to an atomic notifier chain.
109  *
110  *      Currently always returns zero.
111  */
112 int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
113                 struct notifier_block *n)
114 {
115         unsigned long flags;
116         int ret;
117
118         spin_lock_irqsave(&nh->lock, flags);
119         ret = notifier_chain_register(&nh->head, n);
120         spin_unlock_irqrestore(&nh->lock, flags);
121         return ret;
122 }
123 EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);
124
125 /**
126  *      atomic_notifier_chain_unregister - Remove notifier from an atomic notifier chain
127  *      @nh: Pointer to head of the atomic notifier chain
128  *      @n: Entry to remove from notifier chain
129  *
130  *      Removes a notifier from an atomic notifier chain.
131  *
132  *      Returns zero on success or %-ENOENT on failure.
133  */
134 int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
135                 struct notifier_block *n)
136 {
137         unsigned long flags;
138         int ret;
139
140         spin_lock_irqsave(&nh->lock, flags);
141         ret = notifier_chain_unregister(&nh->head, n);
142         spin_unlock_irqrestore(&nh->lock, flags);
143         synchronize_rcu();
144         return ret;
145 }
146 EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);
147
148 /**
149  *      __atomic_notifier_call_chain - Call functions in an atomic notifier chain
150  *      @nh: Pointer to head of the atomic notifier chain
151  *      @val: Value passed unmodified to notifier function
152  *      @v: Pointer passed unmodified to notifier function
153  *      @nr_to_call: See the comment for notifier_call_chain.
154  *      @nr_calls: See the comment for notifier_call_chain.
155  *
156  *      Calls each function in a notifier chain in turn.  The functions
157  *      run in an atomic context, so they must not block.
158  *      This routine uses RCU to synchronize with changes to the chain.
159  *
160  *      If the return value of the notifier can be and'ed
161  *      with %NOTIFY_STOP_MASK then atomic_notifier_call_chain()
162  *      will return immediately, with the return value of
163  *      the notifier function which halted execution.
164  *      Otherwise the return value is the return value
165  *      of the last notifier function called.
166  */
167 int __kprobes __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
168                                         unsigned long val, void *v,
169                                         int nr_to_call, int *nr_calls)
170 {
171         int ret;
172
173         rcu_read_lock();
174         ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
175         rcu_read_unlock();
176         return ret;
177 }
178 EXPORT_SYMBOL_GPL(__atomic_notifier_call_chain);
179
180 int __kprobes atomic_notifier_call_chain(struct atomic_notifier_head *nh,
181                 unsigned long val, void *v)
182 {
183         return __atomic_notifier_call_chain(nh, val, v, -1, NULL);
184 }
185 EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);
186
187 /*
188  *      Blocking notifier chain routines.  All access to the chain is
189  *      synchronized by an rwsem.
190  */
191
192 /**
193  *      blocking_notifier_chain_register - Add notifier to a blocking notifier chain
194  *      @nh: Pointer to head of the blocking notifier chain
195  *      @n: New entry in notifier chain
196  *
197  *      Adds a notifier to a blocking notifier chain.
198  *      Must be called in process context.
199  *
200  *      Currently always returns zero.
201  */
202 int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
203                 struct notifier_block *n)
204 {
205         int ret;
206
207         /*
208          * This code gets used during boot-up, when task switching is
209          * not yet working and interrupts must remain disabled.  At
210          * such times we must not call down_write().
211          */
212         if (unlikely(system_state == SYSTEM_BOOTING))
213                 return notifier_chain_register(&nh->head, n);
214
215         down_write(&nh->rwsem);
216         ret = notifier_chain_register(&nh->head, n);
217         up_write(&nh->rwsem);
218         return ret;
219 }
220 EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);
221
222 /**
223  *      blocking_notifier_chain_cond_register - Cond add notifier to a blocking notifier chain
224  *      @nh: Pointer to head of the blocking notifier chain
225  *      @n: New entry in notifier chain
226  *
227  *      Adds a notifier to a blocking notifier chain, only if not already
228  *      present in the chain.
229  *      Must be called in process context.
230  *
231  *      Currently always returns zero.
232  */
233 int blocking_notifier_chain_cond_register(struct blocking_notifier_head *nh,
234                 struct notifier_block *n)
235 {
236         int ret;
237
238         down_write(&nh->rwsem);
239         ret = notifier_chain_cond_register(&nh->head, n);
240         up_write(&nh->rwsem);
241         return ret;
242 }
243 EXPORT_SYMBOL_GPL(blocking_notifier_chain_cond_register);
244
245 /**
246  *      blocking_notifier_chain_unregister - Remove notifier from a blocking notifier chain
247  *      @nh: Pointer to head of the blocking notifier chain
248  *      @n: Entry to remove from notifier chain
249  *
250  *      Removes a notifier from a blocking notifier chain.
251  *      Must be called from process context.
252  *
253  *      Returns zero on success or %-ENOENT on failure.
254  */
255 int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
256                 struct notifier_block *n)
257 {
258         int ret;
259
260         /*
261          * This code gets used during boot-up, when task switching is
262          * not yet working and interrupts must remain disabled.  At
263          * such times we must not call down_write().
264          */
265         if (unlikely(system_state == SYSTEM_BOOTING))
266                 return notifier_chain_unregister(&nh->head, n);
267
268         down_write(&nh->rwsem);
269         ret = notifier_chain_unregister(&nh->head, n);
270         up_write(&nh->rwsem);
271         return ret;
272 }
273 EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
274
275 /**
276  *      __blocking_notifier_call_chain - Call functions in a blocking notifier chain
277  *      @nh: Pointer to head of the blocking notifier chain
278  *      @val: Value passed unmodified to notifier function
279  *      @v: Pointer passed unmodified to notifier function
280  *      @nr_to_call: See comment for notifier_call_chain.
281  *      @nr_calls: See comment for notifier_call_chain.
282  *
283  *      Calls each function in a notifier chain in turn.  The functions
284  *      run in a process context, so they are allowed to block.
285  *
286  *      If the return value of the notifier can be and'ed
287  *      with %NOTIFY_STOP_MASK then blocking_notifier_call_chain()
288  *      will return immediately, with the return value of
289  *      the notifier function which halted execution.
290  *      Otherwise the return value is the return value
291  *      of the last notifier function called.
292  */
293 int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
294                                    unsigned long val, void *v,
295                                    int nr_to_call, int *nr_calls)
296 {
297         int ret = NOTIFY_DONE;
298
299         /*
300          * We check the head outside the lock, but if this access is
301          * racy then it does not matter what the result of the test
302          * is, we re-check the list after having taken the lock anyway:
303          */
304         if (rcu_dereference(nh->head)) {
305                 down_read(&nh->rwsem);
306                 ret = notifier_call_chain(&nh->head, val, v, nr_to_call,
307                                         nr_calls);
308                 up_read(&nh->rwsem);
309         }
310         return ret;
311 }
312 EXPORT_SYMBOL_GPL(__blocking_notifier_call_chain);
313
314 int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
315                 unsigned long val, void *v)
316 {
317         return __blocking_notifier_call_chain(nh, val, v, -1, NULL);
318 }
319 EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);
320
321 /*
322  *      Raw notifier chain routines.  There is no protection;
323  *      the caller must provide it.  Use at your own risk!
324  */
325
326 /**
327  *      raw_notifier_chain_register - Add notifier to a raw notifier chain
328  *      @nh: Pointer to head of the raw notifier chain
329  *      @n: New entry in notifier chain
330  *
331  *      Adds a notifier to a raw notifier chain.
332  *      All locking must be provided by the caller.
333  *
334  *      Currently always returns zero.
335  */
336 int raw_notifier_chain_register(struct raw_notifier_head *nh,
337                 struct notifier_block *n)
338 {
339         return notifier_chain_register(&nh->head, n);
340 }
341 EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
342
343 /**
344  *      raw_notifier_chain_unregister - Remove notifier from a raw notifier chain
345  *      @nh: Pointer to head of the raw notifier chain
346  *      @n: Entry to remove from notifier chain
347  *
348  *      Removes a notifier from a raw notifier chain.
349  *      All locking must be provided by the caller.
350  *
351  *      Returns zero on success or %-ENOENT on failure.
352  */
353 int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
354                 struct notifier_block *n)
355 {
356         return notifier_chain_unregister(&nh->head, n);
357 }
358 EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
359
360 /**
361  *      __raw_notifier_call_chain - Call functions in a raw notifier chain
362  *      @nh: Pointer to head of the raw notifier chain
363  *      @val: Value passed unmodified to notifier function
364  *      @v: Pointer passed unmodified to notifier function
365  *      @nr_to_call: See comment for notifier_call_chain.
366  *      @nr_calls: See comment for notifier_call_chain
367  *
368  *      Calls each function in a notifier chain in turn.  The functions
369  *      run in an undefined context.
370  *      All locking must be provided by the caller.
371  *
372  *      If the return value of the notifier can be and'ed
373  *      with %NOTIFY_STOP_MASK then raw_notifier_call_chain()
374  *      will return immediately, with the return value of
375  *      the notifier function which halted execution.
376  *      Otherwise the return value is the return value
377  *      of the last notifier function called.
378  */
379 int __raw_notifier_call_chain(struct raw_notifier_head *nh,
380                               unsigned long val, void *v,
381                               int nr_to_call, int *nr_calls)
382 {
383         return notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
384 }
385 EXPORT_SYMBOL_GPL(__raw_notifier_call_chain);
386
387 int raw_notifier_call_chain(struct raw_notifier_head *nh,
388                 unsigned long val, void *v)
389 {
390         return __raw_notifier_call_chain(nh, val, v, -1, NULL);
391 }
392 EXPORT_SYMBOL_GPL(raw_notifier_call_chain);
393
394 /*
395  *      SRCU notifier chain routines.    Registration and unregistration
396  *      use a mutex, and call_chain is synchronized by SRCU (no locks).
397  */
398
399 /**
400  *      srcu_notifier_chain_register - Add notifier to an SRCU notifier chain
401  *      @nh: Pointer to head of the SRCU notifier chain
402  *      @n: New entry in notifier chain
403  *
404  *      Adds a notifier to an SRCU notifier chain.
405  *      Must be called in process context.
406  *
407  *      Currently always returns zero.
408  */
409 int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
410                 struct notifier_block *n)
411 {
412         int ret;
413
414         /*
415          * This code gets used during boot-up, when task switching is
416          * not yet working and interrupts must remain disabled.  At
417          * such times we must not call mutex_lock().
418          */
419         if (unlikely(system_state == SYSTEM_BOOTING))
420                 return notifier_chain_register(&nh->head, n);
421
422         mutex_lock(&nh->mutex);
423         ret = notifier_chain_register(&nh->head, n);
424         mutex_unlock(&nh->mutex);
425         return ret;
426 }
427 EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);
428
429 /**
430  *      srcu_notifier_chain_unregister - Remove notifier from an SRCU notifier chain
431  *      @nh: Pointer to head of the SRCU notifier chain
432  *      @n: Entry to remove from notifier chain
433  *
434  *      Removes a notifier from an SRCU notifier chain.
435  *      Must be called from process context.
436  *
437  *      Returns zero on success or %-ENOENT on failure.
438  */
439 int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
440                 struct notifier_block *n)
441 {
442         int ret;
443
444         /*
445          * This code gets used during boot-up, when task switching is
446          * not yet working and interrupts must remain disabled.  At
447          * such times we must not call mutex_lock().
448          */
449         if (unlikely(system_state == SYSTEM_BOOTING))
450                 return notifier_chain_unregister(&nh->head, n);
451
452         mutex_lock(&nh->mutex);
453         ret = notifier_chain_unregister(&nh->head, n);
454         mutex_unlock(&nh->mutex);
455         synchronize_srcu(&nh->srcu);
456         return ret;
457 }
458 EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);
459
460 /**
461  *      __srcu_notifier_call_chain - Call functions in an SRCU notifier chain
462  *      @nh: Pointer to head of the SRCU notifier chain
463  *      @val: Value passed unmodified to notifier function
464  *      @v: Pointer passed unmodified to notifier function
465  *      @nr_to_call: See comment for notifier_call_chain.
466  *      @nr_calls: See comment for notifier_call_chain
467  *
468  *      Calls each function in a notifier chain in turn.  The functions
469  *      run in a process context, so they are allowed to block.
470  *
471  *      If the return value of the notifier can be and'ed
472  *      with %NOTIFY_STOP_MASK then srcu_notifier_call_chain()
473  *      will return immediately, with the return value of
474  *      the notifier function which halted execution.
475  *      Otherwise the return value is the return value
476  *      of the last notifier function called.
477  */
478 int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
479                                unsigned long val, void *v,
480                                int nr_to_call, int *nr_calls)
481 {
482         int ret;
483         int idx;
484
485         idx = srcu_read_lock(&nh->srcu);
486         ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
487         srcu_read_unlock(&nh->srcu, idx);
488         return ret;
489 }
490 EXPORT_SYMBOL_GPL(__srcu_notifier_call_chain);
491
492 int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
493                 unsigned long val, void *v)
494 {
495         return __srcu_notifier_call_chain(nh, val, v, -1, NULL);
496 }
497 EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);
498
499 /**
500  *      srcu_init_notifier_head - Initialize an SRCU notifier head
501  *      @nh: Pointer to head of the srcu notifier chain
502  *
503  *      Unlike other sorts of notifier heads, SRCU notifier heads require
504  *      dynamic initialization.  Be sure to call this routine before
505  *      calling any of the other SRCU notifier routines for this head.
506  *
507  *      If an SRCU notifier head is deallocated, it must first be cleaned
508  *      up by calling srcu_cleanup_notifier_head().  Otherwise the head's
509  *      per-cpu data (used by the SRCU mechanism) will leak.
510  */
511 void srcu_init_notifier_head(struct srcu_notifier_head *nh)
512 {
513         mutex_init(&nh->mutex);
514         if (init_srcu_struct(&nh->srcu) < 0)
515                 BUG();
516         nh->head = NULL;
517 }
518 EXPORT_SYMBOL_GPL(srcu_init_notifier_head);
519
520 /**
521  *      register_reboot_notifier - Register function to be called at reboot time
522  *      @nb: Info about notifier function to be called
523  *
524  *      Registers a function with the list of functions
525  *      to be called at reboot time.
526  *
527  *      Currently always returns zero, as blocking_notifier_chain_register()
528  *      always returns zero.
529  */
530 int register_reboot_notifier(struct notifier_block *nb)
531 {
532         return blocking_notifier_chain_register(&reboot_notifier_list, nb);
533 }
534 EXPORT_SYMBOL(register_reboot_notifier);
535
536 /**
537  *      unregister_reboot_notifier - Unregister previously registered reboot notifier
538  *      @nb: Hook to be unregistered
539  *
540  *      Unregisters a previously registered reboot
541  *      notifier function.
542  *
543  *      Returns zero on success, or %-ENOENT on failure.
544  */
545 int unregister_reboot_notifier(struct notifier_block *nb)
546 {
547         return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
548 }
549 EXPORT_SYMBOL(unregister_reboot_notifier);
550
551 static ATOMIC_NOTIFIER_HEAD(die_chain);
552
553 int notify_die(enum die_val val, const char *str,
554                struct pt_regs *regs, long err, int trap, int sig)
555 {
556         struct die_args args = {
557                 .regs   = regs,
558                 .str    = str,
559                 .err    = err,
560                 .trapnr = trap,
561                 .signr  = sig,
562
563         };
564         return atomic_notifier_call_chain(&die_chain, val, &args);
565 }
566
567 int register_die_notifier(struct notifier_block *nb)
568 {
569         vmalloc_sync_all();
570         return atomic_notifier_chain_register(&die_chain, nb);
571 }
572 EXPORT_SYMBOL_GPL(register_die_notifier);
573
574 int unregister_die_notifier(struct notifier_block *nb)
575 {
576         return atomic_notifier_chain_unregister(&die_chain, nb);
577 }
578 EXPORT_SYMBOL_GPL(unregister_die_notifier);