Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : #include <linux/export.h>
       3                 :            : #include <linux/sched.h>
       4                 :            : #include <linux/personality.h>
       5                 :            : #include <linux/binfmts.h>
       6                 :            : #include <linux/elf.h>
       7                 :            : #include <linux/elf-fdpic.h>
       8                 :            : #include <asm/system_info.h>
       9                 :            : 
      10                 :          3 : int elf_check_arch(const struct elf32_hdr *x)
      11                 :            : {
      12                 :            :         unsigned int eflags;
      13                 :            : 
      14                 :            :         /* Make sure it's an ARM executable */
      15                 :          3 :         if (x->e_machine != EM_ARM)
      16                 :            :                 return 0;
      17                 :            : 
      18                 :            :         /* Make sure the entry address is reasonable */
      19                 :          3 :         if (x->e_entry & 1) {
      20                 :          0 :                 if (!(elf_hwcap & HWCAP_THUMB))
      21                 :            :                         return 0;
      22                 :          3 :         } else if (x->e_entry & 3)
      23                 :            :                 return 0;
      24                 :            : 
      25                 :          3 :         eflags = x->e_flags;
      26                 :          3 :         if ((eflags & EF_ARM_EABI_MASK) == EF_ARM_EABI_UNKNOWN) {
      27                 :            :                 unsigned int flt_fmt;
      28                 :            : 
      29                 :            :                 /* APCS26 is only allowed if the CPU supports it */
      30                 :          0 :                 if ((eflags & EF_ARM_APCS_26) && !(elf_hwcap & HWCAP_26BIT))
      31                 :            :                         return 0;
      32                 :            : 
      33                 :          0 :                 flt_fmt = eflags & (EF_ARM_VFP_FLOAT | EF_ARM_SOFT_FLOAT);
      34                 :            : 
      35                 :            :                 /* VFP requires the supporting code */
      36                 :          0 :                 if (flt_fmt == EF_ARM_VFP_FLOAT && !(elf_hwcap & HWCAP_VFP))
      37                 :            :                         return 0;
      38                 :            :         }
      39                 :          3 :         return 1;
      40                 :            : }
      41                 :            : EXPORT_SYMBOL(elf_check_arch);
      42                 :            : 
      43                 :          3 : void elf_set_personality(const struct elf32_hdr *x)
      44                 :            : {
      45                 :          3 :         unsigned int eflags = x->e_flags;
      46                 :          3 :         unsigned int personality = current->personality & ~PER_MASK;
      47                 :            : 
      48                 :            :         /*
      49                 :            :          * We only support Linux ELF executables, so always set the
      50                 :            :          * personality to LINUX.
      51                 :            :          */
      52                 :            :         personality |= PER_LINUX;
      53                 :            : 
      54                 :            :         /*
      55                 :            :          * APCS-26 is only valid for OABI executables
      56                 :            :          */
      57                 :          3 :         if ((eflags & EF_ARM_EABI_MASK) == EF_ARM_EABI_UNKNOWN &&
      58                 :            :             (eflags & EF_ARM_APCS_26))
      59                 :          0 :                 personality &= ~ADDR_LIMIT_32BIT;
      60                 :            :         else
      61                 :          3 :                 personality |= ADDR_LIMIT_32BIT;
      62                 :            : 
      63                 :          3 :         set_personality(personality);
      64                 :            : 
      65                 :            :         /*
      66                 :            :          * Since the FPA coprocessor uses CP1 and CP2, and iWMMXt uses CP0
      67                 :            :          * and CP1, we only enable access to the iWMMXt coprocessor if the
      68                 :            :          * binary is EABI or softfloat (and thus, guaranteed not to use
      69                 :            :          * FPA instructions.)
      70                 :            :          */
      71                 :          3 :         if (elf_hwcap & HWCAP_IWMMXT &&
      72                 :          0 :             eflags & (EF_ARM_EABI_MASK | EF_ARM_SOFT_FLOAT)) {
      73                 :            :                 set_thread_flag(TIF_USING_IWMMXT);
      74                 :            :         } else {
      75                 :            :                 clear_thread_flag(TIF_USING_IWMMXT);
      76                 :            :         }
      77                 :          3 : }
      78                 :            : EXPORT_SYMBOL(elf_set_personality);
      79                 :            : 
      80                 :            : /*
      81                 :            :  * Set READ_IMPLIES_EXEC if:
      82                 :            :  *  - the binary requires an executable stack
      83                 :            :  *  - we're running on a CPU which doesn't support NX.
      84                 :            :  */
      85                 :          3 : int arm_elf_read_implies_exec(int executable_stack)
      86                 :            : {
      87                 :          3 :         if (executable_stack != EXSTACK_DISABLE_X)
      88                 :            :                 return 1;
      89                 :          3 :         if (cpu_architecture() < CPU_ARCH_ARMv6)
      90                 :            :                 return 1;
      91                 :          3 :         return 0;
      92                 :            : }
      93                 :            : EXPORT_SYMBOL(arm_elf_read_implies_exec);
      94                 :            : 
      95                 :            : #if defined(CONFIG_MMU) && defined(CONFIG_BINFMT_ELF_FDPIC)
      96                 :            : 
      97                 :            : void elf_fdpic_arch_lay_out_mm(struct elf_fdpic_params *exec_params,
      98                 :            :                                struct elf_fdpic_params *interp_params,
      99                 :            :                                unsigned long *start_stack,
     100                 :            :                                unsigned long *start_brk)
     101                 :            : {
     102                 :            :         elf_set_personality(&exec_params->hdr);
     103                 :            : 
     104                 :            :         exec_params->load_addr = 0x8000;
     105                 :            :         interp_params->load_addr = ELF_ET_DYN_BASE;
     106                 :            :         *start_stack = TASK_SIZE - SZ_16M;
     107                 :            : 
     108                 :            :         if ((exec_params->flags & ELF_FDPIC_FLAG_ARRANGEMENT) == ELF_FDPIC_FLAG_INDEPENDENT) {
     109                 :            :                 exec_params->flags &= ~ELF_FDPIC_FLAG_ARRANGEMENT;
     110                 :            :                 exec_params->flags |= ELF_FDPIC_FLAG_CONSTDISP;
     111                 :            :         }
     112                 :            : }
     113                 :            : 
     114                 :            : #endif