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<b的时候宏才有可能为真。~0UL等于将32位全部置为1,但是除以2之后得到最大的正数(相当于右移1位),而当a小于b的时候才有可能使得最高位等于1。这里表明当前rdp的gpnum小于completed,只有一种情况会出现这种现象,那就是当前处理器处于扩展QS,也就是当前处理器可能已经离线了,所以直接将gpnum更新为completed就可以了。

接下来是一个位操作,不论是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);
	}
}


你可能感兴趣的:(linux)