preempt.h 4.4 KB

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