Linux RCU队列（3）树形RCU队列实现代码分析

经过之前的分析基本清楚了整个RCU的结构体，下面就通过分代码来解读RCU的实现。

void synchronize_rcu(void)
{
	if (!rcu_scheduler_active)
		return;
	wait_rcu_gp(call_rcu);
}

当rcu_scheduler_active变量将会在第一个任务创建之前由0转换为1.当这个变量等于0的时候，RCU可以假设当前系统中仅仅存在一个任务。这样进行RCU等待就没有必要，所以通过这个变量对初始化时RCU队列进行优化，当这个变量转换为1时，表明系统已经准备好探测真正的grace period。顺便提一下，这里之所以从synchronize_rcu函数开始，是因为这个函数最后会调用call_rcu，而这个函数的指针则是作为参数传递到wait_rcu_gp中。

void wait_rcu_gp(call_rcu_func_t crf)
{
	struct rcu_synchronize rcu;
	init_rcu_head_on_stack(&rcu.head);
	init_completion(&rcu.completion);
	crf(&rcu.head, wakeme_after_rcu);
	wait_for_completion(&rcu.completion);
	destroy_rcu_head_on_stack(&rcu.head);
}

Wait_rcu_gp函数的实现如上图所示，首先从栈中分配一个结构体，这个阶梯就是中包含rcu的实现——一个队列指针，一个函数指针，已经一个同步等待的结构体（如果是异步rcu则没有同步等待结构体）。在初始化之后就转入到调用异步的call_rcu函数中，然后进行等待操作以及对堆栈上的RCU对象进行清理。先看一下wait_for_completion。

void wait_for_completion(struct completion *x)
{
	wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
}

从wait_for_completion函数的实现可以看出，不能在x上进行唤醒操作。则当前函数将会无限等待下去（MAX_SCHEDULE_TIMEOUT）而不会被信号打断（TASK_UNINTERRUPTIBLE）。

static void wakeme_after_rcu(struct rcu_head  *head)
{
	struct rcu_synchronize *rcu;
	rcu = container_of(head, struct rcu_synchronize, head);
	complete(&rcu->completion);
}

再看看wakeme_after_rcu函数的实现，这个函数的实现仅仅唤醒当前正在等待的任务而不会释放内存，因为内存在堆栈中。

void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
{
	__call_rcu(head, func, &rcu_preempt_state);
}
static void
__call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu),
	   struct rcu_state *rsp)
{
	unsigned long flags;
	struct rcu_data *rdp;
	head->func = func;
	head->next = NULL;
	smp_mb(); 
	local_irq_save(flags);
	rdp = this_cpu_ptr(rsp->rda);
	*rdp->nxttail[RCU_NEXT_TAIL] = head;
	rdp->nxttail[RCU_NEXT_TAIL] = &head->next;
	rdp->qlen++;
	if (irqs_disabled_flags(flags)) {
		local_irq_restore(flags);
		return;
	}
	if ((rdp->qlen > rdp->qlen_last_fqs_check + qhimark)) {
		rcu_process_gp_end(rsp, rdp);
		check_for_new_grace_period(rsp, rdp);
		if (!rcu_gp_in_progress(rsp)) {
			unsigned long nestflag;
			struct rcu_node *rnp_root = rcu_get_root(rsp);
			raw_spin_lock_irqsave(&rnp_root->lock, nestflag);
			rcu_start_gp(rsp, nestflag);  /* rlses rnp_root->lock */
		} else {
			rdp->blimit = LONG_MAX;
			if (rsp->n_force_qs == rdp->n_force_qs_snap &&
			    *rdp->nxttail[RCU_DONE_TAIL] != head)
				force_quiescent_state(rsp, 0);
			rdp->n_force_qs_snap = rsp->n_force_qs;
			rdp->qlen_last_fqs_check = rdp->qlen;
		}
	} 
	else if (ULONG_CMP_LT(rsp->jiffies_force_qs, jiffies))
		force_quiescent_state(rsp, 1);
	local_irq_restore(flags);
}

上面是call_rcu的具体实现，不过这个实现只包括一部分。因为还有很大一部分涉及到系统调度相关。

