1
2#include <linux/kdebug.h>
3#include <linux/kprobes.h>
4#include <linux/export.h>
5#include <linux/notifier.h>
6#include <linux/rcupdate.h>
7#include <linux/vmalloc.h>
8#include <linux/reboot.h>
9
10
11
12
13
14
15BLOCKING_NOTIFIER_HEAD(reboot_notifier_list);
16
17
18
19
20
21
22static int notifier_chain_register(struct notifier_block **nl,
23 struct notifier_block *n)
24{
25 while ((*nl) != NULL) {
26 if (unlikely((*nl) == n)) {
27 WARN(1, "double register detected");
28 return 0;
29 }
30 if (n->priority > (*nl)->priority)
31 break;
32 nl = &((*nl)->next);
33 }
34 n->next = *nl;
35 rcu_assign_pointer(*nl, n);
36 return 0;
37}
38
39static int notifier_chain_unregister(struct notifier_block **nl,
40 struct notifier_block *n)
41{
42 while ((*nl) != NULL) {
43 if ((*nl) == n) {
44 rcu_assign_pointer(*nl, n->next);
45 return 0;
46 }
47 nl = &((*nl)->next);
48 }
49 return -ENOENT;
50}
51
52
53
54
55
56
57
58
59
60
61
62
63
64static int notifier_call_chain(struct notifier_block **nl,
65 unsigned long val, void *v,
66 int nr_to_call, int *nr_calls)
67{
68 int ret = NOTIFY_DONE;
69 struct notifier_block *nb, *next_nb;
70
71 nb = rcu_dereference_raw(*nl);
72
73 while (nb && nr_to_call) {
74 next_nb = rcu_dereference_raw(nb->next);
75
76#ifdef CONFIG_DEBUG_NOTIFIERS
77 if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {
78 WARN(1, "Invalid notifier called!");
79 nb = next_nb;
80 continue;
81 }
82#endif
83 ret = nb->notifier_call(nb, val, v);
84
85 if (nr_calls)
86 (*nr_calls)++;
87
88 if (ret & NOTIFY_STOP_MASK)
89 break;
90 nb = next_nb;
91 nr_to_call--;
92 }
93 return ret;
94}
95NOKPROBE_SYMBOL(notifier_call_chain);
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112static int notifier_call_chain_robust(struct notifier_block **nl,
113 unsigned long val_up, unsigned long val_down,
114 void *v)
115{
116 int ret, nr = 0;
117
118 ret = notifier_call_chain(nl, val_up, v, -1, &nr);
119 if (ret & NOTIFY_STOP_MASK)
120 notifier_call_chain(nl, val_down, v, nr-1, NULL);
121
122 return ret;
123}
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
140 struct notifier_block *n)
141{
142 unsigned long flags;
143 int ret;
144
145 spin_lock_irqsave(&nh->lock, flags);
146 ret = notifier_chain_register(&nh->head, n);
147 spin_unlock_irqrestore(&nh->lock, flags);
148 return ret;
149}
150EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);
151
152
153
154
155
156
157
158
159
160
161int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
162 struct notifier_block *n)
163{
164 unsigned long flags;
165 int ret;
166
167 spin_lock_irqsave(&nh->lock, flags);
168 ret = notifier_chain_unregister(&nh->head, n);
169 spin_unlock_irqrestore(&nh->lock, flags);
170 synchronize_rcu();
171 return ret;
172}
173EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);
174
175int atomic_notifier_call_chain_robust(struct atomic_notifier_head *nh,
176 unsigned long val_up, unsigned long val_down, void *v)
177{
178 unsigned long flags;
179 int ret;
180
181
182
183
184
185 spin_lock_irqsave(&nh->lock, flags);
186 ret = notifier_call_chain_robust(&nh->head, val_up, val_down, v);
187 spin_unlock_irqrestore(&nh->lock, flags);
188
189 return ret;
190}
191EXPORT_SYMBOL_GPL(atomic_notifier_call_chain_robust);
192NOKPROBE_SYMBOL(atomic_notifier_call_chain_robust);
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
212 unsigned long val, void *v)
213{
214 int ret;
215
216 rcu_read_lock();
217 ret = notifier_call_chain(&nh->head, val, v, -1, NULL);
218 rcu_read_unlock();
219
220 return ret;
221}
222EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);
223NOKPROBE_SYMBOL(atomic_notifier_call_chain);
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
241 struct notifier_block *n)
242{
243 int ret;
244
245
246
247
248
249
250 if (unlikely(system_state == SYSTEM_BOOTING))
251 return notifier_chain_register(&nh->head, n);
252
253 down_write(&nh->rwsem);
254 ret = notifier_chain_register(&nh->head, n);
255 up_write(&nh->rwsem);
256 return ret;
257}
258EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);
259
260
261
262
263
264
265
266
267
268
269
270int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
271 struct notifier_block *n)
272{
273 int ret;
274
275
276
277
278
279
280 if (unlikely(system_state == SYSTEM_BOOTING))
281 return notifier_chain_unregister(&nh->head, n);
282
283 down_write(&nh->rwsem);
284 ret = notifier_chain_unregister(&nh->head, n);
285 up_write(&nh->rwsem);
286 return ret;
287}
288EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
289
290int blocking_notifier_call_chain_robust(struct blocking_notifier_head *nh,
291 unsigned long val_up, unsigned long val_down, void *v)
292{
293 int ret = NOTIFY_DONE;
294
295
296
297
298
299
300 if (rcu_access_pointer(nh->head)) {
301 down_read(&nh->rwsem);
302 ret = notifier_call_chain_robust(&nh->head, val_up, val_down, v);
303 up_read(&nh->rwsem);
304 }
305 return ret;
306}
307EXPORT_SYMBOL_GPL(blocking_notifier_call_chain_robust);
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
326 unsigned long val, void *v)
327{
328 int ret = NOTIFY_DONE;
329
330
331
332
333
334
335 if (rcu_access_pointer(nh->head)) {
336 down_read(&nh->rwsem);
337 ret = notifier_call_chain(&nh->head, val, v, -1, NULL);
338 up_read(&nh->rwsem);
339 }
340 return ret;
341}
342EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359int raw_notifier_chain_register(struct raw_notifier_head *nh,
360 struct notifier_block *n)
361{
362 return notifier_chain_register(&nh->head, n);
363}
364EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
365
366
367
368
369
370
371
372
373
374
375
376int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
377 struct notifier_block *n)
378{
379 return notifier_chain_unregister(&nh->head, n);
380}
381EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
382
383int raw_notifier_call_chain_robust(struct raw_notifier_head *nh,
384 unsigned long val_up, unsigned long val_down, void *v)
385{
386 return notifier_call_chain_robust(&nh->head, val_up, val_down, v);
387}
388EXPORT_SYMBOL_GPL(raw_notifier_call_chain_robust);
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407int raw_notifier_call_chain(struct raw_notifier_head *nh,
408 unsigned long val, void *v)
409{
410 return notifier_call_chain(&nh->head, val, v, -1, NULL);
411}
412EXPORT_SYMBOL_GPL(raw_notifier_call_chain);
413
414#ifdef CONFIG_SRCU
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
431 struct notifier_block *n)
432{
433 int ret;
434
435
436
437
438
439
440 if (unlikely(system_state == SYSTEM_BOOTING))
441 return notifier_chain_register(&nh->head, n);
442
443 mutex_lock(&nh->mutex);
444 ret = notifier_chain_register(&nh->head, n);
445 mutex_unlock(&nh->mutex);
446 return ret;
447}
448EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);
449
450
451
452
453
454
455
456
457
458
459
460int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
461 struct notifier_block *n)
462{
463 int ret;
464
465
466
467
468
469
470 if (unlikely(system_state == SYSTEM_BOOTING))
471 return notifier_chain_unregister(&nh->head, n);
472
473 mutex_lock(&nh->mutex);
474 ret = notifier_chain_unregister(&nh->head, n);
475 mutex_unlock(&nh->mutex);
476 synchronize_srcu(&nh->srcu);
477 return ret;
478}
479EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
498 unsigned long val, void *v)
499{
500 int ret;
501 int idx;
502
503 idx = srcu_read_lock(&nh->srcu);
504 ret = notifier_call_chain(&nh->head, val, v, -1, NULL);
505 srcu_read_unlock(&nh->srcu, idx);
506 return ret;
507}
508EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);
509
510
511
512
513
514
515
516
517
518
519
520
521
522void srcu_init_notifier_head(struct srcu_notifier_head *nh)
523{
524 mutex_init(&nh->mutex);
525 if (init_srcu_struct(&nh->srcu) < 0)
526 BUG();
527 nh->head = NULL;
528}
529EXPORT_SYMBOL_GPL(srcu_init_notifier_head);
530
531#endif
532
533static ATOMIC_NOTIFIER_HEAD(die_chain);
534
535int notrace notify_die(enum die_val val, const char *str,
536 struct pt_regs *regs, long err, int trap, int sig)
537{
538 struct die_args args = {
539 .regs = regs,
540 .str = str,
541 .err = err,
542 .trapnr = trap,
543 .signr = sig,
544
545 };
546 RCU_LOCKDEP_WARN(!rcu_is_watching(),
547 "notify_die called but RCU thinks we're quiescent");
548 return atomic_notifier_call_chain(&die_chain, val, &args);
549}
550NOKPROBE_SYMBOL(notify_die);
551
552int register_die_notifier(struct notifier_block *nb)
553{
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