关于current->bio_list的加锁疑问

csern

3.0内核中generic_make_request()函数定义如下

1. void generic_make_request(struct bio *bio)                                       
   
2. {                                                                                
   
3.         struct bio_list bio_list_on_stack;                                       
   
4.                                                                                  
   
5.         if (current->bio_list) {                                                
   
6.                 /* make_request is active */                                    
   
7.                 bio_list_add(current->bio_list, bio);                           
   
8.                 return;                                                         
   
9.         }                                                                        
   
10.         /* following loop may be a bit non-obvious, and so deserves some         
    
11.          * explanation.                                                         
    
12.          * Before entering the loop, bio->bi_next is NULL (as all callers        
    
13.          * ensure that) so we have a list with a single bio.                     
    
14.          * We pretend that we have just taken it off a longer list, so           
    
15.          * we assign bio_list to a pointer to the bio_list_on_stack,            
    
16.          * thus initialising the bio_list of new bios to be                     
    
17.          * added.  __generic_make_request may indeed add some more bios         
    
18.          * through a recursive call to generic_make_request.  If it              
    
19.          * did, we find a non-NULL value in bio_list and re-enter the loop           
    
20.          * from the top.  In this case we really did just take the bio           
    
21.          * of the top of the list (no pretending) and so remove it from         
    
22.          * bio_list, and call into __generic_make_request again.                 
    
23.          *                                                                       
    
24.          * The loop was structured like this to make only one call to            
    
25.          * __generic_make_request (which is important as it is large and         
    
26.          * inlined) and to keep the structure simple.                           
    
27.          */                                                                     
    
28.         BUG_ON(bio->bi_next);                                                   
    
29.         bio_list_init(&bio_list_on_stack);                                       
    
30.         current->bio_list = &bio_list_on_stack;                                 
    
31.         do {                                                                     
    
32.                 __generic_make_request(bio);                                    
    
33.                 bio = bio_list_pop(current->bio_list);                           
    
34.         } while (bio);                                                           
    
35.         current->bio_list = NULL; /* deactivate */                              
    
36. }

复制代码

对bio_list为什么不需要锁的控制呢，有点不太明白

csern

明白了，bio_list是每个进程的结构，内核的几个竞争条件都不会触发
a) 中断： 该成员没有在中断中被访问
b) 抢占：因为是per task成员，不会产生竞争
c) SMP: 同b