函数的两个参数和函数里面定义的结构体rcu_data结构在之前的讲解中已经介绍了。其中rcu_state是一个全局结构体，而rcu_data则代表一个处理器相关的数据，在rcu_state和rcu_data之间还有一层数据结构rcu_node（稍后会介绍），这三个结构体组成RCU的树形结构。函数开头会将正在等待的参数给挂载到当前处理器的数据节点中，然后相应的队列计数会自加1，当这个计数超过一定的上限就会引起系统强制性开启grace period——毕竟RCU占用了很多额外的内存。

接下来是一个if判断进行流程控制，首先看下面的if部分。根据上面的分析，这里表明挂载到队列的回调函数过多需要进行一次强制性的grace period。函数首先更新状态，表明当前正在进行grace period处理之中。RCU层次处理包含两个层次递降过程：第一次是初始化的时候，利用rcu_start_gp将rsp当中的gpnum给递增上去，然后逐步更新rnp和rdp，同时rdp上的相关处理器位以及其他的资源也需要初始化；这些操作完成之后表明grace period完成，下一步就是逐层的往上争取锁并改变与处理器相应的状态。当所有的处理器都经过依次调度之后达到最上层的rsp则会引起rsp利用gpnum更新completed，并同时更新rnp上的completed，这是导致rnp和rdp上的completed不相等，那么表明grace period结束，需要向上提交回调函数并且更新rdp的completed。下面看一下rcu_process_gp_end的内部实现函数__rcu_process_gp_end。

static void
__rcu_process_gp_end(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp)
{
	if (rdp->completed != rnp->completed) {
		rdp->nxttail[RCU_DONE_TAIL] = rdp->nxttail[RCU_WAIT_TAIL];
		rdp->nxttail[RCU_WAIT_TAIL] = rdp->nxttail[RCU_NEXT_READY_TAIL];
		rdp->nxttail[RCU_NEXT_READY_TAIL] = rdp->nxttail[RCU_NEXT_TAIL];
		rdp->completed = rnp->completed;
		if (ULONG_CMP_LT(rdp->gpnum, rdp->completed))
			rdp->gpnum = rdp->completed;
		if ((rnp->qsmask & rdp->grpmask) == 0)
			rdp->qs_pending = 0;
	}
}

这个函数检测当前处理器结构体rdp的completed和当前处理器的上层节点结构体rnp的completed数据成员变量是否相等来检验grace period是否结束。如果结束了，则需要将回调函数队列给提交正在等待的队列进行提交。不过在介绍这个队列之前，首先看一下两个宏，前者是grace period结束的截止时间，如果在三个时钟中断之后grace period还没有结束则表明grace period超时；后者是回调函数队列的长度。再由之前的回调函数挂载到队列的操作可以知道，回调函数队列长度为4刚好等于三个等待的队列和一个需要被执行的队列。

#define RCU_JIFFIES_TILL_FORCE_QS	 3
#define RCU_NEXT_SIZE		4

那么为什么是三个时钟中断呢？其实由之前的分析也很好理解，在rnp的gpnum被更新为rsp的gpnum之后最少需要三个时钟中断达到grace period（第一个时钟中断将rdp的gpnum更新为rnp的gpnum，第二个时钟中断相应的处理器往上层移动，第三个时钟中断更新rsp和rnp的completed为rsp的gpnum）。

Nxttail队列是一个间接的队列，他所指向的是nxtlist中的数据。下面又遇到一个宏，宏的定义如下：

#define ULONG_CMP_LT(a, b)	(ULONG_MAX / 2 < (a) - (b))
#define ULONG_MAX	(~0UL)

这里需要注意的是，当a

接下来是一个位操作，不论是rnp还是rdp都包含两个部分的位，第一个是qsmask，这个表明rdp管理的每一个处理器QS状态的掩码，如果rdp中的qsmask清零则表明相应的处理器穿过了QS，如果rdp中的所有qsmask都被清零则需要利用rdp中的grpmask将上层的rnp中的qsmask相应的位清零。对于rnp也是一样的操作。所以这里的判断是对相应的位进行测试，如果测试位等于0表明当前处理器上面没有正在等待的回调函数队列。这里有两种情况等于0，第一种是当前处理器已经离线，那么肯定测试等于0；第二种是当前处理器已经经过层层考核将相应的位清零所以也等于0. 

static void __note_new_gpnum(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp)
{
	if (rdp->gpnum != rnp->gpnum) {
		rdp->gpnum = rnp->gpnum;
		if (rnp->qsmask & rdp->grpmask) {
			rdp->qs_pending = 1;
			rdp->passed_quiesce = 0;
		} else
			rdp->qs_pending = 0;
	}
}

