TREE RCU实现之二 —— 主干函数

         RCU的实现集中在以下几个步骤:

         1, 调用call_rcu,将回调函数增加到列表。

         2,   开始一个宽限期。

         3,   每个CPU报告自己的状态,直到最后一个CPU,结束一个宽限期。

         4, 宽限期结束,每个CPU处理自己的回调函数。

call_rcu的实现  

static void
__call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu),
           struct rcu_state *rsp, bool lazy)
{
        unsigned long flags;
        struct rcu_data *rdp;

        WARN_ON_ONCE((unsigned long)head & 0x3); /* 检测head在内存中是否对齐! */
        debug_rcu_head_queue(head);
        head->func = func;
        head->next = NULL;

        smp_mb(); /* Ensure RCU update seen before callback registry. */

        /*
         * 这是一个检测宽限期开始或者结束的机会。
         * 当我们看到一个结束的时候,可能还会看到一个开始。
         * 反过来,看到一个开始的时候,不一定能看到一个结束,
         * 因为宽限期结束需要一定时间。
         */
        local_irq_save(flags);
        rdp = this_cpu_ptr(rsp->rda);

        /* 将要增加callback到nxtlist. */
        ACCESS_ONCE(rdp->qlen)++;
        if (lazy)
                rdp->qlen_lazy++;
        else
                rcu_idle_count_callbacks_posted();
        smp_mb();  /* Count before adding callback for rcu_barrier(). */
        *rdp->nxttail[RCU_NEXT_TAIL] = head;
        rdp->nxttail[RCU_NEXT_TAIL] = &head->next;

        if (__is_kfree_rcu_offset((unsigned long)func))
                trace_rcu_kfree_callback(rsp->name, head, (unsigned long)func,
                                         rdp->qlen_lazy, rdp->qlen);
        else
                trace_rcu_callback(rsp->name, head, rdp->qlen_lazy, rdp->qlen);

        /* 去处理rcu_core。 */
        __call_rcu_core(rsp, rdp, head, flags);
        local_irq_restore(flags);
}

         call_rcu中最主要的工作,就是将回调函数加入到CPU的nxtlist列表。这里用到了指针处理的小技巧,我们来看看。首先看看nxttail的初始化:

 

static void init_callback_list(struct rcu_data *rdp)
{
        int i;

        rdp->nxtlist = NULL;
        for (i = 0; i < RCU_NEXT_SIZE; i++)
                rdp->nxttail[i] = &rdp->nxtlist;
}

       我们看到nxttail的全部成员都指向了nxtlist的地址。当nxtlist为空的时候,也是这个情形。

       *rdp->nxttail[RCU_NEXT_TAIL] = head;       

       当nxtlist为空的时候, *rdp->nxttail[RCU_NEXT_TAIL] 得到的其实就是nxtlist,将head的值赋予它。

       rdp->nxttail[RCU_NEXT_TAIL] = &head->next;

       之后 RCU_NEXT_TAIL指向 head的next指针。这样当再有一个节点加入的时候,*rdp->nxttail[RCU_NEXT_TAIL]得到的其实就是前一次加入的head的next指针,它将指向新加入的值。如此,nxtlist就成为了一个链表。或者这样理解,rdp->nxttail[RCU_NEXT_TAIL] 指向的就是nxtlist中最后一个节点的 next指针。

       除了将回调函数插入,该函数其它代码多为检查代码。而最后要调用__call_rcu_core,该函数的功用主要是在回调函数太多或者等待时间过长的状态下,强制执行RCU状态更新。我们暂时不关注。

开始一个宽限期

       在一个宽限期结束,或者当一个CPU检测到自身有需要一个宽限期的时候会开始一个新的宽限期,开始宽限期的代码如下:

 

