kernel/srcu.c

   1 /*
   2  * Sleepable Read-Copy Update mechanism for mutual exclusion.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  *
  18  * Copyright (C) IBM Corporation, 2006
  19  * Copyright (C) Fujitsu, 2012
  20  *
  21  * Author: Paul McKenney <paulmck@us.ibm.com>
  22  *         Lai Jiangshan <laijs@cn.fujitsu.com>
  23  *
  24  * For detailed explanation of Read-Copy Update mechanism see -
  25  *              Documentation/RCU/ *.txt
  26  *
  27  */
  28
  29 #include <linux/export.h>
  30 #include <linux/mutex.h>
  31 #include <linux/percpu.h>
  32 #include <linux/preempt.h>
  33 #include <linux/rcupdate.h>
  34 #include <linux/sched.h>
  35 #include <linux/smp.h>
  36 #include <linux/delay.h>
  37 #include <linux/srcu.h>
  38
  39 #include <trace/events/rcu.h>
  40
  41 #include "rcu.h"
  42
  43 /*
  44  * Initialize an rcu_batch structure to empty.
  45  */
  46 static inline void rcu_batch_init(struct rcu_batch *b)
  47 {
  48         b->head = NULL;
  49         b->tail = &b->head;
  50 }
  51
  52 /*
  53  * Enqueue a callback onto the tail of the specified rcu_batch structure.
  54  */
  55 static inline void rcu_batch_queue(struct rcu_batch *b, struct rcu_head *head)
  56 {
  57         *b->tail = head;
  58         b->tail = &head->next;
  59 }
  60
  61 /*
  62  * Is the specified rcu_batch structure empty?
  63  */
  64 static inline bool rcu_batch_empty(struct rcu_batch *b)
  65 {
  66         return b->tail == &b->head;
  67 }
  68
  69 /*
  70  * Remove the callback at the head of the specified rcu_batch structure
  71  * and return a pointer to it, or return NULL if the structure is empty.
  72  */
  73 static inline struct rcu_head *rcu_batch_dequeue(struct rcu_batch *b)
  74 {
  75         struct rcu_head *head;
  76
  77         if (rcu_batch_empty(b))
  78                 return NULL;
  79
  80         head = b->head;
  81         b->head = head->next;
  82         if (b->tail == &head->next)
  83                 rcu_batch_init(b);
  84
  85         return head;
  86 }
  87
  88 /*
  89  * Move all callbacks from the rcu_batch structure specified by "from" to
  90  * the structure specified by "to".
  91  */
  92 static inline void rcu_batch_move(struct rcu_batch *to, struct rcu_batch *from)
  93 {
  94         if (!rcu_batch_empty(from)) {
  95                 *to->tail = from->head;
  96                 to->tail = from->tail;
  97                 rcu_batch_init(from);
  98         }
  99 }
 100
 101 static int init_srcu_struct_fields(struct srcu_struct *sp)
 102 {
 103         sp->completed = 0;
 104         spin_lock_init(&sp->queue_lock);
 105         sp->running = false;
 106         rcu_batch_init(&sp->batch_queue);
 107         rcu_batch_init(&sp->batch_check0);
 108         rcu_batch_init(&sp->batch_check1);
 109         rcu_batch_init(&sp->batch_done);
 110         INIT_DELAYED_WORK(&sp->work, process_srcu);
 111         sp->per_cpu_ref = alloc_percpu(struct srcu_struct_array);
 112         return sp->per_cpu_ref ? 0 : -ENOMEM;
 113 }
 114
 115 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 116
 117 int __init_srcu_struct(struct srcu_struct *sp, const char *name,
 118                        struct lock_class_key *key)
 119 {
 120         /* Don't re-initialize a lock while it is held. */
 121         debug_check_no_locks_freed((void *)sp, sizeof(*sp));
 122         lockdep_init_map(&sp->dep_map, name, key, 0);
 123         return init_srcu_struct_fields(sp);
 124 }
 125 EXPORT_SYMBOL_GPL(__init_srcu_struct);
 126
 127 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 128
 129 /**
 130  * init_srcu_struct - initialize a sleep-RCU structure
 131  * @sp: structure to initialize.
 132  *
 133  * Must invoke this on a given srcu_struct before passing that srcu_struct
 134  * to any other function.  Each srcu_struct represents a separate domain
 135  * of SRCU protection.
 136  */
 137 int init_srcu_struct(struct srcu_struct *sp)
 138 {
 139         return init_srcu_struct_fields(sp);
 140 }
 141 EXPORT_SYMBOL_GPL(init_srcu_struct);
 142
 143 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 144
 145 /*
 146  * Returns approximate total of the readers' ->seq[] values for the
 147  * rank of per-CPU counters specified by idx.
 148  */
 149 static unsigned long srcu_readers_seq_idx(struct srcu_struct *sp, int idx)
 150 {
 151         int cpu;
 152         unsigned long sum = 0;
 153         unsigned long t;
 154
 155         for_each_possible_cpu(cpu) {
 156                 t = ACCESS_ONCE(per_cpu_ptr(sp->per_cpu_ref, cpu)->seq[idx]);
 157                 sum += t;
 158         }
 159         return sum;
 160 }
 161
 162 /*
 163  * Returns approximate number of readers active on the specified rank
 164  * of the per-CPU ->c[] counters.
 165  */
 166 static unsigned long srcu_readers_active_idx(struct srcu_struct *sp, int idx)
 167 {
 168         int cpu;
 169         unsigned long sum = 0;
 170         unsigned long t;
 171
 172         for_each_possible_cpu(cpu) {
 173                 t = ACCESS_ONCE(per_cpu_ptr(sp->per_cpu_ref, cpu)->c[idx]);
 174                 sum += t;
 175         }
 176         return sum;
 177 }
 178
 179 /*
 180  * Return true if the number of pre-existing readers is determined to
 181  * be stably zero.  An example unstable zero can occur if the call
 182  * to srcu_readers_active_idx() misses an __srcu_read_lock() increment,
 183  * but due to task migration, sees the corresponding __srcu_read_unlock()
 184  * decrement.  This can happen because srcu_readers_active_idx() takes
 185  * time to sum the array, and might in fact be interrupted or preempted
 186  * partway through the summation.
 187  */
 188 static bool srcu_readers_active_idx_check(struct srcu_struct *sp, int idx)
 189 {
 190         unsigned long seq;
 191
 192         seq = srcu_readers_seq_idx(sp, idx);
 193
 194         /*
 195          * The following smp_mb() A pairs with the smp_mb() B located in
 196          * __srcu_read_lock().  This pairing ensures that if an
 197          * __srcu_read_lock() increments its counter after the summation
 198          * in srcu_readers_active_idx(), then the corresponding SRCU read-side
 199          * critical section will see any changes made prior to the start
 200          * of the current SRCU grace period.
 201          *
 202          * Also, if the above call to srcu_readers_seq_idx() saw the
 203          * increment of ->seq[], then the call to srcu_readers_active_idx()
 204          * must see the increment of ->c[].
 205          */
 206         smp_mb(); /* A */
 207
 208         /*
 209          * Note that srcu_readers_active_idx() can incorrectly return
 210          * zero even though there is a pre-existing reader throughout.
 211          * To see this, suppose that task A is in a very long SRCU
 212          * read-side critical section that started on CPU 0, and that
 213          * no other reader exists, so that the sum of the counters
 214          * is equal to one.  Then suppose that task B starts executing
 215          * srcu_readers_active_idx(), summing up to CPU 1, and then that
 216          * task C starts reading on CPU 0, so that its increment is not
 217          * summed, but finishes reading on CPU 2, so that its decrement
 218          * -is- summed.  Then when task B completes its sum, it will
 219          * incorrectly get zero, despite the fact that task A has been
 220          * in its SRCU read-side critical section the whole time.
 221          *
 222          * We therefore do a validation step should srcu_readers_active_idx()
 223          * return zero.
 224          */
 225         if (srcu_readers_active_idx(sp, idx) != 0)
 226                 return false;
 227
 228         /*
 229          * The remainder of this function is the validation step.
 230          * The following smp_mb() D pairs with the smp_mb() C in
 231          * __srcu_read_unlock().  If the __srcu_read_unlock() was seen
 232          * by srcu_readers_active_idx() above, then any destructive
 233          * operation performed after the grace period will happen after
 234          * the corresponding SRCU read-side critical section.
 235          *
 236          * Note that there can be at most NR_CPUS worth of readers using
 237          * the old index, which is not enough to overflow even a 32-bit
 238          * integer.  (Yes, this does mean that systems having more than
 239          * a billion or so CPUs need to be 64-bit systems.)  Therefore,
 240          * the sum of the ->seq[] counters cannot possibly overflow.
 241          * Therefore, the only way that the return values of the two
 242          * calls to srcu_readers_seq_idx() can be equal is if there were
 243          * no increments of the corresponding rank of ->seq[] counts
 244          * in the interim.  But the missed-increment scenario laid out
 245          * above includes an increment of the ->seq[] counter by
 246          * the corresponding __srcu_read_lock().  Therefore, if this
 247          * scenario occurs, the return values from the two calls to
 248          * srcu_readers_seq_idx() will differ, and thus the validation
 249          * step below suffices.
 250          */
 251         smp_mb(); /* D */
 252
 253         return srcu_readers_seq_idx(sp, idx) == seq;
 254 }
 255
 256 /**
 257  * srcu_readers_active - returns approximate number of readers.
 258  * @sp: which srcu_struct to count active readers (holding srcu_read_lock).
 259  *
 260  * Note that this is not an atomic primitive, and can therefore suffer
 261  * severe errors when invoked on an active srcu_struct.  That said, it
 262  * can be useful as an error check at cleanup time.
 263  */
 264 static int srcu_readers_active(struct srcu_struct *sp)
 265 {
 266         int cpu;
 267         unsigned long sum = 0;
 268
 269         for_each_possible_cpu(cpu) {
 270                 sum += ACCESS_ONCE(per_cpu_ptr(sp->per_cpu_ref, cpu)->c[0]);
 271                 sum += ACCESS_ONCE(per_cpu_ptr(sp->per_cpu_ref, cpu)->c[1]);
 272         }
 273         return sum;
 274 }
 275
 276 /**
 277  * cleanup_srcu_struct - deconstruct a sleep-RCU structure
 278  * @sp: structure to clean up.
 279  *
 280  * Must invoke this after you are finished using a given srcu_struct that
 281  * was initialized via init_srcu_struct(), else you leak memory.
 282  */
 283 void cleanup_srcu_struct(struct srcu_struct *sp)
 284 {
 285         if (WARN_ON(srcu_readers_active(sp)))
 286                 return; /* Leakage unless caller handles error. */
 287         free_percpu(sp->per_cpu_ref);
 288         sp->per_cpu_ref = NULL;
 289 }
 290 EXPORT_SYMBOL_GPL(cleanup_srcu_struct);
 291
 292 /*
 293  * Counts the new reader in the appropriate per-CPU element of the
 294  * srcu_struct.  Must be called from process context.
 295  * Returns an index that must be passed to the matching srcu_read_unlock().
 296  */
 297 int __srcu_read_lock(struct srcu_struct *sp)
 298 {
 299         int idx;
 300
 301         preempt_disable();
 302         idx = rcu_dereference_index_check(sp->completed,
 303                                           rcu_read_lock_sched_held()) & 0x1;
 304         ACCESS_ONCE(this_cpu_ptr(sp->per_cpu_ref)->c[idx]) += 1;
 305         smp_mb(); /* B */  /* Avoid leaking the critical section. */
 306         ACCESS_ONCE(this_cpu_ptr(sp->per_cpu_ref)->seq[idx]) += 1;
 307         preempt_enable();
 308         return idx;
 309 }
 310 EXPORT_SYMBOL_GPL(__srcu_read_lock);
 311
 312 /*
 313  * Removes the count for the old reader from the appropriate per-CPU
 314  * element of the srcu_struct.  Note that this may well be a different
 315  * CPU than that which was incremented by the corresponding srcu_read_lock().
 316  * Must be called from process context.
 317  */
 318 void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 319 {
 320         smp_mb(); /* C */  /* Avoid leaking the critical section. */
 321         this_cpu_dec(sp->per_cpu_ref->c[idx]);
 322 }
 323 EXPORT_SYMBOL_GPL(__srcu_read_unlock);
 324
 325 /*
 326  * We use an adaptive strategy for synchronize_srcu() and especially for
 327  * synchronize_srcu_expedited().  We spin for a fixed time period
 328  * (defined below) to allow SRCU readers to exit their read-side critical
 329  * sections.  If there are still some readers after 10 microseconds,
 330  * we repeatedly block for 1-millisecond time periods.  This approach
 331  * has done well in testing, so there is no need for a config parameter.
 332  */
 333 #define SRCU_RETRY_CHECK_DELAY          5
 334 #define SYNCHRONIZE_SRCU_TRYCOUNT       2
 335 #define SYNCHRONIZE_SRCU_EXP_TRYCOUNT   12
 336
 337 /*
 338  * @@@ Wait until all pre-existing readers complete.  Such readers
 339  * will have used the index specified by "idx".
 340  * the caller should ensures the ->completed is not changed while checking
 341  * and idx = (->completed & 1) ^ 1
 342  */
 343 static bool try_check_zero(struct srcu_struct *sp, int idx, int trycount)
 344 {
 345         for (;;) {
 346                 if (srcu_readers_active_idx_check(sp, idx))
 347                         return true;
 348                 if (--trycount <= 0)
 349                         return false;
 350                 udelay(SRCU_RETRY_CHECK_DELAY);
 351         }
 352 }
 353
 354 /*
 355  * Increment the ->completed counter so that future SRCU readers will
 356  * use the other rank of the ->c[] and ->seq[] arrays.  This allows
 357  * us to wait for pre-existing readers in a starvation-free manner.
 358  */
 359 static void srcu_flip(struct srcu_struct *sp)
 360 {
 361         sp->completed++;
 362 }
 363
 364 /*
 365  * Enqueue an SRCU callback on the specified srcu_struct structure,
 366  * initiating grace-period processing if it is not already running.
 367  */
 368 void call_srcu(struct srcu_struct *sp, struct rcu_head *head,
 369                 void (*func)(struct rcu_head *head))
 370 {
 371         unsigned long flags;
 372
 373         head->next = NULL;
 374         head->func = func;
 375         spin_lock_irqsave(&sp->queue_lock, flags);
 376         rcu_batch_queue(&sp->batch_queue, head);
 377         if (!sp->running) {
 378                 sp->running = true;
 379                 schedule_delayed_work(&sp->work, 0);
 380         }
 381         spin_unlock_irqrestore(&sp->queue_lock, flags);
 382 }
 383 EXPORT_SYMBOL_GPL(call_srcu);
 384
 385 struct rcu_synchronize {
 386         struct rcu_head head;
 387         struct completion completion;
 388 };
 389
 390 /*
 391  * Awaken the corresponding synchronize_srcu() instance now that a
 392  * grace period has elapsed.
 393  */
 394 static void wakeme_after_rcu(struct rcu_head *head)
 395 {
 396         struct rcu_synchronize *rcu;
 397
 398         rcu = container_of(head, struct rcu_synchronize, head);
 399         complete(&rcu->completion);
 400 }
 401
 402 static void srcu_advance_batches(struct srcu_struct *sp, int trycount);
 403 static void srcu_reschedule(struct srcu_struct *sp);
 404
 405 /*
 406  * Helper function for synchronize_srcu() and synchronize_srcu_expedited().
 407  */
 408 static void __synchronize_srcu(struct srcu_struct *sp, int trycount)
 409 {
 410         struct rcu_synchronize rcu;
 411         struct rcu_head *head = &rcu.head;
 412         bool done = false;
 413
 414         rcu_lockdep_assert(!lock_is_held(&sp->dep_map) &&
 415                            !lock_is_held(&rcu_bh_lock_map) &&
 416                            !lock_is_held(&rcu_lock_map) &&
 417                            !lock_is_held(&rcu_sched_lock_map),
 418                            "Illegal synchronize_srcu() in same-type SRCU (or RCU) read-side critical section");
 419
 420         might_sleep();
 421         init_completion(&rcu.completion);
 422
 423         head->next = NULL;
 424         head->func = wakeme_after_rcu;
 425         spin_lock_irq(&sp->queue_lock);
 426         if (!sp->running) {
 427                 /* steal the processing owner */
 428                 sp->running = true;
 429                 rcu_batch_queue(&sp->batch_check0, head);
 430                 spin_unlock_irq(&sp->queue_lock);
 431
 432                 srcu_advance_batches(sp, trycount);
 433                 if (!rcu_batch_empty(&sp->batch_done)) {
 434                         BUG_ON(sp->batch_done.head != head);
 435                         rcu_batch_dequeue(&sp->batch_done);
 436                         done = true;
 437                 }
 438                 /* give the processing owner to work_struct */
 439                 srcu_reschedule(sp);
 440         } else {
 441                 rcu_batch_queue(&sp->batch_queue, head);
 442                 spin_unlock_irq(&sp->queue_lock);
 443         }
 444
 445         if (!done)
 446                 wait_for_completion(&rcu.completion);
 447 }
 448
 449 /**
 450  * synchronize_srcu - wait for prior SRCU read-side critical-section completion
 451  * @sp: srcu_struct with which to synchronize.
 452  *
 453  * Wait for the count to drain to zero of both indexes. To avoid the
 454  * possible starvation of synchronize_srcu(), it waits for the count of
 455  * the index=((->completed & 1) ^ 1) to drain to zero at first,
 456  * and then flip the completed and wait for the count of the other index.
 457  *
 458  * Can block; must be called from process context.
 459  *
 460  * Note that it is illegal to call synchronize_srcu() from the corresponding
 461  * SRCU read-side critical section; doing so will result in deadlock.
 462  * However, it is perfectly legal to call synchronize_srcu() on one
 463  * srcu_struct from some other srcu_struct's read-side critical section.
 464  */
 465 void synchronize_srcu(struct srcu_struct *sp)
 466 {
 467         __synchronize_srcu(sp, rcu_expedited
 468                            ? SYNCHRONIZE_SRCU_EXP_TRYCOUNT
 469                            : SYNCHRONIZE_SRCU_TRYCOUNT);
 470 }
 471 EXPORT_SYMBOL_GPL(synchronize_srcu);
 472
 473 /**
 474  * synchronize_srcu_expedited - Brute-force SRCU grace period
 475  * @sp: srcu_struct with which to synchronize.
 476  *
 477  * Wait for an SRCU grace period to elapse, but be more aggressive about
 478  * spinning rather than blocking when waiting.
 479  *
 480  * Note that it is illegal to call this function while holding any lock
 481  * that is acquired by a CPU-hotplug notifier.  It is also illegal to call
 482  * synchronize_srcu_expedited() from the corresponding SRCU read-side
 483  * critical section; doing so will result in deadlock.  However, it is
 484  * perfectly legal to call synchronize_srcu_expedited() on one srcu_struct
 485  * from some other srcu_struct's read-side critical section, as long as
 486  * the resulting graph of srcu_structs is acyclic.
 487  */
 488 void synchronize_srcu_expedited(struct srcu_struct *sp)
 489 {
 490         __synchronize_srcu(sp, SYNCHRONIZE_SRCU_EXP_TRYCOUNT);
 491 }
 492 EXPORT_SYMBOL_GPL(synchronize_srcu_expedited);
 493
 494 /**
 495  * srcu_barrier - Wait until all in-flight call_srcu() callbacks complete.
 496  */
 497 void srcu_barrier(struct srcu_struct *sp)
 498 {
 499         synchronize_srcu(sp);
 500 }
 501 EXPORT_SYMBOL_GPL(srcu_barrier);
 502
 503 /**
 504  * srcu_batches_completed - return batches completed.
 505  * @sp: srcu_struct on which to report batch completion.
 506  *
 507  * Report the number of batches, correlated with, but not necessarily
 508  * precisely the same as, the number of grace periods that have elapsed.
 509  */
 510 long srcu_batches_completed(struct srcu_struct *sp)
 511 {
 512         return sp->completed;
 513 }
 514 EXPORT_SYMBOL_GPL(srcu_batches_completed);
 515
 516 #define SRCU_CALLBACK_BATCH     10
 517 #define SRCU_INTERVAL           1
 518
 519 /*
 520  * Move any new SRCU callbacks to the first stage of the SRCU grace
 521  * period pipeline.
 522  */
 523 static void srcu_collect_new(struct srcu_struct *sp)
 524 {
 525         if (!rcu_batch_empty(&sp->batch_queue)) {
 526                 spin_lock_irq(&sp->queue_lock);
 527                 rcu_batch_move(&sp->batch_check0, &sp->batch_queue);
 528                 spin_unlock_irq(&sp->queue_lock);
 529         }
 530 }
 531
 532 /*
 533  * Core SRCU state machine.  Advance callbacks from ->batch_check0 to
 534  * ->batch_check1 and then to ->batch_done as readers drain.
 535  */
 536 static void srcu_advance_batches(struct srcu_struct *sp, int trycount)
 537 {
 538         int idx = 1 ^ (sp->completed & 1);
 539
 540         /*
 541          * Because readers might be delayed for an extended period after
 542          * fetching ->completed for their index, at any point in time there
 543          * might well be readers using both idx=0 and idx=1.  We therefore
 544          * need to wait for readers to clear from both index values before
 545          * invoking a callback.
 546          */
 547
 548         if (rcu_batch_empty(&sp->batch_check0) &&
 549             rcu_batch_empty(&sp->batch_check1))
 550                 return; /* no callbacks need to be advanced */
 551
 552         if (!try_check_zero(sp, idx, trycount))
 553                 return; /* failed to advance, will try after SRCU_INTERVAL */
 554
 555         /*
 556          * The callbacks in ->batch_check1 have already done with their
 557          * first zero check and flip back when they were enqueued on
 558          * ->batch_check0 in a previous invocation of srcu_advance_batches().
 559          * (Presumably try_check_zero() returned false during that
 560          * invocation, leaving the callbacks stranded on ->batch_check1.)
 561          * They are therefore ready to invoke, so move them to ->batch_done.
 562          */
 563         rcu_batch_move(&sp->batch_done, &sp->batch_check1);
 564
 565         if (rcu_batch_empty(&sp->batch_check0))
 566                 return; /* no callbacks need to be advanced */
 567         srcu_flip(sp);
 568
 569         /*
 570          * The callbacks in ->batch_check0 just finished their
 571          * first check zero and flip, so move them to ->batch_check1
 572          * for future checking on the other idx.
 573          */
 574         rcu_batch_move(&sp->batch_check1, &sp->batch_check0);
 575
 576         /*
 577          * SRCU read-side critical sections are normally short, so check
 578          * at least twice in quick succession after a flip.
 579          */
 580         trycount = trycount < 2 ? 2 : trycount;
 581         if (!try_check_zero(sp, idx^1, trycount))
 582                 return; /* failed to advance, will try after SRCU_INTERVAL */
 583
 584         /*
 585          * The callbacks in ->batch_check1 have now waited for all
 586          * pre-existing readers using both idx values.  They are therefore
 587          * ready to invoke, so move them to ->batch_done.
 588          */
 589         rcu_batch_move(&sp->batch_done, &sp->batch_check1);
 590 }
 591
 592 /*
 593  * Invoke a limited number of SRCU callbacks that have passed through
 594  * their grace period.  If there are more to do, SRCU will reschedule
 595  * the workqueue.
 596  */
 597 static void srcu_invoke_callbacks(struct srcu_struct *sp)
 598 {
 599         int i;
 600         struct rcu_head *head;
 601
 602         for (i = 0; i < SRCU_CALLBACK_BATCH; i++) {
 603                 head = rcu_batch_dequeue(&sp->batch_done);
 604                 if (!head)
 605                         break;
 606                 local_bh_disable();
 607                 head->func(head);
 608                 local_bh_enable();
 609         }
 610 }
 611
 612 /*
 613  * Finished one round of SRCU grace period.  Start another if there are
 614  * more SRCU callbacks queued, otherwise put SRCU into not-running state.
 615  */
 616 static void srcu_reschedule(struct srcu_struct *sp)
 617 {
 618         bool pending = true;
 619
 620         if (rcu_batch_empty(&sp->batch_done) &&
 621             rcu_batch_empty(&sp->batch_check1) &&
 622             rcu_batch_empty(&sp->batch_check0) &&
 623             rcu_batch_empty(&sp->batch_queue)) {
 624                 spin_lock_irq(&sp->queue_lock);
 625                 if (rcu_batch_empty(&sp->batch_done) &&
 626                     rcu_batch_empty(&sp->batch_check1) &&
 627                     rcu_batch_empty(&sp->batch_check0) &&
 628                     rcu_batch_empty(&sp->batch_queue)) {
 629                         sp->running = false;
 630                         pending = false;
 631                 }
 632                 spin_unlock_irq(&sp->queue_lock);
 633         }
 634
 635         if (pending)
 636                 schedule_delayed_work(&sp->work, SRCU_INTERVAL);
 637 }
 638
 639 /*
 640  * This is the work-queue function that handles SRCU grace periods.
 641  */
 642 void process_srcu(struct work_struct *work)
 643 {
 644         struct srcu_struct *sp;
 645
 646         sp = container_of(work, struct srcu_struct, work.work);
 647
 648         srcu_collect_new(sp);
 649         srcu_advance_batches(sp, 1);
 650         srcu_invoke_callbacks(sp);
 651         srcu_reschedule(sp);
 652 }
 653 EXPORT_SYMBOL_GPL(process_srcu);