sched: Add IRQ_TIME_ACCOUNTING, finer accounting of irq time
[linux-2.6.git] / include / linux / hardirq.h
1 #ifndef LINUX_HARDIRQ_H
2 #define LINUX_HARDIRQ_H
3
4 #include <linux/preempt.h>
5 #ifdef CONFIG_PREEMPT
6 #include <linux/smp_lock.h>
7 #endif
8 #include <linux/lockdep.h>
9 #include <linux/ftrace_irq.h>
10 #include <asm/hardirq.h>
11 #include <asm/system.h>
12
13 /*
14  * We put the hardirq and softirq counter into the preemption
15  * counter. The bitmask has the following meaning:
16  *
17  * - bits 0-7 are the preemption count (max preemption depth: 256)
18  * - bits 8-15 are the softirq count (max # of softirqs: 256)
19  *
20  * The hardirq count can in theory reach the same as NR_IRQS.
21  * In reality, the number of nested IRQS is limited to the stack
22  * size as well. For archs with over 1000 IRQS it is not practical
23  * to expect that they will all nest. We give a max of 10 bits for
24  * hardirq nesting. An arch may choose to give less than 10 bits.
25  * m68k expects it to be 8.
26  *
27  * - bits 16-25 are the hardirq count (max # of nested hardirqs: 1024)
28  * - bit 26 is the NMI_MASK
29  * - bit 28 is the PREEMPT_ACTIVE flag
30  *
31  * PREEMPT_MASK: 0x000000ff
32  * SOFTIRQ_MASK: 0x0000ff00
33  * HARDIRQ_MASK: 0x03ff0000
34  *     NMI_MASK: 0x04000000
35  */
36 #define PREEMPT_BITS    8
37 #define SOFTIRQ_BITS    8
38 #define NMI_BITS        1
39
40 #define MAX_HARDIRQ_BITS 10
41
42 #ifndef HARDIRQ_BITS
43 # define HARDIRQ_BITS   MAX_HARDIRQ_BITS
44 #endif
45
46 #if HARDIRQ_BITS > MAX_HARDIRQ_BITS
47 #error HARDIRQ_BITS too high!
48 #endif
49
50 #define PREEMPT_SHIFT   0
51 #define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
52 #define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
53 #define NMI_SHIFT       (HARDIRQ_SHIFT + HARDIRQ_BITS)
54
55 #define __IRQ_MASK(x)   ((1UL << (x))-1)
56
57 #define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
58 #define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
59 #define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
60 #define NMI_MASK        (__IRQ_MASK(NMI_BITS)     << NMI_SHIFT)
61
62 #define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
63 #define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
64 #define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
65 #define NMI_OFFSET      (1UL << NMI_SHIFT)
66
67 #define SOFTIRQ_DISABLE_OFFSET  (2 * SOFTIRQ_OFFSET)
68
69 #ifndef PREEMPT_ACTIVE
70 #define PREEMPT_ACTIVE_BITS     1
71 #define PREEMPT_ACTIVE_SHIFT    (NMI_SHIFT + NMI_BITS)
72 #define PREEMPT_ACTIVE  (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
73 #endif
74
75 #if PREEMPT_ACTIVE < (1 << (NMI_SHIFT + NMI_BITS))
76 #error PREEMPT_ACTIVE is too low!
77 #endif
78
79 #define hardirq_count() (preempt_count() & HARDIRQ_MASK)
80 #define softirq_count() (preempt_count() & SOFTIRQ_MASK)
81 #define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
82                                  | NMI_MASK))
83
84 /*
85  * Are we doing bottom half or hardware interrupt processing?
86  * Are we in a softirq context? Interrupt context?
87  * in_softirq - Are we currently processing softirq or have bh disabled?
88  * in_serving_softirq - Are we currently processing softirq?
89  */
90 #define in_irq()                (hardirq_count())
91 #define in_softirq()            (softirq_count())
92 #define in_interrupt()          (irq_count())
93 #define in_serving_softirq()    (softirq_count() & SOFTIRQ_OFFSET)
94
95 /*
96  * Are we in NMI context?
97  */
98 #define in_nmi()        (preempt_count() & NMI_MASK)
99
100 #if defined(CONFIG_PREEMPT)
101 # define PREEMPT_INATOMIC_BASE kernel_locked()
102 # define PREEMPT_CHECK_OFFSET 1
103 #else
104 # define PREEMPT_INATOMIC_BASE 0
105 # define PREEMPT_CHECK_OFFSET 0
106 #endif
107
108 /*
109  * Are we running in atomic context?  WARNING: this macro cannot
110  * always detect atomic context; in particular, it cannot know about
111  * held spinlocks in non-preemptible kernels.  Thus it should not be
112  * used in the general case to determine whether sleeping is possible.
113  * Do not use in_atomic() in driver code.
114  */
115 #define in_atomic()     ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_INATOMIC_BASE)
116
117 /*
118  * Check whether we were atomic before we did preempt_disable():
119  * (used by the scheduler, *after* releasing the kernel lock)
120  */
121 #define in_atomic_preempt_off() \
122                 ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
123
124 #ifdef CONFIG_PREEMPT
125 # define preemptible()  (preempt_count() == 0 && !irqs_disabled())
126 # define IRQ_EXIT_OFFSET (HARDIRQ_OFFSET-1)
127 #else
128 # define preemptible()  0
129 # define IRQ_EXIT_OFFSET HARDIRQ_OFFSET
130 #endif
131
132 #if defined(CONFIG_SMP) || defined(CONFIG_GENERIC_HARDIRQS)
133 extern void synchronize_irq(unsigned int irq);
134 #else
135 # define synchronize_irq(irq)   barrier()
136 #endif
137
138 struct task_struct;
139
140 #if !defined(CONFIG_VIRT_CPU_ACCOUNTING) && !defined(CONFIG_IRQ_TIME_ACCOUNTING)
141 static inline void account_system_vtime(struct task_struct *tsk)
142 {
143 }
144 #else
145 extern void account_system_vtime(struct task_struct *tsk);
146 #endif
147
148 #if defined(CONFIG_NO_HZ)
149 #if defined(CONFIG_TINY_RCU)
150 extern void rcu_enter_nohz(void);
151 extern void rcu_exit_nohz(void);
152
153 static inline void rcu_irq_enter(void)
154 {
155         rcu_exit_nohz();
156 }
157
158 static inline void rcu_irq_exit(void)
159 {
160         rcu_enter_nohz();
161 }
162
163 static inline void rcu_nmi_enter(void)
164 {
165 }
166
167 static inline void rcu_nmi_exit(void)
168 {
169 }
170
171 #else
172 extern void rcu_irq_enter(void);
173 extern void rcu_irq_exit(void);
174 extern void rcu_nmi_enter(void);
175 extern void rcu_nmi_exit(void);
176 #endif
177 #else
178 # define rcu_irq_enter() do { } while (0)
179 # define rcu_irq_exit() do { } while (0)
180 # define rcu_nmi_enter() do { } while (0)
181 # define rcu_nmi_exit() do { } while (0)
182 #endif /* #if defined(CONFIG_NO_HZ) */
183
184 /*
185  * It is safe to do non-atomic ops on ->hardirq_context,
186  * because NMI handlers may not preempt and the ops are
187  * always balanced, so the interrupted value of ->hardirq_context
188  * will always be restored.
189  */
190 #define __irq_enter()                                   \
191         do {                                            \
192                 account_system_vtime(current);          \
193                 add_preempt_count(HARDIRQ_OFFSET);      \
194                 trace_hardirq_enter();                  \
195         } while (0)
196
197 /*
198  * Enter irq context (on NO_HZ, update jiffies):
199  */
200 extern void irq_enter(void);
201
202 /*
203  * Exit irq context without processing softirqs:
204  */
205 #define __irq_exit()                                    \
206         do {                                            \
207                 trace_hardirq_exit();                   \
208                 account_system_vtime(current);          \
209                 sub_preempt_count(HARDIRQ_OFFSET);      \
210         } while (0)
211
212 /*
213  * Exit irq context and process softirqs if needed:
214  */
215 extern void irq_exit(void);
216
217 #define nmi_enter()                                             \
218         do {                                                    \
219                 ftrace_nmi_enter();                             \
220                 BUG_ON(in_nmi());                               \
221                 add_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
222                 lockdep_off();                                  \
223                 rcu_nmi_enter();                                \
224                 trace_hardirq_enter();                          \
225         } while (0)
226
227 #define nmi_exit()                                              \
228         do {                                                    \
229                 trace_hardirq_exit();                           \
230                 rcu_nmi_exit();                                 \
231                 lockdep_on();                                   \
232                 BUG_ON(!in_nmi());                              \
233                 sub_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
234                 ftrace_nmi_exit();                              \
235         } while (0)
236
237 #endif /* LINUX_HARDIRQ_H */