限制printk打印频率函数printk_ratelimit【转】

转自：http://blog.csdn.net/lkkey80/article/details/45190095

版权声明：博文地址 http://blog.csdn.net/lkkey80?viewmode=list 转载请注明出处

    在Linux内核代码里当需要限制printk打印频率时会用到__ratelimit或printk_ratelimit（封装了__ratelimit）。

[cpp]  view plain  copy

1. /*                                                                                                      
2.  * printk rate limiting, lifted from the networking subsystem.                                          
3.  *                                                                                                      
4.  * This enforces a rate limit: not more than 10 kernel messages                                         
5.  * every 5s to make a denial-of-service attack impossible.                                              
6.  */                                                                                                      
7. DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);                                              
8.                                                                                                          
9. int printk_ratelimit(void)                                                                               
10. {                                                                                                        
11.     return __ratelimit(&printk_ratelimit_state);                                                         
12. }                                                                                                        
13. EXPORT_SYMBOL(printk_ratelimit);  

/var/log/messages里一个可能的输出如下：

kernel: end_request: I/O error, dev sdr, sector 2048                            
kernel: end_request: I/O error, dev sdr, sector 2048                            
kernel: end_request: I/O error, dev sdr, sector 2104                            
kernel: end_request: I/O error, dev sdr, sector 2048                            
kernel: end_request: I/O error, dev sdr, sector 2048                            
kernel: __ratelimit: 125 callbacks suppressed                                   
kernel: sd 21:0:0:0: [sdr] Unhandled error code                                 
kernel: sd 21:0:0:0: [sdr] Result: hostbyte=DID_BAD_TARGET driverbyte=DRIVER_OK 
kernel: sd 21:0:0:0: [sdr] CDB: Read(10): 28 00 00 00 00 00 00 00 20 00         
kernel: __ratelimit: 125 callbacks suppressed                                   
kernel: __ratelimit: 128 callbacks suppressed                                   
kernel: Buffer I/O error on device sdr, logical block 0                         
kernel: Buffer I/O error on device sdr, logical block 1                         
kernel: Buffer I/O error on device sdr, logical block 2                         
kernel: Buffer I/O error on device sdr, logical block 3                         

    printk_ratelimit默认允许在5s内最多打印10条消息出来。可通过 /proc/sys/kernel/printk_ratelimit （多长时间）和 /proc/sys/kernel/printk_ratelimit_burst （在printk_ratelimit时间段内最多允许的消息数量）。当然如果内核代码里没有调用printk_ratelimit就不受这两个值的限制。

    内核块设备代码中的一个例子如下：

 

[cpp]  view plain  copy

1. bool blk_update_request(struct request *req, int error, unsigned int nr_bytes)  
2. {  
3.     int total_bytes, bio_nbytes, next_idx = 0;  
4.     struct bio *bio;  
5.   
6.     if (!req->bio)  
7.         return false;  
8.   
9.     trace_block_rq_complete(req->q, req);  
10.   
11.     /* 
12.      * For fs requests, rq is just carrier of independent bio's 
13.      * and each partial completion should be handled separately. 
14.      * Reset per-request error on each partial completion. 
15.      * 
16.      * TODO: tj: This is too subtle.  It would be better to let 
17.      * low level drivers do what they see fit. 
18.      */  
19.     if (req->cmd_type == REQ_TYPE_FS)  
20.         req->errors = 0;  
21.   
22.     if (error && req->cmd_type == REQ_TYPE_FS &&  
23.         !(req->cmd_flags & REQ_QUIET)) {  
24.         char *error_type;  
25.   
26.         switch (error) {  
27.         case -ENOLINK:  
28.             error_type = "recoverable transport";  
29.             break;  
30.         case -EREMOTEIO:  
31.             error_type = "critical target";  
32.             break;  
33.         case -EBADE:  
34.             error_type = "critical nexus";  
35.             break;  
36.         case -EIO:  
37.         default:  
38.             error_type = "I/O";  
39.             break;  
40.         }  
41.         printk_ratelimited(KERN_ERR "end_request: %s error, dev %s, "  
42.                    "sector %llu\n", error_type, req->rq_disk ?  
43.                    req->rq_disk->disk_name : "?",  
44.                    (unsigned long long)blk_rq_pos(req));  
45.     }  
46.   
47.     blk_account_io_completion(req, nr_bytes);  
48. ...  
49. }  

    printk_ratelimited是一个宏，并直接调用了 __ratelimit

 

[cpp]  view plain  copy

1. 1. #define printk_ratelimited(fmt, ...)  ({        \                                                        
   2.     static struct ratelimit_state _rs = {       \                                                        
   3.         .interval = DEFAULT_RATELIMIT_INTERVAL, \                                                        
   4.         .burst = DEFAULT_RATELIMIT_BURST,       \  
   5.     };                                              \                                                    
   6.                             \  
   7.     if (!__ratelimit(&_rs))                         \                                                    
   8.         printk(fmt, ##__VA_ARGS__);     \                                                                
   9. }) 

本文转自张昺华-sky博客园博客，原文链接： http://www.cnblogs.com/sky-heaven/p/7644086.html ，如需转载请自行联系原作者