root/compat/osf1/osf1_exec.c

DEFINITIONS

1. osf1_exec_ecoff_hook
2. osf1_copyargs
3. osf1_exec_ecoff_dynamic

    1 /* $OpenBSD: osf1_exec.c,v 1.5 2004/06/22 23:52:18 jfb Exp $ */
    2 /* $NetBSD$ */
    4 /*
    5  * Copyright (c) 1999 Christopher G. Demetriou.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Christopher G. Demetriou
   18  *      for the NetBSD Project.
   19  * 4. The name of the author may not be used to endorse or promote products
   20  *    derived from this software without specific prior written permission
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   32  */
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/kernel.h>
   37 #include <sys/proc.h>
   38 #include <sys/malloc.h>
   39 #include <sys/namei.h>
   40 #include <sys/vnode.h>
   41 #include <sys/mount.h>
   42 #include <sys/exec.h>
   43 #include <sys/exec_ecoff.h>
   44 #include <sys/signalvar.h>
   45 #include <sys/fcntl.h>
   46 #include <sys/stat.h>
   48 #include <compat/osf1/osf1.h>
   49 #include <compat/osf1/osf1_syscall.h>
   50 #include <compat/osf1/osf1_util.h>
   51 #include <compat/osf1/osf1_cvt.h>
   53 extern int scdebug;
   54 extern char *osf1_syscallnames[];
   57 struct osf1_exec_emul_arg {
   58         int        flags;
   59 #define OSF1_EXEC_EMUL_FLAGS_HAVE_LOADER        0x01
   61         char        exec_name[MAXPATHLEN+1];
   62         char        loader_name[MAXPATHLEN+1];
   63 };
   65 static void *osf1_copyargs(struct exec_package *pack,
   66         struct ps_strings *arginfo, void *stack, void *argp);
   67 int osf1_exec_ecoff_hook(struct proc *, struct exec_package *);
   68 static int osf1_exec_ecoff_dynamic(struct proc *, struct exec_package *);
   70 #define MAX_AUX_ENTRIES                4        /* max we'll ever push (right now) */
   72 extern struct sysent osf1_sysent[];
   73 extern void cpu_exec_ecoff_setregs(struct proc *, struct exec_package *,
u_long, register_t *);
   75 extern char osf1_sigcode[], osf1_esigcode[];
   77 struct emul emul_osf1 = {
   78         "osf1",
NULL,
sendsig,
OSF1_SYS_syscall,
OSF1_SYS_MAXSYSCALL,
osf1_sysent,   
   84 #ifdef SYSCALL_DEBUG
osf1_syscallnames,
   86 #else
NULL,
   88 #endif
   89         0,
osf1_copyargs,
cpu_exec_ecoff_setregs,
NULL,
osf1_sigcode,
osf1_esigcode,
   95 };
   97 int
osf1_exec_ecoff_hook(struct proc *p, struct exec_package *epp)
   99 {
  100         struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr;
  101         struct osf1_exec_emul_arg *emul_arg;
  102         int error;
  104         /* if we're here and we're exec-able at all, we're an OSF/1 binary */
epp->ep_emul = &emul_osf1;
  107         /* set up the exec package emul arg as appropriate */
emul_arg = malloc(sizeof *emul_arg, M_TEMP, M_WAITOK);
epp->ep_emul_arg = emul_arg;
emul_arg->flags = 0;
  112         if (epp->ep_ndp->ni_segflg == UIO_SYSSPACE)
error = copystr(epp->ep_ndp->ni_dirp, emul_arg->exec_name,
MAXPATHLEN + 1, NULL);
  115         else
error = copyinstr(epp->ep_ndp->ni_dirp, emul_arg->exec_name,
MAXPATHLEN + 1, NULL);
  118 #ifdef DIAGNOSTIC
  119         if (error != 0)
panic("osf1_exec_ecoff_hook: copyinstr failed");
  121 #endif
  123         /* do any special object file handling */
  124         switch (execp->f.f_flags & ECOFF_FLAG_OBJECT_TYPE_MASK) {
  125         case ECOFF_OBJECT_TYPE_SHARABLE:
  126                 /* can't exec a shared library! */
uprintf("can't execute OSF/1 shared libraries\n");
error = ENOEXEC;
  129                 break;
  131         case ECOFF_OBJECT_TYPE_CALL_SHARED:
error = osf1_exec_ecoff_dynamic(p, epp);
  133                 break;
  135         default:
  136                 /* just let the normal ECOFF handlers deal with it. */
error = 0;
  138                 break;
  139         }
  141         if (error) {
free(epp->ep_emul_arg, M_TEMP);
epp->ep_emul_arg = NULL;
kill_vmcmds(&epp->ep_vmcmds);           /* if any */
  145         }
  147         return (error);
  148 }
  150 /*
  151  * copy arguments onto the stack in the normal way, then copy out
  152  * any ELF-like AUX entries used by the dynamic loading scheme.
  153  */
  154 static void *
