tree_plugin.h revision 6303b9c87d52eaedc82968d3ff59c471e7682afc
1/* 2 * Read-Copy Update mechanism for mutual exclusion (tree-based version) 3 * Internal non-public definitions that provide either classic 4 * or preemptible semantics. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 * 20 * Copyright Red Hat, 2009 21 * Copyright IBM Corporation, 2009 22 * 23 * Author: Ingo Molnar <mingo@elte.hu> 24 * Paul E. McKenney <paulmck@linux.vnet.ibm.com> 25 */ 26 27#include <linux/delay.h> 28#include <linux/gfp.h> 29#include <linux/oom.h> 30#include <linux/smpboot.h> 31#include "../time/tick-internal.h" 32 33#define RCU_KTHREAD_PRIO 1 34 35#ifdef CONFIG_RCU_BOOST 36#define RCU_BOOST_PRIO CONFIG_RCU_BOOST_PRIO 37#else 38#define RCU_BOOST_PRIO RCU_KTHREAD_PRIO 39#endif 40 41#ifdef CONFIG_RCU_NOCB_CPU 42static cpumask_var_t rcu_nocb_mask; /* CPUs to have callbacks offloaded. */ 43static bool have_rcu_nocb_mask; /* Was rcu_nocb_mask allocated? */ 44static bool __read_mostly rcu_nocb_poll; /* Offload kthread are to poll. */ 45static char __initdata nocb_buf[NR_CPUS * 5]; 46#endif /* #ifdef CONFIG_RCU_NOCB_CPU */ 47 48/* 49 * Check the RCU kernel configuration parameters and print informative 50 * messages about anything out of the ordinary. If you like #ifdef, you 51 * will love this function. 52 */ 53static void __init rcu_bootup_announce_oddness(void) 54{ 55#ifdef CONFIG_RCU_TRACE 56 pr_info("\tRCU debugfs-based tracing is enabled.\n"); 57#endif 58#if (defined(CONFIG_64BIT) && CONFIG_RCU_FANOUT != 64) || (!defined(CONFIG_64BIT) && CONFIG_RCU_FANOUT != 32) 59 pr_info("\tCONFIG_RCU_FANOUT set to non-default value of %d\n", 60 CONFIG_RCU_FANOUT); 61#endif 62#ifdef CONFIG_RCU_FANOUT_EXACT 63 pr_info("\tHierarchical RCU autobalancing is disabled.\n"); 64#endif 65#ifdef CONFIG_RCU_FAST_NO_HZ 66 pr_info("\tRCU dyntick-idle grace-period acceleration is enabled.\n"); 67#endif 68#ifdef CONFIG_PROVE_RCU 69 pr_info("\tRCU lockdep checking is enabled.\n"); 70#endif 71#ifdef CONFIG_RCU_TORTURE_TEST_RUNNABLE 72 pr_info("\tRCU torture testing starts during boot.\n"); 73#endif 74#if defined(CONFIG_TREE_PREEMPT_RCU) && !defined(CONFIG_RCU_CPU_STALL_VERBOSE) 75 pr_info("\tDump stacks of tasks blocking RCU-preempt GP.\n"); 76#endif 77#if defined(CONFIG_RCU_CPU_STALL_INFO) 78 pr_info("\tAdditional per-CPU info printed with stalls.\n"); 79#endif 80#if NUM_RCU_LVL_4 != 0 81 pr_info("\tFour-level hierarchy is enabled.\n"); 82#endif 83 if (rcu_fanout_leaf != CONFIG_RCU_FANOUT_LEAF) 84 pr_info("\tBoot-time adjustment of leaf fanout to %d.\n", rcu_fanout_leaf); 85 if (nr_cpu_ids != NR_CPUS) 86 pr_info("\tRCU restricting CPUs from NR_CPUS=%d to nr_cpu_ids=%d.\n", NR_CPUS, nr_cpu_ids); 87#ifdef CONFIG_RCU_NOCB_CPU 88#ifndef CONFIG_RCU_NOCB_CPU_NONE 89 if (!have_rcu_nocb_mask) { 90 zalloc_cpumask_var(&rcu_nocb_mask, GFP_KERNEL); 91 have_rcu_nocb_mask = true; 92 } 93#ifdef CONFIG_RCU_NOCB_CPU_ZERO 94 pr_info("\tOffload RCU callbacks from CPU 0\n"); 95 cpumask_set_cpu(0, rcu_nocb_mask); 96#endif /* #ifdef CONFIG_RCU_NOCB_CPU_ZERO */ 97#ifdef CONFIG_RCU_NOCB_CPU_ALL 98 pr_info("\tOffload RCU callbacks from all CPUs\n"); 99 cpumask_copy(rcu_nocb_mask, cpu_possible_mask); 100#endif /* #ifdef CONFIG_RCU_NOCB_CPU_ALL */ 101#endif /* #ifndef CONFIG_RCU_NOCB_CPU_NONE */ 102 if (have_rcu_nocb_mask) { 103 if (!cpumask_subset(rcu_nocb_mask, cpu_possible_mask)) { 104 pr_info("\tNote: kernel parameter 'rcu_nocbs=' contains nonexistent CPUs.\n"); 105 cpumask_and(rcu_nocb_mask, cpu_possible_mask, 106 rcu_nocb_mask); 107 } 108 cpulist_scnprintf(nocb_buf, sizeof(nocb_buf), rcu_nocb_mask); 109 pr_info("\tOffload RCU callbacks from CPUs: %s.\n", nocb_buf); 110 if (rcu_nocb_poll) 111 pr_info("\tPoll for callbacks from no-CBs CPUs.\n"); 112 } 113#endif /* #ifdef CONFIG_RCU_NOCB_CPU */ 114} 115 116#ifdef CONFIG_TREE_PREEMPT_RCU 117 118RCU_STATE_INITIALIZER(rcu_preempt, 'p', call_rcu); 119static struct rcu_state *rcu_state = &rcu_preempt_state; 120 121static int rcu_preempted_readers_exp(struct rcu_node *rnp); 122 123/* 124 * Tell them what RCU they are running. 125 */ 126static void __init rcu_bootup_announce(void) 127{ 128 pr_info("Preemptible hierarchical RCU implementation.\n"); 129 rcu_bootup_announce_oddness(); 130} 131 132/* 133 * Return the number of RCU-preempt batches processed thus far 134 * for debug and statistics. 135 */ 136long rcu_batches_completed_preempt(void) 137{ 138 return rcu_preempt_state.completed; 139} 140EXPORT_SYMBOL_GPL(rcu_batches_completed_preempt); 141 142/* 143 * Return the number of RCU batches processed thus far for debug & stats. 144 */ 145long rcu_batches_completed(void) 146{ 147 return rcu_batches_completed_preempt(); 148} 149EXPORT_SYMBOL_GPL(rcu_batches_completed); 150 151/* 152 * Force a quiescent state for preemptible RCU. 153 */ 154void rcu_force_quiescent_state(void) 155{ 156 force_quiescent_state(&rcu_preempt_state); 157} 158EXPORT_SYMBOL_GPL(rcu_force_quiescent_state); 159 160/* 161 * Record a preemptible-RCU quiescent state for the specified CPU. Note 162 * that this just means that the task currently running on the CPU is 163 * not in a quiescent state. There might be any number of tasks blocked 164 * while in an RCU read-side critical section. 165 * 166 * Unlike the other rcu_*_qs() functions, callers to this function 167 * must disable irqs in order to protect the assignment to 168 * ->rcu_read_unlock_special. 169 */ 170static void rcu_preempt_qs(int cpu) 171{ 172 struct rcu_data *rdp = &per_cpu(rcu_preempt_data, cpu); 173 174 if (rdp->passed_quiesce == 0) 175 trace_rcu_grace_period(TPS("rcu_preempt"), rdp->gpnum, TPS("cpuqs")); 176 rdp->passed_quiesce = 1; 177 current->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_NEED_QS; 178} 179 180/* 181 * We have entered the scheduler, and the current task might soon be 182 * context-switched away from. If this task is in an RCU read-side 183 * critical section, we will no longer be able to rely on the CPU to 184 * record that fact, so we enqueue the task on the blkd_tasks list. 185 * The task will dequeue itself when it exits the outermost enclosing 186 * RCU read-side critical section. Therefore, the current grace period 187 * cannot be permitted to complete until the blkd_tasks list entries 188 * predating the current grace period drain, in other words, until 189 * rnp->gp_tasks becomes NULL. 190 * 191 * Caller must disable preemption. 192 */ 193static void rcu_preempt_note_context_switch(int cpu) 194{ 195 struct task_struct *t = current; 196 unsigned long flags; 197 struct rcu_data *rdp; 198 struct rcu_node *rnp; 199 200 if (t->rcu_read_lock_nesting > 0 && 201 (t->rcu_read_unlock_special & RCU_READ_UNLOCK_BLOCKED) == 0) { 202 203 /* Possibly blocking in an RCU read-side critical section. */ 204 rdp = per_cpu_ptr(rcu_preempt_state.rda, cpu); 205 rnp = rdp->mynode; 206 raw_spin_lock_irqsave(&rnp->lock, flags); 207 smp_mb__after_unlock_lock(); 208 t->rcu_read_unlock_special |= RCU_READ_UNLOCK_BLOCKED; 209 t->rcu_blocked_node = rnp; 210 211 /* 212 * If this CPU has already checked in, then this task 213 * will hold up the next grace period rather than the 214 * current grace period. Queue the task accordingly. 215 * If the task is queued for the current grace period 216 * (i.e., this CPU has not yet passed through a quiescent 217 * state for the current grace period), then as long 218 * as that task remains queued, the current grace period 219 * cannot end. Note that there is some uncertainty as 220 * to exactly when the current grace period started. 221 * We take a conservative approach, which can result 222 * in unnecessarily waiting on tasks that started very 223 * slightly after the current grace period began. C'est 224 * la vie!!! 225 * 226 * But first, note that the current CPU must still be 227 * on line! 228 */ 229 WARN_ON_ONCE((rdp->grpmask & rnp->qsmaskinit) == 0); 230 WARN_ON_ONCE(!list_empty(&t->rcu_node_entry)); 231 if ((rnp->qsmask & rdp->grpmask) && rnp->gp_tasks != NULL) { 232 list_add(&t->rcu_node_entry, rnp->gp_tasks->prev); 233 rnp->gp_tasks = &t->rcu_node_entry; 234#ifdef CONFIG_RCU_BOOST 235 if (rnp->boost_tasks != NULL) 236 rnp->boost_tasks = rnp->gp_tasks; 237#endif /* #ifdef CONFIG_RCU_BOOST */ 238 } else { 239 list_add(&t->rcu_node_entry, &rnp->blkd_tasks); 240 if (rnp->qsmask & rdp->grpmask) 241 rnp->gp_tasks = &t->rcu_node_entry; 242 } 243 trace_rcu_preempt_task(rdp->rsp->name, 244 t->pid, 245 (rnp->qsmask & rdp->grpmask) 246 ? rnp->gpnum 247 : rnp->gpnum + 1); 248 raw_spin_unlock_irqrestore(&rnp->lock, flags); 249 } else if (t->rcu_read_lock_nesting < 0 && 250 t->rcu_read_unlock_special) { 251 252 /* 253 * Complete exit from RCU read-side critical section on 254 * behalf of preempted instance of __rcu_read_unlock(). 255 */ 256 rcu_read_unlock_special(t); 257 } 258 259 /* 260 * Either we were not in an RCU read-side critical section to 261 * begin with, or we have now recorded that critical section 262 * globally. Either way, we can now note a quiescent state 263 * for this CPU. Again, if we were in an RCU read-side critical 264 * section, and if that critical section was blocking the current 265 * grace period, then the fact that the task has been enqueued 266 * means that we continue to block the current grace period. 267 */ 268 local_irq_save(flags); 269 rcu_preempt_qs(cpu); 270 local_irq_restore(flags); 271} 272 273/* 274 * Check for preempted RCU readers blocking the current grace period 275 * for the specified rcu_node structure. If the caller needs a reliable 276 * answer, it must hold the rcu_node's ->lock. 277 */ 278static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp) 279{ 280 return rnp->gp_tasks != NULL; 281} 282 283/* 284 * Record a quiescent state for all tasks that were previously queued 285 * on the specified rcu_node structure and that were blocking the current 286 * RCU grace period. The caller must hold the specified rnp->lock with 287 * irqs disabled, and this lock is released upon return, but irqs remain 288 * disabled. 289 */ 290static void rcu_report_unblock_qs_rnp(struct rcu_node *rnp, unsigned long flags) 291 __releases(rnp->lock) 292{ 293 unsigned long mask; 294 struct rcu_node *rnp_p; 295 296 if (rnp->qsmask != 0 || rcu_preempt_blocked_readers_cgp(rnp)) { 297 raw_spin_unlock_irqrestore(&rnp->lock, flags); 298 return; /* Still need more quiescent states! */ 299 } 300 301 rnp_p = rnp->parent; 302 if (rnp_p == NULL) { 303 /* 304 * Either there is only one rcu_node in the tree, 305 * or tasks were kicked up to root rcu_node due to 306 * CPUs going offline. 307 */ 308 rcu_report_qs_rsp(&rcu_preempt_state, flags); 309 return; 310 } 311 312 /* Report up the rest of the hierarchy. */ 313 mask = rnp->grpmask; 314 raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */ 315 raw_spin_lock(&rnp_p->lock); /* irqs already disabled. */ 316 smp_mb__after_unlock_lock(); 317 rcu_report_qs_rnp(mask, &rcu_preempt_state, rnp_p, flags); 318} 319 320/* 321 * Advance a ->blkd_tasks-list pointer to the next entry, instead 322 * returning NULL if at the end of the list. 323 */ 324static struct list_head *rcu_next_node_entry(struct task_struct *t, 325 struct rcu_node *rnp) 326{ 327 struct list_head *np; 328 329 np = t->rcu_node_entry.next; 330 if (np == &rnp->blkd_tasks) 331 np = NULL; 332 return np; 333} 334 335/* 336 * Handle special cases during rcu_read_unlock(), such as needing to 337 * notify RCU core processing or task having blocked during the RCU 338 * read-side critical section. 339 */ 340void rcu_read_unlock_special(struct task_struct *t) 341{ 342 int empty; 343 int empty_exp; 344 int empty_exp_now; 345 unsigned long flags; 346 struct list_head *np; 347#ifdef CONFIG_RCU_BOOST 348 struct rt_mutex *rbmp = NULL; 349#endif /* #ifdef CONFIG_RCU_BOOST */ 350 struct rcu_node *rnp; 351 int special; 352 353 /* NMI handlers cannot block and cannot safely manipulate state. */ 354 if (in_nmi()) 355 return; 356 357 local_irq_save(flags); 358 359 /* 360 * If RCU core is waiting for this CPU to exit critical section, 361 * let it know that we have done so. 362 */ 363 special = t->rcu_read_unlock_special; 364 if (special & RCU_READ_UNLOCK_NEED_QS) { 365 rcu_preempt_qs(smp_processor_id()); 366 } 367 368 /* Hardware IRQ handlers cannot block. */ 369 if (in_irq() || in_serving_softirq()) { 370 local_irq_restore(flags); 371 return; 372 } 373 374 /* Clean up if blocked during RCU read-side critical section. */ 375 if (special & RCU_READ_UNLOCK_BLOCKED) { 376 t->rcu_read_unlock_special &= ~RCU_READ_UNLOCK_BLOCKED; 377 378 /* 379 * Remove this task from the list it blocked on. The 380 * task can migrate while we acquire the lock, but at 381 * most one time. So at most two passes through loop. 382 */ 383 for (;;) { 384 rnp = t->rcu_blocked_node; 385 raw_spin_lock(&rnp->lock); /* irqs already disabled. */ 386 smp_mb__after_unlock_lock(); 387 if (rnp == t->rcu_blocked_node) 388 break; 389 raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */ 390 } 391 empty = !rcu_preempt_blocked_readers_cgp(rnp); 392 empty_exp = !rcu_preempted_readers_exp(rnp); 393 smp_mb(); /* ensure expedited fastpath sees end of RCU c-s. */ 394 np = rcu_next_node_entry(t, rnp); 395 list_del_init(&t->rcu_node_entry); 396 t->rcu_blocked_node = NULL; 397 trace_rcu_unlock_preempted_task(TPS("rcu_preempt"), 398 rnp->gpnum, t->pid); 399 if (&t->rcu_node_entry == rnp->gp_tasks) 400 rnp->gp_tasks = np; 401 if (&t->rcu_node_entry == rnp->exp_tasks) 402 rnp->exp_tasks = np; 403#ifdef CONFIG_RCU_BOOST 404 if (&t->rcu_node_entry == rnp->boost_tasks) 405 rnp->boost_tasks = np; 406 /* Snapshot/clear ->rcu_boost_mutex with rcu_node lock held. */ 407 if (t->rcu_boost_mutex) { 408 rbmp = t->rcu_boost_mutex; 409 t->rcu_boost_mutex = NULL; 410 } 411#endif /* #ifdef CONFIG_RCU_BOOST */ 412 413 /* 414 * If this was the last task on the current list, and if 415 * we aren't waiting on any CPUs, report the quiescent state. 416 * Note that rcu_report_unblock_qs_rnp() releases rnp->lock, 417 * so we must take a snapshot of the expedited state. 418 */ 419 empty_exp_now = !rcu_preempted_readers_exp(rnp); 420 if (!empty && !rcu_preempt_blocked_readers_cgp(rnp)) { 421 trace_rcu_quiescent_state_report(TPS("preempt_rcu"), 422 rnp->gpnum, 423 0, rnp->qsmask, 424 rnp->level, 425 rnp->grplo, 426 rnp->grphi, 427 !!rnp->gp_tasks); 428 rcu_report_unblock_qs_rnp(rnp, flags); 429 } else { 430 raw_spin_unlock_irqrestore(&rnp->lock, flags); 431 } 432 433#ifdef CONFIG_RCU_BOOST 434 /* Unboost if we were boosted. */ 435 if (rbmp) 436 rt_mutex_unlock(rbmp); 437#endif /* #ifdef CONFIG_RCU_BOOST */ 438 439 /* 440 * If this was the last task on the expedited lists, 441 * then we need to report up the rcu_node hierarchy. 442 */ 443 if (!empty_exp && empty_exp_now) 444 rcu_report_exp_rnp(&rcu_preempt_state, rnp, true); 445 } else { 446 local_irq_restore(flags); 447 } 448} 449 450#ifdef CONFIG_RCU_CPU_STALL_VERBOSE 451 452/* 453 * Dump detailed information for all tasks blocking the current RCU 454 * grace period on the specified rcu_node structure. 455 */ 456static void rcu_print_detail_task_stall_rnp(struct rcu_node *rnp) 457{ 458 unsigned long flags; 459 struct task_struct *t; 460 461 raw_spin_lock_irqsave(&rnp->lock, flags); 462 if (!rcu_preempt_blocked_readers_cgp(rnp)) { 463 raw_spin_unlock_irqrestore(&rnp->lock, flags); 464 return; 465 } 466 t = list_entry(rnp->gp_tasks, 467 struct task_struct, rcu_node_entry); 468 list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) 469 sched_show_task(t); 470 raw_spin_unlock_irqrestore(&rnp->lock, flags); 471} 472 473/* 474 * Dump detailed information for all tasks blocking the current RCU 475 * grace period. 476 */ 477static void rcu_print_detail_task_stall(struct rcu_state *rsp) 478{ 479 struct rcu_node *rnp = rcu_get_root(rsp); 480 481 rcu_print_detail_task_stall_rnp(rnp); 482 rcu_for_each_leaf_node(rsp, rnp) 483 rcu_print_detail_task_stall_rnp(rnp); 484} 485 486#else /* #ifdef CONFIG_RCU_CPU_STALL_VERBOSE */ 487 488static void rcu_print_detail_task_stall(struct rcu_state *rsp) 489{ 490} 491 492#endif /* #else #ifdef CONFIG_RCU_CPU_STALL_VERBOSE */ 493 494#ifdef CONFIG_RCU_CPU_STALL_INFO 495 496static void rcu_print_task_stall_begin(struct rcu_node *rnp) 497{ 498 pr_err("\tTasks blocked on level-%d rcu_node (CPUs %d-%d):", 499 rnp->level, rnp->grplo, rnp->grphi); 500} 501 502static void rcu_print_task_stall_end(void) 503{ 504 pr_cont("\n"); 505} 506 507#else /* #ifdef CONFIG_RCU_CPU_STALL_INFO */ 508 509static void rcu_print_task_stall_begin(struct rcu_node *rnp) 510{ 511} 512 513static void rcu_print_task_stall_end(void) 514{ 515} 516 517#endif /* #else #ifdef CONFIG_RCU_CPU_STALL_INFO */ 518 519/* 520 * Scan the current list of tasks blocked within RCU read-side critical 521 * sections, printing out the tid of each. 522 */ 523static int rcu_print_task_stall(struct rcu_node *rnp) 524{ 525 struct task_struct *t; 526 int ndetected = 0; 527 528 if (!rcu_preempt_blocked_readers_cgp(rnp)) 529 return 0; 530 rcu_print_task_stall_begin(rnp); 531 t = list_entry(rnp->gp_tasks, 532 struct task_struct, rcu_node_entry); 533 list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) { 534 pr_cont(" P%d", t->pid); 535 ndetected++; 536 } 537 rcu_print_task_stall_end(); 538 return ndetected; 539} 540 541/* 542 * Check that the list of blocked tasks for the newly completed grace 543 * period is in fact empty. It is a serious bug to complete a grace 544 * period that still has RCU readers blocked! This function must be 545 * invoked -before- updating this rnp's ->gpnum, and the rnp's ->lock 546 * must be held by the caller. 547 * 548 * Also, if there are blocked tasks on the list, they automatically 549 * block the newly created grace period, so set up ->gp_tasks accordingly. 550 */ 551static void rcu_preempt_check_blocked_tasks(struct rcu_node *rnp) 552{ 553 WARN_ON_ONCE(rcu_preempt_blocked_readers_cgp(rnp)); 554 if (!list_empty(&rnp->blkd_tasks)) 555 rnp->gp_tasks = rnp->blkd_tasks.next; 556 WARN_ON_ONCE(rnp->qsmask); 557} 558 559#ifdef CONFIG_HOTPLUG_CPU 560 561/* 562 * Handle tasklist migration for case in which all CPUs covered by the 563 * specified rcu_node have gone offline. Move them up to the root 564 * rcu_node. The reason for not just moving them to the immediate 565 * parent is to remove the need for rcu_read_unlock_special() to 566 * make more than two attempts to acquire the target rcu_node's lock. 567 * Returns true if there were tasks blocking the current RCU grace 568 * period. 569 * 570 * Returns 1 if there was previously a task blocking the current grace 571 * period on the specified rcu_node structure. 572 * 573 * The caller must hold rnp->lock with irqs disabled. 574 */ 575static int rcu_preempt_offline_tasks(struct rcu_state *rsp, 576 struct rcu_node *rnp, 577 struct rcu_data *rdp) 578{ 579 struct list_head *lp; 580 struct list_head *lp_root; 581 int retval = 0; 582 struct rcu_node *rnp_root = rcu_get_root(rsp); 583 struct task_struct *t; 584 585 if (rnp == rnp_root) { 586 WARN_ONCE(1, "Last CPU thought to be offlined?"); 587 return 0; /* Shouldn't happen: at least one CPU online. */ 588 } 589 590 /* If we are on an internal node, complain bitterly. */ 591 WARN_ON_ONCE(rnp != rdp->mynode); 592 593 /* 594 * Move tasks up to root rcu_node. Don't try to get fancy for 595 * this corner-case operation -- just put this node's tasks 596 * at the head of the root node's list, and update the root node's 597 * ->gp_tasks and ->exp_tasks pointers to those of this node's, 598 * if non-NULL. This might result in waiting for more tasks than 599 * absolutely necessary, but this is a good performance/complexity 600 * tradeoff. 601 */ 602 if (rcu_preempt_blocked_readers_cgp(rnp) && rnp->qsmask == 0) 603 retval |= RCU_OFL_TASKS_NORM_GP; 604 if (rcu_preempted_readers_exp(rnp)) 605 retval |= RCU_OFL_TASKS_EXP_GP; 606 lp = &rnp->blkd_tasks; 607 lp_root = &rnp_root->blkd_tasks; 608 while (!list_empty(lp)) { 609 t = list_entry(lp->next, typeof(*t), rcu_node_entry); 610 raw_spin_lock(&rnp_root->lock); /* irqs already disabled */ 611 smp_mb__after_unlock_lock(); 612 list_del(&t->rcu_node_entry); 613 t->rcu_blocked_node = rnp_root; 614 list_add(&t->rcu_node_entry, lp_root); 615 if (&t->rcu_node_entry == rnp->gp_tasks) 616 rnp_root->gp_tasks = rnp->gp_tasks; 617 if (&t->rcu_node_entry == rnp->exp_tasks) 618 rnp_root->exp_tasks = rnp->exp_tasks; 619#ifdef CONFIG_RCU_BOOST 620 if (&t->rcu_node_entry == rnp->boost_tasks) 621 rnp_root->boost_tasks = rnp->boost_tasks; 622#endif /* #ifdef CONFIG_RCU_BOOST */ 623 raw_spin_unlock(&rnp_root->lock); /* irqs still disabled */ 624 } 625 626 rnp->gp_tasks = NULL; 627 rnp->exp_tasks = NULL; 628#ifdef CONFIG_RCU_BOOST 629 rnp->boost_tasks = NULL; 630 /* 631 * In case root is being boosted and leaf was not. Make sure 632 * that we boost the tasks blocking the current grace period 633 * in this case. 634 */ 635 raw_spin_lock(&rnp_root->lock); /* irqs already disabled */ 636 smp_mb__after_unlock_lock(); 637 if (rnp_root->boost_tasks != NULL && 638 rnp_root->boost_tasks != rnp_root->gp_tasks && 639 rnp_root->boost_tasks != rnp_root->exp_tasks) 640 rnp_root->boost_tasks = rnp_root->gp_tasks; 641 raw_spin_unlock(&rnp_root->lock); /* irqs still disabled */ 642#endif /* #ifdef CONFIG_RCU_BOOST */ 643 644 return retval; 645} 646 647#endif /* #ifdef CONFIG_HOTPLUG_CPU */ 648 649/* 650 * Check for a quiescent state from the current CPU. When a task blocks, 651 * the task is recorded in the corresponding CPU's rcu_node structure, 652 * which is checked elsewhere. 653 * 654 * Caller must disable hard irqs. 655 */ 656static void rcu_preempt_check_callbacks(int cpu) 657{ 658 struct task_struct *t = current; 659 660 if (t->rcu_read_lock_nesting == 0) { 661 rcu_preempt_qs(cpu); 662 return; 663 } 664 if (t->rcu_read_lock_nesting > 0 && 665 per_cpu(rcu_preempt_data, cpu).qs_pending) 666 t->rcu_read_unlock_special |= RCU_READ_UNLOCK_NEED_QS; 667} 668 669#ifdef CONFIG_RCU_BOOST 670 671static void rcu_preempt_do_callbacks(void) 672{ 673 rcu_do_batch(&rcu_preempt_state, this_cpu_ptr(&rcu_preempt_data)); 674} 675 676#endif /* #ifdef CONFIG_RCU_BOOST */ 677 678/* 679 * Queue a preemptible-RCU callback for invocation after a grace period. 680 */ 681void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu)) 682{ 683 __call_rcu(head, func, &rcu_preempt_state, -1, 0); 684} 685EXPORT_SYMBOL_GPL(call_rcu); 686 687/* 688 * Queue an RCU callback for lazy invocation after a grace period. 689 * This will likely be later named something like "call_rcu_lazy()", 690 * but this change will require some way of tagging the lazy RCU 691 * callbacks in the list of pending callbacks. Until then, this 692 * function may only be called from __kfree_rcu(). 693 */ 694void kfree_call_rcu(struct rcu_head *head, 695 void (*func)(struct rcu_head *rcu)) 696{ 697 __call_rcu(head, func, &rcu_preempt_state, -1, 1); 698} 699EXPORT_SYMBOL_GPL(kfree_call_rcu); 700 701/** 702 * synchronize_rcu - wait until a grace period has elapsed. 703 * 704 * Control will return to the caller some time after a full grace 705 * period has elapsed, in other words after all currently executing RCU 706 * read-side critical sections have completed. Note, however, that 707 * upon return from synchronize_rcu(), the caller might well be executing 708 * concurrently with new RCU read-side critical sections that began while 709 * synchronize_rcu() was waiting. RCU read-side critical sections are 710 * delimited by rcu_read_lock() and rcu_read_unlock(), and may be nested. 711 * 712 * See the description of synchronize_sched() for more detailed information 713 * on memory ordering guarantees. 714 */ 715void synchronize_rcu(void) 716{ 717 rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map) && 718 !lock_is_held(&rcu_lock_map) && 719 !lock_is_held(&rcu_sched_lock_map), 720 "Illegal synchronize_rcu() in RCU read-side critical section"); 721 if (!rcu_scheduler_active) 722 return; 723 if (rcu_expedited) 724 synchronize_rcu_expedited(); 725 else 726 wait_rcu_gp(call_rcu); 727} 728EXPORT_SYMBOL_GPL(synchronize_rcu); 729 730static DECLARE_WAIT_QUEUE_HEAD(sync_rcu_preempt_exp_wq); 731static unsigned long sync_rcu_preempt_exp_count; 732static DEFINE_MUTEX(sync_rcu_preempt_exp_mutex); 733 734/* 735 * Return non-zero if there are any tasks in RCU read-side critical 736 * sections blocking the current preemptible-RCU expedited grace period. 737 * If there is no preemptible-RCU expedited grace period currently in 738 * progress, returns zero unconditionally. 739 */ 740static int rcu_preempted_readers_exp(struct rcu_node *rnp) 741{ 742 return rnp->exp_tasks != NULL; 743} 744 745/* 746 * return non-zero if there is no RCU expedited grace period in progress 747 * for the specified rcu_node structure, in other words, if all CPUs and 748 * tasks covered by the specified rcu_node structure have done their bit 749 * for the current expedited grace period. Works only for preemptible 750 * RCU -- other RCU implementation use other means. 751 * 752 * Caller must hold sync_rcu_preempt_exp_mutex. 753 */ 754static int sync_rcu_preempt_exp_done(struct rcu_node *rnp) 755{ 756 return !rcu_preempted_readers_exp(rnp) && 757 ACCESS_ONCE(rnp->expmask) == 0; 758} 759 760/* 761 * Report the exit from RCU read-side critical section for the last task 762 * that queued itself during or before the current expedited preemptible-RCU 763 * grace period. This event is reported either to the rcu_node structure on 764 * which the task was queued or to one of that rcu_node structure's ancestors, 765 * recursively up the tree. (Calm down, calm down, we do the recursion 766 * iteratively!) 767 * 768 * Most callers will set the "wake" flag, but the task initiating the 769 * expedited grace period need not wake itself. 770 * 771 * Caller must hold sync_rcu_preempt_exp_mutex. 772 */ 773static void rcu_report_exp_rnp(struct rcu_state *rsp, struct rcu_node *rnp, 774 bool wake) 775{ 776 unsigned long flags; 777 unsigned long mask; 778 779 raw_spin_lock_irqsave(&rnp->lock, flags); 780 smp_mb__after_unlock_lock(); 781 for (;;) { 782 if (!sync_rcu_preempt_exp_done(rnp)) { 783 raw_spin_unlock_irqrestore(&rnp->lock, flags); 784 break; 785 } 786 if (rnp->parent == NULL) { 787 raw_spin_unlock_irqrestore(&rnp->lock, flags); 788 if (wake) 789 wake_up(&sync_rcu_preempt_exp_wq); 790 break; 791 } 792 mask = rnp->grpmask; 793 raw_spin_unlock(&rnp->lock); /* irqs remain disabled */ 794 rnp = rnp->parent; 795 raw_spin_lock(&rnp->lock); /* irqs already disabled */ 796 smp_mb__after_unlock_lock(); 797 rnp->expmask &= ~mask; 798 } 799} 800 801/* 802 * Snapshot the tasks blocking the newly started preemptible-RCU expedited 803 * grace period for the specified rcu_node structure. If there are no such 804 * tasks, report it up the rcu_node hierarchy. 805 * 806 * Caller must hold sync_rcu_preempt_exp_mutex and must exclude 807 * CPU hotplug operations. 808 */ 809static void 810sync_rcu_preempt_exp_init(struct rcu_state *rsp, struct rcu_node *rnp) 811{ 812 unsigned long flags; 813 int must_wait = 0; 814 815 raw_spin_lock_irqsave(&rnp->lock, flags); 816 smp_mb__after_unlock_lock(); 817 if (list_empty(&rnp->blkd_tasks)) { 818 raw_spin_unlock_irqrestore(&rnp->lock, flags); 819 } else { 820 rnp->exp_tasks = rnp->blkd_tasks.next; 821 rcu_initiate_boost(rnp, flags); /* releases rnp->lock */ 822 must_wait = 1; 823 } 824 if (!must_wait) 825 rcu_report_exp_rnp(rsp, rnp, false); /* Don't wake self. */ 826} 827 828/** 829 * synchronize_rcu_expedited - Brute-force RCU grace period 830 * 831 * Wait for an RCU-preempt grace period, but expedite it. The basic 832 * idea is to invoke synchronize_sched_expedited() to push all the tasks to 833 * the ->blkd_tasks lists and wait for this list to drain. This consumes 834 * significant time on all CPUs and is unfriendly to real-time workloads, 835 * so is thus not recommended for any sort of common-case code. 836 * In fact, if you are using synchronize_rcu_expedited() in a loop, 837 * please restructure your code to batch your updates, and then Use a 838 * single synchronize_rcu() instead. 839 * 840 * Note that it is illegal to call this function while holding any lock 841 * that is acquired by a CPU-hotplug notifier. And yes, it is also illegal 842 * to call this function from a CPU-hotplug notifier. Failing to observe 843 * these restriction will result in deadlock. 844 */ 845void synchronize_rcu_expedited(void) 846{ 847 unsigned long flags; 848 struct rcu_node *rnp; 849 struct rcu_state *rsp = &rcu_preempt_state; 850 unsigned long snap; 851 int trycount = 0; 852 853 smp_mb(); /* Caller's modifications seen first by other CPUs. */ 854 snap = ACCESS_ONCE(sync_rcu_preempt_exp_count) + 1; 855 smp_mb(); /* Above access cannot bleed into critical section. */ 856 857 /* 858 * Block CPU-hotplug operations. This means that any CPU-hotplug 859 * operation that finds an rcu_node structure with tasks in the 860 * process of being boosted will know that all tasks blocking 861 * this expedited grace period will already be in the process of 862 * being boosted. This simplifies the process of moving tasks 863 * from leaf to root rcu_node structures. 864 */ 865 get_online_cpus(); 866 867 /* 868 * Acquire lock, falling back to synchronize_rcu() if too many 869 * lock-acquisition failures. Of course, if someone does the 870 * expedited grace period for us, just leave. 871 */ 872 while (!mutex_trylock(&sync_rcu_preempt_exp_mutex)) { 873 if (ULONG_CMP_LT(snap, 874 ACCESS_ONCE(sync_rcu_preempt_exp_count))) { 875 put_online_cpus(); 876 goto mb_ret; /* Others did our work for us. */ 877 } 878 if (trycount++ < 10) { 879 udelay(trycount * num_online_cpus()); 880 } else { 881 put_online_cpus(); 882 wait_rcu_gp(call_rcu); 883 return; 884 } 885 } 886 if (ULONG_CMP_LT(snap, ACCESS_ONCE(sync_rcu_preempt_exp_count))) { 887 put_online_cpus(); 888 goto unlock_mb_ret; /* Others did our work for us. */ 889 } 890 891 /* force all RCU readers onto ->blkd_tasks lists. */ 892 synchronize_sched_expedited(); 893 894 /* Initialize ->expmask for all non-leaf rcu_node structures. */ 895 rcu_for_each_nonleaf_node_breadth_first(rsp, rnp) { 896 raw_spin_lock_irqsave(&rnp->lock, flags); 897 smp_mb__after_unlock_lock(); 898 rnp->expmask = rnp->qsmaskinit; 899 raw_spin_unlock_irqrestore(&rnp->lock, flags); 900 } 901 902 /* Snapshot current state of ->blkd_tasks lists. */ 903 rcu_for_each_leaf_node(rsp, rnp) 904 sync_rcu_preempt_exp_init(rsp, rnp); 905 if (NUM_RCU_NODES > 1) 906 sync_rcu_preempt_exp_init(rsp, rcu_get_root(rsp)); 907 908 put_online_cpus(); 909 910 /* Wait for snapshotted ->blkd_tasks lists to drain. */ 911 rnp = rcu_get_root(rsp); 912 wait_event(sync_rcu_preempt_exp_wq, 913 sync_rcu_preempt_exp_done(rnp)); 914 915 /* Clean up and exit. */ 916 smp_mb(); /* ensure expedited GP seen before counter increment. */ 917 ACCESS_ONCE(sync_rcu_preempt_exp_count)++; 918unlock_mb_ret: 919 mutex_unlock(&sync_rcu_preempt_exp_mutex); 920mb_ret: 921 smp_mb(); /* ensure subsequent action seen after grace period. */ 922} 923EXPORT_SYMBOL_GPL(synchronize_rcu_expedited); 924 925/** 926 * rcu_barrier - Wait until all in-flight call_rcu() callbacks complete. 927 * 928 * Note that this primitive does not necessarily wait for an RCU grace period 929 * to complete. For example, if there are no RCU callbacks queued anywhere 930 * in the system, then rcu_barrier() is within its rights to return 931 * immediately, without waiting for anything, much less an RCU grace period. 932 */ 933void rcu_barrier(void) 934{ 935 _rcu_barrier(&rcu_preempt_state); 936} 937EXPORT_SYMBOL_GPL(rcu_barrier); 938 939/* 940 * Initialize preemptible RCU's state structures. 941 */ 942static void __init __rcu_init_preempt(void) 943{ 944 rcu_init_one(&rcu_preempt_state, &rcu_preempt_data); 945} 946 947/* 948 * Check for a task exiting while in a preemptible-RCU read-side 949 * critical section, clean up if so. No need to issue warnings, 950 * as debug_check_no_locks_held() already does this if lockdep 951 * is enabled. 952 */ 953void exit_rcu(void) 954{ 955 struct task_struct *t = current; 956 957 if (likely(list_empty(¤t->rcu_node_entry))) 958 return; 959 t->rcu_read_lock_nesting = 1; 960 barrier(); 961 t->rcu_read_unlock_special = RCU_READ_UNLOCK_BLOCKED; 962 __rcu_read_unlock(); 963} 964 965#else /* #ifdef CONFIG_TREE_PREEMPT_RCU */ 966 967static struct rcu_state *rcu_state = &rcu_sched_state; 968 969/* 970 * Tell them what RCU they are running. 971 */ 972static void __init rcu_bootup_announce(void) 973{ 974 pr_info("Hierarchical RCU implementation.\n"); 975 rcu_bootup_announce_oddness(); 976} 977 978/* 979 * Return the number of RCU batches processed thus far for debug & stats. 980 */ 981long rcu_batches_completed(void) 982{ 983 return rcu_batches_completed_sched(); 984} 985EXPORT_SYMBOL_GPL(rcu_batches_completed); 986 987/* 988 * Force a quiescent state for RCU, which, because there is no preemptible 989 * RCU, becomes the same as rcu-sched. 990 */ 991void rcu_force_quiescent_state(void) 992{ 993 rcu_sched_force_quiescent_state(); 994} 995EXPORT_SYMBOL_GPL(rcu_force_quiescent_state); 996 997/* 998 * Because preemptible RCU does not exist, we never have to check for 999 * CPUs being in quiescent states. 1000 */ 1001static void rcu_preempt_note_context_switch(int cpu) 1002{ 1003} 1004 1005/* 1006 * Because preemptible RCU does not exist, there are never any preempted 1007 * RCU readers. 1008 */ 1009static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp) 1010{ 1011 return 0; 1012} 1013 1014#ifdef CONFIG_HOTPLUG_CPU 1015 1016/* Because preemptible RCU does not exist, no quieting of tasks. */ 1017static void rcu_report_unblock_qs_rnp(struct rcu_node *rnp, unsigned long flags) 1018{ 1019 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1020} 1021 1022#endif /* #ifdef CONFIG_HOTPLUG_CPU */ 1023 1024/* 1025 * Because preemptible RCU does not exist, we never have to check for 1026 * tasks blocked within RCU read-side critical sections. 1027 */ 1028static void rcu_print_detail_task_stall(struct rcu_state *rsp) 1029{ 1030} 1031 1032/* 1033 * Because preemptible RCU does not exist, we never have to check for 1034 * tasks blocked within RCU read-side critical sections. 1035 */ 1036static int rcu_print_task_stall(struct rcu_node *rnp) 1037{ 1038 return 0; 1039} 1040 1041/* 1042 * Because there is no preemptible RCU, there can be no readers blocked, 1043 * so there is no need to check for blocked tasks. So check only for 1044 * bogus qsmask values. 1045 */ 1046static void rcu_preempt_check_blocked_tasks(struct rcu_node *rnp) 1047{ 1048 WARN_ON_ONCE(rnp->qsmask); 1049} 1050 1051#ifdef CONFIG_HOTPLUG_CPU 1052 1053/* 1054 * Because preemptible RCU does not exist, it never needs to migrate 1055 * tasks that were blocked within RCU read-side critical sections, and 1056 * such non-existent tasks cannot possibly have been blocking the current 1057 * grace period. 1058 */ 1059static int rcu_preempt_offline_tasks(struct rcu_state *rsp, 1060 struct rcu_node *rnp, 1061 struct rcu_data *rdp) 1062{ 1063 return 0; 1064} 1065 1066#endif /* #ifdef CONFIG_HOTPLUG_CPU */ 1067 1068/* 1069 * Because preemptible RCU does not exist, it never has any callbacks 1070 * to check. 1071 */ 1072static void rcu_preempt_check_callbacks(int cpu) 1073{ 1074} 1075 1076/* 1077 * Queue an RCU callback for lazy invocation after a grace period. 1078 * This will likely be later named something like "call_rcu_lazy()", 1079 * but this change will require some way of tagging the lazy RCU 1080 * callbacks in the list of pending callbacks. Until then, this 1081 * function may only be called from __kfree_rcu(). 1082 * 1083 * Because there is no preemptible RCU, we use RCU-sched instead. 1084 */ 1085void kfree_call_rcu(struct rcu_head *head, 1086 void (*func)(struct rcu_head *rcu)) 1087{ 1088 __call_rcu(head, func, &rcu_sched_state, -1, 1); 1089} 1090EXPORT_SYMBOL_GPL(kfree_call_rcu); 1091 1092/* 1093 * Wait for an rcu-preempt grace period, but make it happen quickly. 1094 * But because preemptible RCU does not exist, map to rcu-sched. 1095 */ 1096void synchronize_rcu_expedited(void) 1097{ 1098 synchronize_sched_expedited(); 1099} 1100EXPORT_SYMBOL_GPL(synchronize_rcu_expedited); 1101 1102#ifdef CONFIG_HOTPLUG_CPU 1103 1104/* 1105 * Because preemptible RCU does not exist, there is never any need to 1106 * report on tasks preempted in RCU read-side critical sections during 1107 * expedited RCU grace periods. 1108 */ 1109static void rcu_report_exp_rnp(struct rcu_state *rsp, struct rcu_node *rnp, 1110 bool wake) 1111{ 1112} 1113 1114#endif /* #ifdef CONFIG_HOTPLUG_CPU */ 1115 1116/* 1117 * Because preemptible RCU does not exist, rcu_barrier() is just 1118 * another name for rcu_barrier_sched(). 1119 */ 1120void rcu_barrier(void) 1121{ 1122 rcu_barrier_sched(); 1123} 1124EXPORT_SYMBOL_GPL(rcu_barrier); 1125 1126/* 1127 * Because preemptible RCU does not exist, it need not be initialized. 1128 */ 1129static void __init __rcu_init_preempt(void) 1130{ 1131} 1132 1133/* 1134 * Because preemptible RCU does not exist, tasks cannot possibly exit 1135 * while in preemptible RCU read-side critical sections. 1136 */ 1137void exit_rcu(void) 1138{ 1139} 1140 1141#endif /* #else #ifdef CONFIG_TREE_PREEMPT_RCU */ 1142 1143#ifdef CONFIG_RCU_BOOST 1144 1145#include "../locking/rtmutex_common.h" 1146 1147#ifdef CONFIG_RCU_TRACE 1148 1149static void rcu_initiate_boost_trace(struct rcu_node *rnp) 1150{ 1151 if (list_empty(&rnp->blkd_tasks)) 1152 rnp->n_balk_blkd_tasks++; 1153 else if (rnp->exp_tasks == NULL && rnp->gp_tasks == NULL) 1154 rnp->n_balk_exp_gp_tasks++; 1155 else if (rnp->gp_tasks != NULL && rnp->boost_tasks != NULL) 1156 rnp->n_balk_boost_tasks++; 1157 else if (rnp->gp_tasks != NULL && rnp->qsmask != 0) 1158 rnp->n_balk_notblocked++; 1159 else if (rnp->gp_tasks != NULL && 1160 ULONG_CMP_LT(jiffies, rnp->boost_time)) 1161 rnp->n_balk_notyet++; 1162 else 1163 rnp->n_balk_nos++; 1164} 1165 1166#else /* #ifdef CONFIG_RCU_TRACE */ 1167 1168static void rcu_initiate_boost_trace(struct rcu_node *rnp) 1169{ 1170} 1171 1172#endif /* #else #ifdef CONFIG_RCU_TRACE */ 1173 1174static void rcu_wake_cond(struct task_struct *t, int status) 1175{ 1176 /* 1177 * If the thread is yielding, only wake it when this 1178 * is invoked from idle 1179 */ 1180 if (status != RCU_KTHREAD_YIELDING || is_idle_task(current)) 1181 wake_up_process(t); 1182} 1183 1184/* 1185 * Carry out RCU priority boosting on the task indicated by ->exp_tasks 1186 * or ->boost_tasks, advancing the pointer to the next task in the 1187 * ->blkd_tasks list. 1188 * 1189 * Note that irqs must be enabled: boosting the task can block. 1190 * Returns 1 if there are more tasks needing to be boosted. 1191 */ 1192static int rcu_boost(struct rcu_node *rnp) 1193{ 1194 unsigned long flags; 1195 struct rt_mutex mtx; 1196 struct task_struct *t; 1197 struct list_head *tb; 1198 1199 if (rnp->exp_tasks == NULL && rnp->boost_tasks == NULL) 1200 return 0; /* Nothing left to boost. */ 1201 1202 raw_spin_lock_irqsave(&rnp->lock, flags); 1203 smp_mb__after_unlock_lock(); 1204 1205 /* 1206 * Recheck under the lock: all tasks in need of boosting 1207 * might exit their RCU read-side critical sections on their own. 1208 */ 1209 if (rnp->exp_tasks == NULL && rnp->boost_tasks == NULL) { 1210 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1211 return 0; 1212 } 1213 1214 /* 1215 * Preferentially boost tasks blocking expedited grace periods. 1216 * This cannot starve the normal grace periods because a second 1217 * expedited grace period must boost all blocked tasks, including 1218 * those blocking the pre-existing normal grace period. 1219 */ 1220 if (rnp->exp_tasks != NULL) { 1221 tb = rnp->exp_tasks; 1222 rnp->n_exp_boosts++; 1223 } else { 1224 tb = rnp->boost_tasks; 1225 rnp->n_normal_boosts++; 1226 } 1227 rnp->n_tasks_boosted++; 1228 1229 /* 1230 * We boost task t by manufacturing an rt_mutex that appears to 1231 * be held by task t. We leave a pointer to that rt_mutex where 1232 * task t can find it, and task t will release the mutex when it 1233 * exits its outermost RCU read-side critical section. Then 1234 * simply acquiring this artificial rt_mutex will boost task 1235 * t's priority. (Thanks to tglx for suggesting this approach!) 1236 * 1237 * Note that task t must acquire rnp->lock to remove itself from 1238 * the ->blkd_tasks list, which it will do from exit() if from 1239 * nowhere else. We therefore are guaranteed that task t will 1240 * stay around at least until we drop rnp->lock. Note that 1241 * rnp->lock also resolves races between our priority boosting 1242 * and task t's exiting its outermost RCU read-side critical 1243 * section. 1244 */ 1245 t = container_of(tb, struct task_struct, rcu_node_entry); 1246 rt_mutex_init_proxy_locked(&mtx, t); 1247 t->rcu_boost_mutex = &mtx; 1248 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1249 rt_mutex_lock(&mtx); /* Side effect: boosts task t's priority. */ 1250 rt_mutex_unlock(&mtx); /* Keep lockdep happy. */ 1251 1252 return ACCESS_ONCE(rnp->exp_tasks) != NULL || 1253 ACCESS_ONCE(rnp->boost_tasks) != NULL; 1254} 1255 1256/* 1257 * Priority-boosting kthread. One per leaf rcu_node and one for the 1258 * root rcu_node. 1259 */ 1260static int rcu_boost_kthread(void *arg) 1261{ 1262 struct rcu_node *rnp = (struct rcu_node *)arg; 1263 int spincnt = 0; 1264 int more2boost; 1265 1266 trace_rcu_utilization(TPS("Start boost kthread@init")); 1267 for (;;) { 1268 rnp->boost_kthread_status = RCU_KTHREAD_WAITING; 1269 trace_rcu_utilization(TPS("End boost kthread@rcu_wait")); 1270 rcu_wait(rnp->boost_tasks || rnp->exp_tasks); 1271 trace_rcu_utilization(TPS("Start boost kthread@rcu_wait")); 1272 rnp->boost_kthread_status = RCU_KTHREAD_RUNNING; 1273 more2boost = rcu_boost(rnp); 1274 if (more2boost) 1275 spincnt++; 1276 else 1277 spincnt = 0; 1278 if (spincnt > 10) { 1279 rnp->boost_kthread_status = RCU_KTHREAD_YIELDING; 1280 trace_rcu_utilization(TPS("End boost kthread@rcu_yield")); 1281 schedule_timeout_interruptible(2); 1282 trace_rcu_utilization(TPS("Start boost kthread@rcu_yield")); 1283 spincnt = 0; 1284 } 1285 } 1286 /* NOTREACHED */ 1287 trace_rcu_utilization(TPS("End boost kthread@notreached")); 1288 return 0; 1289} 1290 1291/* 1292 * Check to see if it is time to start boosting RCU readers that are 1293 * blocking the current grace period, and, if so, tell the per-rcu_node 1294 * kthread to start boosting them. If there is an expedited grace 1295 * period in progress, it is always time to boost. 1296 * 1297 * The caller must hold rnp->lock, which this function releases. 1298 * The ->boost_kthread_task is immortal, so we don't need to worry 1299 * about it going away. 1300 */ 1301static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags) 1302{ 1303 struct task_struct *t; 1304 1305 if (!rcu_preempt_blocked_readers_cgp(rnp) && rnp->exp_tasks == NULL) { 1306 rnp->n_balk_exp_gp_tasks++; 1307 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1308 return; 1309 } 1310 if (rnp->exp_tasks != NULL || 1311 (rnp->gp_tasks != NULL && 1312 rnp->boost_tasks == NULL && 1313 rnp->qsmask == 0 && 1314 ULONG_CMP_GE(jiffies, rnp->boost_time))) { 1315 if (rnp->exp_tasks == NULL) 1316 rnp->boost_tasks = rnp->gp_tasks; 1317 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1318 t = rnp->boost_kthread_task; 1319 if (t) 1320 rcu_wake_cond(t, rnp->boost_kthread_status); 1321 } else { 1322 rcu_initiate_boost_trace(rnp); 1323 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1324 } 1325} 1326 1327/* 1328 * Wake up the per-CPU kthread to invoke RCU callbacks. 1329 */ 1330static void invoke_rcu_callbacks_kthread(void) 1331{ 1332 unsigned long flags; 1333 1334 local_irq_save(flags); 1335 __this_cpu_write(rcu_cpu_has_work, 1); 1336 if (__this_cpu_read(rcu_cpu_kthread_task) != NULL && 1337 current != __this_cpu_read(rcu_cpu_kthread_task)) { 1338 rcu_wake_cond(__this_cpu_read(rcu_cpu_kthread_task), 1339 __this_cpu_read(rcu_cpu_kthread_status)); 1340 } 1341 local_irq_restore(flags); 1342} 1343 1344/* 1345 * Is the current CPU running the RCU-callbacks kthread? 1346 * Caller must have preemption disabled. 1347 */ 1348static bool rcu_is_callbacks_kthread(void) 1349{ 1350 return __this_cpu_read(rcu_cpu_kthread_task) == current; 1351} 1352 1353#define RCU_BOOST_DELAY_JIFFIES DIV_ROUND_UP(CONFIG_RCU_BOOST_DELAY * HZ, 1000) 1354 1355/* 1356 * Do priority-boost accounting for the start of a new grace period. 1357 */ 1358static void rcu_preempt_boost_start_gp(struct rcu_node *rnp) 1359{ 1360 rnp->boost_time = jiffies + RCU_BOOST_DELAY_JIFFIES; 1361} 1362 1363/* 1364 * Create an RCU-boost kthread for the specified node if one does not 1365 * already exist. We only create this kthread for preemptible RCU. 1366 * Returns zero if all is well, a negated errno otherwise. 1367 */ 1368static int rcu_spawn_one_boost_kthread(struct rcu_state *rsp, 1369 struct rcu_node *rnp) 1370{ 1371 int rnp_index = rnp - &rsp->node[0]; 1372 unsigned long flags; 1373 struct sched_param sp; 1374 struct task_struct *t; 1375 1376 if (&rcu_preempt_state != rsp) 1377 return 0; 1378 1379 if (!rcu_scheduler_fully_active || rnp->qsmaskinit == 0) 1380 return 0; 1381 1382 rsp->boost = 1; 1383 if (rnp->boost_kthread_task != NULL) 1384 return 0; 1385 t = kthread_create(rcu_boost_kthread, (void *)rnp, 1386 "rcub/%d", rnp_index); 1387 if (IS_ERR(t)) 1388 return PTR_ERR(t); 1389 raw_spin_lock_irqsave(&rnp->lock, flags); 1390 smp_mb__after_unlock_lock(); 1391 rnp->boost_kthread_task = t; 1392 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1393 sp.sched_priority = RCU_BOOST_PRIO; 1394 sched_setscheduler_nocheck(t, SCHED_FIFO, &sp); 1395 wake_up_process(t); /* get to TASK_INTERRUPTIBLE quickly. */ 1396 return 0; 1397} 1398 1399static void rcu_kthread_do_work(void) 1400{ 1401 rcu_do_batch(&rcu_sched_state, this_cpu_ptr(&rcu_sched_data)); 1402 rcu_do_batch(&rcu_bh_state, this_cpu_ptr(&rcu_bh_data)); 1403 rcu_preempt_do_callbacks(); 1404} 1405 1406static void rcu_cpu_kthread_setup(unsigned int cpu) 1407{ 1408 struct sched_param sp; 1409 1410 sp.sched_priority = RCU_KTHREAD_PRIO; 1411 sched_setscheduler_nocheck(current, SCHED_FIFO, &sp); 1412} 1413 1414static void rcu_cpu_kthread_park(unsigned int cpu) 1415{ 1416 per_cpu(rcu_cpu_kthread_status, cpu) = RCU_KTHREAD_OFFCPU; 1417} 1418 1419static int rcu_cpu_kthread_should_run(unsigned int cpu) 1420{ 1421 return __this_cpu_read(rcu_cpu_has_work); 1422} 1423 1424/* 1425 * Per-CPU kernel thread that invokes RCU callbacks. This replaces the 1426 * RCU softirq used in flavors and configurations of RCU that do not 1427 * support RCU priority boosting. 1428 */ 1429static void rcu_cpu_kthread(unsigned int cpu) 1430{ 1431 unsigned int *statusp = this_cpu_ptr(&rcu_cpu_kthread_status); 1432 char work, *workp = this_cpu_ptr(&rcu_cpu_has_work); 1433 int spincnt; 1434 1435 for (spincnt = 0; spincnt < 10; spincnt++) { 1436 trace_rcu_utilization(TPS("Start CPU kthread@rcu_wait")); 1437 local_bh_disable(); 1438 *statusp = RCU_KTHREAD_RUNNING; 1439 this_cpu_inc(rcu_cpu_kthread_loops); 1440 local_irq_disable(); 1441 work = *workp; 1442 *workp = 0; 1443 local_irq_enable(); 1444 if (work) 1445 rcu_kthread_do_work(); 1446 local_bh_enable(); 1447 if (*workp == 0) { 1448 trace_rcu_utilization(TPS("End CPU kthread@rcu_wait")); 1449 *statusp = RCU_KTHREAD_WAITING; 1450 return; 1451 } 1452 } 1453 *statusp = RCU_KTHREAD_YIELDING; 1454 trace_rcu_utilization(TPS("Start CPU kthread@rcu_yield")); 1455 schedule_timeout_interruptible(2); 1456 trace_rcu_utilization(TPS("End CPU kthread@rcu_yield")); 1457 *statusp = RCU_KTHREAD_WAITING; 1458} 1459 1460/* 1461 * Set the per-rcu_node kthread's affinity to cover all CPUs that are 1462 * served by the rcu_node in question. The CPU hotplug lock is still 1463 * held, so the value of rnp->qsmaskinit will be stable. 1464 * 1465 * We don't include outgoingcpu in the affinity set, use -1 if there is 1466 * no outgoing CPU. If there are no CPUs left in the affinity set, 1467 * this function allows the kthread to execute on any CPU. 1468 */ 1469static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu) 1470{ 1471 struct task_struct *t = rnp->boost_kthread_task; 1472 unsigned long mask = rnp->qsmaskinit; 1473 cpumask_var_t cm; 1474 int cpu; 1475 1476 if (!t) 1477 return; 1478 if (!zalloc_cpumask_var(&cm, GFP_KERNEL)) 1479 return; 1480 for (cpu = rnp->grplo; cpu <= rnp->grphi; cpu++, mask >>= 1) 1481 if ((mask & 0x1) && cpu != outgoingcpu) 1482 cpumask_set_cpu(cpu, cm); 1483 if (cpumask_weight(cm) == 0) { 1484 cpumask_setall(cm); 1485 for (cpu = rnp->grplo; cpu <= rnp->grphi; cpu++) 1486 cpumask_clear_cpu(cpu, cm); 1487 WARN_ON_ONCE(cpumask_weight(cm) == 0); 1488 } 1489 set_cpus_allowed_ptr(t, cm); 1490 free_cpumask_var(cm); 1491} 1492 1493static struct smp_hotplug_thread rcu_cpu_thread_spec = { 1494 .store = &rcu_cpu_kthread_task, 1495 .thread_should_run = rcu_cpu_kthread_should_run, 1496 .thread_fn = rcu_cpu_kthread, 1497 .thread_comm = "rcuc/%u", 1498 .setup = rcu_cpu_kthread_setup, 1499 .park = rcu_cpu_kthread_park, 1500}; 1501 1502/* 1503 * Spawn all kthreads -- called as soon as the scheduler is running. 1504 */ 1505static int __init rcu_spawn_kthreads(void) 1506{ 1507 struct rcu_node *rnp; 1508 int cpu; 1509 1510 rcu_scheduler_fully_active = 1; 1511 for_each_possible_cpu(cpu) 1512 per_cpu(rcu_cpu_has_work, cpu) = 0; 1513 BUG_ON(smpboot_register_percpu_thread(&rcu_cpu_thread_spec)); 1514 rnp = rcu_get_root(rcu_state); 1515 (void)rcu_spawn_one_boost_kthread(rcu_state, rnp); 1516 if (NUM_RCU_NODES > 1) { 1517 rcu_for_each_leaf_node(rcu_state, rnp) 1518 (void)rcu_spawn_one_boost_kthread(rcu_state, rnp); 1519 } 1520 return 0; 1521} 1522early_initcall(rcu_spawn_kthreads); 1523 1524static void rcu_prepare_kthreads(int cpu) 1525{ 1526 struct rcu_data *rdp = per_cpu_ptr(rcu_state->rda, cpu); 1527 struct rcu_node *rnp = rdp->mynode; 1528 1529 /* Fire up the incoming CPU's kthread and leaf rcu_node kthread. */ 1530 if (rcu_scheduler_fully_active) 1531 (void)rcu_spawn_one_boost_kthread(rcu_state, rnp); 1532} 1533 1534#else /* #ifdef CONFIG_RCU_BOOST */ 1535 1536static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags) 1537{ 1538 raw_spin_unlock_irqrestore(&rnp->lock, flags); 1539} 1540 1541static void invoke_rcu_callbacks_kthread(void) 1542{ 1543 WARN_ON_ONCE(1); 1544} 1545 1546static bool rcu_is_callbacks_kthread(void) 1547{ 1548 return false; 1549} 1550 1551static void rcu_preempt_boost_start_gp(struct rcu_node *rnp) 1552{ 1553} 1554 1555static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu) 1556{ 1557} 1558 1559static int __init rcu_scheduler_really_started(void) 1560{ 1561 rcu_scheduler_fully_active = 1; 1562 return 0; 1563} 1564early_initcall(rcu_scheduler_really_started); 1565 1566static void rcu_prepare_kthreads(int cpu) 1567{ 1568} 1569 1570#endif /* #else #ifdef CONFIG_RCU_BOOST */ 1571 1572#if !defined(CONFIG_RCU_FAST_NO_HZ) 1573 1574/* 1575 * Check to see if any future RCU-related work will need to be done 1576 * by the current CPU, even if none need be done immediately, returning 1577 * 1 if so. This function is part of the RCU implementation; it is -not- 1578 * an exported member of the RCU API. 1579 * 1580 * Because we not have RCU_FAST_NO_HZ, just check whether this CPU needs 1581 * any flavor of RCU. 1582 */ 1583int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies) 1584{ 1585 *delta_jiffies = ULONG_MAX; 1586 return rcu_cpu_has_callbacks(cpu, NULL); 1587} 1588 1589/* 1590 * Because we do not have RCU_FAST_NO_HZ, don't bother cleaning up 1591 * after it. 1592 */ 1593static void rcu_cleanup_after_idle(int cpu) 1594{ 1595} 1596 1597/* 1598 * Do the idle-entry grace-period work, which, because CONFIG_RCU_FAST_NO_HZ=n, 1599 * is nothing. 1600 */ 1601static void rcu_prepare_for_idle(int cpu) 1602{ 1603} 1604 1605/* 1606 * Don't bother keeping a running count of the number of RCU callbacks 1607 * posted because CONFIG_RCU_FAST_NO_HZ=n. 1608 */ 1609static void rcu_idle_count_callbacks_posted(void) 1610{ 1611} 1612 1613#else /* #if !defined(CONFIG_RCU_FAST_NO_HZ) */ 1614 1615/* 1616 * This code is invoked when a CPU goes idle, at which point we want 1617 * to have the CPU do everything required for RCU so that it can enter 1618 * the energy-efficient dyntick-idle mode. This is handled by a 1619 * state machine implemented by rcu_prepare_for_idle() below. 1620 * 1621 * The following three proprocessor symbols control this state machine: 1622 * 1623 * RCU_IDLE_GP_DELAY gives the number of jiffies that a CPU is permitted 1624 * to sleep in dyntick-idle mode with RCU callbacks pending. This 1625 * is sized to be roughly one RCU grace period. Those energy-efficiency 1626 * benchmarkers who might otherwise be tempted to set this to a large 1627 * number, be warned: Setting RCU_IDLE_GP_DELAY too high can hang your 1628 * system. And if you are -that- concerned about energy efficiency, 1629 * just power the system down and be done with it! 1630 * RCU_IDLE_LAZY_GP_DELAY gives the number of jiffies that a CPU is 1631 * permitted to sleep in dyntick-idle mode with only lazy RCU 1632 * callbacks pending. Setting this too high can OOM your system. 1633 * 1634 * The values below work well in practice. If future workloads require 1635 * adjustment, they can be converted into kernel config parameters, though 1636 * making the state machine smarter might be a better option. 1637 */ 1638#define RCU_IDLE_GP_DELAY 4 /* Roughly one grace period. */ 1639#define RCU_IDLE_LAZY_GP_DELAY (6 * HZ) /* Roughly six seconds. */ 1640 1641static int rcu_idle_gp_delay = RCU_IDLE_GP_DELAY; 1642module_param(rcu_idle_gp_delay, int, 0644); 1643static int rcu_idle_lazy_gp_delay = RCU_IDLE_LAZY_GP_DELAY; 1644module_param(rcu_idle_lazy_gp_delay, int, 0644); 1645 1646extern int tick_nohz_enabled; 1647 1648/* 1649 * Try to advance callbacks for all flavors of RCU on the current CPU, but 1650 * only if it has been awhile since the last time we did so. Afterwards, 1651 * if there are any callbacks ready for immediate invocation, return true. 1652 */ 1653static bool rcu_try_advance_all_cbs(void) 1654{ 1655 bool cbs_ready = false; 1656 struct rcu_data *rdp; 1657 struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks); 1658 struct rcu_node *rnp; 1659 struct rcu_state *rsp; 1660 1661 /* Exit early if we advanced recently. */ 1662 if (jiffies == rdtp->last_advance_all) 1663 return 0; 1664 rdtp->last_advance_all = jiffies; 1665 1666 for_each_rcu_flavor(rsp) { 1667 rdp = this_cpu_ptr(rsp->rda); 1668 rnp = rdp->mynode; 1669 1670 /* 1671 * Don't bother checking unless a grace period has 1672 * completed since we last checked and there are 1673 * callbacks not yet ready to invoke. 1674 */ 1675 if (rdp->completed != rnp->completed && 1676 rdp->nxttail[RCU_DONE_TAIL] != rdp->nxttail[RCU_NEXT_TAIL]) 1677 note_gp_changes(rsp, rdp); 1678 1679 if (cpu_has_callbacks_ready_to_invoke(rdp)) 1680 cbs_ready = true; 1681 } 1682 return cbs_ready; 1683} 1684 1685/* 1686 * Allow the CPU to enter dyntick-idle mode unless it has callbacks ready 1687 * to invoke. If the CPU has callbacks, try to advance them. Tell the 1688 * caller to set the timeout based on whether or not there are non-lazy 1689 * callbacks. 1690 * 1691 * The caller must have disabled interrupts. 1692 */ 1693int rcu_needs_cpu(int cpu, unsigned long *dj) 1694{ 1695 struct rcu_dynticks *rdtp = &per_cpu(rcu_dynticks, cpu); 1696 1697 /* Snapshot to detect later posting of non-lazy callback. */ 1698 rdtp->nonlazy_posted_snap = rdtp->nonlazy_posted; 1699 1700 /* If no callbacks, RCU doesn't need the CPU. */ 1701 if (!rcu_cpu_has_callbacks(cpu, &rdtp->all_lazy)) { 1702 *dj = ULONG_MAX; 1703 return 0; 1704 } 1705 1706 /* Attempt to advance callbacks. */ 1707 if (rcu_try_advance_all_cbs()) { 1708 /* Some ready to invoke, so initiate later invocation. */ 1709 invoke_rcu_core(); 1710 return 1; 1711 } 1712 rdtp->last_accelerate = jiffies; 1713 1714 /* Request timer delay depending on laziness, and round. */ 1715 if (!rdtp->all_lazy) { 1716 *dj = round_up(rcu_idle_gp_delay + jiffies, 1717 rcu_idle_gp_delay) - jiffies; 1718 } else { 1719 *dj = round_jiffies(rcu_idle_lazy_gp_delay + jiffies) - jiffies; 1720 } 1721 return 0; 1722} 1723 1724/* 1725 * Prepare a CPU for idle from an RCU perspective. The first major task 1726 * is to sense whether nohz mode has been enabled or disabled via sysfs. 1727 * The second major task is to check to see if a non-lazy callback has 1728 * arrived at a CPU that previously had only lazy callbacks. The third 1729 * major task is to accelerate (that is, assign grace-period numbers to) 1730 * any recently arrived callbacks. 1731 * 1732 * The caller must have disabled interrupts. 1733 */ 1734static void rcu_prepare_for_idle(int cpu) 1735{ 1736 struct rcu_data *rdp; 1737 struct rcu_dynticks *rdtp = &per_cpu(rcu_dynticks, cpu); 1738 struct rcu_node *rnp; 1739 struct rcu_state *rsp; 1740 int tne; 1741 1742 /* Handle nohz enablement switches conservatively. */ 1743 tne = ACCESS_ONCE(tick_nohz_enabled); 1744 if (tne != rdtp->tick_nohz_enabled_snap) { 1745 if (rcu_cpu_has_callbacks(cpu, NULL)) 1746 invoke_rcu_core(); /* force nohz to see update. */ 1747 rdtp->tick_nohz_enabled_snap = tne; 1748 return; 1749 } 1750 if (!tne) 1751 return; 1752 1753 /* If this is a no-CBs CPU, no callbacks, just return. */ 1754 if (rcu_is_nocb_cpu(cpu)) 1755 return; 1756 1757 /* 1758 * If a non-lazy callback arrived at a CPU having only lazy 1759 * callbacks, invoke RCU core for the side-effect of recalculating 1760 * idle duration on re-entry to idle. 1761 */ 1762 if (rdtp->all_lazy && 1763 rdtp->nonlazy_posted != rdtp->nonlazy_posted_snap) { 1764 rdtp->all_lazy = false; 1765 rdtp->nonlazy_posted_snap = rdtp->nonlazy_posted; 1766 invoke_rcu_core(); 1767 return; 1768 } 1769 1770 /* 1771 * If we have not yet accelerated this jiffy, accelerate all 1772 * callbacks on this CPU. 1773 */ 1774 if (rdtp->last_accelerate == jiffies) 1775 return; 1776 rdtp->last_accelerate = jiffies; 1777 for_each_rcu_flavor(rsp) { 1778 rdp = per_cpu_ptr(rsp->rda, cpu); 1779 if (!*rdp->nxttail[RCU_DONE_TAIL]) 1780 continue; 1781 rnp = rdp->mynode; 1782 raw_spin_lock(&rnp->lock); /* irqs already disabled. */ 1783 smp_mb__after_unlock_lock(); 1784 rcu_accelerate_cbs(rsp, rnp, rdp); 1785 raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */ 1786 } 1787} 1788 1789/* 1790 * Clean up for exit from idle. Attempt to advance callbacks based on 1791 * any grace periods that elapsed while the CPU was idle, and if any 1792 * callbacks are now ready to invoke, initiate invocation. 1793 */ 1794static void rcu_cleanup_after_idle(int cpu) 1795{ 1796 1797 if (rcu_is_nocb_cpu(cpu)) 1798 return; 1799 if (rcu_try_advance_all_cbs()) 1800 invoke_rcu_core(); 1801} 1802 1803/* 1804 * Keep a running count of the number of non-lazy callbacks posted 1805 * on this CPU. This running counter (which is never decremented) allows 1806 * rcu_prepare_for_idle() to detect when something out of the idle loop 1807 * posts a callback, even if an equal number of callbacks are invoked. 1808 * Of course, callbacks should only be posted from within a trace event 1809 * designed to be called from idle or from within RCU_NONIDLE(). 1810 */ 1811static void rcu_idle_count_callbacks_posted(void) 1812{ 1813 __this_cpu_add(rcu_dynticks.nonlazy_posted, 1); 1814} 1815 1816/* 1817 * Data for flushing lazy RCU callbacks at OOM time. 1818 */ 1819static atomic_t oom_callback_count; 1820static DECLARE_WAIT_QUEUE_HEAD(oom_callback_wq); 1821 1822/* 1823 * RCU OOM callback -- decrement the outstanding count and deliver the 1824 * wake-up if we are the last one. 1825 */ 1826static void rcu_oom_callback(struct rcu_head *rhp) 1827{ 1828 if (atomic_dec_and_test(&oom_callback_count)) 1829 wake_up(&oom_callback_wq); 1830} 1831 1832/* 1833 * Post an rcu_oom_notify callback on the current CPU if it has at 1834 * least one lazy callback. This will unnecessarily post callbacks 1835 * to CPUs that already have a non-lazy callback at the end of their 1836 * callback list, but this is an infrequent operation, so accept some 1837 * extra overhead to keep things simple. 1838 */ 1839static void rcu_oom_notify_cpu(void *unused) 1840{ 1841 struct rcu_state *rsp; 1842 struct rcu_data *rdp; 1843 1844 for_each_rcu_flavor(rsp) { 1845 rdp = __this_cpu_ptr(rsp->rda); 1846 if (rdp->qlen_lazy != 0) { 1847 atomic_inc(&oom_callback_count); 1848 rsp->call(&rdp->oom_head, rcu_oom_callback); 1849 } 1850 } 1851} 1852 1853/* 1854 * If low on memory, ensure that each CPU has a non-lazy callback. 1855 * This will wake up CPUs that have only lazy callbacks, in turn 1856 * ensuring that they free up the corresponding memory in a timely manner. 1857 * Because an uncertain amount of memory will be freed in some uncertain 1858 * timeframe, we do not claim to have freed anything. 1859 */ 1860static int rcu_oom_notify(struct notifier_block *self, 1861 unsigned long notused, void *nfreed) 1862{ 1863 int cpu; 1864 1865 /* Wait for callbacks from earlier instance to complete. */ 1866 wait_event(oom_callback_wq, atomic_read(&oom_callback_count) == 0); 1867 1868 /* 1869 * Prevent premature wakeup: ensure that all increments happen 1870 * before there is a chance of the counter reaching zero. 1871 */ 1872 atomic_set(&oom_callback_count, 1); 1873 1874 get_online_cpus(); 1875 for_each_online_cpu(cpu) { 1876 smp_call_function_single(cpu, rcu_oom_notify_cpu, NULL, 1); 1877 cond_resched(); 1878 } 1879 put_online_cpus(); 1880 1881 /* Unconditionally decrement: no need to wake ourselves up. */ 1882 atomic_dec(&oom_callback_count); 1883 1884 return NOTIFY_OK; 1885} 1886 1887static struct notifier_block rcu_oom_nb = { 1888 .notifier_call = rcu_oom_notify 1889}; 1890 1891static int __init rcu_register_oom_notifier(void) 1892{ 1893 register_oom_notifier(&rcu_oom_nb); 1894 return 0; 1895} 1896early_initcall(rcu_register_oom_notifier); 1897 1898#endif /* #else #if !defined(CONFIG_RCU_FAST_NO_HZ) */ 1899 1900#ifdef CONFIG_RCU_CPU_STALL_INFO 1901 1902#ifdef CONFIG_RCU_FAST_NO_HZ 1903 1904static void print_cpu_stall_fast_no_hz(char *cp, int cpu) 1905{ 1906 struct rcu_dynticks *rdtp = &per_cpu(rcu_dynticks, cpu); 1907 unsigned long nlpd = rdtp->nonlazy_posted - rdtp->nonlazy_posted_snap; 1908 1909 sprintf(cp, "last_accelerate: %04lx/%04lx, nonlazy_posted: %ld, %c%c", 1910 rdtp->last_accelerate & 0xffff, jiffies & 0xffff, 1911 ulong2long(nlpd), 1912 rdtp->all_lazy ? 'L' : '.', 1913 rdtp->tick_nohz_enabled_snap ? '.' : 'D'); 1914} 1915 1916#else /* #ifdef CONFIG_RCU_FAST_NO_HZ */ 1917 1918static void print_cpu_stall_fast_no_hz(char *cp, int cpu) 1919{ 1920 *cp = '\0'; 1921} 1922 1923#endif /* #else #ifdef CONFIG_RCU_FAST_NO_HZ */ 1924 1925/* Initiate the stall-info list. */ 1926static void print_cpu_stall_info_begin(void) 1927{ 1928 pr_cont("\n"); 1929} 1930 1931/* 1932 * Print out diagnostic information for the specified stalled CPU. 1933 * 1934 * If the specified CPU is aware of the current RCU grace period 1935 * (flavor specified by rsp), then print the number of scheduling 1936 * clock interrupts the CPU has taken during the time that it has 1937 * been aware. Otherwise, print the number of RCU grace periods 1938 * that this CPU is ignorant of, for example, "1" if the CPU was 1939 * aware of the previous grace period. 1940 * 1941 * Also print out idle and (if CONFIG_RCU_FAST_NO_HZ) idle-entry info. 1942 */ 1943static void print_cpu_stall_info(struct rcu_state *rsp, int cpu) 1944{ 1945 char fast_no_hz[72]; 1946 struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu); 1947 struct rcu_dynticks *rdtp = rdp->dynticks; 1948 char *ticks_title; 1949 unsigned long ticks_value; 1950 1951 if (rsp->gpnum == rdp->gpnum) { 1952 ticks_title = "ticks this GP"; 1953 ticks_value = rdp->ticks_this_gp; 1954 } else { 1955 ticks_title = "GPs behind"; 1956 ticks_value = rsp->gpnum - rdp->gpnum; 1957 } 1958 print_cpu_stall_fast_no_hz(fast_no_hz, cpu); 1959 pr_err("\t%d: (%lu %s) idle=%03x/%llx/%d softirq=%u/%u %s\n", 1960 cpu, ticks_value, ticks_title, 1961 atomic_read(&rdtp->dynticks) & 0xfff, 1962 rdtp->dynticks_nesting, rdtp->dynticks_nmi_nesting, 1963 rdp->softirq_snap, kstat_softirqs_cpu(RCU_SOFTIRQ, cpu), 1964 fast_no_hz); 1965} 1966 1967/* Terminate the stall-info list. */ 1968static void print_cpu_stall_info_end(void) 1969{ 1970 pr_err("\t"); 1971} 1972 1973/* Zero ->ticks_this_gp for all flavors of RCU. */ 1974static void zero_cpu_stall_ticks(struct rcu_data *rdp) 1975{ 1976 rdp->ticks_this_gp = 0; 1977 rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); 1978} 1979 1980/* Increment ->ticks_this_gp for all flavors of RCU. */ 1981static void increment_cpu_stall_ticks(void) 1982{ 1983 struct rcu_state *rsp; 1984 1985 for_each_rcu_flavor(rsp) 1986 __this_cpu_ptr(rsp->rda)->ticks_this_gp++; 1987} 1988 1989#else /* #ifdef CONFIG_RCU_CPU_STALL_INFO */ 1990 1991static void print_cpu_stall_info_begin(void) 1992{ 1993 pr_cont(" {"); 1994} 1995 1996static void print_cpu_stall_info(struct rcu_state *rsp, int cpu) 1997{ 1998 pr_cont(" %d", cpu); 1999} 2000 2001static void print_cpu_stall_info_end(void) 2002{ 2003 pr_cont("} "); 2004} 2005 2006static void zero_cpu_stall_ticks(struct rcu_data *rdp) 2007{ 2008} 2009 2010static void increment_cpu_stall_ticks(void) 2011{ 2012} 2013 2014#endif /* #else #ifdef CONFIG_RCU_CPU_STALL_INFO */ 2015 2016#ifdef CONFIG_RCU_NOCB_CPU 2017 2018/* 2019 * Offload callback processing from the boot-time-specified set of CPUs 2020 * specified by rcu_nocb_mask. For each CPU in the set, there is a 2021 * kthread created that pulls the callbacks from the corresponding CPU, 2022 * waits for a grace period to elapse, and invokes the callbacks. 2023 * The no-CBs CPUs do a wake_up() on their kthread when they insert 2024 * a callback into any empty list, unless the rcu_nocb_poll boot parameter 2025 * has been specified, in which case each kthread actively polls its 2026 * CPU. (Which isn't so great for energy efficiency, but which does 2027 * reduce RCU's overhead on that CPU.) 2028 * 2029 * This is intended to be used in conjunction with Frederic Weisbecker's 2030 * adaptive-idle work, which would seriously reduce OS jitter on CPUs 2031 * running CPU-bound user-mode computations. 2032 * 2033 * Offloading of callback processing could also in theory be used as 2034 * an energy-efficiency measure because CPUs with no RCU callbacks 2035 * queued are more aggressive about entering dyntick-idle mode. 2036 */ 2037 2038 2039/* Parse the boot-time rcu_nocb_mask CPU list from the kernel parameters. */ 2040static int __init rcu_nocb_setup(char *str) 2041{ 2042 alloc_bootmem_cpumask_var(&rcu_nocb_mask); 2043 have_rcu_nocb_mask = true; 2044 cpulist_parse(str, rcu_nocb_mask); 2045 return 1; 2046} 2047__setup("rcu_nocbs=", rcu_nocb_setup); 2048 2049static int __init parse_rcu_nocb_poll(char *arg) 2050{ 2051 rcu_nocb_poll = 1; 2052 return 0; 2053} 2054early_param("rcu_nocb_poll", parse_rcu_nocb_poll); 2055 2056/* 2057 * Do any no-CBs CPUs need another grace period? 2058 * 2059 * Interrupts must be disabled. If the caller does not hold the root 2060 * rnp_node structure's ->lock, the results are advisory only. 2061 */ 2062static int rcu_nocb_needs_gp(struct rcu_state *rsp) 2063{ 2064 struct rcu_node *rnp = rcu_get_root(rsp); 2065 2066 return rnp->need_future_gp[(ACCESS_ONCE(rnp->completed) + 1) & 0x1]; 2067} 2068 2069/* 2070 * Wake up any no-CBs CPUs' kthreads that were waiting on the just-ended 2071 * grace period. 2072 */ 2073static void rcu_nocb_gp_cleanup(struct rcu_state *rsp, struct rcu_node *rnp) 2074{ 2075 wake_up_all(&rnp->nocb_gp_wq[rnp->completed & 0x1]); 2076} 2077 2078/* 2079 * Set the root rcu_node structure's ->need_future_gp field 2080 * based on the sum of those of all rcu_node structures. This does 2081 * double-count the root rcu_node structure's requests, but this 2082 * is necessary to handle the possibility of a rcu_nocb_kthread() 2083 * having awakened during the time that the rcu_node structures 2084 * were being updated for the end of the previous grace period. 2085 */ 2086static void rcu_nocb_gp_set(struct rcu_node *rnp, int nrq) 2087{ 2088 rnp->need_future_gp[(rnp->completed + 1) & 0x1] += nrq; 2089} 2090 2091static void rcu_init_one_nocb(struct rcu_node *rnp) 2092{ 2093 init_waitqueue_head(&rnp->nocb_gp_wq[0]); 2094 init_waitqueue_head(&rnp->nocb_gp_wq[1]); 2095} 2096 2097/* Is the specified CPU a no-CPUs CPU? */ 2098bool rcu_is_nocb_cpu(int cpu) 2099{ 2100 if (have_rcu_nocb_mask) 2101 return cpumask_test_cpu(cpu, rcu_nocb_mask); 2102 return false; 2103} 2104 2105/* 2106 * Enqueue the specified string of rcu_head structures onto the specified 2107 * CPU's no-CBs lists. The CPU is specified by rdp, the head of the 2108 * string by rhp, and the tail of the string by rhtp. The non-lazy/lazy 2109 * counts are supplied by rhcount and rhcount_lazy. 2110 * 2111 * If warranted, also wake up the kthread servicing this CPUs queues. 2112 */ 2113static void __call_rcu_nocb_enqueue(struct rcu_data *rdp, 2114 struct rcu_head *rhp, 2115 struct rcu_head **rhtp, 2116 int rhcount, int rhcount_lazy) 2117{ 2118 int len; 2119 struct rcu_head **old_rhpp; 2120 struct task_struct *t; 2121 2122 /* Enqueue the callback on the nocb list and update counts. */ 2123 old_rhpp = xchg(&rdp->nocb_tail, rhtp); 2124 ACCESS_ONCE(*old_rhpp) = rhp; 2125 atomic_long_add(rhcount, &rdp->nocb_q_count); 2126 atomic_long_add(rhcount_lazy, &rdp->nocb_q_count_lazy); 2127 2128 /* If we are not being polled and there is a kthread, awaken it ... */ 2129 t = ACCESS_ONCE(rdp->nocb_kthread); 2130 if (rcu_nocb_poll || !t) { 2131 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2132 TPS("WakeNotPoll")); 2133 return; 2134 } 2135 len = atomic_long_read(&rdp->nocb_q_count); 2136 if (old_rhpp == &rdp->nocb_head) { 2137 wake_up(&rdp->nocb_wq); /* ... only if queue was empty ... */ 2138 rdp->qlen_last_fqs_check = 0; 2139 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("WakeEmpty")); 2140 } else if (len > rdp->qlen_last_fqs_check + qhimark) { 2141 wake_up_process(t); /* ... or if many callbacks queued. */ 2142 rdp->qlen_last_fqs_check = LONG_MAX / 2; 2143 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("WakeOvf")); 2144 } else { 2145 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("WakeNot")); 2146 } 2147 return; 2148} 2149 2150/* 2151 * This is a helper for __call_rcu(), which invokes this when the normal 2152 * callback queue is inoperable. If this is not a no-CBs CPU, this 2153 * function returns failure back to __call_rcu(), which can complain 2154 * appropriately. 2155 * 2156 * Otherwise, this function queues the callback where the corresponding 2157 * "rcuo" kthread can find it. 2158 */ 2159static bool __call_rcu_nocb(struct rcu_data *rdp, struct rcu_head *rhp, 2160 bool lazy) 2161{ 2162 2163 if (!rcu_is_nocb_cpu(rdp->cpu)) 2164 return 0; 2165 __call_rcu_nocb_enqueue(rdp, rhp, &rhp->next, 1, lazy); 2166 if (__is_kfree_rcu_offset((unsigned long)rhp->func)) 2167 trace_rcu_kfree_callback(rdp->rsp->name, rhp, 2168 (unsigned long)rhp->func, 2169 -atomic_long_read(&rdp->nocb_q_count_lazy), 2170 -atomic_long_read(&rdp->nocb_q_count)); 2171 else 2172 trace_rcu_callback(rdp->rsp->name, rhp, 2173 -atomic_long_read(&rdp->nocb_q_count_lazy), 2174 -atomic_long_read(&rdp->nocb_q_count)); 2175 return 1; 2176} 2177 2178/* 2179 * Adopt orphaned callbacks on a no-CBs CPU, or return 0 if this is 2180 * not a no-CBs CPU. 2181 */ 2182static bool __maybe_unused rcu_nocb_adopt_orphan_cbs(struct rcu_state *rsp, 2183 struct rcu_data *rdp) 2184{ 2185 long ql = rsp->qlen; 2186 long qll = rsp->qlen_lazy; 2187 2188 /* If this is not a no-CBs CPU, tell the caller to do it the old way. */ 2189 if (!rcu_is_nocb_cpu(smp_processor_id())) 2190 return 0; 2191 rsp->qlen = 0; 2192 rsp->qlen_lazy = 0; 2193 2194 /* First, enqueue the donelist, if any. This preserves CB ordering. */ 2195 if (rsp->orphan_donelist != NULL) { 2196 __call_rcu_nocb_enqueue(rdp, rsp->orphan_donelist, 2197 rsp->orphan_donetail, ql, qll); 2198 ql = qll = 0; 2199 rsp->orphan_donelist = NULL; 2200 rsp->orphan_donetail = &rsp->orphan_donelist; 2201 } 2202 if (rsp->orphan_nxtlist != NULL) { 2203 __call_rcu_nocb_enqueue(rdp, rsp->orphan_nxtlist, 2204 rsp->orphan_nxttail, ql, qll); 2205 ql = qll = 0; 2206 rsp->orphan_nxtlist = NULL; 2207 rsp->orphan_nxttail = &rsp->orphan_nxtlist; 2208 } 2209 return 1; 2210} 2211 2212/* 2213 * If necessary, kick off a new grace period, and either way wait 2214 * for a subsequent grace period to complete. 2215 */ 2216static void rcu_nocb_wait_gp(struct rcu_data *rdp) 2217{ 2218 unsigned long c; 2219 bool d; 2220 unsigned long flags; 2221 struct rcu_node *rnp = rdp->mynode; 2222 2223 raw_spin_lock_irqsave(&rnp->lock, flags); 2224 smp_mb__after_unlock_lock(); 2225 c = rcu_start_future_gp(rnp, rdp); 2226 raw_spin_unlock_irqrestore(&rnp->lock, flags); 2227 2228 /* 2229 * Wait for the grace period. Do so interruptibly to avoid messing 2230 * up the load average. 2231 */ 2232 trace_rcu_future_gp(rnp, rdp, c, TPS("StartWait")); 2233 for (;;) { 2234 wait_event_interruptible( 2235 rnp->nocb_gp_wq[c & 0x1], 2236 (d = ULONG_CMP_GE(ACCESS_ONCE(rnp->completed), c))); 2237 if (likely(d)) 2238 break; 2239 flush_signals(current); 2240 trace_rcu_future_gp(rnp, rdp, c, TPS("ResumeWait")); 2241 } 2242 trace_rcu_future_gp(rnp, rdp, c, TPS("EndWait")); 2243 smp_mb(); /* Ensure that CB invocation happens after GP end. */ 2244} 2245 2246/* 2247 * Per-rcu_data kthread, but only for no-CBs CPUs. Each kthread invokes 2248 * callbacks queued by the corresponding no-CBs CPU. 2249 */ 2250static int rcu_nocb_kthread(void *arg) 2251{ 2252 int c, cl; 2253 bool firsttime = 1; 2254 struct rcu_head *list; 2255 struct rcu_head *next; 2256 struct rcu_head **tail; 2257 struct rcu_data *rdp = arg; 2258 2259 /* Each pass through this loop invokes one batch of callbacks */ 2260 for (;;) { 2261 /* If not polling, wait for next batch of callbacks. */ 2262 if (!rcu_nocb_poll) { 2263 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2264 TPS("Sleep")); 2265 wait_event_interruptible(rdp->nocb_wq, rdp->nocb_head); 2266 } else if (firsttime) { 2267 firsttime = 0; 2268 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2269 TPS("Poll")); 2270 } 2271 list = ACCESS_ONCE(rdp->nocb_head); 2272 if (!list) { 2273 if (!rcu_nocb_poll) 2274 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2275 TPS("WokeEmpty")); 2276 schedule_timeout_interruptible(1); 2277 flush_signals(current); 2278 continue; 2279 } 2280 firsttime = 1; 2281 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2282 TPS("WokeNonEmpty")); 2283 2284 /* 2285 * Extract queued callbacks, update counts, and wait 2286 * for a grace period to elapse. 2287 */ 2288 ACCESS_ONCE(rdp->nocb_head) = NULL; 2289 tail = xchg(&rdp->nocb_tail, &rdp->nocb_head); 2290 c = atomic_long_xchg(&rdp->nocb_q_count, 0); 2291 cl = atomic_long_xchg(&rdp->nocb_q_count_lazy, 0); 2292 ACCESS_ONCE(rdp->nocb_p_count) += c; 2293 ACCESS_ONCE(rdp->nocb_p_count_lazy) += cl; 2294 rcu_nocb_wait_gp(rdp); 2295 2296 /* Each pass through the following loop invokes a callback. */ 2297 trace_rcu_batch_start(rdp->rsp->name, cl, c, -1); 2298 c = cl = 0; 2299 while (list) { 2300 next = list->next; 2301 /* Wait for enqueuing to complete, if needed. */ 2302 while (next == NULL && &list->next != tail) { 2303 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2304 TPS("WaitQueue")); 2305 schedule_timeout_interruptible(1); 2306 trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, 2307 TPS("WokeQueue")); 2308 next = list->next; 2309 } 2310 debug_rcu_head_unqueue(list); 2311 local_bh_disable(); 2312 if (__rcu_reclaim(rdp->rsp->name, list)) 2313 cl++; 2314 c++; 2315 local_bh_enable(); 2316 list = next; 2317 } 2318 trace_rcu_batch_end(rdp->rsp->name, c, !!list, 0, 0, 1); 2319 ACCESS_ONCE(rdp->nocb_p_count) -= c; 2320 ACCESS_ONCE(rdp->nocb_p_count_lazy) -= cl; 2321 rdp->n_nocbs_invoked += c; 2322 } 2323 return 0; 2324} 2325 2326/* Initialize per-rcu_data variables for no-CBs CPUs. */ 2327static void __init rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp) 2328{ 2329 rdp->nocb_tail = &rdp->nocb_head; 2330 init_waitqueue_head(&rdp->nocb_wq); 2331} 2332 2333/* Create a kthread for each RCU flavor for each no-CBs CPU. */ 2334static void __init rcu_spawn_nocb_kthreads(struct rcu_state *rsp) 2335{ 2336 int cpu; 2337 struct rcu_data *rdp; 2338 struct task_struct *t; 2339 2340 if (rcu_nocb_mask == NULL) 2341 return; 2342 for_each_cpu(cpu, rcu_nocb_mask) { 2343 rdp = per_cpu_ptr(rsp->rda, cpu); 2344 t = kthread_run(rcu_nocb_kthread, rdp, 2345 "rcuo%c/%d", rsp->abbr, cpu); 2346 BUG_ON(IS_ERR(t)); 2347 ACCESS_ONCE(rdp->nocb_kthread) = t; 2348 } 2349} 2350 2351/* Prevent __call_rcu() from enqueuing callbacks on no-CBs CPUs */ 2352static bool init_nocb_callback_list(struct rcu_data *rdp) 2353{ 2354 if (rcu_nocb_mask == NULL || 2355 !cpumask_test_cpu(rdp->cpu, rcu_nocb_mask)) 2356 return false; 2357 rdp->nxttail[RCU_NEXT_TAIL] = NULL; 2358 return true; 2359} 2360 2361#else /* #ifdef CONFIG_RCU_NOCB_CPU */ 2362 2363static int rcu_nocb_needs_gp(struct rcu_state *rsp) 2364{ 2365 return 0; 2366} 2367 2368static void rcu_nocb_gp_cleanup(struct rcu_state *rsp, struct rcu_node *rnp) 2369{ 2370} 2371 2372static void rcu_nocb_gp_set(struct rcu_node *rnp, int nrq) 2373{ 2374} 2375 2376static void rcu_init_one_nocb(struct rcu_node *rnp) 2377{ 2378} 2379 2380static bool __call_rcu_nocb(struct rcu_data *rdp, struct rcu_head *rhp, 2381 bool lazy) 2382{ 2383 return 0; 2384} 2385 2386static bool __maybe_unused rcu_nocb_adopt_orphan_cbs(struct rcu_state *rsp, 2387 struct rcu_data *rdp) 2388{ 2389 return 0; 2390} 2391 2392static void __init rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp) 2393{ 2394} 2395 2396static void __init rcu_spawn_nocb_kthreads(struct rcu_state *rsp) 2397{ 2398} 2399 2400static bool init_nocb_callback_list(struct rcu_data *rdp) 2401{ 2402 return false; 2403} 2404 2405#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */ 2406 2407/* 2408 * An adaptive-ticks CPU can potentially execute in kernel mode for an 2409 * arbitrarily long period of time with the scheduling-clock tick turned 2410 * off. RCU will be paying attention to this CPU because it is in the 2411 * kernel, but the CPU cannot be guaranteed to be executing the RCU state 2412 * machine because the scheduling-clock tick has been disabled. Therefore, 2413 * if an adaptive-ticks CPU is failing to respond to the current grace 2414 * period and has not be idle from an RCU perspective, kick it. 2415 */ 2416static void rcu_kick_nohz_cpu(int cpu) 2417{ 2418#ifdef CONFIG_NO_HZ_FULL 2419 if (tick_nohz_full_cpu(cpu)) 2420 smp_send_reschedule(cpu); 2421#endif /* #ifdef CONFIG_NO_HZ_FULL */ 2422} 2423 2424 2425#ifdef CONFIG_NO_HZ_FULL_SYSIDLE 2426 2427/* 2428 * Define RCU flavor that holds sysidle state. This needs to be the 2429 * most active flavor of RCU. 2430 */ 2431#ifdef CONFIG_PREEMPT_RCU 2432static struct rcu_state *rcu_sysidle_state = &rcu_preempt_state; 2433#else /* #ifdef CONFIG_PREEMPT_RCU */ 2434static struct rcu_state *rcu_sysidle_state = &rcu_sched_state; 2435#endif /* #else #ifdef CONFIG_PREEMPT_RCU */ 2436 2437static int full_sysidle_state; /* Current system-idle state. */ 2438#define RCU_SYSIDLE_NOT 0 /* Some CPU is not idle. */ 2439#define RCU_SYSIDLE_SHORT 1 /* All CPUs idle for brief period. */ 2440#define RCU_SYSIDLE_LONG 2 /* All CPUs idle for long enough. */ 2441#define RCU_SYSIDLE_FULL 3 /* All CPUs idle, ready for sysidle. */ 2442#define RCU_SYSIDLE_FULL_NOTED 4 /* Actually entered sysidle state. */ 2443 2444/* 2445 * Invoked to note exit from irq or task transition to idle. Note that 2446 * usermode execution does -not- count as idle here! After all, we want 2447 * to detect full-system idle states, not RCU quiescent states and grace 2448 * periods. The caller must have disabled interrupts. 2449 */ 2450static void rcu_sysidle_enter(struct rcu_dynticks *rdtp, int irq) 2451{ 2452 unsigned long j; 2453 2454 /* Adjust nesting, check for fully idle. */ 2455 if (irq) { 2456 rdtp->dynticks_idle_nesting--; 2457 WARN_ON_ONCE(rdtp->dynticks_idle_nesting < 0); 2458 if (rdtp->dynticks_idle_nesting != 0) 2459 return; /* Still not fully idle. */ 2460 } else { 2461 if ((rdtp->dynticks_idle_nesting & DYNTICK_TASK_NEST_MASK) == 2462 DYNTICK_TASK_NEST_VALUE) { 2463 rdtp->dynticks_idle_nesting = 0; 2464 } else { 2465 rdtp->dynticks_idle_nesting -= DYNTICK_TASK_NEST_VALUE; 2466 WARN_ON_ONCE(rdtp->dynticks_idle_nesting < 0); 2467 return; /* Still not fully idle. */ 2468 } 2469 } 2470 2471 /* Record start of fully idle period. */ 2472 j = jiffies; 2473 ACCESS_ONCE(rdtp->dynticks_idle_jiffies) = j; 2474 smp_mb__before_atomic_inc(); 2475 atomic_inc(&rdtp->dynticks_idle); 2476 smp_mb__after_atomic_inc(); 2477 WARN_ON_ONCE(atomic_read(&rdtp->dynticks_idle) & 0x1); 2478} 2479 2480/* 2481 * Unconditionally force exit from full system-idle state. This is 2482 * invoked when a normal CPU exits idle, but must be called separately 2483 * for the timekeeping CPU (tick_do_timer_cpu). The reason for this 2484 * is that the timekeeping CPU is permitted to take scheduling-clock 2485 * interrupts while the system is in system-idle state, and of course 2486 * rcu_sysidle_exit() has no way of distinguishing a scheduling-clock 2487 * interrupt from any other type of interrupt. 2488 */ 2489void rcu_sysidle_force_exit(void) 2490{ 2491 int oldstate = ACCESS_ONCE(full_sysidle_state); 2492 int newoldstate; 2493 2494 /* 2495 * Each pass through the following loop attempts to exit full 2496 * system-idle state. If contention proves to be a problem, 2497 * a trylock-based contention tree could be used here. 2498 */ 2499 while (oldstate > RCU_SYSIDLE_SHORT) { 2500 newoldstate = cmpxchg(&full_sysidle_state, 2501 oldstate, RCU_SYSIDLE_NOT); 2502 if (oldstate == newoldstate && 2503 oldstate == RCU_SYSIDLE_FULL_NOTED) { 2504 rcu_kick_nohz_cpu(tick_do_timer_cpu); 2505 return; /* We cleared it, done! */ 2506 } 2507 oldstate = newoldstate; 2508 } 2509 smp_mb(); /* Order initial oldstate fetch vs. later non-idle work. */ 2510} 2511 2512/* 2513 * Invoked to note entry to irq or task transition from idle. Note that 2514 * usermode execution does -not- count as idle here! The caller must 2515 * have disabled interrupts. 2516 */ 2517static void rcu_sysidle_exit(struct rcu_dynticks *rdtp, int irq) 2518{ 2519 /* Adjust nesting, check for already non-idle. */ 2520 if (irq) { 2521 rdtp->dynticks_idle_nesting++; 2522 WARN_ON_ONCE(rdtp->dynticks_idle_nesting <= 0); 2523 if (rdtp->dynticks_idle_nesting != 1) 2524 return; /* Already non-idle. */ 2525 } else { 2526 /* 2527 * Allow for irq misnesting. Yes, it really is possible 2528 * to enter an irq handler then never leave it, and maybe 2529 * also vice versa. Handle both possibilities. 2530 */ 2531 if (rdtp->dynticks_idle_nesting & DYNTICK_TASK_NEST_MASK) { 2532 rdtp->dynticks_idle_nesting += DYNTICK_TASK_NEST_VALUE; 2533 WARN_ON_ONCE(rdtp->dynticks_idle_nesting <= 0); 2534 return; /* Already non-idle. */ 2535 } else { 2536 rdtp->dynticks_idle_nesting = DYNTICK_TASK_EXIT_IDLE; 2537 } 2538 } 2539 2540 /* Record end of idle period. */ 2541 smp_mb__before_atomic_inc(); 2542 atomic_inc(&rdtp->dynticks_idle); 2543 smp_mb__after_atomic_inc(); 2544 WARN_ON_ONCE(!(atomic_read(&rdtp->dynticks_idle) & 0x1)); 2545 2546 /* 2547 * If we are the timekeeping CPU, we are permitted to be non-idle 2548 * during a system-idle state. This must be the case, because 2549 * the timekeeping CPU has to take scheduling-clock interrupts 2550 * during the time that the system is transitioning to full 2551 * system-idle state. This means that the timekeeping CPU must 2552 * invoke rcu_sysidle_force_exit() directly if it does anything 2553 * more than take a scheduling-clock interrupt. 2554 */ 2555 if (smp_processor_id() == tick_do_timer_cpu) 2556 return; 2557 2558 /* Update system-idle state: We are clearly no longer fully idle! */ 2559 rcu_sysidle_force_exit(); 2560} 2561 2562/* 2563 * Check to see if the current CPU is idle. Note that usermode execution 2564 * does not count as idle. The caller must have disabled interrupts. 2565 */ 2566static void rcu_sysidle_check_cpu(struct rcu_data *rdp, bool *isidle, 2567 unsigned long *maxj) 2568{ 2569 int cur; 2570 unsigned long j; 2571 struct rcu_dynticks *rdtp = rdp->dynticks; 2572 2573 /* 2574 * If some other CPU has already reported non-idle, if this is 2575 * not the flavor of RCU that tracks sysidle state, or if this 2576 * is an offline or the timekeeping CPU, nothing to do. 2577 */ 2578 if (!*isidle || rdp->rsp != rcu_sysidle_state || 2579 cpu_is_offline(rdp->cpu) || rdp->cpu == tick_do_timer_cpu) 2580 return; 2581 if (rcu_gp_in_progress(rdp->rsp)) 2582 WARN_ON_ONCE(smp_processor_id() != tick_do_timer_cpu); 2583 2584 /* Pick up current idle and NMI-nesting counter and check. */ 2585 cur = atomic_read(&rdtp->dynticks_idle); 2586 if (cur & 0x1) { 2587 *isidle = false; /* We are not idle! */ 2588 return; 2589 } 2590 smp_mb(); /* Read counters before timestamps. */ 2591 2592 /* Pick up timestamps. */ 2593 j = ACCESS_ONCE(rdtp->dynticks_idle_jiffies); 2594 /* If this CPU entered idle more recently, update maxj timestamp. */ 2595 if (ULONG_CMP_LT(*maxj, j)) 2596 *maxj = j; 2597} 2598 2599/* 2600 * Is this the flavor of RCU that is handling full-system idle? 2601 */ 2602static bool is_sysidle_rcu_state(struct rcu_state *rsp) 2603{ 2604 return rsp == rcu_sysidle_state; 2605} 2606 2607/* 2608 * Bind the grace-period kthread for the sysidle flavor of RCU to the 2609 * timekeeping CPU. 2610 */ 2611static void rcu_bind_gp_kthread(void) 2612{ 2613 int cpu = ACCESS_ONCE(tick_do_timer_cpu); 2614 2615 if (cpu < 0 || cpu >= nr_cpu_ids) 2616 return; 2617 if (raw_smp_processor_id() != cpu) 2618 set_cpus_allowed_ptr(current, cpumask_of(cpu)); 2619} 2620 2621/* 2622 * Return a delay in jiffies based on the number of CPUs, rcu_node 2623 * leaf fanout, and jiffies tick rate. The idea is to allow larger 2624 * systems more time to transition to full-idle state in order to 2625 * avoid the cache thrashing that otherwise occur on the state variable. 2626 * Really small systems (less than a couple of tens of CPUs) should 2627 * instead use a single global atomically incremented counter, and later 2628 * versions of this will automatically reconfigure themselves accordingly. 2629 */ 2630static unsigned long rcu_sysidle_delay(void) 2631{ 2632 if (nr_cpu_ids <= CONFIG_NO_HZ_FULL_SYSIDLE_SMALL) 2633 return 0; 2634 return DIV_ROUND_UP(nr_cpu_ids * HZ, rcu_fanout_leaf * 1000); 2635} 2636 2637/* 2638 * Advance the full-system-idle state. This is invoked when all of 2639 * the non-timekeeping CPUs are idle. 2640 */ 2641static void rcu_sysidle(unsigned long j) 2642{ 2643 /* Check the current state. */ 2644 switch (ACCESS_ONCE(full_sysidle_state)) { 2645 case RCU_SYSIDLE_NOT: 2646 2647 /* First time all are idle, so note a short idle period. */ 2648 ACCESS_ONCE(full_sysidle_state) = RCU_SYSIDLE_SHORT; 2649 break; 2650 2651 case RCU_SYSIDLE_SHORT: 2652 2653 /* 2654 * Idle for a bit, time to advance to next state? 2655 * cmpxchg failure means race with non-idle, let them win. 2656 */ 2657 if (ULONG_CMP_GE(jiffies, j + rcu_sysidle_delay())) 2658 (void)cmpxchg(&full_sysidle_state, 2659 RCU_SYSIDLE_SHORT, RCU_SYSIDLE_LONG); 2660 break; 2661 2662 case RCU_SYSIDLE_LONG: 2663 2664 /* 2665 * Do an additional check pass before advancing to full. 2666 * cmpxchg failure means race with non-idle, let them win. 2667 */ 2668 if (ULONG_CMP_GE(jiffies, j + rcu_sysidle_delay())) 2669 (void)cmpxchg(&full_sysidle_state, 2670 RCU_SYSIDLE_LONG, RCU_SYSIDLE_FULL); 2671 break; 2672 2673 default: 2674 break; 2675 } 2676} 2677 2678/* 2679 * Found a non-idle non-timekeeping CPU, so kick the system-idle state 2680 * back to the beginning. 2681 */ 2682static void rcu_sysidle_cancel(void) 2683{ 2684 smp_mb(); 2685 ACCESS_ONCE(full_sysidle_state) = RCU_SYSIDLE_NOT; 2686} 2687 2688/* 2689 * Update the sysidle state based on the results of a force-quiescent-state 2690 * scan of the CPUs' dyntick-idle state. 2691 */ 2692static void rcu_sysidle_report(struct rcu_state *rsp, int isidle, 2693 unsigned long maxj, bool gpkt) 2694{ 2695 if (rsp != rcu_sysidle_state) 2696 return; /* Wrong flavor, ignore. */ 2697 if (gpkt && nr_cpu_ids <= CONFIG_NO_HZ_FULL_SYSIDLE_SMALL) 2698 return; /* Running state machine from timekeeping CPU. */ 2699 if (isidle) 2700 rcu_sysidle(maxj); /* More idle! */ 2701 else 2702 rcu_sysidle_cancel(); /* Idle is over. */ 2703} 2704 2705/* 2706 * Wrapper for rcu_sysidle_report() when called from the grace-period 2707 * kthread's context. 2708 */ 2709static void rcu_sysidle_report_gp(struct rcu_state *rsp, int isidle, 2710 unsigned long maxj) 2711{ 2712 rcu_sysidle_report(rsp, isidle, maxj, true); 2713} 2714 2715/* Callback and function for forcing an RCU grace period. */ 2716struct rcu_sysidle_head { 2717 struct rcu_head rh; 2718 int inuse; 2719}; 2720 2721static void rcu_sysidle_cb(struct rcu_head *rhp) 2722{ 2723 struct rcu_sysidle_head *rshp; 2724 2725 /* 2726 * The following memory barrier is needed to replace the 2727 * memory barriers that would normally be in the memory 2728 * allocator. 2729 */ 2730 smp_mb(); /* grace period precedes setting inuse. */ 2731 2732 rshp = container_of(rhp, struct rcu_sysidle_head, rh); 2733 ACCESS_ONCE(rshp->inuse) = 0; 2734} 2735 2736/* 2737 * Check to see if the system is fully idle, other than the timekeeping CPU. 2738 * The caller must have disabled interrupts. 2739 */ 2740bool rcu_sys_is_idle(void) 2741{ 2742 static struct rcu_sysidle_head rsh; 2743 int rss = ACCESS_ONCE(full_sysidle_state); 2744 2745 if (WARN_ON_ONCE(smp_processor_id() != tick_do_timer_cpu)) 2746 return false; 2747 2748 /* Handle small-system case by doing a full scan of CPUs. */ 2749 if (nr_cpu_ids <= CONFIG_NO_HZ_FULL_SYSIDLE_SMALL) { 2750 int oldrss = rss - 1; 2751 2752 /* 2753 * One pass to advance to each state up to _FULL. 2754 * Give up if any pass fails to advance the state. 2755 */ 2756 while (rss < RCU_SYSIDLE_FULL && oldrss < rss) { 2757 int cpu; 2758 bool isidle = true; 2759 unsigned long maxj = jiffies - ULONG_MAX / 4; 2760 struct rcu_data *rdp; 2761 2762 /* Scan all the CPUs looking for nonidle CPUs. */ 2763 for_each_possible_cpu(cpu) { 2764 rdp = per_cpu_ptr(rcu_sysidle_state->rda, cpu); 2765 rcu_sysidle_check_cpu(rdp, &isidle, &maxj); 2766 if (!isidle) 2767 break; 2768 } 2769 rcu_sysidle_report(rcu_sysidle_state, 2770 isidle, maxj, false); 2771 oldrss = rss; 2772 rss = ACCESS_ONCE(full_sysidle_state); 2773 } 2774 } 2775 2776 /* If this is the first observation of an idle period, record it. */ 2777 if (rss == RCU_SYSIDLE_FULL) { 2778 rss = cmpxchg(&full_sysidle_state, 2779 RCU_SYSIDLE_FULL, RCU_SYSIDLE_FULL_NOTED); 2780 return rss == RCU_SYSIDLE_FULL; 2781 } 2782 2783 smp_mb(); /* ensure rss load happens before later caller actions. */ 2784 2785 /* If already fully idle, tell the caller (in case of races). */ 2786 if (rss == RCU_SYSIDLE_FULL_NOTED) 2787 return true; 2788 2789 /* 2790 * If we aren't there yet, and a grace period is not in flight, 2791 * initiate a grace period. Either way, tell the caller that 2792 * we are not there yet. We use an xchg() rather than an assignment 2793 * to make up for the memory barriers that would otherwise be 2794 * provided by the memory allocator. 2795 */ 2796 if (nr_cpu_ids > CONFIG_NO_HZ_FULL_SYSIDLE_SMALL && 2797 !rcu_gp_in_progress(rcu_sysidle_state) && 2798 !rsh.inuse && xchg(&rsh.inuse, 1) == 0) 2799 call_rcu(&rsh.rh, rcu_sysidle_cb); 2800 return false; 2801} 2802 2803/* 2804 * Initialize dynticks sysidle state for CPUs coming online. 2805 */ 2806static void rcu_sysidle_init_percpu_data(struct rcu_dynticks *rdtp) 2807{ 2808 rdtp->dynticks_idle_nesting = DYNTICK_TASK_NEST_VALUE; 2809} 2810 2811#else /* #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */ 2812 2813static void rcu_sysidle_enter(struct rcu_dynticks *rdtp, int irq) 2814{ 2815} 2816 2817static void rcu_sysidle_exit(struct rcu_dynticks *rdtp, int irq) 2818{ 2819} 2820 2821static void rcu_sysidle_check_cpu(struct rcu_data *rdp, bool *isidle, 2822 unsigned long *maxj) 2823{ 2824} 2825 2826static bool is_sysidle_rcu_state(struct rcu_state *rsp) 2827{ 2828 return false; 2829} 2830 2831static void rcu_bind_gp_kthread(void) 2832{ 2833} 2834 2835static void rcu_sysidle_report_gp(struct rcu_state *rsp, int isidle, 2836 unsigned long maxj) 2837{ 2838} 2839 2840static void rcu_sysidle_init_percpu_data(struct rcu_dynticks *rdtp) 2841{ 2842} 2843 2844#endif /* #else #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */ 2845