Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#ifndef LINUX_PREEMPT_MASK_H
2#define LINUX_PREEMPT_MASK_H
3
4#include <linux/preempt.h>
5#include <asm/hardirq.h>
6
7/*
8 * We put the hardirq and softirq counter into the preemption
9 * counter. The bitmask has the following meaning:
10 *
11 * - bits 0-7 are the preemption count (max preemption depth: 256)
12 * - bits 8-15 are the softirq count (max # of softirqs: 256)
13 *
14 * The hardirq count could in theory be the same as the number of
15 * interrupts in the system, but we run all interrupt handlers with
16 * interrupts disabled, so we cannot have nesting interrupts. Though
17 * there are a few palaeontologic drivers which reenable interrupts in
18 * the handler, so we need more than one bit here.
19 *
20 * PREEMPT_MASK: 0x000000ff
21 * SOFTIRQ_MASK: 0x0000ff00
22 * HARDIRQ_MASK: 0x000f0000
23 * NMI_MASK: 0x00100000
24 * PREEMPT_ACTIVE: 0x00200000
25 */
26#define PREEMPT_BITS 8
27#define SOFTIRQ_BITS 8
28#define HARDIRQ_BITS 4
29#define NMI_BITS 1
30
31#define PREEMPT_SHIFT 0
32#define SOFTIRQ_SHIFT (PREEMPT_SHIFT + PREEMPT_BITS)
33#define HARDIRQ_SHIFT (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
34#define NMI_SHIFT (HARDIRQ_SHIFT + HARDIRQ_BITS)
35
36#define __IRQ_MASK(x) ((1UL << (x))-1)
37
38#define PREEMPT_MASK (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
39#define SOFTIRQ_MASK (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
40#define HARDIRQ_MASK (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
41#define NMI_MASK (__IRQ_MASK(NMI_BITS) << NMI_SHIFT)
42
43#define PREEMPT_OFFSET (1UL << PREEMPT_SHIFT)
44#define SOFTIRQ_OFFSET (1UL << SOFTIRQ_SHIFT)
45#define HARDIRQ_OFFSET (1UL << HARDIRQ_SHIFT)
46#define NMI_OFFSET (1UL << NMI_SHIFT)
47
48#define SOFTIRQ_DISABLE_OFFSET (2 * SOFTIRQ_OFFSET)
49
50#define PREEMPT_ACTIVE_BITS 1
51#define PREEMPT_ACTIVE_SHIFT (NMI_SHIFT + NMI_BITS)
52#define PREEMPT_ACTIVE (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
53
54#define hardirq_count() (preempt_count() & HARDIRQ_MASK)
55#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
56#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
57 | NMI_MASK))
58
59/*
60 * Are we doing bottom half or hardware interrupt processing?
61 * Are we in a softirq context? Interrupt context?
62 * in_softirq - Are we currently processing softirq or have bh disabled?
63 * in_serving_softirq - Are we currently processing softirq?
64 */
65#define in_irq() (hardirq_count())
66#define in_softirq() (softirq_count())
67#define in_interrupt() (irq_count())
68#define in_serving_softirq() (softirq_count() & SOFTIRQ_OFFSET)
69
70/*
71 * Are we in NMI context?
72 */
73#define in_nmi() (preempt_count() & NMI_MASK)
74
75#if defined(CONFIG_PREEMPT_COUNT)
76# define PREEMPT_CHECK_OFFSET 1
77#else
78# define PREEMPT_CHECK_OFFSET 0
79#endif
80
81/*
82 * Are we running in atomic context? WARNING: this macro cannot
83 * always detect atomic context; in particular, it cannot know about
84 * held spinlocks in non-preemptible kernels. Thus it should not be
85 * used in the general case to determine whether sleeping is possible.
86 * Do not use in_atomic() in driver code.
87 */
88#define in_atomic() ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
89
90/*
91 * Check whether we were atomic before we did preempt_disable():
92 * (used by the scheduler, *after* releasing the kernel lock)
93 */
94#define in_atomic_preempt_off() \
95 ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
96
97#ifdef CONFIG_PREEMPT_COUNT
98# define preemptible() (preempt_count() == 0 && !irqs_disabled())
99#else
100# define preemptible() 0
101#endif
102
103#endif /* LINUX_PREEMPT_MASK_H */