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 #define tif_need_resched() test_thread_flag(TIF_NEED_RESCHED)
  19
  20 #include <asm/preempt.h>
  21
  22 #if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_PREEMPT_TRACER)
  23 extern void preempt_count_add(int val);
  24 extern void preempt_count_sub(int val);
  25 #define preempt_count_dec_and_test() ({ preempt_count_sub(1); should_resched(); })
  26 #else
  27 #define preempt_count_add(val)  __preempt_count_add(val)
  28 #define preempt_count_sub(val)  __preempt_count_sub(val)
  29 #define preempt_count_dec_and_test() __preempt_count_dec_and_test()
  30 #endif
  31
  32 #define __preempt_count_inc() __preempt_count_add(1)
  33 #define __preempt_count_dec() __preempt_count_sub(1)
  34
  35 #define preempt_count_inc() preempt_count_add(1)
  36 #define preempt_count_dec() preempt_count_sub(1)
  37
  38 #ifdef CONFIG_PREEMPT_COUNT
  39
  40 #define preempt_disable() \
  41 do { \
  42         preempt_count_inc(); \
  43         barrier(); \
  44 } while (0)
  45
  46 #define sched_preempt_enable_no_resched() \
  47 do { \
  48         barrier(); \
  49         preempt_count_dec(); \
  50 } while (0)
  51
  52 #define preempt_enable_no_resched() sched_preempt_enable_no_resched()
  53
  54 #ifdef CONFIG_PREEMPT
  55 #define preempt_enable() \
  56 do { \
  57         barrier(); \
  58         if (unlikely(preempt_count_dec_and_test())) \
  59                 __preempt_schedule(); \
  60 } while (0)
  61
  62 #define preempt_check_resched() \
  63 do { \
  64         if (should_resched()) \
  65                 __preempt_schedule(); \
  66 } while (0)
  67
  68 #else
  69 #define preempt_enable() \
  70 do { \
  71         barrier(); \
  72         preempt_count_dec(); \
  73 } while (0)
  74 #define preempt_check_resched() do { } while (0)
  75 #endif
  76
  77 #define preempt_disable_notrace() \
  78 do { \
  79         __preempt_count_inc(); \
  80         barrier(); \
  81 } while (0)
  82
  83 #define preempt_enable_no_resched_notrace() \
  84 do { \
  85         barrier(); \
  86         __preempt_count_dec(); \
  87 } while (0)
  88
  89 #ifdef CONFIG_PREEMPT
  90
  91 #ifndef CONFIG_CONTEXT_TRACKING
  92 #define __preempt_schedule_context() __preempt_schedule()
  93 #endif
  94
  95 #define preempt_enable_notrace() \
  96 do { \
  97         barrier(); \
  98         if (unlikely(__preempt_count_dec_and_test())) \
  99                 __preempt_schedule_context(); \
 100 } while (0)
 101 #else
 102 #define preempt_enable_notrace() \
 103 do { \
 104         barrier(); \
 105         __preempt_count_dec(); \
 106 } while (0)
 107 #endif
 108
 109 #else /* !CONFIG_PREEMPT_COUNT */
 110
 111 /*
 112  * Even if we don't have any preemption, we need preempt disable/enable
 113  * to be barriers, so that we don't have things like get_user/put_user
 114  * that can cause faults and scheduling migrate into our preempt-protected
 115  * region.
 116  */
 117 #define preempt_disable()                       barrier()
 118 #define sched_preempt_enable_no_resched()       barrier()
 119 #define preempt_enable_no_resched()             barrier()
 120 #define preempt_enable()                        barrier()
 121 #define preempt_check_resched()                 do { } while (0)
 122
 123 #define preempt_disable_notrace()               barrier()
 124 #define preempt_enable_no_resched_notrace()     barrier()
 125 #define preempt_enable_notrace()                barrier()
 126
 127 #endif /* CONFIG_PREEMPT_COUNT */
 128
 129 #ifdef MODULE
 130 /*
 131  * Modules have no business playing preemption tricks.
 132  */
 133 #undef sched_preempt_enable_no_resched
 134 #undef preempt_enable_no_resched
 135 #undef preempt_enable_no_resched_notrace
 136 #undef preempt_check_resched
 137 #endif
 138
 139 #define preempt_set_need_resched() \
 140 do { \
 141         set_preempt_need_resched(); \
 142 } while (0)
 143 #define preempt_fold_need_resched() \
 144 do { \
 145         if (tif_need_resched()) \
 146                 set_preempt_need_resched(); \
 147 } while (0)
 148
 149 #ifdef CONFIG_PREEMPT_NOTIFIERS
 150
 151 struct preempt_notifier;
 152
 153 /**
 154  * preempt_ops - notifiers called when a task is preempted and rescheduled
 155  * @sched_in: we're about to be rescheduled:
 156  *    notifier: struct preempt_notifier for the task being scheduled
 157  *    cpu:  cpu we're scheduled on
 158  * @sched_out: we've just been preempted
 159  *    notifier: struct preempt_notifier for the task being preempted
 160  *    next: the task that's kicking us out
 161  *
 162  * Please note that sched_in and out are called under different
 163  * contexts.  sched_out is called with rq lock held and irq disabled
 164  * while sched_in is called without rq lock and irq enabled.  This
 165  * difference is intentional and depended upon by its users.
 166  */
 167 struct preempt_ops {
 168         void (*sched_in)(struct preempt_notifier *notifier, int cpu);
 169         void (*sched_out)(struct preempt_notifier *notifier,
 170                           struct task_struct *next);
 171 };
 172
 173 /**
 174  * preempt_notifier - key for installing preemption notifiers
 175  * @link: internal use
 176  * @ops: defines the notifier functions to be called
 177  *
 178  * Usually used in conjunction with container_of().
 179  */
 180 struct preempt_notifier {
 181         struct hlist_node link;
 182         struct preempt_ops *ops;
 183 };
 184
 185 void preempt_notifier_register(struct preempt_notifier *notifier);
 186 void preempt_notifier_unregister(struct preempt_notifier *notifier);
 187
 188 static inline void preempt_notifier_init(struct preempt_notifier *notifier,
 189                                      struct preempt_ops *ops)
 190 {
 191         INIT_HLIST_NODE(&notifier->link);
 192         notifier->ops = ops;
 193 }
 194
 195 #endif
 196
 197 #endif /* __LINUX_PREEMPT_H */