static void
rcu_start_gp(struct rcu_state *rsp, unsigned long flags)
        __releases(rcu_get_root(rsp)->lock)
{
        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)) {
                /*
                 * 如果scheduler 还没有启动non-idle任务
                 * 或者不需要启动一个新的宽限期则退出。
                 * 需要再次判断cpu_needs_another_gp,
                 * 是因为可能有多个CPU执行这个过程。
                 */
               raw_spin_unlock_irqrestore(&rnp->lock, flags);
               return;
        }

        if (rsp->fqs_active) {
                /*
                 * 这个CPU需要一个宽限期,而force_quiescent_state()
                 * 正在运行,告诉它开始一个。
                 */
                rsp->fqs_need_gp = 1;
                raw_spin_unlock_irqrestore(&rnp->lock, flags);
                return;
        }

        /* 开始一个新的宽限期并且初始化。 */
        rsp->gpnum++;
        trace_rcu_grace_period(rsp->name, rsp->gpnum, "start");
        WARN_ON_ONCE(rsp->fqs_state == RCU_GP_INIT);
        rsp->fqs_state = RCU_GP_INIT; /* 阻止 force_quiescent_state。 */
        rsp->jiffies_force_qs = jiffies + RCU_JIFFIES_TILL_FORCE_QS;
        record_gp_stall_check_time(rsp);
        raw_spin_unlock(&rnp->lock);  /* leave irqs disabled. */

        /* 排除CPU的热插拔。*/
        raw_spin_lock(&rsp->onofflock);  /* irqs already disabled. */

       /*
	* 从父节点开始以广度优先的方式,遍历所有的节点,设置qsmask的值,
	* 所有在线CPU所在bit都将被设置成1。
	* 通过遍历rsp->node[]数组就可以达到这个目的。
	* 其它CPU在自己所属的节点还没有被设置前,只有可能访问这个节点,
	* 因为它所作的判断是宽限期还没有开始。
	* 此外,我们排除了CPU热插拔。
	* 
	* 直到初始化过程完成之前,这个宽限期不可能完成,因为至少当前的
	* CPU所属的bit将不会被设置。这个是因为我们启动了禁止中断,所以
	* 这个CPU不会调用到宽限期检测代码。
	*/
	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);
                trace_rcu_grace_period_init(rsp->name, rnp->gpnum,
                                            rnp->level, rnp->grplo,
                                            rnp->grphi, rnp->qsmask);
                raw_spin_unlock(&rnp->lock);    /* irqs remain disabled. */
        }

        rnp = rcu_get_root(rsp);
        raw_spin_lock(&rnp->lock);              /* irqs already disabled. */
        rsp->fqs_state = RCU_SIGNAL_INIT; /* force_quiescent_state now OK. */
        raw_spin_unlock(&rnp->lock);            /* irqs remain disabled. */
        raw_spin_unlock_irqrestore(&rsp->onofflock, flags);
}

       标记一个新的宽限期开始,rcu_state要做的就是将gp_num加1。然后再设置所有node,qsmask被设置成qsmasinit,qsmask每个bit代表一个CPU,所有在线的CPU都将被设置成1;gpnum将被设置成新值。嗯,一个新宽限期的开始只需要设置这些标记位。

 

CPU的宽限期检测

        当一个宽限期开始后,每个CPU都需要检测自己的状态,如果已经通过静止状态,那么就向上一级node进行报告。

        这个处理过程,可以分为两个步骤:

                1, 检测新的处理过程开始,设置rcu_data中的gpnum和passed_quiesce,另外用qs_pending标记一个待处理的新宽限期的开始。

                2, 一个静止状态结束,向上一级node报告这个过程。

        这两个过程通过rcu_check_quiescent_state()来实现,需要注意的是这个函数隔一段时间调用一次,并不只调用一次。

 

/*
* 检测这个CPU是否还不知道一个新宽限期开始,如果是设置它的变量。
* 否则检查它是不是第一次通过静止状态,如果是,向上报告。
*/
static void
rcu_check_quiescent_state(struct rcu_state *rsp, struct rcu_data *rdp)
{
	/* 如果有新的宽限期开始,记录它并返回。*/
	if (check_for_new_grace_period(rsp, rdp))
		return;

	/*
	 * 这个CPU是否已经处理过它的宽限期?如果是返回。
	 */
	if (!rdp->qs_pending)
		return;

	/*
	 * 是否通过了静止状态?如果没有,返回。
         */
	if (!rdp->passed_quiesce)
		return;

	/*
	 * 向所属的node报告。(但rcu_report_qs_rdp() 仍然会去判断它)。
	 */
	rcu_report_qs_rdp(rdp->cpu, rsp, rdp, rdp->passed_quiesce_gpnum);
}

     

            A, CPU检测新宽限期的开始
 