上面是check_for_new_grace_period函数的内部实现，这个函数就是对rdp中相应的状态进行初始化。如果当前的处理器并没有被清零，那么需要设置QS标志为0，这个标志会在以后层层更新之后设置为1.

static int rcu_gp_in_progress(struct rcu_state *rsp)
{
	return (rsp->completed) != (rsp->gpnum);
}

第三个函数，有上面的解释很好理解。上面提到的三个函数实际上是当前grace period的三种状态。

Rcu_start_gp函数开始一个grace period，当处理器存在回调函数等待grace period并且当前状态并没有处于grace period中时会新开启一个grace period。

static int
cpu_needs_another_gp(struct rcu_state *rsp, struct rcu_data *rdp)
{
	return *rdp->nxttail[RCU_DONE_TAIL +
			     (rsp->completed) != rdp->completed] &&
	       !rcu_gp_in_progress(rsp);
}

由于start_rcu_gp太长，所以进行分布分析。首先start_rcu_gp会进行一些验证保证当前适合开启一个新的grace period。当rsp的completed不等于rdp中的completed则表明已经开启了一个从QS等到grace period结束的过程，所以这样的话nxttail中的等待队列不能为空，否则就出现错误了——只有队列中存在数据才需要申请graceperiod；而如果两者相等则表明grace period结束，这样RCU_DONE_TAIL必须不等于0。

	if (rsp->fqs_active) {
		rsp->fqs_need_gp = 1;
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
		return;
	}

上面对状态位的测试表明当前正在处于强制性QS阶段，先设置一下标志位fqs_need_gp在强制性QS结束之后会补齐开启grace period的过程。

rsp->gpnum++;
rsp->signaled = RCU_GP_INIT; 
rsp->jiffies_force_qs = jiffies + RCU_JIFFIES_TILL_FORCE_QS;

graceperiod初始化实际包含两部分，第一部分是对rsp的初始化，第二部分将这种初始化给深入到下面的rnp和rdp中，这样处理的原因也是不希望加锁打击面太大。回过头看上面的初始化实际上是在禁止当前处理器中断以及对顶层rnp中的lock加锁实现的，而有一些初始化需要对整个系统加锁，毕竟搞这么复杂的RCU实现有一个目的是为了处理器的热插拔，而在上面的处理中不需要这么大的系统锁。当然也因为这个原因，所以这里的标志是RCU_GP_INIT。

	raw_spin_unlock(&rnp->lock);
	raw_spin_lock(&rsp->onofflock); 
	rcu_for_each_node_breadth_first(rsp, rnp) {
		raw_spin_lock(&rnp->lock);
		rcu_preempt_check_blocked_tasks(rnp);
		rnp->qsmask = rnp->qsmaskinit;
		rnp->gpnum = rsp->gpnum;
		rnp->completed = rsp->completed;
		if (rnp == rdp->mynode)
			rcu_start_gp_per_cpu(rsp, rnp, rdp);
		rcu_preempt_boost_start_gp(rnp);
		raw_spin_unlock(&rnp->lock);
	}

上面对rnp解锁之后，不久就有一个对rnp的上锁过程。实际上这里下面的rnp和前面的rnp可能不是同一个，因为这里是对整个rnp队列进行遍历操作。所以需要一个更大的专用的锁进行全局的保护——就是rsp中的onoff锁。在互斥条件下，所有的rnp都不能进行热插拔处理。同时将rnp状态进行初始化，qsmaskinit是一个动态变化的处理器掩码，这个掩码系列随着处理器的数目而可能发生变化。在这个处理中，如果当前的rdp的rnp等于循环的rnp则需要设置rdp。到这里基本上所有的RCU初始化都已经初始化了。其他处理器的rdp上的设置在前面的__note_new_gpnum函数里面实现。最后会将当前状态设置为RCU_SIGNAL_INIT。