osf1_copyargs(pack, arginfo, stack, argp)
  156         struct exec_package *pack;
  157         struct ps_strings *arginfo;
  158         void *stack;
  159         void *argp;
  160 {
  161         struct proc *p = curproc;                       /* XXX !!! */
  162         struct osf1_exec_emul_arg *emul_arg = pack->ep_emul_arg;
  163         struct osf1_auxv ai[MAX_AUX_ENTRIES], *a;
  164         char *prognameloc, *loadernameloc;
size_t len;
stack = copyargs(pack, arginfo, stack, argp);
  168         if (!stack)
  169                 goto bad;
a = ai;
memset(ai, 0, sizeof ai);
prognameloc = (char *)stack + sizeof ai;
  175         if (copyoutstr(emul_arg->exec_name, prognameloc, MAXPATHLEN + 1, NULL))
  176             goto bad;
a->a_type = OSF1_AT_EXEC_FILENAME;
a->a_un.a_ptr = prognameloc;
a++;
  181         /*
  182          * if there's a loader, push additional auxv entries on the stack.
  183          */
  184         if (emul_arg->flags & OSF1_EXEC_EMUL_FLAGS_HAVE_LOADER) {
loadernameloc = prognameloc + MAXPATHLEN + 1;
  187                 if (copyoutstr(emul_arg->loader_name, loadernameloc,
MAXPATHLEN + 1, NULL))
  189                         goto bad;
a->a_type = OSF1_AT_EXEC_LOADER_FILENAME;
a->a_un.a_ptr = loadernameloc;
a++;
a->a_type = OSF1_AT_EXEC_LOADER_FLAGS;
a->a_un.a_val = 0;
  196                 if (pack->ep_vap->va_mode & S_ISUID)
a->a_un.a_val |= OSF1_LDR_EXEC_SETUID_F;
  198                 if (pack->ep_vap->va_mode & S_ISGID)
a->a_un.a_val |= OSF1_LDR_EXEC_SETGID_F;
  200                 if (p->p_flag & P_TRACED)
a->a_un.a_val |= OSF1_LDR_EXEC_PTRACE_F;
a++;
  203         }
a->a_type = OSF1_AT_NULL;
a->a_un.a_val = 0;
a++;
len = (a - ai) * sizeof(struct osf1_auxv);
  210         if (copyout(ai, stack, len))
  211                 goto bad;
stack = (caddr_t)stack + len;
out:
free(pack->ep_emul_arg, M_TEMP);
pack->ep_emul_arg = NULL;
  217         return stack;
bad:
stack = NULL;
  221         goto out;
  222 }
  224 static int