/* 
 * 为当前CPU,更新rcu_data的状态,去标记一个新宽限期的开始
 * 如果当前CPU启动了一个宽限期或者检测到一个新的宽限期开始,
 * 都需要调用这个函数。这个过程必须锁定父节点的lock,另外需
 * 要禁止中断
 */
static void __note_new_gpnum(struct rcu_state *rsp, struct rcu_node *rnp, struct rcu_data *rdp)
{
	if (rdp->gpnum != rnp->gpnum) {
		/*
 		 * 如果当前的宽限期需要处理这个CPU的状态,设置并
		 * 去检测它的静止状态。否则不要去管它。
		 */		
                rdp->gpnum = rnp->gpnum;
		trace_rcu_grace_period(rsp->name, rdp->gpnum, "cpustart");
		if (rnp->qsmask & rdp->grpmask) {
			rdp->qs_pending = 1;
			rdp->passed_quiesce = 0;
		} else {
			rdp->qs_pending = 0;
		}
		zero_cpu_stall_ticks(rdp);
	}
}

static void note_new_gpnum(struct rcu_state *rsp, struct rcu_data *rdp)
{
	unsigned long flags;
	struct rcu_node *rnp;

	local_irq_save(flags);
	rnp = rdp->mynode;
	if (rdp->gpnum == ACCESS_ONCE(rnp->gpnum) || /* outside lock. */
	    !raw_spin_trylock(&rnp->lock)) { /* irqs already off, so later. */
		local_irq_restore(flags);
		return;
	}
	__note_new_gpnum(rsp, rnp, rdp);
	raw_spin_unlock_irqrestore(&rnp->lock, flags);
}

/*
 * 在我们的上次检测之后,其它CPU启动了一个新的宽限期?
 * 如果是更新相应的rcu_data的状态。
 * 必须是在rdp对应的CPU上执行。
 */
static int
check_for_new_grace_period(struct rcu_state *rsp, struct rcu_data *rdp)
{
	unsigned long flags;
	int ret = 0;

	local_irq_save(flags);
	if (rdp->gpnum != rsp->gpnum) {
		note_new_gpnum(rsp, rdp);
		ret = 1;
	}
	local_irq_restore(flags);
	return ret;
}

        check_for_new_grace_period 和 note_new_gpnum分别用来检测rdp的gpnum与rsp已经对应的rnp的值是否相同,来确定是否有一个新的宽限期开始。之所以需要检测两次,是因为在rsp设置以后,rnp可能并没有设置完成。

        __note_new_gpnum 将设置gpnum的值。另外设置 qs_pending为1,该标记位代表该节点还没有向父节点报告自己的状态;passed_quiesce为0,表示需要一个静止状态,设置该位是因为下次调用rcu_check_quiescent_state()可能是在一个读过程还没有结束的时候。

         qs_pending的状态有可能为0,这只在以下情形下出现:当前CPU在宽限期开始的时候实在离线状态,而现在变成了在线。

         我们注意到在 check_for_new_grace_period检测到有新的宽限期开始后,rcu_check_quiescent_state将直接返回,因为这个宽限期可能是在该CPU的上一个静止状态之前已经开始,所以需要等待下一个静止状态。

 

      B,CPU报告静止状态

      当再一次调用到rcu_check_quiescent_state()的时候,check_for_new_grace_period()将返回FALSE,接着运行后面的函数来判断 qs_pending 和 passed_quiesce 的值来决定是否调用rcu_report_qs_rdp。需要判断qs_peding是因为当这次rcu_report_qs_rdp调用成功的时候,下次再运行rcu_check_quiescent_state()则不需要继续运行后续函数。

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;	/* need qs for new gp. */
		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;

		/*
		 *  可以确定这个宽限期还没有结束,所以可以确定当前CPU上的
		 *  所有回调函数可以在下次宽限期结束后处理。
		 */
		rdp->nxttail[RCU_NEXT_READY_TAIL] = rdp->nxttail[RCU_NEXT_TAIL];

		rcu_report_qs_rnp(mask, rsp, rnp, flags); /* rlses rnp->lock */
	}
}

        从我看来,这个函数只会调用到最后一个else分支,而之前的连个if分支都不会调用到。因为在调用该函数前,代码已经做了必要的检测。

        以此来看,这个函数的功用就是设置qs_pending的值,阻止这次宽限期没有完成之前再次调用掉该函数;设置nxttail,决定下次宽限期后可以执行的回调函数;然后向父节点报告静止状态完成。

 

     C,向上报告

