include/linux/preempt.h

   1 #ifndef __LINUX_PREEMPT_H
   2 #define __LINUX_PREEMPT_H
   3
   4 /*
   5  * include/linux/preempt.h - macros for accessing and manipulating
   6  * preempt_count (used for kernel preemption, interrupt count, etc.)
   7  */
   8
   9 #include <linux/linkage.h>
  10 #include <linux/list.h>
  11
  12 /*
  13  * We use the MSB mostly because its available; see <linux/preempt_mask.h> for
  14  * the other bits -- can't include that header due to inclusion hell.
  15  */
  16 #define PREEMPT_NEED_RESCHED    0x80000000
  17
  18 #include <asm/preempt.h>
  19
  20 #if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_PREEMPT_TRACER)
  21 extern void preempt_count_add(int val);
  22 extern void preempt_count_sub(int val);
  23 #define preempt_count_dec_and_test() ({ preempt_count_sub(1); should_resched(); })
  24 #else
  25 #define preempt_count_add(val)  __preempt_count_add(val)
  26 #define preempt_count_sub(val)  __preempt_count_sub(val)
  27 #define preempt_count_dec_and_test() __preempt_count_dec_and_test()
  28 #endif
  29
  30 #define __preempt_count_inc() __preempt_count_add(1)
  31 #define __preempt_count_dec() __preempt_count_sub(1)
  32
  33 #define preempt_count_inc() preempt_count_add(1)
  34 #define preempt_count_dec() preempt_count_sub(1)
  35
  36 #ifdef CONFIG_PREEMPT_COUNT
  37
  38 #define preempt_disable() \
  39 do { \
  40         preempt_count_inc(); \
  41         barrier(); \
  42 } while (0)
  43
  44 #define sched_preempt_enable_no_resched() \
  45 do { \
  46         barrier(); \
  47         preempt_count_dec(); \
  48 } while (0)
  49
  50 #define preempt_enable_no_resched() sched_preempt_enable_no_resched()
  51
  52 #ifdef CONFIG_PREEMPT
  53 asmlinkage void preempt_schedule(void);
  54 #define preempt_enable() \
  55 do { \
  56         barrier(); \
  57         if (unlikely(preempt_count_dec_and_test())) \
  58                 preempt_schedule(); \
  59 } while (0)
  60
  61 #define preempt_check_resched() \
  62 do { \
  63         if (should_resched()) \
  64                 preempt_schedule(); \
  65 } while (0)
  66
  67 #else
  68 #define preempt_enable() preempt_enable_no_resched()
  69 #define preempt_check_resched() do { } while (0)
  70 #endif
  71
  72 #define preempt_disable_notrace() \
  73 do { \
  74         __preempt_count_inc(); \
  75         barrier(); \
  76 } while (0)
  77
  78 #define preempt_enable_no_resched_notrace() \
  79 do { \
  80         barrier(); \
  81         __preempt_count_dec(); \
  82 } while (0)
  83
  84 #ifdef CONFIG_PREEMPT
  85
  86 #ifdef CONFIG_CONTEXT_TRACKING
  87 asmlinkage void preempt_schedule_context(void);
  88 #else
  89 #define preempt_schedule_context() preempt_schedule()
  90 #endif
  91
  92 #define preempt_enable_notrace() \
  93 do { \
  94         barrier(); \
  95         if (unlikely(__preempt_count_dec_and_test())) \
  96                 preempt_schedule_context(); \
  97 } while (0)
  98 #else
  99 #define preempt_enable_notrace() preempt_enable_no_resched_notrace()
 100 #endif
 101
 102 #else /* !CONFIG_PREEMPT_COUNT */
 103
 104 /*
 105  * Even if we don't have any preemption, we need preempt disable/enable
 106  * to be barriers, so that we don't have things like get_user/put_user
 107  * that can cause faults and scheduling migrate into our preempt-protected
 108  * region.
 109  */
 110 #define preempt_disable()                       barrier()
 111 #define sched_preempt_enable_no_resched()       barrier()
 112 #define preempt_enable_no_resched()             barrier()
 113 #define preempt_enable()                        barrier()
 114 #define preempt_check_resched()                 do { } while (0)
 115
 116 #define preempt_disable_notrace()               barrier()
 117 #define preempt_enable_no_resched_notrace()     barrier()
 118 #define preempt_enable_notrace()                barrier()
 119
 120 #endif /* CONFIG_PREEMPT_COUNT */
 121
 122 #ifdef CONFIG_PREEMPT_NOTIFIERS
 123
 124 struct preempt_notifier;
 125
 126 /**
 127  * preempt_ops - notifiers called when a task is preempted and rescheduled
 128  * @sched_in: we're about to be rescheduled:
 129  *    notifier: struct preempt_notifier for the task being scheduled
 130  *    cpu:  cpu we're scheduled on
 131  * @sched_out: we've just been preempted
 132  *    notifier: struct preempt_notifier for the task being preempted
 133  *    next: the task that's kicking us out
 134  *
 135  * Please note that sched_in and out are called under different
 136  * contexts.  sched_out is called with rq lock held and irq disabled
 137  * while sched_in is called without rq lock and irq enabled.  This
 138  * difference is intentional and depended upon by its users.
 139  */
 140 struct preempt_ops {
 141         void (*sched_in)(struct preempt_notifier *notifier, int cpu);
 142         void (*sched_out)(struct preempt_notifier *notifier,
 143                           struct task_struct *next);
 144 };
 145
 146 /**
 147  * preempt_notifier - key for installing preemption notifiers
 148  * @link: internal use
 149  * @ops: defines the notifier functions to be called
 150  *
 151  * Usually used in conjunction with container_of().
 152  */
 153 struct preempt_notifier {
 154         struct hlist_node link;
 155         struct preempt_ops *ops;
 156 };
 157
 158 void preempt_notifier_register(struct preempt_notifier *notifier);
 159 void preempt_notifier_unregister(struct preempt_notifier *notifier);
 160
 161 static inline void preempt_notifier_init(struct preempt_notifier *notifier,
 162                                      struct preempt_ops *ops)
 163 {
 164         INIT_HLIST_NODE(&notifier->link);
 165         notifier->ops = ops;
 166 }
 167
 168 #endif
 169
 170 #endif /* __LINUX_PREEMPT_H */