1 #if !defined(_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ) 2 #define _TRACE_IRQ_H 3 4 #include <linux/tracepoint.h> 5 #include <linux/interrupt.h> 6 7 #undef TRACE_SYSTEM 8 #define TRACE_SYSTEM irq 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