xref: /freebsd/sys/kern/kern_exec.c (revision f231de478ebb97e0d19fe8c0f95bcd7ac78492bc)
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 
304da0d332SPeter Wemm #include "opt_hwpmc_hooks.h"
311e9b3d91SPeter Wemm #include "opt_ktrace.h"
32339b79b9SRobert Watson #include "opt_mac.h"
331e9b3d91SPeter Wemm 
34df8bae1dSRodney W. Grimes #include <sys/param.h>
3526f9a767SRodney W. Grimes #include <sys/systm.h>
3675b8b3b2SJohn Baldwin #include <sys/eventhandler.h>
37fb919e4dSMark Murray #include <sys/lock.h>
38fb919e4dSMark Murray #include <sys/mutex.h>
39d2d3e875SBruce Evans #include <sys/sysproto.h>
4026f9a767SRodney W. Grimes #include <sys/signalvar.h>
4126f9a767SRodney W. Grimes #include <sys/kernel.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>
51acd3428bSRobert Watson #include <sys/priv.h>
52a794e791SBruce Evans #include <sys/proc.h>
532a024a2bSSean Eric Fagan #include <sys/pioctl.h>
54a794e791SBruce Evans #include <sys/namei.h>
556004362eSDavid Schultz #include <sys/resourcevar.h>
5659c8bc40SAlan Cox #include <sys/sf_buf.h>
5784e0b075SDavid Xu #include <sys/syscallsubr.h>
581e1e0b44SSøren Schmidt #include <sys/sysent.h>
59797f2d22SPoul-Henning Kamp #include <sys/shm.h>
6099ac3bc8SPeter Wemm #include <sys/sysctl.h>
61a794e791SBruce Evans #include <sys/vnode.h>
62c781aea8SPeter Wemm #ifdef KTRACE
63c781aea8SPeter Wemm #include <sys/ktrace.h>
64c781aea8SPeter Wemm #endif
6526f9a767SRodney W. Grimes 
6626f9a767SRodney W. Grimes #include <vm/vm.h>
67efeaf95aSDavid Greenman #include <vm/vm_param.h>
68efeaf95aSDavid Greenman #include <vm/pmap.h>
691616db3cSJohn Dyson #include <vm/vm_page.h>
70efeaf95aSDavid Greenman #include <vm/vm_map.h>
7126f9a767SRodney W. Grimes #include <vm/vm_kern.h>
72efeaf95aSDavid Greenman #include <vm/vm_extern.h>
731ebd0c59SDavid Greenman #include <vm/vm_object.h>
741616db3cSJohn Dyson #include <vm/vm_pager.h>
7526f9a767SRodney W. Grimes 
76ebccf1e3SJoseph Koshy #ifdef	HWPMC_HOOKS
77ebccf1e3SJoseph Koshy #include <sys/pmckern.h>
78ebccf1e3SJoseph Koshy #endif
79ebccf1e3SJoseph Koshy 
8026f9a767SRodney W. Grimes #include <machine/reg.h>
8126f9a767SRodney W. Grimes 
82ae1078d6SWayne Salamon #include <security/audit/audit.h>
83aed55708SRobert Watson #include <security/mac/mac_framework.h>
84ae1078d6SWayne Salamon 
85b9df5231SPoul-Henning Kamp MALLOC_DEFINE(M_PARGS, "proc-args", "Process arguments");
86b9df5231SPoul-Henning Kamp 
8705ba50f5SJake Burkholder static int sysctl_kern_ps_strings(SYSCTL_HANDLER_ARGS);
8805ba50f5SJake Burkholder static int sysctl_kern_usrstack(SYSCTL_HANDLER_ARGS);
895dadd17bSJake Burkholder static int sysctl_kern_stackprot(SYSCTL_HANDLER_ARGS);
90610ecfe0SMaxim Sobolev static int do_execve(struct thread *td, struct image_args *args,
91610ecfe0SMaxim Sobolev     struct mac *mac_p);
928917b8d2SJohn Baldwin static void exec_free_args(struct image_args *);
9305ba50f5SJake Burkholder 
949701cd40SJohn Baldwin /* XXX This should be vm_size_t. */
9505ba50f5SJake Burkholder SYSCTL_PROC(_kern, KERN_PS_STRINGS, ps_strings, CTLTYPE_ULONG|CTLFLAG_RD,
9605ba50f5SJake Burkholder     NULL, 0, sysctl_kern_ps_strings, "LU", "");
97486bddb0SDoug Rabson 
989701cd40SJohn Baldwin /* XXX This should be vm_size_t. */
9905ba50f5SJake Burkholder SYSCTL_PROC(_kern, KERN_USRSTACK, usrstack, CTLTYPE_ULONG|CTLFLAG_RD,
10005ba50f5SJake Burkholder     NULL, 0, sysctl_kern_usrstack, "LU", "");
10199ac3bc8SPeter Wemm 
1025dadd17bSJake Burkholder SYSCTL_PROC(_kern, OID_AUTO, stackprot, CTLTYPE_INT|CTLFLAG_RD,
1035dadd17bSJake Burkholder     NULL, 0, sysctl_kern_stackprot, "I", "");
1045dadd17bSJake Burkholder 
105b9df5231SPoul-Henning Kamp u_long ps_arg_cache_limit = PAGE_SIZE / 16;
106c3699b5fSPeter Wemm SYSCTL_ULONG(_kern, OID_AUTO, ps_arg_cache_limit, CTLFLAG_RW,
1079701cd40SJohn Baldwin     &ps_arg_cache_limit, 0, "");
108b9df5231SPoul-Henning Kamp 
10905ba50f5SJake Burkholder static int
11005ba50f5SJake Burkholder sysctl_kern_ps_strings(SYSCTL_HANDLER_ARGS)
11105ba50f5SJake Burkholder {
11205ba50f5SJake Burkholder 	struct proc *p;
113df7c361eSPeter Wemm 	int error;
11405ba50f5SJake Burkholder 
11505ba50f5SJake Burkholder 	p = curproc;
116a7bc3102SPeter Wemm #ifdef SCTL_MASK32
117a7bc3102SPeter Wemm 	if (req->flags & SCTL_MASK32) {
118df7c361eSPeter Wemm 		unsigned int val;
119df7c361eSPeter Wemm 		val = (unsigned int)p->p_sysent->sv_psstrings;
120df7c361eSPeter Wemm 		error = SYSCTL_OUT(req, &val, sizeof(val));
121df7c361eSPeter Wemm 	} else
122df7c361eSPeter Wemm #endif
123df7c361eSPeter Wemm 		error = SYSCTL_OUT(req, &p->p_sysent->sv_psstrings,
124df7c361eSPeter Wemm 		   sizeof(p->p_sysent->sv_psstrings));
125df7c361eSPeter Wemm 	return error;
12605ba50f5SJake Burkholder }
12705ba50f5SJake Burkholder 
12805ba50f5SJake Burkholder static int
12905ba50f5SJake Burkholder sysctl_kern_usrstack(SYSCTL_HANDLER_ARGS)
13005ba50f5SJake Burkholder {
13105ba50f5SJake Burkholder 	struct proc *p;
132df7c361eSPeter Wemm 	int error;
13305ba50f5SJake Burkholder 
13405ba50f5SJake Burkholder 	p = curproc;
135a7bc3102SPeter Wemm #ifdef SCTL_MASK32
136a7bc3102SPeter Wemm 	if (req->flags & SCTL_MASK32) {
137df7c361eSPeter Wemm 		unsigned int val;
138df7c361eSPeter Wemm 		val = (unsigned int)p->p_sysent->sv_usrstack;
139df7c361eSPeter Wemm 		error = SYSCTL_OUT(req, &val, sizeof(val));
140df7c361eSPeter Wemm 	} else
141df7c361eSPeter Wemm #endif
142df7c361eSPeter Wemm 		error = SYSCTL_OUT(req, &p->p_sysent->sv_usrstack,
143df7c361eSPeter Wemm 		    sizeof(p->p_sysent->sv_usrstack));
144df7c361eSPeter Wemm 	return error;
14505ba50f5SJake Burkholder }
14605ba50f5SJake Burkholder 
1475dadd17bSJake Burkholder static int
1485dadd17bSJake Burkholder sysctl_kern_stackprot(SYSCTL_HANDLER_ARGS)
1495dadd17bSJake Burkholder {
1505dadd17bSJake Burkholder 	struct proc *p;
1515dadd17bSJake Burkholder 
1525dadd17bSJake Burkholder 	p = curproc;
1535dadd17bSJake Burkholder 	return (SYSCTL_OUT(req, &p->p_sysent->sv_stackprot,
1545dadd17bSJake Burkholder 	    sizeof(p->p_sysent->sv_stackprot)));
1555dadd17bSJake Burkholder }
1565dadd17bSJake Burkholder 
15799ac3bc8SPeter Wemm /*
158aa855a59SPeter Wemm  * Each of the items is a pointer to a `const struct execsw', hence the
159aa855a59SPeter Wemm  * double pointer here.
160df8bae1dSRodney W. Grimes  */
161aa855a59SPeter Wemm static const struct execsw **execsw;
16226f9a767SRodney W. Grimes 
163ca46e90eSBruce Evans #ifndef _SYS_SYSPROTO_H_
164ca46e90eSBruce Evans struct execve_args {
165ca46e90eSBruce Evans 	char    *fname;
166ca46e90eSBruce Evans 	char    **argv;
167ca46e90eSBruce Evans 	char    **envv;
168ca46e90eSBruce Evans };
169ca46e90eSBruce Evans #endif
170ca46e90eSBruce Evans 
171ca46e90eSBruce Evans int
172ca46e90eSBruce Evans execve(td, uap)
173ca46e90eSBruce Evans 	struct thread *td;
174ca46e90eSBruce Evans 	struct execve_args /* {
175ca46e90eSBruce Evans 		char *fname;
176ca46e90eSBruce Evans 		char **argv;
177ca46e90eSBruce Evans 		char **envv;
178ca46e90eSBruce Evans 	} */ *uap;
179ca46e90eSBruce Evans {
180610ecfe0SMaxim Sobolev 	int error;
181610ecfe0SMaxim Sobolev 	struct image_args args;
182ca46e90eSBruce Evans 
183610ecfe0SMaxim Sobolev 	error = exec_copyin_args(&args, uap->fname, UIO_USERSPACE,
184610ecfe0SMaxim Sobolev 	    uap->argv, uap->envv);
185610ecfe0SMaxim Sobolev 	if (error == 0)
186610ecfe0SMaxim Sobolev 		error = kern_execve(td, &args, NULL);
187610ecfe0SMaxim Sobolev 	return (error);
188ca46e90eSBruce Evans }
189ca46e90eSBruce Evans 
190ca46e90eSBruce Evans #ifndef _SYS_SYSPROTO_H_
191ca46e90eSBruce Evans struct __mac_execve_args {
192ca46e90eSBruce Evans 	char	*fname;
193ca46e90eSBruce Evans 	char	**argv;
194ca46e90eSBruce Evans 	char	**envv;
195ca46e90eSBruce Evans 	struct mac	*mac_p;
196ca46e90eSBruce Evans };
197ca46e90eSBruce Evans #endif
198ca46e90eSBruce Evans 
199ca46e90eSBruce Evans int
200ca46e90eSBruce Evans __mac_execve(td, uap)
201ca46e90eSBruce Evans 	struct thread *td;
202ca46e90eSBruce Evans 	struct __mac_execve_args /* {
203ca46e90eSBruce Evans 		char *fname;
204ca46e90eSBruce Evans 		char **argv;
205ca46e90eSBruce Evans 		char **envv;
206ca46e90eSBruce Evans 		struct mac *mac_p;
207ca46e90eSBruce Evans 	} */ *uap;
208ca46e90eSBruce Evans {
209ca46e90eSBruce Evans #ifdef MAC
210610ecfe0SMaxim Sobolev 	int error;
211610ecfe0SMaxim Sobolev 	struct image_args args;
212610ecfe0SMaxim Sobolev 
213610ecfe0SMaxim Sobolev 	error = exec_copyin_args(&args, uap->fname, UIO_USERSPACE,
214610ecfe0SMaxim Sobolev 	    uap->argv, uap->envv);
215610ecfe0SMaxim Sobolev 	if (error == 0)
216610ecfe0SMaxim Sobolev 		error = kern_execve(td, &args, uap->mac_p);
217610ecfe0SMaxim Sobolev 	return (error);
218ca46e90eSBruce Evans #else
219ca46e90eSBruce Evans 	return (ENOSYS);
220ca46e90eSBruce Evans #endif
221ca46e90eSBruce Evans }
222ca46e90eSBruce Evans 
22333812c06SColin Percival /*
224873fbcd7SRobert Watson  * XXX: kern_execve has the astonishing property of not always returning to
225873fbcd7SRobert Watson  * the caller.  If sufficiently bad things happen during the call to
226873fbcd7SRobert Watson  * do_execve(), it can end up calling exit1(); as a result, callers must
227873fbcd7SRobert Watson  * avoid doing anything which they might need to undo (e.g., allocating
228873fbcd7SRobert Watson  * memory).
22933812c06SColin Percival  */
23084e0b075SDavid Xu int
231610ecfe0SMaxim Sobolev kern_execve(td, args, mac_p)
232906ac69dSDavid Xu 	struct thread *td;
233610ecfe0SMaxim Sobolev 	struct image_args *args;
234906ac69dSDavid Xu 	struct mac *mac_p;
235906ac69dSDavid Xu {
236906ac69dSDavid Xu 	struct proc *p = td->td_proc;
237906ac69dSDavid Xu 	int error;
238906ac69dSDavid Xu 
239ae1078d6SWayne Salamon 	AUDIT_ARG(argv, args->begin_argv, args->argc,
240ae1078d6SWayne Salamon 	    args->begin_envv - args->begin_argv);
241ae1078d6SWayne Salamon 	AUDIT_ARG(envv, args->begin_envv, args->envc,
242ae1078d6SWayne Salamon 	    args->endp - args->begin_envv);
243906ac69dSDavid Xu 	if (p->p_flag & P_HADTHREADS) {
244906ac69dSDavid Xu 		PROC_LOCK(p);
245906ac69dSDavid Xu 		if (thread_single(SINGLE_BOUNDARY)) {
246906ac69dSDavid Xu 			PROC_UNLOCK(p);
24768ff3c24SStephan Uphoff 	       		exec_free_args(args);
248906ac69dSDavid Xu 			return (ERESTART);	/* Try again later. */
249906ac69dSDavid Xu 		}
250906ac69dSDavid Xu 		PROC_UNLOCK(p);
251906ac69dSDavid Xu 	}
252906ac69dSDavid Xu 
253610ecfe0SMaxim Sobolev 	error = do_execve(td, args, mac_p);
254906ac69dSDavid Xu 
255906ac69dSDavid Xu 	if (p->p_flag & P_HADTHREADS) {
256906ac69dSDavid Xu 		PROC_LOCK(p);
257906ac69dSDavid Xu 		/*
258906ac69dSDavid Xu 		 * If success, we upgrade to SINGLE_EXIT state to
259906ac69dSDavid Xu 		 * force other threads to suicide.
260906ac69dSDavid Xu 		 */
261906ac69dSDavid Xu 		if (error == 0)
262906ac69dSDavid Xu 			thread_single(SINGLE_EXIT);
263906ac69dSDavid Xu 		else
264906ac69dSDavid Xu 			thread_single_end();
265906ac69dSDavid Xu 		PROC_UNLOCK(p);
266906ac69dSDavid Xu 	}
267906ac69dSDavid Xu 
268906ac69dSDavid Xu 	return (error);
269906ac69dSDavid Xu }
270906ac69dSDavid Xu 
27126f9a767SRodney W. Grimes /*
272450ffb44SRobert Watson  * In-kernel implementation of execve().  All arguments are assumed to be
273450ffb44SRobert Watson  * userspace pointers from the passed thread.
27426f9a767SRodney W. Grimes  */
275450ffb44SRobert Watson static int
276610ecfe0SMaxim Sobolev do_execve(td, args, mac_p)
277b40ce416SJulian Elischer 	struct thread *td;
278610ecfe0SMaxim Sobolev 	struct image_args *args;
279670cb89bSRobert Watson 	struct mac *mac_p;
280df8bae1dSRodney W. Grimes {
281b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
28226f9a767SRodney W. Grimes 	struct nameidata nd, *ndp;
2839b3b1c5fSJohn Baldwin 	struct ucred *newcred = NULL, *oldcred;
2841419eacbSAlfred Perlstein 	struct uidinfo *euip;
285654f6be1SBruce Evans 	register_t *stack_base;
286bb56ec4aSPoul-Henning Kamp 	int error, len, i;
287c52007c2SDavid Greenman 	struct image_params image_params, *imgp;
2889f5c1d19SDiomidis Spinellis 	struct vattr attr;
2894d77a549SAlfred Perlstein 	int (*img_first)(struct image_params *);
29069be5db9SAlfred Perlstein 	struct pargs *oldargs = NULL, *newargs = NULL;
29190af4afaSJohn Baldwin 	struct sigacts *oldsigacts, *newsigacts;
2926c84de02SJohn Baldwin #ifdef KTRACE
2936c84de02SJohn Baldwin 	struct vnode *tracevp = NULL;
294a5881ea5SJohn Baldwin 	struct ucred *tracecred = NULL;
2956c84de02SJohn Baldwin #endif
2966c84de02SJohn Baldwin 	struct vnode *textvp = NULL;
297d06c0d4dSRobert Watson 	int credential_changing;
298269576c8SJeff Roberson 	int vfslocked;
299619eb6e5SJeff Roberson 	int textset;
300ccafe7ebSRobert Watson #ifdef MAC
301eca8a663SRobert Watson 	struct label *interplabel = NULL;
302eca8a663SRobert Watson 	int will_transition;
303ccafe7ebSRobert Watson #endif
30415139246SJoseph Koshy #ifdef HWPMC_HOOKS
30515139246SJoseph Koshy 	struct pmckern_procexec pe;
30615139246SJoseph Koshy #endif
30726f9a767SRodney W. Grimes 
308532c491bSJeff Roberson 	vfslocked = 0;
309c52007c2SDavid Greenman 	imgp = &image_params;
310df8bae1dSRodney W. Grimes 
3119ca45e81SDag-Erling Smørgrav 	/*
3129ca45e81SDag-Erling Smørgrav 	 * Lock the process and set the P_INEXEC flag to indicate that
3139ca45e81SDag-Erling Smørgrav 	 * it should be left alone until we're done here.  This is
3149ca45e81SDag-Erling Smørgrav 	 * necessary to avoid race conditions - e.g. in ptrace() -
3159ca45e81SDag-Erling Smørgrav 	 * that might allow a local user to illicitly obtain elevated
3169ca45e81SDag-Erling Smørgrav 	 * privileges.
3179ca45e81SDag-Erling Smørgrav 	 */
3189ca45e81SDag-Erling Smørgrav 	PROC_LOCK(p);
3199ca45e81SDag-Erling Smørgrav 	KASSERT((p->p_flag & P_INEXEC) == 0,
32091f91617SDavid E. O'Brien 	    ("%s(): process already has P_INEXEC flag", __func__));
3219ca45e81SDag-Erling Smørgrav 	p->p_flag |= P_INEXEC;
3229ca45e81SDag-Erling Smørgrav 	PROC_UNLOCK(p);
3239ca45e81SDag-Erling Smørgrav 
324df8bae1dSRodney W. Grimes 	/*
325c52007c2SDavid Greenman 	 * Initialize part of the common data
326df8bae1dSRodney W. Grimes 	 */
327c52007c2SDavid Greenman 	imgp->proc = p;
328670cb89bSRobert Watson 	imgp->execlabel = NULL;
329c52007c2SDavid Greenman 	imgp->attr = &attr;
330c52007c2SDavid Greenman 	imgp->entry_addr = 0;
331c52007c2SDavid Greenman 	imgp->vmspace_destroyed = 0;
332c52007c2SDavid Greenman 	imgp->interpreted = 0;
33390dc539bSMaxim Sobolev 	imgp->interpreter_name = args->buf + PATH_MAX + ARG_MAX;
334e1743d02SSøren Schmidt 	imgp->auxargs = NULL;
3351616db3cSJohn Dyson 	imgp->vp = NULL;
3360b2ed1aeSJeff Roberson 	imgp->object = NULL;
3371616db3cSJohn Dyson 	imgp->firstpage = NULL;
3384fe88fe6SJohn Polstra 	imgp->ps_strings = 0;
339b9a22da4STakanori Watanabe 	imgp->auxarg_size = 0;
340610ecfe0SMaxim Sobolev 	imgp->args = args;
34126f9a767SRodney W. Grimes 
342670cb89bSRobert Watson #ifdef MAC
343eca8a663SRobert Watson 	error = mac_execve_enter(imgp, mac_p);
344532c491bSJeff Roberson 	if (error)
345670cb89bSRobert Watson 		goto exec_fail;
346670cb89bSRobert Watson #endif
347670cb89bSRobert Watson 
34859c8bc40SAlan Cox 	imgp->image_header = NULL;
34926f9a767SRodney W. Grimes 
35026f9a767SRodney W. Grimes 	/*
35126f9a767SRodney W. Grimes 	 * Translate the file name. namei() returns a vnode pointer
35226f9a767SRodney W. Grimes 	 *	in ni_vp amoung other things.
353ae1078d6SWayne Salamon 	 *
354ae1078d6SWayne Salamon 	 * XXXAUDIT: It would be desirable to also audit the name of the
355ae1078d6SWayne Salamon 	 * interpreter if this is an interpreted binary.
35626f9a767SRodney W. Grimes 	 */
35726f9a767SRodney W. Grimes 	ndp = &nd;
3584bb260adSRobert Watson 	NDINIT(ndp, LOOKUP, ISOPEN | LOCKLEAF | FOLLOW | SAVENAME | MPSAFE |
3594bb260adSRobert Watson 	    AUDITVNODE1, UIO_SYSSPACE, args->fname, td);
36026f9a767SRodney W. Grimes 
36126f9a767SRodney W. Grimes interpret:
36226f9a767SRodney W. Grimes 	error = namei(ndp);
363610ecfe0SMaxim Sobolev 	if (error)
36426f9a767SRodney W. Grimes 		goto exec_fail;
36526f9a767SRodney W. Grimes 
366269576c8SJeff Roberson 	vfslocked = NDHASGIANT(ndp);
367c52007c2SDavid Greenman 	imgp->vp = ndp->ni_vp;
36826f9a767SRodney W. Grimes 
36926f9a767SRodney W. Grimes 	/*
3709022e4adSDavid Greenman 	 * Check file permissions (also 'opens' file)
3719022e4adSDavid Greenman 	 */
372c52007c2SDavid Greenman 	error = exec_check_permissions(imgp);
373619eb6e5SJeff Roberson 	if (error)
37426f9a767SRodney W. Grimes 		goto exec_fail_dealloc;
375619eb6e5SJeff Roberson 
3768516dd18SPoul-Henning Kamp 	imgp->object = imgp->vp->v_object;
3778516dd18SPoul-Henning Kamp 	if (imgp->object != NULL)
3780b2ed1aeSJeff Roberson 		vm_object_reference(imgp->object);
37926f9a767SRodney W. Grimes 
380619eb6e5SJeff Roberson 	/*
381619eb6e5SJeff Roberson 	 * Set VV_TEXT now so no one can write to the executable while we're
382619eb6e5SJeff Roberson 	 * activating it.
383619eb6e5SJeff Roberson 	 *
384619eb6e5SJeff Roberson 	 * Remember if this was set before and unset it in case this is not
385619eb6e5SJeff Roberson 	 * actually an executable image.
386619eb6e5SJeff Roberson 	 */
387619eb6e5SJeff Roberson 	textset = imgp->vp->v_vflag & VV_TEXT;
388619eb6e5SJeff Roberson 	imgp->vp->v_vflag |= VV_TEXT;
389619eb6e5SJeff Roberson 
3901616db3cSJohn Dyson 	error = exec_map_first_page(imgp);
3916d5a0a8cSDavid Greenman 	if (error)
39226f9a767SRodney W. Grimes 		goto exec_fail_dealloc;
39326f9a767SRodney W. Grimes 
394f231de47SKonstantin Belousov 	imgp->proc->p_osrel = 0;
39526f9a767SRodney W. Grimes 	/*
396d323ddf3SMatthew Dillon 	 *	If the current process has a special image activator it
397d323ddf3SMatthew Dillon 	 *	wants to try first, call it.   For example, emulating shell
398d323ddf3SMatthew Dillon 	 *	scripts differently.
39926f9a767SRodney W. Grimes 	 */
400d323ddf3SMatthew Dillon 	error = -1;
401d323ddf3SMatthew Dillon 	if ((img_first = imgp->proc->p_sysent->sv_imgact_try) != NULL)
402d323ddf3SMatthew Dillon 		error = img_first(imgp);
403d323ddf3SMatthew Dillon 
404d323ddf3SMatthew Dillon 	/*
405d323ddf3SMatthew Dillon 	 *	Loop through the list of image activators, calling each one.
406d323ddf3SMatthew Dillon 	 *	An activator returns -1 if there is no match, 0 on success,
407d323ddf3SMatthew Dillon 	 *	and an error otherwise.
408d323ddf3SMatthew Dillon 	 */
409d323ddf3SMatthew Dillon 	for (i = 0; error == -1 && execsw[i]; ++i) {
410d323ddf3SMatthew Dillon 		if (execsw[i]->ex_imgact == NULL ||
411d323ddf3SMatthew Dillon 		    execsw[i]->ex_imgact == img_first) {
412d323ddf3SMatthew Dillon 			continue;
413d323ddf3SMatthew Dillon 		}
414c52007c2SDavid Greenman 		error = (*execsw[i]->ex_imgact)(imgp);
415d323ddf3SMatthew Dillon 	}
416d323ddf3SMatthew Dillon 
417d323ddf3SMatthew Dillon 	if (error) {
418619eb6e5SJeff Roberson 		if (error == -1) {
419619eb6e5SJeff Roberson 			if (textset == 0)
420619eb6e5SJeff Roberson 				imgp->vp->v_vflag &= ~VV_TEXT;
421d323ddf3SMatthew Dillon 			error = ENOEXEC;
422619eb6e5SJeff Roberson 		}
42326f9a767SRodney W. Grimes 		goto exec_fail_dealloc;
424d323ddf3SMatthew Dillon 	}
425d323ddf3SMatthew Dillon 
426d323ddf3SMatthew Dillon 	/*
427d323ddf3SMatthew Dillon 	 * Special interpreter operation, cleanup and loop up to try to
428d323ddf3SMatthew Dillon 	 * activate the interpreter.
429d323ddf3SMatthew Dillon 	 */
430c52007c2SDavid Greenman 	if (imgp->interpreted) {
4311616db3cSJohn Dyson 		exec_unmap_first_page(imgp);
432619eb6e5SJeff Roberson 		/*
433619eb6e5SJeff Roberson 		 * VV_TEXT needs to be unset for scripts.  There is a short
434619eb6e5SJeff Roberson 		 * period before we determine that something is a script where
435619eb6e5SJeff Roberson 		 * VV_TEXT will be set. The vnode lock is held over this
436619eb6e5SJeff Roberson 		 * entire period so nothing should illegitimately be blocked.
437619eb6e5SJeff Roberson 		 */
438619eb6e5SJeff Roberson 		imgp->vp->v_vflag &= ~VV_TEXT;
439762e6b85SEivind Eklund 		/* free name buffer and old vnode */
440762e6b85SEivind Eklund 		NDFREE(ndp, NDF_ONLY_PNBUF);
441670cb89bSRobert Watson #ifdef MAC
442eca8a663SRobert Watson 		interplabel = mac_vnode_label_alloc();
44330d239bcSRobert Watson 		mac_vnode_copy_label(ndp->ni_vp->v_label, interplabel);
444670cb89bSRobert Watson #endif
445619eb6e5SJeff Roberson 		vput(ndp->ni_vp);
4460b2ed1aeSJeff Roberson 		vm_object_deallocate(imgp->object);
4470b2ed1aeSJeff Roberson 		imgp->object = NULL;
448269576c8SJeff Roberson 		VFS_UNLOCK_GIANT(vfslocked);
449532c491bSJeff Roberson 		vfslocked = 0;
45026f9a767SRodney W. Grimes 		/* set new name to that of the interpreter */
451269576c8SJeff Roberson 		NDINIT(ndp, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME | MPSAFE,
452b40ce416SJulian Elischer 		    UIO_SYSSPACE, imgp->interpreter_name, td);
45326f9a767SRodney W. Grimes 		goto interpret;
45426f9a767SRodney W. Grimes 	}
45526f9a767SRodney W. Grimes 
45626f9a767SRodney W. Grimes 	/*
45726f9a767SRodney W. Grimes 	 * Copy out strings (args and env) and initialize stack base
45826f9a767SRodney W. Grimes 	 */
4593ebc1248SPeter Wemm 	if (p->p_sysent->sv_copyout_strings)
4603ebc1248SPeter Wemm 		stack_base = (*p->p_sysent->sv_copyout_strings)(imgp);
4613ebc1248SPeter Wemm 	else
462c52007c2SDavid Greenman 		stack_base = exec_copyout_strings(imgp);
46326f9a767SRodney W. Grimes 
46426f9a767SRodney W. Grimes 	/*
4651e1e0b44SSøren Schmidt 	 * If custom stack fixup routine present for this process
4661e1e0b44SSøren Schmidt 	 * let it do the stack setup.
4671e1e0b44SSøren Schmidt 	 * Else stuff argument count as first item on stack
46826f9a767SRodney W. Grimes 	 */
469d6c847f3SBruce Evans 	if (p->p_sysent->sv_fixup != NULL)
470c52007c2SDavid Greenman 		(*p->p_sysent->sv_fixup)(&stack_base, imgp);
4711e1e0b44SSøren Schmidt 	else
472610ecfe0SMaxim Sobolev 		suword(--stack_base, imgp->args->argc);
47326f9a767SRodney W. Grimes 
474a78e8d2aSDavid Greenman 	/*
475a78e8d2aSDavid Greenman 	 * For security and other reasons, the file descriptor table cannot
476a78e8d2aSDavid Greenman 	 * be shared after an exec.
477a78e8d2aSDavid Greenman 	 */
478c113083cSPoul-Henning Kamp 	fdunshare(p, td);
479a78e8d2aSDavid Greenman 
480333ea485SGuido van Rooij 	/*
4819b3b1c5fSJohn Baldwin 	 * Malloc things before we need locks.
4829b3b1c5fSJohn Baldwin 	 */
4839b3b1c5fSJohn Baldwin 	newcred = crget();
4841419eacbSAlfred Perlstein 	euip = uifind(attr.va_uid);
485610ecfe0SMaxim Sobolev 	i = imgp->args->begin_envv - imgp->args->begin_argv;
4865997cae9SDon Lewis 	/* Cache arguments if they fit inside our allowance */
4875997cae9SDon Lewis 	if (ps_arg_cache_limit >= i + sizeof(struct pargs)) {
4889b3b1c5fSJohn Baldwin 		newargs = pargs_alloc(i);
4895997cae9SDon Lewis 		bcopy(imgp->args->begin_argv, newargs->ar_args, i);
4905997cae9SDon Lewis 	}
4919b3b1c5fSJohn Baldwin 
4929b3b1c5fSJohn Baldwin 	/* close files on exec */
493d302786cSTor Egge 	VOP_UNLOCK(imgp->vp, 0, td);
4949b3b1c5fSJohn Baldwin 	fdcloseexec(td);
495d302786cSTor Egge 	vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY, td);
4969b3b1c5fSJohn Baldwin 
497619eb6e5SJeff Roberson 	/* Get a reference to the vnode prior to locking the proc */
498619eb6e5SJeff Roberson 	VREF(ndp->ni_vp);
499619eb6e5SJeff Roberson 
5009b3b1c5fSJohn Baldwin 	/*
501333ea485SGuido van Rooij 	 * For security and other reasons, signal handlers cannot
5028688bb93SJohn Baldwin 	 * be shared after an exec. The new process gets a copy of the old
503b2c3fa70SDima Dorfman 	 * handlers. In execsigs(), the new process will have its signals
504333ea485SGuido van Rooij 	 * reset.
505333ea485SGuido van Rooij 	 */
5069b3b1c5fSJohn Baldwin 	PROC_LOCK(p);
50790af4afaSJohn Baldwin 	if (sigacts_shared(p->p_sigacts)) {
50890af4afaSJohn Baldwin 		oldsigacts = p->p_sigacts;
5099b3b1c5fSJohn Baldwin 		PROC_UNLOCK(p);
51090af4afaSJohn Baldwin 		newsigacts = sigacts_alloc();
51190af4afaSJohn Baldwin 		sigacts_copy(newsigacts, oldsigacts);
5129b3b1c5fSJohn Baldwin 		PROC_LOCK(p);
51390af4afaSJohn Baldwin 		p->p_sigacts = newsigacts;
51490af4afaSJohn Baldwin 	} else
51590af4afaSJohn Baldwin 		oldsigacts = NULL;
516333ea485SGuido van Rooij 
517fdf4e8b3SWarner Losh 	/* Stop profiling */
518fdf4e8b3SWarner Losh 	stopprofclock(p);
519fdf4e8b3SWarner Losh 
52026f9a767SRodney W. Grimes 	/* reset caught signals */
52126f9a767SRodney W. Grimes 	execsigs(p);
52226f9a767SRodney W. Grimes 
52326f9a767SRodney W. Grimes 	/* name this process - nameiexec(p, ndp) */
52426f9a767SRodney W. Grimes 	len = min(ndp->ni_cnd.cn_namelen,MAXCOMLEN);
52526f9a767SRodney W. Grimes 	bcopy(ndp->ni_cnd.cn_nameptr, p->p_comm, len);
52626f9a767SRodney W. Grimes 	p->p_comm[len] = 0;
527ca081fdbSJulian Elischer 	bcopy(p->p_comm, td->td_name, sizeof(td->td_name));
52826f9a767SRodney W. Grimes 
52926f9a767SRodney W. Grimes 	/*
53024b34f09SSujal Patel 	 * mark as execed, wakeup the process that vforked (if any) and tell
531dc733423SDag-Erling Smørgrav 	 * it that it now has its own resources back
53226f9a767SRodney W. Grimes 	 */
53326f9a767SRodney W. Grimes 	p->p_flag |= P_EXEC;
53426f9a767SRodney W. Grimes 	if (p->p_pptr && (p->p_flag & P_PPWAIT)) {
53526f9a767SRodney W. Grimes 		p->p_flag &= ~P_PPWAIT;
5367f05b035SAlfred Perlstein 		wakeup(p->p_pptr);
53726f9a767SRodney W. Grimes 	}
53826f9a767SRodney W. Grimes 
53926f9a767SRodney W. Grimes 	/*
540a78e8d2aSDavid Greenman 	 * Implement image setuid/setgid.
541a78e8d2aSDavid Greenman 	 *
542a78e8d2aSDavid Greenman 	 * Don't honor setuid/setgid if the filesystem prohibits it or if
543a78e8d2aSDavid Greenman 	 * the process is being traced.
544670cb89bSRobert Watson 	 *
545670cb89bSRobert Watson 	 * XXXMAC: For the time being, use NOSUID to also prohibit
546670cb89bSRobert Watson 	 * transitions on the file system.
547c52007c2SDavid Greenman 	 */
548b1fc0ec1SRobert Watson 	oldcred = p->p_ucred;
549d06c0d4dSRobert Watson 	credential_changing = 0;
550d06c0d4dSRobert Watson 	credential_changing |= (attr.va_mode & VSUID) && oldcred->cr_uid !=
551d06c0d4dSRobert Watson 	    attr.va_uid;
552d06c0d4dSRobert Watson 	credential_changing |= (attr.va_mode & VSGID) && oldcred->cr_gid !=
553d06c0d4dSRobert Watson 	    attr.va_gid;
554ccafe7ebSRobert Watson #ifdef MAC
55530d239bcSRobert Watson 	will_transition = mac_vnode_execve_will_transition(oldcred, imgp->vp,
556eca8a663SRobert Watson 	    interplabel, imgp);
557ccafe7ebSRobert Watson 	credential_changing |= will_transition;
558ccafe7ebSRobert Watson #endif
559d06c0d4dSRobert Watson 
560d06c0d4dSRobert Watson 	if (credential_changing &&
561a78e8d2aSDavid Greenman 	    (imgp->vp->v_mount->mnt_flag & MNT_NOSUID) == 0 &&
562c52007c2SDavid Greenman 	    (p->p_flag & P_TRACED) == 0) {
563c52007c2SDavid Greenman 		/*
564c52007c2SDavid Greenman 		 * Turn off syscall tracing for set-id programs, except for
565b85db196SPeter Wemm 		 * root.  Record any set-id flags first to make sure that
566b85db196SPeter Wemm 		 * we do not regain any tracing during a possible block.
56726f9a767SRodney W. Grimes 		 */
568b85db196SPeter Wemm 		setsugid(p);
569acd3428bSRobert Watson 
5706c84de02SJohn Baldwin #ifdef KTRACE
571acd3428bSRobert Watson 		if (p->p_tracevp != NULL &&
57232f9753cSRobert Watson 		    priv_check_cred(oldcred, PRIV_DEBUG_DIFFCRED, 0)) {
5736c84de02SJohn Baldwin 			mtx_lock(&ktrace_mtx);
57479deba82SMatthew Dillon 			p->p_traceflag = 0;
575a5881ea5SJohn Baldwin 			tracevp = p->p_tracevp;
576a5881ea5SJohn Baldwin 			p->p_tracevp = NULL;
577a5881ea5SJohn Baldwin 			tracecred = p->p_tracecred;
578a5881ea5SJohn Baldwin 			p->p_tracecred = NULL;
5796c84de02SJohn Baldwin 			mtx_unlock(&ktrace_mtx);
58026f9a767SRodney W. Grimes 		}
5816c84de02SJohn Baldwin #endif
58228b325aaSDon Lewis 		/*
583c1e2d386SNate Lawson 		 * Close any file descriptors 0..2 that reference procfs,
584c1e2d386SNate Lawson 		 * then make sure file descriptors 0..2 are in use.
58528b325aaSDon Lewis 		 *
586c1e2d386SNate Lawson 		 * setugidsafety() may call closef() and then pfind()
587c1e2d386SNate Lawson 		 * which may grab the process lock.
58828b325aaSDon Lewis 		 * fdcheckstd() may call falloc() which may block to
58928b325aaSDon Lewis 		 * allocate memory, so temporarily drop the process lock.
59028b325aaSDon Lewis 		 */
59128b325aaSDon Lewis 		PROC_UNLOCK(p);
592c1e2d386SNate Lawson 		setugidsafety(td);
593d302786cSTor Egge 		VOP_UNLOCK(imgp->vp, 0, td);
594e983a376SJacques Vidrine 		error = fdcheckstd(td);
595d302786cSTor Egge 		vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY, td);
59663c9e754SJohn Baldwin 		if (error != 0)
59769be5db9SAlfred Perlstein 			goto done1;
598e1b1aa3bSJohn Baldwin 		PROC_LOCK(p);
599c52007c2SDavid Greenman 		/*
600c52007c2SDavid Greenman 		 * Set the new credentials.
601c52007c2SDavid Greenman 		 */
6029b3b1c5fSJohn Baldwin 		crcopy(newcred, oldcred);
603c52007c2SDavid Greenman 		if (attr.va_mode & VSUID)
6041419eacbSAlfred Perlstein 			change_euid(newcred, euip);
605c52007c2SDavid Greenman 		if (attr.va_mode & VSGID)
606b1fc0ec1SRobert Watson 			change_egid(newcred, attr.va_gid);
607ccafe7ebSRobert Watson #ifdef MAC
608670cb89bSRobert Watson 		if (will_transition) {
60930d239bcSRobert Watson 			mac_vnode_execve_transition(oldcred, newcred, imgp->vp,
610eca8a663SRobert Watson 			    interplabel, imgp);
611670cb89bSRobert Watson 		}
612ccafe7ebSRobert Watson #endif
6139b3b1c5fSJohn Baldwin 		/*
6149b3b1c5fSJohn Baldwin 		 * Implement correct POSIX saved-id behavior.
615ccafe7ebSRobert Watson 		 *
616ccafe7ebSRobert Watson 		 * XXXMAC: Note that the current logic will save the
617ccafe7ebSRobert Watson 		 * uid and gid if a MAC domain transition occurs, even
618ccafe7ebSRobert Watson 		 * though maybe it shouldn't.
6199b3b1c5fSJohn Baldwin 		 */
6209b3b1c5fSJohn Baldwin 		change_svuid(newcred, newcred->cr_uid);
6219b3b1c5fSJohn Baldwin 		change_svgid(newcred, newcred->cr_gid);
6229b3b1c5fSJohn Baldwin 		p->p_ucred = newcred;
6239b3b1c5fSJohn Baldwin 		newcred = NULL;
624c52007c2SDavid Greenman 	} else {
625b1fc0ec1SRobert Watson 		if (oldcred->cr_uid == oldcred->cr_ruid &&
626b1fc0ec1SRobert Watson 		    oldcred->cr_gid == oldcred->cr_rgid)
627c52007c2SDavid Greenman 			p->p_flag &= ~P_SUGID;
62826f9a767SRodney W. Grimes 		/*
629c52007c2SDavid Greenman 		 * Implement correct POSIX saved-id behavior.
630b1fc0ec1SRobert Watson 		 *
631b1fc0ec1SRobert Watson 		 * XXX: It's not clear that the existing behavior is
6329b3b1c5fSJohn Baldwin 		 * POSIX-compliant.  A number of sources indicate that the
6339b3b1c5fSJohn Baldwin 		 * saved uid/gid should only be updated if the new ruid is
6349b3b1c5fSJohn Baldwin 		 * not equal to the old ruid, or the new euid is not equal
6359b3b1c5fSJohn Baldwin 		 * to the old euid and the new euid is not equal to the old
6369b3b1c5fSJohn Baldwin 		 * ruid.  The FreeBSD code always updates the saved uid/gid.
6379b3b1c5fSJohn Baldwin 		 * Also, this code uses the new (replaced) euid and egid as
6389b3b1c5fSJohn Baldwin 		 * the source, which may or may not be the right ones to use.
63926f9a767SRodney W. Grimes 		 */
640b1fc0ec1SRobert Watson 		if (oldcred->cr_svuid != oldcred->cr_uid ||
641b1fc0ec1SRobert Watson 		    oldcred->cr_svgid != oldcred->cr_gid) {
6429b3b1c5fSJohn Baldwin 			crcopy(newcred, oldcred);
643b1fc0ec1SRobert Watson 			change_svuid(newcred, newcred->cr_uid);
644b1fc0ec1SRobert Watson 			change_svgid(newcred, newcred->cr_gid);
645b1fc0ec1SRobert Watson 			p->p_ucred = newcred;
6469b3b1c5fSJohn Baldwin 			newcred = NULL;
6479b3b1c5fSJohn Baldwin 		}
648b1fc0ec1SRobert Watson 	}
64926f9a767SRodney W. Grimes 
65026f9a767SRodney W. Grimes 	/*
651619eb6e5SJeff Roberson 	 * Store the vp for use in procfs.  This vnode was referenced prior
652619eb6e5SJeff Roberson 	 * to locking the proc lock.
6532a531c80SDavid Greenman 	 */
6549b3b1c5fSJohn Baldwin 	textvp = p->p_textvp;
6552a531c80SDavid Greenman 	p->p_textvp = ndp->ni_vp;
6562a531c80SDavid Greenman 
6572a531c80SDavid Greenman 	/*
6589ca45e81SDag-Erling Smørgrav 	 * Notify others that we exec'd, and clear the P_INEXEC flag
6599ca45e81SDag-Erling Smørgrav 	 * as we're now a bona fide freshly-execed process.
660cb679c38SJonathan Lemon 	 */
661ad3b9257SJohn-Mark Gurney 	KNOTE_LOCKED(&p->p_klist, NOTE_EXEC);
6629ca45e81SDag-Erling Smørgrav 	p->p_flag &= ~P_INEXEC;
663cb679c38SJonathan Lemon 
664cb679c38SJonathan Lemon 	/*
66526f9a767SRodney W. Grimes 	 * If tracing the process, trap to debugger so breakpoints
66626f9a767SRodney W. Grimes 	 * can be set before the program executes.
667906ac69dSDavid Xu 	 * Use tdsignal to deliver signal to current thread, use
668906ac69dSDavid Xu 	 * psignal may cause the signal to be delivered to wrong thread
669906ac69dSDavid Xu 	 * because that thread will exit, remember we are going to enter
670906ac69dSDavid Xu 	 * single thread mode.
67126f9a767SRodney W. Grimes 	 */
67226f9a767SRodney W. Grimes 	if (p->p_flag & P_TRACED)
6736d7b314bSDavid Xu 		tdsignal(p, td, SIGTRAP, NULL);
67426f9a767SRodney W. Grimes 
67526f9a767SRodney W. Grimes 	/* clear "fork but no exec" flag, as we _are_ execing */
67626f9a767SRodney W. Grimes 	p->p_acflag &= ~AFORK;
67726f9a767SRodney W. Grimes 
6785997cae9SDon Lewis 	/*
67934ea500bSDon Lewis 	 * Free any previous argument cache and replace it with
6805997cae9SDon Lewis 	 * the new argument cache, if any.
6815997cae9SDon Lewis 	 */
6829b3b1c5fSJohn Baldwin 	oldargs = p->p_args;
683e1b1aa3bSJohn Baldwin 	p->p_args = newargs;
684e1b1aa3bSJohn Baldwin 	newargs = NULL;
685ebccf1e3SJoseph Koshy 
686ebccf1e3SJoseph Koshy #ifdef	HWPMC_HOOKS
687ebccf1e3SJoseph Koshy 	/*
688f263522aSJoseph Koshy 	 * Check if system-wide sampling is in effect or if the
689f263522aSJoseph Koshy 	 * current process is using PMCs.  If so, do exec() time
690ebccf1e3SJoseph Koshy 	 * processing.  This processing needs to happen AFTER the
691ebccf1e3SJoseph Koshy 	 * P_INEXEC flag is cleared.
692ebccf1e3SJoseph Koshy 	 *
693ebccf1e3SJoseph Koshy 	 * The proc lock needs to be released before taking the PMC
694ebccf1e3SJoseph Koshy 	 * SX.
695ebccf1e3SJoseph Koshy 	 */
696f263522aSJoseph Koshy 	if (PMC_SYSTEM_SAMPLING_ACTIVE() || PMC_PROC_IS_USING_PMCS(p)) {
697e1b1aa3bSJohn Baldwin 		PROC_UNLOCK(p);
69815139246SJoseph Koshy 		pe.pm_credentialschanged = credential_changing;
69915139246SJoseph Koshy 		pe.pm_entryaddr = imgp->entry_addr;
70015139246SJoseph Koshy 
70115139246SJoseph Koshy 		PMC_CALL_HOOK_X(td, PMC_FN_PROCESS_EXEC, (void *) &pe);
702ebccf1e3SJoseph Koshy 	} else
703ebccf1e3SJoseph Koshy 		PROC_UNLOCK(p);
704ebccf1e3SJoseph Koshy #else  /* !HWPMC_HOOKS */
705ebccf1e3SJoseph Koshy 	PROC_UNLOCK(p);
706ebccf1e3SJoseph Koshy #endif
707e1b1aa3bSJohn Baldwin 
708e913ca22SDoug Rabson 	/* Set values passed into the program in registers. */
7093ebc1248SPeter Wemm 	if (p->p_sysent->sv_setregs)
7103ebc1248SPeter Wemm 		(*p->p_sysent->sv_setregs)(td, imgp->entry_addr,
7113ebc1248SPeter Wemm 		    (u_long)(uintptr_t)stack_base, imgp->ps_strings);
7123ebc1248SPeter Wemm 	else
713bafbd492SJake Burkholder 		exec_setregs(td, imgp->entry_addr,
714bafbd492SJake Burkholder 		    (u_long)(uintptr_t)stack_base, imgp->ps_strings);
715e913ca22SDoug Rabson 
7169f5c1d19SDiomidis Spinellis 	vfs_mark_atime(imgp->vp, td);
7176341095eSKen Smith 
71869be5db9SAlfred Perlstein done1:
7199b3b1c5fSJohn Baldwin 	/*
7209b3b1c5fSJohn Baldwin 	 * Free any resources malloc'd earlier that we didn't use.
7219b3b1c5fSJohn Baldwin 	 */
7221419eacbSAlfred Perlstein 	uifree(euip);
7239b3b1c5fSJohn Baldwin 	if (newcred == NULL)
7249b3b1c5fSJohn Baldwin 		crfree(oldcred);
7259b3b1c5fSJohn Baldwin 	else
7269b3b1c5fSJohn Baldwin 		crfree(newcred);
727d302786cSTor Egge 	VOP_UNLOCK(imgp->vp, 0, td);
7289b3b1c5fSJohn Baldwin 	/*
7299b3b1c5fSJohn Baldwin 	 * Handle deferred decrement of ref counts.
7309b3b1c5fSJohn Baldwin 	 */
73168ce4375SJeff Roberson 	if (textvp != NULL) {
73268ce4375SJeff Roberson 		int tvfslocked;
73368ce4375SJeff Roberson 
73468ce4375SJeff Roberson 		tvfslocked = VFS_LOCK_GIANT(textvp->v_mount);
7359b3b1c5fSJohn Baldwin 		vrele(textvp);
73668ce4375SJeff Roberson 		VFS_UNLOCK_GIANT(tvfslocked);
73768ce4375SJeff Roberson 	}
738619eb6e5SJeff Roberson 	if (ndp->ni_vp && error != 0)
739619eb6e5SJeff Roberson 		vrele(ndp->ni_vp);
7406c84de02SJohn Baldwin #ifdef KTRACE
741ce0be646SJohn Baldwin 	if (tracevp != NULL) {
742ce0be646SJohn Baldwin 		int tvfslocked;
743ce0be646SJohn Baldwin 
744ce0be646SJohn Baldwin 		tvfslocked = VFS_LOCK_GIANT(tracevp->v_mount);
7459b3b1c5fSJohn Baldwin 		vrele(tracevp);
746ce0be646SJohn Baldwin 		VFS_UNLOCK_GIANT(tvfslocked);
747ce0be646SJohn Baldwin 	}
748a5881ea5SJohn Baldwin 	if (tracecred != NULL)
749a5881ea5SJohn Baldwin 		crfree(tracecred);
7506c84de02SJohn Baldwin #endif
751d302786cSTor Egge 	vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY, td);
75269be5db9SAlfred Perlstein 	if (oldargs != NULL)
7539b3b1c5fSJohn Baldwin 		pargs_drop(oldargs);
75469be5db9SAlfred Perlstein 	if (newargs != NULL)
75569be5db9SAlfred Perlstein 		pargs_drop(newargs);
75690af4afaSJohn Baldwin 	if (oldsigacts != NULL)
75790af4afaSJohn Baldwin 		sigacts_free(oldsigacts);
758b9df5231SPoul-Henning Kamp 
7591616db3cSJohn Dyson exec_fail_dealloc:
7601616db3cSJohn Dyson 
76126f9a767SRodney W. Grimes 	/*
76226f9a767SRodney W. Grimes 	 * free various allocated resources
76326f9a767SRodney W. Grimes 	 */
764d6c847f3SBruce Evans 	if (imgp->firstpage != NULL)
7651616db3cSJohn Dyson 		exec_unmap_first_page(imgp);
76626f9a767SRodney W. Grimes 
767d6c847f3SBruce Evans 	if (imgp->vp != NULL) {
768762e6b85SEivind Eklund 		NDFREE(ndp, NDF_ONLY_PNBUF);
769619eb6e5SJeff Roberson 		vput(imgp->vp);
770a3cf6ebaSDavid Greenman 	}
77126f9a767SRodney W. Grimes 
772d6c847f3SBruce Evans 	if (imgp->object != NULL)
7730b2ed1aeSJeff Roberson 		vm_object_deallocate(imgp->object);
7740b2ed1aeSJeff Roberson 
775d1989db5SRobert Drehmel 	if (error == 0) {
776d1989db5SRobert Drehmel 		/*
777d1989db5SRobert Drehmel 		 * Stop the process here if its stop event mask has
778d1989db5SRobert Drehmel 		 * the S_EXEC bit set.
779d1989db5SRobert Drehmel 		 */
780d1989db5SRobert Drehmel 		STOPEVENT(p, S_EXEC, 0);
781116734c4SMatthew Dillon 		goto done2;
782d1989db5SRobert Drehmel 	}
7831616db3cSJohn Dyson 
78426f9a767SRodney W. Grimes exec_fail:
7859ca45e81SDag-Erling Smørgrav 	/* we're done here, clear P_INEXEC */
7869ca45e81SDag-Erling Smørgrav 	PROC_LOCK(p);
7879ca45e81SDag-Erling Smørgrav 	p->p_flag &= ~P_INEXEC;
7889ca45e81SDag-Erling Smørgrav 	PROC_UNLOCK(p);
7899ca45e81SDag-Erling Smørgrav 
790116734c4SMatthew Dillon done2:
791670cb89bSRobert Watson #ifdef MAC
792670cb89bSRobert Watson 	mac_execve_exit(imgp);
793eca8a663SRobert Watson 	if (interplabel != NULL)
794eca8a663SRobert Watson 		mac_vnode_label_free(interplabel);
795670cb89bSRobert Watson #endif
796269576c8SJeff Roberson 	VFS_UNLOCK_GIANT(vfslocked);
7978917b8d2SJohn Baldwin 	exec_free_args(args);
7988917b8d2SJohn Baldwin 
7998917b8d2SJohn Baldwin 	if (error && imgp->vmspace_destroyed) {
8008917b8d2SJohn Baldwin 		/* sorry, no more process anymore. exit gracefully */
8018917b8d2SJohn Baldwin 		exit1(td, W_EXITCODE(0, SIGABRT));
8028917b8d2SJohn Baldwin 		/* NOT REACHED */
8038917b8d2SJohn Baldwin 	}
804116734c4SMatthew Dillon 	return (error);
80526f9a767SRodney W. Grimes }
80626f9a767SRodney W. Grimes 
8071616db3cSJohn Dyson int
8081616db3cSJohn Dyson exec_map_first_page(imgp)
8091616db3cSJohn Dyson 	struct image_params *imgp;
8101616db3cSJohn Dyson {
811d8aad40cSJohn Baldwin 	int rv, i;
81295461b45SJohn Dyson 	int initial_pagein;
81395461b45SJohn Dyson 	vm_page_t ma[VM_INITIAL_PAGEIN];
8141616db3cSJohn Dyson 	vm_object_t object;
8151616db3cSJohn Dyson 
816d6c847f3SBruce Evans 	if (imgp->firstpage != NULL)
8171616db3cSJohn Dyson 		exec_unmap_first_page(imgp);
8181616db3cSJohn Dyson 
8198516dd18SPoul-Henning Kamp 	object = imgp->vp->v_object;
8204d7d2993SJeff Roberson 	if (object == NULL)
8214d7d2993SJeff Roberson 		return (EACCES);
822fd0cc9a8SAlan Cox 	VM_OBJECT_LOCK(object);
82395461b45SJohn Dyson 	ma[0] = vm_page_grab(object, 0, VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
82495461b45SJohn Dyson 	if ((ma[0]->valid & VM_PAGE_BITS_ALL) != VM_PAGE_BITS_ALL) {
82595461b45SJohn Dyson 		initial_pagein = VM_INITIAL_PAGEIN;
82695461b45SJohn Dyson 		if (initial_pagein > object->size)
82795461b45SJohn Dyson 			initial_pagein = object->size;
82895461b45SJohn Dyson 		for (i = 1; i < initial_pagein; i++) {
829d254af07SMatthew Dillon 			if ((ma[i] = vm_page_lookup(object, i)) != NULL) {
8306ec2fca5SAlan Cox 				if (ma[i]->valid)
8316ec2fca5SAlan Cox 					break;
8329af80719SAlan Cox 				if ((ma[i]->oflags & VPO_BUSY) || ma[i]->busy)
83306fa71cdSAlan Cox 					break;
834e69763a3SDoug Rabson 				vm_page_busy(ma[i]);
83595461b45SJohn Dyson 			} else {
836ca0387efSJake Burkholder 				ma[i] = vm_page_alloc(object, i,
8377bfda801SAlan Cox 				    VM_ALLOC_NORMAL | VM_ALLOC_IFNOTCACHED);
83895461b45SJohn Dyson 				if (ma[i] == NULL)
83995461b45SJohn Dyson 					break;
84095461b45SJohn Dyson 			}
84195461b45SJohn Dyson 		}
84295461b45SJohn Dyson 		initial_pagein = i;
84395461b45SJohn Dyson 		rv = vm_pager_get_pages(object, ma, initial_pagein, 0);
84495461b45SJohn Dyson 		ma[0] = vm_page_lookup(object, 0);
845ca0387efSJake Burkholder 		if ((rv != VM_PAGER_OK) || (ma[0] == NULL) ||
846ca0387efSJake Burkholder 		    (ma[0]->valid == 0)) {
847ecbb00a2SDoug Rabson 			if (ma[0]) {
8486ec2fca5SAlan Cox 				vm_page_lock_queues();
8498f9110f6SJohn Dyson 				vm_page_free(ma[0]);
85006fa71cdSAlan Cox 				vm_page_unlock_queues();
8516ec2fca5SAlan Cox 			}
85206fa71cdSAlan Cox 			VM_OBJECT_UNLOCK(object);
853a7cddfedSJake Burkholder 			return (EIO);
8541616db3cSJohn Dyson 		}
8551616db3cSJohn Dyson 	}
8566ec2fca5SAlan Cox 	vm_page_lock_queues();
857148b3f62SAlan Cox 	vm_page_hold(ma[0]);
85897646f56SAlan Cox 	vm_page_unlock_queues();
8592a53696fSAlan Cox 	vm_page_wakeup(ma[0]);
8606ec2fca5SAlan Cox 	VM_OBJECT_UNLOCK(object);
8611616db3cSJohn Dyson 
86259c8bc40SAlan Cox 	imgp->firstpage = sf_buf_alloc(ma[0], 0);
86359c8bc40SAlan Cox 	imgp->image_header = (char *)sf_buf_kva(imgp->firstpage);
8641616db3cSJohn Dyson 
865a7cddfedSJake Burkholder 	return (0);
8661616db3cSJohn Dyson }
8671616db3cSJohn Dyson 
8681616db3cSJohn Dyson void
8691616db3cSJohn Dyson exec_unmap_first_page(imgp)
8701616db3cSJohn Dyson 	struct image_params *imgp;
8711616db3cSJohn Dyson {
87259c8bc40SAlan Cox 	vm_page_t m;
87323955314SAlfred Perlstein 
874d6c847f3SBruce Evans 	if (imgp->firstpage != NULL) {
87559c8bc40SAlan Cox 		m = sf_buf_page(imgp->firstpage);
87659c8bc40SAlan Cox 		sf_buf_free(imgp->firstpage);
8771616db3cSJohn Dyson 		imgp->firstpage = NULL;
87859c8bc40SAlan Cox 		vm_page_lock_queues();
87959c8bc40SAlan Cox 		vm_page_unhold(m);
88059c8bc40SAlan Cox 		vm_page_unlock_queues();
8811616db3cSJohn Dyson 	}
8821616db3cSJohn Dyson }
8831616db3cSJohn Dyson 
88426f9a767SRodney W. Grimes /*
88526f9a767SRodney W. Grimes  * Destroy old address space, and allocate a new stack
88626f9a767SRodney W. Grimes  *	The new stack is only SGROWSIZ large because it is grown
88726f9a767SRodney W. Grimes  *	automatically in trap.c.
88826f9a767SRodney W. Grimes  */
88926f9a767SRodney W. Grimes int
89005ba50f5SJake Burkholder exec_new_vmspace(imgp, sv)
891c52007c2SDavid Greenman 	struct image_params *imgp;
89205ba50f5SJake Burkholder 	struct sysentvec *sv;
89326f9a767SRodney W. Grimes {
89426f9a767SRodney W. Grimes 	int error;
8955e20c11fSAlan Cox 	struct proc *p = imgp->proc;
8965e20c11fSAlan Cox 	struct vmspace *vmspace = p->p_vmspace;
89705ba50f5SJake Burkholder 	vm_offset_t stack_addr;
89805ba50f5SJake Burkholder 	vm_map_t map;
89959d8f3ffSJohn Baldwin 	u_long ssiz;
90026f9a767SRodney W. Grimes 
901c52007c2SDavid Greenman 	imgp->vmspace_destroyed = 1;
902993182e5SAlexander Leidinger 	imgp->sysent = sv;
90326f9a767SRodney W. Grimes 
904bd37fd72SKris Kennaway 	/* May be called with Giant held */
905993182e5SAlexander Leidinger 	EVENTHANDLER_INVOKE(process_exec, p, imgp);
9066f5dafeaSAlan Cox 
9076f5dafeaSAlan Cox 	/*
908af9ec885SJohn Dyson 	 * Blow away entire process VM, if address space not shared,
909af9ec885SJohn Dyson 	 * otherwise, create a new VM space so that other threads are
910af9ec885SJohn Dyson 	 * not disrupted
911af9ec885SJohn Dyson 	 */
91205ba50f5SJake Burkholder 	map = &vmspace->vm_map;
91305ba50f5SJake Burkholder 	if (vmspace->vm_refcnt == 1 && vm_map_min(map) == sv->sv_minuser &&
91405ba50f5SJake Burkholder 	    vm_map_max(map) == sv->sv_maxuser) {
9153db161e0SMatthew Dillon 		shmexit(vmspace);
916b9eee07eSPeter Wemm 		pmap_remove_pages(vmspace_pmap(vmspace));
91705ba50f5SJake Burkholder 		vm_map_remove(map, vm_map_min(map), vm_map_max(map));
918af9ec885SJohn Dyson 	} else {
91989b57fcfSKonstantin Belousov 		error = vmspace_exec(p, sv->sv_minuser, sv->sv_maxuser);
92089b57fcfSKonstantin Belousov 		if (error)
92189b57fcfSKonstantin Belousov 			return (error);
9225e20c11fSAlan Cox 		vmspace = p->p_vmspace;
92305ba50f5SJake Burkholder 		map = &vmspace->vm_map;
924af9ec885SJohn Dyson 	}
92526f9a767SRodney W. Grimes 
92626f9a767SRodney W. Grimes 	/* Allocate a new stack */
92759d8f3ffSJohn Baldwin 	if (sv->sv_maxssiz != NULL)
92859d8f3ffSJohn Baldwin 		ssiz = *sv->sv_maxssiz;
92959d8f3ffSJohn Baldwin 	else
93059d8f3ffSJohn Baldwin 		ssiz = maxssiz;
93159d8f3ffSJohn Baldwin 	stack_addr = sv->sv_usrstack - ssiz;
93259d8f3ffSJohn Baldwin 	error = vm_map_stack(map, stack_addr, (vm_size_t)ssiz,
933fd75d710SMarcel Moolenaar 	    sv->sv_stackprot, VM_PROT_ALL, MAP_STACK_GROWS_DOWN);
9342267af78SJulian Elischer 	if (error)
9352267af78SJulian Elischer 		return (error);
9362267af78SJulian Elischer 
93763c47a5cSDoug Rabson #ifdef __ia64__
938fd75d710SMarcel Moolenaar 	/* Allocate a new register stack */
939bab1f052SMarcel Moolenaar 	stack_addr = IA64_BACKINGSTORE;
94059d8f3ffSJohn Baldwin 	error = vm_map_stack(map, stack_addr, (vm_size_t)ssiz,
941fd75d710SMarcel Moolenaar 	    sv->sv_stackprot, VM_PROT_ALL, MAP_STACK_GROWS_UP);
942fd75d710SMarcel Moolenaar 	if (error)
943fd75d710SMarcel Moolenaar 		return (error);
94463c47a5cSDoug Rabson #endif
94563c47a5cSDoug Rabson 
9462267af78SJulian Elischer 	/* vm_ssize and vm_maxsaddr are somewhat antiquated concepts in the
9472267af78SJulian Elischer 	 * VM_STACK case, but they are still used to monitor the size of the
9482267af78SJulian Elischer 	 * process stack so we can check the stack rlimit.
9492267af78SJulian Elischer 	 */
950cbc89bfbSPaul Saab 	vmspace->vm_ssize = sgrowsiz >> PAGE_SHIFT;
95159d8f3ffSJohn Baldwin 	vmspace->vm_maxsaddr = (char *)sv->sv_usrstack - ssiz;
95226f9a767SRodney W. Grimes 
95326f9a767SRodney W. Grimes 	return (0);
95426f9a767SRodney W. Grimes }
95526f9a767SRodney W. Grimes 
95626f9a767SRodney W. Grimes /*
957873fbcd7SRobert Watson  * Copy out argument and environment strings from the old process address
958873fbcd7SRobert Watson  * space into the temporary string buffer.
95926f9a767SRodney W. Grimes  */
96026f9a767SRodney W. Grimes int
961610ecfe0SMaxim Sobolev exec_copyin_args(struct image_args *args, char *fname,
962610ecfe0SMaxim Sobolev     enum uio_seg segflg, char **argv, char **envv)
96326f9a767SRodney W. Grimes {
96426f9a767SRodney W. Grimes 	char *argp, *envp;
965ecbb00a2SDoug Rabson 	int error;
966ecbb00a2SDoug Rabson 	size_t length;
96726f9a767SRodney W. Grimes 
968610ecfe0SMaxim Sobolev 	error = 0;
969610ecfe0SMaxim Sobolev 
970610ecfe0SMaxim Sobolev 	bzero(args, sizeof(*args));
971610ecfe0SMaxim Sobolev 	if (argv == NULL)
972610ecfe0SMaxim Sobolev 		return (EFAULT);
97326f9a767SRodney W. Grimes 	/*
974610ecfe0SMaxim Sobolev 	 * Allocate temporary demand zeroed space for argument and
97590dc539bSMaxim Sobolev 	 *	environment strings:
97690dc539bSMaxim Sobolev 	 *
97790dc539bSMaxim Sobolev 	 * o ARG_MAX for argument and environment;
97890dc539bSMaxim Sobolev 	 * o MAXSHELLCMDLEN for the name of interpreters.
97926f9a767SRodney W. Grimes 	 */
98090dc539bSMaxim Sobolev 	args->buf = (char *) kmem_alloc_wait(exec_map,
98190dc539bSMaxim Sobolev 	    PATH_MAX + ARG_MAX + MAXSHELLCMDLEN);
982610ecfe0SMaxim Sobolev 	if (args->buf == NULL)
983610ecfe0SMaxim Sobolev 		return (ENOMEM);
984610ecfe0SMaxim Sobolev 	args->begin_argv = args->buf;
985610ecfe0SMaxim Sobolev 	args->endp = args->begin_argv;
986610ecfe0SMaxim Sobolev 	args->stringspace = ARG_MAX;
98726f9a767SRodney W. Grimes 
988610ecfe0SMaxim Sobolev 	args->fname = args->buf + ARG_MAX;
98926f9a767SRodney W. Grimes 
990610ecfe0SMaxim Sobolev 	/*
991610ecfe0SMaxim Sobolev 	 * Copy the file name.
992610ecfe0SMaxim Sobolev 	 */
993610ecfe0SMaxim Sobolev 	error = (segflg == UIO_SYSSPACE) ?
994610ecfe0SMaxim Sobolev 	    copystr(fname, args->fname, PATH_MAX, &length) :
995610ecfe0SMaxim Sobolev 	    copyinstr(fname, args->fname, PATH_MAX, &length);
996c30af532SMaxim Sobolev 	if (error != 0)
99768ff3c24SStephan Uphoff 		goto err_exit;
99826f9a767SRodney W. Grimes 
999610ecfe0SMaxim Sobolev 	/*
1000610ecfe0SMaxim Sobolev 	 * extract arguments first
1001610ecfe0SMaxim Sobolev 	 */
1002610ecfe0SMaxim Sobolev 	while ((argp = (caddr_t) (intptr_t) fuword(argv++))) {
100368ff3c24SStephan Uphoff 		if (argp == (caddr_t) -1) {
100468ff3c24SStephan Uphoff 			error = EFAULT;
100568ff3c24SStephan Uphoff 			goto err_exit;
100668ff3c24SStephan Uphoff 		}
1007610ecfe0SMaxim Sobolev 		if ((error = copyinstr(argp, args->endp,
1008610ecfe0SMaxim Sobolev 		    args->stringspace, &length))) {
1009610ecfe0SMaxim Sobolev 			if (error == ENAMETOOLONG)
101068ff3c24SStephan Uphoff 				error = E2BIG;
101168ff3c24SStephan Uphoff 			goto err_exit;
1012610ecfe0SMaxim Sobolev 		}
1013610ecfe0SMaxim Sobolev 		args->stringspace -= length;
1014610ecfe0SMaxim Sobolev 		args->endp += length;
1015610ecfe0SMaxim Sobolev 		args->argc++;
1016610ecfe0SMaxim Sobolev 	}
1017610ecfe0SMaxim Sobolev 
1018610ecfe0SMaxim Sobolev 	args->begin_envv = args->endp;
1019b9df5231SPoul-Henning Kamp 
102026f9a767SRodney W. Grimes 	/*
102126f9a767SRodney W. Grimes 	 * extract environment strings
102226f9a767SRodney W. Grimes 	 */
10230fd1a014SDavid Greenman 	if (envv) {
1024aae0aa45SBruce Evans 		while ((envp = (caddr_t)(intptr_t)fuword(envv++))) {
102568ff3c24SStephan Uphoff 			if (envp == (caddr_t)-1) {
102668ff3c24SStephan Uphoff 				error = EFAULT;
102768ff3c24SStephan Uphoff 				goto err_exit;
102868ff3c24SStephan Uphoff 			}
1029610ecfe0SMaxim Sobolev 			if ((error = copyinstr(envp, args->endp,
1030610ecfe0SMaxim Sobolev 			    args->stringspace, &length))) {
10310fd1a014SDavid Greenman 				if (error == ENAMETOOLONG)
103268ff3c24SStephan Uphoff 					error = E2BIG;
103368ff3c24SStephan Uphoff 				goto err_exit;
10340fd1a014SDavid Greenman 			}
1035610ecfe0SMaxim Sobolev 			args->stringspace -= length;
1036610ecfe0SMaxim Sobolev 			args->endp += length;
1037610ecfe0SMaxim Sobolev 			args->envc++;
103826f9a767SRodney W. Grimes 		}
10390fd1a014SDavid Greenman 	}
104026f9a767SRodney W. Grimes 
104126f9a767SRodney W. Grimes 	return (0);
104268ff3c24SStephan Uphoff 
104368ff3c24SStephan Uphoff err_exit:
104468ff3c24SStephan Uphoff 	exec_free_args(args);
104568ff3c24SStephan Uphoff 	return (error);
104626f9a767SRodney W. Grimes }
104726f9a767SRodney W. Grimes 
10488917b8d2SJohn Baldwin static void
1049610ecfe0SMaxim Sobolev exec_free_args(struct image_args *args)
1050610ecfe0SMaxim Sobolev {
1051610ecfe0SMaxim Sobolev 
1052610ecfe0SMaxim Sobolev 	if (args->buf) {
105390dc539bSMaxim Sobolev 		kmem_free_wakeup(exec_map, (vm_offset_t)args->buf,
105490dc539bSMaxim Sobolev 		    PATH_MAX + ARG_MAX + MAXSHELLCMDLEN);
1055610ecfe0SMaxim Sobolev 		args->buf = NULL;
1056610ecfe0SMaxim Sobolev 	}
1057610ecfe0SMaxim Sobolev }
1058610ecfe0SMaxim Sobolev 
105926f9a767SRodney W. Grimes /*
1060873fbcd7SRobert Watson  * Copy strings out to the new process address space, constructing new arg
1061873fbcd7SRobert Watson  * and env vector tables. Return a pointer to the base so that it can be used
1062873fbcd7SRobert Watson  * as the initial stack pointer.
106326f9a767SRodney W. Grimes  */
1064654f6be1SBruce Evans register_t *
1065c52007c2SDavid Greenman exec_copyout_strings(imgp)
1066c52007c2SDavid Greenman 	struct image_params *imgp;
106726f9a767SRodney W. Grimes {
106826f9a767SRodney W. Grimes 	int argc, envc;
106926f9a767SRodney W. Grimes 	char **vectp;
107026f9a767SRodney W. Grimes 	char *stringp, *destp;
1071654f6be1SBruce Evans 	register_t *stack_base;
107293f6448cSDavid Greenman 	struct ps_strings *arginfo;
1073f3bec5d7SJake Burkholder 	struct proc *p;
1074d66a5066SPeter Wemm 	int szsigcode;
107526f9a767SRodney W. Grimes 
107626f9a767SRodney W. Grimes 	/*
107726f9a767SRodney W. Grimes 	 * Calculate string base and vector table pointers.
1078d66a5066SPeter Wemm 	 * Also deal with signal trampoline code for this exec type.
107926f9a767SRodney W. Grimes 	 */
1080f3bec5d7SJake Burkholder 	p = imgp->proc;
1081f3bec5d7SJake Burkholder 	szsigcode = 0;
108205ba50f5SJake Burkholder 	arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
1083f3bec5d7SJake Burkholder 	if (p->p_sysent->sv_szsigcode != NULL)
1084f3bec5d7SJake Burkholder 		szsigcode = *(p->p_sysent->sv_szsigcode);
1085d66a5066SPeter Wemm 	destp =	(caddr_t)arginfo - szsigcode - SPARE_USRSPACE -
1086610ecfe0SMaxim Sobolev 	    roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
10871ed012f9SPeter Wemm 
108826f9a767SRodney W. Grimes 	/*
1089d66a5066SPeter Wemm 	 * install sigcode
1090d66a5066SPeter Wemm 	 */
1091d66a5066SPeter Wemm 	if (szsigcode)
1092f3bec5d7SJake Burkholder 		copyout(p->p_sysent->sv_sigcode, ((caddr_t)arginfo -
1093f3bec5d7SJake Burkholder 		    szsigcode), szsigcode);
1094d66a5066SPeter Wemm 
1095d66a5066SPeter Wemm 	/*
1096e1743d02SSøren Schmidt 	 * If we have a valid auxargs ptr, prepare some room
1097e1743d02SSøren Schmidt 	 * on the stack.
1098e1743d02SSøren Schmidt 	 */
1099b9a22da4STakanori Watanabe 	if (imgp->auxargs) {
1100e1743d02SSøren Schmidt 		/*
1101b9a22da4STakanori Watanabe 		 * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
1102b9a22da4STakanori Watanabe 		 * lower compatibility.
1103b9a22da4STakanori Watanabe 		 */
1104ca0387efSJake Burkholder 		imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
1105ca0387efSJake Burkholder 		    (AT_COUNT * 2);
1106b9a22da4STakanori Watanabe 		/*
1107b9a22da4STakanori Watanabe 		 * The '+ 2' is for the null pointers at the end of each of
1108b9a22da4STakanori Watanabe 		 * the arg and env vector sets,and imgp->auxarg_size is room
1109b9a22da4STakanori Watanabe 		 * for argument of Runtime loader.
1110e1743d02SSøren Schmidt 		 */
1111610ecfe0SMaxim Sobolev 		vectp = (char **)(destp - (imgp->args->argc +
1112610ecfe0SMaxim Sobolev 		    imgp->args->envc + 2 + imgp->auxarg_size) *
1113610ecfe0SMaxim Sobolev 		    sizeof(char *));
1114b9a22da4STakanori Watanabe 
1115610ecfe0SMaxim Sobolev 	} else {
1116e1743d02SSøren Schmidt 		/*
1117b9a22da4STakanori Watanabe 		 * The '+ 2' is for the null pointers at the end of each of
1118b9a22da4STakanori Watanabe 		 * the arg and env vector sets
111926f9a767SRodney W. Grimes 		 */
1120610ecfe0SMaxim Sobolev 		vectp = (char **)(destp - (imgp->args->argc + imgp->args->envc + 2) *
1121ca0387efSJake Burkholder 		    sizeof(char *));
1122610ecfe0SMaxim Sobolev 	}
112326f9a767SRodney W. Grimes 
112426f9a767SRodney W. Grimes 	/*
112526f9a767SRodney W. Grimes 	 * vectp also becomes our initial stack base
112626f9a767SRodney W. Grimes 	 */
1127654f6be1SBruce Evans 	stack_base = (register_t *)vectp;
112826f9a767SRodney W. Grimes 
1129610ecfe0SMaxim Sobolev 	stringp = imgp->args->begin_argv;
1130610ecfe0SMaxim Sobolev 	argc = imgp->args->argc;
1131610ecfe0SMaxim Sobolev 	envc = imgp->args->envc;
113226f9a767SRodney W. Grimes 
113393f6448cSDavid Greenman 	/*
11343aed948bSDavid Greenman 	 * Copy out strings - arguments and environment.
113593f6448cSDavid Greenman 	 */
1136610ecfe0SMaxim Sobolev 	copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
113793f6448cSDavid Greenman 
113893f6448cSDavid Greenman 	/*
11393aed948bSDavid Greenman 	 * Fill in "ps_strings" struct for ps, w, etc.
11403aed948bSDavid Greenman 	 */
1141aae0aa45SBruce Evans 	suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp);
11423aed948bSDavid Greenman 	suword(&arginfo->ps_nargvstr, argc);
11433aed948bSDavid Greenman 
11443aed948bSDavid Greenman 	/*
11453aed948bSDavid Greenman 	 * Fill in argument portion of vector table.
114693f6448cSDavid Greenman 	 */
114726f9a767SRodney W. Grimes 	for (; argc > 0; --argc) {
1148aae0aa45SBruce Evans 		suword(vectp++, (long)(intptr_t)destp);
11493aed948bSDavid Greenman 		while (*stringp++ != 0)
11503aed948bSDavid Greenman 			destp++;
11513aed948bSDavid Greenman 		destp++;
115226f9a767SRodney W. Grimes 	}
115326f9a767SRodney W. Grimes 
11541a6e52d0SJeroen Ruigrok van der Werven 	/* a null vector table pointer separates the argp's from the envp's */
11556ab46d52SBruce Evans 	suword(vectp++, 0);
115626f9a767SRodney W. Grimes 
1157aae0aa45SBruce Evans 	suword(&arginfo->ps_envstr, (long)(intptr_t)vectp);
11583aed948bSDavid Greenman 	suword(&arginfo->ps_nenvstr, envc);
115993f6448cSDavid Greenman 
116093f6448cSDavid Greenman 	/*
11613aed948bSDavid Greenman 	 * Fill in environment portion of vector table.
116293f6448cSDavid Greenman 	 */
116326f9a767SRodney W. Grimes 	for (; envc > 0; --envc) {
1164aae0aa45SBruce Evans 		suword(vectp++, (long)(intptr_t)destp);
11653aed948bSDavid Greenman 		while (*stringp++ != 0)
11663aed948bSDavid Greenman 			destp++;
11673aed948bSDavid Greenman 		destp++;
116826f9a767SRodney W. Grimes 	}
116926f9a767SRodney W. Grimes 
117026f9a767SRodney W. Grimes 	/* end of vector table is a null pointer */
11716ab46d52SBruce Evans 	suword(vectp, 0);
117226f9a767SRodney W. Grimes 
117326f9a767SRodney W. Grimes 	return (stack_base);
117426f9a767SRodney W. Grimes }
117526f9a767SRodney W. Grimes 
117626f9a767SRodney W. Grimes /*
117726f9a767SRodney W. Grimes  * Check permissions of file to execute.
1178cf64863aSRobert Watson  *	Called with imgp->vp locked.
117926f9a767SRodney W. Grimes  *	Return 0 for success or error code on failure.
118026f9a767SRodney W. Grimes  */
1181c8a79999SPeter Wemm int
1182c52007c2SDavid Greenman exec_check_permissions(imgp)
1183c52007c2SDavid Greenman 	struct image_params *imgp;
118426f9a767SRodney W. Grimes {
1185c52007c2SDavid Greenman 	struct vnode *vp = imgp->vp;
1186c52007c2SDavid Greenman 	struct vattr *attr = imgp->attr;
1187a854ed98SJohn Baldwin 	struct thread *td;
118826f9a767SRodney W. Grimes 	int error;
118926f9a767SRodney W. Grimes 
1190a854ed98SJohn Baldwin 	td = curthread;			/* XXXKSE */
1191339b79b9SRobert Watson 
1192ec35c2afSRobert Watson 	/* Get file attributes */
1193ec35c2afSRobert Watson 	error = VOP_GETATTR(vp, attr, td->td_ucred, td);
1194ec35c2afSRobert Watson 	if (error)
1195ec35c2afSRobert Watson 		return (error);
1196ec35c2afSRobert Watson 
1197339b79b9SRobert Watson #ifdef MAC
119830d239bcSRobert Watson 	error = mac_vnode_check_exec(td->td_ucred, imgp->vp, imgp);
1199339b79b9SRobert Watson 	if (error)
1200339b79b9SRobert Watson 		return (error);
1201339b79b9SRobert Watson #endif
1202339b79b9SRobert Watson 
120326f9a767SRodney W. Grimes 	/*
120426f9a767SRodney W. Grimes 	 * 1) Check if file execution is disabled for the filesystem that this
120526f9a767SRodney W. Grimes 	 *	file resides on.
120626f9a767SRodney W. Grimes 	 * 2) Insure that at least one execute bit is on - otherwise root
120726f9a767SRodney W. Grimes 	 *	will always succeed, and we don't want to happen unless the
120826f9a767SRodney W. Grimes 	 *	file really is executable.
120926f9a767SRodney W. Grimes 	 * 3) Insure that the file is a regular file.
121026f9a767SRodney W. Grimes 	 */
1211c52007c2SDavid Greenman 	if ((vp->v_mount->mnt_flag & MNT_NOEXEC) ||
121226f9a767SRodney W. Grimes 	    ((attr->va_mode & 0111) == 0) ||
1213a854ed98SJohn Baldwin 	    (attr->va_type != VREG))
121426f9a767SRodney W. Grimes 		return (EACCES);
121526f9a767SRodney W. Grimes 
121626f9a767SRodney W. Grimes 	/*
121726f9a767SRodney W. Grimes 	 * Zero length files can't be exec'd
121826f9a767SRodney W. Grimes 	 */
121926f9a767SRodney W. Grimes 	if (attr->va_size == 0)
122026f9a767SRodney W. Grimes 		return (ENOEXEC);
122126f9a767SRodney W. Grimes 
122226f9a767SRodney W. Grimes 	/*
122326f9a767SRodney W. Grimes 	 *  Check for execute permission to file based on current credentials.
122426f9a767SRodney W. Grimes 	 */
1225a854ed98SJohn Baldwin 	error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td);
122626f9a767SRodney W. Grimes 	if (error)
122726f9a767SRodney W. Grimes 		return (error);
122826f9a767SRodney W. Grimes 
12296d5a0a8cSDavid Greenman 	/*
12306d5a0a8cSDavid Greenman 	 * Check number of open-for-writes on the file and deny execution
12316d5a0a8cSDavid Greenman 	 * if there are any.
12326d5a0a8cSDavid Greenman 	 */
12336d5a0a8cSDavid Greenman 	if (vp->v_writecount)
12346d5a0a8cSDavid Greenman 		return (ETXTBSY);
12356d5a0a8cSDavid Greenman 
12366d5a0a8cSDavid Greenman 	/*
12376d5a0a8cSDavid Greenman 	 * Call filesystem specific open routine (which does nothing in the
12386d5a0a8cSDavid Greenman 	 * general case).
12396d5a0a8cSDavid Greenman 	 */
12409e223287SKonstantin Belousov 	error = VOP_OPEN(vp, FREAD, td->td_ucred, td, NULL);
124126f9a767SRodney W. Grimes 	return (error);
1242df8bae1dSRodney W. Grimes }
1243aa855a59SPeter Wemm 
1244aa855a59SPeter Wemm /*
1245aa855a59SPeter Wemm  * Exec handler registration
1246aa855a59SPeter Wemm  */
1247aa855a59SPeter Wemm int
1248aa855a59SPeter Wemm exec_register(execsw_arg)
1249aa855a59SPeter Wemm 	const struct execsw *execsw_arg;
1250aa855a59SPeter Wemm {
1251aa855a59SPeter Wemm 	const struct execsw **es, **xs, **newexecsw;
1252aa855a59SPeter Wemm 	int count = 2;	/* New slot and trailing NULL */
1253aa855a59SPeter Wemm 
1254aa855a59SPeter Wemm 	if (execsw)
1255aa855a59SPeter Wemm 		for (es = execsw; *es; es++)
1256aa855a59SPeter Wemm 			count++;
1257a163d034SWarner Losh 	newexecsw = malloc(count * sizeof(*es), M_TEMP, M_WAITOK);
1258aa855a59SPeter Wemm 	if (newexecsw == NULL)
1259a7cddfedSJake Burkholder 		return (ENOMEM);
1260aa855a59SPeter Wemm 	xs = newexecsw;
1261aa855a59SPeter Wemm 	if (execsw)
1262aa855a59SPeter Wemm 		for (es = execsw; *es; es++)
1263aa855a59SPeter Wemm 			*xs++ = *es;
1264aa855a59SPeter Wemm 	*xs++ = execsw_arg;
1265aa855a59SPeter Wemm 	*xs = NULL;
1266aa855a59SPeter Wemm 	if (execsw)
1267aa855a59SPeter Wemm 		free(execsw, M_TEMP);
1268aa855a59SPeter Wemm 	execsw = newexecsw;
1269a7cddfedSJake Burkholder 	return (0);
1270aa855a59SPeter Wemm }
1271aa855a59SPeter Wemm 
1272aa855a59SPeter Wemm int
1273aa855a59SPeter Wemm exec_unregister(execsw_arg)
1274aa855a59SPeter Wemm 	const struct execsw *execsw_arg;
1275aa855a59SPeter Wemm {
1276aa855a59SPeter Wemm 	const struct execsw **es, **xs, **newexecsw;
1277aa855a59SPeter Wemm 	int count = 1;
1278aa855a59SPeter Wemm 
1279aa855a59SPeter Wemm 	if (execsw == NULL)
1280aa855a59SPeter Wemm 		panic("unregister with no handlers left?\n");
1281aa855a59SPeter Wemm 
1282aa855a59SPeter Wemm 	for (es = execsw; *es; es++) {
1283aa855a59SPeter Wemm 		if (*es == execsw_arg)
1284aa855a59SPeter Wemm 			break;
1285aa855a59SPeter Wemm 	}
1286aa855a59SPeter Wemm 	if (*es == NULL)
1287a7cddfedSJake Burkholder 		return (ENOENT);
1288aa855a59SPeter Wemm 	for (es = execsw; *es; es++)
1289aa855a59SPeter Wemm 		if (*es != execsw_arg)
1290aa855a59SPeter Wemm 			count++;
1291a163d034SWarner Losh 	newexecsw = malloc(count * sizeof(*es), M_TEMP, M_WAITOK);
1292aa855a59SPeter Wemm 	if (newexecsw == NULL)
1293a7cddfedSJake Burkholder 		return (ENOMEM);
1294aa855a59SPeter Wemm 	xs = newexecsw;
1295aa855a59SPeter Wemm 	for (es = execsw; *es; es++)
1296aa855a59SPeter Wemm 		if (*es != execsw_arg)
1297aa855a59SPeter Wemm 			*xs++ = *es;
1298aa855a59SPeter Wemm 	*xs = NULL;
1299aa855a59SPeter Wemm 	if (execsw)
1300aa855a59SPeter Wemm 		free(execsw, M_TEMP);
1301aa855a59SPeter Wemm 	execsw = newexecsw;
1302a7cddfedSJake Burkholder 	return (0);
1303aa855a59SPeter Wemm }
1304