cregit-Linux how code gets into the kernel

Release 4.12 include/linux/rcu_segcblist.h

Directory: include/linux
 * RCU segmented callback lists
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you can access it online at
 * Copyright IBM Corporation, 2017
 * Authors: Paul E. McKenney <>



/* Simple unsegmented callback lists. */

struct rcu_cblist {
struct rcu_head *head;
struct rcu_head **tail;
long len;
long len_lazy;

#define RCU_CBLIST_INITIALIZER(n) { .head = NULL, .tail = &n.head }

/* Complicated segmented callback lists.  ;-) */

 * Index values for segments in rcu_segcblist structure.
 * The segments are as follows:
 * [head, *tails[RCU_DONE_TAIL]):
 *      Callbacks whose grace period has elapsed, and thus can be invoked.
 * [*tails[RCU_DONE_TAIL], *tails[RCU_WAIT_TAIL]):
 *      Callbacks waiting for the current GP from the current CPU's viewpoint.
 * [*tails[RCU_WAIT_TAIL], *tails[RCU_NEXT_READY_TAIL]):
 *      Callbacks that arrived before the next GP started, again from
 *      the current CPU's viewpoint.  These can be handled by the next GP.
 * [*tails[RCU_NEXT_READY_TAIL], *tails[RCU_NEXT_TAIL]):
 *      Callbacks that might have arrived after the next GP started.
 *      There is some uncertainty as to when a given GP starts and
 *      ends, but a CPU knows the exact times if it is the one starting
 *      or ending the GP.  Other CPUs know that the previous GP ends
 *      before the next one starts.
 * Note that RCU_WAIT_TAIL cannot be empty unless RCU_NEXT_READY_TAIL is also
 * empty.
 * The ->gp_seq[] array contains the grace-period number at which the
 * corresponding segment of callbacks will be ready to invoke.  A given
 * element of this array is meaningful only when the corresponding segment
 * is non-empty, and it is never valid for RCU_DONE_TAIL (whose callbacks
 * are already ready to invoke) or for RCU_NEXT_TAIL (whose callbacks have
 * not yet been assigned a grace-period number).

#define RCU_DONE_TAIL		0	
/* Also RCU_WAIT head. */

#define RCU_WAIT_TAIL		1	
/* Also RCU_NEXT_READY head. */

/* Also RCU_NEXT head. */

#define RCU_NEXT_TAIL		3


struct rcu_segcblist {
struct rcu_head *head;
struct rcu_head **tails[RCU_CBLIST_NSEGS];
unsigned long gp_seq[RCU_CBLIST_NSEGS];
long len;
long len_lazy;

{ \
        .head = NULL, \
        .tails[RCU_DONE_TAIL] = &n.head, \
        .tails[RCU_WAIT_TAIL] = &n.head, \
        .tails[RCU_NEXT_READY_TAIL] = &n.head, \
        .tails[RCU_NEXT_TAIL] = &n.head, \


Overall Contributors

Paul E. McKenney10297.14%266.67%
Ingo Molnar32.86%133.33%
Directory: include/linux
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.