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 */
14BLOCKING_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
21static 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
34static 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
49static 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 */
74static int 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}
105NOKPROBE_SYMBOL(notifier_call_chain);
106
107/*
108 *	Atomic notifier chain routines.  Registration and unregistration
109 *	use a spinlock, and call_chain is synchronized by RCU (no locks).
110 */
111
112/**
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
116 *
117 *	Adds a notifier to an atomic notifier chain.
118 *
119 *	Currently always returns zero.
120 */
121int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
122		struct notifier_block *n)
123{
124	unsigned long flags;
125	int ret;
126
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;
131}
132EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);
133
134/**
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
138 *
139 *	Removes a notifier from an atomic notifier chain.
140 *
141 *	Returns zero on success or %-ENOENT on failure.
142 */
143int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
144		struct notifier_block *n)
145{
146	unsigned long flags;
147	int ret;
148
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;
154}
155EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);
156
157/**
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.
164 *
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.
168 *
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.
175 */
176int __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
177				 unsigned long val, void *v,
178				 int nr_to_call, int *nr_calls)
179{
180	int ret;
181
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;
186}
187EXPORT_SYMBOL_GPL(__atomic_notifier_call_chain);
188NOKPROBE_SYMBOL(__atomic_notifier_call_chain);
189
190int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
191			       unsigned long val, void *v)
192{
193	return __atomic_notifier_call_chain(nh, val, v, -1, NULL);
194}
195EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);
196NOKPROBE_SYMBOL(atomic_notifier_call_chain);
197
198/*
199 *	Blocking notifier chain routines.  All access to the chain is
200 *	synchronized by an rwsem.
201 */
202
203/**
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
207 *
208 *	Adds a notifier to a blocking notifier chain.
209 *	Must be called in process context.
210 *
211 *	Currently always returns zero.
212 */
213int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
214		struct notifier_block *n)
215{
216	int ret;
217
218	/*
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().
222	 */
223	if (unlikely(system_state == SYSTEM_BOOTING))
224		return notifier_chain_register(&nh->head, n);
225
226	down_write(&nh->rwsem);
227	ret = notifier_chain_register(&nh->head, n);
228	up_write(&nh->rwsem);
229	return ret;
230}
231EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);
232
233/**
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
237 *
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.
241 *
242 *	Currently always returns zero.
243 */
244int blocking_notifier_chain_cond_register(struct blocking_notifier_head *nh,
245		struct notifier_block *n)
246{
247	int ret;
248
249	down_write(&nh->rwsem);
250	ret = notifier_chain_cond_register(&nh->head, n);
251	up_write(&nh->rwsem);
252	return ret;
253}
254EXPORT_SYMBOL_GPL(blocking_notifier_chain_cond_register);
255
256/**
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
260 *
261 *	Removes a notifier from a blocking notifier chain.
262 *	Must be called from process context.
263 *
264 *	Returns zero on success or %-ENOENT on failure.
265 */
266int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
267		struct notifier_block *n)
268{
269	int ret;
270
271	/*
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().
275	 */
276	if (unlikely(system_state == SYSTEM_BOOTING))
277		return notifier_chain_unregister(&nh->head, n);
278
279	down_write(&nh->rwsem);
280	ret = notifier_chain_unregister(&nh->head, n);
281	up_write(&nh->rwsem);
282	return ret;
283}
284EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
285
286/**
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.
293 *
294 *	Calls each function in a notifier chain in turn.  The functions
295 *	run in a process context, so they are allowed to block.
296 *
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.
303 */
304int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
305				   unsigned long val, void *v,
306				   int nr_to_call, int *nr_calls)
307{
308	int ret = NOTIFY_DONE;
309
310	/*
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:
314	 */
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);
320	}
321	return ret;
322}
323EXPORT_SYMBOL_GPL(__blocking_notifier_call_chain);
324
325int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
326		unsigned long val, void *v)
327{
328	return __blocking_notifier_call_chain(nh, val, v, -1, NULL);
329}
330EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);
331
332/*
333 *	Raw notifier chain routines.  There is no protection;
334 *	the caller must provide it.  Use at your own risk!
335 */
336
337/**
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
341 *
342 *	Adds a notifier to a raw notifier chain.
343 *	All locking must be provided by the caller.
344 *
345 *	Currently always returns zero.
346 */
347int raw_notifier_chain_register(struct raw_notifier_head *nh,
348		struct notifier_block *n)
349{
350	return notifier_chain_register(&nh->head, n);
351}
352EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
353
354/**
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
358 *
359 *	Removes a notifier from a raw notifier chain.
360 *	All locking must be provided by the caller.
361 *
362 *	Returns zero on success or %-ENOENT on failure.
363 */
364int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
365		struct notifier_block *n)
366{
367	return notifier_chain_unregister(&nh->head, n);
368}
369EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
370
371/**
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
378 *
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.
382 *
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.
389 */
390int __raw_notifier_call_chain(struct raw_notifier_head *nh,
391			      unsigned long val, void *v,
392			      int nr_to_call, int *nr_calls)
393{
394	return notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
395}
396EXPORT_SYMBOL_GPL(__raw_notifier_call_chain);
397
398int raw_notifier_call_chain(struct raw_notifier_head *nh,
399		unsigned long val, void *v)
400{
401	return __raw_notifier_call_chain(nh, val, v, -1, NULL);
402}
403EXPORT_SYMBOL_GPL(raw_notifier_call_chain);
404
405#ifdef CONFIG_SRCU
406/*
407 *	SRCU notifier chain routines.    Registration and unregistration
408 *	use a mutex, and call_chain is synchronized by SRCU (no locks).
409 */
410
411/**
412 *	srcu_notifier_chain_register - Add notifier to an SRCU notifier chain
413 *	@nh: Pointer to head of the SRCU notifier chain
414 *	@n: New entry in notifier chain
415 *
416 *	Adds a notifier to an SRCU notifier chain.
417 *	Must be called in process context.
418 *
419 *	Currently always returns zero.
420 */
421int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
422		struct notifier_block *n)
423{
424	int ret;
425
426	/*
427	 * This code gets used during boot-up, when task switching is
428	 * not yet working and interrupts must remain disabled.  At
429	 * such times we must not call mutex_lock().
430	 */
431	if (unlikely(system_state == SYSTEM_BOOTING))
432		return notifier_chain_register(&nh->head, n);
433
434	mutex_lock(&nh->mutex);
435	ret = notifier_chain_register(&nh->head, n);
436	mutex_unlock(&nh->mutex);
437	return ret;
438}
439EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);
440
441/**
442 *	srcu_notifier_chain_unregister - Remove notifier from an SRCU notifier chain
443 *	@nh: Pointer to head of the SRCU notifier chain
444 *	@n: Entry to remove from notifier chain
445 *
446 *	Removes a notifier from an SRCU notifier chain.
447 *	Must be called from process context.
448 *
449 *	Returns zero on success or %-ENOENT on failure.
450 */
451int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
452		struct notifier_block *n)
453{
454	int ret;
455
456	/*
457	 * This code gets used during boot-up, when task switching is
458	 * not yet working and interrupts must remain disabled.  At
459	 * such times we must not call mutex_lock().
460	 */
461	if (unlikely(system_state == SYSTEM_BOOTING))
462		return notifier_chain_unregister(&nh->head, n);
463
464	mutex_lock(&nh->mutex);
465	ret = notifier_chain_unregister(&nh->head, n);
466	mutex_unlock(&nh->mutex);
467	synchronize_srcu(&nh->srcu);
468	return ret;
469}
470EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);
471
472/**
473 *	__srcu_notifier_call_chain - Call functions in an SRCU notifier chain
474 *	@nh: Pointer to head of the SRCU notifier chain
475 *	@val: Value passed unmodified to notifier function
476 *	@v: Pointer passed unmodified to notifier function
477 *	@nr_to_call: See comment for notifier_call_chain.
478 *	@nr_calls: See comment for notifier_call_chain
479 *
480 *	Calls each function in a notifier chain in turn.  The functions
481 *	run in a process context, so they are allowed to block.
482 *
483 *	If the return value of the notifier can be and'ed
484 *	with %NOTIFY_STOP_MASK then srcu_notifier_call_chain()
485 *	will return immediately, with the return value of
486 *	the notifier function which halted execution.
487 *	Otherwise the return value is the return value
488 *	of the last notifier function called.
489 */
490int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
491			       unsigned long val, void *v,
492			       int nr_to_call, int *nr_calls)
493{
494	int ret;
495	int idx;
496
497	idx = srcu_read_lock(&nh->srcu);
498	ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
499	srcu_read_unlock(&nh->srcu, idx);
500	return ret;
501}
502EXPORT_SYMBOL_GPL(__srcu_notifier_call_chain);
503
504int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
505		unsigned long val, void *v)
506{
507	return __srcu_notifier_call_chain(nh, val, v, -1, NULL);
508}
509EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);
510
511/**
512 *	srcu_init_notifier_head - Initialize an SRCU notifier head
513 *	@nh: Pointer to head of the srcu notifier chain
514 *
515 *	Unlike other sorts of notifier heads, SRCU notifier heads require
516 *	dynamic initialization.  Be sure to call this routine before
517 *	calling any of the other SRCU notifier routines for this head.
518 *
519 *	If an SRCU notifier head is deallocated, it must first be cleaned
520 *	up by calling srcu_cleanup_notifier_head().  Otherwise the head's
521 *	per-cpu data (used by the SRCU mechanism) will leak.
522 */
523void srcu_init_notifier_head(struct srcu_notifier_head *nh)
524{
525	mutex_init(&nh->mutex);
526	if (init_srcu_struct(&nh->srcu) < 0)
527		BUG();
528	nh->head = NULL;
529}
530EXPORT_SYMBOL_GPL(srcu_init_notifier_head);
531
532#endif /* CONFIG_SRCU */
533
534static ATOMIC_NOTIFIER_HEAD(die_chain);
535
536int notrace notify_die(enum die_val val, const char *str,
537	       struct pt_regs *regs, long err, int trap, int sig)
538{
539	struct die_args args = {
540		.regs	= regs,
541		.str	= str,
542		.err	= err,
543		.trapnr	= trap,
544		.signr	= sig,
545
546	};
547	return atomic_notifier_call_chain(&die_chain, val, &args);
548}
549NOKPROBE_SYMBOL(notify_die);
550
551int register_die_notifier(struct notifier_block *nb)
552{
553	vmalloc_sync_all();
554	return atomic_notifier_chain_register(&die_chain, nb);
555}
556EXPORT_SYMBOL_GPL(register_die_notifier);
557
558int unregister_die_notifier(struct notifier_block *nb)
559{
560	return atomic_notifier_chain_unregister(&die_chain, nb);
561}
562EXPORT_SYMBOL_GPL(unregister_die_notifier);
563