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