mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-30 07:34:12 +08:00
386afc9114
In UP and non-preempt respectively, the spinlocks and preemption disable/enable points are stubbed out entirely, because there is no regular code that can ever hit the kind of concurrency they are meant to protect against. However, while there is no regular code that can cause scheduling, we _do_ end up having some exceptional (literally!) code that can do so, and that we need to make sure does not ever get moved into the critical region by the compiler. In particular, get_user() and put_user() is generally implemented as inline asm statements (even if the inline asm may then make a call instruction to call out-of-line), and can obviously cause a page fault and IO as a result. If that inline asm has been scheduled into the middle of a preemption-safe (or spinlock-protected) code region, we obviously lose. Now, admittedly this is *very* unlikely to actually ever happen, and we've not seen examples of actual bugs related to this. But partly exactly because it's so hard to trigger and the resulting bug is so subtle, we should be extra careful to get this right. So make sure that even when preemption is disabled, and we don't have to generate any actual *code* to explicitly tell the system that we are in a preemption-disabled region, we need to at least tell the compiler not to move things around the critical region. This patch grew out of the same discussion that caused commits79e5f05edc("ARC: Add implicit compiler barrier to raw_local_irq* functions") and3e2e0d2c22("tile: comment assumption about __insn_mtspr for <asm/irqflags.h>") to come about. Note for stable: use discretion when/if applying this. As mentioned, this bug may never have actually bitten anybody, and gcc may never have done the required code motion for it to possibly ever trigger in practice. Cc: stable@vger.kernel.org Cc: Steven Rostedt <srostedt@redhat.com> Cc: Peter Zijlstra <peterz@infradead.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
162 lines
4.3 KiB
C
162 lines
4.3 KiB
C
#ifndef __LINUX_PREEMPT_H
|
|
#define __LINUX_PREEMPT_H
|
|
|
|
/*
|
|
* include/linux/preempt.h - macros for accessing and manipulating
|
|
* preempt_count (used for kernel preemption, interrupt count, etc.)
|
|
*/
|
|
|
|
#include <linux/thread_info.h>
|
|
#include <linux/linkage.h>
|
|
#include <linux/list.h>
|
|
|
|
#if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_PREEMPT_TRACER)
|
|
extern void add_preempt_count(int val);
|
|
extern void sub_preempt_count(int val);
|
|
#else
|
|
# define add_preempt_count(val) do { preempt_count() += (val); } while (0)
|
|
# define sub_preempt_count(val) do { preempt_count() -= (val); } while (0)
|
|
#endif
|
|
|
|
#define inc_preempt_count() add_preempt_count(1)
|
|
#define dec_preempt_count() sub_preempt_count(1)
|
|
|
|
#define preempt_count() (current_thread_info()->preempt_count)
|
|
|
|
#ifdef CONFIG_PREEMPT
|
|
|
|
asmlinkage void preempt_schedule(void);
|
|
|
|
#define preempt_check_resched() \
|
|
do { \
|
|
if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
|
|
preempt_schedule(); \
|
|
} while (0)
|
|
|
|
#else /* !CONFIG_PREEMPT */
|
|
|
|
#define preempt_check_resched() do { } while (0)
|
|
|
|
#endif /* CONFIG_PREEMPT */
|
|
|
|
|
|
#ifdef CONFIG_PREEMPT_COUNT
|
|
|
|
#define preempt_disable() \
|
|
do { \
|
|
inc_preempt_count(); \
|
|
barrier(); \
|
|
} while (0)
|
|
|
|
#define sched_preempt_enable_no_resched() \
|
|
do { \
|
|
barrier(); \
|
|
dec_preempt_count(); \
|
|
} while (0)
|
|
|
|
#define preempt_enable_no_resched() sched_preempt_enable_no_resched()
|
|
|
|
#define preempt_enable() \
|
|
do { \
|
|
preempt_enable_no_resched(); \
|
|
barrier(); \
|
|
preempt_check_resched(); \
|
|
} while (0)
|
|
|
|
/* For debugging and tracer internals only! */
|
|
#define add_preempt_count_notrace(val) \
|
|
do { preempt_count() += (val); } while (0)
|
|
#define sub_preempt_count_notrace(val) \
|
|
do { preempt_count() -= (val); } while (0)
|
|
#define inc_preempt_count_notrace() add_preempt_count_notrace(1)
|
|
#define dec_preempt_count_notrace() sub_preempt_count_notrace(1)
|
|
|
|
#define preempt_disable_notrace() \
|
|
do { \
|
|
inc_preempt_count_notrace(); \
|
|
barrier(); \
|
|
} while (0)
|
|
|
|
#define preempt_enable_no_resched_notrace() \
|
|
do { \
|
|
barrier(); \
|
|
dec_preempt_count_notrace(); \
|
|
} while (0)
|
|
|
|
/* preempt_check_resched is OK to trace */
|
|
#define preempt_enable_notrace() \
|
|
do { \
|
|
preempt_enable_no_resched_notrace(); \
|
|
barrier(); \
|
|
preempt_check_resched(); \
|
|
} while (0)
|
|
|
|
#else /* !CONFIG_PREEMPT_COUNT */
|
|
|
|
/*
|
|
* Even if we don't have any preemption, we need preempt disable/enable
|
|
* to be barriers, so that we don't have things like get_user/put_user
|
|
* that can cause faults and scheduling migrate into our preempt-protected
|
|
* region.
|
|
*/
|
|
#define preempt_disable() barrier()
|
|
#define sched_preempt_enable_no_resched() barrier()
|
|
#define preempt_enable_no_resched() barrier()
|
|
#define preempt_enable() barrier()
|
|
|
|
#define preempt_disable_notrace() barrier()
|
|
#define preempt_enable_no_resched_notrace() barrier()
|
|
#define preempt_enable_notrace() barrier()
|
|
|
|
#endif /* CONFIG_PREEMPT_COUNT */
|
|
|
|
#ifdef CONFIG_PREEMPT_NOTIFIERS
|
|
|
|
struct preempt_notifier;
|
|
|
|
/**
|
|
* preempt_ops - notifiers called when a task is preempted and rescheduled
|
|
* @sched_in: we're about to be rescheduled:
|
|
* notifier: struct preempt_notifier for the task being scheduled
|
|
* cpu: cpu we're scheduled on
|
|
* @sched_out: we've just been preempted
|
|
* notifier: struct preempt_notifier for the task being preempted
|
|
* next: the task that's kicking us out
|
|
*
|
|
* Please note that sched_in and out are called under different
|
|
* contexts. sched_out is called with rq lock held and irq disabled
|
|
* while sched_in is called without rq lock and irq enabled. This
|
|
* difference is intentional and depended upon by its users.
|
|
*/
|
|
struct preempt_ops {
|
|
void (*sched_in)(struct preempt_notifier *notifier, int cpu);
|
|
void (*sched_out)(struct preempt_notifier *notifier,
|
|
struct task_struct *next);
|
|
};
|
|
|
|
/**
|
|
* preempt_notifier - key for installing preemption notifiers
|
|
* @link: internal use
|
|
* @ops: defines the notifier functions to be called
|
|
*
|
|
* Usually used in conjunction with container_of().
|
|
*/
|
|
struct preempt_notifier {
|
|
struct hlist_node link;
|
|
struct preempt_ops *ops;
|
|
};
|
|
|
|
void preempt_notifier_register(struct preempt_notifier *notifier);
|
|
void preempt_notifier_unregister(struct preempt_notifier *notifier);
|
|
|
|
static inline void preempt_notifier_init(struct preempt_notifier *notifier,
|
|
struct preempt_ops *ops)
|
|
{
|
|
INIT_HLIST_NODE(¬ifier->link);
|
|
notifier->ops = ops;
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* __LINUX_PREEMPT_H */
|