static void
rcu_report_qs_rnp(unsigned long mask, struct rcu_state *rsp,
		  struct rcu_node *rnp, unsigned long flags)
	__releases(rnp->lock)
{
	struct rcu_node *rnp_c;

	/* 向上遍历所有层级 */
	for (;;) {
		if (!(rnp->qsmask & mask)) {

			/* 这个CPU的标记已经被清除,证明已经处理过了,返回 */
			raw_spin_unlock_irqrestore(&rnp->lock, flags);
			return;
		}
		rnp->qsmask &= ~mask;
		trace_rcu_quiescent_state_report(rsp->name, rnp->gpnum,
						 mask, rnp->qsmask, rnp->level,
						 rnp->grplo, rnp->grphi,
						 !!rnp->gp_tasks);
		if (rnp->qsmask != 0 || rcu_preempt_blocked_readers_cgp(rnp)) {

			/* 这个节点中还有其它CPU没有处理完成,那么返回 */
			raw_spin_unlock_irqrestore(&rnp->lock, flags);
			return;
		}
		mask = rnp->grpmask;
		if (rnp->parent == NULL) {

			/* 到这儿,已经到了根节点 */

			break;
		}
		raw_spin_unlock_irqrestore(&rnp->lock, flags);
		rnp_c = rnp;
		rnp = rnp->parent;
		raw_spin_lock_irqsave(&rnp->lock, flags);
		WARN_ON_ONCE(rnp_c->qsmask);
	}

	/*
 	 *  程序运行到这儿,说明所有的CPU都通过了宽限期,
 	 *  那么调用rcu_report_qs_rsp()来结束这个宽限期。
 	 */	
        rcu_report_qs_rsp(rsp, flags); /* releases rnp->lock. */
}


        这个过程并不复杂,清理rnp中qsmask对应该CPU的bit。然后判断该节点是否处理完成,如果是则继续向上调用,否则就退出函数。最后一个CPU调用后,可以调用到rcu_report_qs_rsp()。

static void rcu_report_qs_rsp(struct rcu_state *rsp, unsigned long flags)
	__releases(rcu_get_root(rsp)->lock)
{
	unsigned long gp_duration;
	struct rcu_node *rnp = rcu_get_root(rsp);
	struct rcu_data *rdp = this_cpu_ptr(rsp->rda);

	WARN_ON_ONCE(!rcu_gp_in_progress(rsp));

	/*
	 * Ensure that all grace-period and pre-grace-period activity
	 * is seen before the assignment to rsp->completed.
	 */
	smp_mb(); /* See above block comment. */
	gp_duration = jiffies - rsp->gp_start;
	if (gp_duration > rsp->gp_max)
		rsp->gp_max = gp_duration;

	/*
	 * 当前CPU知道宽限期已经结束,不过其它CPU都认为它还在运行。
	 * 由于completed还没有设置,其它CPU都不会对父node进行处理。
	 * 所以这时候将各个node标记为完成是安全的。
	 * 
	 * 不过当前CPU有等待下一次宽限期的回调函数的时候,我们会
	 * 先去处理下一个宽限期。
	 * 这儿使用RCU_WAIT_TAIL代替了RCU_DONE_TAIL,这是因为当前
	 * CPU还没有进一步处理完成状态,当前RCU_WAIT_TAIL状态的元
	 * 素其实在这次宽限期结束后,已经可以执行了。
	 * 
	 */
	if (*rdp->nxttail[RCU_WAIT_TAIL] == NULL) {
		raw_spin_unlock(&rnp->lock);	 /* irqs remain disabled. */

		/*
		 * 设置 rnp->completed的值,避免这个过程要等到下一次宽限期开始。		 
		 */
		rcu_for_each_node_breadth_first(rsp, rnp) {
			raw_spin_lock(&rnp->lock); /* irqs already disabled. */
			rnp->completed = rsp->gpnum;
			raw_spin_unlock(&rnp->lock); /* irqs remain disabled. */
		}
		rnp = rcu_get_root(rsp);
		raw_spin_lock(&rnp->lock); /* irqs already disabled. */
	}

	rsp->completed = rsp->gpnum;  /* Declare the grace period complete. */
	trace_rcu_grace_period(rsp->name, rsp->completed, "end");
	rsp->fqs_state = RCU_GP_IDLE;
	rcu_start_gp(rsp, flags);  /* releases root node's rnp->lock. */
}


       这个过程最主要的内容就是设置rsp->completed的值,中间多了对node的处理。因为在rcu_start_gp中也会对node进行处理,当前CPU无法判断其它CPU是否需要一个宽限期,但它自身还有等待宽限期的回调函数的时候,它确定会有一个新的宽限期马上开始,所以忽略这个过程。     

 CPU的宽限期结束处理

     这个过程也可以分为两个步骤,第一步是检查宽限期是否结束,第二步是调用已完成的回调函数。


     A, CPU检测宽限期的结束

     每个CPU都会定期检查当前的宽限期是否结束,如果结束将处理自身状态已经nxtlist表。rcu_process_gp_end就是用来做这个事情:

