LCOV - code coverage report
Current view: top level - arch/x86/include/asm - elf.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 11 11 100.0 %
Date: 2021-04-22 12:43:58 Functions: 0 0 -

          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(&current->thread, _r, 0)
     185             : 
     186             : #define COMPAT_ELF_PLAT_INIT(regs, load_addr)           \
     187             :         elf_common_init(&current->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 */

Generated by: LCOV version 1.14