Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]

Diff markup

Differences between /linux/include/trace/events/irq.h (Version 2.6.31.13) and /linux/include/trace/events/irq.h (Version 2.6.11.8)


  1 #undef TRACE_SYSTEM                                 1 
  2 #define TRACE_SYSTEM irq                          
  3                                                   
  4 #if !defined(_TRACE_IRQ_H) || defined(TRACE_HE    
  5 #define _TRACE_IRQ_H                              
  6                                                   
  7 #include <linux/tracepoint.h>                     
  8 #include <linux/interrupt.h>                      
  9                                                   
 10 #define softirq_name(sirq) { sirq##_SOFTIRQ, #    
 11 #define show_softirq_name(val)                    
 12         __print_symbolic(val,                     
 13                          softirq_name(HI),        
 14                          softirq_name(TIMER),     
 15                          softirq_name(NET_TX),    
 16                          softirq_name(NET_RX),    
 17                          softirq_name(BLOCK),     
 18                          softirq_name(TASKLET)    
 19                          softirq_name(SCHED),     
 20                          softirq_name(HRTIMER)    
 21                          softirq_name(RCU))       
 22                                                   
 23 /**                                               
 24  * irq_handler_entry - called immediately befo    
 25  * @irq: irq number                               
 26  * @action: pointer to struct irqaction           
 27  *                                                
 28  * The struct irqaction pointed to by @action     
 29  * information about the handler, including th    
 30  * @action->name, and the device id, @action->    
 31  * conjunction with the irq_handler_exit trace    
 32  * out irq handler latencies.                     
 33  */                                               
 34 TRACE_EVENT(irq_handler_entry,                    
 35                                                   
 36         TP_PROTO(int irq, struct irqaction *ac    
 37                                                   
 38         TP_ARGS(irq, action),                     
 39                                                   
 40         TP_STRUCT__entry(                         
 41                 __field(        int,    irq       
 42                 __string(       name,   action    
 43         ),                                        
 44                                                   
 45         TP_fast_assign(                           
 46                 __entry->irq = irq;               
 47                 __assign_str(name, action->nam    
 48         ),                                        
 49                                                   
 50         TP_printk("irq=%d handler=%s", __entry    
 51 );                                                
 52                                                   
 53 /**                                               
 54  * irq_handler_exit - called immediately after    
 55  * @irq: irq number                               
 56  * @action: pointer to struct irqaction           
 57  * @ret: return value                             
 58  *                                                
 59  * If the @ret value is set to IRQ_HANDLED, th    
 60  * @action->handler scuccessully handled this     
 61  * a shared irq line, or the irq was not handl    
 62  * conjunction with the irq_handler_entry to u    
 63  */                                               
 64 TRACE_EVENT(irq_handler_exit,                     
 65                                                   
 66         TP_PROTO(int irq, struct irqaction *ac    
 67                                                   
 68         TP_ARGS(irq, action, ret),                
 69                                                   
 70         TP_STRUCT__entry(                         
 71                 __field(        int,    irq       
 72                 __field(        int,    ret       
 73         ),                                        
 74                                                   
 75         TP_fast_assign(                           
 76                 __entry->irq    = irq;            
 77                 __entry->ret    = ret;            
 78         ),                                        
 79                                                   
 80         TP_printk("irq=%d return=%s",             
 81                   __entry->irq, __entry->ret ?    
 82 );                                                
 83                                                   
 84 /**                                               
 85  * softirq_entry - called immediately before t    
 86  * @h: pointer to struct softirq_action           
 87  * @vec: pointer to first struct softirq_actio    
 88  *                                                
 89  * The @h parameter, contains a pointer to the    
 90  * which has a pointer to the action handler t    
 91  * the @vec pointer from the @h pointer, we ca    
 92  * number. Also, when used in combination with    
 93  * we can determine the softirq latency.          
 94  */                                               
 95 TRACE_EVENT(softirq_entry,                        
 96                                                   
 97         TP_PROTO(struct softirq_action *h, str    
 98                                                   
 99         TP_ARGS(h, vec),                          
100                                                   
101         TP_STRUCT__entry(                         
102                 __field(        int,    vec       
103         ),                                        
104                                                   
105         TP_fast_assign(                           
106                 __entry->vec = (int)(h - vec);    
107         ),                                        
108                                                   
109         TP_printk("softirq=%d action=%s", __en    
110                   show_softirq_name(__entry->v    
111 );                                                
112                                                   
113 /**                                               
114  * softirq_exit - called immediately after the    
115  * @h: pointer to struct softirq_action           
116  * @vec: pointer to first struct softirq_actio    
117  *                                                
118  * The @h parameter contains a pointer to the     
119  * that has handled the softirq. By subtractin    
120  * the @h pointer, we can determine the softir    
121  * combination with the softirq_entry tracepoi    
122  * latency.                                       
123  */                                               
124 TRACE_EVENT(softirq_exit,                         
125                                                   
126         TP_PROTO(struct softirq_action *h, str    
127                                                   
128         TP_ARGS(h, vec),                          
129                                                   
130         TP_STRUCT__entry(                         
131                 __field(        int,    vec       
132         ),                                        
133                                                   
134         TP_fast_assign(                           
135                 __entry->vec = (int)(h - vec);    
136         ),                                        
137                                                   
138         TP_printk("softirq=%d action=%s", __en    
139                   show_softirq_name(__entry->v    
140 );                                                
141                                                   
142 #endif /*  _TRACE_IRQ_H */                        
143                                                   
144 /* This part must be outside protection */        
145 #include <trace/define_trace.h>                   
146                                                   
  This page was automatically generated by the LXR engine.