求教神们一个RCU的问题

kitiz

读者在访问被RCU保护的共享数据期间不能被阻塞，这是RCU机制得以实现的一个基本前提，
也就说当读者在引用被RCU保护的共享数据期间，读者所在的CPU不能发生上下文切换
“读者所在的CPU不能发生上下文切换”请问这个是怎么保证的？

瀚海书香

回复 1# kitiz
这个需要你的代码显示的实现禁止CPU切换的功能。比如rcu_read_lock()函数。

juruqiang

回复  kitiz
这个需要你的代码显示的实现禁止CPU切换的功能。比如rcu_read_lock()函数。
瀚海书香 发表于 2011-12-16 22:55

1. void __rcu_read_lock(void)
   
2. {
   
3.         int idx;
   
4.         struct task_struct *t = current;
   
5.         int nesting;
   
6. 
   
7.         nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
   
8.         if (nesting != 0) {
   
9. 
   
10.                 /* An earlier rcu_read_lock() covers us, just count it. */
    
11. 
    
12.                 t->rcu_read_lock_nesting = nesting + 1;
    
13. 
    
14.         } else {
    
15.                 unsigned long flags;
    
16. 
    
17.                 /*
    
18.                  * We disable interrupts for the following reasons:
    
19.                  * - If we get scheduling clock interrupt here, and we
    
20.                  *   end up acking the counter flip, it's like a promise
    
21.                  *   that we will never increment the old counter again.
    
22.                  *   Thus we will break that promise if that
    
23.                  *   scheduling clock interrupt happens between the time
    
24.                  *   we pick the .completed field and the time that we
    
25.                  *   increment our counter.
    
26.                  *
    
27.                  * - We don't want to be preempted out here.
    
28.                  *
    
29.                  * NMIs can still occur, of course, and might themselves
    
30.                  * contain rcu_read_lock().
    
31.                  */
    
32. 
    
33.                 local_irq_save(flags);
    
34. 
    
35.                 /*
    
36.                  * Outermost nesting of rcu_read_lock(), so increment
    
37.                  * the current counter for the current CPU.  Use volatile
    
38.                  * casts to prevent the compiler from reordering.
    
39.                  */
    
40. 
    
41.                 idx = ACCESS_ONCE(rcu_ctrlblk.completed) & 0x1;
    
42.                 ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])++;
    
43. 
    
44.                 /*
    
45.                  * Now that the per-CPU counter has been incremented, we
    
46.                  * are protected from races with rcu_read_lock() invoked
    
47.                  * from NMI handlers on this CPU.  We can therefore safely
    
48.                  * increment the nesting counter, relieving further NMIs
    
49.                  * of the need to increment the per-CPU counter.
    
50.                  */
    
51. 
    
52.                 ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting + 1;
    
53. 
    
54.                 /*
    
55.                  * Now that we have preventing any NMIs from storing
    
56.                  * to the ->rcu_flipctr_idx, we can safely use it to
    
57.                  * remember which counter to decrement in the matching
    
58.                  * rcu_read_unlock().
    
59.                  */
    
60. 
    
61.                 ACCESS_ONCE(t->rcu_flipctr_idx) = idx;
    
62.                 local_irq_restore(flags);
    
63.         }
    
64. }

复制代码

juruqiang

有好多个__rcu_read_lock实现啊