1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 1880 ahl * Common Development and Distribution License (the "License"). 6 1880 ahl * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 1880 ahl 22 0 stevel /* 23 9405 Mita * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 0 stevel * Use is subject to license terms. 25 0 stevel */ 26 0 stevel 27 0 stevel /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 0 stevel /* All Rights Reserved */ 29 0 stevel 30 0 stevel #include <sys/types.h> 31 0 stevel #include <sys/param.h> 32 0 stevel #include <sys/thread.h> 33 0 stevel #include <sys/sysmacros.h> 34 0 stevel #include <sys/signal.h> 35 0 stevel #include <sys/cred.h> 36 0 stevel #include <sys/user.h> 37 0 stevel #include <sys/errno.h> 38 0 stevel #include <sys/vnode.h> 39 0 stevel #include <sys/mman.h> 40 0 stevel #include <sys/kmem.h> 41 0 stevel #include <sys/proc.h> 42 0 stevel #include <sys/pathname.h> 43 0 stevel #include <sys/cmn_err.h> 44 0 stevel #include <sys/systm.h> 45 0 stevel #include <sys/elf.h> 46 0 stevel #include <sys/vmsystm.h> 47 0 stevel #include <sys/debug.h> 48 0 stevel #include <sys/auxv.h> 49 0 stevel #include <sys/exec.h> 50 0 stevel #include <sys/prsystm.h> 51 0 stevel #include <vm/as.h> 52 0 stevel #include <vm/rm.h> 53 0 stevel #include <vm/seg.h> 54 0 stevel #include <vm/seg_vn.h> 55 0 stevel #include <sys/modctl.h> 56 0 stevel #include <sys/systeminfo.h> 57 0 stevel #include <sys/vmparam.h> 58 0 stevel #include <sys/machelf.h> 59 0 stevel #include <sys/shm_impl.h> 60 0 stevel #include <sys/archsystm.h> 61 0 stevel #include <sys/fasttrap.h> 62 2712 nn35248 #include <sys/brand.h> 63 0 stevel #include "elf_impl.h" 64 2712 nn35248 #include <sys/sdt.h> 65 0 stevel 66 0 stevel extern int at_flags; 67 0 stevel 68 0 stevel #define ORIGIN_STR "ORIGIN" 69 0 stevel #define ORIGIN_STR_SIZE 6 70 0 stevel 71 942 ahl static int getelfhead(vnode_t *, cred_t *, Ehdr *, int *, int *, int *); 72 942 ahl static int getelfphdr(vnode_t *, cred_t *, const Ehdr *, int, caddr_t *, 73 942 ahl ssize_t *); 74 942 ahl static int getelfshdr(vnode_t *, cred_t *, const Ehdr *, int, int, caddr_t *, 75 942 ahl ssize_t *, caddr_t *, ssize_t *); 76 942 ahl static size_t elfsize(Ehdr *, int, caddr_t, uintptr_t *); 77 942 ahl static int mapelfexec(vnode_t *, Ehdr *, int, caddr_t, 78 0 stevel Phdr **, Phdr **, Phdr **, Phdr **, Phdr *, 79 2712 nn35248 caddr_t *, caddr_t *, intptr_t *, intptr_t *, size_t, long *, size_t *); 80 0 stevel 81 0 stevel typedef enum { 82 0 stevel STR_CTF, 83 0 stevel STR_SYMTAB, 84 0 stevel STR_DYNSYM, 85 0 stevel STR_STRTAB, 86 0 stevel STR_DYNSTR, 87 0 stevel STR_SHSTRTAB, 88 0 stevel STR_NUM 89 0 stevel } shstrtype_t; 90 0 stevel 91 0 stevel static const char *shstrtab_data[] = { 92 0 stevel ".SUNW_ctf", 93 0 stevel ".symtab", 94 0 stevel ".dynsym", 95 0 stevel ".strtab", 96 0 stevel ".dynstr", 97 0 stevel ".shstrtab" 98 0 stevel }; 99 0 stevel 100 0 stevel typedef struct shstrtab { 101 0 stevel int sst_ndx[STR_NUM]; 102 0 stevel int sst_cur; 103 0 stevel } shstrtab_t; 104 0 stevel 105 0 stevel static void 106 0 stevel shstrtab_init(shstrtab_t *s) 107 0 stevel { 108 0 stevel bzero(&s->sst_ndx, sizeof (s->sst_ndx)); 109 0 stevel s->sst_cur = 1; 110 0 stevel } 111 0 stevel 112 0 stevel static int 113 0 stevel shstrtab_ndx(shstrtab_t *s, shstrtype_t type) 114 0 stevel { 115 0 stevel int ret; 116 0 stevel 117 0 stevel if ((ret = s->sst_ndx[type]) != 0) 118 0 stevel return (ret); 119 0 stevel 120 0 stevel ret = s->sst_ndx[type] = s->sst_cur; 121 0 stevel s->sst_cur += strlen(shstrtab_data[type]) + 1; 122 0 stevel 123 0 stevel return (ret); 124 0 stevel } 125 0 stevel 126 0 stevel static size_t 127 0 stevel shstrtab_size(const shstrtab_t *s) 128 0 stevel { 129 0 stevel return (s->sst_cur); 130 0 stevel } 131 0 stevel 132 0 stevel static void 133 0 stevel shstrtab_dump(const shstrtab_t *s, char *buf) 134 0 stevel { 135 0 stevel int i, ndx; 136 0 stevel 137 0 stevel *buf = '\0'; 138 0 stevel for (i = 0; i < STR_NUM; i++) { 139 0 stevel if ((ndx = s->sst_ndx[i]) != 0) 140 0 stevel (void) strcpy(buf + ndx, shstrtab_data[i]); 141 0 stevel } 142 0 stevel } 143 0 stevel 144 0 stevel static int 145 0 stevel dtrace_safe_phdr(Phdr *phdrp, struct uarg *args, uintptr_t base) 146 0 stevel { 147 0 stevel ASSERT(phdrp->p_type == PT_SUNWDTRACE); 148 0 stevel 149 0 stevel /* 150 0 stevel * See the comment in fasttrap.h for information on how to safely 151 0 stevel * update this program header. 152 0 stevel */ 153 0 stevel if (phdrp->p_memsz < PT_SUNWDTRACE_SIZE || 154 0 stevel (phdrp->p_flags & (PF_R | PF_W | PF_X)) != (PF_R | PF_W | PF_X)) 155 0 stevel return (-1); 156 0 stevel 157 0 stevel args->thrptr = phdrp->p_vaddr + base; 158 0 stevel 159 0 stevel return (0); 160 0 stevel } 161 0 stevel 162 2712 nn35248 /* 163 2712 nn35248 * Map in the executable pointed to by vp. Returns 0 on success. 164 2712 nn35248 */ 165 2712 nn35248 int 166 4440 edp mapexec_brand(vnode_t *vp, uarg_t *args, Ehdr *ehdr, Addr *uphdr_vaddr, 167 2712 nn35248 intptr_t *voffset, caddr_t exec_file, int *interp, caddr_t *bssbase, 168 4642 sl108498 caddr_t *brkbase, size_t *brksize, uintptr_t *lddatap) 169 2712 nn35248 { 170 2712 nn35248 size_t len; 171 2712 nn35248 struct vattr vat; 172 2712 nn35248 caddr_t phdrbase = NULL; 173 2712 nn35248 ssize_t phdrsize; 174 2712 nn35248 int nshdrs, shstrndx, nphdrs; 175 2712 nn35248 int error = 0; 176 2712 nn35248 Phdr *uphdr = NULL; 177 2712 nn35248 Phdr *junk = NULL; 178 2712 nn35248 Phdr *dynphdr = NULL; 179 2712 nn35248 Phdr *dtrphdr = NULL; 180 2712 nn35248 uintptr_t lddata; 181 2712 nn35248 long execsz; 182 2712 nn35248 intptr_t minaddr; 183 4642 sl108498 184 4642 sl108498 if (lddatap != NULL) 185 4642 sl108498 *lddatap = NULL; 186 2712 nn35248 187 2712 nn35248 if (error = execpermissions(vp, &vat, args)) { 188 2712 nn35248 uprintf("%s: Cannot execute %s\n", exec_file, args->pathname); 189 2712 nn35248 return (error); 190 2712 nn35248 } 191 2712 nn35248 192 2712 nn35248 if ((error = getelfhead(vp, CRED(), ehdr, &nshdrs, &shstrndx, 193 2712 nn35248 &nphdrs)) != 0 || 194 2712 nn35248 (error = getelfphdr(vp, CRED(), ehdr, nphdrs, &phdrbase, 195 2712 nn35248 &phdrsize)) != 0) { 196 2712 nn35248 uprintf("%s: Cannot read %s\n", exec_file, args->pathname); 197 2712 nn35248 return (error); 198 2712 nn35248 } 199 2712 nn35248 200 2712 nn35248 if ((len = elfsize(ehdr, nphdrs, phdrbase, &lddata)) == 0) { 201 2712 nn35248 uprintf("%s: Nothing to load in %s", exec_file, args->pathname); 202 2712 nn35248 kmem_free(phdrbase, phdrsize); 203 2712 nn35248 return (ENOEXEC); 204 2712 nn35248 } 205 4642 sl108498 if (lddatap != NULL) 206 4642 sl108498 *lddatap = lddata; 207 2712 nn35248 208 2712 nn35248 if (error = mapelfexec(vp, ehdr, nphdrs, phdrbase, &uphdr, &dynphdr, 209 2712 nn35248 &junk, &dtrphdr, NULL, bssbase, brkbase, voffset, &minaddr, 210 2712 nn35248 len, &execsz, brksize)) { 211 2712 nn35248 uprintf("%s: Cannot map %s\n", exec_file, args->pathname); 212 2712 nn35248 kmem_free(phdrbase, phdrsize); 213 2712 nn35248 return (error); 214 2712 nn35248 } 215 2712 nn35248 216 2712 nn35248 /* 217 2712 nn35248 * Inform our caller if the executable needs an interpreter. 218 2712 nn35248 */ 219 2712 nn35248 *interp = (dynphdr == NULL) ? 0 : 1; 220 2712 nn35248 221 2712 nn35248 /* 222 2712 nn35248 * If this is a statically linked executable, voffset should indicate 223 2712 nn35248 * the address of the executable itself (it normally holds the address 224 2712 nn35248 * of the interpreter). 225 2712 nn35248 */ 226 2712 nn35248 if (ehdr->e_type == ET_EXEC && *interp == 0) 227 2712 nn35248 *voffset = minaddr; 228 2712 nn35248 229 2712 nn35248 if (uphdr != NULL) { 230 2712 nn35248 *uphdr_vaddr = uphdr->p_vaddr; 231 2712 nn35248 } else { 232 4440 edp *uphdr_vaddr = (Addr)-1; 233 2712 nn35248 } 234 2712 nn35248 235 2712 nn35248 kmem_free(phdrbase, phdrsize); 236 2712 nn35248 return (error); 237 2712 nn35248 } 238 2712 nn35248 239 0 stevel /*ARGSUSED*/ 240 0 stevel int 241 0 stevel elfexec(vnode_t *vp, execa_t *uap, uarg_t *args, intpdata_t *idatap, 242 2712 nn35248 int level, long *execsz, int setid, caddr_t exec_file, cred_t *cred, 243 2712 nn35248 int brand_action) 244 0 stevel { 245 0 stevel caddr_t phdrbase = NULL; 246 0 stevel caddr_t bssbase = 0; 247 0 stevel caddr_t brkbase = 0; 248 0 stevel size_t brksize = 0; 249 0 stevel ssize_t dlnsize; 250 0 stevel aux_entry_t *aux; 251 0 stevel int error; 252 0 stevel ssize_t resid; 253 0 stevel int fd = -1; 254 0 stevel intptr_t voffset; 255 2712 nn35248 Phdr *dyphdr = NULL; 256 2712 nn35248 Phdr *stphdr = NULL; 257 2712 nn35248 Phdr *uphdr = NULL; 258 2712 nn35248 Phdr *junk = NULL; 259 0 stevel size_t len; 260 0 stevel ssize_t phdrsize; 261 0 stevel int postfixsize = 0; 262 0 stevel int i, hsize; 263 0 stevel Phdr *phdrp; 264 0 stevel Phdr *dataphdrp = NULL; 265 0 stevel Phdr *dtrphdr; 266 7838 Roger Phdr *capphdr = NULL; 267 7838 Roger Cap *cap = NULL; 268 7838 Roger ssize_t capsize; 269 0 stevel int hasu = 0; 270 0 stevel int hasauxv = 0; 271 0 stevel int hasdy = 0; 272 2712 nn35248 int branded = 0; 273 0 stevel 274 0 stevel struct proc *p = ttoproc(curthread); 275 0 stevel struct user *up = PTOU(p); 276 0 stevel struct bigwad { 277 0 stevel Ehdr ehdr; 278 0 stevel aux_entry_t elfargs[__KERN_NAUXV_IMPL]; 279 0 stevel char dl_name[MAXPATHLEN]; 280 0 stevel char pathbuf[MAXPATHLEN]; 281 0 stevel struct vattr vattr; 282 0 stevel struct execenv exenv; 283 0 stevel } *bigwad; /* kmem_alloc this behemoth so we don't blow stack */ 284 942 ahl Ehdr *ehdrp; 285 942 ahl int nshdrs, shstrndx, nphdrs; 286 0 stevel char *dlnp; 287 0 stevel char *pathbufp; 288 0 stevel rlim64_t limit; 289 0 stevel rlim64_t roundlimit; 290 0 stevel 291 0 stevel ASSERT(p->p_model == DATAMODEL_ILP32 || p->p_model == DATAMODEL_LP64); 292 2712 nn35248 293 0 stevel bigwad = kmem_alloc(sizeof (struct bigwad), KM_SLEEP); 294 0 stevel ehdrp = &bigwad->ehdr; 295 0 stevel dlnp = bigwad->dl_name; 296 0 stevel pathbufp = bigwad->pathbuf; 297 0 stevel 298 0 stevel /* 299 0 stevel * Obtain ELF and program header information. 300 0 stevel */ 301 942 ahl if ((error = getelfhead(vp, CRED(), ehdrp, &nshdrs, &shstrndx, 302 942 ahl &nphdrs)) != 0 || 303 942 ahl (error = getelfphdr(vp, CRED(), ehdrp, nphdrs, &phdrbase, 304 942 ahl &phdrsize)) != 0) 305 0 stevel goto out; 306 2355 rie 307 2355 rie /* 308 2355 rie * Prevent executing an ELF file that has no entry point. 309 2355 rie */ 310 2355 rie if (ehdrp->e_entry == 0) { 311 2355 rie uprintf("%s: Bad entry point\n", exec_file); 312 2355 rie goto bad; 313 2355 rie } 314 0 stevel 315 0 stevel /* 316 0 stevel * Put data model that we're exec-ing to into the args passed to 317 0 stevel * exec_args(), so it will know what it is copying to on new stack. 318 0 stevel * Now that we know whether we are exec-ing a 32-bit or 64-bit 319 0 stevel * executable, we can set execsz with the appropriate NCARGS. 320 0 stevel */ 321 0 stevel #ifdef _LP64 322 0 stevel if (ehdrp->e_ident[EI_CLASS] == ELFCLASS32) { 323 0 stevel args->to_model = DATAMODEL_ILP32; 324 0 stevel *execsz = btopr(SINCR) + btopr(SSIZE) + btopr(NCARGS32-1); 325 0 stevel } else { 326 0 stevel args->to_model = DATAMODEL_LP64; 327 0 stevel args->stk_prot &= ~PROT_EXEC; 328 0 stevel #if defined(__i386) || defined(__amd64) 329 0 stevel args->dat_prot &= ~PROT_EXEC; 330 0 stevel #endif 331 0 stevel *execsz = btopr(SINCR) + btopr(SSIZE) + btopr(NCARGS64-1); 332 0 stevel } 333 0 stevel #else /* _LP64 */ 334 0 stevel args->to_model = DATAMODEL_ILP32; 335 0 stevel *execsz = btopr(SINCR) + btopr(SSIZE) + btopr(NCARGS-1); 336 0 stevel #endif /* _LP64 */ 337 4440 edp 338 4440 edp /* 339 4440 edp * We delay invoking the brand callback until we've figured out 340 4440 edp * what kind of elf binary we're trying to run, 32-bit or 64-bit. 341 4440 edp * We do this because now the brand library can just check 342 4440 edp * args->to_model to see if the target is 32-bit or 64-bit without 343 4440 edp * having do duplicate all the code above. 344 4440 edp */ 345 4440 edp if ((level < 2) && 346 4440 edp (brand_action != EBA_NATIVE) && (PROC_IS_BRANDED(p))) { 347 5172 edp error = BROP(p)->b_elfexec(vp, uap, args, 348 4440 edp idatap, level + 1, execsz, setid, exec_file, cred, 349 5172 edp brand_action); 350 5172 edp goto out; 351 4440 edp } 352 0 stevel 353 0 stevel /* 354 0 stevel * Determine aux size now so that stack can be built 355 0 stevel * in one shot (except actual copyout of aux image), 356 0 stevel * determine any non-default stack protections, 357 0 stevel * and still have this code be machine independent. 358 0 stevel */ 359 0 stevel hsize = ehdrp->e_phentsize; 360 0 stevel phdrp = (Phdr *)phdrbase; 361 942 ahl for (i = nphdrs; i > 0; i--) { 362 0 stevel switch (phdrp->p_type) { 363 0 stevel case PT_INTERP: 364 0 stevel hasauxv = hasdy = 1; 365 0 stevel break; 366 0 stevel case PT_PHDR: 367 0 stevel hasu = 1; 368 0 stevel break; 369 0 stevel case PT_SUNWSTACK: 370 0 stevel args->stk_prot = PROT_USER; 371 0 stevel if (phdrp->p_flags & PF_R) 372 0 stevel args->stk_prot |= PROT_READ; 373 0 stevel if (phdrp->p_flags & PF_W) 374 0 stevel args->stk_prot |= PROT_WRITE; 375 0 stevel if (phdrp->p_flags & PF_X) 376 0 stevel args->stk_prot |= PROT_EXEC; 377 0 stevel break; 378 0 stevel case PT_LOAD: 379 0 stevel dataphdrp = phdrp; 380 0 stevel break; 381 7838 Roger case PT_SUNWCAP: 382 7838 Roger capphdr = phdrp; 383 7838 Roger break; 384 0 stevel } 385 0 stevel phdrp = (Phdr *)((caddr_t)phdrp + hsize); 386 0 stevel } 387 0 stevel 388 0 stevel if (ehdrp->e_type != ET_EXEC) { 389 0 stevel dataphdrp = NULL; 390 0 stevel hasauxv = 1; 391 0 stevel } 392 0 stevel 393 0 stevel /* Copy BSS permissions to args->dat_prot */ 394 0 stevel if (dataphdrp != NULL) { 395 0 stevel args->dat_prot = PROT_USER; 396 0 stevel if (dataphdrp->p_flags & PF_R) 397 0 stevel args->dat_prot |= PROT_READ; 398 0 stevel if (dataphdrp->p_flags & PF_W) 399 0 stevel args->dat_prot |= PROT_WRITE; 400 0 stevel if (dataphdrp->p_flags & PF_X) 401 0 stevel args->dat_prot |= PROT_EXEC; 402 0 stevel } 403 0 stevel 404 0 stevel /* 405 0 stevel * If a auxvector will be required - reserve the space for 406 0 stevel * it now. This may be increased by exec_args if there are 407 0 stevel * ISA-specific types (included in __KERN_NAUXV_IMPL). 408 0 stevel */ 409 0 stevel if (hasauxv) { 410 0 stevel /* 411 0 stevel * If a AUX vector is being built - the base AUX 412 0 stevel * entries are: 413 0 stevel * 414 0 stevel * AT_BASE 415 0 stevel * AT_FLAGS 416 0 stevel * AT_PAGESZ 417 0 stevel * AT_SUN_LDSECURE 418 0 stevel * AT_SUN_HWCAP 419 0 stevel * AT_SUN_PLATFORM 420 0 stevel * AT_SUN_EXECNAME 421 0 stevel * AT_NULL 422 0 stevel * 423 0 stevel * total == 8 424 0 stevel */ 425 0 stevel if (hasdy && hasu) { 426 0 stevel /* 427 0 stevel * Has PT_INTERP & PT_PHDR - the auxvectors that 428 0 stevel * will be built are: 429 0 stevel * 430 0 stevel * AT_PHDR 431 0 stevel * AT_PHENT 432 0 stevel * AT_PHNUM 433 0 stevel * AT_ENTRY 434 0 stevel * AT_LDDATA 435 0 stevel * 436 0 stevel * total = 5 437 0 stevel */ 438 0 stevel args->auxsize = (8 + 5) * sizeof (aux_entry_t); 439 0 stevel } else if (hasdy) { 440 0 stevel /* 441 0 stevel * Has PT_INTERP but no PT_PHDR 442 0 stevel * 443 0 stevel * AT_EXECFD 444 0 stevel * AT_LDDATA 445 0 stevel * 446 0 stevel * total = 2 447 0 stevel */ 448 0 stevel args->auxsize = (8 + 2) * sizeof (aux_entry_t); 449 0 stevel } else { 450 0 stevel args->auxsize = 8 * sizeof (aux_entry_t); 451 0 stevel } 452 7838 Roger } else { 453 0 stevel args->auxsize = 0; 454 7838 Roger } 455 0 stevel 456 2712 nn35248 /* 457 2712 nn35248 * If this binary is using an emulator, we need to add an 458 2712 nn35248 * AT_SUN_EMULATOR aux entry. 459 2712 nn35248 */ 460 2712 nn35248 if (args->emulator != NULL) 461 2712 nn35248 args->auxsize += sizeof (aux_entry_t); 462 2712 nn35248 463 2712 nn35248 if ((brand_action != EBA_NATIVE) && (PROC_IS_BRANDED(p))) { 464 2712 nn35248 branded = 1; 465 2712 nn35248 /* 466 4642 sl108498 * We will be adding 4 entries to the aux vectors. One for 467 4642 sl108498 * the the brandname and 3 for the brand specific aux vectors. 468 2712 nn35248 */ 469 4642 sl108498 args->auxsize += 4 * sizeof (aux_entry_t); 470 7838 Roger } 471 7838 Roger 472 7838 Roger /* Hardware/Software capabilities */ 473 7838 Roger if (capphdr != NULL && 474 7838 Roger (capsize = capphdr->p_filesz) > 0 && 475 7838 Roger capsize <= 16 * sizeof (*cap)) { 476 7838 Roger int ncaps = capsize / sizeof (*cap); 477 7838 Roger Cap *cp; 478 7838 Roger 479 7838 Roger cap = kmem_alloc(capsize, KM_SLEEP); 480 7838 Roger if ((error = vn_rdwr(UIO_READ, vp, (caddr_t)cap, 481 7838 Roger capsize, (offset_t)capphdr->p_offset, 482 7838 Roger UIO_SYSSPACE, 0, (rlim64_t)0, CRED(), &resid)) != 0) { 483 7838 Roger uprintf("%s: Cannot read capabilities section\n", 484 7838 Roger exec_file); 485 7838 Roger goto out; 486 7838 Roger } 487 7838 Roger for (cp = cap; cp < cap + ncaps; cp++) { 488 7838 Roger if (cp->c_tag == CA_SUNW_SF_1 && 489 7838 Roger (cp->c_un.c_val & SF1_SUNW_ADDR32)) { 490 7838 Roger if (args->to_model == DATAMODEL_LP64) 491 7838 Roger args->addr32 = 1; 492 7838 Roger break; 493 7838 Roger } 494 7838 Roger } 495 2712 nn35248 } 496 2712 nn35248 497 0 stevel aux = bigwad->elfargs; 498 0 stevel /* 499 0 stevel * Move args to the user's stack. 500 0 stevel */ 501 0 stevel if ((error = exec_args(uap, args, idatap, (void **)&aux)) != 0) { 502 0 stevel if (error == -1) { 503 0 stevel error = ENOEXEC; 504 0 stevel goto bad; 505 0 stevel } 506 0 stevel goto out; 507 0 stevel } 508 2712 nn35248 /* we're single threaded after this point */ 509 0 stevel 510 0 stevel /* 511 0 stevel * If this is an ET_DYN executable (shared object), 512 0 stevel * determine its memory size so that mapelfexec() can load it. 513 0 stevel */ 514 0 stevel if (ehdrp->e_type == ET_DYN) 515 942 ahl len = elfsize(ehdrp, nphdrs, phdrbase, NULL); 516 0 stevel else 517 0 stevel len = 0; 518 0 stevel 519 0 stevel dtrphdr = NULL; 520 0 stevel 521 942 ahl if ((error = mapelfexec(vp, ehdrp, nphdrs, phdrbase, &uphdr, &dyphdr, 522 2712 nn35248 &stphdr, &dtrphdr, dataphdrp, &bssbase, &brkbase, &voffset, NULL, 523 2712 nn35248 len, execsz, &brksize)) != 0) 524 0 stevel goto bad; 525 0 stevel 526 0 stevel if (uphdr != NULL && dyphdr == NULL) 527 0 stevel goto bad; 528 0 stevel 529 0 stevel if (dtrphdr != NULL && dtrace_safe_phdr(dtrphdr, args, voffset) != 0) { 530 0 stevel uprintf("%s: Bad DTrace phdr in %s\n", exec_file, exec_file); 531 0 stevel goto bad; 532 0 stevel } 533 0 stevel 534 0 stevel if (dyphdr != NULL) { 535 0 stevel size_t len; 536 0 stevel uintptr_t lddata; 537 0 stevel char *p; 538 0 stevel struct vnode *nvp; 539 0 stevel 540 0 stevel dlnsize = dyphdr->p_filesz; 541 0 stevel 542 0 stevel if (dlnsize > MAXPATHLEN || dlnsize <= 0) 543 0 stevel goto bad; 544 0 stevel 545 0 stevel /* 546 0 stevel * Read in "interpreter" pathname. 547 0 stevel */ 548 0 stevel if ((error = vn_rdwr(UIO_READ, vp, dlnp, dyphdr->p_filesz, 549 0 stevel (offset_t)dyphdr->p_offset, UIO_SYSSPACE, 0, (rlim64_t)0, 550 0 stevel CRED(), &resid)) != 0) { 551 0 stevel uprintf("%s: Cannot obtain interpreter pathname\n", 552 0 stevel exec_file); 553 0 stevel goto bad; 554 0 stevel } 555 0 stevel 556 0 stevel if (resid != 0 || dlnp[dlnsize - 1] != '\0') 557 0 stevel goto bad; 558 0 stevel 559 0 stevel /* 560 0 stevel * Search for '$ORIGIN' token in interpreter path. 561 0 stevel * If found, expand it. 562 0 stevel */ 563 0 stevel for (p = dlnp; p = strchr(p, '$'); ) { 564 0 stevel uint_t len, curlen; 565 0 stevel char *_ptr; 566 0 stevel 567 0 stevel if (strncmp(++p, ORIGIN_STR, ORIGIN_STR_SIZE)) 568 0 stevel continue; 569 0 stevel 570 0 stevel curlen = 0; 571 0 stevel len = p - dlnp - 1; 572 0 stevel if (len) { 573 0 stevel bcopy(dlnp, pathbufp, len); 574 0 stevel curlen += len; 575 0 stevel } 576 0 stevel if (_ptr = strrchr(args->pathname, '/')) { 577 0 stevel len = _ptr - args->pathname; 578 0 stevel if ((curlen + len) > MAXPATHLEN) 579 0 stevel break; 580 0 stevel 581 0 stevel bcopy(args->pathname, &pathbufp[curlen], len); 582 0 stevel curlen += len; 583 0 stevel } else { 584 0 stevel /* 585 0 stevel * executable is a basename found in the 586 0 stevel * current directory. So - just substitue 587 0 stevel * '.' for ORIGIN. 588 0 stevel */ 589 0 stevel pathbufp[curlen] = '.'; 590 0 stevel curlen++; 591 0 stevel } 592 0 stevel p += ORIGIN_STR_SIZE; 593 0 stevel len = strlen(p); 594 0 stevel 595 0 stevel if ((curlen + len) > MAXPATHLEN) 596 0 stevel break; 597 0 stevel bcopy(p, &pathbufp[curlen], len); 598 0 stevel curlen += len; 599 0 stevel pathbufp[curlen++] = '\0'; 600 0 stevel bcopy(pathbufp, dlnp, curlen); 601 0 stevel } 602 0 stevel 603 0 stevel /* 604 0 stevel * /usr/lib/ld.so.1 is known to be a symlink to /lib/ld.so.1 605 0 stevel * (and /usr/lib/64/ld.so.1 is a symlink to /lib/64/ld.so.1). 606 0 stevel * Just in case /usr is not mounted, change it now. 607 0 stevel */ 608 0 stevel if (strcmp(dlnp, USR_LIB_RTLD) == 0) 609 0 stevel dlnp += 4; 610 0 stevel error = lookupname(dlnp, UIO_SYSSPACE, FOLLOW, NULLVPP, &nvp); 611 0 stevel if (error && dlnp != bigwad->dl_name) { 612 0 stevel /* new kernel, old user-level */ 613 0 stevel error = lookupname(dlnp -= 4, UIO_SYSSPACE, FOLLOW, 614 4642 sl108498 NULLVPP, &nvp); 615 0 stevel } 616 0 stevel if (error) { 617 0 stevel uprintf("%s: Cannot find %s\n", exec_file, dlnp); 618 0 stevel goto bad; 619 0 stevel } 620 0 stevel 621 0 stevel /* 622 0 stevel * Setup the "aux" vector. 623 0 stevel */ 624 0 stevel if (uphdr) { 625 0 stevel if (ehdrp->e_type == ET_DYN) { 626 0 stevel /* don't use the first page */ 627 0 stevel bigwad->exenv.ex_brkbase = (caddr_t)PAGESIZE; 628 0 stevel bigwad->exenv.ex_bssbase = (caddr_t)PAGESIZE; 629 0 stevel } else { 630 0 stevel bigwad->exenv.ex_bssbase = bssbase; 631 0 stevel bigwad->exenv.ex_brkbase = brkbase; 632 0 stevel } 633 0 stevel bigwad->exenv.ex_brksize = brksize; 634 0 stevel bigwad->exenv.ex_magic = elfmagic; 635 0 stevel bigwad->exenv.ex_vp = vp; 636 0 stevel setexecenv(&bigwad->exenv); 637 0 stevel 638 0 stevel ADDAUX(aux, AT_PHDR, uphdr->p_vaddr + voffset) 639 0 stevel ADDAUX(aux, AT_PHENT, ehdrp->e_phentsize) 640 942 ahl ADDAUX(aux, AT_PHNUM, nphdrs) 641 0 stevel ADDAUX(aux, AT_ENTRY, ehdrp->e_entry + voffset) 642 0 stevel } else { 643 0 stevel if ((error = execopen(&vp, &fd)) != 0) { 644 0 stevel VN_RELE(nvp); 645 0 stevel goto bad; 646 0 stevel } 647 0 stevel 648 0 stevel ADDAUX(aux, AT_EXECFD, fd) 649 0 stevel } 650 0 stevel 651 0 stevel if ((error = execpermissions(nvp, &bigwad->vattr, args)) != 0) { 652 0 stevel VN_RELE(nvp); 653 0 stevel uprintf("%s: Cannot execute %s\n", exec_file, dlnp); 654 0 stevel goto bad; 655 0 stevel } 656 0 stevel 657 0 stevel /* 658 0 stevel * Now obtain the ELF header along with the entire program 659 0 stevel * header contained in "nvp". 660 0 stevel */ 661 0 stevel kmem_free(phdrbase, phdrsize); 662 0 stevel phdrbase = NULL; 663 942 ahl if ((error = getelfhead(nvp, CRED(), ehdrp, &nshdrs, 664 942 ahl &shstrndx, &nphdrs)) != 0 || 665 942 ahl (error = getelfphdr(nvp, CRED(), ehdrp, nphdrs, &phdrbase, 666 0 stevel &phdrsize)) != 0) { 667 0 stevel VN_RELE(nvp); 668 0 stevel uprintf("%s: Cannot read %s\n", exec_file, dlnp); 669 0 stevel goto bad; 670 0 stevel } 671 0 stevel 672 0 stevel /* 673 0 stevel * Determine memory size of the "interpreter's" loadable 674 0 stevel * sections. This size is then used to obtain the virtual 675 0 stevel * address of a hole, in the user's address space, large 676 0 stevel * enough to map the "interpreter". 677 0 stevel */ 678 942 ahl if ((len = elfsize(ehdrp, nphdrs, phdrbase, &lddata)) == 0) { 679 0 stevel VN_RELE(nvp); 680 0 stevel uprintf("%s: Nothing to load in %s\n", exec_file, dlnp); 681 0 stevel goto bad; 682 0 stevel } 683 0 stevel 684 0 stevel dtrphdr = NULL; 685 0 stevel 686 942 ahl error = mapelfexec(nvp, ehdrp, nphdrs, phdrbase, &junk, &junk, 687 2712 nn35248 &junk, &dtrphdr, NULL, NULL, NULL, &voffset, NULL, len, 688 2712 nn35248 execsz, NULL); 689 0 stevel if (error || junk != NULL) { 690 0 stevel VN_RELE(nvp); 691 0 stevel uprintf("%s: Cannot map %s\n", exec_file, dlnp); 692 0 stevel goto bad; 693 0 stevel } 694 0 stevel 695 0 stevel /* 696 0 stevel * We use the DTrace program header to initialize the 697 0 stevel * architecture-specific user per-LWP location. The dtrace 698 0 stevel * fasttrap provider requires ready access to per-LWP scratch 699 0 stevel * space. We assume that there is only one such program header 700 0 stevel * in the interpreter. 701 0 stevel */ 702 0 stevel if (dtrphdr != NULL && 703 0 stevel dtrace_safe_phdr(dtrphdr, args, voffset) != 0) { 704 0 stevel VN_RELE(nvp); 705 0 stevel uprintf("%s: Bad DTrace phdr in %s\n", exec_file, dlnp); 706 0 stevel goto bad; 707 0 stevel } 708 0 stevel 709 0 stevel VN_RELE(nvp); 710 0 stevel ADDAUX(aux, AT_SUN_LDDATA, voffset + lddata) 711 0 stevel } 712 0 stevel 713 0 stevel if (hasauxv) { 714 0 stevel int auxf = AF_SUN_HWCAPVERIFY; 715 0 stevel /* 716 0 stevel * Note: AT_SUN_PLATFORM was filled in via exec_args() 717 0 stevel */ 718 0 stevel ADDAUX(aux, AT_BASE, voffset) 719 0 stevel ADDAUX(aux, AT_FLAGS, at_flags) 720 0 stevel ADDAUX(aux, AT_PAGESZ, PAGESIZE) 721 0 stevel /* 722 0 stevel * Linker flags. (security) 723 0 stevel * p_flag not yet set at this time. 724 0 stevel * We rely on gexec() to provide us with the information. 725 1335 casper * If the application is set-uid but this is not reflected 726 1335 casper * in a mismatch between real/effective uids/gids, then 727 1335 casper * don't treat this as a set-uid exec. So we care about 728 1335 casper * the EXECSETID_UGIDS flag but not the ...SETID flag. 729 0 stevel */ 730 6229 edp if ((setid &= ~EXECSETID_SETID) != 0) 731 6229 edp auxf |= AF_SUN_SETUGID; 732 6229 edp /* 733 6229 edp * Record the user addr of the auxflags aux vector entry 734 6229 edp * since brands may optionally want to manipulate this field. 735 6229 edp */ 736 6229 edp args->auxp_auxflags = 737 6229 edp (char *)((char *)args->stackend + 738 6229 edp ((char *)&aux->a_type - 739 6229 edp (char *)bigwad->elfargs)); 740 6229 edp ADDAUX(aux, AT_SUN_AUXFLAGS, auxf); 741 0 stevel /* 742 0 stevel * Hardware capability flag word (performance hints) 743 0 stevel * Used for choosing faster library routines. 744 0 stevel * (Potentially different between 32-bit and 64-bit ABIs) 745 0 stevel */ 746 0 stevel #if defined(_LP64) 747 0 stevel if (args->to_model == DATAMODEL_NATIVE) 748 0 stevel ADDAUX(aux, AT_SUN_HWCAP, auxv_hwcap) 749 0 stevel else 750 0 stevel ADDAUX(aux, AT_SUN_HWCAP, auxv_hwcap32) 751 0 stevel #else 752 0 stevel ADDAUX(aux, AT_SUN_HWCAP, auxv_hwcap) 753 0 stevel #endif 754 2712 nn35248 if (branded) { 755 2712 nn35248 /* 756 4642 sl108498 * Reserve space for the brand-private aux vectors, 757 2712 nn35248 * and record the user addr of that space. 758 2712 nn35248 */ 759 4642 sl108498 args->auxp_brand = 760 4440 edp (char *)((char *)args->stackend + 761 4440 edp ((char *)&aux->a_type - 762 4440 edp (char *)bigwad->elfargs)); 763 4642 sl108498 ADDAUX(aux, AT_SUN_BRAND_AUX1, 0) 764 4642 sl108498 ADDAUX(aux, AT_SUN_BRAND_AUX2, 0) 765 4642 sl108498 ADDAUX(aux, AT_SUN_BRAND_AUX3, 0) 766 2712 nn35248 } 767 2712 nn35248 768 0 stevel ADDAUX(aux, AT_NULL, 0) 769 0 stevel postfixsize = (char *)aux - (char *)bigwad->elfargs; 770 0 stevel ASSERT(postfixsize == args->auxsize); 771 0 stevel ASSERT(postfixsize <= __KERN_NAUXV_IMPL * sizeof (aux_entry_t)); 772 0 stevel } 773 0 stevel 774 0 stevel /* 775 0 stevel * For the 64-bit kernel, the limit is big enough that rounding it up 776 0 stevel * to a page can overflow the 64-bit limit, so we check for btopr() 777 0 stevel * overflowing here by comparing it with the unrounded limit in pages. 778 0 stevel * If it hasn't overflowed, compare the exec size with the rounded up 779 0 stevel * limit in pages. Otherwise, just compare with the unrounded limit. 780 0 stevel */ 781 0 stevel limit = btop(p->p_vmem_ctl); 782 0 stevel roundlimit = btopr(p->p_vmem_ctl); 783 0 stevel if ((roundlimit > limit && *execsz > roundlimit) || 784 0 stevel (roundlimit < limit && *execsz > limit)) { 785 0 stevel mutex_enter(&p->p_lock); 786 0 stevel (void) rctl_action(rctlproc_legacy[RLIMIT_VMEM], p->p_rctls, p, 787 0 stevel RCA_SAFE); 788 0 stevel mutex_exit(&p->p_lock); 789 0 stevel error = ENOMEM; 790 0 stevel goto bad; 791 0 stevel } 792 0 stevel 793 0 stevel bzero(up->u_auxv, sizeof (up->u_auxv)); 794 0 stevel if (postfixsize) { 795 0 stevel int num_auxv; 796 0 stevel 797 0 stevel /* 798 0 stevel * Copy the aux vector to the user stack. 799 0 stevel */ 800 0 stevel error = execpoststack(args, bigwad->elfargs, postfixsize); 801 0 stevel if (error) 802 0 stevel goto bad; 803 0 stevel 804 0 stevel /* 805 0 stevel * Copy auxv to the process's user structure for use by /proc. 806 2712 nn35248 * If this is a branded process, the brand's exec routine will 807 2712 nn35248 * copy it's private entries to the user structure later. It 808 2712 nn35248 * relies on the fact that the blank entries are at the end. 809 0 stevel */ 810 0 stevel num_auxv = postfixsize / sizeof (aux_entry_t); 811 0 stevel ASSERT(num_auxv <= sizeof (up->u_auxv) / sizeof (auxv_t)); 812 0 stevel aux = bigwad->elfargs; 813 0 stevel for (i = 0; i < num_auxv; i++) { 814 0 stevel up->u_auxv[i].a_type = aux[i].a_type; 815 0 stevel up->u_auxv[i].a_un.a_val = (aux_val_t)aux[i].a_un.a_val; 816 0 stevel } 817 0 stevel } 818 0 stevel 819 0 stevel /* 820 0 stevel * Pass back the starting address so we can set the program counter. 821 0 stevel */ 822 0 stevel args->entry = (uintptr_t)(ehdrp->e_entry + voffset); 823 0 stevel 824 0 stevel if (!uphdr) { 825 0 stevel if (ehdrp->e_type == ET_DYN) { 826 0 stevel /* 827 0 stevel * If we are executing a shared library which doesn't 828 0 stevel * have a interpreter (probably ld.so.1) then 829 0 stevel * we don't set the brkbase now. Instead we 830 0 stevel * delay it's setting until the first call 831 0 stevel * via grow.c::brk(). This permits ld.so.1 to 832 0 stevel * initialize brkbase to the tail of the executable it 833 0 stevel * loads (which is where it needs to be). 834 0 stevel */ 835 0 stevel bigwad->exenv.ex_brkbase = (caddr_t)0; 836 0 stevel bigwad->exenv.ex_bssbase = (caddr_t)0; 837 0 stevel bigwad->exenv.ex_brksize = 0; 838 0 stevel } else { 839 0 stevel bigwad->exenv.ex_brkbase = brkbase; 840 0 stevel bigwad->exenv.ex_bssbase = bssbase; 841 0 stevel bigwad->exenv.ex_brksize = brksize; 842 0 stevel } 843 0 stevel bigwad->exenv.ex_magic = elfmagic; 844 0 stevel bigwad->exenv.ex_vp = vp; 845 0 stevel setexecenv(&bigwad->exenv); 846 0 stevel } 847 0 stevel 848 0 stevel ASSERT(error == 0); 849 0 stevel goto out; 850 0 stevel 851 0 stevel bad: 852 0 stevel if (fd != -1) /* did we open the a.out yet */ 853 0 stevel (void) execclose(fd); 854 0 stevel 855 0 stevel psignal(p, SIGKILL); 856 0 stevel 857 0 stevel if (error == 0) 858 0 stevel error = ENOEXEC; 859 0 stevel out: 860 0 stevel if (phdrbase != NULL) 861 0 stevel kmem_free(phdrbase, phdrsize); 862 7838 Roger if (cap != NULL) 863 7838 Roger kmem_free(cap, capsize); 864 0 stevel kmem_free(bigwad, sizeof (struct bigwad)); 865 0 stevel return (error); 866 0 stevel } 867 0 stevel 868 0 stevel /* 869 0 stevel * Compute the memory size requirement for the ELF file. 870 0 stevel */ 871 0 stevel static size_t 872 942 ahl elfsize(Ehdr *ehdrp, int nphdrs, caddr_t phdrbase, uintptr_t *lddata) 873 0 stevel { 874 0 stevel size_t len; 875 0 stevel Phdr *phdrp = (Phdr *)phdrbase; 876 0 stevel int hsize = ehdrp->e_phentsize; 877 0 stevel int first = 1; 878 0 stevel int dfirst = 1; /* first data segment */ 879 0 stevel uintptr_t loaddr = 0; 880 0 stevel uintptr_t hiaddr = 0; 881 0 stevel uintptr_t lo, hi; 882 0 stevel int i; 883 0 stevel 884 942 ahl for (i = nphdrs; i > 0; i--) { 885 0 stevel if (phdrp->p_type == PT_LOAD) { 886 0 stevel lo = phdrp->p_vaddr; 887 0 stevel hi = lo + phdrp->p_memsz; 888 0 stevel if (first) { 889 0 stevel loaddr = lo; 890 0 stevel hiaddr = hi; 891 0 stevel first = 0; 892 0 stevel } else { 893 0 stevel if (loaddr > lo) 894 0 stevel loaddr = lo; 895 0 stevel if (hiaddr < hi) 896 0 stevel hiaddr = hi; 897 0 stevel } 898 0 stevel 899 0 stevel /* 900 0 stevel * save the address of the first data segment 901 0 stevel * of a object - used for the AT_SUNW_LDDATA 902 0 stevel * aux entry. 903 0 stevel */ 904 0 stevel if ((lddata != NULL) && dfirst && 905 0 stevel (phdrp->p_flags & PF_W)) { 906 0 stevel *lddata = lo; 907 0 stevel dfirst = 0; 908 0 stevel } 909 0 stevel } 910 0 stevel phdrp = (Phdr *)((caddr_t)phdrp + hsize); 911 0 stevel } 912 0 stevel 913 0 stevel len = hiaddr - (loaddr & PAGEMASK); 914 0 stevel len = roundup(len, PAGESIZE); 915 0 stevel 916 0 stevel return (len); 917 0 stevel } 918 0 stevel 919 0 stevel /* 920 0 stevel * Read in the ELF header and program header table. 921 0 stevel * SUSV3 requires: 922 0 stevel * ENOEXEC File format is not recognized 923 0 stevel * EINVAL Format recognized but execution not supported 924 0 stevel */ 925 0 stevel static int 926 942 ahl getelfhead(vnode_t *vp, cred_t *credp, Ehdr *ehdr, int *nshdrs, int *shstrndx, 927 942 ahl int *nphdrs) 928 0 stevel { 929 0 stevel int error; 930 0 stevel ssize_t resid; 931 0 stevel 932 0 stevel /* 933 0 stevel * We got here by the first two bytes in ident, 934 0 stevel * now read the entire ELF header. 935 0 stevel */ 936 0 stevel if ((error = vn_rdwr(UIO_READ, vp, (caddr_t)ehdr, 937 0 stevel sizeof (Ehdr), (offset_t)0, UIO_SYSSPACE, 0, 938 0 stevel (rlim64_t)0, credp, &resid)) != 0) 939 0 stevel return (error); 940 0 stevel 941 0 stevel /* 942 0 stevel * Since a separate version is compiled for handling 32-bit and 943 0 stevel * 64-bit ELF executables on a 64-bit kernel, the 64-bit version 944 0 stevel * doesn't need to be able to deal with 32-bit ELF files. 945 0 stevel */ 946 0 stevel if (resid != 0 || 947 0 stevel ehdr->e_ident[EI_MAG2] != ELFMAG2 || 948 0 stevel ehdr->e_ident[EI_MAG3] != ELFMAG3) 949 0 stevel return (ENOEXEC); 950 942 ahl 951 0 stevel if ((ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN) || 952 0 stevel #if defined(_ILP32) || defined(_ELF32_COMPAT) 953 0 stevel ehdr->e_ident[EI_CLASS] != ELFCLASS32 || 954 0 stevel #else 955 0 stevel ehdr->e_ident[EI_CLASS] != ELFCLASS64 || 956 0 stevel #endif 957 0 stevel !elfheadcheck(ehdr->e_ident[EI_DATA], ehdr->e_machine, 958 942 ahl ehdr->e_flags)) 959 0 stevel return (EINVAL); 960 942 ahl 961 942 ahl *nshdrs = ehdr->e_shnum; 962 942 ahl *shstrndx = ehdr->e_shstrndx; 963 942 ahl *nphdrs = ehdr->e_phnum; 964 942 ahl 965 942 ahl /* 966 942 ahl * If e_shnum, e_shstrndx, or e_phnum is its sentinel value, we need 967 942 ahl * to read in the section header at index zero to acces the true 968 942 ahl * values for those fields. 969 942 ahl */ 970 942 ahl if ((*nshdrs == 0 && ehdr->e_shoff != 0) || 971 942 ahl *shstrndx == SHN_XINDEX || *nphdrs == PN_XNUM) { 972 942 ahl Shdr shdr; 973 942 ahl 974 942 ahl if (ehdr->e_shoff == 0) 975 942 ahl return (EINVAL); 976 942 ahl 977 942 ahl if ((error = vn_rdwr(UIO_READ, vp, (caddr_t)&shdr, 978 942 ahl sizeof (shdr), (offset_t)ehdr->e_shoff, UIO_SYSSPACE, 0, 979 942 ahl (rlim64_t)0, credp, &resid)) != 0) 980 942 ahl return (error); 981 942 ahl 982 942 ahl if (*nshdrs == 0) 983 942 ahl *nshdrs = shdr.sh_size; 984 942 ahl if (*shstrndx == SHN_XINDEX) 985 942 ahl *shstrndx = shdr.sh_link; 986 942 ahl if (*nphdrs == PN_XNUM && shdr.sh_info != 0) 987 942 ahl *nphdrs = shdr.sh_info; 988 942 ahl } 989 0 stevel 990 0 stevel return (0); 991 0 stevel } 992 0 stevel 993 0 stevel #ifdef _ELF32_COMPAT 994 0 stevel extern size_t elf_nphdr_max; 995 0 stevel #else 996 0 stevel size_t elf_nphdr_max = 1000; 997 0 stevel #endif 998 0 stevel 999 0 stevel static int 1000 942 ahl getelfphdr(vnode_t *vp, cred_t *credp, const Ehdr *ehdr, int nphdrs, 1001 0 stevel caddr_t *phbasep, ssize_t *phsizep) 1002 0 stevel { 1003 0 stevel ssize_t resid, minsize; 1004 0 stevel int err; 1005 0 stevel 1006 0 stevel /* 1007 0 stevel * Since we're going to be using e_phentsize to iterate down the 1008 0 stevel * array of program headers, it must be 8-byte aligned or else 1009 0 stevel * a we might cause a misaligned access. We use all members through 1010 0 stevel * p_flags on 32-bit ELF files and p_memsz on 64-bit ELF files so 1011 0 stevel * e_phentsize must be at least large enough to include those 1012 0 stevel * members. 1013 0 stevel */ 1014 0 stevel #if !defined(_LP64) || defined(_ELF32_COMPAT) 1015 0 stevel minsize = offsetof(Phdr, p_flags) + sizeof (((Phdr *)NULL)->p_flags); 1016 0 stevel #else 1017 0 stevel minsize = offsetof(Phdr, p_memsz) + sizeof (((Phdr *)NULL)->p_memsz); 1018 0 stevel #endif 1019 0 stevel if (ehdr->e_phentsize < minsize || (ehdr->e_phentsize & 3)) 1020 0 stevel return (EINVAL); 1021 0 stevel 1022 942 ahl *phsizep = nphdrs * ehdr->e_phentsize; 1023 0 stevel 1024 0 stevel if (*phsizep > sizeof (Phdr) * elf_nphdr_max) { 1025 0 stevel if ((*phbasep = kmem_alloc(*phsizep, KM_NOSLEEP)) == NULL) 1026 0 stevel return (ENOMEM); 1027 0 stevel } else { 1028 0 stevel *phbasep = kmem_alloc(*phsizep, KM_SLEEP); 1029 0 stevel } 1030 0 stevel 1031 0 stevel if ((err = vn_rdwr(UIO_READ, vp, *phbasep, *phsizep, 1032 0 stevel (offset_t)ehdr->e_phoff, UIO_SYSSPACE, 0, (rlim64_t)0, 1033 0 stevel credp, &resid)) != 0) { 1034 0 stevel kmem_free(*phbasep, *phsizep); 1035 0 stevel *phbasep = NULL; 1036 0 stevel return (err); 1037 0 stevel } 1038 0 stevel 1039 0 stevel return (0); 1040 0 stevel } 1041 0 stevel 1042 0 stevel #ifdef _ELF32_COMPAT 1043 0 stevel extern size_t elf_nshdr_max; 1044 0 stevel extern size_t elf_shstrtab_max; 1045 0 stevel #else 1046 0 stevel size_t elf_nshdr_max = 10000; 1047 0 stevel size_t elf_shstrtab_max = 100 * 1024; 1048 0 stevel #endif 1049 0 stevel 1050 0 stevel 1051 0 stevel static int 1052 0 stevel getelfshdr(vnode_t *vp, cred_t *credp, const Ehdr *ehdr, 1053 942 ahl int nshdrs, int shstrndx, caddr_t *shbasep, ssize_t *shsizep, 1054 0 stevel char **shstrbasep, ssize_t *shstrsizep) 1055 0 stevel { 1056 0 stevel ssize_t resid, minsize; 1057 0 stevel int err; 1058 0 stevel Shdr *shdr; 1059 0 stevel 1060 0 stevel /* 1061 0 stevel * Since we're going to be using e_shentsize to iterate down the 1062 0 stevel * array of section headers, it must be 8-byte aligned or else 1063 0 stevel * a we might cause a misaligned access. We use all members through 1064 0 stevel * sh_entsize (on both 32- and 64-bit ELF files) so e_shentsize 1065 942 ahl * must be at least large enough to include that member. The index 1066 942 ahl * of the string table section must also be valid. 1067 0 stevel */ 1068 0 stevel minsize = offsetof(Shdr, sh_entsize) + sizeof (shdr->sh_entsize); 1069 0 stevel if (ehdr->e_shentsize < minsize || (ehdr->e_shentsize & 3) || 1070 942 ahl shstrndx >= nshdrs) 1071 0 stevel return (EINVAL); 1072 0 stevel 1073 942 ahl *shsizep = nshdrs * ehdr->e_shentsize; 1074 0 stevel 1075 0 stevel if (*shsizep > sizeof (Shdr) * elf_nshdr_max) { 1076 0 stevel if ((*shbasep = kmem_alloc(*shsizep, KM_NOSLEEP)) == NULL) 1077 0 stevel return (ENOMEM); 1078 0 stevel } else { 1079 0 stevel *shbasep = kmem_alloc(*shsizep, KM_SLEEP); 1080 0 stevel } 1081 0 stevel 1082 0 stevel if ((err = vn_rdwr(UIO_READ, vp, *shbasep, *shsizep, 1083 0 stevel (offset_t)ehdr->e_shoff, UIO_SYSSPACE, 0, (rlim64_t)0, 1084 0 stevel credp, &resid)) != 0) { 1085 0 stevel kmem_free(*shbasep, *shsizep); 1086 0 stevel return (err); 1087 0 stevel } 1088 0 stevel 1089 0 stevel /* 1090 0 stevel * Pull the section string table out of the vnode; fail if the size 1091 0 stevel * is zero. 1092 0 stevel */ 1093 942 ahl shdr = (Shdr *)(*shbasep + shstrndx * ehdr->e_shentsize); 1094 0 stevel if ((*shstrsizep = shdr->sh_size) == 0) { 1095 0 stevel kmem_free(*shbasep, *shsizep); 1096 0 stevel return (EINVAL); 1097 0 stevel } 1098 0 stevel 1099 0 stevel if (*shstrsizep > elf_shstrtab_max) { 1100 0 stevel if ((*shstrbasep = kmem_alloc(*shstrsizep, 1101 0 stevel KM_NOSLEEP)) == NULL) { 1102 0 stevel kmem_free(*shbasep, *shsizep); 1103 0 stevel return (ENOMEM); 1104 0 stevel } 1105 0 stevel } else { 1106 0 stevel *shstrbasep = kmem_alloc(*shstrsizep, KM_SLEEP); 1107 0 stevel } 1108 0 stevel 1109 0 stevel if ((err = vn_rdwr(UIO_READ, vp, *shstrbasep, *shstrsizep, 1110 0 stevel (offset_t)shdr->sh_offset, UIO_SYSSPACE, 0, (rlim64_t)0, 1111 0 stevel credp, &resid)) != 0) { 1112 0 stevel kmem_free(*shbasep, *shsizep); 1113 0 stevel kmem_free(*shstrbasep, *shstrsizep); 1114 0 stevel return (err); 1115 0 stevel } 1116 0 stevel 1117 0 stevel /* 1118 0 stevel * Make sure the strtab is null-terminated to make sure we 1119 0 stevel * don't run off the end of the table. 1120 0 stevel */ 1121 0 stevel (*shstrbasep)[*shstrsizep - 1] = '\0'; 1122 0 stevel 1123 0 stevel return (0); 1124 0 stevel } 1125 0 stevel 1126 0 stevel static int 1127 0 stevel mapelfexec( 1128 0 stevel vnode_t *vp, 1129 0 stevel Ehdr *ehdr, 1130 942 ahl int nphdrs, 1131 0 stevel caddr_t phdrbase, 1132 0 stevel Phdr **uphdr, 1133 0 stevel Phdr **dyphdr, 1134 0 stevel Phdr **stphdr, 1135 0 stevel Phdr **dtphdr, 1136 0 stevel Phdr *dataphdrp, 1137 0 stevel caddr_t *bssbase, 1138 0 stevel caddr_t *brkbase, 1139 0 stevel intptr_t *voffset, 1140 2712 nn35248 intptr_t *minaddr, 1141 0 stevel size_t len, 1142 0 stevel long *execsz, 1143 0 stevel size_t *brksize) 1144 0 stevel { 1145 0 stevel Phdr *phdr; 1146 0 stevel int i, prot, error; 1147 6036 mec caddr_t addr = NULL; 1148 0 stevel size_t zfodsz; 1149 0 stevel int ptload = 0; 1150 0 stevel int page; 1151 0 stevel off_t offset; 1152 0 stevel int hsize = ehdr->e_phentsize; 1153 2712 nn35248 caddr_t mintmp = (caddr_t)-1; 1154 2991 susans extern int use_brk_lpg; 1155 0 stevel 1156 0 stevel if (ehdr->e_type == ET_DYN) { 1157 0 stevel /* 1158 0 stevel * Obtain the virtual address of a hole in the 1159 0 stevel * address space to map the "interpreter". 1160 0 stevel */ 1161 0 stevel map_addr(&addr, len, (offset_t)0, 1, 0); 1162 0 stevel if (addr == NULL) 1163 0 stevel return (ENOMEM); 1164 0 stevel *voffset = (intptr_t)addr; 1165 4730 eh208807 1166 4730 eh208807 /* 1167 4730 eh208807 * Calculate the minimum vaddr so it can be subtracted out. 1168 4730 eh208807 * According to the ELF specification, since PT_LOAD sections 1169 4730 eh208807 * must be sorted by increasing p_vaddr values, this is 1170 4730 eh208807 * guaranteed to be the first PT_LOAD section. 1171 4730 eh208807 */ 1172 4730 eh208807 phdr = (Phdr *)phdrbase; 1173 4730 eh208807 for (i = nphdrs; i > 0; i--) { 1174 4730 eh208807 if (phdr->p_type == PT_LOAD) { 1175 4730 eh208807 *voffset -= (uintptr_t)phdr->p_vaddr; 1176 4730 eh208807 break; 1177 4730 eh208807 } 1178 4730 eh208807 phdr = (Phdr *)((caddr_t)phdr + hsize); 1179 4730 eh208807 } 1180 4730 eh208807 1181 0 stevel } else { 1182 0 stevel *voffset = 0; 1183 0 stevel } 1184 0 stevel phdr = (Phdr *)phdrbase; 1185 942 ahl for (i = nphdrs; i > 0; i--) { 1186 0 stevel switch (phdr->p_type) { 1187 0 stevel case PT_LOAD: 1188 0 stevel if ((*dyphdr != NULL) && (*uphdr == NULL)) 1189 0 stevel return (0); 1190 0 stevel 1191 0 stevel ptload = 1; 1192 0 stevel prot = PROT_USER; 1193 0 stevel if (phdr->p_flags & PF_R) 1194 0 stevel prot |= PROT_READ; 1195 0 stevel if (phdr->p_flags & PF_W) 1196 0 stevel prot |= PROT_WRITE; 1197 0 stevel if (phdr->p_flags & PF_X) 1198 0 stevel prot |= PROT_EXEC; 1199 0 stevel 1200 0 stevel addr = (caddr_t)((uintptr_t)phdr->p_vaddr + *voffset); 1201 2712 nn35248 1202 2712 nn35248 /* 1203 2712 nn35248 * Keep track of the segment with the lowest starting 1204 2712 nn35248 * address. 1205 2712 nn35248 */ 1206 2712 nn35248 if (addr < mintmp) 1207 2712 nn35248 mintmp = addr; 1208 2712 nn35248 1209 0 stevel zfodsz = (size_t)phdr->p_memsz - phdr->p_filesz; 1210 0 stevel 1211 0 stevel offset = phdr->p_offset; 1212 0 stevel if (((uintptr_t)offset & PAGEOFFSET) == 1213 0 stevel ((uintptr_t)addr & PAGEOFFSET) && 1214 4642 sl108498 (!(vp->v_flag & VNOMAP))) { 1215 0 stevel page = 1; 1216 0 stevel } else { 1217 0 stevel page = 0; 1218 0 stevel } 1219 0 stevel 1220 2991 susans /* 1221 2991 susans * Set the heap pagesize for OOB when the bss size 1222 2991 susans * is known and use_brk_lpg is not 0. 1223 2991 susans */ 1224 2991 susans if (brksize != NULL && use_brk_lpg && 1225 2991 susans zfodsz != 0 && phdr == dataphdrp && 1226 2991 susans (prot & PROT_WRITE)) { 1227 2991 susans size_t tlen = P2NPHASE((uintptr_t)addr + 1228 2991 susans phdr->p_filesz, PAGESIZE); 1229 2991 susans 1230 2991 susans if (zfodsz > tlen) { 1231 2991 susans curproc->p_brkpageszc = 1232 2991 susans page_szc(map_pgsz(MAPPGSZ_HEAP, 1233 4642 sl108498 curproc, addr + phdr->p_filesz + 1234 4642 sl108498 tlen, zfodsz - tlen, 0)); 1235 2991 susans } 1236 2991 susans } 1237 2991 susans 1238 295 davemq if (curproc->p_brkpageszc != 0 && phdr == dataphdrp && 1239 295 davemq (prot & PROT_WRITE)) { 1240 0 stevel uint_t szc = curproc->p_brkpageszc; 1241 0 stevel size_t pgsz = page_get_pagesize(szc); 1242 2991 susans caddr_t ebss = addr + phdr->p_memsz; 1243 2991 susans size_t extra_zfodsz; 1244 0 stevel 1245 0 stevel ASSERT(pgsz > PAGESIZE); 1246 0 stevel 1247 2991 susans extra_zfodsz = P2NPHASE((uintptr_t)ebss, pgsz); 1248 2991 susans 1249 0 stevel if (error = execmap(vp, addr, phdr->p_filesz, 1250 2991 susans zfodsz + extra_zfodsz, phdr->p_offset, 1251 2991 susans prot, page, szc)) 1252 0 stevel goto bad; 1253 0 stevel if (brksize != NULL) 1254 2991 susans *brksize = extra_zfodsz; 1255 0 stevel } else { 1256 0 stevel if (error = execmap(vp, addr, phdr->p_filesz, 1257 0 stevel zfodsz, phdr->p_offset, prot, page, 0)) 1258 0 stevel goto bad; 1259 0 stevel } 1260 0 stevel 1261 0 stevel if (bssbase != NULL && addr >= *bssbase && 1262 0 stevel phdr == dataphdrp) { 1263 0 stevel *bssbase = addr + phdr->p_filesz; 1264 0 stevel } 1265 0 stevel if (brkbase != NULL && addr >= *brkbase) { 1266 0 stevel *brkbase = addr + phdr->p_memsz; 1267 0 stevel } 1268 0 stevel 1269 0 stevel *execsz += btopr(phdr->p_memsz); 1270 0 stevel break; 1271 0 stevel 1272 0 stevel case PT_INTERP: 1273 0 stevel if (ptload) 1274 0 stevel goto bad; 1275 0 stevel *dyphdr = phdr; 1276 0 stevel break; 1277 0 stevel 1278 0 stevel case PT_SHLIB: 1279 0 stevel *stphdr = phdr; 1280 0 stevel break; 1281 0 stevel 1282 0 stevel case PT_PHDR: 1283 0 stevel if (ptload) 1284 0 stevel goto bad; 1285 0 stevel *uphdr = phdr; 1286 0 stevel break; 1287 0 stevel 1288 0 stevel case PT_NULL: 1289 0 stevel case PT_DYNAMIC: 1290 0 stevel case PT_NOTE: 1291 0 stevel break; 1292 0 stevel 1293 0 stevel case PT_SUNWDTRACE: 1294 0 stevel if (dtphdr != NULL) 1295 0 stevel *dtphdr = phdr; 1296 0 stevel break; 1297 0 stevel 1298 0 stevel default: 1299 0 stevel break; 1300 0 stevel } 1301 0 stevel phdr = (Phdr *)((caddr_t)phdr + hsize); 1302 0 stevel } 1303 2712 nn35248 1304 2712 nn35248 if (minaddr != NULL) { 1305 2712 nn35248 ASSERT(mintmp != (caddr_t)-1); 1306 2712 nn35248 *minaddr = (intptr_t)mintmp; 1307 2712 nn35248 } 1308 2712 nn35248 1309 0 stevel return (0); 1310 0 stevel bad: 1311 0 stevel if (error == 0) 1312 0 stevel error = EINVAL; 1313 0 stevel return (error); 1314 0 stevel } 1315 0 stevel 1316 0 stevel int 1317 0 stevel elfnote(vnode_t *vp, offset_t *offsetp, int type, int descsz, void *desc, 1318 0 stevel rlim64_t rlimit, cred_t *credp) 1319 0 stevel { 1320 0 stevel Note note; 1321 0 stevel int error; 1322 0 stevel 1323 0 stevel bzero(¬e, sizeof (note)); 1324 0 stevel bcopy("CORE", note.name, 4); 1325 0 stevel note.nhdr.n_type = type; 1326 0 stevel /* 1327 0 stevel * The System V ABI states that n_namesz must be the length of the 1328 0 stevel * string that follows the Nhdr structure including the terminating 1329 0 stevel * null. The ABI also specifies that sufficient padding should be 1330 0 stevel * included so that the description that follows the name string 1331 0 stevel * begins on a 4- or 8-byte boundary for 32- and 64-bit binaries 1332 0 stevel * respectively. However, since this change was not made correctly 1333 0 stevel * at the time of the 64-bit port, both 32- and 64-bit binaries 1334 0 stevel * descriptions are only guaranteed to begin on a 4-byte boundary. 1335 0 stevel */ 1336 0 stevel note.nhdr.n_namesz = 5; 1337 0 stevel note.nhdr.n_descsz = roundup(descsz, sizeof (Word)); 1338 0 stevel 1339 0 stevel if (error = core_write(vp, UIO_SYSSPACE, *offsetp, ¬e, 1340 0 stevel sizeof (note), rlimit, credp)) 1341 0 stevel return (error); 1342 0 stevel 1343 0 stevel *offsetp += sizeof (note); 1344 0 stevel 1345 0 stevel if (error = core_write(vp, UIO_SYSSPACE, *offsetp, desc, 1346 0 stevel note.nhdr.n_descsz, rlimit, credp)) 1347 0 stevel return (error); 1348 0 stevel 1349 0 stevel *offsetp += note.nhdr.n_descsz; 1350 0 stevel return (0); 1351 0 stevel } 1352 0 stevel 1353 0 stevel /* 1354 0 stevel * Copy the section data from one vnode to the section of another vnode. 1355 0 stevel */ 1356 0 stevel static void 1357 0 stevel copy_scn(Shdr *src, vnode_t *src_vp, Shdr *dst, vnode_t *dst_vp, Off *doffset, 1358 0 stevel void *buf, size_t size, cred_t *credp, rlim64_t rlimit) 1359 0 stevel { 1360 0 stevel ssize_t resid; 1361 0 stevel size_t len, n = src->sh_size; 1362 0 stevel offset_t off = 0; 1363 0 stevel 1364 0 stevel while (n != 0) { 1365 0 stevel len = MIN(size, n); 1366 0 stevel if (vn_rdwr(UIO_READ, src_vp, buf, len, src->sh_offset + off, 1367 0 stevel UIO_SYSSPACE, 0, (rlim64_t)0, credp, &resid) != 0 || 1368 0 stevel resid >= len || 1369 0 stevel core_write(dst_vp, UIO_SYSSPACE, *doffset + off, 1370 0 stevel buf, len - resid, rlimit, credp) != 0) { 1371 0 stevel dst->sh_size = 0; 1372 0 stevel dst->sh_offset = 0; 1373 0 stevel return; 1374 0 stevel } 1375 0 stevel 1376 0 stevel ASSERT(n >= len - resid); 1377 0 stevel 1378 0 stevel n -= len - resid; 1379 0 stevel off += len - resid; 1380 0 stevel } 1381 0 stevel 1382 0 stevel *doffset += src->sh_size; 1383 0 stevel } 1384 0 stevel 1385 0 stevel #ifdef _ELF32_COMPAT 1386 0 stevel extern size_t elf_datasz_max; 1387 0 stevel #else 1388 0 stevel size_t elf_datasz_max = 1 * 1024 * 1024; 1389 0 stevel #endif 1390 0 stevel 1391 0 stevel /* 1392 0 stevel * This function processes mappings that correspond to load objects to 1393 0 stevel * examine their respective sections for elfcore(). It's called once with 1394 0 stevel * v set to NULL to count the number of sections that we're going to need 1395 0 stevel * and then again with v set to some allocated buffer that we fill in with 1396 0 stevel * all the section data. 1397 0 stevel */ 1398 0 stevel static int 1399 0 stevel process_scns(core_content_t content, proc_t *p, cred_t *credp, vnode_t *vp, 1400 1880 ahl Shdr *v, int nv, rlim64_t rlimit, Off *doffsetp, int *nshdrsp) 1401 0 stevel { 1402 0 stevel vnode_t *lastvp = NULL; 1403 0 stevel struct seg *seg; 1404 0 stevel int i, j; 1405 0 stevel void *data = NULL; 1406 0 stevel size_t datasz = 0; 1407 0 stevel shstrtab_t shstrtab; 1408 0 stevel struct as *as = p->p_as; 1409 0 stevel int error = 0; 1410 0 stevel 1411 0 stevel if (v != NULL) 1412 0 stevel shstrtab_init(&shstrtab); 1413 0 stevel 1414 0 stevel i = 1; 1415 0 stevel for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) { 1416 0 stevel uint_t prot; 1417 0 stevel vnode_t *mvp; 1418 0 stevel void *tmp = NULL; 1419 0 stevel caddr_t saddr = seg->s_base; 1420 0 stevel caddr_t naddr; 1421 0 stevel caddr_t eaddr; 1422 0 stevel size_t segsize; 1423 0 stevel 1424 0 stevel Ehdr ehdr; 1425 942 ahl int nshdrs, shstrndx, nphdrs; 1426 0 stevel caddr_t shbase; 1427 0 stevel ssize_t shsize; 1428 0 stevel char *shstrbase; 1429 0 stevel ssize_t shstrsize; 1430 0 stevel 1431 0 stevel Shdr *shdr; 1432 0 stevel const char *name; 1433 0 stevel size_t sz; 1434 0 stevel uintptr_t off; 1435 0 stevel 1436 0 stevel int ctf_ndx = 0; 1437 0 stevel int symtab_ndx = 0; 1438 0 stevel 1439 0 stevel /* 1440 0 stevel * Since we're just looking for text segments of load 1441 0 stevel * objects, we only care about the protection bits; we don't 1442 0 stevel * care about the actual size of the segment so we use the 1443 0 stevel * reserved size. If the segment's size is zero, there's 1444 0 stevel * something fishy going on so we ignore this segment. 1445 0 stevel */ 1446 0 stevel if (seg->s_ops != &segvn_ops || 1447 0 stevel SEGOP_GETVP(seg, seg->s_base, &mvp) != 0 || 1448 0 stevel mvp == lastvp || mvp == NULL || mvp->v_type != VREG || 1449 0 stevel (segsize = pr_getsegsize(seg, 1)) == 0) 1450 0 stevel continue; 1451 0 stevel 1452 0 stevel eaddr = saddr + segsize; 1453 0 stevel prot = pr_getprot(seg, 1, &tmp, &saddr, &naddr, eaddr); 1454 0 stevel pr_getprot_done(&tmp); 1455 0 stevel 1456 0 stevel /* 1457 0 stevel * Skip this segment unless the protection bits look like 1458 0 stevel * what we'd expect for a text segment. 1459 0 stevel */ 1460 0 stevel if ((prot & (PROT_WRITE | PROT_EXEC)) != PROT_EXEC) 1461 0 stevel continue; 1462 0 stevel 1463 942 ahl if (getelfhead(mvp, credp, &ehdr, &nshdrs, &shstrndx, 1464 942 ahl &nphdrs) != 0 || 1465 942 ahl getelfshdr(mvp, credp, &ehdr, nshdrs, shstrndx, 1466 942 ahl &shbase, &shsize, &shstrbase, &shstrsize) != 0) 1467 0 stevel continue; 1468 0 stevel 1469 0 stevel off = ehdr.e_shentsize; 1470 942 ahl for (j = 1; j < nshdrs; j++, off += ehdr.e_shentsize) { 1471 0 stevel Shdr *symtab = NULL, *strtab; 1472 0 stevel 1473 0 stevel shdr = (Shdr *)(shbase + off); 1474 0 stevel 1475 0 stevel if (shdr->sh_name >= shstrsize) 1476 0 stevel continue; 1477 0 stevel 1478 0 stevel name = shstrbase + shdr->sh_name; 1479 0 stevel 1480 0 stevel if (strcmp(name, shstrtab_data[STR_CTF]) == 0) { 1481 0 stevel if ((content & CC_CONTENT_CTF) == 0 || 1482 0 stevel ctf_ndx != 0) 1483 0 stevel continue; 1484 0 stevel 1485 0 stevel if (shdr->sh_link > 0 && 1486 942 ahl shdr->sh_link < nshdrs) { 1487 0 stevel symtab = (Shdr *)(shbase + 1488 0 stevel shdr->sh_link * ehdr.e_shentsize); 1489 0 stevel } 1490 0 stevel 1491 1880 ahl if (v != NULL && i < nv - 1) { 1492 0 stevel if (shdr->sh_size > datasz && 1493 0 stevel shdr->sh_size <= elf_datasz_max) { 1494 0 stevel if (data != NULL) 1495 0 stevel kmem_free(data, datasz); 1496 0 stevel 1497 0 stevel datasz = shdr->sh_size; 1498 0 stevel data = kmem_alloc(datasz, 1499 0 stevel KM_SLEEP); 1500 0 stevel } 1501 0 stevel 1502 0 stevel v[i].sh_name = shstrtab_ndx(&shstrtab, 1503 0 stevel STR_CTF); 1504 0 stevel v[i].sh_addr = (Addr)(uintptr_t)saddr; 1505 0 stevel v[i].sh_type = SHT_PROGBITS; 1506 0 stevel v[i].sh_addralign = 4; 1507 0 stevel *doffsetp = roundup(*doffsetp, 1508 0 stevel v[i].sh_addralign); 1509 0 stevel v[i].sh_offset = *doffsetp; 1510 0 stevel v[i].sh_size = shdr->sh_size; 1511 0 stevel if (symtab == NULL) { 1512 0 stevel v[i].sh_link = 0; 1513 0 stevel } else if (symtab->sh_type == 1514 0 stevel SHT_SYMTAB && 1515 0 stevel symtab_ndx != 0) { 1516 0 stevel v[i].sh_link = 1517 0 stevel symtab_ndx; 1518 0 stevel } else { 1519 0 stevel v[i].sh_link = i + 1; 1520 0 stevel } 1521 0 stevel 1522 0 stevel copy_scn(shdr, mvp, &v[i], vp, 1523 0 stevel doffsetp, data, datasz, credp, 1524 0 stevel rlimit); 1525 0 stevel } 1526 0 stevel 1527 0 stevel ctf_ndx = i++; 1528 0 stevel 1529 0 stevel /* 1530 0 stevel * We've already dumped the symtab. 1531 0 stevel */ 1532 0 stevel if (symtab != NULL && 1533 0 stevel symtab->sh_type == SHT_SYMTAB && 1534 0 stevel symtab_ndx != 0) 1535 0 stevel continue; 1536 0 stevel 1537 0 stevel } else if (strcmp(name, 1538 0 stevel shstrtab_data[STR_SYMTAB]) == 0) { 1539 0 stevel if ((content & CC_CONTENT_SYMTAB) == 0 || 1540 0 stevel symtab != 0) 1541 0 stevel continue; 1542 0 stevel 1543 0 stevel symtab = shdr; 1544 0 stevel } 1545 0 stevel 1546 0 stevel if (symtab != NULL) { 1547 0 stevel if ((symtab->sh_type != SHT_DYNSYM && 1548 0 stevel symtab->sh_type != SHT_SYMTAB) || 1549 0 stevel symtab->sh_link == 0 || 1550 942 ahl symtab->sh_link >= nshdrs) 1551 0 stevel continue; 1552 0 stevel 1553 0 stevel strtab = (Shdr *)(shbase + 1554 0 stevel symtab->sh_link * ehdr.e_shentsize); 1555 0 stevel 1556 0 stevel if (strtab->sh_type != SHT_STRTAB) 1557 0 stevel continue; 1558 0 stevel 1559 1880 ahl if (v != NULL && i < nv - 2) { 1560 0 stevel sz = MAX(symtab->sh_size, 1561 0 stevel strtab->sh_size); 1562 0 stevel if (sz > datasz && 1563 0 stevel sz <= elf_datasz_max) { 1564 0 stevel if (data != NULL) 1565 0 stevel kmem_free(data, datasz); 1566 0 stevel 1567 0 stevel datasz = sz; 1568 0 stevel data = kmem_alloc(datasz, 1569 0 stevel KM_SLEEP); 1570 0 stevel } 1571 0 stevel 1572 0 stevel if (symtab->sh_type == SHT_DYNSYM) { 1573 0 stevel v[i].sh_name = shstrtab_ndx( 1574 0 stevel &shstrtab, STR_DYNSYM); 1575 0 stevel v[i + 1].sh_name = shstrtab_ndx( 1576 0 stevel &shstrtab, STR_DYNSTR); 1577 0 stevel } else { 1578 0 stevel v[i].sh_name = shstrtab_ndx( 1579 0 stevel &shstrtab, STR_SYMTAB); 1580 0 stevel v[i + 1].sh_name = shstrtab_ndx( 1581 0 stevel &shstrtab, STR_STRTAB); 1582 0 stevel } 1583 0 stevel 1584 0 stevel v[i].sh_type = symtab->sh_type; 1585 0 stevel v[i].sh_addr = symtab->sh_addr; 1586 0 stevel if (ehdr.e_type == ET_DYN || 1587 0 stevel v[i].sh_addr == 0) 1588 0 stevel v[i].sh_addr += 1589 0 stevel (Addr)(uintptr_t)saddr; 1590 0 stevel v[i].sh_addralign = 1591 0 stevel symtab->sh_addralign; 1592 0 stevel *doffsetp = roundup(*doffsetp, 1593 0 stevel v[i].sh_addralign); 1594 0 stevel v[i].sh_offset = *doffsetp; 1595 0 stevel v[i].sh_size = symtab->sh_size; 1596 0 stevel v[i].sh_link = i + 1; 1597 0 stevel v[i].sh_entsize = symtab->sh_entsize; 1598 0 stevel v[i].sh_info = symtab->sh_info; 1599 0 stevel 1600 0 stevel copy_scn(symtab, mvp, &v[i], vp, 1601 0 stevel doffsetp, data, datasz, credp, 1602 0 stevel rlimit); 1603 0 stevel 1604 0 stevel v[i + 1].sh_type = SHT_STRTAB; 1605 0 stevel v[i + 1].sh_flags = SHF_STRINGS; 1606 0 stevel v[i + 1].sh_addr = symtab->sh_addr; 1607 0 stevel if (ehdr.e_type == ET_DYN || 1608 0 stevel v[i + 1].sh_addr == 0) 1609 0 stevel v[i + 1].sh_addr += 1610 0 stevel (Addr)(uintptr_t)saddr; 1611 0 stevel v[i + 1].sh_addralign = 1612 0 stevel strtab->sh_addralign; 1613 0 stevel *doffsetp = roundup(*doffsetp, 1614 0 stevel v[i + 1].sh_addralign); 1615 0 stevel v[i + 1].sh_offset = *doffsetp; 1616 0 stevel v[i + 1].sh_size = strtab->sh_size; 1617 0 stevel 1618 0 stevel copy_scn(strtab, mvp, &v[i + 1], vp, 1619 0 stevel doffsetp, data, datasz, credp, 1620 0 stevel rlimit); 1621 0 stevel } 1622 0 stevel 1623 0 stevel if (symtab->sh_type == SHT_SYMTAB) 1624 0 stevel symtab_ndx = i; 1625 0 stevel i += 2; 1626 0 stevel } 1627 0 stevel } 1628 0 stevel 1629 0 stevel kmem_free(shstrbase, shstrsize); 1630 0 stevel kmem_free(shbase, shsize); 1631 0 stevel 1632 0 stevel lastvp = mvp; 1633 0 stevel } 1634 0 stevel 1635 0 stevel if (v == NULL) { 1636 0 stevel if (i == 1) 1637 0 stevel *nshdrsp = 0; 1638 0 stevel else 1639 0 stevel *nshdrsp = i + 1; 1640 0 stevel goto done; 1641 0 stevel } 1642 0 stevel 1643 1880 ahl if (i != nv - 1) { 1644 0 stevel cmn_err(CE_WARN, "elfcore: core dump failed for " 1645 0 stevel "process %d; address space is changing", p->p_pid); 1646 0 stevel error = EIO; 1647 0 stevel goto done; 1648 0 stevel } 1649 0 stevel 1650 0 stevel v[i].sh_name = shstrtab_ndx(&shstrtab, STR_SHSTRTAB); 1651 0 stevel v[i].sh_size = shstrtab_size(&shstrtab); 1652 0 stevel v[i].sh_addralign = 1; 1653 0 stevel *doffsetp = roundup(*doffsetp, v[i].sh_addralign); 1654 0 stevel v[i].sh_offset = *doffsetp; 1655 0 stevel v[i].sh_flags = SHF_STRINGS; 1656 0 stevel v[i].sh_type = SHT_STRTAB; 1657 0 stevel 1658 0 stevel if (v[i].sh_size > datasz) { 1659 0 stevel if (data != NULL) 1660 0 stevel kmem_free(data, datasz); 1661 0 stevel 1662 0 stevel datasz = v[i].sh_size; 1663 0 stevel data = kmem_alloc(datasz, 1664 0 stevel KM_SLEEP); 1665 0 stevel } 1666 0 stevel 1667 0 stevel shstrtab_dump(&shstrtab, data); 1668 0 stevel 1669 0 stevel if ((error = core_write(vp, UIO_SYSSPACE, *doffsetp, 1670 0 stevel data, v[i].sh_size, rlimit, credp)) != 0) 1671 0 stevel goto done; 1672 0 stevel 1673 0 stevel *doffsetp += v[i].sh_size; 1674 0 stevel 1675 0 stevel done: 1676 0 stevel if (data != NULL) 1677 0 stevel kmem_free(data, datasz); 1678 0 stevel 1679 0 stevel return (error); 1680 0 stevel } 1681 0 stevel 1682 0 stevel int 1683 0 stevel elfcore(vnode_t *vp, proc_t *p, cred_t *credp, rlim64_t rlimit, int sig, 1684 0 stevel core_content_t content) 1685 0 stevel { 1686 0 stevel offset_t poffset, soffset; 1687 0 stevel Off doffset; 1688 0 stevel int error, i, nphdrs, nshdrs; 1689 0 stevel int overflow = 0; 1690 0 stevel struct seg *seg; 1691 0 stevel struct as *as = p->p_as; 1692 0 stevel union { 1693 0 stevel Ehdr ehdr; 1694 0 stevel Phdr phdr[1]; 1695 0 stevel Shdr shdr[1]; 1696 0 stevel } *bigwad; 1697 0 stevel size_t bigsize; 1698 0 stevel size_t phdrsz, shdrsz; 1699 0 stevel Ehdr *ehdr; 1700 0 stevel Phdr *v; 1701 0 stevel caddr_t brkbase; 1702 0 stevel size_t brksize; 1703 0 stevel caddr_t stkbase; 1704 0 stevel size_t stksize; 1705 0 stevel int ntries = 0; 1706 0 stevel 1707 0 stevel top: 1708 0 stevel /* 1709 0 stevel * Make sure we have everything we need (registers, etc.). 1710 0 stevel * All other lwps have already stopped and are in an orderly state. 1711 0 stevel */ 1712 0 stevel ASSERT(p == ttoproc(curthread)); 1713 0 stevel prstop(0, 0); 1714 0 stevel 1715 0 stevel AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER); 1716 0 stevel nphdrs = prnsegs(as, 0) + 2; /* two CORE note sections */ 1717 0 stevel 1718 0 stevel /* 1719 0 stevel * Count the number of section headers we're going to need. 1720 0 stevel */ 1721 0 stevel nshdrs = 0; 1722 0 stevel if (content & (CC_CONTENT_CTF | CC_CONTENT_SYMTAB)) { 1723 0 stevel (void) process_scns(content, p, credp, NULL, NULL, NULL, 0, 1724 0 stevel NULL, &nshdrs); 1725 0 stevel } 1726 0 stevel AS_LOCK_EXIT(as, &as->a_lock); 1727 0 stevel 1728 942 ahl ASSERT(nshdrs == 0 || nshdrs > 1); 1729 942 ahl 1730 942 ahl /* 1731 942 ahl * The core file contents may required zero section headers, but if 1732 942 ahl * we overflow the 16 bits allotted to the program header count in 1733 942 ahl * the ELF header, we'll need that program header at index zero. 1734 942 ahl */ 1735 942 ahl if (nshdrs == 0 && nphdrs >= PN_XNUM) 1736 942 ahl nshdrs = 1; 1737 942 ahl 1738 0 stevel phdrsz = nphdrs * sizeof (Phdr); 1739 0 stevel shdrsz = nshdrs * sizeof (Shdr); 1740 0 stevel 1741 0 stevel bigsize = MAX(sizeof (*bigwad), MAX(phdrsz, shdrsz)); 1742 0 stevel bigwad = kmem_alloc(bigsize, KM_SLEEP); 1743 0 stevel 1744 0 stevel ehdr = &bigwad->ehdr; 1745 0 stevel bzero(ehdr, sizeof (*ehdr)); 1746 0 stevel 1747 0 stevel ehdr->e_ident[EI_MAG0] = ELFMAG0; 1748 0 stevel ehdr->e_ident[EI_MAG1] = ELFMAG1; 1749 0 stevel ehdr->e_ident[EI_MAG2] = ELFMAG2; 1750 0 stevel ehdr->e_ident[EI_MAG3] = ELFMAG3; 1751 0 stevel ehdr->e_ident[EI_CLASS] = ELFCLASS; 1752 0 stevel ehdr->e_type = ET_CORE; 1753 0 stevel 1754 0 stevel #if !defined(_LP64) || defined(_ELF32_COMPAT) 1755 0 stevel 1756 0 stevel #if defined(__sparc) 1757 0 stevel ehdr->e_ident[EI_DATA] = ELFDATA2MSB; 1758 0 stevel ehdr->e_machine = EM_SPARC; 1759 0 stevel #elif defined(__i386) || defined(__i386_COMPAT) 1760 0 stevel ehdr->e_ident[EI_DATA] = ELFDATA2LSB; 1761 0 stevel ehdr->e_machine = EM_386; 1762 0 stevel #else 1763 0 stevel #error "no recognized machine type is defined" 1764 0 stevel #endif 1765 0 stevel 1766 0 stevel #else /* !defined(_LP64) || defined(_ELF32_COMPAT) */ 1767 0 stevel 1768 0 stevel #if defined(__sparc) 1769 0 stevel ehdr->e_ident[EI_DATA] = ELFDATA2MSB; 1770 0 stevel ehdr->e_machine = EM_SPARCV9; 1771 0 stevel #elif defined(__amd64) 1772 0 stevel ehdr->e_ident[EI_DATA] = ELFDATA2LSB; 1773 0 stevel ehdr->e_machine = EM_AMD64; 1774 0 stevel #else 1775 0 stevel #error "no recognized 64-bit machine type is defined" 1776 0 stevel #endif 1777 0 stevel 1778 0 stevel #endif /* !defined(_LP64) || defined(_ELF32_COMPAT) */ 1779 0 stevel 1780 942 ahl /* 1781 942 ahl * If the count of program headers or section headers or the index 1782 942 ahl * of the section string table can't fit in the mere 16 bits 1783 942 ahl * shortsightedly allotted to them in the ELF header, we use the 1784 942 ahl * extended formats and put the real values in the section header 1785 942 ahl * as index 0. 1786 942 ahl */ 1787 0 stevel ehdr->e_version = EV_CURRENT; 1788 942 ahl ehdr->e_ehsize = sizeof (Ehdr); 1789 942 ahl 1790 942 ahl if (nphdrs >= PN_XNUM) 1791 942 ahl ehdr->e_phnum = PN_XNUM; 1792 942 ahl else 1793 942 ahl ehdr->e_phnum = (unsigned short)nphdrs; 1794 942 ahl 1795 0 stevel ehdr->e_phoff = sizeof (Ehdr); 1796 0 stevel ehdr->e_phentsize = sizeof (Phdr); 1797 0 stevel 1798 0 stevel if (nshdrs > 0) { 1799 942 ahl if (nshdrs >= SHN_LORESERVE) 1800 942 ahl ehdr->e_shnum = 0; 1801 942 ahl else 1802 942 ahl ehdr->e_shnum = (unsigned short)nshdrs; 1803 942 ahl 1804 942 ahl if (nshdrs - 1 >= SHN_LORESERVE) 1805 942 ahl ehdr->e_shstrndx = SHN_XINDEX; 1806 942 ahl else 1807 942 ahl ehdr->e_shstrndx = (unsigned short)(nshdrs - 1); 1808 942 ahl 1809 942 ahl ehdr->e_shoff = ehdr->e_phoff + ehdr->e_phentsize * nphdrs; 1810 0 stevel ehdr->e_shentsize = sizeof (Shdr); 1811 0 stevel } 1812 0 stevel 1813 0 stevel if (error = core_write(vp, UIO_SYSSPACE, (offset_t)0, ehdr, 1814 0 stevel sizeof (Ehdr), rlimit, credp)) 1815 0 stevel goto done; 1816 0 stevel 1817 0 stevel poffset = sizeof (Ehdr); 1818 0 stevel soffset = sizeof (Ehdr) + phdrsz; 1819 0 stevel doffset = sizeof (Ehdr) + phdrsz + shdrsz; 1820 0 stevel 1821 0 stevel v = &bigwad->phdr[0]; 1822 0 stevel bzero(v, phdrsz); 1823 0 stevel 1824 0 stevel setup_old_note_header(&v[0], p); 1825 0 stevel v[0].p_offset = doffset = roundup(doffset, sizeof (Word)); 1826 0 stevel doffset += v[0].p_filesz; 1827 0 stevel 1828 0 stevel setup_note_header(&v[1], p); 1829 0 stevel v[1].p_offset = doffset = roundup(doffset, sizeof (Word)); 1830 0 stevel doffset += v[1].p_filesz; 1831 0 stevel 1832 0 stevel mutex_enter(&p->p_lock); 1833 0 stevel 1834 0 stevel brkbase = p->p_brkbase; 1835 0 stevel brksize = p->p_brksize; 1836 0 stevel 1837 0 stevel stkbase = p->p_usrstack - p->p_stksize; 1838 0 stevel stksize = p->p_stksize; 1839 0 stevel 1840 0 stevel mutex_exit(&p->p_lock); 1841 0 stevel 1842 0 stevel AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER); 1843 0 stevel i = 2; 1844 0 stevel for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) { 1845 0 stevel caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0); 1846 0 stevel caddr_t saddr, naddr; 1847 0 stevel void *tmp = NULL; 1848 0 stevel extern struct seg_ops segspt_shmops; 1849 0 stevel 1850 0 stevel for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) { 1851 0 stevel uint_t prot; 1852 0 stevel size_t size; 1853 0 stevel int type; 1854 0 stevel vnode_t *mvp; 1855 0 stevel 1856 0 stevel prot = pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr); 1857 0 stevel prot &= PROT_READ | PROT_WRITE | PROT_EXEC; 1858 0 stevel if ((size = (size_t)(naddr - saddr)) == 0) 1859 0 stevel continue; 1860 0 stevel if (i == nphdrs) { 1861 0 stevel overflow++; 1862 0 stevel continue; 1863 0 stevel } 1864 0 stevel v[i].p_type = PT_LOAD; 1865 0 stevel v[i].p_vaddr = (Addr)(uintptr_t)saddr; 1866 0 stevel v[i].p_memsz = size; 1867 0 stevel if (prot & PROT_READ) 1868 0 stevel v[i].p_flags |= PF_R; 1869 0 stevel if (prot & PROT_WRITE) 1870 0 stevel v[i].p_flags |= PF_W; 1871 0 stevel if (prot & PROT_EXEC) 1872 0 stevel v[i].p_flags |= PF_X; 1873 0 stevel 1874 0 stevel /* 1875 0 stevel * Figure out which mappings to include in the core. 1876 0 stevel */ 1877 0 stevel type = SEGOP_GETTYPE(seg, saddr); 1878 0 stevel 1879 0 stevel if (saddr == stkbase && size == stksize) { 1880 0 stevel if (!(content & CC_CONTENT_STACK)) 1881 0 stevel goto exclude; 1882 0 stevel 1883 0 stevel } else if (saddr == brkbase && size == brksize) { 1884 0 stevel if (!(content & CC_CONTENT_HEAP)) 1885 0 stevel goto exclude; 1886 0 stevel 1887 0 stevel } else if (seg->s_ops == &segspt_shmops) { 1888 0 stevel if (type & MAP_NORESERVE) { 1889 0 stevel if (!(content & CC_CONTENT_DISM)) 1890 0 stevel goto exclude; 1891 0 stevel } else { 1892 0 stevel if (!(content & CC_CONTENT_ISM)) 1893 0 stevel goto exclude; 1894 0 stevel } 1895 0 stevel 1896 0 stevel } else if (seg->s_ops != &segvn_ops) { 1897 0 stevel goto exclude; 1898 0 stevel 1899 0 stevel } else if (type & MAP_SHARED) { 1900 0 stevel if (shmgetid(p, saddr) != SHMID_NONE) { 1901 0 stevel if (!(content & CC_CONTENT_SHM)) 1902 0 stevel goto exclude; 1903 0 stevel 1904 0 stevel } else if (SEGOP_GETVP(seg, seg->s_base, 1905 0 stevel &mvp) != 0 || mvp == NULL || 1906 0 stevel mvp->v_type != VREG) { 1907 0 stevel if (!(content & CC_CONTENT_SHANON)) 1908 0 stevel goto exclude; 1909 0 stevel 1910 0 stevel } else { 1911 0 stevel if (!(content & CC_CONTENT_SHFILE)) 1912 0 stevel goto exclude; 1913 0 stevel } 1914 0 stevel 1915 0 stevel } else if (SEGOP_GETVP(seg, seg->s_base, &mvp) != 0 || 1916 0 stevel mvp == NULL || mvp->v_type != VREG) { 1917 0 stevel if (!(content & CC_CONTENT_ANON)) 1918 0 stevel goto exclude; 1919 0 stevel 1920 0 stevel } else if (prot == (PROT_READ | PROT_EXEC)) { 1921 0 stevel if (!(content & CC_CONTENT_TEXT)) 1922 0 stevel goto exclude; 1923 0 stevel 1924 0 stevel } else if (prot == PROT_READ) { 1925 0 stevel if (!(content & CC_CONTENT_RODATA)) 1926 0 stevel goto exclude; 1927 0 stevel 1928 0 stevel } else { 1929 0 stevel if (!(content & CC_CONTENT_DATA)) 1930 0 stevel goto exclude; 1931 0 stevel } 1932 0 stevel 1933 0 stevel doffset = roundup(doffset, sizeof (Word)); 1934 0 stevel v[i].p_offset = doffset; 1935 0 stevel v[i].p_filesz = size; 1936 0 stevel doffset += size; 1937 0 stevel exclude: 1938 0 stevel i++; 1939 0 stevel } 1940 0 stevel ASSERT(tmp == NULL); 1941 0 stevel } 1942 0 stevel AS_LOCK_EXIT(as, &as->a_lock); 1943 0 stevel 1944 0 stevel if (overflow || i != nphdrs) { 1945 0 stevel if (ntries++ == 0) { 1946 0 stevel kmem_free(bigwad, bigsize); 1947 9405 Mita overflow = 0; 1948 0 stevel goto top; 1949 0 stevel } 1950 0 stevel cmn_err(CE_WARN, "elfcore: core dump failed for " 1951 0 stevel "process %d; address space is changing", p->p_pid); 1952 0 stevel error = EIO; 1953 0 stevel goto done; 1954 0 stevel } 1955 0 stevel 1956 0 stevel if ((error = core_write(vp, UIO_SYSSPACE, poffset, 1957 0 stevel v, phdrsz, rlimit, credp)) != 0) 1958 0 stevel goto done; 1959 0 stevel 1960 0 stevel if ((error = write_old_elfnotes(p, sig, vp, v[0].p_offset, rlimit, 1961 0 stevel credp)) != 0) 1962 0 stevel goto done; 1963 0 stevel 1964 0 stevel if ((error = write_elfnotes(p, sig, vp, v[1].p_offset, rlimit, 1965 0 stevel credp, content)) != 0) 1966 0 stevel goto done; 1967 0 stevel 1968 0 stevel for (i = 2; i < nphdrs; i++) { 1969 0 stevel if (v[i].p_filesz == 0) 1970 0 stevel continue; 1971 0 stevel 1972 0 stevel /* 1973 0 stevel * If dumping out this segment fails, rather than failing 1974 0 stevel * the core dump entirely, we reset the size of the mapping 1975 0 stevel * to zero to indicate that the data is absent from the core 1976 0 stevel * file and or in the PF_SUNW_FAILURE flag to differentiate 1977 0 stevel * this from mappings that were excluded due to the core file 1978 0 stevel * content settings. 1979 0 stevel */ 1980 0 stevel if ((error = core_seg(p, vp, v[i].p_offset, 1981 0 stevel (caddr_t)(uintptr_t)v[i].p_vaddr, v[i].p_filesz, 1982 0 stevel rlimit, credp)) != 0) { 1983 0 stevel 1984 0 stevel /* 1985 0 stevel * Since the space reserved for the segment is now 1986 0 stevel * unused, we stash the errno in the first four 1987 0 stevel * bytes. This undocumented interface will let us 1988 0 stevel * understand the nature of the failure. 1989 0 stevel */ 1990 0 stevel (void) core_write(vp, UIO_SYSSPACE, v[i].p_offset, 1991 0 stevel &error, sizeof (error), rlimit, credp); 1992 0 stevel 1993 0 stevel v[i].p_filesz = 0; 1994 0 stevel v[i].p_flags |= PF_SUNW_FAILURE; 1995 0 stevel if ((error = core_write(vp, UIO_SYSSPACE, 1996 0 stevel poffset + sizeof (v[i]) * i, &v[i], sizeof (v[i]), 1997 0 stevel rlimit, credp)) != 0) 1998 0 stevel goto done; 1999 0 stevel } 2000 0 stevel } 2001 0 stevel 2002 0 stevel if (nshdrs > 0) { 2003 0 stevel bzero(&bigwad->shdr[0], shdrsz); 2004 0 stevel 2005 942 ahl if (nshdrs >= SHN_LORESERVE) 2006 942 ahl bigwad->shdr[0].sh_size = nshdrs; 2007 942 ahl 2008 942 ahl if (nshdrs - 1 >= SHN_LORESERVE) 2009 942 ahl bigwad->shdr[0].sh_link = nshdrs - 1; 2010 942 ahl 2011 942 ahl if (nphdrs >= PN_XNUM) 2012 942 ahl bigwad->shdr[0].sh_info = nphdrs; 2013 942 ahl 2014 942 ahl if (nshdrs > 1) { 2015 942 ahl AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER); 2016 942 ahl if ((error = process_scns(content, p, credp, vp, 2017 942 ahl &bigwad->shdr[0], nshdrs, rlimit, &doffset, 2018 942 ahl NULL)) != 0) { 2019 942 ahl AS_LOCK_EXIT(as, &as->a_lock); 2020 942 ahl goto done; 2021 942 ahl } 2022 0 stevel AS_LOCK_EXIT(as, &as->a_lock); 2023 0 stevel } 2024 0 stevel 2025 0 stevel if ((error = core_write(vp, UIO_SYSSPACE, soffset, 2026 0 stevel &bigwad->shdr[0], shdrsz, rlimit, credp)) != 0) 2027 0 stevel goto done; 2028 0 stevel } 2029 0 stevel 2030 0 stevel done: 2031 0 stevel kmem_free(bigwad, bigsize); 2032 0 stevel return (error); 2033 0 stevel } 2034 0 stevel 2035 0 stevel #ifndef _ELF32_COMPAT 2036 0 stevel 2037 0 stevel static struct execsw esw = { 2038 0 stevel #ifdef _LP64 2039 0 stevel elf64magicstr, 2040 0 stevel #else /* _LP64 */ 2041 0 stevel elf32magicstr, 2042 0 stevel #endif /* _LP64 */ 2043 0 stevel 0, 2044 0 stevel 5, 2045 0 stevel elfexec, 2046 0 stevel elfcore 2047 0 stevel }; 2048 0 stevel 2049 0 stevel static struct modlexec modlexec = { 2050 7838 Roger &mod_execops, "exec module for elf", &esw 2051 0 stevel }; 2052 0 stevel 2053 0 stevel #ifdef _LP64 2054 0 stevel extern int elf32exec(vnode_t *vp, execa_t *uap, uarg_t *args, 2055 0 stevel intpdata_t *idatap, int level, long *execsz, 2056 2712 nn35248 int setid, caddr_t exec_file, cred_t *cred, 2057 2712 nn35248 int brand_action); 2058 0 stevel extern int elf32core(vnode_t *vp, proc_t *p, cred_t *credp, 2059 0 stevel rlim64_t rlimit, int sig, core_content_t content); 2060 0 stevel 2061 0 stevel static struct execsw esw32 = { 2062 0 stevel elf32magicstr, 2063 0 stevel 0, 2064 0 stevel 5, 2065 0 stevel elf32exec, 2066 0 stevel elf32core 2067 0 stevel }; 2068 0 stevel 2069 0 stevel static struct modlexec modlexec32 = { 2070 0 stevel &mod_execops, "32-bit exec module for elf", &esw32 2071 0 stevel }; 2072 0 stevel #endif /* _LP64 */ 2073 0 stevel 2074 0 stevel static struct modlinkage modlinkage = { 2075 0 stevel MODREV_1, 2076 0 stevel (void *)&modlexec, 2077 0 stevel #ifdef _LP64 2078 0 stevel (void *)&modlexec32, 2079 0 stevel #endif /* _LP64 */ 2080 0 stevel NULL 2081 0 stevel }; 2082 0 stevel 2083 0 stevel int 2084 0 stevel _init(void) 2085 0 stevel { 2086 0 stevel return (mod_install(&modlinkage)); 2087 0 stevel } 2088 0 stevel 2089 0 stevel int 2090 0 stevel _fini(void) 2091 0 stevel { 2092 0 stevel return (mod_remove(&modlinkage)); 2093 0 stevel } 2094 0 stevel 2095 0 stevel int 2096 0 stevel _info(struct modinfo *modinfop) 2097 0 stevel { 2098 0 stevel return (mod_info(&modlinkage, modinfop)); 2099 0 stevel } 2100 0 stevel 2101 0 stevel #endif /* !_ELF32_COMPAT */ 2102
Indexes created Thu Nov 26 09:50:34 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.