xref: /freebsd/sys/kern/kern_exec.c (revision 8516dd18e1380699ae90775760436483bfda23a2)
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