19454b2d8SWarner Losh /*- 226f9a767SRodney W. Grimes * Copyright (c) 1993, David Greenman 326f9a767SRodney W. Grimes * All rights reserved. 4df8bae1dSRodney W. Grimes * 5df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 6df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 7df8bae1dSRodney W. Grimes * are met: 8df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 9df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 10df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 12df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 13df8bae1dSRodney W. Grimes * 1426f9a767SRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1726f9a767SRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24df8bae1dSRodney W. Grimes * SUCH DAMAGE. 25df8bae1dSRodney W. Grimes */ 26df8bae1dSRodney W. Grimes 27677b542eSDavid E. O'Brien #include <sys/cdefs.h> 28677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 29677b542eSDavid E. O'Brien 301e9b3d91SPeter Wemm #include "opt_ktrace.h" 31339b79b9SRobert Watson #include "opt_mac.h" 321e9b3d91SPeter Wemm 33df8bae1dSRodney W. Grimes #include <sys/param.h> 3426f9a767SRodney W. Grimes #include <sys/systm.h> 3575b8b3b2SJohn Baldwin #include <sys/eventhandler.h> 36fb919e4dSMark Murray #include <sys/lock.h> 37fb919e4dSMark Murray #include <sys/mutex.h> 38d2d3e875SBruce Evans #include <sys/sysproto.h> 3926f9a767SRodney W. Grimes #include <sys/signalvar.h> 4026f9a767SRodney W. Grimes #include <sys/kernel.h> 41339b79b9SRobert Watson #include <sys/mac.h> 4226f9a767SRodney W. Grimes #include <sys/mount.h> 43797f2d22SPoul-Henning Kamp #include <sys/filedesc.h> 44079cc25bSDavid Greenman #include <sys/fcntl.h> 4526f9a767SRodney W. Grimes #include <sys/acct.h> 4626f9a767SRodney W. Grimes #include <sys/exec.h> 4726f9a767SRodney W. Grimes #include <sys/imgact.h> 48e1743d02SSøren Schmidt #include <sys/imgact_elf.h> 4926f9a767SRodney W. Grimes #include <sys/wait.h> 50333ea485SGuido van Rooij #include <sys/malloc.h> 51a794e791SBruce Evans #include <sys/proc.h> 522a024a2bSSean Eric Fagan #include <sys/pioctl.h> 53a794e791SBruce Evans #include <sys/namei.h> 546004362eSDavid Schultz #include <sys/resourcevar.h> 5559c8bc40SAlan Cox #include <sys/sf_buf.h> 5684e0b075SDavid Xu #include <sys/syscallsubr.h> 571e1e0b44SSøren Schmidt #include <sys/sysent.h> 58797f2d22SPoul-Henning Kamp #include <sys/shm.h> 5999ac3bc8SPeter Wemm #include <sys/sysctl.h> 60a794e791SBruce Evans #include <sys/vnode.h> 61c781aea8SPeter Wemm #ifdef KTRACE 62c781aea8SPeter Wemm #include <sys/ktrace.h> 63c781aea8SPeter Wemm #endif 6426f9a767SRodney W. Grimes 6526f9a767SRodney W. Grimes #include <vm/vm.h> 66efeaf95aSDavid Greenman #include <vm/vm_param.h> 67efeaf95aSDavid Greenman #include <vm/pmap.h> 681616db3cSJohn Dyson #include <vm/vm_page.h> 69efeaf95aSDavid Greenman #include <vm/vm_map.h> 7026f9a767SRodney W. Grimes #include <vm/vm_kern.h> 71efeaf95aSDavid Greenman #include <vm/vm_extern.h> 721ebd0c59SDavid Greenman #include <vm/vm_object.h> 731616db3cSJohn Dyson #include <vm/vm_pager.h> 7426f9a767SRodney W. Grimes 7526f9a767SRodney W. Grimes #include <machine/reg.h> 7626f9a767SRodney W. Grimes 77b9df5231SPoul-Henning Kamp MALLOC_DEFINE(M_PARGS, "proc-args", "Process arguments"); 78b9df5231SPoul-Henning Kamp 7905ba50f5SJake Burkholder static int sysctl_kern_ps_strings(SYSCTL_HANDLER_ARGS); 8005ba50f5SJake Burkholder static int sysctl_kern_usrstack(SYSCTL_HANDLER_ARGS); 815dadd17bSJake Burkholder static int sysctl_kern_stackprot(SYSCTL_HANDLER_ARGS); 82906ac69dSDavid Xu static int do_execve(struct thread *td, char *fname, char **argv, 83906ac69dSDavid Xu char **envv, struct mac *mac_p); 8405ba50f5SJake Burkholder 859701cd40SJohn Baldwin /* XXX This should be vm_size_t. */ 8605ba50f5SJake Burkholder SYSCTL_PROC(_kern, KERN_PS_STRINGS, ps_strings, CTLTYPE_ULONG|CTLFLAG_RD, 8705ba50f5SJake Burkholder NULL, 0, sysctl_kern_ps_strings, "LU", ""); 88486bddb0SDoug Rabson 899701cd40SJohn Baldwin /* XXX This should be vm_size_t. */ 9005ba50f5SJake Burkholder SYSCTL_PROC(_kern, KERN_USRSTACK, usrstack, CTLTYPE_ULONG|CTLFLAG_RD, 9105ba50f5SJake Burkholder NULL, 0, sysctl_kern_usrstack, "LU", ""); 9299ac3bc8SPeter Wemm 935dadd17bSJake Burkholder SYSCTL_PROC(_kern, OID_AUTO, stackprot, CTLTYPE_INT|CTLFLAG_RD, 945dadd17bSJake Burkholder NULL, 0, sysctl_kern_stackprot, "I", ""); 955dadd17bSJake Burkholder 96b9df5231SPoul-Henning Kamp u_long ps_arg_cache_limit = PAGE_SIZE / 16; 97c3699b5fSPeter Wemm SYSCTL_ULONG(_kern, OID_AUTO, ps_arg_cache_limit, CTLFLAG_RW, 989701cd40SJohn Baldwin &ps_arg_cache_limit, 0, ""); 99b9df5231SPoul-Henning Kamp 10005ba50f5SJake Burkholder static int 10105ba50f5SJake Burkholder sysctl_kern_ps_strings(SYSCTL_HANDLER_ARGS) 10205ba50f5SJake Burkholder { 10305ba50f5SJake Burkholder struct proc *p; 104df7c361eSPeter Wemm int error; 10505ba50f5SJake Burkholder 10605ba50f5SJake Burkholder p = curproc; 107a7bc3102SPeter Wemm #ifdef SCTL_MASK32 108a7bc3102SPeter Wemm if (req->flags & SCTL_MASK32) { 109df7c361eSPeter Wemm unsigned int val; 110df7c361eSPeter Wemm val = (unsigned int)p->p_sysent->sv_psstrings; 111df7c361eSPeter Wemm error = SYSCTL_OUT(req, &val, sizeof(val)); 112df7c361eSPeter Wemm } else 113df7c361eSPeter Wemm #endif 114df7c361eSPeter Wemm error = SYSCTL_OUT(req, &p->p_sysent->sv_psstrings, 115df7c361eSPeter Wemm sizeof(p->p_sysent->sv_psstrings)); 116df7c361eSPeter Wemm return error; 11705ba50f5SJake Burkholder } 11805ba50f5SJake Burkholder 11905ba50f5SJake Burkholder static int 12005ba50f5SJake Burkholder sysctl_kern_usrstack(SYSCTL_HANDLER_ARGS) 12105ba50f5SJake Burkholder { 12205ba50f5SJake Burkholder struct proc *p; 123df7c361eSPeter Wemm int error; 12405ba50f5SJake Burkholder 12505ba50f5SJake Burkholder p = curproc; 126a7bc3102SPeter Wemm #ifdef SCTL_MASK32 127a7bc3102SPeter Wemm if (req->flags & SCTL_MASK32) { 128df7c361eSPeter Wemm unsigned int val; 129df7c361eSPeter Wemm val = (unsigned int)p->p_sysent->sv_usrstack; 130df7c361eSPeter Wemm error = SYSCTL_OUT(req, &val, sizeof(val)); 131df7c361eSPeter Wemm } else 132df7c361eSPeter Wemm #endif 133df7c361eSPeter Wemm error = SYSCTL_OUT(req, &p->p_sysent->sv_usrstack, 134df7c361eSPeter Wemm sizeof(p->p_sysent->sv_usrstack)); 135df7c361eSPeter Wemm return error; 13605ba50f5SJake Burkholder } 13705ba50f5SJake Burkholder 1385dadd17bSJake Burkholder static int 1395dadd17bSJake Burkholder sysctl_kern_stackprot(SYSCTL_HANDLER_ARGS) 1405dadd17bSJake Burkholder { 1415dadd17bSJake Burkholder struct proc *p; 1425dadd17bSJake Burkholder 1435dadd17bSJake Burkholder p = curproc; 1445dadd17bSJake Burkholder return (SYSCTL_OUT(req, &p->p_sysent->sv_stackprot, 1455dadd17bSJake Burkholder sizeof(p->p_sysent->sv_stackprot))); 1465dadd17bSJake Burkholder } 1475dadd17bSJake Burkholder 14899ac3bc8SPeter Wemm /* 149aa855a59SPeter Wemm * Each of the items is a pointer to a `const struct execsw', hence the 150aa855a59SPeter Wemm * double pointer here. 151df8bae1dSRodney W. Grimes */ 152aa855a59SPeter Wemm static const struct execsw **execsw; 15326f9a767SRodney W. Grimes 154ca46e90eSBruce Evans #ifndef _SYS_SYSPROTO_H_ 155ca46e90eSBruce Evans struct execve_args { 156ca46e90eSBruce Evans char *fname; 157ca46e90eSBruce Evans char **argv; 158ca46e90eSBruce Evans char **envv; 159ca46e90eSBruce Evans }; 160ca46e90eSBruce Evans #endif 161ca46e90eSBruce Evans 162ca46e90eSBruce Evans /* 163ca46e90eSBruce Evans * MPSAFE 164ca46e90eSBruce Evans */ 165ca46e90eSBruce Evans int 166ca46e90eSBruce Evans execve(td, uap) 167ca46e90eSBruce Evans struct thread *td; 168ca46e90eSBruce Evans struct execve_args /* { 169ca46e90eSBruce Evans char *fname; 170ca46e90eSBruce Evans char **argv; 171ca46e90eSBruce Evans char **envv; 172ca46e90eSBruce Evans } */ *uap; 173ca46e90eSBruce Evans { 174ca46e90eSBruce Evans 175ca46e90eSBruce Evans return (kern_execve(td, uap->fname, uap->argv, uap->envv, NULL)); 176ca46e90eSBruce Evans } 177ca46e90eSBruce Evans 178ca46e90eSBruce Evans #ifndef _SYS_SYSPROTO_H_ 179ca46e90eSBruce Evans struct __mac_execve_args { 180ca46e90eSBruce Evans char *fname; 181ca46e90eSBruce Evans char **argv; 182ca46e90eSBruce Evans char **envv; 183ca46e90eSBruce Evans struct mac *mac_p; 184ca46e90eSBruce Evans }; 185ca46e90eSBruce Evans #endif 186ca46e90eSBruce Evans 187ca46e90eSBruce Evans /* 188ca46e90eSBruce Evans * MPSAFE 189ca46e90eSBruce Evans */ 190ca46e90eSBruce Evans int 191ca46e90eSBruce Evans __mac_execve(td, uap) 192ca46e90eSBruce Evans struct thread *td; 193ca46e90eSBruce Evans struct __mac_execve_args /* { 194ca46e90eSBruce Evans char *fname; 195ca46e90eSBruce Evans char **argv; 196ca46e90eSBruce Evans char **envv; 197ca46e90eSBruce Evans struct mac *mac_p; 198ca46e90eSBruce Evans } */ *uap; 199ca46e90eSBruce Evans { 200ca46e90eSBruce Evans 201ca46e90eSBruce Evans #ifdef MAC 202ca46e90eSBruce Evans return (kern_execve(td, uap->fname, uap->argv, uap->envv, 203ca46e90eSBruce Evans uap->mac_p)); 204ca46e90eSBruce Evans #else 205ca46e90eSBruce Evans return (ENOSYS); 206ca46e90eSBruce Evans #endif 207ca46e90eSBruce Evans } 208ca46e90eSBruce Evans 20984e0b075SDavid Xu int 210906ac69dSDavid Xu kern_execve(td, fname, argv, envv, mac_p) 211906ac69dSDavid Xu struct thread *td; 212906ac69dSDavid Xu char *fname; 213906ac69dSDavid Xu char **argv; 214906ac69dSDavid Xu char **envv; 215906ac69dSDavid Xu struct mac *mac_p; 216906ac69dSDavid Xu { 217906ac69dSDavid Xu struct proc *p = td->td_proc; 218906ac69dSDavid Xu int error; 219906ac69dSDavid Xu 220906ac69dSDavid Xu if (p->p_flag & P_HADTHREADS) { 221906ac69dSDavid Xu PROC_LOCK(p); 222906ac69dSDavid Xu if (thread_single(SINGLE_BOUNDARY)) { 223906ac69dSDavid Xu PROC_UNLOCK(p); 224906ac69dSDavid Xu return (ERESTART); /* Try again later. */ 225906ac69dSDavid Xu } 226906ac69dSDavid Xu PROC_UNLOCK(p); 227906ac69dSDavid Xu } 228906ac69dSDavid Xu 229906ac69dSDavid Xu error = do_execve(td, fname, argv, envv, mac_p); 230906ac69dSDavid Xu 231906ac69dSDavid Xu if (p->p_flag & P_HADTHREADS) { 232906ac69dSDavid Xu PROC_LOCK(p); 233906ac69dSDavid Xu /* 234906ac69dSDavid Xu * If success, we upgrade to SINGLE_EXIT state to 235906ac69dSDavid Xu * force other threads to suicide. 236906ac69dSDavid Xu */ 237906ac69dSDavid Xu if (error == 0) 238906ac69dSDavid Xu thread_single(SINGLE_EXIT); 239906ac69dSDavid Xu else 240906ac69dSDavid Xu thread_single_end(); 241906ac69dSDavid Xu PROC_UNLOCK(p); 242906ac69dSDavid Xu } 243906ac69dSDavid Xu 244906ac69dSDavid Xu return (error); 245906ac69dSDavid Xu } 246906ac69dSDavid Xu 24726f9a767SRodney W. Grimes /* 248450ffb44SRobert Watson * In-kernel implementation of execve(). All arguments are assumed to be 249450ffb44SRobert Watson * userspace pointers from the passed thread. 250116734c4SMatthew Dillon * 251116734c4SMatthew Dillon * MPSAFE 25226f9a767SRodney W. Grimes */ 253450ffb44SRobert Watson static int 254906ac69dSDavid Xu do_execve(td, fname, argv, envv, mac_p) 255b40ce416SJulian Elischer struct thread *td; 256450ffb44SRobert Watson char *fname; 257450ffb44SRobert Watson char **argv; 258450ffb44SRobert Watson char **envv; 259670cb89bSRobert Watson struct mac *mac_p; 260df8bae1dSRodney W. Grimes { 261b40ce416SJulian Elischer struct proc *p = td->td_proc; 26226f9a767SRodney W. Grimes struct nameidata nd, *ndp; 2639b3b1c5fSJohn Baldwin struct ucred *newcred = NULL, *oldcred; 2641419eacbSAlfred Perlstein struct uidinfo *euip; 265654f6be1SBruce Evans register_t *stack_base; 266bb56ec4aSPoul-Henning Kamp int error, len, i; 267c52007c2SDavid Greenman struct image_params image_params, *imgp; 26826f9a767SRodney W. Grimes struct vattr attr; 2694d77a549SAlfred Perlstein int (*img_first)(struct image_params *); 27069be5db9SAlfred Perlstein struct pargs *oldargs = NULL, *newargs = NULL; 27190af4afaSJohn Baldwin struct sigacts *oldsigacts, *newsigacts; 2726c84de02SJohn Baldwin #ifdef KTRACE 2736c84de02SJohn Baldwin struct vnode *tracevp = NULL; 274a5881ea5SJohn Baldwin struct ucred *tracecred = NULL; 2756c84de02SJohn Baldwin #endif 2766c84de02SJohn Baldwin struct vnode *textvp = NULL; 277d06c0d4dSRobert Watson int credential_changing; 278619eb6e5SJeff Roberson int textset; 279ccafe7ebSRobert Watson #ifdef MAC 280eca8a663SRobert Watson struct label *interplabel = NULL; 281eca8a663SRobert Watson int will_transition; 282ccafe7ebSRobert Watson #endif 28326f9a767SRodney W. Grimes 284c52007c2SDavid Greenman imgp = &image_params; 285df8bae1dSRodney W. Grimes 2869ca45e81SDag-Erling Smørgrav /* 2879ca45e81SDag-Erling Smørgrav * Lock the process and set the P_INEXEC flag to indicate that 2889ca45e81SDag-Erling Smørgrav * it should be left alone until we're done here. This is 2899ca45e81SDag-Erling Smørgrav * necessary to avoid race conditions - e.g. in ptrace() - 2909ca45e81SDag-Erling Smørgrav * that might allow a local user to illicitly obtain elevated 2919ca45e81SDag-Erling Smørgrav * privileges. 2929ca45e81SDag-Erling Smørgrav */ 2939ca45e81SDag-Erling Smørgrav PROC_LOCK(p); 2949ca45e81SDag-Erling Smørgrav KASSERT((p->p_flag & P_INEXEC) == 0, 29591f91617SDavid E. O'Brien ("%s(): process already has P_INEXEC flag", __func__)); 2969ca45e81SDag-Erling Smørgrav p->p_flag |= P_INEXEC; 2979ca45e81SDag-Erling Smørgrav PROC_UNLOCK(p); 2989ca45e81SDag-Erling Smørgrav 299df8bae1dSRodney W. Grimes /* 300c52007c2SDavid Greenman * Initialize part of the common data 301df8bae1dSRodney W. Grimes */ 302c52007c2SDavid Greenman imgp->proc = p; 303450ffb44SRobert Watson imgp->userspace_argv = argv; 304450ffb44SRobert Watson imgp->userspace_envv = envv; 305670cb89bSRobert Watson imgp->execlabel = NULL; 306c52007c2SDavid Greenman imgp->attr = &attr; 307c52007c2SDavid Greenman imgp->argc = imgp->envc = 0; 3085cf3d12cSAndrey A. Chernov imgp->argv0 = NULL; 309c52007c2SDavid Greenman imgp->entry_addr = 0; 310c52007c2SDavid Greenman imgp->vmspace_destroyed = 0; 311c52007c2SDavid Greenman imgp->interpreted = 0; 312c52007c2SDavid Greenman imgp->interpreter_name[0] = '\0'; 313e1743d02SSøren Schmidt imgp->auxargs = NULL; 3141616db3cSJohn Dyson imgp->vp = NULL; 3150b2ed1aeSJeff Roberson imgp->object = NULL; 3161616db3cSJohn Dyson imgp->firstpage = NULL; 3174fe88fe6SJohn Polstra imgp->ps_strings = 0; 318b9a22da4STakanori Watanabe imgp->auxarg_size = 0; 31926f9a767SRodney W. Grimes 320670cb89bSRobert Watson #ifdef MAC 321eca8a663SRobert Watson error = mac_execve_enter(imgp, mac_p); 322670cb89bSRobert Watson if (error) { 323670cb89bSRobert Watson mtx_lock(&Giant); 324670cb89bSRobert Watson goto exec_fail; 325670cb89bSRobert Watson } 326670cb89bSRobert Watson #endif 327670cb89bSRobert Watson 32826f9a767SRodney W. Grimes /* 32926f9a767SRodney W. Grimes * Allocate temporary demand zeroed space for argument and 33026f9a767SRodney W. Grimes * environment strings 33126f9a767SRodney W. Grimes */ 33259c8bc40SAlan Cox imgp->stringbase = (char *)kmem_alloc_wait(exec_map, ARG_MAX); 333c2f9f36bSDavid Greenman if (imgp->stringbase == NULL) { 33426f9a767SRodney W. Grimes error = ENOMEM; 335b3afd20dSAlan Cox mtx_lock(&Giant); 33626f9a767SRodney W. Grimes goto exec_fail; 33726f9a767SRodney W. Grimes } 338c52007c2SDavid Greenman imgp->stringp = imgp->stringbase; 339c52007c2SDavid Greenman imgp->stringspace = ARG_MAX; 34059c8bc40SAlan Cox imgp->image_header = NULL; 34126f9a767SRodney W. Grimes 34226f9a767SRodney W. Grimes /* 34326f9a767SRodney W. Grimes * Translate the file name. namei() returns a vnode pointer 34426f9a767SRodney W. Grimes * in ni_vp amoung other things. 34526f9a767SRodney W. Grimes */ 34626f9a767SRodney W. Grimes ndp = &nd; 347b35ba931SDavid Greenman NDINIT(ndp, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, 348450ffb44SRobert Watson UIO_USERSPACE, fname, td); 34926f9a767SRodney W. Grimes 350b3afd20dSAlan Cox mtx_lock(&Giant); 35126f9a767SRodney W. Grimes interpret: 35226f9a767SRodney W. Grimes 35326f9a767SRodney W. Grimes error = namei(ndp); 35426f9a767SRodney W. Grimes if (error) { 3551616db3cSJohn Dyson kmem_free_wakeup(exec_map, (vm_offset_t)imgp->stringbase, 35659c8bc40SAlan Cox ARG_MAX); 35726f9a767SRodney W. Grimes goto exec_fail; 35826f9a767SRodney W. Grimes } 35926f9a767SRodney W. Grimes 360c52007c2SDavid Greenman imgp->vp = ndp->ni_vp; 361450ffb44SRobert Watson imgp->fname = fname; 36226f9a767SRodney W. Grimes 36326f9a767SRodney W. Grimes /* 3649022e4adSDavid Greenman * Check file permissions (also 'opens' file) 3659022e4adSDavid Greenman */ 366c52007c2SDavid Greenman error = exec_check_permissions(imgp); 367619eb6e5SJeff Roberson if (error) 36826f9a767SRodney W. Grimes goto exec_fail_dealloc; 369619eb6e5SJeff Roberson 3708516dd18SPoul-Henning Kamp imgp->object = imgp->vp->v_object; 3718516dd18SPoul-Henning Kamp if (imgp->object != NULL) 3720b2ed1aeSJeff Roberson vm_object_reference(imgp->object); 37326f9a767SRodney W. Grimes 374619eb6e5SJeff Roberson /* 375619eb6e5SJeff Roberson * Set VV_TEXT now so no one can write to the executable while we're 376619eb6e5SJeff Roberson * activating it. 377619eb6e5SJeff Roberson * 378619eb6e5SJeff Roberson * Remember if this was set before and unset it in case this is not 379619eb6e5SJeff Roberson * actually an executable image. 380619eb6e5SJeff Roberson */ 381619eb6e5SJeff Roberson textset = imgp->vp->v_vflag & VV_TEXT; 382619eb6e5SJeff Roberson imgp->vp->v_vflag |= VV_TEXT; 383619eb6e5SJeff Roberson 3841616db3cSJohn Dyson error = exec_map_first_page(imgp); 3856d5a0a8cSDavid Greenman if (error) 38626f9a767SRodney W. Grimes goto exec_fail_dealloc; 38726f9a767SRodney W. Grimes 38826f9a767SRodney W. Grimes /* 389d323ddf3SMatthew Dillon * If the current process has a special image activator it 390d323ddf3SMatthew Dillon * wants to try first, call it. For example, emulating shell 391d323ddf3SMatthew Dillon * scripts differently. 39226f9a767SRodney W. Grimes */ 393d323ddf3SMatthew Dillon error = -1; 394d323ddf3SMatthew Dillon if ((img_first = imgp->proc->p_sysent->sv_imgact_try) != NULL) 395d323ddf3SMatthew Dillon error = img_first(imgp); 396d323ddf3SMatthew Dillon 397d323ddf3SMatthew Dillon /* 398d323ddf3SMatthew Dillon * Loop through the list of image activators, calling each one. 399d323ddf3SMatthew Dillon * An activator returns -1 if there is no match, 0 on success, 400d323ddf3SMatthew Dillon * and an error otherwise. 401d323ddf3SMatthew Dillon */ 402d323ddf3SMatthew Dillon for (i = 0; error == -1 && execsw[i]; ++i) { 403d323ddf3SMatthew Dillon if (execsw[i]->ex_imgact == NULL || 404d323ddf3SMatthew Dillon execsw[i]->ex_imgact == img_first) { 405d323ddf3SMatthew Dillon continue; 406d323ddf3SMatthew Dillon } 407c52007c2SDavid Greenman error = (*execsw[i]->ex_imgact)(imgp); 408d323ddf3SMatthew Dillon } 409d323ddf3SMatthew Dillon 410d323ddf3SMatthew Dillon if (error) { 411619eb6e5SJeff Roberson if (error == -1) { 412619eb6e5SJeff Roberson if (textset == 0) 413619eb6e5SJeff Roberson imgp->vp->v_vflag &= ~VV_TEXT; 414d323ddf3SMatthew Dillon error = ENOEXEC; 415619eb6e5SJeff Roberson } 41626f9a767SRodney W. Grimes goto exec_fail_dealloc; 417d323ddf3SMatthew Dillon } 418d323ddf3SMatthew Dillon 419d323ddf3SMatthew Dillon /* 420d323ddf3SMatthew Dillon * Special interpreter operation, cleanup and loop up to try to 421d323ddf3SMatthew Dillon * activate the interpreter. 422d323ddf3SMatthew Dillon */ 423c52007c2SDavid Greenman if (imgp->interpreted) { 4241616db3cSJohn Dyson exec_unmap_first_page(imgp); 425619eb6e5SJeff Roberson /* 426619eb6e5SJeff Roberson * VV_TEXT needs to be unset for scripts. There is a short 427619eb6e5SJeff Roberson * period before we determine that something is a script where 428619eb6e5SJeff Roberson * VV_TEXT will be set. The vnode lock is held over this 429619eb6e5SJeff Roberson * entire period so nothing should illegitimately be blocked. 430619eb6e5SJeff Roberson */ 431619eb6e5SJeff Roberson imgp->vp->v_vflag &= ~VV_TEXT; 432762e6b85SEivind Eklund /* free name buffer and old vnode */ 433762e6b85SEivind Eklund NDFREE(ndp, NDF_ONLY_PNBUF); 434670cb89bSRobert Watson #ifdef MAC 435eca8a663SRobert Watson interplabel = mac_vnode_label_alloc(); 436eca8a663SRobert Watson mac_copy_vnode_label(ndp->ni_vp->v_label, interplabel); 437670cb89bSRobert Watson #endif 438619eb6e5SJeff Roberson vput(ndp->ni_vp); 4390b2ed1aeSJeff Roberson vm_object_deallocate(imgp->object); 4400b2ed1aeSJeff Roberson imgp->object = NULL; 44126f9a767SRodney W. Grimes /* set new name to that of the interpreter */ 442b35ba931SDavid Greenman NDINIT(ndp, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, 443b40ce416SJulian Elischer UIO_SYSSPACE, imgp->interpreter_name, td); 44426f9a767SRodney W. Grimes goto interpret; 44526f9a767SRodney W. Grimes } 44626f9a767SRodney W. Grimes 44726f9a767SRodney W. Grimes /* 44826f9a767SRodney W. Grimes * Copy out strings (args and env) and initialize stack base 44926f9a767SRodney W. Grimes */ 4503ebc1248SPeter Wemm if (p->p_sysent->sv_copyout_strings) 4513ebc1248SPeter Wemm stack_base = (*p->p_sysent->sv_copyout_strings)(imgp); 4523ebc1248SPeter Wemm else 453c52007c2SDavid Greenman stack_base = exec_copyout_strings(imgp); 45426f9a767SRodney W. Grimes 45526f9a767SRodney W. Grimes /* 4561e1e0b44SSøren Schmidt * If custom stack fixup routine present for this process 4571e1e0b44SSøren Schmidt * let it do the stack setup. 4581e1e0b44SSøren Schmidt * Else stuff argument count as first item on stack 45926f9a767SRodney W. Grimes */ 460d6c847f3SBruce Evans if (p->p_sysent->sv_fixup != NULL) 461c52007c2SDavid Greenman (*p->p_sysent->sv_fixup)(&stack_base, imgp); 4621e1e0b44SSøren Schmidt else 463c52007c2SDavid Greenman suword(--stack_base, imgp->argc); 46426f9a767SRodney W. Grimes 465a78e8d2aSDavid Greenman /* 466a78e8d2aSDavid Greenman * For security and other reasons, the file descriptor table cannot 467a78e8d2aSDavid Greenman * be shared after an exec. 468a78e8d2aSDavid Greenman */ 469c113083cSPoul-Henning Kamp fdunshare(p, td); 470a78e8d2aSDavid Greenman 471333ea485SGuido van Rooij /* 4729b3b1c5fSJohn Baldwin * Malloc things before we need locks. 4739b3b1c5fSJohn Baldwin */ 4749b3b1c5fSJohn Baldwin newcred = crget(); 4751419eacbSAlfred Perlstein euip = uifind(attr.va_uid); 4769b3b1c5fSJohn Baldwin i = imgp->endargs - imgp->stringbase; 4779b3b1c5fSJohn Baldwin if (ps_arg_cache_limit >= i + sizeof(struct pargs)) 4789b3b1c5fSJohn Baldwin newargs = pargs_alloc(i); 4799b3b1c5fSJohn Baldwin 4809b3b1c5fSJohn Baldwin /* close files on exec */ 4819b3b1c5fSJohn Baldwin fdcloseexec(td); 4829b3b1c5fSJohn Baldwin 483619eb6e5SJeff Roberson /* Get a reference to the vnode prior to locking the proc */ 484619eb6e5SJeff Roberson VREF(ndp->ni_vp); 485619eb6e5SJeff Roberson 4869b3b1c5fSJohn Baldwin /* 487333ea485SGuido van Rooij * For security and other reasons, signal handlers cannot 4888688bb93SJohn Baldwin * be shared after an exec. The new process gets a copy of the old 489b2c3fa70SDima Dorfman * handlers. In execsigs(), the new process will have its signals 490333ea485SGuido van Rooij * reset. 491333ea485SGuido van Rooij */ 4929b3b1c5fSJohn Baldwin PROC_LOCK(p); 49390af4afaSJohn Baldwin if (sigacts_shared(p->p_sigacts)) { 49490af4afaSJohn Baldwin oldsigacts = p->p_sigacts; 4959b3b1c5fSJohn Baldwin PROC_UNLOCK(p); 49690af4afaSJohn Baldwin newsigacts = sigacts_alloc(); 49790af4afaSJohn Baldwin sigacts_copy(newsigacts, oldsigacts); 4989b3b1c5fSJohn Baldwin PROC_LOCK(p); 49990af4afaSJohn Baldwin p->p_sigacts = newsigacts; 50090af4afaSJohn Baldwin } else 50190af4afaSJohn Baldwin oldsigacts = NULL; 502333ea485SGuido van Rooij 503fdf4e8b3SWarner Losh /* Stop profiling */ 504fdf4e8b3SWarner Losh stopprofclock(p); 505fdf4e8b3SWarner Losh 50626f9a767SRodney W. Grimes /* reset caught signals */ 50726f9a767SRodney W. Grimes execsigs(p); 50826f9a767SRodney W. Grimes 50926f9a767SRodney W. Grimes /* name this process - nameiexec(p, ndp) */ 51026f9a767SRodney W. Grimes len = min(ndp->ni_cnd.cn_namelen,MAXCOMLEN); 51126f9a767SRodney W. Grimes bcopy(ndp->ni_cnd.cn_nameptr, p->p_comm, len); 51226f9a767SRodney W. Grimes p->p_comm[len] = 0; 51326f9a767SRodney W. Grimes 51426f9a767SRodney W. Grimes /* 51524b34f09SSujal Patel * mark as execed, wakeup the process that vforked (if any) and tell 516dc733423SDag-Erling Smørgrav * it that it now has its own resources back 51726f9a767SRodney W. Grimes */ 51826f9a767SRodney W. Grimes p->p_flag |= P_EXEC; 51926f9a767SRodney W. Grimes if (p->p_pptr && (p->p_flag & P_PPWAIT)) { 52026f9a767SRodney W. Grimes p->p_flag &= ~P_PPWAIT; 5217f05b035SAlfred Perlstein wakeup(p->p_pptr); 52226f9a767SRodney W. Grimes } 52326f9a767SRodney W. Grimes 52426f9a767SRodney W. Grimes /* 525a78e8d2aSDavid Greenman * Implement image setuid/setgid. 526a78e8d2aSDavid Greenman * 527a78e8d2aSDavid Greenman * Don't honor setuid/setgid if the filesystem prohibits it or if 528a78e8d2aSDavid Greenman * the process is being traced. 529670cb89bSRobert Watson * 530670cb89bSRobert Watson * XXXMAC: For the time being, use NOSUID to also prohibit 531670cb89bSRobert Watson * transitions on the file system. 532c52007c2SDavid Greenman */ 533b1fc0ec1SRobert Watson oldcred = p->p_ucred; 534d06c0d4dSRobert Watson credential_changing = 0; 535d06c0d4dSRobert Watson credential_changing |= (attr.va_mode & VSUID) && oldcred->cr_uid != 536d06c0d4dSRobert Watson attr.va_uid; 537d06c0d4dSRobert Watson credential_changing |= (attr.va_mode & VSGID) && oldcred->cr_gid != 538d06c0d4dSRobert Watson attr.va_gid; 539ccafe7ebSRobert Watson #ifdef MAC 540670cb89bSRobert Watson will_transition = mac_execve_will_transition(oldcred, imgp->vp, 541eca8a663SRobert Watson interplabel, imgp); 542ccafe7ebSRobert Watson credential_changing |= will_transition; 543ccafe7ebSRobert Watson #endif 544d06c0d4dSRobert Watson 545d06c0d4dSRobert Watson if (credential_changing && 546a78e8d2aSDavid Greenman (imgp->vp->v_mount->mnt_flag & MNT_NOSUID) == 0 && 547c52007c2SDavid Greenman (p->p_flag & P_TRACED) == 0) { 548c52007c2SDavid Greenman /* 549c52007c2SDavid Greenman * Turn off syscall tracing for set-id programs, except for 550b85db196SPeter Wemm * root. Record any set-id flags first to make sure that 551b85db196SPeter Wemm * we do not regain any tracing during a possible block. 55226f9a767SRodney W. Grimes */ 553b85db196SPeter Wemm setsugid(p); 5546c84de02SJohn Baldwin #ifdef KTRACE 55556f21b9dSColin Percival if (p->p_tracevp != NULL && suser_cred(oldcred, SUSER_ALLOWJAIL)) { 5566c84de02SJohn Baldwin mtx_lock(&ktrace_mtx); 55779deba82SMatthew Dillon p->p_traceflag = 0; 558a5881ea5SJohn Baldwin tracevp = p->p_tracevp; 559a5881ea5SJohn Baldwin p->p_tracevp = NULL; 560a5881ea5SJohn Baldwin tracecred = p->p_tracecred; 561a5881ea5SJohn Baldwin p->p_tracecred = NULL; 5626c84de02SJohn Baldwin mtx_unlock(&ktrace_mtx); 56326f9a767SRodney W. Grimes } 5646c84de02SJohn Baldwin #endif 56528b325aaSDon Lewis /* 566c1e2d386SNate Lawson * Close any file descriptors 0..2 that reference procfs, 567c1e2d386SNate Lawson * then make sure file descriptors 0..2 are in use. 56828b325aaSDon Lewis * 569c1e2d386SNate Lawson * setugidsafety() may call closef() and then pfind() 570c1e2d386SNate Lawson * which may grab the process lock. 57128b325aaSDon Lewis * fdcheckstd() may call falloc() which may block to 57228b325aaSDon Lewis * allocate memory, so temporarily drop the process lock. 57328b325aaSDon Lewis */ 57428b325aaSDon Lewis PROC_UNLOCK(p); 575c1e2d386SNate Lawson setugidsafety(td); 576e983a376SJacques Vidrine error = fdcheckstd(td); 57763c9e754SJohn Baldwin if (error != 0) 57869be5db9SAlfred Perlstein goto done1; 579e1b1aa3bSJohn Baldwin PROC_LOCK(p); 580c52007c2SDavid Greenman /* 581c52007c2SDavid Greenman * Set the new credentials. 582c52007c2SDavid Greenman */ 5839b3b1c5fSJohn Baldwin crcopy(newcred, oldcred); 584c52007c2SDavid Greenman if (attr.va_mode & VSUID) 5851419eacbSAlfred Perlstein change_euid(newcred, euip); 586c52007c2SDavid Greenman if (attr.va_mode & VSGID) 587b1fc0ec1SRobert Watson change_egid(newcred, attr.va_gid); 588ccafe7ebSRobert Watson #ifdef MAC 589670cb89bSRobert Watson if (will_transition) { 590670cb89bSRobert Watson mac_execve_transition(oldcred, newcred, imgp->vp, 591eca8a663SRobert Watson interplabel, imgp); 592670cb89bSRobert Watson } 593ccafe7ebSRobert Watson #endif 5949b3b1c5fSJohn Baldwin /* 5959b3b1c5fSJohn Baldwin * Implement correct POSIX saved-id behavior. 596ccafe7ebSRobert Watson * 597ccafe7ebSRobert Watson * XXXMAC: Note that the current logic will save the 598ccafe7ebSRobert Watson * uid and gid if a MAC domain transition occurs, even 599ccafe7ebSRobert Watson * though maybe it shouldn't. 6009b3b1c5fSJohn Baldwin */ 6019b3b1c5fSJohn Baldwin change_svuid(newcred, newcred->cr_uid); 6029b3b1c5fSJohn Baldwin change_svgid(newcred, newcred->cr_gid); 6039b3b1c5fSJohn Baldwin p->p_ucred = newcred; 6049b3b1c5fSJohn Baldwin newcred = NULL; 605c52007c2SDavid Greenman } else { 606b1fc0ec1SRobert Watson if (oldcred->cr_uid == oldcred->cr_ruid && 607b1fc0ec1SRobert Watson oldcred->cr_gid == oldcred->cr_rgid) 608c52007c2SDavid Greenman p->p_flag &= ~P_SUGID; 60926f9a767SRodney W. Grimes /* 610c52007c2SDavid Greenman * Implement correct POSIX saved-id behavior. 611b1fc0ec1SRobert Watson * 612b1fc0ec1SRobert Watson * XXX: It's not clear that the existing behavior is 6139b3b1c5fSJohn Baldwin * POSIX-compliant. A number of sources indicate that the 6149b3b1c5fSJohn Baldwin * saved uid/gid should only be updated if the new ruid is 6159b3b1c5fSJohn Baldwin * not equal to the old ruid, or the new euid is not equal 6169b3b1c5fSJohn Baldwin * to the old euid and the new euid is not equal to the old 6179b3b1c5fSJohn Baldwin * ruid. The FreeBSD code always updates the saved uid/gid. 6189b3b1c5fSJohn Baldwin * Also, this code uses the new (replaced) euid and egid as 6199b3b1c5fSJohn Baldwin * the source, which may or may not be the right ones to use. 62026f9a767SRodney W. Grimes */ 621b1fc0ec1SRobert Watson if (oldcred->cr_svuid != oldcred->cr_uid || 622b1fc0ec1SRobert Watson oldcred->cr_svgid != oldcred->cr_gid) { 6239b3b1c5fSJohn Baldwin crcopy(newcred, oldcred); 624b1fc0ec1SRobert Watson change_svuid(newcred, newcred->cr_uid); 625b1fc0ec1SRobert Watson change_svgid(newcred, newcred->cr_gid); 626b1fc0ec1SRobert Watson p->p_ucred = newcred; 6279b3b1c5fSJohn Baldwin newcred = NULL; 6289b3b1c5fSJohn Baldwin } 629b1fc0ec1SRobert Watson } 63026f9a767SRodney W. Grimes 63126f9a767SRodney W. Grimes /* 632619eb6e5SJeff Roberson * Store the vp for use in procfs. This vnode was referenced prior 633619eb6e5SJeff Roberson * to locking the proc lock. 6342a531c80SDavid Greenman */ 6359b3b1c5fSJohn Baldwin textvp = p->p_textvp; 6362a531c80SDavid Greenman p->p_textvp = ndp->ni_vp; 6372a531c80SDavid Greenman 6382a531c80SDavid Greenman /* 6399ca45e81SDag-Erling Smørgrav * Notify others that we exec'd, and clear the P_INEXEC flag 6409ca45e81SDag-Erling Smørgrav * as we're now a bona fide freshly-execed process. 641cb679c38SJonathan Lemon */ 642ad3b9257SJohn-Mark Gurney KNOTE_LOCKED(&p->p_klist, NOTE_EXEC); 6439ca45e81SDag-Erling Smørgrav p->p_flag &= ~P_INEXEC; 644cb679c38SJonathan Lemon 645cb679c38SJonathan Lemon /* 64626f9a767SRodney W. Grimes * If tracing the process, trap to debugger so breakpoints 64726f9a767SRodney W. Grimes * can be set before the program executes. 648906ac69dSDavid Xu * Use tdsignal to deliver signal to current thread, use 649906ac69dSDavid Xu * psignal may cause the signal to be delivered to wrong thread 650906ac69dSDavid Xu * because that thread will exit, remember we are going to enter 651906ac69dSDavid Xu * single thread mode. 65226f9a767SRodney W. Grimes */ 65326f9a767SRodney W. Grimes if (p->p_flag & P_TRACED) 654906ac69dSDavid Xu tdsignal(td, SIGTRAP, SIGTARGET_TD); 65526f9a767SRodney W. Grimes 65626f9a767SRodney W. Grimes /* clear "fork but no exec" flag, as we _are_ execing */ 65726f9a767SRodney W. Grimes p->p_acflag &= ~AFORK; 65826f9a767SRodney W. Grimes 659b9df5231SPoul-Henning Kamp /* Free any previous argument cache */ 6609b3b1c5fSJohn Baldwin oldargs = p->p_args; 661b9df5231SPoul-Henning Kamp p->p_args = NULL; 662b9df5231SPoul-Henning Kamp 663e1b1aa3bSJohn Baldwin /* Cache arguments if they fit inside our allowance */ 664e1b1aa3bSJohn Baldwin if (ps_arg_cache_limit >= i + sizeof(struct pargs)) { 665e1b1aa3bSJohn Baldwin bcopy(imgp->stringbase, newargs->ar_args, i); 666e1b1aa3bSJohn Baldwin p->p_args = newargs; 667e1b1aa3bSJohn Baldwin newargs = NULL; 668e1b1aa3bSJohn Baldwin } 669e1b1aa3bSJohn Baldwin PROC_UNLOCK(p); 670e1b1aa3bSJohn Baldwin 671e913ca22SDoug Rabson /* Set values passed into the program in registers. */ 6723ebc1248SPeter Wemm if (p->p_sysent->sv_setregs) 6733ebc1248SPeter Wemm (*p->p_sysent->sv_setregs)(td, imgp->entry_addr, 6743ebc1248SPeter Wemm (u_long)(uintptr_t)stack_base, imgp->ps_strings); 6753ebc1248SPeter Wemm else 676bafbd492SJake Burkholder exec_setregs(td, imgp->entry_addr, 677bafbd492SJake Burkholder (u_long)(uintptr_t)stack_base, imgp->ps_strings); 678e913ca22SDoug Rabson 67969be5db9SAlfred Perlstein done1: 6809b3b1c5fSJohn Baldwin /* 6819b3b1c5fSJohn Baldwin * Free any resources malloc'd earlier that we didn't use. 6829b3b1c5fSJohn Baldwin */ 6831419eacbSAlfred Perlstein uifree(euip); 6849b3b1c5fSJohn Baldwin if (newcred == NULL) 6859b3b1c5fSJohn Baldwin crfree(oldcred); 6869b3b1c5fSJohn Baldwin else 6879b3b1c5fSJohn Baldwin crfree(newcred); 6889b3b1c5fSJohn Baldwin /* 6899b3b1c5fSJohn Baldwin * Handle deferred decrement of ref counts. 6909b3b1c5fSJohn Baldwin */ 6919b3b1c5fSJohn Baldwin if (textvp != NULL) 6929b3b1c5fSJohn Baldwin vrele(textvp); 693619eb6e5SJeff Roberson if (ndp->ni_vp && error != 0) 694619eb6e5SJeff Roberson vrele(ndp->ni_vp); 6956c84de02SJohn Baldwin #ifdef KTRACE 6969b3b1c5fSJohn Baldwin if (tracevp != NULL) 6979b3b1c5fSJohn Baldwin vrele(tracevp); 698a5881ea5SJohn Baldwin if (tracecred != NULL) 699a5881ea5SJohn Baldwin crfree(tracecred); 7006c84de02SJohn Baldwin #endif 70169be5db9SAlfred Perlstein if (oldargs != NULL) 7029b3b1c5fSJohn Baldwin pargs_drop(oldargs); 70369be5db9SAlfred Perlstein if (newargs != NULL) 70469be5db9SAlfred Perlstein pargs_drop(newargs); 70590af4afaSJohn Baldwin if (oldsigacts != NULL) 70690af4afaSJohn Baldwin sigacts_free(oldsigacts); 707b9df5231SPoul-Henning Kamp 7081616db3cSJohn Dyson exec_fail_dealloc: 7091616db3cSJohn Dyson 71026f9a767SRodney W. Grimes /* 71126f9a767SRodney W. Grimes * free various allocated resources 71226f9a767SRodney W. Grimes */ 713d6c847f3SBruce Evans if (imgp->firstpage != NULL) 7141616db3cSJohn Dyson exec_unmap_first_page(imgp); 71526f9a767SRodney W. Grimes 716d6c847f3SBruce Evans if (imgp->vp != NULL) { 717762e6b85SEivind Eklund NDFREE(ndp, NDF_ONLY_PNBUF); 718619eb6e5SJeff Roberson vput(imgp->vp); 719a3cf6ebaSDavid Greenman } 72026f9a767SRodney W. Grimes 721a9a08882SJeff Roberson if (imgp->stringbase != NULL) 722a9a08882SJeff Roberson kmem_free_wakeup(exec_map, (vm_offset_t)imgp->stringbase, 72359c8bc40SAlan Cox ARG_MAX); 724a9a08882SJeff Roberson 725d6c847f3SBruce Evans if (imgp->object != NULL) 7260b2ed1aeSJeff Roberson vm_object_deallocate(imgp->object); 7270b2ed1aeSJeff Roberson 728d1989db5SRobert Drehmel if (error == 0) { 729d1989db5SRobert Drehmel /* 730d1989db5SRobert Drehmel * Stop the process here if its stop event mask has 731d1989db5SRobert Drehmel * the S_EXEC bit set. 732d1989db5SRobert Drehmel */ 733d1989db5SRobert Drehmel STOPEVENT(p, S_EXEC, 0); 734116734c4SMatthew Dillon goto done2; 735d1989db5SRobert Drehmel } 7361616db3cSJohn Dyson 73726f9a767SRodney W. Grimes exec_fail: 7389ca45e81SDag-Erling Smørgrav /* we're done here, clear P_INEXEC */ 7399ca45e81SDag-Erling Smørgrav PROC_LOCK(p); 7409ca45e81SDag-Erling Smørgrav p->p_flag &= ~P_INEXEC; 7419ca45e81SDag-Erling Smørgrav PROC_UNLOCK(p); 7429ca45e81SDag-Erling Smørgrav 743c52007c2SDavid Greenman if (imgp->vmspace_destroyed) { 74426f9a767SRodney W. Grimes /* sorry, no more process anymore. exit gracefully */ 745670cb89bSRobert Watson #ifdef MAC 746670cb89bSRobert Watson mac_execve_exit(imgp); 747eca8a663SRobert Watson if (interplabel != NULL) 748eca8a663SRobert Watson mac_vnode_label_free(interplabel); 749670cb89bSRobert Watson #endif 75063993cf0SJohn Baldwin mtx_unlock(&Giant); 751b40ce416SJulian Elischer exit1(td, W_EXITCODE(0, SIGABRT)); 75226f9a767SRodney W. Grimes /* NOT REACHED */ 753116734c4SMatthew Dillon error = 0; 75426f9a767SRodney W. Grimes } 755116734c4SMatthew Dillon done2: 756670cb89bSRobert Watson #ifdef MAC 757670cb89bSRobert Watson mac_execve_exit(imgp); 758eca8a663SRobert Watson if (interplabel != NULL) 759eca8a663SRobert Watson mac_vnode_label_free(interplabel); 760670cb89bSRobert Watson #endif 761116734c4SMatthew Dillon mtx_unlock(&Giant); 762116734c4SMatthew Dillon return (error); 76326f9a767SRodney W. Grimes } 76426f9a767SRodney W. Grimes 7651616db3cSJohn Dyson int 7661616db3cSJohn Dyson exec_map_first_page(imgp) 7671616db3cSJohn Dyson struct image_params *imgp; 7681616db3cSJohn Dyson { 769d8aad40cSJohn Baldwin int rv, i; 77095461b45SJohn Dyson int initial_pagein; 77195461b45SJohn Dyson vm_page_t ma[VM_INITIAL_PAGEIN]; 7721616db3cSJohn Dyson vm_object_t object; 7731616db3cSJohn Dyson 7740cddd8f0SMatthew Dillon GIANT_REQUIRED; 7751616db3cSJohn Dyson 776d6c847f3SBruce Evans if (imgp->firstpage != NULL) 7771616db3cSJohn Dyson exec_unmap_first_page(imgp); 7781616db3cSJohn Dyson 7798516dd18SPoul-Henning Kamp object = imgp->vp->v_object; 780fd0cc9a8SAlan Cox VM_OBJECT_LOCK(object); 78195461b45SJohn Dyson ma[0] = vm_page_grab(object, 0, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); 78295461b45SJohn Dyson if ((ma[0]->valid & VM_PAGE_BITS_ALL) != VM_PAGE_BITS_ALL) { 78395461b45SJohn Dyson initial_pagein = VM_INITIAL_PAGEIN; 78495461b45SJohn Dyson if (initial_pagein > object->size) 78595461b45SJohn Dyson initial_pagein = object->size; 78695461b45SJohn Dyson for (i = 1; i < initial_pagein; i++) { 787d254af07SMatthew Dillon if ((ma[i] = vm_page_lookup(object, i)) != NULL) { 7886ec2fca5SAlan Cox if (ma[i]->valid) 7896ec2fca5SAlan Cox break; 790ee113343SAlan Cox vm_page_lock_queues(); 79106fa71cdSAlan Cox if ((ma[i]->flags & PG_BUSY) || ma[i]->busy) { 79206fa71cdSAlan Cox vm_page_unlock_queues(); 79306fa71cdSAlan Cox break; 79406fa71cdSAlan Cox } 795e69763a3SDoug Rabson vm_page_busy(ma[i]); 796ee113343SAlan Cox vm_page_unlock_queues(); 79795461b45SJohn Dyson } else { 798ca0387efSJake Burkholder ma[i] = vm_page_alloc(object, i, 799ca0387efSJake Burkholder VM_ALLOC_NORMAL); 80095461b45SJohn Dyson if (ma[i] == NULL) 80195461b45SJohn Dyson break; 80295461b45SJohn Dyson } 80395461b45SJohn Dyson } 80495461b45SJohn Dyson initial_pagein = i; 80595461b45SJohn Dyson rv = vm_pager_get_pages(object, ma, initial_pagein, 0); 80695461b45SJohn Dyson ma[0] = vm_page_lookup(object, 0); 807ca0387efSJake Burkholder if ((rv != VM_PAGER_OK) || (ma[0] == NULL) || 808ca0387efSJake Burkholder (ma[0]->valid == 0)) { 809ecbb00a2SDoug Rabson if (ma[0]) { 8106ec2fca5SAlan Cox vm_page_lock_queues(); 8114fec79beSAlan Cox pmap_remove_all(ma[0]); 8128f9110f6SJohn Dyson vm_page_free(ma[0]); 81306fa71cdSAlan Cox vm_page_unlock_queues(); 8146ec2fca5SAlan Cox } 81506fa71cdSAlan Cox VM_OBJECT_UNLOCK(object); 816a7cddfedSJake Burkholder return (EIO); 8171616db3cSJohn Dyson } 8181616db3cSJohn Dyson } 8196ec2fca5SAlan Cox vm_page_lock_queues(); 820148b3f62SAlan Cox vm_page_hold(ma[0]); 821e69763a3SDoug Rabson vm_page_wakeup(ma[0]); 82297646f56SAlan Cox vm_page_unlock_queues(); 8236ec2fca5SAlan Cox VM_OBJECT_UNLOCK(object); 8241616db3cSJohn Dyson 82559c8bc40SAlan Cox imgp->firstpage = sf_buf_alloc(ma[0], 0); 82659c8bc40SAlan Cox imgp->image_header = (char *)sf_buf_kva(imgp->firstpage); 8271616db3cSJohn Dyson 828a7cddfedSJake Burkholder return (0); 8291616db3cSJohn Dyson } 8301616db3cSJohn Dyson 8311616db3cSJohn Dyson void 8321616db3cSJohn Dyson exec_unmap_first_page(imgp) 8331616db3cSJohn Dyson struct image_params *imgp; 8341616db3cSJohn Dyson { 83559c8bc40SAlan Cox vm_page_t m; 83623955314SAlfred Perlstein 837d6c847f3SBruce Evans if (imgp->firstpage != NULL) { 83859c8bc40SAlan Cox m = sf_buf_page(imgp->firstpage); 83959c8bc40SAlan Cox sf_buf_free(imgp->firstpage); 8401616db3cSJohn Dyson imgp->firstpage = NULL; 84159c8bc40SAlan Cox vm_page_lock_queues(); 84259c8bc40SAlan Cox vm_page_unhold(m); 84359c8bc40SAlan Cox vm_page_unlock_queues(); 8441616db3cSJohn Dyson } 8451616db3cSJohn Dyson } 8461616db3cSJohn Dyson 84726f9a767SRodney W. Grimes /* 84826f9a767SRodney W. Grimes * Destroy old address space, and allocate a new stack 84926f9a767SRodney W. Grimes * The new stack is only SGROWSIZ large because it is grown 85026f9a767SRodney W. Grimes * automatically in trap.c. 85126f9a767SRodney W. Grimes */ 85226f9a767SRodney W. Grimes int 85305ba50f5SJake Burkholder exec_new_vmspace(imgp, sv) 854c52007c2SDavid Greenman struct image_params *imgp; 85505ba50f5SJake Burkholder struct sysentvec *sv; 85626f9a767SRodney W. Grimes { 85726f9a767SRodney W. Grimes int error; 8585e20c11fSAlan Cox struct proc *p = imgp->proc; 8595e20c11fSAlan Cox struct vmspace *vmspace = p->p_vmspace; 86005ba50f5SJake Burkholder vm_offset_t stack_addr; 86105ba50f5SJake Burkholder vm_map_t map; 86226f9a767SRodney W. Grimes 8630cddd8f0SMatthew Dillon GIANT_REQUIRED; 8640cddd8f0SMatthew Dillon 865c52007c2SDavid Greenman imgp->vmspace_destroyed = 1; 86626f9a767SRodney W. Grimes 867a5bdcb2aSPeter Wemm /* Called with Giant held, do not depend on it! */ 86875b8b3b2SJohn Baldwin EVENTHANDLER_INVOKE(process_exec, p); 8696f5dafeaSAlan Cox 8706f5dafeaSAlan Cox /* 871c460ac3aSPeter Wemm * Here is as good a place as any to do any resource limit cleanups. 872c460ac3aSPeter Wemm * This is needed if a 64 bit binary exec's a 32 bit binary - the 873c460ac3aSPeter Wemm * data size limit may need to be changed to a value that makes 874c460ac3aSPeter Wemm * sense for the 32 bit binary. 875c460ac3aSPeter Wemm */ 876d6c847f3SBruce Evans if (sv->sv_fixlimits != NULL) 877c460ac3aSPeter Wemm sv->sv_fixlimits(imgp); 878c460ac3aSPeter Wemm 879c460ac3aSPeter Wemm /* 880af9ec885SJohn Dyson * Blow away entire process VM, if address space not shared, 881af9ec885SJohn Dyson * otherwise, create a new VM space so that other threads are 882af9ec885SJohn Dyson * not disrupted 883af9ec885SJohn Dyson */ 88405ba50f5SJake Burkholder map = &vmspace->vm_map; 88505ba50f5SJake Burkholder if (vmspace->vm_refcnt == 1 && vm_map_min(map) == sv->sv_minuser && 88605ba50f5SJake Burkholder vm_map_max(map) == sv->sv_maxuser) { 8873db161e0SMatthew Dillon shmexit(vmspace); 88805ba50f5SJake Burkholder pmap_remove_pages(vmspace_pmap(vmspace), vm_map_min(map), 88905ba50f5SJake Burkholder vm_map_max(map)); 89005ba50f5SJake Burkholder vm_map_remove(map, vm_map_min(map), vm_map_max(map)); 891af9ec885SJohn Dyson } else { 89205ba50f5SJake Burkholder vmspace_exec(p, sv->sv_minuser, sv->sv_maxuser); 8935e20c11fSAlan Cox vmspace = p->p_vmspace; 89405ba50f5SJake Burkholder map = &vmspace->vm_map; 895af9ec885SJohn Dyson } 89626f9a767SRodney W. Grimes 89726f9a767SRodney W. Grimes /* Allocate a new stack */ 898fd75d710SMarcel Moolenaar stack_addr = sv->sv_usrstack - maxssiz; 89905ba50f5SJake Burkholder error = vm_map_stack(map, stack_addr, (vm_size_t)maxssiz, 900fd75d710SMarcel Moolenaar sv->sv_stackprot, VM_PROT_ALL, MAP_STACK_GROWS_DOWN); 9012267af78SJulian Elischer if (error) 9022267af78SJulian Elischer return (error); 9032267af78SJulian Elischer 90463c47a5cSDoug Rabson #ifdef __ia64__ 905fd75d710SMarcel Moolenaar /* Allocate a new register stack */ 906bab1f052SMarcel Moolenaar stack_addr = IA64_BACKINGSTORE; 907fd75d710SMarcel Moolenaar error = vm_map_stack(map, stack_addr, (vm_size_t)maxssiz, 908fd75d710SMarcel Moolenaar sv->sv_stackprot, VM_PROT_ALL, MAP_STACK_GROWS_UP); 909fd75d710SMarcel Moolenaar if (error) 910fd75d710SMarcel Moolenaar return (error); 91163c47a5cSDoug Rabson #endif 91263c47a5cSDoug Rabson 9132267af78SJulian Elischer /* vm_ssize and vm_maxsaddr are somewhat antiquated concepts in the 9142267af78SJulian Elischer * VM_STACK case, but they are still used to monitor the size of the 9152267af78SJulian Elischer * process stack so we can check the stack rlimit. 9162267af78SJulian Elischer */ 917cbc89bfbSPaul Saab vmspace->vm_ssize = sgrowsiz >> PAGE_SHIFT; 91805ba50f5SJake Burkholder vmspace->vm_maxsaddr = (char *)sv->sv_usrstack - maxssiz; 91926f9a767SRodney W. Grimes 92026f9a767SRodney W. Grimes return (0); 92126f9a767SRodney W. Grimes } 92226f9a767SRodney W. Grimes 92326f9a767SRodney W. Grimes /* 92426f9a767SRodney W. Grimes * Copy out argument and environment strings from the old process 92526f9a767SRodney W. Grimes * address space into the temporary string buffer. 92626f9a767SRodney W. Grimes */ 92726f9a767SRodney W. Grimes int 928c52007c2SDavid Greenman exec_extract_strings(imgp) 929c52007c2SDavid Greenman struct image_params *imgp; 93026f9a767SRodney W. Grimes { 93126f9a767SRodney W. Grimes char **argv, **envv; 93226f9a767SRodney W. Grimes char *argp, *envp; 933ecbb00a2SDoug Rabson int error; 934ecbb00a2SDoug Rabson size_t length; 93526f9a767SRodney W. Grimes 93626f9a767SRodney W. Grimes /* 93726f9a767SRodney W. Grimes * extract arguments first 93826f9a767SRodney W. Grimes */ 93926f9a767SRodney W. Grimes 940450ffb44SRobert Watson argv = imgp->userspace_argv; 94126f9a767SRodney W. Grimes 9420fd1a014SDavid Greenman if (argv) { 943aae0aa45SBruce Evans argp = (caddr_t)(intptr_t)fuword(argv); 9445cf3d12cSAndrey A. Chernov if (argp == (caddr_t)-1) 9455cf3d12cSAndrey A. Chernov return (EFAULT); 9465cf3d12cSAndrey A. Chernov if (argp) 9475cf3d12cSAndrey A. Chernov argv++; 9485cf3d12cSAndrey A. Chernov if (imgp->argv0) 9495cf3d12cSAndrey A. Chernov argp = imgp->argv0; 9505cf3d12cSAndrey A. Chernov if (argp) { 9515cf3d12cSAndrey A. Chernov do { 95226f9a767SRodney W. Grimes if (argp == (caddr_t)-1) 95326f9a767SRodney W. Grimes return (EFAULT); 954c52007c2SDavid Greenman if ((error = copyinstr(argp, imgp->stringp, 955c52007c2SDavid Greenman imgp->stringspace, &length))) { 9560fd1a014SDavid Greenman if (error == ENAMETOOLONG) 95726f9a767SRodney W. Grimes return (E2BIG); 9580fd1a014SDavid Greenman return (error); 9590fd1a014SDavid Greenman } 960c52007c2SDavid Greenman imgp->stringspace -= length; 961c52007c2SDavid Greenman imgp->stringp += length; 962c52007c2SDavid Greenman imgp->argc++; 963aae0aa45SBruce Evans } while ((argp = (caddr_t)(intptr_t)fuword(argv++))); 96426f9a767SRodney W. Grimes } 9657700eb86SRuslan Ermilov } else 9667700eb86SRuslan Ermilov return (EFAULT); 96726f9a767SRodney W. Grimes 968b9df5231SPoul-Henning Kamp imgp->endargs = imgp->stringp; 969b9df5231SPoul-Henning Kamp 97026f9a767SRodney W. Grimes /* 97126f9a767SRodney W. Grimes * extract environment strings 97226f9a767SRodney W. Grimes */ 97326f9a767SRodney W. Grimes 974450ffb44SRobert Watson envv = imgp->userspace_envv; 97526f9a767SRodney W. Grimes 9760fd1a014SDavid Greenman if (envv) { 977aae0aa45SBruce Evans while ((envp = (caddr_t)(intptr_t)fuword(envv++))) { 97826f9a767SRodney W. Grimes if (envp == (caddr_t)-1) 97926f9a767SRodney W. Grimes return (EFAULT); 980c52007c2SDavid Greenman if ((error = copyinstr(envp, imgp->stringp, 981c52007c2SDavid Greenman imgp->stringspace, &length))) { 9820fd1a014SDavid Greenman if (error == ENAMETOOLONG) 98326f9a767SRodney W. Grimes return (E2BIG); 9840fd1a014SDavid Greenman return (error); 9850fd1a014SDavid Greenman } 986c52007c2SDavid Greenman imgp->stringspace -= length; 987c52007c2SDavid Greenman imgp->stringp += length; 988c52007c2SDavid Greenman imgp->envc++; 98926f9a767SRodney W. Grimes } 9900fd1a014SDavid Greenman } 99126f9a767SRodney W. Grimes 99226f9a767SRodney W. Grimes return (0); 99326f9a767SRodney W. Grimes } 99426f9a767SRodney W. Grimes 99526f9a767SRodney W. Grimes /* 99626f9a767SRodney W. Grimes * Copy strings out to the new process address space, constructing 99726f9a767SRodney W. Grimes * new arg and env vector tables. Return a pointer to the base 99826f9a767SRodney W. Grimes * so that it can be used as the initial stack pointer. 99926f9a767SRodney W. Grimes */ 1000654f6be1SBruce Evans register_t * 1001c52007c2SDavid Greenman exec_copyout_strings(imgp) 1002c52007c2SDavid Greenman struct image_params *imgp; 100326f9a767SRodney W. Grimes { 100426f9a767SRodney W. Grimes int argc, envc; 100526f9a767SRodney W. Grimes char **vectp; 100626f9a767SRodney W. Grimes char *stringp, *destp; 1007654f6be1SBruce Evans register_t *stack_base; 100893f6448cSDavid Greenman struct ps_strings *arginfo; 1009f3bec5d7SJake Burkholder struct proc *p; 1010d66a5066SPeter Wemm int szsigcode; 101126f9a767SRodney W. Grimes 101226f9a767SRodney W. Grimes /* 101326f9a767SRodney W. Grimes * Calculate string base and vector table pointers. 1014d66a5066SPeter Wemm * Also deal with signal trampoline code for this exec type. 101526f9a767SRodney W. Grimes */ 1016f3bec5d7SJake Burkholder p = imgp->proc; 1017f3bec5d7SJake Burkholder szsigcode = 0; 101805ba50f5SJake Burkholder arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings; 1019f3bec5d7SJake Burkholder if (p->p_sysent->sv_szsigcode != NULL) 1020f3bec5d7SJake Burkholder szsigcode = *(p->p_sysent->sv_szsigcode); 1021d66a5066SPeter Wemm destp = (caddr_t)arginfo - szsigcode - SPARE_USRSPACE - 10221ed012f9SPeter Wemm roundup((ARG_MAX - imgp->stringspace), sizeof(char *)); 10231ed012f9SPeter Wemm 102426f9a767SRodney W. Grimes /* 1025d66a5066SPeter Wemm * install sigcode 1026d66a5066SPeter Wemm */ 1027d66a5066SPeter Wemm if (szsigcode) 1028f3bec5d7SJake Burkholder copyout(p->p_sysent->sv_sigcode, ((caddr_t)arginfo - 1029f3bec5d7SJake Burkholder szsigcode), szsigcode); 1030d66a5066SPeter Wemm 1031d66a5066SPeter Wemm /* 1032e1743d02SSøren Schmidt * If we have a valid auxargs ptr, prepare some room 1033e1743d02SSøren Schmidt * on the stack. 1034e1743d02SSøren Schmidt */ 1035b9a22da4STakanori Watanabe if (imgp->auxargs) { 1036e1743d02SSøren Schmidt /* 1037b9a22da4STakanori Watanabe * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for 1038b9a22da4STakanori Watanabe * lower compatibility. 1039b9a22da4STakanori Watanabe */ 1040ca0387efSJake Burkholder imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size : 1041ca0387efSJake Burkholder (AT_COUNT * 2); 1042b9a22da4STakanori Watanabe /* 1043b9a22da4STakanori Watanabe * The '+ 2' is for the null pointers at the end of each of 1044b9a22da4STakanori Watanabe * the arg and env vector sets,and imgp->auxarg_size is room 1045b9a22da4STakanori Watanabe * for argument of Runtime loader. 1046e1743d02SSøren Schmidt */ 1047e1743d02SSøren Schmidt vectp = (char **)(destp - (imgp->argc + imgp->envc + 2 + 1048b9a22da4STakanori Watanabe imgp->auxarg_size) * sizeof(char *)); 1049b9a22da4STakanori Watanabe 1050b9a22da4STakanori Watanabe } else 1051e1743d02SSøren Schmidt /* 1052b9a22da4STakanori Watanabe * The '+ 2' is for the null pointers at the end of each of 1053b9a22da4STakanori Watanabe * the arg and env vector sets 105426f9a767SRodney W. Grimes */ 1055ca0387efSJake Burkholder vectp = (char **)(destp - (imgp->argc + imgp->envc + 2) * 1056ca0387efSJake Burkholder sizeof(char *)); 105726f9a767SRodney W. Grimes 105826f9a767SRodney W. Grimes /* 105926f9a767SRodney W. Grimes * vectp also becomes our initial stack base 106026f9a767SRodney W. Grimes */ 1061654f6be1SBruce Evans stack_base = (register_t *)vectp; 106226f9a767SRodney W. Grimes 1063c52007c2SDavid Greenman stringp = imgp->stringbase; 1064c52007c2SDavid Greenman argc = imgp->argc; 1065c52007c2SDavid Greenman envc = imgp->envc; 106626f9a767SRodney W. Grimes 106793f6448cSDavid Greenman /* 10683aed948bSDavid Greenman * Copy out strings - arguments and environment. 106993f6448cSDavid Greenman */ 1070c52007c2SDavid Greenman copyout(stringp, destp, ARG_MAX - imgp->stringspace); 107193f6448cSDavid Greenman 107293f6448cSDavid Greenman /* 10733aed948bSDavid Greenman * Fill in "ps_strings" struct for ps, w, etc. 10743aed948bSDavid Greenman */ 1075aae0aa45SBruce Evans suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp); 10763aed948bSDavid Greenman suword(&arginfo->ps_nargvstr, argc); 10773aed948bSDavid Greenman 10783aed948bSDavid Greenman /* 10793aed948bSDavid Greenman * Fill in argument portion of vector table. 108093f6448cSDavid Greenman */ 108126f9a767SRodney W. Grimes for (; argc > 0; --argc) { 1082aae0aa45SBruce Evans suword(vectp++, (long)(intptr_t)destp); 10833aed948bSDavid Greenman while (*stringp++ != 0) 10843aed948bSDavid Greenman destp++; 10853aed948bSDavid Greenman destp++; 108626f9a767SRodney W. Grimes } 108726f9a767SRodney W. Grimes 10881a6e52d0SJeroen Ruigrok van der Werven /* a null vector table pointer separates the argp's from the envp's */ 10896ab46d52SBruce Evans suword(vectp++, 0); 109026f9a767SRodney W. Grimes 1091aae0aa45SBruce Evans suword(&arginfo->ps_envstr, (long)(intptr_t)vectp); 10923aed948bSDavid Greenman suword(&arginfo->ps_nenvstr, envc); 109393f6448cSDavid Greenman 109493f6448cSDavid Greenman /* 10953aed948bSDavid Greenman * Fill in environment portion of vector table. 109693f6448cSDavid Greenman */ 109726f9a767SRodney W. Grimes for (; envc > 0; --envc) { 1098aae0aa45SBruce Evans suword(vectp++, (long)(intptr_t)destp); 10993aed948bSDavid Greenman while (*stringp++ != 0) 11003aed948bSDavid Greenman destp++; 11013aed948bSDavid Greenman destp++; 110226f9a767SRodney W. Grimes } 110326f9a767SRodney W. Grimes 110426f9a767SRodney W. Grimes /* end of vector table is a null pointer */ 11056ab46d52SBruce Evans suword(vectp, 0); 110626f9a767SRodney W. Grimes 110726f9a767SRodney W. Grimes return (stack_base); 110826f9a767SRodney W. Grimes } 110926f9a767SRodney W. Grimes 111026f9a767SRodney W. Grimes /* 111126f9a767SRodney W. Grimes * Check permissions of file to execute. 1112cf64863aSRobert Watson * Called with imgp->vp locked. 111326f9a767SRodney W. Grimes * Return 0 for success or error code on failure. 111426f9a767SRodney W. Grimes */ 1115c8a79999SPeter Wemm int 1116c52007c2SDavid Greenman exec_check_permissions(imgp) 1117c52007c2SDavid Greenman struct image_params *imgp; 111826f9a767SRodney W. Grimes { 1119c52007c2SDavid Greenman struct vnode *vp = imgp->vp; 1120c52007c2SDavid Greenman struct vattr *attr = imgp->attr; 1121a854ed98SJohn Baldwin struct thread *td; 112226f9a767SRodney W. Grimes int error; 112326f9a767SRodney W. Grimes 1124a854ed98SJohn Baldwin td = curthread; /* XXXKSE */ 1125339b79b9SRobert Watson 1126ec35c2afSRobert Watson /* Get file attributes */ 1127ec35c2afSRobert Watson error = VOP_GETATTR(vp, attr, td->td_ucred, td); 1128ec35c2afSRobert Watson if (error) 1129ec35c2afSRobert Watson return (error); 1130ec35c2afSRobert Watson 1131339b79b9SRobert Watson #ifdef MAC 1132670cb89bSRobert Watson error = mac_check_vnode_exec(td->td_ucred, imgp->vp, imgp); 1133339b79b9SRobert Watson if (error) 1134339b79b9SRobert Watson return (error); 1135339b79b9SRobert Watson #endif 1136339b79b9SRobert Watson 113726f9a767SRodney W. Grimes /* 113826f9a767SRodney W. Grimes * 1) Check if file execution is disabled for the filesystem that this 113926f9a767SRodney W. Grimes * file resides on. 114026f9a767SRodney W. Grimes * 2) Insure that at least one execute bit is on - otherwise root 114126f9a767SRodney W. Grimes * will always succeed, and we don't want to happen unless the 114226f9a767SRodney W. Grimes * file really is executable. 114326f9a767SRodney W. Grimes * 3) Insure that the file is a regular file. 114426f9a767SRodney W. Grimes */ 1145c52007c2SDavid Greenman if ((vp->v_mount->mnt_flag & MNT_NOEXEC) || 114626f9a767SRodney W. Grimes ((attr->va_mode & 0111) == 0) || 1147a854ed98SJohn Baldwin (attr->va_type != VREG)) 114826f9a767SRodney W. Grimes return (EACCES); 114926f9a767SRodney W. Grimes 115026f9a767SRodney W. Grimes /* 115126f9a767SRodney W. Grimes * Zero length files can't be exec'd 115226f9a767SRodney W. Grimes */ 115326f9a767SRodney W. Grimes if (attr->va_size == 0) 115426f9a767SRodney W. Grimes return (ENOEXEC); 115526f9a767SRodney W. Grimes 115626f9a767SRodney W. Grimes /* 115726f9a767SRodney W. Grimes * Check for execute permission to file based on current credentials. 115826f9a767SRodney W. Grimes */ 1159a854ed98SJohn Baldwin error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td); 116026f9a767SRodney W. Grimes if (error) 116126f9a767SRodney W. Grimes return (error); 116226f9a767SRodney W. Grimes 11636d5a0a8cSDavid Greenman /* 11646d5a0a8cSDavid Greenman * Check number of open-for-writes on the file and deny execution 11656d5a0a8cSDavid Greenman * if there are any. 11666d5a0a8cSDavid Greenman */ 11676d5a0a8cSDavid Greenman if (vp->v_writecount) 11686d5a0a8cSDavid Greenman return (ETXTBSY); 11696d5a0a8cSDavid Greenman 11706d5a0a8cSDavid Greenman /* 11716d5a0a8cSDavid Greenman * Call filesystem specific open routine (which does nothing in the 11726d5a0a8cSDavid Greenman * general case). 11736d5a0a8cSDavid Greenman */ 1174a8d43c90SPoul-Henning Kamp error = VOP_OPEN(vp, FREAD, td->td_ucred, td, -1); 117526f9a767SRodney W. Grimes return (error); 1176df8bae1dSRodney W. Grimes } 1177aa855a59SPeter Wemm 1178aa855a59SPeter Wemm /* 1179aa855a59SPeter Wemm * Exec handler registration 1180aa855a59SPeter Wemm */ 1181aa855a59SPeter Wemm int 1182aa855a59SPeter Wemm exec_register(execsw_arg) 1183aa855a59SPeter Wemm const struct execsw *execsw_arg; 1184aa855a59SPeter Wemm { 1185aa855a59SPeter Wemm const struct execsw **es, **xs, **newexecsw; 1186aa855a59SPeter Wemm int count = 2; /* New slot and trailing NULL */ 1187aa855a59SPeter Wemm 1188aa855a59SPeter Wemm if (execsw) 1189aa855a59SPeter Wemm for (es = execsw; *es; es++) 1190aa855a59SPeter Wemm count++; 1191a163d034SWarner Losh newexecsw = malloc(count * sizeof(*es), M_TEMP, M_WAITOK); 1192aa855a59SPeter Wemm if (newexecsw == NULL) 1193a7cddfedSJake Burkholder return (ENOMEM); 1194aa855a59SPeter Wemm xs = newexecsw; 1195aa855a59SPeter Wemm if (execsw) 1196aa855a59SPeter Wemm for (es = execsw; *es; es++) 1197aa855a59SPeter Wemm *xs++ = *es; 1198aa855a59SPeter Wemm *xs++ = execsw_arg; 1199aa855a59SPeter Wemm *xs = NULL; 1200aa855a59SPeter Wemm if (execsw) 1201aa855a59SPeter Wemm free(execsw, M_TEMP); 1202aa855a59SPeter Wemm execsw = newexecsw; 1203a7cddfedSJake Burkholder return (0); 1204aa855a59SPeter Wemm } 1205aa855a59SPeter Wemm 1206aa855a59SPeter Wemm int 1207aa855a59SPeter Wemm exec_unregister(execsw_arg) 1208aa855a59SPeter Wemm const struct execsw *execsw_arg; 1209aa855a59SPeter Wemm { 1210aa855a59SPeter Wemm const struct execsw **es, **xs, **newexecsw; 1211aa855a59SPeter Wemm int count = 1; 1212aa855a59SPeter Wemm 1213aa855a59SPeter Wemm if (execsw == NULL) 1214aa855a59SPeter Wemm panic("unregister with no handlers left?\n"); 1215aa855a59SPeter Wemm 1216aa855a59SPeter Wemm for (es = execsw; *es; es++) { 1217aa855a59SPeter Wemm if (*es == execsw_arg) 1218aa855a59SPeter Wemm break; 1219aa855a59SPeter Wemm } 1220aa855a59SPeter Wemm if (*es == NULL) 1221a7cddfedSJake Burkholder return (ENOENT); 1222aa855a59SPeter Wemm for (es = execsw; *es; es++) 1223aa855a59SPeter Wemm if (*es != execsw_arg) 1224aa855a59SPeter Wemm count++; 1225a163d034SWarner Losh newexecsw = malloc(count * sizeof(*es), M_TEMP, M_WAITOK); 1226aa855a59SPeter Wemm if (newexecsw == NULL) 1227a7cddfedSJake Burkholder return (ENOMEM); 1228aa855a59SPeter Wemm xs = newexecsw; 1229aa855a59SPeter Wemm for (es = execsw; *es; es++) 1230aa855a59SPeter Wemm if (*es != execsw_arg) 1231aa855a59SPeter Wemm *xs++ = *es; 1232aa855a59SPeter Wemm *xs = NULL; 1233aa855a59SPeter Wemm if (execsw) 1234aa855a59SPeter Wemm free(execsw, M_TEMP); 1235aa855a59SPeter Wemm execsw = newexecsw; 1236a7cddfedSJake Burkholder return (0); 1237aa855a59SPeter Wemm } 1238