static void
rcu_start_gp(struct rcu_state *rsp, unsigned long flags)
{
	struct rcu_data *rdp = this_cpu_ptr(rsp->rda);
	struct rcu_node *rnp = rcu_get_root(rsp);
	if (!rcu_scheduler_fully_active ||
	    !cpu_needs_another_gp(rsp, rdp)) {
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
		return;
	}
	if (rsp->fqs_active) {
		rsp->fqs_need_gp = 1;
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
		return;
	}
	rsp->gpnum++;
	rsp->signaled = RCU_GP_INIT; 
	rsp->jiffies_force_qs = jiffies + RCU_JIFFIES_TILL_FORCE_QS;
	record_gp_stall_check_time(rsp);
	if (NUM_RCU_NODES == 1) {
		rcu_preempt_check_blocked_tasks(rnp);
		rnp->qsmask = rnp->qsmaskinit;
		rnp->gpnum = rsp->gpnum;
		rnp->completed = rsp->completed;
		   rsp->signaled = RCU_SIGNAL_INIT;
		   rcu_start_gp_per_cpu(rsp, rnp, rdp);
		rcu_preempt_boost_start_gp(rnp);
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
		return;
	}
	raw_spin_unlock(&rnp->lock);
	raw_spin_lock(&rsp->onofflock); 
	rcu_for_each_node_breadth_first(rsp, rnp) {
		raw_spin_lock(&rnp->lock);	/* irqs already disabled. */
		rcu_preempt_check_blocked_tasks(rnp);
		rnp->qsmask = rnp->qsmaskinit;
		rnp->gpnum = rsp->gpnum;
		rnp->completed = rsp->completed;
		if (rnp == rdp->mynode)
			rcu_start_gp_per_cpu(rsp, rnp, rdp);
		rcu_preempt_boost_start_gp(rnp);
		raw_spin_unlock(&rnp->lock);
	}
	rnp = rcu_get_root(rsp);
	raw_spin_lock(&rnp->lock);		
	rsp->signaled = RCU_SIGNAL_INIT;
	raw_spin_unlock(&rnp->lock);
	raw_spin_unlock_irqrestore(&rsp->onofflock, flags);
}

接下来是force_quiescent_state函数，这个函数可能存在两次调用机会。第一次和第二次的第二个参数不一样，前者为0后者为1.前者表明当前还不非常紧急可以暂缓强制QS，而后者则表明当前已经必须进行QS处理了。Force_quiescent_state函数主体是一个switch分支结构，分支结构起始位置是一个状态位的设置是不是很熟悉，下面就根据rsp当前的状态进行全局的分支调用，主要状态是RCU_SAVE_DYNTICK和RCU_FORCE_QS。

	rsp->fqs_active = 1;
	switch (rsp->signaled) {
	case RCU_GP_IDLE:
	case RCU_GP_INIT:
		break;
	case RCU_SAVE_DYNTICK:
		if (RCU_SIGNAL_INIT != RCU_SAVE_DYNTICK)
			break;
		raw_spin_unlock(&rnp->lock);  /* irqs remain disabled */
		force_qs_rnp(rsp, dyntick_save_progress_counter);
		raw_spin_lock(&rnp->lock);  /* irqs already disabled */
		if (rcu_gp_in_progress(rsp))
			rsp->signaled = RCU_FORCE_QS;
		break;
	case RCU_FORCE_QS:
		raw_spin_unlock(&rnp->lock);  /* irqs remain disabled */
		force_qs_rnp(rsp, rcu_implicit_dynticks_qs);
		raw_spin_lock(&rnp->lock);  /* irqs already disabled */
		break;
	}
	rsp->fqs_active = 0;
	if (rsp->fqs_need_gp) {
		raw_spin_unlock(&rsp->fqslock); /* irqs remain disabled */
		rsp->fqs_need_gp = 0;
		rcu_start_gp(rsp, flags); /* releases rnp->lock */
		return;
	}

上面同样调用force_qs_rnp两次，不过同样的第二个参数不相同。前者的主要目的是记录下当前的处理器dynticks状态，以避免正在休眠的处理器被唤醒，而后者则将进行真正的强制性QS操作。从上面的代码流程看下来仿佛所有的QS都需要经过强制性QS处理才能穿过QS，实际上不然，因为还有一部分会在处理器时钟中断中处理。处理流程和上面的流程很相似，不过调用是从时钟中断处理中发出来的。真正的强制性QS只在两种可能下处理，第一种是grace period结束，第二种grace period可能结束——也就是超时了。所以grace period只需要设置rnp的处理就可以了而不需要考虑rdp，而rdp的处理则是在时钟中断中进行调用——时钟中断引起调度，顺便处理下rdp表明当前处理器已经进行了一次调度是完全可行的。

