Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : #ifndef _ASM_X86_ELF_H
3 : #define _ASM_X86_ELF_H
4 :
5 : /*
6 : * ELF register definitions..
7 : */
8 : #include <linux/thread_info.h>
9 :
10 : #include <asm/ptrace.h>
11 : #include <asm/user.h>
12 : #include <asm/auxvec.h>
13 : #include <asm/fsgsbase.h>
14 :
15 : typedef unsigned long elf_greg_t;
16 :
17 : #define ELF_NGREG (sizeof(struct user_regs_struct) / sizeof(elf_greg_t))
18 : typedef elf_greg_t elf_gregset_t[ELF_NGREG];
19 :
20 : typedef struct user_i387_struct elf_fpregset_t;
21 :
22 : #ifdef __i386__
23 :
24 : #define R_386_NONE 0
25 : #define R_386_32 1
26 : #define R_386_PC32 2
27 : #define R_386_GOT32 3
28 : #define R_386_PLT32 4
29 : #define R_386_COPY 5
30 : #define R_386_GLOB_DAT 6
31 : #define R_386_JMP_SLOT 7
32 : #define R_386_RELATIVE 8
33 : #define R_386_GOTOFF 9
34 : #define R_386_GOTPC 10
35 : #define R_386_NUM 11
36 :
37 : /*
38 : * These are used to set parameters in the core dumps.
39 : */
40 : #define ELF_CLASS ELFCLASS32
41 : #define ELF_DATA ELFDATA2LSB
42 : #define ELF_ARCH EM_386
43 :
44 : #else
45 :
46 : /* x86-64 relocation types */
47 : #define R_X86_64_NONE 0 /* No reloc */
48 : #define R_X86_64_64 1 /* Direct 64 bit */
49 : #define R_X86_64_PC32 2 /* PC relative 32 bit signed */
50 : #define R_X86_64_GOT32 3 /* 32 bit GOT entry */
51 : #define R_X86_64_PLT32 4 /* 32 bit PLT address */
52 : #define R_X86_64_COPY 5 /* Copy symbol at runtime */
53 : #define R_X86_64_GLOB_DAT 6 /* Create GOT entry */
54 : #define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */
55 : #define R_X86_64_RELATIVE 8 /* Adjust by program base */
56 : #define R_X86_64_GOTPCREL 9 /* 32 bit signed pc relative
57 : offset to GOT */
58 : #define R_X86_64_32 10 /* Direct 32 bit zero extended */
59 : #define R_X86_64_32S 11 /* Direct 32 bit sign extended */
60 : #define R_X86_64_16 12 /* Direct 16 bit zero extended */
61 : #define R_X86_64_PC16 13 /* 16 bit sign extended pc relative */
62 : #define R_X86_64_8 14 /* Direct 8 bit sign extended */
63 : #define R_X86_64_PC8 15 /* 8 bit sign extended pc relative */
64 : #define R_X86_64_PC64 24 /* Place relative 64-bit signed */
65 :
66 : /*
67 : * These are used to set parameters in the core dumps.
68 : */
69 : #define ELF_CLASS ELFCLASS64
70 : #define ELF_DATA ELFDATA2LSB
71 : #define ELF_ARCH EM_X86_64
72 :
73 : #endif
74 :
75 : #include <asm/vdso.h>
76 :
77 : #ifdef CONFIG_X86_64
78 : extern unsigned int vdso64_enabled;
79 : #endif
80 : #if defined(CONFIG_X86_32) || defined(CONFIG_IA32_EMULATION)
81 : extern unsigned int vdso32_enabled;
82 : #endif
83 :
84 : /*
85 : * This is used to ensure we don't load something for the wrong architecture.
86 : */
87 : #define elf_check_arch_ia32(x) \
88 : (((x)->e_machine == EM_386) || ((x)->e_machine == EM_486))
89 :
90 : #include <asm/processor.h>
91 :
92 : #ifdef CONFIG_X86_32
93 : #include <asm/desc.h>
94 :
95 : #define elf_check_arch(x) elf_check_arch_ia32(x)
96 :
97 : /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program starts %edx
98 : contains a pointer to a function which might be registered using `atexit'.
99 : This provides a mean for the dynamic linker to call DT_FINI functions for
100 : shared libraries that have been loaded before the code runs.
101 :
102 : A value of 0 tells we have no such handler.
103 :
104 : We might as well make sure everything else is cleared too (except for %esp),
105 : just to make things more deterministic.
106 : */
107 : #define ELF_PLAT_INIT(_r, load_addr) \
108 : do { \
109 : _r->bx = 0; _r->cx = 0; _r->dx = 0; \
110 : _r->si = 0; _r->di = 0; _r->bp = 0; \
111 : _r->ax = 0; \
112 : } while (0)
113 :
114 : /*
115 : * regs is struct pt_regs, pr_reg is elf_gregset_t (which is
116 : * now struct_user_regs, they are different)
117 : */
118 :
119 : #define ELF_CORE_COPY_REGS_COMMON(pr_reg, regs) \
120 : do { \
121 : pr_reg[0] = regs->bx; \
122 : pr_reg[1] = regs->cx; \
123 : pr_reg[2] = regs->dx; \
124 : pr_reg[3] = regs->si; \
125 : pr_reg[4] = regs->di; \
126 : pr_reg[5] = regs->bp; \
127 : pr_reg[6] = regs->ax; \
128 : pr_reg[7] = regs->ds; \
129 : pr_reg[8] = regs->es; \
130 : pr_reg[9] = regs->fs; \
131 : pr_reg[11] = regs->orig_ax; \
132 : pr_reg[12] = regs->ip; \
133 : pr_reg[13] = regs->cs; \
134 : pr_reg[14] = regs->flags; \
135 : pr_reg[15] = regs->sp; \
136 : pr_reg[16] = regs->ss; \
137 : } while (0);
138 :
139 : #define ELF_CORE_COPY_REGS(pr_reg, regs) \
140 : do { \
141 : ELF_CORE_COPY_REGS_COMMON(pr_reg, regs);\
142 : pr_reg[10] = get_user_gs(regs); \
143 : } while (0);
144 :
145 : #define ELF_CORE_COPY_KERNEL_REGS(pr_reg, regs) \
146 : do { \
147 : ELF_CORE_COPY_REGS_COMMON(pr_reg, regs);\
148 : savesegment(gs, pr_reg[10]); \
149 : } while (0);
150 :
151 : #define ELF_PLATFORM (utsname()->machine)
152 : #define set_personality_64bit() do { } while (0)
153 :
154 : #else /* CONFIG_X86_32 */
155 :
156 : /*
157 : * This is used to ensure we don't load something for the wrong architecture.
158 : */
159 : #define elf_check_arch(x) \
160 : ((x)->e_machine == EM_X86_64)
161 :
162 : #define compat_elf_check_arch(x) \
163 : (elf_check_arch_ia32(x) || \
164 : (IS_ENABLED(CONFIG_X86_X32_ABI) && (x)->e_machine == EM_X86_64))
165 :
166 : #if __USER32_DS != __USER_DS
167 : # error "The following code assumes __USER32_DS == __USER_DS"
168 : #endif
169 :
170 1129 : static inline void elf_common_init(struct thread_struct *t,
171 : struct pt_regs *regs, const u16 ds)
172 : {
173 : /* ax gets execve's return value. */
174 1129 : /*regs->ax = */ regs->bx = regs->cx = regs->dx = 0;
175 1129 : regs->si = regs->di = regs->bp = 0;
176 1129 : regs->r8 = regs->r9 = regs->r10 = regs->r11 = 0;
177 1129 : regs->r12 = regs->r13 = regs->r14 = regs->r15 = 0;
178 1129 : t->fsbase = t->gsbase = 0;
179 1129 : t->fsindex = t->gsindex = 0;
180 1129 : t->ds = t->es = ds;
181 : }
182 :
183 : #define ELF_PLAT_INIT(_r, load_addr) \
184 : elf_common_init(¤t->thread, _r, 0)
185 :
186 : #define COMPAT_ELF_PLAT_INIT(regs, load_addr) \
187 : elf_common_init(¤t->thread, regs, __USER_DS)
188 :
189 : void compat_start_thread(struct pt_regs *regs, u32 new_ip, u32 new_sp, bool x32);
190 : #define COMPAT_START_THREAD(ex, regs, new_ip, new_sp) \
191 : compat_start_thread(regs, new_ip, new_sp, ex->e_machine == EM_X86_64)
192 :
193 : void set_personality_ia32(bool);
194 : #define COMPAT_SET_PERSONALITY(ex) \
195 : set_personality_ia32((ex).e_machine == EM_X86_64)
196 :
197 : #define COMPAT_ELF_PLATFORM ("i686")
198 :
199 : /*
200 : * regs is struct pt_regs, pr_reg is elf_gregset_t (which is
201 : * now struct_user_regs, they are different). Assumes current is the process
202 : * getting dumped.
203 : */
204 :
205 : #define ELF_CORE_COPY_REGS(pr_reg, regs) \
206 : do { \
207 : unsigned v; \
208 : (pr_reg)[0] = (regs)->r15; \
209 : (pr_reg)[1] = (regs)->r14; \
210 : (pr_reg)[2] = (regs)->r13; \
211 : (pr_reg)[3] = (regs)->r12; \
212 : (pr_reg)[4] = (regs)->bp; \
213 : (pr_reg)[5] = (regs)->bx; \
214 : (pr_reg)[6] = (regs)->r11; \
215 : (pr_reg)[7] = (regs)->r10; \
216 : (pr_reg)[8] = (regs)->r9; \
217 : (pr_reg)[9] = (regs)->r8; \
218 : (pr_reg)[10] = (regs)->ax; \
219 : (pr_reg)[11] = (regs)->cx; \
220 : (pr_reg)[12] = (regs)->dx; \
221 : (pr_reg)[13] = (regs)->si; \
222 : (pr_reg)[14] = (regs)->di; \
223 : (pr_reg)[15] = (regs)->orig_ax; \
224 : (pr_reg)[16] = (regs)->ip; \
225 : (pr_reg)[17] = (regs)->cs; \
226 : (pr_reg)[18] = (regs)->flags; \
227 : (pr_reg)[19] = (regs)->sp; \
228 : (pr_reg)[20] = (regs)->ss; \
229 : (pr_reg)[21] = x86_fsbase_read_cpu(); \
230 : (pr_reg)[22] = x86_gsbase_read_cpu_inactive(); \
231 : asm("movl %%ds,%0" : "=r" (v)); (pr_reg)[23] = v; \
232 : asm("movl %%es,%0" : "=r" (v)); (pr_reg)[24] = v; \
233 : asm("movl %%fs,%0" : "=r" (v)); (pr_reg)[25] = v; \
234 : asm("movl %%gs,%0" : "=r" (v)); (pr_reg)[26] = v; \
235 : } while (0);
236 :
237 : /* I'm not sure if we can use '-' here */
238 : #define ELF_PLATFORM ("x86_64")
239 : extern void set_personality_64bit(void);
240 : extern unsigned int sysctl_vsyscall32;
241 : extern int force_personality32;
242 :
243 : #endif /* !CONFIG_X86_32 */
244 :
245 : #define CORE_DUMP_USE_REGSET
246 : #define ELF_EXEC_PAGESIZE 4096
247 :
248 : /*
249 : * This is the base location for PIE (ET_DYN with INTERP) loads. On
250 : * 64-bit, this is above 4GB to leave the entire 32-bit address
251 : * space open for things that want to use the area for 32-bit pointers.
252 : */
253 : #define ELF_ET_DYN_BASE (mmap_is_ia32() ? 0x000400000UL : \
254 : (DEFAULT_MAP_WINDOW / 3 * 2))
255 :
256 : /* This yields a mask that user programs can use to figure out what
257 : instruction set this CPU supports. This could be done in user space,
258 : but it's not easy, and we've already done it here. */
259 :
260 : #define ELF_HWCAP (boot_cpu_data.x86_capability[CPUID_1_EDX])
261 :
262 : extern u32 elf_hwcap2;
263 :
264 : /*
265 : * HWCAP2 supplies mask with kernel enabled CPU features, so that
266 : * the application can discover that it can safely use them.
267 : * The bits are defined in uapi/asm/hwcap2.h.
268 : */
269 : #define ELF_HWCAP2 (elf_hwcap2)
270 :
271 : /* This yields a string that ld.so will use to load implementation
272 : specific libraries for optimization. This is more specific in
273 : intent than poking at uname or /proc/cpuinfo.
274 :
275 : For the moment, we have only optimizations for the Intel generations,
276 : but that could change... */
277 :
278 : #define SET_PERSONALITY(ex) set_personality_64bit()
279 :
280 : /*
281 : * An executable for which elf_read_implies_exec() returns TRUE will
282 : * have the READ_IMPLIES_EXEC personality flag set automatically.
283 : *
284 : * The decision process for determining the results are:
285 : *
286 : * CPU: | lacks NX* | has NX, ia32 | has NX, x86_64 |
287 : * ELF: | | | |
288 : * ---------------------|------------|------------------|----------------|
289 : * missing PT_GNU_STACK | exec-all | exec-all | exec-none |
290 : * PT_GNU_STACK == RWX | exec-stack | exec-stack | exec-stack |
291 : * PT_GNU_STACK == RW | exec-none | exec-none | exec-none |
292 : *
293 : * exec-all : all PROT_READ user mappings are executable, except when
294 : * backed by files on a noexec-filesystem.
295 : * exec-none : only PROT_EXEC user mappings are executable.
296 : * exec-stack: only the stack and PROT_EXEC user mappings are executable.
297 : *
298 : * *this column has no architectural effect: NX markings are ignored by
299 : * hardware, but may have behavioral effects when "wants X" collides with
300 : * "cannot be X" constraints in memory permission flags, as in
301 : * https://lkml.kernel.org/r/20190418055759.GA3155@mellanox.com
302 : *
303 : */
304 : #define elf_read_implies_exec(ex, executable_stack) \
305 : (mmap_is_ia32() && executable_stack == EXSTACK_DEFAULT)
306 :
307 : struct task_struct;
308 :
309 : #define ARCH_DLINFO_IA32 \
310 : do { \
311 : if (VDSO_CURRENT_BASE) { \
312 : NEW_AUX_ENT(AT_SYSINFO, VDSO_ENTRY); \
313 : NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_CURRENT_BASE); \
314 : } \
315 : } while (0)
316 :
317 : /*
318 : * True on X86_32 or when emulating IA32 on X86_64
319 : */
320 5553 : static inline int mmap_is_ia32(void)
321 : {
322 5553 : return IS_ENABLED(CONFIG_X86_32) ||
323 : (IS_ENABLED(CONFIG_COMPAT) &&
324 5553 : test_thread_flag(TIF_ADDR32));
325 : }
326 :
327 : extern unsigned long task_size_32bit(void);
328 : extern unsigned long task_size_64bit(int full_addr_space);
329 : extern unsigned long get_mmap_base(int is_legacy);
330 : extern bool mmap_address_hint_valid(unsigned long addr, unsigned long len);
331 :
332 : #ifdef CONFIG_X86_32
333 :
334 : #define __STACK_RND_MASK(is32bit) (0x7ff)
335 : #define STACK_RND_MASK (0x7ff)
336 :
337 : #define ARCH_DLINFO ARCH_DLINFO_IA32
338 :
339 : /* update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT entries changes */
340 :
341 : #else /* CONFIG_X86_32 */
342 :
343 : /* 1GB for 64bit, 8MB for 32bit */
344 : #define __STACK_RND_MASK(is32bit) ((is32bit) ? 0x7ff : 0x3fffff)
345 : #define STACK_RND_MASK __STACK_RND_MASK(mmap_is_ia32())
346 :
347 : #define ARCH_DLINFO \
348 : do { \
349 : if (vdso64_enabled) \
350 : NEW_AUX_ENT(AT_SYSINFO_EHDR, \
351 : (unsigned long __force)current->mm->context.vdso); \
352 : } while (0)
353 :
354 : /* As a historical oddity, the x32 and x86_64 vDSOs are controlled together. */
355 : #define ARCH_DLINFO_X32 \
356 : do { \
357 : if (vdso64_enabled) \
358 : NEW_AUX_ENT(AT_SYSINFO_EHDR, \
359 : (unsigned long __force)current->mm->context.vdso); \
360 : } while (0)
361 :
362 : #define AT_SYSINFO 32
363 :
364 : #define COMPAT_ARCH_DLINFO \
365 : if (exec->e_machine == EM_X86_64) \
366 : ARCH_DLINFO_X32; \
367 : else if (IS_ENABLED(CONFIG_IA32_EMULATION)) \
368 : ARCH_DLINFO_IA32
369 :
370 : #define COMPAT_ELF_ET_DYN_BASE (TASK_UNMAPPED_BASE + 0x1000000)
371 :
372 : #endif /* !CONFIG_X86_32 */
373 :
374 : #define VDSO_CURRENT_BASE ((unsigned long)current->mm->context.vdso)
375 :
376 : #define VDSO_ENTRY \
377 : ((unsigned long)current->mm->context.vdso + \
378 : vdso_image_32.sym___kernel_vsyscall)
379 :
380 : struct linux_binprm;
381 :
382 : #define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1
383 : extern int arch_setup_additional_pages(struct linux_binprm *bprm,
384 : int uses_interp);
385 : extern int compat_arch_setup_additional_pages(struct linux_binprm *bprm,
386 : int uses_interp, bool x32);
387 : #define COMPAT_ARCH_SETUP_ADDITIONAL_PAGES(bprm, ex, interpreter) \
388 : compat_arch_setup_additional_pages(bprm, interpreter, \
389 : (ex->e_machine == EM_X86_64))
390 :
391 : extern bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs);
392 :
393 : /* Do not change the values. See get_align_mask() */
394 : enum align_flags {
395 : ALIGN_VA_32 = BIT(0),
396 : ALIGN_VA_64 = BIT(1),
397 : };
398 :
399 : struct va_alignment {
400 : int flags;
401 : unsigned long mask;
402 : unsigned long bits;
403 : } ____cacheline_aligned;
404 :
405 : extern struct va_alignment va_align;
406 : extern unsigned long align_vdso_addr(unsigned long);
407 : #endif /* _ASM_X86_ELF_H */
|
