KEYS: add missing permission check for request_key() destination
[linux/fpc-iii.git] / kernel / notifier.c
blob4803da6eab62f182354707c10f48be35a8b54fb5
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>
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.
14 BLOCKING_NOTIFIER_HEAD(reboot_notifier_list);
17 * Notifier chain core routines. The exported routines below
18 * are layered on top of these, with appropriate locking added.
21 static int notifier_chain_register(struct notifier_block **nl,
22 struct notifier_block *n)
24 while ((*nl) != NULL) {
25 if (n->priority > (*nl)->priority)
26 break;
27 nl = &((*nl)->next);
29 n->next = *nl;
30 rcu_assign_pointer(*nl, n);
31 return 0;
34 static int notifier_chain_cond_register(struct notifier_block **nl,
35 struct notifier_block *n)
37 while ((*nl) != NULL) {
38 if ((*nl) == n)
39 return 0;
40 if (n->priority > (*nl)->priority)
41 break;
42 nl = &((*nl)->next);
44 n->next = *nl;
45 rcu_assign_pointer(*nl, n);
46 return 0;
49 static int notifier_chain_unregister(struct notifier_block **nl,
50 struct notifier_block *n)
52 while ((*nl) != NULL) {
53 if ((*nl) == n) {
54 rcu_assign_pointer(*nl, n->next);
55 return 0;
57 nl = &((*nl)->next);
59 return -ENOENT;
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.
74 static int notifier_call_chain(struct notifier_block **nl,
75 unsigned long val, void *v,
76 int nr_to_call, int *nr_calls)
78 int ret = NOTIFY_DONE;
79 struct notifier_block *nb, *next_nb;
81 nb = rcu_dereference_raw(*nl);
83 while (nb && nr_to_call) {
84 next_nb = rcu_dereference_raw(nb->next);
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;
92 #endif
93 ret = nb->notifier_call(nb, val, v);
95 if (nr_calls)
96 (*nr_calls)++;
98 if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)
99 break;
100 nb = next_nb;
101 nr_to_call--;
103 return ret;
105 NOKPROBE_SYMBOL(notifier_call_chain);
108 * Atomic notifier chain routines. Registration and unregistration
109 * use a spinlock, and call_chain is synchronized by RCU (no locks).
113 * atomic_notifier_chain_register - Add notifier to an atomic notifier chain
114 * @nh: Pointer to head of the atomic notifier chain
115 * @n: New entry in notifier chain
117 * Adds a notifier to an atomic notifier chain.
119 * Currently always returns zero.
121 int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
122 struct notifier_block *n)
124 unsigned long flags;
125 int ret;
127 spin_lock_irqsave(&nh->lock, flags);
128 ret = notifier_chain_register(&nh->head, n);
129 spin_unlock_irqrestore(&nh->lock, flags);
130 return ret;
132 EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);
135 * atomic_notifier_chain_unregister - Remove notifier from an atomic notifier chain
136 * @nh: Pointer to head of the atomic notifier chain
137 * @n: Entry to remove from notifier chain
139 * Removes a notifier from an atomic notifier chain.
141 * Returns zero on success or %-ENOENT on failure.
143 int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
144 struct notifier_block *n)
146 unsigned long flags;
147 int ret;
149 spin_lock_irqsave(&nh->lock, flags);
150 ret = notifier_chain_unregister(&nh->head, n);
151 spin_unlock_irqrestore(&nh->lock, flags);
152 synchronize_rcu();
153 return ret;
155 EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);
158 * __atomic_notifier_call_chain - Call functions in an atomic notifier chain
159 * @nh: Pointer to head of the atomic notifier chain
160 * @val: Value passed unmodified to notifier function
161 * @v: Pointer passed unmodified to notifier function
162 * @nr_to_call: See the comment for notifier_call_chain.
163 * @nr_calls: See the comment for notifier_call_chain.
165 * Calls each function in a notifier chain in turn. The functions
166 * run in an atomic context, so they must not block.
167 * This routine uses RCU to synchronize with changes to the chain.
169 * If the return value of the notifier can be and'ed
170 * with %NOTIFY_STOP_MASK then atomic_notifier_call_chain()
171 * will return immediately, with the return value of
172 * the notifier function which halted execution.
173 * Otherwise the return value is the return value
174 * of the last notifier function called.
176 int __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
177 unsigned long val, void *v,
178 int nr_to_call, int *nr_calls)
180 int ret;
182 rcu_read_lock();
183 ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
184 rcu_read_unlock();
185 return ret;
187 EXPORT_SYMBOL_GPL(__atomic_notifier_call_chain);
188 NOKPROBE_SYMBOL(__atomic_notifier_call_chain);
190 int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
191 unsigned long val, void *v)
193 return __atomic_notifier_call_chain(nh, val, v, -1, NULL);
195 EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);
196 NOKPROBE_SYMBOL(atomic_notifier_call_chain);
199 * Blocking notifier chain routines. All access to the chain is
200 * synchronized by an rwsem.
204 * blocking_notifier_chain_register - Add notifier to a blocking notifier chain
205 * @nh: Pointer to head of the blocking notifier chain
206 * @n: New entry in notifier chain
208 * Adds a notifier to a blocking notifier chain.
209 * Must be called in process context.
211 * Currently always returns zero.
213 int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
214 struct notifier_block *n)
216 int ret;
219 * This code gets used during boot-up, when task switching is
220 * not yet working and interrupts must remain disabled. At
221 * such times we must not call down_write().
223 if (unlikely(system_state == SYSTEM_BOOTING))
224 return notifier_chain_register(&nh->head, n);
226 down_write(&nh->rwsem);
227 ret = notifier_chain_register(&nh->head, n);
228 up_write(&nh->rwsem);
229 return ret;
231 EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);
234 * blocking_notifier_chain_cond_register - Cond add notifier to a blocking notifier chain
235 * @nh: Pointer to head of the blocking notifier chain
236 * @n: New entry in notifier chain
238 * Adds a notifier to a blocking notifier chain, only if not already
239 * present in the chain.
240 * Must be called in process context.
242 * Currently always returns zero.
244 int blocking_notifier_chain_cond_register(struct blocking_notifier_head *nh,
245 struct notifier_block *n)
247 int ret;
249 down_write(&nh->rwsem);
250 ret = notifier_chain_cond_register(&nh->head, n);
251 up_write(&nh->rwsem);
252 return ret;
254 EXPORT_SYMBOL_GPL(blocking_notifier_chain_cond_register);
257 * blocking_notifier_chain_unregister - Remove notifier from a blocking notifier chain
258 * @nh: Pointer to head of the blocking notifier chain
259 * @n: Entry to remove from notifier chain
261 * Removes a notifier from a blocking notifier chain.
262 * Must be called from process context.
264 * Returns zero on success or %-ENOENT on failure.
266 int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
267 struct notifier_block *n)
269 int ret;
272 * This code gets used during boot-up, when task switching is
273 * not yet working and interrupts must remain disabled. At
274 * such times we must not call down_write().
276 if (unlikely(system_state == SYSTEM_BOOTING))
277 return notifier_chain_unregister(&nh->head, n);
279 down_write(&nh->rwsem);
280 ret = notifier_chain_unregister(&nh->head, n);
281 up_write(&nh->rwsem);
282 return ret;
284 EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
287 * __blocking_notifier_call_chain - Call functions in a blocking notifier chain
288 * @nh: Pointer to head of the blocking notifier chain
289 * @val: Value passed unmodified to notifier function
290 * @v: Pointer passed unmodified to notifier function
291 * @nr_to_call: See comment for notifier_call_chain.
292 * @nr_calls: See comment for notifier_call_chain.
294 * Calls each function in a notifier chain in turn. The functions
295 * run in a process context, so they are allowed to block.
297 * If the return value of the notifier can be and'ed
298 * with %NOTIFY_STOP_MASK then blocking_notifier_call_chain()
299 * will return immediately, with the return value of
300 * the notifier function which halted execution.
301 * Otherwise the return value is the return value
302 * of the last notifier function called.
304 int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
305 unsigned long val, void *v,
306 int nr_to_call, int *nr_calls)
308 int ret = NOTIFY_DONE;
311 * We check the head outside the lock, but if this access is
312 * racy then it does not matter what the result of the test
313 * is, we re-check the list after having taken the lock anyway:
315 if (rcu_access_pointer(nh->head)) {
316 down_read(&nh->rwsem);
317 ret = notifier_call_chain(&nh->head, val, v, nr_to_call,
318 nr_calls);
319 up_read(&nh->rwsem);
321 return ret;
323 EXPORT_SYMBOL_GPL(__blocking_notifier_call_chain);
325 int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
326 unsigned long val, void *v)
328 return __blocking_notifier_call_chain(nh, val, v, -1, NULL);
330 EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);
333 * Raw notifier chain routines. There is no protection;
334 * the caller must provide it. Use at your own risk!
338 * raw_notifier_chain_register - Add notifier to a raw notifier chain
339 * @nh: Pointer to head of the raw notifier chain
340 * @n: New entry in notifier chain
342 * Adds a notifier to a raw notifier chain.
343 * All locking must be provided by the caller.
345 * Currently always returns zero.
347 int raw_notifier_chain_register(struct raw_notifier_head *nh,
348 struct notifier_block *n)
350 return notifier_chain_register(&nh->head, n);
352 EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
355 * raw_notifier_chain_unregister - Remove notifier from a raw notifier chain
356 * @nh: Pointer to head of the raw notifier chain
357 * @n: Entry to remove from notifier chain
359 * Removes a notifier from a raw notifier chain.
360 * All locking must be provided by the caller.
362 * Returns zero on success or %-ENOENT on failure.
364 int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
365 struct notifier_block *n)
367 return notifier_chain_unregister(&nh->head, n);
369 EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
372 * __raw_notifier_call_chain - Call functions in a raw notifier chain
373 * @nh: Pointer to head of the raw notifier chain
374 * @val: Value passed unmodified to notifier function
375 * @v: Pointer passed unmodified to notifier function
376 * @nr_to_call: See comment for notifier_call_chain.
377 * @nr_calls: See comment for notifier_call_chain
379 * Calls each function in a notifier chain in turn. The functions
380 * run in an undefined context.
381 * All locking must be provided by the caller.
383 * If the return value of the notifier can be and'ed
384 * with %NOTIFY_STOP_MASK then raw_notifier_call_chain()
385 * will return immediately, with the return value of
386 * the notifier function which halted execution.
387 * Otherwise the return value is the return value
388 * of the last notifier function called.
390 int __raw_notifier_call_chain(struct raw_notifier_head *nh,
391 unsigned long val, void *v,
392 int nr_to_call, int *nr_calls)
394 return notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
396 EXPORT_SYMBOL_GPL(__raw_notifier_call_chain);
398 int raw_notifier_call_chain(struct raw_notifier_head *nh,
399 unsigned long val, void *v)
401 return __raw_notifier_call_chain(nh, val, v, -1, NULL);
403 EXPORT_SYMBOL_GPL(raw_notifier_call_chain);
406 * SRCU notifier chain routines. Registration and unregistration
407 * use a mutex, and call_chain is synchronized by SRCU (no locks).
411 * srcu_notifier_chain_register - Add notifier to an SRCU notifier chain
412 * @nh: Pointer to head of the SRCU notifier chain
413 * @n: New entry in notifier chain
415 * Adds a notifier to an SRCU notifier chain.
416 * Must be called in process context.
418 * Currently always returns zero.
420 int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
421 struct notifier_block *n)
423 int ret;
426 * This code gets used during boot-up, when task switching is
427 * not yet working and interrupts must remain disabled. At
428 * such times we must not call mutex_lock().
430 if (unlikely(system_state == SYSTEM_BOOTING))
431 return notifier_chain_register(&nh->head, n);
433 mutex_lock(&nh->mutex);
434 ret = notifier_chain_register(&nh->head, n);
435 mutex_unlock(&nh->mutex);
436 return ret;
438 EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);
441 * srcu_notifier_chain_unregister - Remove notifier from an SRCU notifier chain
442 * @nh: Pointer to head of the SRCU notifier chain
443 * @n: Entry to remove from notifier chain
445 * Removes a notifier from an SRCU notifier chain.
446 * Must be called from process context.
448 * Returns zero on success or %-ENOENT on failure.
450 int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
451 struct notifier_block *n)
453 int ret;
456 * This code gets used during boot-up, when task switching is
457 * not yet working and interrupts must remain disabled. At
458 * such times we must not call mutex_lock().
460 if (unlikely(system_state == SYSTEM_BOOTING))
461 return notifier_chain_unregister(&nh->head, n);
463 mutex_lock(&nh->mutex);
464 ret = notifier_chain_unregister(&nh->head, n);
465 mutex_unlock(&nh->mutex);
466 synchronize_srcu(&nh->srcu);
467 return ret;
469 EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);
472 * __srcu_notifier_call_chain - Call functions in an SRCU notifier chain
473 * @nh: Pointer to head of the SRCU notifier chain
474 * @val: Value passed unmodified to notifier function
475 * @v: Pointer passed unmodified to notifier function
476 * @nr_to_call: See comment for notifier_call_chain.
477 * @nr_calls: See comment for notifier_call_chain
479 * Calls each function in a notifier chain in turn. The functions
480 * run in a process context, so they are allowed to block.
482 * If the return value of the notifier can be and'ed
483 * with %NOTIFY_STOP_MASK then srcu_notifier_call_chain()
484 * will return immediately, with the return value of
485 * the notifier function which halted execution.
486 * Otherwise the return value is the return value
487 * of the last notifier function called.
489 int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
490 unsigned long val, void *v,
491 int nr_to_call, int *nr_calls)
493 int ret;
494 int idx;
496 idx = srcu_read_lock(&nh->srcu);
497 ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
498 srcu_read_unlock(&nh->srcu, idx);
499 return ret;
501 EXPORT_SYMBOL_GPL(__srcu_notifier_call_chain);
503 int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
504 unsigned long val, void *v)
506 return __srcu_notifier_call_chain(nh, val, v, -1, NULL);
508 EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);
511 * srcu_init_notifier_head - Initialize an SRCU notifier head
512 * @nh: Pointer to head of the srcu notifier chain
514 * Unlike other sorts of notifier heads, SRCU notifier heads require
515 * dynamic initialization. Be sure to call this routine before
516 * calling any of the other SRCU notifier routines for this head.
518 * If an SRCU notifier head is deallocated, it must first be cleaned
519 * up by calling srcu_cleanup_notifier_head(). Otherwise the head's
520 * per-cpu data (used by the SRCU mechanism) will leak.
522 void srcu_init_notifier_head(struct srcu_notifier_head *nh)
524 mutex_init(&nh->mutex);
525 if (init_srcu_struct(&nh->srcu) < 0)
526 BUG();
527 nh->head = NULL;
529 EXPORT_SYMBOL_GPL(srcu_init_notifier_head);
531 static ATOMIC_NOTIFIER_HEAD(die_chain);
533 int notrace notify_die(enum die_val val, const char *str,
534 struct pt_regs *regs, long err, int trap, int sig)
536 struct die_args args = {
537 .regs = regs,
538 .str = str,
539 .err = err,
540 .trapnr = trap,
541 .signr = sig,
544 return atomic_notifier_call_chain(&die_chain, val, &args);
546 NOKPROBE_SYMBOL(notify_die);
548 int register_die_notifier(struct notifier_block *nb)
550 vmalloc_sync_all();
551 return atomic_notifier_chain_register(&die_chain, nb);
553 EXPORT_SYMBOL_GPL(register_die_notifier);
555 int unregister_die_notifier(struct notifier_block *nb)
557 return atomic_notifier_chain_unregister(&die_chain, nb);
559 EXPORT_SYMBOL_GPL(unregister_die_notifier);