elf32_machdep.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright 1996-1998 John D. Polstra.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   26  *
   27  * $FreeBSD$
   28  */
   29 
   30 #include <sys/param.h>
   31 #include <sys/kernel.h>
   32 #include <sys/systm.h>
   33 
   34 #define __ELF_WORD_SIZE 32
   35 
   36 #include <sys/exec.h>
   37 #include <sys/imgact.h>
   38 #include <sys/malloc.h>
   39 #include <sys/proc.h>
   40 #include <sys/namei.h>
   41 #include <sys/fcntl.h>
   42 #include <sys/sysent.h>
   43 #include <sys/imgact_elf.h>
   44 #include <sys/jail.h>
   45 #include <sys/smp.h>
   46 #include <sys/syscall.h>
   47 #include <sys/sysctl.h>
   48 #include <sys/signalvar.h>
   49 #include <sys/vnode.h>
   50 #include <sys/linker.h>
   51 
   52 #include <vm/vm.h>
   53 #include <vm/vm_param.h>
   54 
   55 #include <machine/altivec.h>
   56 #include <machine/cpu.h>
   57 #include <machine/fpu.h>
   58 #include <machine/elf.h>
   59 #include <machine/reg.h>
   60 #include <machine/md_var.h>
   61 
   62 #include <powerpc/powerpc/elf_common.c>
   63 
   64 #ifdef __powerpc64__
   65 #include <compat/freebsd32/freebsd32_proto.h>
   66 #include <compat/freebsd32/freebsd32_util.h>
   67 
   68 extern const char *freebsd32_syscallnames[];
   69 static void ppc32_fixlimit(struct rlimit *rl, int which);
   70 
   71 static SYSCTL_NODE(_compat, OID_AUTO, ppc32, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
   72     "32-bit mode");
   73 
   74 #define PPC32_MAXDSIZ (1024*1024*1024)
   75 static u_long ppc32_maxdsiz = PPC32_MAXDSIZ;
   76 SYSCTL_ULONG(_compat_ppc32, OID_AUTO, maxdsiz, CTLFLAG_RWTUN, &ppc32_maxdsiz,
   77              0, "");
   78 #define PPC32_MAXSSIZ (64*1024*1024)
   79 u_long ppc32_maxssiz = PPC32_MAXSSIZ;
   80 SYSCTL_ULONG(_compat_ppc32, OID_AUTO, maxssiz, CTLFLAG_RWTUN, &ppc32_maxssiz,
   81              0, "");
   82 #else
   83 static void ppc32_runtime_resolve(void);
   84 #endif
   85 
   86 struct sysentvec elf32_freebsd_sysvec = {
   87         .sv_size        = SYS_MAXSYSCALL,
   88 #ifdef __powerpc64__
   89         .sv_table       = freebsd32_sysent,
   90 #else
   91         .sv_table       = sysent,
   92 #endif
   93         .sv_transtrap   = NULL,
   94         .sv_fixup       = __elfN(freebsd_fixup),
   95         .sv_copyout_auxargs = __elfN(powerpc_copyout_auxargs),
   96         .sv_sendsig     = sendsig,
   97         .sv_sigcode     = sigcode32,
   98         .sv_szsigcode   = &szsigcode32,
   99         .sv_name        = "FreeBSD ELF32",
  100         .sv_coredump    = __elfN(coredump),
  101         .sv_imgact_try  = NULL,
  102         .sv_minsigstksz = MINSIGSTKSZ,
  103         .sv_minuser     = VM_MIN_ADDRESS,
  104         .sv_stackprot   = VM_PROT_ALL,
  105 #ifdef __powerpc64__
  106         .sv_maxuser     = VM_MAXUSER_ADDRESS32,
  107         .sv_usrstack    = FREEBSD32_USRSTACK,
  108         .sv_psstrings   = FREEBSD32_PS_STRINGS,
  109         .sv_copyout_strings = freebsd32_copyout_strings,
  110         .sv_setregs     = ppc32_setregs,
  111         .sv_syscallnames = freebsd32_syscallnames,
  112         .sv_fixlimit    = ppc32_fixlimit,
  113 #else
  114         .sv_maxuser     = VM_MAXUSER_ADDRESS,
  115         .sv_usrstack    = USRSTACK,
  116         .sv_psstrings   = PS_STRINGS,
  117         .sv_copyout_strings = exec_copyout_strings,
  118         .sv_setregs     = exec_setregs,
  119         .sv_syscallnames = syscallnames,
  120         .sv_fixlimit    = NULL,
  121 #endif
  122         .sv_maxssiz     = NULL,
  123         .sv_flags       = SV_ABI_FREEBSD | SV_ILP32 | SV_SHP | SV_ASLR |
  124                             SV_TIMEKEEP | SV_RNG_SEED_VER,
  125         .sv_set_syscall_retval = cpu_set_syscall_retval,
  126         .sv_fetch_syscall_args = cpu_fetch_syscall_args,
  127         .sv_shared_page_base = FREEBSD32_SHAREDPAGE,
  128         .sv_shared_page_len = PAGE_SIZE,
  129         .sv_schedtail   = NULL,
  130         .sv_thread_detach = NULL,
  131         .sv_trap        = NULL,
  132         .sv_hwcap       = &cpu_features,
  133         .sv_hwcap2      = &cpu_features2,
  134         .sv_onexec_old  = exec_onexec_old,
  135         .sv_onexit      = exit_onexit,
  136 };
  137 INIT_SYSENTVEC(elf32_sysvec, &elf32_freebsd_sysvec);
  138 
  139 static Elf32_Brandinfo freebsd_brand_info = {
  140         .brand          = ELFOSABI_FREEBSD,
  141         .machine        = EM_PPC,
  142         .compat_3_brand = "FreeBSD",
  143         .emul_path      = NULL,
  144         .interp_path    = "/libexec/ld-elf.so.1",
  145         .sysvec         = &elf32_freebsd_sysvec,
  146 #ifdef __powerpc64__
  147         .interp_newpath = "/libexec/ld-elf32.so.1",
  148 #else
  149         .interp_newpath = NULL,
  150 #endif
  151         .brand_note     = &elf32_freebsd_brandnote,
  152         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
  153 };
  154 
  155 SYSINIT(elf32, SI_SUB_EXEC, SI_ORDER_FIRST,
  156     (sysinit_cfunc_t) elf32_insert_brand_entry,
  157     &freebsd_brand_info);
  158 
  159 static Elf32_Brandinfo freebsd_brand_oinfo = {
  160         .brand          = ELFOSABI_FREEBSD,
  161         .machine        = EM_PPC,
  162         .compat_3_brand = "FreeBSD",
  163         .emul_path      = NULL,
  164         .interp_path    = "/usr/libexec/ld-elf.so.1",
  165         .sysvec         = &elf32_freebsd_sysvec,
  166         .interp_newpath = NULL,
  167         .brand_note     = &elf32_freebsd_brandnote,
  168         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
  169 };
  170 
  171 SYSINIT(oelf32, SI_SUB_EXEC, SI_ORDER_ANY,
  172         (sysinit_cfunc_t) elf32_insert_brand_entry,
  173         &freebsd_brand_oinfo);
  174 
  175 void elf_reloc_self(Elf_Dyn *dynp, Elf_Addr relocbase);
  176 
  177 void
  178 elf32_dump_thread(struct thread *td, void *dst, size_t *off)
  179 {
  180         size_t len;
  181         struct pcb *pcb;
  182         uint64_t vshr[32];
  183         uint64_t *vsr_dw1;
  184         int vsr_idx;
  185 
  186         len = 0;
  187         pcb = td->td_pcb;
  188 
  189         if (pcb->pcb_flags & PCB_VEC) {
  190                 save_vec_nodrop(td);
  191                 if (dst != NULL) {
  192                         len += elf32_populate_note(NT_PPC_VMX,
  193                             &pcb->pcb_vec, (char *)dst + len,
  194                             sizeof(pcb->pcb_vec), NULL);
  195                 } else
  196                         len += elf32_populate_note(NT_PPC_VMX, NULL, NULL,
  197                             sizeof(pcb->pcb_vec), NULL);
  198         }
  199 
  200         if (pcb->pcb_flags & PCB_VSX) {
  201                 save_fpu_nodrop(td);
  202                 if (dst != NULL) {
  203                         /*
  204                          * Doubleword 0 of VSR0-VSR31 overlap with FPR0-FPR31 and
  205                          * VSR32-VSR63 overlap with VR0-VR31, so we only copy
  206                          * the non-overlapping data, which is doubleword 1 of VSR0-VSR31.
  207                          */
  208                         for (vsr_idx = 0; vsr_idx < nitems(vshr); vsr_idx++) {
  209                                 vsr_dw1 = (uint64_t *)&pcb->pcb_fpu.fpr[vsr_idx].vsr[2];
  210                                 vshr[vsr_idx] = *vsr_dw1;
  211                         }
  212                         len += elf32_populate_note(NT_PPC_VSX,
  213                             vshr, (char *)dst + len,
  214                             sizeof(vshr), NULL);
  215                 } else
  216                         len += elf32_populate_note(NT_PPC_VSX, NULL, NULL,
  217                             sizeof(vshr), NULL);
  218         }
  219 
  220         *off = len;
  221 }
  222 
  223 #ifndef __powerpc64__
  224 bool
  225 elf_is_ifunc_reloc(Elf_Size r_info)
  226 {
  227 
  228         return (ELF_R_TYPE(r_info) == R_PPC_IRELATIVE);
  229 }
  230 
  231 /* Process one elf relocation with addend. */
  232 static int
  233 elf_reloc_internal(linker_file_t lf, Elf_Addr relocbase, const void *data,
  234     int type, int local, elf_lookup_fn lookup)
  235 {
  236         Elf_Addr *where;
  237         Elf_Half *hwhere;
  238         Elf_Addr addr;
  239         Elf_Addr addend, val;
  240         Elf_Word rtype, symidx;
  241         const Elf_Rela *rela;
  242         int error;
  243 
  244         switch (type) {
  245         case ELF_RELOC_REL:
  246                 panic("PPC only supports RELA relocations");
  247                 break;
  248         case ELF_RELOC_RELA:
  249                 rela = (const Elf_Rela *)data;
  250                 where = (Elf_Addr *) ((uintptr_t)relocbase + rela->r_offset);
  251                 hwhere = (Elf_Half *) ((uintptr_t)relocbase + rela->r_offset);
  252                 addend = rela->r_addend;
  253                 rtype = ELF_R_TYPE(rela->r_info);
  254                 symidx = ELF_R_SYM(rela->r_info);
  255                 break;
  256         default:
  257                 panic("elf_reloc: unknown relocation mode %d\n", type);
  258         }
  259 
  260         switch (rtype) {
  261         case R_PPC_NONE:
  262                 break;
  263 
  264         case R_PPC_ADDR32: /* word32 S + A */
  265                 error = lookup(lf, symidx, 1, &addr);
  266                 if (error != 0)
  267                         return (-1);
  268                 *where = elf_relocaddr(lf, addr + addend);
  269                         break;
  270 
  271         case R_PPC_ADDR16_LO: /* #lo(S) */
  272                 error = lookup(lf, symidx, 1, &addr);
  273                 if (error != 0)
  274                         return (-1);
  275                 /*
  276                  * addend values are sometimes relative to sections
  277                  * (i.e. .rodata) in rela, where in reality they
  278                  * are relative to relocbase. Detect this condition.
  279                  */
  280                 if (addr > relocbase && addr <= (relocbase + addend))
  281                         addr = relocbase;
  282                 addr = elf_relocaddr(lf, addr + addend);
  283                 *hwhere = addr & 0xffff;
  284                 break;
  285 
  286         case R_PPC_ADDR16_HA: /* #ha(S) */
  287                 error = lookup(lf, symidx, 1, &addr);
  288                 if (error != 0)
  289                         return (-1);
  290                 /*
  291                  * addend values are sometimes relative to sections
  292                  * (i.e. .rodata) in rela, where in reality they
  293                  * are relative to relocbase. Detect this condition.
  294                  */
  295                 if (addr > relocbase && addr <= (relocbase + addend))
  296                         addr = relocbase;
  297                 addr = elf_relocaddr(lf, addr + addend);
  298                 *hwhere = ((addr >> 16) + ((addr & 0x8000) ? 1 : 0))
  299                     & 0xffff;
  300                 break;
  301 
  302         case R_PPC_RELATIVE: /* word32 B + A */
  303                 *where = elf_relocaddr(lf, relocbase + addend);
  304                 break;
  305 
  306         case R_PPC_JMP_SLOT: /* PLT jump slot entry */
  307                 /*
  308                  * We currently only support Secure-PLT jump slots.
  309                  * Given that we reject BSS-PLT modules during load, we
  310                  * don't need to check again.
  311                  * The method we are using here is equivilent to
  312                  * LD_BIND_NOW.
  313                  */
  314                 error = lookup(lf, symidx, 1, &addr);
  315                 if (error != 0)
  316                         return (-1);
  317                 *where = elf_relocaddr(lf, addr + addend);
  318                 break;
  319 
  320         case R_PPC_IRELATIVE:
  321                 addr = relocbase + addend;
  322                 val = ((Elf32_Addr (*)(void))addr)();
  323                 if (*where != val)
  324                         *where = val;
  325                 break;
  326 
  327         default:
  328                 printf("kldload: unexpected relocation type %d, "
  329                     "symbol index %d\n", (int)rtype, symidx);
  330                 return (-1);
  331         }
  332         return (0);
  333 }
  334 
  335 void
  336 elf_reloc_self(Elf_Dyn *dynp, Elf_Addr relocbase)
  337 {
  338         Elf_Rela *rela = NULL, *relalim;
  339         Elf_Addr relasz = 0;
  340         Elf_Addr *where;
  341 
  342         /*
  343          * Extract the rela/relasz values from the dynamic section
  344          */
  345         for (; dynp->d_tag != DT_NULL; dynp++) {
  346                 switch (dynp->d_tag) {
  347                 case DT_RELA:
  348                         rela = (Elf_Rela *)(relocbase+dynp->d_un.d_ptr);
  349                         break;
  350                 case DT_RELASZ:
  351                         relasz = dynp->d_un.d_val;
  352                         break;
  353                 }
  354         }
  355 
  356         /*
  357          * Relocate these values
  358          */
  359         relalim = (Elf_Rela *)((caddr_t)rela + relasz);
  360         for (; rela < relalim; rela++) {
  361                 if (ELF_R_TYPE(rela->r_info) != R_PPC_RELATIVE)
  362                         continue;
  363                 where = (Elf_Addr *)(relocbase + rela->r_offset);
  364                 *where = (Elf_Addr)(relocbase + rela->r_addend);
  365         }
  366 }
  367 
  368 int
  369 elf_reloc(linker_file_t lf, Elf_Addr relocbase, const void *data, int type,
  370     elf_lookup_fn lookup)
  371 {
  372 
  373         return (elf_reloc_internal(lf, relocbase, data, type, 0, lookup));
  374 }
  375 
  376 int
  377 elf_reloc_local(linker_file_t lf, Elf_Addr relocbase, const void *data,
  378     int type, elf_lookup_fn lookup)
  379 {
  380 
  381         return (elf_reloc_internal(lf, relocbase, data, type, 1, lookup));
  382 }
  383 
  384 int
  385 elf_cpu_load_file(linker_file_t lf)
  386 {
  387 
  388         /* Only sync the cache for non-kernel modules */
  389         if (lf->id != 1)
  390                 __syncicache(lf->address, lf->size);
  391         return (0);
  392 }
  393 
  394 int
  395 elf_cpu_unload_file(linker_file_t lf __unused)
  396 {
  397 
  398         return (0);
  399 }
  400 
  401 static void
  402 ppc32_runtime_resolve()
  403 {
  404 
  405         /*
  406          * Since we don't support lazy binding, panic immediately if anyone
  407          * manages to call the runtime resolver.
  408          */
  409         panic("kldload: Runtime resolver was called unexpectedly!");
  410 }
  411 
  412 int
  413 elf_cpu_parse_dynamic(caddr_t loadbase, Elf_Dyn *dynamic)
  414 {
  415         Elf_Dyn *dp;
  416         bool has_plt = false;
  417         bool secure_plt = false;
  418         Elf_Addr *got;
  419 
  420         for (dp = dynamic; dp->d_tag != DT_NULL; dp++) {
  421                 switch (dp->d_tag) {
  422                 case DT_PPC_GOT:
  423                         secure_plt = true;
  424                         got = (Elf_Addr *)(loadbase + dp->d_un.d_ptr);
  425                         /* Install runtime resolver canary. */
  426                         got[1] = (Elf_Addr)ppc32_runtime_resolve;
  427                         got[2] = (Elf_Addr)0;
  428                         break;
  429                 case DT_PLTGOT:
  430                         has_plt = true;
  431                         break;
  432                 }
  433         }
  434 
  435         if (has_plt && !secure_plt) {
  436                 printf("kldload: BSS-PLT modules are not supported.\n");
  437                 return (-1);
  438         }
  439         return (0);
  440 }
  441 #endif
  442 
  443 #ifdef __powerpc64__
  444 static void
  445 ppc32_fixlimit(struct rlimit *rl, int which)
  446 {
  447         switch (which) {
  448         case RLIMIT_DATA:
  449                 if (ppc32_maxdsiz != 0) {
  450                         if (rl->rlim_cur > ppc32_maxdsiz)
  451                                 rl->rlim_cur = ppc32_maxdsiz;
  452                         if (rl->rlim_max > ppc32_maxdsiz)
  453                                 rl->rlim_max = ppc32_maxdsiz;
  454                 }
  455                 break;
  456         case RLIMIT_STACK:
  457                 if (ppc32_maxssiz != 0) {
  458                         if (rl->rlim_cur > ppc32_maxssiz)
  459                                 rl->rlim_cur = ppc32_maxssiz;
  460                         if (rl->rlim_max > ppc32_maxssiz)
  461                                 rl->rlim_max = ppc32_maxssiz;
  462                 }
  463                 break;
  464         }
  465 }
  466 #endif
Cache object: e9c554456ec82a00f86b81749bd84e8e
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/powerpc/powerpc/elf32_machdep.c

FreeBSD/Linux Kernel Cross Reference
sys/powerpc/powerpc/elf32_machdep.c
