1#include <linux/kdebug.h> 2#include <linux/kprobes.h> 3#include <linux/module.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 __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 */ 120int 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} 131EXPORT_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 */ 142int 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} 154EXPORT_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 */ 175int __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} 186EXPORT_SYMBOL_GPL(__atomic_notifier_call_chain); 187 188int __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} 193EXPORT_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 */ 210int 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} 228EXPORT_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 */ 241int 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} 251EXPORT_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 */ 263int 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} 281EXPORT_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 */ 301int __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} 320EXPORT_SYMBOL_GPL(__blocking_notifier_call_chain); 321 322int 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} 327EXPORT_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 */ 344int raw_notifier_chain_register(struct raw_notifier_head *nh, 345 struct notifier_block *n) 346{ 347 return notifier_chain_register(&nh->head, n); 348} 349EXPORT_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 */ 361int raw_notifier_chain_unregister(struct raw_notifier_head *nh, 362 struct notifier_block *n) 363{ 364 return notifier_chain_unregister(&nh->head, n); 365} 366EXPORT_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 */ 387int __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} 393EXPORT_SYMBOL_GPL(__raw_notifier_call_chain); 394 395int 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} 400EXPORT_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 */ 417int 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} 435EXPORT_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 */ 447int 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} 466EXPORT_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 */ 486int __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} 498EXPORT_SYMBOL_GPL(__srcu_notifier_call_chain); 499 500int 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} 505EXPORT_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 */ 519void 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} 526EXPORT_SYMBOL_GPL(srcu_init_notifier_head); 527 528/** 529 * register_reboot_notifier - Register function to be called at reboot time 530 * @nb: Info about notifier function to be called 531 * 532 * Registers a function with the list of functions 533 * to be called at reboot time. 534 * 535 * Currently always returns zero, as blocking_notifier_chain_register() 536 * always returns zero. 537 */ 538int register_reboot_notifier(struct notifier_block *nb) 539{ 540 return blocking_notifier_chain_register(&reboot_notifier_list, nb); 541} 542EXPORT_SYMBOL(register_reboot_notifier); 543 544/** 545 * unregister_reboot_notifier - Unregister previously registered reboot notifier 546 * @nb: Hook to be unregistered 547 * 548 * Unregisters a previously registered reboot 549 * notifier function. 550 * 551 * Returns zero on success, or %-ENOENT on failure. 552 */ 553int unregister_reboot_notifier(struct notifier_block *nb) 554{ 555 return blocking_notifier_chain_unregister(&reboot_notifier_list, nb); 556} 557EXPORT_SYMBOL(unregister_reboot_notifier); 558 559static ATOMIC_NOTIFIER_HEAD(die_chain); 560 561int notrace __kprobes notify_die(enum die_val val, const char *str, 562 struct pt_regs *regs, long err, int trap, int sig) 563{ 564 struct die_args args = { 565 .regs = regs, 566 .str = str, 567 .err = err, 568 .trapnr = trap, 569 .signr = sig, 570 571 }; 572 return atomic_notifier_call_chain(&die_chain, val, &args); 573} 574 575int register_die_notifier(struct notifier_block *nb) 576{ 577 vmalloc_sync_all(); 578 return atomic_notifier_chain_register(&die_chain, nb); 579} 580EXPORT_SYMBOL_GPL(register_die_notifier); 581 582int unregister_die_notifier(struct notifier_block *nb) 583{ 584 return atomic_notifier_chain_unregister(&die_chain, nb); 585} 586EXPORT_SYMBOL_GPL(unregister_die_notifier); 587