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