sys/kern/exec_macho.c

   1 /*      $NetBSD: exec_macho.c,v 1.41 2008/01/03 14:25:50 yamt Exp $     */
   2
   3 /*-
   4  * Copyright (c) 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.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: exec_macho.c,v 1.41 2008/01/03 14:25:50 yamt Exp $");
  34
  35 #include <sys/param.h>
  36 #include <sys/proc.h>
  37 #include <sys/malloc.h>
  38 #include <sys/namei.h>
  39 #include <sys/vnode.h>
  40 #include <sys/exec.h>
  41 #include <sys/exec_macho.h>
  42 #include <sys/syscall.h>
  43 #include <sys/signalvar.h>
  44 #include <sys/resourcevar.h>
  45 #include <sys/mount.h>
  46 #include <sys/stat.h>
  47
  48 #include <uvm/uvm.h>
  49
  50 #ifdef DEBUG_MACHO
  51 #define DPRINTF(a) printf a
  52 #else
  53 #define DPRINTF(a)
  54 #endif
  55
  56 static int exec_macho_load_segment(struct exec_package *, struct vnode *,
  57     u_long, struct exec_macho_segment_command *, int);
  58 static int exec_macho_load_dylinker(struct lwp *, struct exec_package *,
  59     struct exec_macho_dylinker_command *, u_long *, int);
  60 static int exec_macho_load_dylib(struct lwp *, struct exec_package *,
  61     struct exec_macho_dylib_command *, int);
  62 static u_long exec_macho_load_thread(struct exec_macho_thread_command *);
  63 static int exec_macho_load_file(struct lwp *, struct exec_package *,
  64     const char *, u_long *, int, int, int);
  65 static int exec_macho_load_vnode(struct lwp *, struct exec_package *,
  66     struct vnode *, struct exec_macho_fat_header *, u_long *, int, int, int);
  67
  68 #ifdef DEBUG_MACHO
  69 static void
  70 exec_macho_print_segment_command(struct exec_macho_segment_command *ls)
  71 {
  72         printf("ls.cmd 0x%lx\n", ls->cmd);
  73         printf("ls.cmdsize 0x%ld\n", ls->cmdsize);
  74         printf("ls.segname %s\n", ls->segname);
  75         printf("ls.vmaddr 0x%lx\n", ls->vmaddr);
  76         printf("ls.vmsize %ld\n", ls->vmsize);
  77         printf("ls.fileoff 0x%lx\n", ls->fileoff);
  78         printf("ls.filesize %ld\n", ls->filesize);
  79         printf("ls.maxprot 0x%x\n", ls->maxprot);
  80         printf("ls.initprot 0x%x\n", ls->initprot);
  81         printf("ls.nsects %ld\n", ls->nsects);
  82         printf("ls.flags 0x%lx\n", ls->flags);
  83 }
  84
  85 static void
  86 exec_macho_print_fat_header(struct exec_macho_fat_header *fat)
  87 {
  88         printf("fat.magic 0x%x\n", be32toh(fat->magic));
  89         printf("fat.nfat_arch %d\n", be32toh(fat->nfat_arch));
  90 }
  91
  92 static void
  93 exec_macho_print_fat_arch(struct exec_macho_fat_arch *arch)
  94 {
  95         printf("arch.cputype %x\n", be32toh(arch->cputype));
  96         printf("arch.cpusubtype %d\n", be32toh(arch->cpusubtype));
  97         printf("arch.offset 0x%x\n", (int32_t)be32toh(arch->offset));
  98         printf("arch.size %d\n", (int32_t)be32toh(arch->size));
  99         printf("arch.align 0x%x\n", (int32_t)be32toh(arch->align));
 100 }
 101
 102 static void
 103 exec_macho_print_object_header(struct exec_macho_object_header *hdr)
 104 {
 105         printf("hdr.magic 0x%lx\n", hdr->magic);
 106         printf("hdr.cputype %x\n", hdr->cputype);
 107         printf("hdr.cpusubtype %d\n", hdr->cpusubtype);
 108         printf("hdr.filetype 0x%lx\n", hdr->filetype);
 109         printf("hdr.ncmds %ld\n", hdr->ncmds);
 110         printf("hdr.sizeofcmds %ld\n", hdr->sizeofcmds);
 111         printf("hdr.flags 0x%lx\n", hdr->flags);
 112 }
 113
 114 static void
 115 exec_macho_print_load_command(struct exec_macho_load_command *lc)
 116 {
 117         printf("lc.cmd %lx\n", lc->cmd);
 118         printf("lc.cmdsize %ld\n", lc->cmdsize);
 119 }
 120
 121 static void
 122 exec_macho_print_dylinker_command(struct exec_macho_dylinker_command *dy)
 123 {
 124         printf("dy.cmd %lx\n", dy->cmd);
 125         printf("dy.cmdsize %ld\n", dy->cmdsize);
 126         printf("dy.name.offset 0x%lx\n", dy->name.offset);
 127         printf("dy.name %s\n", ((char *)dy) + dy->name.offset);
 128 }
 129
 130 static void
 131 exec_macho_print_dylib_command(struct exec_macho_dylib_command *dy)
 132 {
 133         printf("dy.cmd %lx\n", dy->cmd);
 134         printf("dy.cmdsize %ld\n", dy->cmdsize);
 135         printf("dy.dylib.name.offset 0x%lx\n", dy->dylib.name.offset);
 136         printf("dy.dylib.name %s\n", ((char *)dy) + dy->dylib.name.offset);
 137         printf("dy.dylib.timestamp %ld\n", dy->dylib.timestamp);
 138         printf("dy.dylib.current_version %ld\n", dy->dylib.current_version);
 139         printf("dy.dylib.compatibility_version %ld\n",
 140             dy->dylib.compatibility_version);
 141 }
 142
 143 static void
 144 exec_macho_print_thread_command(struct exec_macho_thread_command *th)
 145 {
 146         printf("th.cmd %lx\n", th->cmd);
 147         printf("th.cmdsize %ld\n", th->cmdsize);
 148         printf("th.flavor %ld\n", th->flavor);
 149         printf("th.count %ld\n", th->count);
 150 }
 151 #endif /* DEBUG_MACHO */
 152
 153 static int
 154 exec_macho_load_segment(struct exec_package *epp, struct vnode *vp,
 155     u_long foff, struct exec_macho_segment_command *ls, int type)
 156 {
 157         int flags;
 158         struct exec_macho_emul_arg *emea;
 159         u_long addr = trunc_page(ls->vmaddr), size = round_page(ls->filesize);
 160
 161         emea = (struct exec_macho_emul_arg *)epp->ep_emul_arg;
 162
 163         flags = VMCMD_BASE;
 164
 165 #ifdef DEBUG_MACHO
 166         exec_macho_print_segment_command(ls);
 167 #endif
 168         if (strcmp(ls->segname, "__PAGEZERO") == 0)
 169                 return 0;
 170
 171         if (strcmp(ls->segname, "__TEXT") != 0 &&
 172             strcmp(ls->segname, "__DATA") != 0 &&
 173             strcmp(ls->segname, "__LOCK") != 0 &&
 174             strcmp(ls->segname, "__OBJC") != 0 &&
 175             strcmp(ls->segname, "__CGSERVER") != 0 &&
 176             strcmp(ls->segname, "__IMAGE") != 0 &&
 177             strcmp(ls->segname, "__LINKEDIT") != 0) {
 178                 DPRINTF(("Unknown exec_macho segment %s\n", ls->segname));
 179                 return ENOEXEC;
 180         }
 181         if (type == MACHO_MOH_EXECUTE) {
 182                 if (strcmp(ls->segname, "__TEXT") == 0) {
 183                         epp->ep_taddr = addr;
 184                         epp->ep_tsize = round_page(ls->vmsize);
 185                         emea->macho_hdr =
 186                             (struct exec_macho_object_header *)addr;
 187                 }
 188                 if ((strcmp(ls->segname, "__DATA") == 0) ||
 189                     (strcmp(ls->segname, "__OBJC") == 0) ||
 190                     (strcmp(ls->segname, "__IMAGE") == 0) ||
 191                     (strcmp(ls->segname, "__CGSERVER") == 0)) {
 192                         epp->ep_daddr = addr;
 193                         epp->ep_dsize = round_page(ls->vmsize);
 194                 }
 195         }
 196
 197         /*
 198          * Some libraries do not have a load base address. The Darwin
 199          * kernel seems to skip them, and dyld will do the job.
 200          */
 201         if (addr == 0)
 202                 return ENOMEM;
 203
 204         if (ls->filesize > 0) {
 205                 NEW_VMCMD2(&epp->ep_vmcmds, vmcmd_map_pagedvn, size,
 206                     addr, vp, (off_t)(ls->fileoff + foff),
 207                     ls->initprot, flags);
 208                 DPRINTF(("map(0x%lx, 0x%lx, %o, fd@ 0x%lx)\n",
 209                     addr, size, ls->initprot,
 210                     ls->fileoff + foff));
 211         }
 212
 213         if (ls->vmsize > size) {
 214                 addr += size;
 215                 size = round_page(ls->vmsize - size);
 216                 NEW_VMCMD2(&epp->ep_vmcmds, vmcmd_map_zero, size,
 217                     addr, vp, (off_t)(ls->fileoff + foff),
 218                     ls->initprot, flags);
 219                 DPRINTF(("mmap(0x%lx, 0x%lx, %o, zero)\n",
 220                     ls->vmaddr + ls->filesize, ls->vmsize - ls->filesize,
 221                     ls->initprot));
 222         }
 223         return 0;
 224 }
 225
 226
 227 static int
 228 exec_macho_load_dylinker(struct lwp *l, struct exec_package *epp,
 229     struct exec_macho_dylinker_command *dy, u_long *entry, int depth)
 230 {
 231         struct exec_macho_emul_arg *emea;
 232         const char *name = ((const char *)dy) + dy->name.offset;
 233         char path[MAXPATHLEN];
 234         int error;
 235 #ifdef DEBUG_MACHO
 236         exec_macho_print_dylinker_command(dy);
 237 #endif
 238         emea = (struct exec_macho_emul_arg *)epp->ep_emul_arg;
 239
 240         (void)snprintf(path, sizeof(path), "%s%s", emea->path, name);
 241         DPRINTF(("loading linker %s\n", path));
 242         if ((error = exec_macho_load_file(l, epp, path, entry,
 243             MACHO_MOH_DYLINKER, 1, depth)) != 0)
 244                 return error;
 245         return 0;
 246 }
 247
 248 static int
 249 exec_macho_load_dylib(struct lwp *l, struct exec_package *epp,
 250     struct exec_macho_dylib_command *dy, int depth)
 251 {
 252         struct exec_macho_emul_arg *emea;
 253         const char *name = ((const char *)dy) + dy->dylib.name.offset;
 254         char path[MAXPATHLEN];
 255         int error;
 256         u_long entry;
 257 #ifdef DEBUG_MACHO
 258         exec_macho_print_dylib_command(dy);
 259 #endif
 260         emea = (struct exec_macho_emul_arg *)epp->ep_emul_arg;
 261         (void)snprintf(path, sizeof(path), "%s%s", emea->path, name);
 262         DPRINTF(("loading library %s\n", path));
 263         if ((error = exec_macho_load_file(l, epp, path, &entry,
 264             MACHO_MOH_DYLIB, 0, depth)) != 0)
 265                 return error;
 266         return 0;
 267 }
 268
 269 static u_long
 270 exec_macho_load_thread(struct exec_macho_thread_command *th)
 271 {
 272 #ifdef DEBUG_MACHO
 273         exec_macho_print_thread_command(th);
 274 #endif
 275         return exec_macho_thread_entry(th);
 276 }
 277
 278 /*
 279  * exec_macho_load_file(): Load a macho-binary. This is used
 280  * for the dynamic linker and library recursive loading.
 281  */
 282 static int
 283 exec_macho_load_file(struct lwp *l, struct exec_package *epp,
 284     const char *path, u_long *entry, int type, int recursive, int depth)
 285 {
 286         int error;
 287         struct nameidata nd;
 288         struct vnode *vp;
 289         struct vattr attr;
 290         struct exec_macho_fat_header fat;
 291
 292         /*
 293          * Check for excessive rercursive loading
 294          */
 295         if (depth++ > 6)
 296                 return E2BIG;
 297
 298         /*
 299          * 1. open file
 300          * 2. read filehdr
 301          * 3. map text, data, and bss out of it using VM_*
 302          */
 303         NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, path);
 304         if ((error = namei(&nd)) != 0)
 305                 return error;
 306         vp = nd.ni_vp;
 307
 308         /*
 309          * Similarly, if it's not marked as executable, or it's not a regular
 310          * file, we don't allow it to be used.
 311          */
 312         if (vp->v_type != VREG) {
 313                 error = EACCES;
 314                 goto badunlock;
 315         }
 316
 317         error = vn_marktext(vp);
 318         if (error)
 319                 return (error);
 320
 321         if ((error = VOP_ACCESS(vp, VEXEC, l->l_cred)) != 0)
 322                 goto badunlock;
 323
 324         /* get attributes */
 325         if ((error = VOP_GETATTR(vp, &attr, l->l_cred)) != 0)
 326                 goto badunlock;
 327
 328 #ifdef notyet /* XXX cgd 960926 */
 329         XXX cgd 960926: (maybe) VOP_OPEN it (and VOP_CLOSE in copyargs?)
 330 #endif
 331         VOP_UNLOCK(vp, 0);
 332
 333         if ((error = exec_read_from(l, vp, 0, &fat, sizeof(fat))) != 0)
 334                 goto bad;
 335
 336         if ((error = exec_macho_load_vnode(l, epp, vp, &fat,
 337             entry, type, recursive, depth)) != 0)
 338                 goto bad;
 339
 340         vrele(vp);
 341         return 0;
 342
 343 badunlock:
 344         VOP_UNLOCK(vp, 0);
 345
 346 bad:
 347 #ifdef notyet /* XXX cgd 960926 */
 348         (maybe) VOP_CLOSE it
 349 #endif
 350         vrele(vp);
 351         return error;
 352 }
 353
 354 /*
 355  * exec_macho_load_vnode(): Map a file from the given vnode.
 356  * The fat signature is checked,
 357  * and it will return the address of the entry point in entry.
 358  * The type determines what we are loading, a dynamic linker,
 359  * a dynamic library, or a binary. We use that to guess at
 360  * the entry point.
 361  */
 362 static int
 363 exec_macho_load_vnode(struct lwp *l, struct exec_package *epp,
 364     struct vnode *vp, struct exec_macho_fat_header *fat, u_long *entry,
 365     int type, int recursive, int depth)
 366 {
 367         u_long aoffs, offs;
 368         struct exec_macho_fat_arch arch;
 369         struct exec_macho_object_header hdr;
 370         struct exec_macho_load_command lc;
 371         struct exec_macho_emul_arg *emea;
 372         int error = ENOEXEC, i;
 373         size_t size;
 374         void *bf = &lc;
 375         uint32_t *sc = NULL;
 376
 377 #ifdef DEBUG_MACHO
 378         exec_macho_print_fat_header(fat);
 379 #endif
 380
 381         switch (fat->magic) {
 382         case MACHO_FAT_MAGIC:
 383                 for (i = 0; i < be32toh(fat->nfat_arch); i++, arch) {
 384                         if ((error = exec_read_from(l, vp, sizeof(*fat) +
 385                             sizeof(arch) * i, &arch, sizeof(arch))) != 0)
 386                                 goto bad;
 387 #ifdef DEBUG_MACHO
 388                         exec_macho_print_fat_arch(&arch);
 389 #endif
 390                         for (sc = exec_macho_supported_cpu; *sc; sc++)
 391                                 if (*sc == be32toh(arch.cputype))
 392                                         break;
 393
 394                         if (sc != NULL)
 395                                 break;
 396                 }
 397                 if (sc == NULL || *sc == 0) {
 398                         DPRINTF(("CPU %d not supported by this binary",
 399                                 be32toh(arch.cputype)));
 400                         goto bad;
 401                 }
 402                 break;
 403
 404         case MACHO_MOH_MAGIC:
 405                 /*
 406                  * This is not a FAT Mach-O binary, the file starts
 407                  * with the object header.
 408                  */
 409                 arch.offset = 0;
 410                 break;
 411
 412         default:
 413                 DPRINTF(("bad exec_macho magic %x\n", fat->magic));
 414                 goto bad;
 415                 break;
 416         }
 417
 418         if ((error = exec_read_from(l, vp, be32toh(arch.offset), &hdr,
 419             sizeof(hdr))) != 0)
 420                 goto bad;
 421
 422         if (hdr.magic != MACHO_MOH_MAGIC) {
 423                 DPRINTF(("bad exec_macho header magic %lx\n", hdr.magic));
 424                 goto bad;
 425         }
 426
 427 #ifdef DEBUG_MACHO
 428         exec_macho_print_object_header(&hdr);
 429 #endif
 430         switch (hdr.filetype) {
 431         case MACHO_MOH_PRELOAD:
 432         case MACHO_MOH_EXECUTE:
 433         case MACHO_MOH_DYLINKER:
 434         case MACHO_MOH_DYLIB:
 435         case MACHO_MOH_BUNDLE:
 436                 break;
 437         default:
 438                 DPRINTF(("Unsupported exec_macho filetype 0x%lx\n",
 439                     hdr.filetype));
 440                 goto bad;
 441         }
 442
 443
 444         aoffs = be32toh(arch.offset);
 445         offs = aoffs + sizeof(hdr);
 446         size = sizeof(lc);
 447         for (i = 0; i < hdr.ncmds; i++) {
 448                 if ((error = exec_read_from(l, vp, offs, &lc, sizeof(lc))) != 0)
 449                         goto bad;
 450
 451 #ifdef DEBUG_MACHO
 452                 exec_macho_print_load_command(&lc);
 453 #endif
 454                 if (size < lc.cmdsize) {
 455                         if (lc.cmdsize > 4096) {
 456                                 DPRINTF(("Bad command size %ld\n", lc.cmdsize));
 457                                 goto bad;
 458                         }
 459                         if (bf != &lc)
 460                                 free(bf, M_TEMP);
 461                         bf = malloc(size = lc.cmdsize, M_TEMP, M_WAITOK);
 462                 }
 463
 464                 if ((error = exec_read_from(l, vp, offs, bf, lc.cmdsize)) != 0)
 465                         goto bad;
 466
 467                 switch (lc.cmd) {
 468                 case MACHO_LC_SEGMENT:
 469                         error = exec_macho_load_segment(epp, vp, aoffs,
 470                             (struct exec_macho_segment_command *)bf, type);
 471
 472                         switch(error) {
 473                         case ENOMEM:    /* Just skip, dyld will load it */
 474                                 DPRINTF(("load segment failed, skipping\n"));
 475                                 i = hdr.ncmds;
 476                                 break;
 477                         case 0:         /* No error, carry on loading file */
 478                                 break;
 479                         default:        /* Abort file load */
 480                                 DPRINTF(("load segment failed, aborting\n"));
 481                                 goto bad;
 482                                 break;
 483                         }
 484                         break;
 485                 case MACHO_LC_LOAD_DYLINKER:
 486                         if ((error = exec_macho_load_dylinker(l, epp,
 487                             (struct exec_macho_dylinker_command *)bf,
 488                             entry, depth)) != 0) {
 489                                 DPRINTF(("load linker failed\n"));
 490                                 goto bad;
 491                         }
 492                         emea = (struct exec_macho_emul_arg *)epp->ep_emul_arg;
 493                         emea->dynamic = 1;
 494                         break;
 495                 case MACHO_LC_LOAD_DYLIB:
 496                         /*
 497                          * We should only load libraries required by the
 498                          * binary we want to load, not libraries required
 499                          * by theses libraries.
 500                          */
 501                         if (recursive == 0)
 502                                 break;
 503                         if ((error = exec_macho_load_dylib(l, epp,
 504                             (struct exec_macho_dylib_command *)bf,
 505                             depth)) != 0) {
 506                                 DPRINTF(("load dylib failed\n"));
 507                                 goto bad;
 508                         }
 509                         break;
 510
 511                 case MACHO_LC_THREAD:
 512                 case MACHO_LC_UNIXTHREAD:
 513                         if (type == MACHO_MOH_DYLINKER || *entry == 0) {
 514                                 *entry = exec_macho_load_thread(
 515                                     (struct exec_macho_thread_command *)bf);
 516                         } else {
 517                                 (void)exec_macho_load_thread(
 518                                     (struct exec_macho_thread_command *)bf);
 519                         }
 520                         break;
 521
 522                 case MACHO_LC_ID_DYLINKER:
 523                 case MACHO_LC_ID_DYLIB:
 524                 case MACHO_LC_SYMTAB:
 525                 case MACHO_LC_DYSYMTAB:
 526                         break;
 527                 default:
 528                         DPRINTF(("Unhandled exec_macho command 0x%lx\n",
 529                             lc.cmd));
 530                         break;
 531                 }
 532                 offs += lc.cmdsize;
 533         }
 534         error = 0;
 535 bad:
 536         if (bf != &lc)
 537                 free(bf, M_TEMP);
 538         return error;
 539 }
 540
 541 /*
 542  * exec_macho_makecmds(): Prepare an Mach-O binary's exec package
 543  *
 544  * First, set of the various offsets/lengths in the exec package.
 545  *
 546  * Then, mark the text image busy (so it can be demand paged) or error
 547  * out if this is not possible.  Finally, set up vmcmds for the
 548  * text, data, bss, and stack segments.
 549  */
 550 int
 551 exec_macho_makecmds(struct lwp *l, struct exec_package *epp)
 552 {
 553         struct exec_macho_fat_header *fat = epp->ep_hdr;
 554         struct exec_macho_emul_arg *emea;
 555         int error;
 556
 557         if (epp->ep_hdrvalid < sizeof(*fat))
 558                 return ENOEXEC;
 559
 560         /*
 561          * Check mount point.  Though we're not trying to exec this binary,
 562          * we will be executing code from it, so if the mount point
 563          * disallows execution or set-id-ness, we punt or kill the set-id.
 564          */
 565         if (epp->ep_vp->v_mount->mnt_flag & MNT_NOEXEC)
 566                 return EACCES;
 567
 568         if (epp->ep_vp->v_mount->mnt_flag & MNT_NOSUID)
 569                 epp->ep_vap->va_mode &= ~(S_ISUID | S_ISGID);
 570
 571         error = vn_marktext(epp->ep_vp);
 572         if (error)
 573                 return (error);
 574
 575         emea = malloc(sizeof(struct exec_macho_emul_arg), M_TEMP, M_WAITOK);
 576         epp->ep_emul_arg = (void *)emea;
 577         emea->dynamic = 0;
 578
 579         if (!epp->ep_esch->u.mach_probe_func)
 580                 emea->path = "/";
 581         else {
 582             if ((error = (*epp->ep_esch->u.mach_probe_func)(&emea->path)) != 0)
 583                     goto bad2;
 584         }
 585
 586         /*
 587          * Make sure the underlying functions will not get
 588          * a random value here. 0 means that no entry point
 589          * has been found yet.
 590          */
 591         epp->ep_entry = 0;
 592
 593         if ((error = exec_macho_load_vnode(l, epp, epp->ep_vp, fat,
 594             &epp->ep_entry, MACHO_MOH_EXECUTE, 1, 0)) != 0)
 595                 goto bad;
 596
 597         /*
 598          * stash a copy of the program name in epp->ep_emul_arg because
 599          * we will need it later.
 600          */
 601         if ((error = copyinstr(epp->ep_name, emea->filename,
 602             MAXPATHLEN, NULL)) != 0) {
 603                 DPRINTF(("Copyinstr %p failed\n", epp->ep_name));
 604                 goto bad;
 605         }
 606
 607         return (*epp->ep_esch->es_setup_stack)(l, epp);
 608 bad:
 609         kill_vmcmds(&epp->ep_vmcmds);
 610 bad2:
 611         free(emea, M_TEMP);
 612         return error;
 613 }