kernel/notifier.c

   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  */
  14 BLOCKING_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
  21 static 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
  34 static 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
  49 static 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  */
  74 static 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(*nl);
  82
  83         while (nb && nr_to_call) {
  84                 next_nb = rcu_dereference(nb->next);
  85                 ret = nb->notifier_call(nb, val, v);
  86
  87                 if (nr_calls)
  88                         (*nr_calls)++;
  89
  90                 if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)
  91                         break;
  92                 nb = next_nb;
  93                 nr_to_call--;
  94         }
  95         return ret;
  96 }
  97
  98 /*
  99  *      Atomic notifier chain routines.  Registration and unregistration
 100  *      use a spinlock, and call_chain is synchronized by RCU (no locks).
 101  */
 102
 103 /**
 104  *      atomic_notifier_chain_register - Add notifier to an atomic notifier chain
 105  *      @nh: Pointer to head of the atomic notifier chain
 106  *      @n: New entry in notifier chain
 107  *
 108  *      Adds a notifier to an atomic notifier chain.
 109  *
 110  *      Currently always returns zero.
 111  */
 112 int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
 113                 struct notifier_block *n)
 114 {
 115         unsigned long flags;
 116         int ret;
 117
 118         spin_lock_irqsave(&nh->lock, flags);
 119         ret = notifier_chain_register(&nh->head, n);
 120         spin_unlock_irqrestore(&nh->lock, flags);
 121         return ret;
 122 }
 123 EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);
 124
 125 /**
 126  *      atomic_notifier_chain_unregister - Remove notifier from an atomic notifier chain
 127  *      @nh: Pointer to head of the atomic notifier chain
 128  *      @n: Entry to remove from notifier chain
 129  *
 130  *      Removes a notifier from an atomic notifier chain.
 131  *
 132  *      Returns zero on success or %-ENOENT on failure.
 133  */
 134 int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
 135                 struct notifier_block *n)
 136 {
 137         unsigned long flags;
 138         int ret;
 139
 140         spin_lock_irqsave(&nh->lock, flags);
 141         ret = notifier_chain_unregister(&nh->head, n);
 142         spin_unlock_irqrestore(&nh->lock, flags);
 143         synchronize_rcu();
 144         return ret;
 145 }
 146 EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);
 147
 148 /**
 149  *      __atomic_notifier_call_chain - Call functions in an atomic notifier chain
 150  *      @nh: Pointer to head of the atomic notifier chain
 151  *      @val: Value passed unmodified to notifier function
 152  *      @v: Pointer passed unmodified to notifier function
 153  *      @nr_to_call: See the comment for notifier_call_chain.
 154  *      @nr_calls: See the comment for notifier_call_chain.
 155  *
 156  *      Calls each function in a notifier chain in turn.  The functions
 157  *      run in an atomic context, so they must not block.
 158  *      This routine uses RCU to synchronize with changes to the chain.
 159  *
 160  *      If the return value of the notifier can be and'ed
 161  *      with %NOTIFY_STOP_MASK then atomic_notifier_call_chain()
 162  *      will return immediately, with the return value of
 163  *      the notifier function which halted execution.
 164  *      Otherwise the return value is the return value
 165  *      of the last notifier function called.
 166  */
 167 int __kprobes __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
 168                                         unsigned long val, void *v,
 169                                         int nr_to_call, int *nr_calls)
 170 {
 171         int ret;
 172
 173         rcu_read_lock();
 174         ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
 175         rcu_read_unlock();
 176         return ret;
 177 }
 178 EXPORT_SYMBOL_GPL(__atomic_notifier_call_chain);
 179
 180 int __kprobes atomic_notifier_call_chain(struct atomic_notifier_head *nh,
 181                 unsigned long val, void *v)
 182 {
 183         return __atomic_notifier_call_chain(nh, val, v, -1, NULL);
 184 }
 185 EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);
 186
 187 /*
 188  *      Blocking notifier chain routines.  All access to the chain is
 189  *      synchronized by an rwsem.
 190  */
 191
 192 /**
 193  *      blocking_notifier_chain_register - Add notifier to a blocking notifier chain
 194  *      @nh: Pointer to head of the blocking notifier chain
 195  *      @n: New entry in notifier chain
 196  *
 197  *      Adds a notifier to a blocking notifier chain.
 198  *      Must be called in process context.
 199  *
 200  *      Currently always returns zero.
 201  */
 202 int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
 203                 struct notifier_block *n)
 204 {
 205         int ret;
 206
 207         /*
 208          * This code gets used during boot-up, when task switching is
 209          * not yet working and interrupts must remain disabled.  At
 210          * such times we must not call down_write().
 211          */
 212         if (unlikely(system_state == SYSTEM_BOOTING))
 213                 return notifier_chain_register(&nh->head, n);
 214
 215         down_write(&nh->rwsem);
 216         ret = notifier_chain_register(&nh->head, n);
 217         up_write(&nh->rwsem);
 218         return ret;
 219 }
 220 EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);
 221
 222 /**
 223  *      blocking_notifier_chain_cond_register - Cond add notifier to a blocking notifier chain
 224  *      @nh: Pointer to head of the blocking notifier chain
 225  *      @n: New entry in notifier chain
 226  *
 227  *      Adds a notifier to a blocking notifier chain, only if not already
 228  *      present in the chain.
 229  *      Must be called in process context.
 230  *
 231  *      Currently always returns zero.
 232  */
 233 int blocking_notifier_chain_cond_register(struct blocking_notifier_head *nh,
 234                 struct notifier_block *n)
 235 {
 236         int ret;
 237
 238         down_write(&nh->rwsem);
 239         ret = notifier_chain_cond_register(&nh->head, n);
 240         up_write(&nh->rwsem);
 241         return ret;
 242 }
 243 EXPORT_SYMBOL_GPL(blocking_notifier_chain_cond_register);
 244
 245 /**
 246  *      blocking_notifier_chain_unregister - Remove notifier from a blocking notifier chain
 247  *      @nh: Pointer to head of the blocking notifier chain
 248  *      @n: Entry to remove from notifier chain
 249  *
 250  *      Removes a notifier from a blocking notifier chain.
 251  *      Must be called from process context.
 252  *
 253  *      Returns zero on success or %-ENOENT on failure.
 254  */
 255 int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
 256                 struct notifier_block *n)
 257 {
 258         int ret;
 259
 260         /*
 261          * This code gets used during boot-up, when task switching is
 262          * not yet working and interrupts must remain disabled.  At
 263          * such times we must not call down_write().
 264          */
 265         if (unlikely(system_state == SYSTEM_BOOTING))
 266                 return notifier_chain_unregister(&nh->head, n);
 267
 268         down_write(&nh->rwsem);
 269         ret = notifier_chain_unregister(&nh->head, n);
 270         up_write(&nh->rwsem);
 271         return ret;
 272 }
 273 EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
 274
 275 /**
 276  *      __blocking_notifier_call_chain - Call functions in a blocking notifier chain
 277  *      @nh: Pointer to head of the blocking notifier chain
 278  *      @val: Value passed unmodified to notifier function
 279  *      @v: Pointer passed unmodified to notifier function
 280  *      @nr_to_call: See comment for notifier_call_chain.
 281  *      @nr_calls: See comment for notifier_call_chain.
 282  *
 283  *      Calls each function in a notifier chain in turn.  The functions
 284  *      run in a process context, so they are allowed to block.
 285  *
 286  *      If the return value of the notifier can be and'ed
 287  *      with %NOTIFY_STOP_MASK then blocking_notifier_call_chain()
 288  *      will return immediately, with the return value of
 289  *      the notifier function which halted execution.
 290  *      Otherwise the return value is the return value
 291  *      of the last notifier function called.
 292  */
 293 int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
 294                                    unsigned long val, void *v,
 295                                    int nr_to_call, int *nr_calls)
 296 {
 297         int ret = NOTIFY_DONE;
 298
 299         /*
 300          * We check the head outside the lock, but if this access is
 301          * racy then it does not matter what the result of the test
 302          * is, we re-check the list after having taken the lock anyway:
 303          */
 304         if (rcu_dereference(nh->head)) {
 305                 down_read(&nh->rwsem);
 306                 ret = notifier_call_chain(&nh->head, val, v, nr_to_call,
 307                                         nr_calls);
 308                 up_read(&nh->rwsem);
 309         }
 310         return ret;
 311 }
 312 EXPORT_SYMBOL_GPL(__blocking_notifier_call_chain);
 313
 314 int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
 315                 unsigned long val, void *v)
 316 {
 317         return __blocking_notifier_call_chain(nh, val, v, -1, NULL);
 318 }
 319 EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);
 320
 321 /*
 322  *      Raw notifier chain routines.  There is no protection;
 323  *      the caller must provide it.  Use at your own risk!
 324  */
 325
 326 /**
 327  *      raw_notifier_chain_register - Add notifier to a raw notifier chain
 328  *      @nh: Pointer to head of the raw notifier chain
 329  *      @n: New entry in notifier chain
 330  *
 331  *      Adds a notifier to a raw notifier chain.
 332  *      All locking must be provided by the caller.
 333  *
 334  *      Currently always returns zero.
 335  */
 336 int raw_notifier_chain_register(struct raw_notifier_head *nh,
 337                 struct notifier_block *n)
 338 {
 339         return notifier_chain_register(&nh->head, n);
 340 }
 341 EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
 342
 343 /**
 344  *      raw_notifier_chain_unregister - Remove notifier from a raw notifier chain
 345  *      @nh: Pointer to head of the raw notifier chain
 346  *      @n: Entry to remove from notifier chain
 347  *
 348  *      Removes a notifier from a raw notifier chain.
 349  *      All locking must be provided by the caller.
 350  *
 351  *      Returns zero on success or %-ENOENT on failure.
 352  */
 353 int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
 354                 struct notifier_block *n)
 355 {
 356         return notifier_chain_unregister(&nh->head, n);
 357 }
 358 EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
 359
 360 /**
 361  *      __raw_notifier_call_chain - Call functions in a raw notifier chain
 362  *      @nh: Pointer to head of the raw notifier chain
 363  *      @val: Value passed unmodified to notifier function
 364  *      @v: Pointer passed unmodified to notifier function
 365  *      @nr_to_call: See comment for notifier_call_chain.
 366  *      @nr_calls: See comment for notifier_call_chain
 367  *
 368  *      Calls each function in a notifier chain in turn.  The functions
 369  *      run in an undefined context.
 370  *      All locking must be provided by the caller.
 371  *
 372  *      If the return value of the notifier can be and'ed
 373  *      with %NOTIFY_STOP_MASK then raw_notifier_call_chain()
 374  *      will return immediately, with the return value of
 375  *      the notifier function which halted execution.
 376  *      Otherwise the return value is the return value
 377  *      of the last notifier function called.
 378  */
 379 int __raw_notifier_call_chain(struct raw_notifier_head *nh,
 380                               unsigned long val, void *v,
 381                               int nr_to_call, int *nr_calls)
 382 {
 383         return notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
 384 }
 385 EXPORT_SYMBOL_GPL(__raw_notifier_call_chain);
 386
 387 int raw_notifier_call_chain(struct raw_notifier_head *nh,
 388                 unsigned long val, void *v)
 389 {
 390         return __raw_notifier_call_chain(nh, val, v, -1, NULL);
 391 }
 392 EXPORT_SYMBOL_GPL(raw_notifier_call_chain);
 393
 394 /*
 395  *      SRCU notifier chain routines.    Registration and unregistration
 396  *      use a mutex, and call_chain is synchronized by SRCU (no locks).
 397  */
 398
 399 /**
 400  *      srcu_notifier_chain_register - Add notifier to an SRCU notifier chain
 401  *      @nh: Pointer to head of the SRCU notifier chain
 402  *      @n: New entry in notifier chain
 403  *
 404  *      Adds a notifier to an SRCU notifier chain.
 405  *      Must be called in process context.
 406  *
 407  *      Currently always returns zero.
 408  */
 409 int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
 410                 struct notifier_block *n)
 411 {
 412         int ret;
 413
 414         /*
 415          * This code gets used during boot-up, when task switching is
 416          * not yet working and interrupts must remain disabled.  At
 417          * such times we must not call mutex_lock().
 418          */
 419         if (unlikely(system_state == SYSTEM_BOOTING))
 420                 return notifier_chain_register(&nh->head, n);
 421
 422         mutex_lock(&nh->mutex);
 423         ret = notifier_chain_register(&nh->head, n);
 424         mutex_unlock(&nh->mutex);
 425         return ret;
 426 }
 427 EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);
 428
 429 /**
 430  *      srcu_notifier_chain_unregister - Remove notifier from an SRCU notifier chain
 431  *      @nh: Pointer to head of the SRCU notifier chain
 432  *      @n: Entry to remove from notifier chain
 433  *
 434  *      Removes a notifier from an SRCU notifier chain.
 435  *      Must be called from process context.
 436  *
 437  *      Returns zero on success or %-ENOENT on failure.
 438  */
 439 int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
 440                 struct notifier_block *n)
 441 {
 442         int ret;
 443
 444         /*
 445          * This code gets used during boot-up, when task switching is
 446          * not yet working and interrupts must remain disabled.  At
 447          * such times we must not call mutex_lock().
 448          */
 449         if (unlikely(system_state == SYSTEM_BOOTING))
 450                 return notifier_chain_unregister(&nh->head, n);
 451
 452         mutex_lock(&nh->mutex);
 453         ret = notifier_chain_unregister(&nh->head, n);
 454         mutex_unlock(&nh->mutex);
 455         synchronize_srcu(&nh->srcu);
 456         return ret;
 457 }
 458 EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);
 459
 460 /**
 461  *      __srcu_notifier_call_chain - Call functions in an SRCU notifier chain
 462  *      @nh: Pointer to head of the SRCU notifier chain
 463  *      @val: Value passed unmodified to notifier function
 464  *      @v: Pointer passed unmodified to notifier function
 465  *      @nr_to_call: See comment for notifier_call_chain.
 466  *      @nr_calls: See comment for notifier_call_chain
 467  *
 468  *      Calls each function in a notifier chain in turn.  The functions
 469  *      run in a process context, so they are allowed to block.
 470  *
 471  *      If the return value of the notifier can be and'ed
 472  *      with %NOTIFY_STOP_MASK then srcu_notifier_call_chain()
 473  *      will return immediately, with the return value of
 474  *      the notifier function which halted execution.
 475  *      Otherwise the return value is the return value
 476  *      of the last notifier function called.
 477  */
 478 int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
 479                                unsigned long val, void *v,
 480                                int nr_to_call, int *nr_calls)
 481 {
 482         int ret;
 483         int idx;
 484
 485         idx = srcu_read_lock(&nh->srcu);
 486         ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
 487         srcu_read_unlock(&nh->srcu, idx);
 488         return ret;
 489 }
 490 EXPORT_SYMBOL_GPL(__srcu_notifier_call_chain);
 491
 492 int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
 493                 unsigned long val, void *v)
 494 {
 495         return __srcu_notifier_call_chain(nh, val, v, -1, NULL);
 496 }
 497 EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);
 498
 499 /**
 500  *      srcu_init_notifier_head - Initialize an SRCU notifier head
 501  *      @nh: Pointer to head of the srcu notifier chain
 502  *
 503  *      Unlike other sorts of notifier heads, SRCU notifier heads require
 504  *      dynamic initialization.  Be sure to call this routine before
 505  *      calling any of the other SRCU notifier routines for this head.
 506  *
 507  *      If an SRCU notifier head is deallocated, it must first be cleaned
 508  *      up by calling srcu_cleanup_notifier_head().  Otherwise the head's
 509  *      per-cpu data (used by the SRCU mechanism) will leak.
 510  */
 511 void srcu_init_notifier_head(struct srcu_notifier_head *nh)
 512 {
 513         mutex_init(&nh->mutex);
 514         if (init_srcu_struct(&nh->srcu) < 0)
 515                 BUG();
 516         nh->head = NULL;
 517 }
 518 EXPORT_SYMBOL_GPL(srcu_init_notifier_head);
 519
 520 /**
 521  *      register_reboot_notifier - Register function to be called at reboot time
 522  *      @nb: Info about notifier function to be called
 523  *
 524  *      Registers a function with the list of functions
 525  *      to be called at reboot time.
 526  *
 527  *      Currently always returns zero, as blocking_notifier_chain_register()
 528  *      always returns zero.
 529  */
 530 int register_reboot_notifier(struct notifier_block *nb)
 531 {
 532         return blocking_notifier_chain_register(&reboot_notifier_list, nb);
 533 }
 534 EXPORT_SYMBOL(register_reboot_notifier);
 535
 536 /**
 537  *      unregister_reboot_notifier - Unregister previously registered reboot notifier
 538  *      @nb: Hook to be unregistered
 539  *
 540  *      Unregisters a previously registered reboot
 541  *      notifier function.
 542  *
 543  *      Returns zero on success, or %-ENOENT on failure.
 544  */
 545 int unregister_reboot_notifier(struct notifier_block *nb)
 546 {
 547         return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
 548 }
 549 EXPORT_SYMBOL(unregister_reboot_notifier);
 550
 551 static ATOMIC_NOTIFIER_HEAD(die_chain);
 552
 553 int notify_die(enum die_val val, const char *str,
 554                struct pt_regs *regs, long err, int trap, int sig)
 555 {
 556         struct die_args args = {
 557                 .regs   = regs,
 558                 .str    = str,
 559                 .err    = err,
 560                 .trapnr = trap,
 561                 .signr  = sig,
 562
 563         };
 564         return atomic_notifier_call_chain(&die_chain, val, &args);
 565 }
 566
 567 int register_die_notifier(struct notifier_block *nb)
 568 {
 569         vmalloc_sync_all();
 570         return atomic_notifier_chain_register(&die_chain, nb);
 571 }
 572 EXPORT_SYMBOL_GPL(register_die_notifier);
 573
 574 int unregister_die_notifier(struct notifier_block *nb)
 575 {
 576         return atomic_notifier_chain_unregister(&die_chain, nb);
 577 }
 578 EXPORT_SYMBOL_GPL(unregister_die_notifier);