Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#ifndef _ASM_X86_SEGMENT_H
2#define _ASM_X86_SEGMENT_H
3
4#include <linux/const.h>
5
6/*
7 * Constructor for a conventional segment GDT (or LDT) entry.
8 * This is a macro so it can be used in initializers.
9 */
10#define GDT_ENTRY(flags, base, limit) \
11 ((((base) & _AC(0xff000000,ULL)) << (56-24)) | \
12 (((flags) & _AC(0x0000f0ff,ULL)) << 40) | \
13 (((limit) & _AC(0x000f0000,ULL)) << (48-16)) | \
14 (((base) & _AC(0x00ffffff,ULL)) << 16) | \
15 (((limit) & _AC(0x0000ffff,ULL))))
16
17/* Simple and small GDT entries for booting only: */
18
19#define GDT_ENTRY_BOOT_CS 2
20#define GDT_ENTRY_BOOT_DS 3
21#define GDT_ENTRY_BOOT_TSS 4
22#define __BOOT_CS (GDT_ENTRY_BOOT_CS*8)
23#define __BOOT_DS (GDT_ENTRY_BOOT_DS*8)
24#define __BOOT_TSS (GDT_ENTRY_BOOT_TSS*8)
25
26/*
27 * Bottom two bits of selector give the ring
28 * privilege level
29 */
30#define SEGMENT_RPL_MASK 0x3
31
32/* User mode is privilege level 3: */
33#define USER_RPL 0x3
34
35/* Bit 2 is Table Indicator (TI): selects between LDT or GDT */
36#define SEGMENT_TI_MASK 0x4
37/* LDT segment has TI set ... */
38#define SEGMENT_LDT 0x4
39/* ... GDT has it cleared */
40#define SEGMENT_GDT 0x0
41
42#define GDT_ENTRY_INVALID_SEG 0
43
44#ifdef CONFIG_X86_32
45/*
46 * The layout of the per-CPU GDT under Linux:
47 *
48 * 0 - null <=== cacheline #1
49 * 1 - reserved
50 * 2 - reserved
51 * 3 - reserved
52 *
53 * 4 - unused <=== cacheline #2
54 * 5 - unused
55 *
56 * ------- start of TLS (Thread-Local Storage) segments:
57 *
58 * 6 - TLS segment #1 [ glibc's TLS segment ]
59 * 7 - TLS segment #2 [ Wine's %fs Win32 segment ]
60 * 8 - TLS segment #3 <=== cacheline #3
61 * 9 - reserved
62 * 10 - reserved
63 * 11 - reserved
64 *
65 * ------- start of kernel segments:
66 *
67 * 12 - kernel code segment <=== cacheline #4
68 * 13 - kernel data segment
69 * 14 - default user CS
70 * 15 - default user DS
71 * 16 - TSS <=== cacheline #5
72 * 17 - LDT
73 * 18 - PNPBIOS support (16->32 gate)
74 * 19 - PNPBIOS support
75 * 20 - PNPBIOS support <=== cacheline #6
76 * 21 - PNPBIOS support
77 * 22 - PNPBIOS support
78 * 23 - APM BIOS support
79 * 24 - APM BIOS support <=== cacheline #7
80 * 25 - APM BIOS support
81 *
82 * 26 - ESPFIX small SS
83 * 27 - per-cpu [ offset to per-cpu data area ]
84 * 28 - stack_canary-20 [ for stack protector ] <=== cacheline #8
85 * 29 - unused
86 * 30 - unused
87 * 31 - TSS for double fault handler
88 */
89#define GDT_ENTRY_TLS_MIN 6
90#define GDT_ENTRY_TLS_MAX (GDT_ENTRY_TLS_MIN + GDT_ENTRY_TLS_ENTRIES - 1)
91
92#define GDT_ENTRY_KERNEL_CS 12
93#define GDT_ENTRY_KERNEL_DS 13
94#define GDT_ENTRY_DEFAULT_USER_CS 14
95#define GDT_ENTRY_DEFAULT_USER_DS 15
96#define GDT_ENTRY_TSS 16
97#define GDT_ENTRY_LDT 17
98#define GDT_ENTRY_PNPBIOS_CS32 18
99#define GDT_ENTRY_PNPBIOS_CS16 19
100#define GDT_ENTRY_PNPBIOS_DS 20
101#define GDT_ENTRY_PNPBIOS_TS1 21
102#define GDT_ENTRY_PNPBIOS_TS2 22
103#define GDT_ENTRY_APMBIOS_BASE 23
104
105#define GDT_ENTRY_ESPFIX_SS 26
106#define GDT_ENTRY_PERCPU 27
107#define GDT_ENTRY_STACK_CANARY 28
108
109#define GDT_ENTRY_DOUBLEFAULT_TSS 31
110
111/*
112 * Number of entries in the GDT table:
113 */
114#define GDT_ENTRIES 32
115
116/*
117 * Segment selector values corresponding to the above entries:
118 */
119
120#define __KERNEL_CS (GDT_ENTRY_KERNEL_CS*8)
121#define __KERNEL_DS (GDT_ENTRY_KERNEL_DS*8)
122#define __USER_DS (GDT_ENTRY_DEFAULT_USER_DS*8 + 3)
123#define __USER_CS (GDT_ENTRY_DEFAULT_USER_CS*8 + 3)
124#define __ESPFIX_SS (GDT_ENTRY_ESPFIX_SS*8)
125
126/* segment for calling fn: */
127#define PNP_CS32 (GDT_ENTRY_PNPBIOS_CS32*8)
128/* code segment for BIOS: */
129#define PNP_CS16 (GDT_ENTRY_PNPBIOS_CS16*8)
130
131/* "Is this PNP code selector (PNP_CS32 or PNP_CS16)?" */
132#define SEGMENT_IS_PNP_CODE(x) (((x) & 0xf4) == PNP_CS32)
133
134/* data segment for BIOS: */
135#define PNP_DS (GDT_ENTRY_PNPBIOS_DS*8)
136/* transfer data segment: */
137#define PNP_TS1 (GDT_ENTRY_PNPBIOS_TS1*8)
138/* another data segment: */
139#define PNP_TS2 (GDT_ENTRY_PNPBIOS_TS2*8)
140
141#ifdef CONFIG_SMP
142# define __KERNEL_PERCPU (GDT_ENTRY_PERCPU*8)
143#else
144# define __KERNEL_PERCPU 0
145#endif
146
147#ifdef CONFIG_CC_STACKPROTECTOR
148# define __KERNEL_STACK_CANARY (GDT_ENTRY_STACK_CANARY*8)
149#else
150# define __KERNEL_STACK_CANARY 0
151#endif
152
153#else /* 64-bit: */
154
155#include <asm/cache.h>
156
157#define GDT_ENTRY_KERNEL32_CS 1
158#define GDT_ENTRY_KERNEL_CS 2
159#define GDT_ENTRY_KERNEL_DS 3
160
161/*
162 * We cannot use the same code segment descriptor for user and kernel mode,
163 * not even in long flat mode, because of different DPL.
164 *
165 * GDT layout to get 64-bit SYSCALL/SYSRET support right. SYSRET hardcodes
166 * selectors:
167 *
168 * if returning to 32-bit userspace: cs = STAR.SYSRET_CS,
169 * if returning to 64-bit userspace: cs = STAR.SYSRET_CS+16,
170 *
171 * ss = STAR.SYSRET_CS+8 (in either case)
172 *
173 * thus USER_DS should be between 32-bit and 64-bit code selectors:
174 */
175#define GDT_ENTRY_DEFAULT_USER32_CS 4
176#define GDT_ENTRY_DEFAULT_USER_DS 5
177#define GDT_ENTRY_DEFAULT_USER_CS 6
178
179/* Needs two entries */
180#define GDT_ENTRY_TSS 8
181/* Needs two entries */
182#define GDT_ENTRY_LDT 10
183
184#define GDT_ENTRY_TLS_MIN 12
185#define GDT_ENTRY_TLS_MAX 14
186
187/* Abused to load per CPU data from limit */
188#define GDT_ENTRY_PER_CPU 15
189
190/*
191 * Number of entries in the GDT table:
192 */
193#define GDT_ENTRIES 16
194
195/*
196 * Segment selector values corresponding to the above entries:
197 *
198 * Note, selectors also need to have a correct RPL,
199 * expressed with the +3 value for user-space selectors:
200 */
201#define __KERNEL32_CS (GDT_ENTRY_KERNEL32_CS*8)
202#define __KERNEL_CS (GDT_ENTRY_KERNEL_CS*8)
203#define __KERNEL_DS (GDT_ENTRY_KERNEL_DS*8)
204#define __USER32_CS (GDT_ENTRY_DEFAULT_USER32_CS*8 + 3)
205#define __USER_DS (GDT_ENTRY_DEFAULT_USER_DS*8 + 3)
206#define __USER32_DS __USER_DS
207#define __USER_CS (GDT_ENTRY_DEFAULT_USER_CS*8 + 3)
208#define __PER_CPU_SEG (GDT_ENTRY_PER_CPU*8 + 3)
209
210/* TLS indexes for 64-bit - hardcoded in arch_prctl(): */
211#define FS_TLS 0
212#define GS_TLS 1
213
214#define GS_TLS_SEL ((GDT_ENTRY_TLS_MIN+GS_TLS)*8 + 3)
215#define FS_TLS_SEL ((GDT_ENTRY_TLS_MIN+FS_TLS)*8 + 3)
216
217#endif
218
219#ifndef CONFIG_PARAVIRT
220# define get_kernel_rpl() 0
221#endif
222
223#define IDT_ENTRIES 256
224#define NUM_EXCEPTION_VECTORS 32
225
226/* Bitmask of exception vectors which push an error code on the stack: */
227#define EXCEPTION_ERRCODE_MASK 0x00027d00
228
229#define GDT_SIZE (GDT_ENTRIES*8)
230#define GDT_ENTRY_TLS_ENTRIES 3
231#define TLS_SIZE (GDT_ENTRY_TLS_ENTRIES* 8)
232
233#ifdef __KERNEL__
234
235/*
236 * early_idt_handler_array is an array of entry points referenced in the
237 * early IDT. For simplicity, it's a real array with one entry point
238 * every nine bytes. That leaves room for an optional 'push $0' if the
239 * vector has no error code (two bytes), a 'push $vector_number' (two
240 * bytes), and a jump to the common entry code (up to five bytes).
241 */
242#define EARLY_IDT_HANDLER_SIZE 9
243
244#ifndef __ASSEMBLY__
245
246extern const char early_idt_handler_array[NUM_EXCEPTION_VECTORS][EARLY_IDT_HANDLER_SIZE];
247#ifdef CONFIG_TRACING
248# define trace_early_idt_handler_array early_idt_handler_array
249#endif
250
251/*
252 * Load a segment. Fall back on loading the zero
253 * segment if something goes wrong..
254 */
255#define loadsegment(seg, value) \
256do { \
257 unsigned short __val = (value); \
258 \
259 asm volatile(" \n" \
260 "1: movl %k0,%%" #seg " \n" \
261 \
262 ".section .fixup,\"ax\" \n" \
263 "2: xorl %k0,%k0 \n" \
264 " jmp 1b \n" \
265 ".previous \n" \
266 \
267 _ASM_EXTABLE(1b, 2b) \
268 \
269 : "+r" (__val) : : "memory"); \
270} while (0)
271
272/*
273 * Save a segment register away:
274 */
275#define savesegment(seg, value) \
276 asm("mov %%" #seg ",%0":"=r" (value) : : "memory")
277
278/*
279 * x86-32 user GS accessors:
280 */
281#ifdef CONFIG_X86_32
282# ifdef CONFIG_X86_32_LAZY_GS
283# define get_user_gs(regs) (u16)({ unsigned long v; savesegment(gs, v); v; })
284# define set_user_gs(regs, v) loadsegment(gs, (unsigned long)(v))
285# define task_user_gs(tsk) ((tsk)->thread.gs)
286# define lazy_save_gs(v) savesegment(gs, (v))
287# define lazy_load_gs(v) loadsegment(gs, (v))
288# else /* X86_32_LAZY_GS */
289# define get_user_gs(regs) (u16)((regs)->gs)
290# define set_user_gs(regs, v) do { (regs)->gs = (v); } while (0)
291# define task_user_gs(tsk) (task_pt_regs(tsk)->gs)
292# define lazy_save_gs(v) do { } while (0)
293# define lazy_load_gs(v) do { } while (0)
294# endif /* X86_32_LAZY_GS */
295#endif /* X86_32 */
296
297#endif /* !__ASSEMBLY__ */
298#endif /* __KERNEL__ */
299
300#endif /* _ASM_X86_SEGMENT_H */