linux_exec_elf32.c revision 1.77.2.1
1 /* $NetBSD: linux_exec_elf32.c,v 1.77.2.1 2007/03/12 05:52:26 rmind Exp $ */ 2 3 /*- 4 * Copyright (c) 1995, 1998, 2000, 2001 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 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * based on exec_aout.c, sunos_exec.c and svr4_exec.c 42 */ 43 44 #include <sys/cdefs.h> 45 __KERNEL_RCSID(0, "$NetBSD: linux_exec_elf32.c,v 1.77.2.1 2007/03/12 05:52:26 rmind Exp $"); 46 47 #ifndef ELFSIZE 48 /* XXX should die */ 49 #define ELFSIZE 32 50 #endif 51 52 #include <sys/param.h> 53 #include <sys/systm.h> 54 #include <sys/kernel.h> 55 #include <sys/proc.h> 56 #include <sys/malloc.h> 57 #include <sys/namei.h> 58 #include <sys/vnode.h> 59 #include <sys/mount.h> 60 #include <sys/exec.h> 61 #include <sys/exec_elf.h> 62 #include <sys/stat.h> 63 #include <sys/kauth.h> 64 65 #include <sys/mman.h> 66 #include <sys/syscallargs.h> 67 68 #include <machine/cpu.h> 69 #include <machine/reg.h> 70 71 #include <compat/linux/common/linux_types.h> 72 #include <compat/linux/common/linux_signal.h> 73 #include <compat/linux/common/linux_util.h> 74 #include <compat/linux/common/linux_exec.h> 75 #include <compat/linux/common/linux_machdep.h> 76 77 #include <compat/linux/linux_syscallargs.h> 78 #include <compat/linux/linux_syscall.h> 79 80 #ifdef DEBUG_LINUX 81 #define DPRINTF(a) uprintf a 82 #else 83 #define DPRINTF(a) 84 #endif 85 86 #ifdef LINUX_ATEXIT_SIGNATURE 87 /* 88 * On the PowerPC, statically linked Linux binaries are not recognized 89 * by linux_signature nor by linux_gcc_signature. Fortunately, thoses 90 * binaries features a __libc_atexit ELF section. We therefore assume we 91 * have a Linux binary if we find this section. 92 */ 93 int 94 ELFNAME2(linux,atexit_signature)(l, epp, eh) 95 struct lwp *l; 96 struct exec_package *epp; 97 Elf_Ehdr *eh; 98 { 99 size_t shsize; 100 int strndx; 101 size_t i; 102 static const char signature[] = "__libc_atexit"; 103 char *strtable = NULL; 104 Elf_Shdr *sh; 105 106 int error; 107 108 /* 109 * load the section header table 110 */ 111 shsize = eh->e_shnum * sizeof(Elf_Shdr); 112 sh = (Elf_Shdr *) malloc(shsize, M_TEMP, M_WAITOK); 113 error = exec_read_from(l, epp->ep_vp, eh->e_shoff, sh, shsize); 114 if (error) 115 goto out; 116 117 /* 118 * Now let's find the string table. If it does not exists, give up. 119 */ 120 strndx = (int)(eh->e_shstrndx); 121 if (strndx == SHN_UNDEF) { 122 error = ENOEXEC; 123 goto out; 124 } 125 126 /* 127 * strndx is the index in section header table of the string table 128 * section get the whole string table in strtable, and then we get access to the names 129 * s->sh_name is the offset of the section name in strtable. 130 */ 131 strtable = malloc(sh[strndx].sh_size, M_TEMP, M_WAITOK); 132 error = exec_read_from(l, epp->ep_vp, sh[strndx].sh_offset, strtable, 133 sh[strndx].sh_size); 134 if (error) 135 goto out; 136 137 for (i = 0; i < eh->e_shnum; i++) { 138 Elf_Shdr *s = &sh[i]; 139 if (!memcmp((void*)(&(strtable[s->sh_name])), signature, 140 sizeof(signature))) { 141 DPRINTF(("linux_atexit_sig=%s\n", 142 &(strtable[s->sh_name]))); 143 error = 0; 144 goto out; 145 } 146 } 147 error = ENOEXEC; 148 149 out: 150 free(sh, M_TEMP); 151 if (strtable) 152 free(strtable, M_TEMP); 153 return (error); 154 } 155 #endif 156 157 #ifdef LINUX_GCC_SIGNATURE 158 /* 159 * Take advantage of the fact that all the linux binaries are compiled 160 * with gcc, and gcc sticks in the comment field a signature. Note that 161 * on SVR4 binaries, the gcc signature will follow the OS name signature, 162 * that will not be a problem. We don't bother to read in the string table, 163 * but we check all the progbits headers. 164 * 165 * XXX This only works in the i386. On the alpha (at least) 166 * XXX we have the same gcc signature which incorrectly identifies 167 * XXX NetBSD binaries as Linux. 168 */ 169 int 170 ELFNAME2(linux,gcc_signature)(l, epp, eh) 171 struct lwp *l; 172 struct exec_package *epp; 173 Elf_Ehdr *eh; 174 { 175 size_t shsize; 176 size_t i; 177 static const char signature[] = "\0GCC: (GNU) "; 178 char tbuf[sizeof(signature) - 1]; 179 Elf_Shdr *sh; 180 int error; 181 182 shsize = eh->e_shnum * sizeof(Elf_Shdr); 183 sh = (Elf_Shdr *) malloc(shsize, M_TEMP, M_WAITOK); 184 error = exec_read_from(l, epp->ep_vp, eh->e_shoff, sh, shsize); 185 if (error) 186 goto out; 187 188 for (i = 0; i < eh->e_shnum; i++) { 189 Elf_Shdr *s = &sh[i]; 190 191 /* 192 * Identify candidates for the comment header; 193 * Header cannot have a load address, or flags and 194 * it must be large enough. 195 */ 196 if (s->sh_type != SHT_PROGBITS || 197 s->sh_addr != 0 || 198 s->sh_flags != 0 || 199 s->sh_size < sizeof(signature) - 1) 200 continue; 201 202 error = exec_read_from(l, epp->ep_vp, s->sh_offset, tbuf, 203 sizeof(signature) - 1); 204 if (error) 205 continue; 206 207 /* 208 * error is 0, if the signatures match we are done. 209 */ 210 DPRINTF(("linux_gcc_sig: sig=%s\n", tbuf)); 211 if (!memcmp(tbuf, signature, sizeof(signature) - 1)) { 212 error = 0; 213 goto out; 214 } 215 } 216 error = ENOEXEC; 217 218 out: 219 free(sh, M_TEMP); 220 return (error); 221 } 222 #endif 223 224 #ifdef LINUX_DEBUGLINK_SIGNATURE 225 /* 226 * Look for a .gnu_debuglink, specific to x86_64 interpeter 227 */ 228 int 229 ELFNAME2(linux,debuglink_signature)(l, epp, eh) 230 struct lwp *l; 231 struct exec_package *epp; 232 Elf_Ehdr *eh; 233 { 234 size_t shsize; 235 int strndx; 236 size_t i; 237 static const char signature[] = ".gnu_debuglink"; 238 char *strtable = NULL; 239 Elf_Shdr *sh; 240 241 int error; 242 243 /* 244 * load the section header table 245 */ 246 shsize = eh->e_shnum * sizeof(Elf_Shdr); 247 sh = (Elf_Shdr *) malloc(shsize, M_TEMP, M_WAITOK); 248 error = exec_read_from(l, epp->ep_vp, eh->e_shoff, sh, shsize); 249 if (error) 250 goto out; 251 252 /* 253 * Now let's find the string table. If it does not exists, give up. 254 */ 255 strndx = (int)(eh->e_shstrndx); 256 if (strndx == SHN_UNDEF) { 257 error = ENOEXEC; 258 goto out; 259 } 260 261 /* 262 * strndx is the index in section header table of the string table 263 * section get the whole string table in strtable, and then we get access to the names 264 * s->sh_name is the offset of the section name in strtable. 265 */ 266 strtable = malloc(sh[strndx].sh_size, M_TEMP, M_WAITOK); 267 error = exec_read_from(l, epp->ep_vp, sh[strndx].sh_offset, strtable, 268 sh[strndx].sh_size); 269 if (error) 270 goto out; 271 272 for (i = 0; i < eh->e_shnum; i++) { 273 Elf_Shdr *s = &sh[i]; 274 275 if (!memcmp((void*)(&(strtable[s->sh_name])), signature, 276 sizeof(signature))) { 277 DPRINTF(("linux_debuglink_sig=%s\n", 278 &(strtable[s->sh_name]))); 279 error = 0; 280 goto out; 281 } 282 } 283 error = ENOEXEC; 284 285 out: 286 free(sh, M_TEMP); 287 if (strtable) 288 free(strtable, M_TEMP); 289 return (error); 290 } 291 #endif 292 293 int 294 ELFNAME2(linux,signature)(l, epp, eh, itp) 295 struct lwp *l; 296 struct exec_package *epp; 297 Elf_Ehdr *eh; 298 char *itp; 299 { 300 size_t i; 301 Elf_Phdr *ph; 302 size_t phsize; 303 int error; 304 static const char linux[] = "Linux"; 305 306 if (eh->e_ident[EI_OSABI] == 3 || 307 memcmp(&eh->e_ident[EI_ABIVERSION], linux, sizeof(linux)) == 0) 308 return 0; 309 310 phsize = eh->e_phnum * sizeof(Elf_Phdr); 311 ph = (Elf_Phdr *)malloc(phsize, M_TEMP, M_WAITOK); 312 error = exec_read_from(l, epp->ep_vp, eh->e_phoff, ph, phsize); 313 if (error) 314 goto out; 315 316 for (i = 0; i < eh->e_phnum; i++) { 317 Elf_Phdr *ephp = &ph[i]; 318 Elf_Nhdr *np; 319 u_int32_t *abi; 320 321 if (ephp->p_type != PT_NOTE || 322 ephp->p_filesz > 1024 || 323 ephp->p_filesz < sizeof(Elf_Nhdr) + 20) 324 continue; 325 326 np = (Elf_Nhdr *)malloc(ephp->p_filesz, M_TEMP, M_WAITOK); 327 error = exec_read_from(l, epp->ep_vp, ephp->p_offset, np, 328 ephp->p_filesz); 329 if (error) 330 goto next; 331 332 if (np->n_type != ELF_NOTE_TYPE_ABI_TAG || 333 np->n_namesz != ELF_NOTE_ABI_NAMESZ || 334 np->n_descsz != ELF_NOTE_ABI_DESCSZ || 335 memcmp((void *)(np + 1), ELF_NOTE_ABI_NAME, 336 ELF_NOTE_ABI_NAMESZ)) 337 goto next; 338 339 /* Make sure the OS is Linux. */ 340 abi = (u_int32_t *)((char *)np + sizeof(Elf_Nhdr) + 341 np->n_namesz); 342 if (abi[0] == ELF_NOTE_ABI_OS_LINUX) 343 error = 0; 344 else 345 error = ENOEXEC; 346 free(np, M_TEMP); 347 goto out; 348 349 next: 350 free(np, M_TEMP); 351 continue; 352 } 353 354 /* Check for certain intepreter names. */ 355 if (itp) { 356 if (!strncmp(itp, "/lib/ld-linux", 13) || 357 #if (ELFSIZE == 64) 358 !strncmp(itp, "/lib64/ld-linux", 15) || 359 #endif 360 !strncmp(itp, "/lib/ld.so.", 11)) 361 error = 0; 362 else 363 error = ENOEXEC; 364 goto out; 365 } 366 367 error = ENOEXEC; 368 out: 369 free(ph, M_TEMP); 370 return (error); 371 } 372 373 int 374 ELFNAME2(linux,probe)(struct lwp *l, struct exec_package *epp, void *eh, 375 char *itp, vaddr_t *pos) 376 { 377 int error; 378 379 if (((error = ELFNAME2(linux,signature)(l, epp, eh, itp)) != 0) && 380 #ifdef LINUX_GCC_SIGNATURE 381 ((error = ELFNAME2(linux,gcc_signature)(l, epp, eh)) != 0) && 382 #endif 383 #ifdef LINUX_ATEXIT_SIGNATURE 384 ((error = ELFNAME2(linux,atexit_signature)(l, epp, eh)) != 0) && 385 #endif 386 #ifdef LINUX_DEBUGLINK_SIGNATURE 387 ((error = ELFNAME2(linux,debuglink_signature)(l, epp, eh)) != 0) && 388 #endif 389 1) { 390 DPRINTF(("linux_probe: returning %d\n", error)); 391 return error; 392 } 393 394 if (itp) { 395 if ((error = emul_find_interp(l, epp->ep_esch->es_emul->e_path, 396 itp))) 397 return (error); 398 } 399 DPRINTF(("linux_probe: returning 0\n")); 400 return 0; 401 } 402 403 #ifndef LINUX_MACHDEP_ELF_COPYARGS 404 /* 405 * Copy arguments onto the stack in the normal way, but add some 406 * extra information in case of dynamic binding. 407 */ 408 int 409 ELFNAME2(linux,copyargs)(struct lwp *l, struct exec_package *pack, 410 struct ps_strings *arginfo, char **stackp, void *argp) 411 { 412 size_t len; 413 AuxInfo ai[LINUX_ELF_AUX_ENTRIES], *a; 414 struct elf_args *ap; 415 int error; 416 struct vattr *vap; 417 418 if ((error = copyargs(l, pack, arginfo, stackp, argp)) != 0) 419 return error; 420 421 a = ai; 422 423 /* 424 * Push extra arguments used by glibc on the stack. 425 */ 426 427 a->a_type = AT_PAGESZ; 428 a->a_v = PAGE_SIZE; 429 a++; 430 431 if ((ap = (struct elf_args *)pack->ep_emul_arg)) { 432 433 a->a_type = AT_PHDR; 434 a->a_v = ap->arg_phaddr; 435 a++; 436 437 a->a_type = AT_PHENT; 438 a->a_v = ap->arg_phentsize; 439 a++; 440 441 a->a_type = AT_PHNUM; 442 a->a_v = ap->arg_phnum; 443 a++; 444 445 a->a_type = AT_BASE; 446 a->a_v = ap->arg_interp; 447 a++; 448 449 a->a_type = AT_FLAGS; 450 a->a_v = 0; 451 a++; 452 453 a->a_type = AT_ENTRY; 454 a->a_v = ap->arg_entry; 455 a++; 456 457 free(pack->ep_emul_arg, M_TEMP); 458 pack->ep_emul_arg = NULL; 459 } 460 461 /* Linux-specific items */ 462 a->a_type = LINUX_AT_CLKTCK; 463 a->a_v = hz; 464 a++; 465 466 vap = pack->ep_vap; 467 468 a->a_type = LINUX_AT_UID; 469 a->a_v = kauth_cred_getuid(l->l_cred); 470 a++; 471 472 a->a_type = LINUX_AT_EUID; 473 if (vap->va_mode & S_ISUID) 474 a->a_v = vap->va_uid; 475 else 476 a->a_v = kauth_cred_geteuid(l->l_cred); 477 a++; 478 479 a->a_type = LINUX_AT_GID; 480 a->a_v = kauth_cred_getgid(l->l_cred); 481 a++; 482 483 a->a_type = LINUX_AT_EGID; 484 if (vap->va_mode & S_ISGID) 485 a->a_v = vap->va_gid; 486 else 487 a->a_v = kauth_cred_getegid(l->l_cred); 488 a++; 489 490 a->a_type = AT_NULL; 491 a->a_v = 0; 492 a++; 493 494 len = (a - ai) * sizeof(AuxInfo); 495 if ((error = copyout(ai, *stackp, len)) != 0) 496 return error; 497 *stackp += len; 498 499 return 0; 500 } 501 #endif /* !LINUX_MACHDEP_ELF_COPYARGS */ 502
Indexes created Mon Sep 22 10:09:38 GMT 2025