static void
rcu_process_gp_end(struct rcu_state *rsp, struct rcu_data *rdp)
{
	unsigned long flags;
	struct rcu_node *rnp;

	local_irq_save(flags);
	rnp = rdp->mynode;
	if (rdp->completed == ACCESS_ONCE(rnp->completed) || /* outside lock. */
	    !raw_spin_trylock(&rnp->lock)) { /* irqs already off, so later. */
		local_irq_restore(flags);
		return;
	}
	__rcu_process_gp_end(rsp, rnp, rdp);
	raw_spin_unlock_irqrestore(&rnp->lock, flags);
}


     当 rdp->completed与rnp->completed的值不同的时候,会调用__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) {

		/* 推进回调函数,即使是NULL指针也没关系。 */
		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];

		/* 更新completed。 */
		rdp->completed = rnp->completed;
		trace_rcu_grace_period(rsp->name, rdp->gpnum, "cpuend");

		/*
 		 * 如果当前的CPU在外部的静止的状态(如离线状态),
		 * 可能已经错过了其它CPU发起的宽限期。所以需要更
 		 * 新gpnum的值,同时要注意不要错过当前正在运行的
 		 * 宽限期,所以它的值被设置成与rnp->completed相同,
 		 * 此时rnp->gpnum 可以已经加1,那么后续的调用
 		 * rcu_check_quiescent_state()会去检测新的宽限期。
 		 */		
                if (ULONG_CMP_LT(rdp->gpnum, rdp->completed))
			rdp->gpnum = rdp->completed;

		/*
		 * 如果下次的宽限期不需要当前CPU报告静止状态,
		 * 设置qs_pending为0。
          	 */
		if ((rnp->qsmask & rdp->grpmask) == 0)
			rdp->qs_pending = 0;
	}
}


   这个过程的重点是设置nxttail的值,将根据它来进行下一步的处理。

 

   B,回调函数的调用