static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *))
{
	unsigned long bit;
	int cpu;
	unsigned long flags;
	unsigned long mask;
	struct rcu_node *rnp;
	rcu_for_each_leaf_node(rsp, rnp) {
		mask = 0;
		raw_spin_lock_irqsave(&rnp->lock, flags);
		if (!rcu_gp_in_progress(rsp)) {
			raw_spin_unlock_irqrestore(&rnp->lock, flags);
			return;
		}
		if (rnp->qsmask == 0) {
			rcu_initiate_boost(rnp, flags); /* releases rnp->lock */
			continue;
		}
		cpu = rnp->grplo;
		bit = 1;
		for (; cpu <= rnp->grphi; cpu++, bit <<= 1) {
			if ((rnp->qsmask & bit) != 0 &&
			    f(per_cpu_ptr(rsp->rda, cpu)))
				mask |= bit;
		}
		if (mask != 0) {
			rcu_report_qs_rnp(mask, rsp, rnp, flags);
			continue;
		}
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
	}
	rnp = rcu_get_root(rsp);
	if (rnp->qsmask == 0) {
		raw_spin_lock_irqsave(&rnp->lock, flags);
		rcu_initiate_boost(rnp, flags); /* releases rnp->lock. */
	}
}

上面这个函数看起来一大堆，实际关键的处理就是一个对rnp自叶节点网上层进行清空处理器掩码的过程——因为下层的节点处理可能逐层上传将上层节点的grpmask掩码进行清零处理。如果掩码成功处理了，则会引起将当前的graceperiod设置为完成——也就是更新rnp的completed和rsp的completed。

static void
__rcu_process_callbacks(struct rcu_state *rsp, struct rcu_data *rdp)
{
	unsigned long flags;
	if (ULONG_CMP_LT(rsp->jiffies_force_qs, jiffies))
		force_quiescent_state(rsp, 1);
	rcu_process_gp_end(rsp, rdp);
	rcu_check_quiescent_state(rsp, rdp);
	if (cpu_needs_another_gp(rsp, rdp)) {
		raw_spin_lock_irqsave(&rcu_get_root(rsp)->lock, flags);
		rcu_start_gp(rsp, flags);  /* releases above lock */
	}
	if (cpu_has_callbacks_ready_to_invoke(rdp))
		invoke_rcu_callbacks(rsp, rdp);
}

处理器调度的时会调用rcu_process_callbacks函数，这个函数主要处理rdp中的处理器掩码进行清空。具体过程不再进一步展开，直接找到关键的部分。

static void
rcu_report_qs_rdp(int cpu, struct rcu_state *rsp, struct rcu_data *rdp, long lastgp)
{
	unsigned long flags;
	unsigned long mask;
	struct rcu_node *rnp;
	rnp = rdp->mynode;
	raw_spin_lock_irqsave(&rnp->lock, flags);
	if (lastgp != rnp->gpnum || rnp->completed == rnp->gpnum) {
		rdp->passed_quiesce = 0;
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
		return;
	}
	mask = rdp->grpmask;
	if ((rnp->qsmask & mask) == 0) {
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
	} else {
		rdp->qs_pending = 0;
		rdp->nxttail[RCU_NEXT_READY_TAIL] = rdp->nxttail[RCU_NEXT_TAIL];
		rcu_report_qs_rnp(mask, rsp, rnp, flags); /* rlses rnp->lock */
	}
}

函数实现，实际有两个部分，前者当rnp和rdp的completed相等则表明是新的grace period，所以需要设置passed_quiesce为0表明还没有穿过QS。否则下面需要根据当前rdp的grpmask设置rnp的位。从这里可以看出，在调度支出肯定有一个判断当rdp的qsmask等于0时才会调用这个函数，否则只是设置与当前处理器相关的函数。

下面还有一个关键的函数调用会回调函数，函数的实现分两种情况表明RCU支持两种情况，一种RCU只作为数据来进行处理，第二种是RCU作为函数来调用。前者实际上是异步处理过程，不管什么样的东西直接当做数据进行释放，而后者则是作为同步处理，所做的操作主要是唤醒等待队列。

static inline void __rcu_reclaim(char *rn, struct rcu_head *head)
{
	unsigned long offset = (unsigned long)head->func;
	if (__is_kfree_rcu_offset(offset)) {
		kfree((void *)head - offset);
	} else {
		head->func(head);
	}
}