[deliverable/linux.git] / arch / x86 / include / asm / i387.h

/*
 * Copyright (C) 1994 Linus Torvalds
 *
 * Pentium III FXSR, SSE support
 * General FPU state handling cleanups
 *	Gareth Hughes <gareth@valinux.com>, May 2000
 * x86-64 work by Andi Kleen 2002
 */

#ifndef _ASM_X86_I387_H
#define _ASM_X86_I387_H

#ifndef __ASSEMBLY__

#include <linux/sched.h>
#include <linux/hardirq.h>

struct pt_regs;
struct user_i387_struct;

extern int init_fpu(struct task_struct *child);
extern void fpu_finit(struct fpu *fpu);
extern int dump_fpu(struct pt_regs *, struct user_i387_struct *);
extern void math_state_restore(void);

extern bool irq_fpu_usable(void);

/*
 * Careful: __kernel_fpu_begin/end() must be called with preempt disabled
 * and they don't touch the preempt state on their own.
 * If you enable preemption after __kernel_fpu_begin(), preempt notifier
 * should call the __kernel_fpu_end() to prevent the kernel/user FPU
 * state from getting corrupted. KVM for example uses this model.
 *
 * All other cases use kernel_fpu_begin/end() which disable preemption
 * during kernel FPU usage.
 */
extern void __kernel_fpu_begin(void);
extern void __kernel_fpu_end(void);

static inline void kernel_fpu_begin(void)
{
	WARN_ON_ONCE(!irq_fpu_usable());
	preempt_disable();
	__kernel_fpu_begin();
}

static inline void kernel_fpu_end(void)
{
	__kernel_fpu_end();
	preempt_enable();
}

/*
 * Some instructions like VIA's padlock instructions generate a spurious
 * DNA fault but don't modify SSE registers. And these instructions
 * get used from interrupt context as well. To prevent these kernel instructions
 * in interrupt context interacting wrongly with other user/kernel fpu usage, we
 * should use them only in the context of irq_ts_save/restore()
 */
static inline int irq_ts_save(void)
{
	/*
	 * If in process context and not atomic, we can take a spurious DNA fault.
	 * Otherwise, doing clts() in process context requires disabling preemption
	 * or some heavy lifting like kernel_fpu_begin()
	 */
	if (!in_atomic())
		return 0;

	if (read_cr0() & X86_CR0_TS) {
		clts();
		return 1;
	}

	return 0;
}

static inline void irq_ts_restore(int TS_state)
{
	if (TS_state)
		stts();
}

/*
 * The question "does this thread have fpu access?"
 * is slightly racy, since preemption could come in
 * and revoke it immediately after the test.
 *
 * However, even in that very unlikely scenario,
 * we can just assume we have FPU access - typically
 * to save the FP state - we'll just take a #NM
 * fault and get the FPU access back.
 */
static inline int user_has_fpu(void)
{
	return current->thread.fpu.has_fpu;
}

extern void unlazy_fpu(struct task_struct *tsk);

#endif /* __ASSEMBLY__ */

#endif /* _ASM_X86_I387_H */
Commit	Line	Data
1eeaed76 RM	1	/*
	2	* Copyright (C) 1994 Linus Torvalds
	3	*
	4	* Pentium III FXSR, SSE support
	5	* General FPU state handling cleanups
	6	* Gareth Hughes <gareth@valinux.com>, May 2000
	7	* x86-64 work by Andi Kleen 2002
	8	*/
	9
1965aae3 PA	10	#ifndef _ASM_X86_I387_H
1965aae3 PA	11	#define _ASM_X86_I387_H
1eeaed76	12
3b0d6596 HX	13	#ifndef __ASSEMBLY__
3b0d6596 HX	14
1eeaed76	15	#include <linux/sched.h>
e4914012	16	#include <linux/hardirq.h>
1361b83a LT	17
	18	struct pt_regs;
	19	struct user_i387_struct;
1eeaed76	20
aa283f49	21	extern int init_fpu(struct task_struct *child);
304bceda	22	extern void fpu_finit(struct fpu *fpu);
36454936	23	extern int dump_fpu(struct pt_regs , struct user_i387_struct );
1361b83a	24	extern void math_state_restore(void);
1eeaed76	25
8546c008	26	extern bool irq_fpu_usable(void);
b1a74bf8 SS	27
	28	/*
	29	* Careful: __kernel_fpu_begin/end() must be called with preempt disabled
	30	* and they don't touch the preempt state on their own.
	31	* If you enable preemption after __kernel_fpu_begin(), preempt notifier
	32	* should call the __kernel_fpu_end() to prevent the kernel/user FPU
	33	* state from getting corrupted. KVM for example uses this model.
	34	*
	35	* All other cases use kernel_fpu_begin/end() which disable preemption
	36	* during kernel FPU usage.
	37	*/
	38	extern void __kernel_fpu_begin(void);
	39	extern void __kernel_fpu_end(void);
	40
	41	static inline void kernel_fpu_begin(void)
	42	{
	43	WARN_ON_ONCE(!irq_fpu_usable());
	44	preempt_disable();
	45	__kernel_fpu_begin();
	46	}
	47
	48	static inline void kernel_fpu_end(void)
	49	{
	50	__kernel_fpu_end();
	51	preempt_enable();
	52	}
1eeaed76	53
e4914012 SS	54	/*
	55	* Some instructions like VIA's padlock instructions generate a spurious
	56	* DNA fault but don't modify SSE registers. And these instructions
0b8c3d5a CE	57	* get used from interrupt context as well. To prevent these kernel instructions
0b8c3d5a CE	58	* in interrupt context interacting wrongly with other user/kernel fpu usage, we
e4914012 SS	59	* should use them only in the context of irq_ts_save/restore()
	60	*/
	61	static inline int irq_ts_save(void)
	62	{
	63	/*
0b8c3d5a CE	64	* If in process context and not atomic, we can take a spurious DNA fault.
	65	* Otherwise, doing clts() in process context requires disabling preemption
	66	* or some heavy lifting like kernel_fpu_begin()
e4914012	67	*/
0b8c3d5a	68	if (!in_atomic())
e4914012 SS	69	return 0;
	70
	71	if (read_cr0() & X86_CR0_TS) {
	72	clts();
	73	return 1;
	74	}
	75
	76	return 0;
	77	}
	78
	79	static inline void irq_ts_restore(int TS_state)
	80	{
	81	if (TS_state)
	82	stts();
	83	}
	84
15d8791c LT	85	/*
	86	* The question "does this thread have fpu access?"
	87	* is slightly racy, since preemption could come in
	88	* and revoke it immediately after the test.
	89	*
	90	* However, even in that very unlikely scenario,
	91	* we can just assume we have FPU access - typically
	92	* to save the FP state - we'll just take a #NM
	93	* fault and get the FPU access back.
15d8791c LT	94	*/
	95	static inline int user_has_fpu(void)
	96	{
1361b83a	97	return current->thread.fpu.has_fpu;
1eeaed76 RM	98	}
1eeaed76 RM	99
8546c008	100	extern void unlazy_fpu(struct task_struct *tsk);
1eeaed76	101
3b0d6596 HX	102	#endif /* __ASSEMBLY__ */
3b0d6596 HX	103
1965aae3	104	#endif /* _ASM_X86_I387_H */