sys/compat/linux32/common/linux32_exec_elf32.c

   1 /*      $NetBSD: linux32_exec_elf32.c,v 1.8 2008/04/28 20:23:44 martin Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1995, 1998, 2000, 2001,2006 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Christos Zoulas, Frank van der Linden, Eric Haszlakiewicz and
   9  * Emmanuel Dreyfus.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __KERNEL_RCSID(0, "$NetBSD: linux32_exec_elf32.c,v 1.8 2008/04/28 20:23:44 martin Exp $");
  35
  36 #define ELFSIZE         32
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/proc.h>
  41 #include <sys/malloc.h>
  42 #include <sys/vnode.h>
  43 #include <sys/exec.h>
  44 #include <sys/exec_elf.h>
  45 #include <sys/kauth.h>
  46 #include <sys/kernel.h>
  47 #include <sys/resourcevar.h>
  48 #include <sys/signal.h>
  49 #include <sys/signalvar.h>
  50
  51 #include <compat/linux/common/linux_exec.h>
  52 #include <compat/netbsd32/netbsd32.h>
  53 #include <compat/netbsd32/netbsd32_exec.h>
  54 #include <compat/linux32/common/linux32_exec.h>
  55
  56 #include <machine/frame.h>
  57
  58 #ifdef DEBUG_LINUX
  59 #define DPRINTF(a)      uprintf a
  60 #else
  61 #define DPRINTF(a)
  62 #endif
  63
  64 int linux32_copyinargs(struct exec_package *, struct ps_strings *,
  65                         void *, size_t, const void *, const void *);
  66
  67 int
  68 ELFNAME2(linux32,probe)(struct lwp *l, struct exec_package *epp,
  69                         void *eh, char *itp, vaddr_t *pos)
  70 {
  71         int error;
  72
  73         if (((error = ELFNAME2(linux,signature)(l, epp, eh, itp)) != 0) &&
  74 #ifdef LINUX32_GCC_SIGNATURE
  75             ((error = ELFNAME2(linux,gcc_signature)(l, epp, eh)) != 0) &&
  76 #endif
  77 #ifdef LINUX32_ATEXIT_SIGNATURE
  78             ((error = ELFNAME2(linux,atexit_signature)(l, epp, eh)) != 0) &&
  79 #endif
  80 #ifdef LINUX32_DEBUGLINK_SIGNATURE
  81             ((error = ELFNAME2(linux,debuglink_signature)(l, epp, eh)) != 0) &&
  82 #endif
  83             1)
  84                         return error;
  85
  86         if (itp) {
  87                 if ((error = emul_find_interp(l, epp, itp)))
  88                         return (error);
  89         }
  90 #if 0
  91         DPRINTF(("linux32_probe: returning 0\n"));
  92 #endif
  93
  94         epp->ep_flags |= EXEC_32;
  95         epp->ep_vm_minaddr = VM_MIN_ADDRESS;
  96         epp->ep_vm_maxaddr = USRSTACK32;
  97
  98         return 0;
  99 }
 100
 101 /* round up and down to page boundaries. */
 102 #define ELF_ROUND(a, b)         (((a) + (b) - 1) & ~((b) - 1))
 103 #define ELF_TRUNC(a, b)         ((a) & ~((b) - 1))
 104
 105 /*
 106  * Copy arguments onto the stack in the normal way, but add some
 107  * extra information in case of dynamic binding.
 108  */
 109 int
 110 linux32_elf32_copyargs(struct lwp *l, struct exec_package *pack,
 111     struct ps_strings *arginfo, char **stackp, void *argp)
 112 {
 113         struct linux32_extra_stack_data *esdp, esd;
 114         struct elf_args *ap;
 115         struct vattr *vap;
 116         Elf_Ehdr *eh;
 117         Elf_Phdr *ph;
 118         Elf_Addr phdr = 0;
 119         u_long phsize;
 120         int error;
 121         int i;
 122
 123         if ((error = netbsd32_copyargs(l, pack, arginfo, stackp, argp)) != 0)
 124                 return error;
 125
 126         /*
 127          * Push extra arguments on the stack needed by dynamically
 128          * linked binaries and static binaries as well.
 129          */
 130         memset(&esd, 0, sizeof(esd));
 131         esdp = (struct linux32_extra_stack_data *)(*stackp);
 132         ap = (struct elf_args *)pack->ep_emul_arg;
 133         vap = pack->ep_vap;
 134         eh = (Elf_Ehdr *)pack->ep_hdr;
 135
 136         /*
 137          * We forgot this, so we ned to reload it now. XXX keep track of it?
 138          */
 139         if (ap == NULL) {
 140                 phsize = eh->e_phnum * sizeof(Elf_Phdr);
 141                 ph = (Elf_Phdr *)malloc(phsize, M_TEMP, M_WAITOK);
 142                 error = exec_read_from(l, pack->ep_vp, eh->e_phoff, ph, phsize);
 143                 if (error != 0) {
 144                         for (i = 0; i < eh->e_phnum; i++) {
 145                                 if (ph[i].p_type == PT_PHDR) {
 146                                         phdr = ph[i].p_vaddr;
 147                                         break;
 148                                 }
 149                         }
 150                 }
 151                 free(ph, M_TEMP);
 152         }
 153
 154
 155         /*
 156          * The exec_package doesn't have a proc pointer and it's not
 157          * exactly trivial to add one since the credentials are
 158          * changing. XXX Linux uses curlwp's credentials.
 159          * Why can't we use them too? XXXad we do now; what's different
 160          * about Linux's LWP creds?
 161          */
 162
 163         i = 0;
 164         esd.ai[i].a_type = LINUX_AT_SYSINFO;
 165         esd.ai[i++].a_v = NETBSD32PTR32I(&esdp->kernel_vsyscall[0]);
 166
 167         esd.ai[i].a_type = LINUX_AT_SYSINFO_EHDR;
 168         esd.ai[i++].a_v = NETBSD32PTR32I(&esdp->elfhdr);
 169
 170         esd.ai[i].a_type = LINUX_AT_HWCAP;
 171         esd.ai[i++].a_v = LINUX32_CPUCAP;
 172
 173         esd.ai[i].a_type = AT_PAGESZ;
 174         esd.ai[i++].a_v = PAGE_SIZE;
 175
 176         esd.ai[i].a_type = LINUX_AT_CLKTCK;
 177         esd.ai[i++].a_v = hz;
 178
 179         esd.ai[i].a_type = AT_PHDR;
 180         esd.ai[i++].a_v = (ap ? ap->arg_phaddr: phdr);
 181
 182         esd.ai[i].a_type = AT_PHENT;
 183         esd.ai[i++].a_v = (ap ? ap->arg_phentsize : eh->e_phentsize);
 184
 185         esd.ai[i].a_type = AT_PHNUM;
 186         esd.ai[i++].a_v = (ap ? ap->arg_phnum : eh->e_phnum);
 187
 188         esd.ai[i].a_type = AT_BASE;
 189         esd.ai[i++].a_v = (ap ? ap->arg_interp : 0);
 190
 191         esd.ai[i].a_type = AT_FLAGS;
 192         esd.ai[i++].a_v = 0;
 193
 194         esd.ai[i].a_type = AT_ENTRY;
 195         esd.ai[i++].a_v = (ap ? ap->arg_entry : eh->e_entry);
 196
 197         esd.ai[i].a_type = LINUX_AT_EGID;
 198         esd.ai[i++].a_v = ((vap->va_mode & S_ISGID) ?
 199             vap->va_gid : kauth_cred_getegid(l->l_cred));
 200
 201         esd.ai[i].a_type = LINUX_AT_GID;
 202         esd.ai[i++].a_v = kauth_cred_getgid(l->l_cred);
 203
 204         esd.ai[i].a_type = LINUX_AT_EUID;
 205         esd.ai[i++].a_v = ((vap->va_mode & S_ISUID) ?
 206             vap->va_uid : kauth_cred_geteuid(l->l_cred));
 207
 208         esd.ai[i].a_type = LINUX_AT_UID;
 209         esd.ai[i++].a_v = kauth_cred_getuid(l->l_cred);
 210
 211         esd.ai[i].a_type = LINUX_AT_SECURE;
 212         esd.ai[i++].a_v = 0;
 213
 214         esd.ai[i].a_type = LINUX_AT_PLATFORM;
 215         esd.ai[i++].a_v = NETBSD32PTR32I(&esdp->hw_platform[0]);
 216
 217         esd.ai[i].a_type = AT_NULL;
 218         esd.ai[i++].a_v = 0;
 219
 220 #ifdef DEBUG_LINUX
 221         if (i != LINUX32_ELF_AUX_ENTRIES) {
 222                 printf("linux32_elf32_copyargs: %d Aux entries\n", i);
 223                 return EINVAL;
 224         }
 225 #endif
 226
 227         memcpy(esd.kernel_vsyscall, linux32_kernel_vsyscall,
 228             sizeof(linux32_kernel_vsyscall));
 229
 230         memcpy(&esd.elfhdr, eh, sizeof(*eh));
 231
 232         strcpy(esd.hw_platform, LINUX32_PLATFORM);
 233
 234         if (ap) {
 235                 free((char *)ap, M_TEMP);
 236                 pack->ep_emul_arg = NULL;
 237         }
 238
 239         /*
 240          * Copy out the ELF auxiliary table and hw platform name
 241          */
 242         if ((error = copyout(&esd, esdp, sizeof(esd))) != 0)
 243                 return error;
 244         *stackp += sizeof(esd);
 245         return 0;
 246 }
 247