static void rcu_do_batch(struct rcu_state *rsp, struct rcu_data *rdp)
{
	unsigned long flags;
	struct rcu_head *next, *list, **tail;
	int bl, count, count_lazy, i;

	/* 没有回调函数,那么返回。*/
	if (!cpu_has_callbacks_ready_to_invoke(rdp)) {
		trace_rcu_batch_start(rsp->name, rdp->qlen_lazy, rdp->qlen, 0);
		trace_rcu_batch_end(rsp->name, 0, !!ACCESS_ONCE(rdp->nxtlist),
				    need_resched(), is_idle_task(current),
				    rcu_is_callbacks_kthread());
		return;
	}

	/*
 	 * 提取回调函数的list,需要禁用中断,以防止调用call_rcu()。 
 	 */	
        local_irq_save(flags);
	WARN_ON_ONCE(cpu_is_offline(smp_processor_id()));
	bl = rdp->blimit;
	trace_rcu_batch_start(rsp->name, rdp->qlen_lazy, rdp->qlen, bl);
	list = rdp->nxtlist;
	/* 
	 * 已经将list指向了nxtlist,此时将nxtlist指向 *rdp->nxttail[RCU_DONE_TAIL]。
	 * 由于nxttail指向的是 rcu_head中的next指针的地址,所以此处得到的就是next所
	 * 指向的rcu_head对象。
	 */
	rdp->nxtlist = *rdp->nxttail[RCU_DONE_TAIL];
	/*将*rdp->nxttail[RCU_DONE_TAIL]指向NULL,也就是将list中的最后一个元素的next设置成NULL*/
	*rdp->nxttail[RCU_DONE_TAIL] = NULL;
	/*tail指向list最后一个元素的next指针的地址*/
	tail = rdp->nxttail[RCU_DONE_TAIL];
	/*此时rdp->nxttail[RCU_DONE_TAIL]指向的内容已经移出,所以让它重新指向nxtlist的地址*/
	for (i = RCU_NEXT_SIZE - 1; i >= 0; i--)
		if (rdp->nxttail[i] == rdp->nxttail[RCU_DONE_TAIL])
			rdp->nxttail[i] = &rdp->nxtlist;
	local_irq_restore(flags);

	/* 调用回调函数 */
	count = count_lazy = 0;
	while (list) {
		next = list->next;
		prefetch(next);
		debug_rcu_head_unqueue(list);
		if (__rcu_reclaim(rsp->name, list))
			count_lazy++;
		list = next;
		/* 当已经全部运行完毕或者CPU有更重要的事情的时候,退出循环。 */
		if (++count >= bl &&
		    (need_resched() ||
		     (!is_idle_task(current) && !rcu_is_callbacks_kthread())))
			break;
	}

	local_irq_save(flags);
	trace_rcu_batch_end(rsp->name, count, !!list, need_resched(),
			    is_idle_task(current),
			    rcu_is_callbacks_kthread());

	/* 更新数量。并将没有执行完的回调函数重新放进列表。 */
	if (list != NULL) {
		*tail = rdp->nxtlist;
		rdp->nxtlist = list;
		for (i = 0; i < RCU_NEXT_SIZE; i++)
			if (&rdp->nxtlist == rdp->nxttail[i])
				rdp->nxttail[i] = tail;
			else
				break;
	}
	smp_mb(); /* 为了 rcu_barrier()统计运行过的回调函数 */
	rdp->qlen_lazy -= count_lazy;
	ACCESS_ONCE(rdp->qlen) -= count;
	rdp->n_cbs_invoked += count;

	/* Reinstate batch limit if we have worked down the excess. */
	if (rdp->blimit == LONG_MAX && rdp->qlen <= qlowmark)
		rdp->blimit = blimit;

	/* Reset ->qlen_last_fqs_check trigger if enough CBs have drained. */
	if (rdp->qlen == 0 && rdp->qlen_last_fqs_check != 0) {
		rdp->qlen_last_fqs_check = 0;
		rdp->n_force_qs_snap = rsp->n_force_qs;
	} else if (rdp->qlen < rdp->qlen_last_fqs_check - qhimark)
		rdp->qlen_last_fqs_check = rdp->qlen;
	WARN_ON_ONCE((rdp->nxtlist == NULL) != (rdp->qlen == 0));

	local_irq_restore(flags);

	/* 如果还有回调函数没有执行,通知再次调用软中断 */
	if (cpu_has_callbacks_ready_to_invoke(rdp))
		invoke_rcu_core();
}

       rcu_do_batch主要作用是取出nxtlist中,nxttail[RCU_DONE_TAIL]之前的元素,遍历执行它们。这时候销毁过程真正的执行了。这段函数需要仔细想想nxttail的处理。

      到此RCU中涉及到的主干函数介绍完了,但是还需要与进程切换等过程交互。将在下节分析它们。

 

你可能感兴趣的:(linux内核笔记,——RCU)