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 ]
  1 #undef TRACE_SYSTEM
  2 #define TRACE_SYSTEM irq
  3 
  4 #if !defined(_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ)
  5 #define _TRACE_IRQ_H
  6 
  7 #include <linux/tracepoint.h>
  8 #include <linux/interrupt.h>
  9 
 10 #define softirq_name(sirq) { sirq##_SOFTIRQ, #sirq }
 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 before the irq action handler
 25  * @irq: irq number
 26  * @action: pointer to struct irqaction
 27  *
 28  * The struct irqaction pointed to by @action contains various
 29  * information about the handler, including the device name,
 30  * @action->name, and the device id, @action->dev_id. When used in
 31  * conjunction with the irq_handler_exit tracepoint, we can figure
 32  * out irq handler latencies.
 33  */
 34 TRACE_EVENT(irq_handler_entry,
 35 
 36         TP_PROTO(int irq, struct irqaction *action),
 37 
 38         TP_ARGS(irq, action),
 39 
 40         TP_STRUCT__entry(
 41                 __field(        int,    irq             )
 42                 __string(       name,   action->name    )
 43         ),
 44 
 45         TP_fast_assign(
 46                 __entry->irq = irq;
 47                 __assign_str(name, action->name);
 48         ),
 49 
 50         TP_printk("irq=%d handler=%s", __entry->irq, __get_str(name))
 51 );
 52 
 53 /**
 54  * irq_handler_exit - called immediately after the irq action handler returns
 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, then we know that the corresponding
 60  * @action->handler scuccessully handled this irq. Otherwise, the irq might be
 61  * a shared irq line, or the irq was not handled successfully. Can be used in
 62  * conjunction with the irq_handler_entry to understand irq handler latencies.
 63  */
 64 TRACE_EVENT(irq_handler_exit,
 65 
 66         TP_PROTO(int irq, struct irqaction *action, int ret),
 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 ? "handled" : "unhandled")
 82 );
 83 
 84 /**
 85  * softirq_entry - called immediately before the softirq handler
 86  * @h: pointer to struct softirq_action
 87  * @vec: pointer to first struct softirq_action in softirq_vec array
 88  *
 89  * The @h parameter, contains a pointer to the struct softirq_action
 90  * which has a pointer to the action handler that is called. By subtracting
 91  * the @vec pointer from the @h pointer, we can determine the softirq
 92  * number. Also, when used in combination with the softirq_exit tracepoint
 93  * we can determine the softirq latency.
 94  */
 95 TRACE_EVENT(softirq_entry,
 96 
 97         TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
 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", __entry->vec,
110                   show_softirq_name(__entry->vec))
111 );
112 
113 /**
114  * softirq_exit - called immediately after the softirq handler returns
115  * @h: pointer to struct softirq_action
116  * @vec: pointer to first struct softirq_action in softirq_vec array
117  *
118  * The @h parameter contains a pointer to the struct softirq_action
119  * that has handled the softirq. By subtracting the @vec pointer from
120  * the @h pointer, we can determine the softirq number. Also, when used in
121  * combination with the softirq_entry tracepoint we can determine the softirq
122  * latency.
123  */
124 TRACE_EVENT(softirq_exit,
125 
126         TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
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", __entry->vec,
139                   show_softirq_name(__entry->vec))
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.