osf1_exec_ecoff_dynamic(struct proc *p, struct exec_package *epp)
  226 {
  227         struct osf1_exec_emul_arg *emul_arg = epp->ep_emul_arg;
  228         struct ecoff_exechdr ldr_exechdr;
  229         struct nameidata nd;
  230         struct vnode *ldr_vp;
  231         char *pathbuf;
size_t resid;  
  233         int error;
  235         /*
  236          * locate the loader
  237          */
error = emul_find(p, NULL, osf1_emul_path,
OSF1_LDR_EXEC_DEFAULT_LOADER, &pathbuf, 0);
  240         /* includes /emul/osf1 if appropriate */
strlcpy(emul_arg->loader_name, pathbuf, sizeof(emul_arg->loader_name));
emul_arg->flags |= OSF1_EXEC_EMUL_FLAGS_HAVE_LOADER;
  243         if (!error)
free((char *)pathbuf, M_TEMP);
uprintf("loader is %s\n", emul_arg->loader_name);
  248         /*
  249          * open the loader, see if it's an ECOFF executable,
  250          * make sure the object type is amenable, then arrange to
  251          * load it up.
  252          */
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
emul_arg->loader_name, p);
  255         if ((error = namei(&nd)) != 0)
  256                 goto bad_no_vp;
ldr_vp = nd.ni_vp;
  259         /*
  260          * Basic access checks.  Reject if:
  261          *      not a regular file
  262          *      exec not allowed on binary
  263          *      exec not allowed on mount point
  264          */
  265         if (ldr_vp->v_type != VREG) {
error = EACCES;
  267                 goto badunlock;
  268         }
  270         if ((error = VOP_ACCESS(ldr_vp, VEXEC, p->p_ucred, p)) != 0)
  271                 goto badunlock;
  273         if (ldr_vp->v_mount->mnt_flag & MNT_NOEXEC) {
error = EACCES;
  275                 goto badunlock;
  276         }
  278         /* 
  279          * If loader's mount point disallows set-id execution,
  280          * disable set-id.
  281          */
  282         if (ldr_vp->v_mount->mnt_flag & MNT_NOSUID)
epp->ep_vap->va_mode &= ~(S_ISUID | S_ISGID);
VOP_UNLOCK(ldr_vp, 0, p);
  287         /*
  288          * read the header, and make sure we got all of it.
  289          */
  290         if ((error = vn_rdwr(UIO_READ, ldr_vp, (caddr_t)&ldr_exechdr,
  291             sizeof ldr_exechdr, 0, UIO_SYSSPACE, 0, p->p_ucred,
  292             &resid, p)) != 0)
  293                 goto bad;
  294         if (resid != 0) {
error = ENOEXEC;
  296                 goto bad;
  297         }
  299         /*
  300          * Check the magic.  We expect it to be the native Alpha ECOFF
  301          * (Digital UNIX) magic number.  Also make sure it's not a shared
  302          * lib or dynamically linked executable.
  303          */
  304         if (ldr_exechdr.f.f_magic != ECOFF_MAGIC_ALPHA) {
error = ENOEXEC;
  306                 goto bad;
  307         }
  308         switch (ldr_exechdr.f.f_flags & ECOFF_FLAG_OBJECT_TYPE_MASK) {
  309         case ECOFF_OBJECT_TYPE_SHARABLE:
  310         case ECOFF_OBJECT_TYPE_CALL_SHARED:
  311                 /* can't exec shared lib or dynamically linked executable. */
error = ENOEXEC;
  313                 goto bad;
  314         }
  316         switch (ldr_exechdr.a.magic) {
  317         case ECOFF_OMAGIC:
error = exec_ecoff_prep_omagic(p, epp);
  319                 break;
  320         case ECOFF_NMAGIC:
error = exec_ecoff_prep_nmagic(p, epp);
  322                 break;
  323         case ECOFF_ZMAGIC:
error = exec_ecoff_prep_zmagic(p, epp);
  325                 break;
  326         default:
error = ENOEXEC;
  328         }
  329         if (error)
  330                 goto bad;
vrele(ldr_vp);
  333         return (0);
badunlock:
VOP_UNLOCK(ldr_vp, 0, p);
bad:
vrele(ldr_vp);
bad_no_vp:
  340         return (error);
  341 }