Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/x86/math-emu/fpu_system.h
26442 views
1
/* SPDX-License-Identifier: GPL-2.0 */

2
/*---------------------------------------------------------------------------+

3
 |  fpu_system.h                                                             |

4
 |                                                                           |

5
 | Copyright (C) 1992,1994,1997                                              |

6
 |                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |

7
 |                       Australia.  E-mail   [email protected]             |

8
 |                                                                           |

9
 +---------------------------------------------------------------------------*/

10


11
#ifndef _FPU_SYSTEM_H

12
#define _FPU_SYSTEM_H

13


14
/* system dependent definitions */

15


16
#include <linux/sched.h>

17
#include <linux/kernel.h>

18
#include <linux/mm.h>

19


20
#include <asm/desc.h>

21
#include <asm/mmu_context.h>

22


23
static inline struct desc_struct FPU_get_ldt_descriptor(unsigned seg)

24
{

25
	static struct desc_struct zero_desc;

26
	struct desc_struct ret = zero_desc;

27


28
#ifdef CONFIG_MODIFY_LDT_SYSCALL

29
	seg >>= 3;

30
	mutex_lock(&current->mm->context.lock);

31
	if (current->mm->context.ldt && seg < current->mm->context.ldt->nr_entries)

32
		ret = current->mm->context.ldt->entries[seg];

33
	mutex_unlock(&current->mm->context.lock);

34
#endif

35
	return ret;

36
}

37


38
#define SEG_TYPE_WRITABLE	(1U << 1)

39
#define SEG_TYPE_EXPANDS_DOWN	(1U << 2)

40
#define SEG_TYPE_EXECUTE	(1U << 3)

41
#define SEG_TYPE_EXPAND_MASK	(SEG_TYPE_EXPANDS_DOWN | SEG_TYPE_EXECUTE)

42
#define SEG_TYPE_EXECUTE_MASK	(SEG_TYPE_WRITABLE | SEG_TYPE_EXECUTE)

43


44
static inline unsigned long seg_get_base(struct desc_struct *d)

45
{

46
	unsigned long base = (unsigned long)d->base2 << 24;

47


48
	return base | ((unsigned long)d->base1 << 16) | d->base0;

49
}

50


51
static inline unsigned long seg_get_limit(struct desc_struct *d)

52
{

53
	return ((unsigned long)d->limit1 << 16) | d->limit0;

54
}

55


56
static inline unsigned long seg_get_granularity(struct desc_struct *d)

57
{

58
	return d->g ? 4096 : 1;

59
}

60


61
static inline bool seg_expands_down(struct desc_struct *d)

62
{

63
	return (d->type & SEG_TYPE_EXPAND_MASK) == SEG_TYPE_EXPANDS_DOWN;

64
}

65


66
static inline bool seg_execute_only(struct desc_struct *d)

67
{

68
	return (d->type & SEG_TYPE_EXECUTE_MASK) == SEG_TYPE_EXECUTE;

69
}

70


71
static inline bool seg_writable(struct desc_struct *d)

72
{

73
	return (d->type & SEG_TYPE_EXECUTE_MASK) == SEG_TYPE_WRITABLE;

74
}

75


76
#define I387			(&x86_task_fpu(current)->fpstate->regs)

77
#define FPU_info		(I387->soft.info)

78


79
#define FPU_CS			(*(unsigned short *) &(FPU_info->regs->cs))

80
#define FPU_SS			(*(unsigned short *) &(FPU_info->regs->ss))

81
#define FPU_DS			(*(unsigned short *) &(FPU_info->regs->ds))

82
#define FPU_EAX			(FPU_info->regs->ax)

83
#define FPU_EFLAGS		(FPU_info->regs->flags)

84
#define FPU_EIP			(FPU_info->regs->ip)

85
#define FPU_ORIG_EIP		(FPU_info->___orig_eip)

86


87
#define FPU_lookahead           (I387->soft.lookahead)

88


89
/* nz if ip_offset and cs_selector are not to be set for the current

90
   instruction. */

91
#define no_ip_update		(*(u_char *)&(I387->soft.no_update))

92
#define FPU_rm			(*(u_char *)&(I387->soft.rm))

93


94
/* Number of bytes of data which can be legally accessed by the current

95
   instruction. This only needs to hold a number <= 108, so a byte will do. */

96
#define access_limit		(*(u_char *)&(I387->soft.alimit))

97


98
#define partial_status		(I387->soft.swd)

99
#define control_word		(I387->soft.cwd)

100
#define fpu_tag_word		(I387->soft.twd)

101
#define registers		(I387->soft.st_space)

102
#define top			(I387->soft.ftop)

103


104
#define instruction_address	(*(struct address *)&I387->soft.fip)

105
#define operand_address		(*(struct address *)&I387->soft.foo)

106


107
#define FPU_access_ok(y,z)	if ( !access_ok(y,z) ) \

108
				math_abort(FPU_info,SIGSEGV)

109
#define FPU_abort		math_abort(FPU_info, SIGSEGV)

110
#define FPU_copy_from_user(to, from, n)	\

111
		do { if (copy_from_user(to, from, n)) FPU_abort; } while (0)

112


113
#undef FPU_IGNORE_CODE_SEGV

114
#ifdef FPU_IGNORE_CODE_SEGV

115
/* access_ok() is very expensive, and causes the emulator to run

116
   about 20% slower if applied to the code. Anyway, errors due to bad

117
   code addresses should be much rarer than errors due to bad data

118
   addresses. */

119
#define	FPU_code_access_ok(z)

120
#else

121
/* A simpler test than access_ok() can probably be done for

122
   FPU_code_access_ok() because the only possible error is to step

123
   past the upper boundary of a legal code area. */

124
#define	FPU_code_access_ok(z) FPU_access_ok((void __user *)FPU_EIP,z)

125
#endif

126


127
#define FPU_get_user(x,y) do { if (get_user((x),(y))) FPU_abort; } while (0)

128
#define FPU_put_user(x,y) do { if (put_user((x),(y))) FPU_abort; } while (0)

129


130
#endif

131


132