Commit | Line | Data |
---|---|---|
984263bc MD |
1 | /* |
2 | * Copyright (c) 1993, David Greenman | |
3 | * All rights reserved. | |
4 | * | |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions | |
7 | * are met: | |
8 | * 1. Redistributions of source code must retain the above copyright | |
9 | * notice, this list of conditions and the following disclaimer. | |
10 | * 2. Redistributions in binary form must reproduce the above copyright | |
11 | * notice, this list of conditions and the following disclaimer in the | |
12 | * documentation and/or other materials provided with the distribution. | |
13 | * | |
14 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND | |
15 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
16 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
17 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |
18 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
19 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
20 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
21 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
22 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
23 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
24 | * SUCH DAMAGE. | |
25 | * | |
26 | * $FreeBSD: src/sys/kern/kern_exec.c,v 1.107.2.15 2002/07/30 15:40:46 nectar Exp $ | |
27 | */ | |
28 | ||
29 | #include <sys/param.h> | |
30 | #include <sys/systm.h> | |
31 | #include <sys/sysproto.h> | |
32 | #include <sys/kernel.h> | |
33 | #include <sys/mount.h> | |
34 | #include <sys/filedesc.h> | |
35 | #include <sys/fcntl.h> | |
36 | #include <sys/acct.h> | |
37 | #include <sys/exec.h> | |
38 | #include <sys/imgact.h> | |
39 | #include <sys/imgact_elf.h> | |
2bd9d75c | 40 | #include <sys/kern_syscall.h> |
984263bc MD |
41 | #include <sys/wait.h> |
42 | #include <sys/malloc.h> | |
43 | #include <sys/proc.h> | |
895c1f85 | 44 | #include <sys/priv.h> |
29f58392 | 45 | #include <sys/ktrace.h> |
984263bc MD |
46 | #include <sys/signalvar.h> |
47 | #include <sys/pioctl.h> | |
fad57d0e | 48 | #include <sys/nlookup.h> |
984263bc MD |
49 | #include <sys/sysent.h> |
50 | #include <sys/shm.h> | |
51 | #include <sys/sysctl.h> | |
52 | #include <sys/vnode.h> | |
a6f89c72 | 53 | #include <sys/vmmeter.h> |
17a7ca1f | 54 | #include <sys/libkern.h> |
984263bc | 55 | |
5c5185ae SG |
56 | #include <cpu/lwbuf.h> |
57 | ||
984263bc MD |
58 | #include <vm/vm.h> |
59 | #include <vm/vm_param.h> | |
60 | #include <sys/lock.h> | |
61 | #include <vm/pmap.h> | |
62 | #include <vm/vm_page.h> | |
63 | #include <vm/vm_map.h> | |
64 | #include <vm/vm_kern.h> | |
65 | #include <vm/vm_extern.h> | |
66 | #include <vm/vm_object.h> | |
a55afca2 | 67 | #include <vm/vnode_pager.h> |
984263bc MD |
68 | #include <vm/vm_pager.h> |
69 | ||
70 | #include <sys/user.h> | |
527fddf7 | 71 | #include <sys/reg.h> |
984263bc | 72 | |
19bfc8ab | 73 | #include <sys/refcount.h> |
5fd012e0 | 74 | #include <sys/thread2.h> |
684a93c4 | 75 | #include <sys/mplock2.h> |
5fd012e0 | 76 | |
984263bc | 77 | MALLOC_DEFINE(M_PARGS, "proc-args", "Process arguments"); |
18b3f457 | 78 | MALLOC_DEFINE(M_EXECARGS, "exec-args", "Exec arguments"); |
984263bc | 79 | |
402ed7e1 | 80 | static register_t *exec_copyout_strings (struct image_params *); |
984263bc MD |
81 | |
82 | /* XXX This should be vm_size_t. */ | |
83 | static u_long ps_strings = PS_STRINGS; | |
84 | SYSCTL_ULONG(_kern, KERN_PS_STRINGS, ps_strings, CTLFLAG_RD, &ps_strings, 0, ""); | |
85 | ||
86 | /* XXX This should be vm_size_t. */ | |
87 | static u_long usrstack = USRSTACK; | |
88 | SYSCTL_ULONG(_kern, KERN_USRSTACK, usrstack, CTLFLAG_RD, &usrstack, 0, ""); | |
89 | ||
90 | u_long ps_arg_cache_limit = PAGE_SIZE / 16; | |
91 | SYSCTL_LONG(_kern, OID_AUTO, ps_arg_cache_limit, CTLFLAG_RW, | |
92 | &ps_arg_cache_limit, 0, ""); | |
93 | ||
94 | int ps_argsopen = 1; | |
95 | SYSCTL_INT(_kern, OID_AUTO, ps_argsopen, CTLFLAG_RW, &ps_argsopen, 0, ""); | |
96 | ||
5c627295 MD |
97 | static int ktrace_suid = 0; |
98 | SYSCTL_INT(_kern, OID_AUTO, ktrace_suid, CTLFLAG_RW, &ktrace_suid, 0, ""); | |
99 | ||
2bd9d75c DRJ |
100 | void print_execve_args(struct image_args *args); |
101 | int debug_execve_args = 0; | |
102 | SYSCTL_INT(_kern, OID_AUTO, debug_execve_args, CTLFLAG_RW, &debug_execve_args, | |
103 | 0, ""); | |
104 | ||
18b3f457 MD |
105 | /* |
106 | * Exec arguments object cache | |
107 | */ | |
108 | static struct objcache *exec_objcache; | |
109 | ||
110 | static | |
111 | void | |
112 | exec_objcache_init(void *arg __unused) | |
113 | { | |
0aa16b5d | 114 | int cluster_limit; |
1f29f2c5 MD |
115 | size_t limsize; |
116 | ||
117 | /* | |
118 | * Maximum number of concurrent execs. This can be limiting on | |
119 | * systems with a lot of cpu cores but it also eats a significant | |
120 | * amount of memory. | |
121 | */ | |
e93da8d4 | 122 | cluster_limit = (ncpus < 16) ? 16 : ncpus; |
1f29f2c5 MD |
123 | limsize = kmem_lim_size(); |
124 | if (limsize > 7 * 1024) | |
125 | cluster_limit *= 2; | |
126 | if (limsize > 15 * 1024) | |
127 | cluster_limit *= 2; | |
0aa16b5d | 128 | |
18b3f457 MD |
129 | exec_objcache = objcache_create_mbacked( |
130 | M_EXECARGS, PATH_MAX + ARG_MAX, | |
765b1ae0 | 131 | &cluster_limit, 8, |
18b3f457 MD |
132 | NULL, NULL, NULL); |
133 | } | |
134 | SYSINIT(exec_objcache, SI_BOOT2_MACHDEP, SI_ORDER_ANY, exec_objcache_init, 0); | |
135 | ||
17a7ca1f MD |
136 | /* |
137 | * stackgap_random specifies if the stackgap should have a random size added | |
138 | * to it. It must be a power of 2. If non-zero, the stack gap will be | |
0ced1954 | 139 | * calculated as: ALIGN(karc4random() & (stackgap_random - 1)). |
17a7ca1f MD |
140 | */ |
141 | static int stackgap_random = 1024; | |
142 | static int | |
143 | sysctl_kern_stackgap(SYSCTL_HANDLER_ARGS) | |
144 | { | |
145 | int error, new_val; | |
146 | new_val = stackgap_random; | |
147 | error = sysctl_handle_int(oidp, &new_val, 0, req); | |
148 | if (error != 0 || req->newptr == NULL) | |
149 | return (error); | |
d0e92318 | 150 | if (new_val > 0 && ((new_val > 16 * PAGE_SIZE) || !powerof2(new_val))) |
17a7ca1f MD |
151 | return (EINVAL); |
152 | stackgap_random = new_val; | |
153 | ||
154 | return(0); | |
155 | } | |
156 | ||
d0e92318 | 157 | SYSCTL_PROC(_kern, OID_AUTO, stackgap_random, CTLFLAG_RW|CTLTYPE_INT, |
1237359e | 158 | 0, 0, sysctl_kern_stackgap, "I", |
d0e92318 | 159 | "Max random stack gap (power of 2), static gap if negative"); |
17a7ca1f | 160 | |
2bd9d75c DRJ |
161 | void |
162 | print_execve_args(struct image_args *args) | |
163 | { | |
164 | char *cp; | |
165 | int ndx; | |
166 | ||
167 | cp = args->begin_argv; | |
168 | for (ndx = 0; ndx < args->argc; ndx++) { | |
6ea70f76 | 169 | kprintf("\targv[%d]: %s\n", ndx, cp); |
2bd9d75c DRJ |
170 | while (*cp++ != '\0'); |
171 | } | |
172 | for (ndx = 0; ndx < args->envc; ndx++) { | |
6ea70f76 | 173 | kprintf("\tenvv[%d]: %s\n", ndx, cp); |
2bd9d75c DRJ |
174 | while (*cp++ != '\0'); |
175 | } | |
176 | } | |
177 | ||
984263bc MD |
178 | /* |
179 | * Each of the items is a pointer to a `const struct execsw', hence the | |
180 | * double pointer here. | |
181 | */ | |
182 | static const struct execsw **execsw; | |
183 | ||
5417cd57 SS |
184 | /* |
185 | * Replace current vmspace with a new binary. | |
186 | * Returns 0 on success, > 0 on recoverable error (use as errno). | |
90947cb1 | 187 | * Returns -1 on lethal error which demands killing of the current |
5417cd57 SS |
188 | * process! |
189 | */ | |
984263bc | 190 | int |
fad57d0e | 191 | kern_execve(struct nlookupdata *nd, struct image_args *args) |
984263bc | 192 | { |
dadab5e9 | 193 | struct thread *td = curthread; |
08f2f1bb | 194 | struct lwp *lp = td->td_lwp; |
dadab5e9 | 195 | struct proc *p = td->td_proc; |
a2ee730d | 196 | struct vnode *ovp; |
984263bc | 197 | register_t *stack_base; |
19bfc8ab | 198 | struct pargs *pa; |
6fa9e71a MD |
199 | struct sigacts *ops; |
200 | struct sigacts *nps; | |
984263bc MD |
201 | int error, len, i; |
202 | struct image_params image_params, *imgp; | |
203 | struct vattr attr; | |
402ed7e1 | 204 | int (*img_first) (struct image_params *); |
984263bc | 205 | |
2bd9d75c | 206 | if (debug_execve_args) { |
6ea70f76 | 207 | kprintf("%s()\n", __func__); |
2bd9d75c DRJ |
208 | print_execve_args(args); |
209 | } | |
210 | ||
dadab5e9 | 211 | KKASSERT(p); |
19bfc8ab | 212 | lwkt_gettoken(&p->p_token); |
984263bc MD |
213 | imgp = &image_params; |
214 | ||
215 | /* | |
dc52e1cc MD |
216 | * NOTE: P_INEXEC is handled by exec_new_vmspace() now. We make |
217 | * no modifications to the process at all until we get there. | |
218 | * | |
219 | * Note that multiple threads may be trying to exec at the same | |
220 | * time. exec_new_vmspace() handles that too. | |
984263bc | 221 | */ |
984263bc MD |
222 | |
223 | /* | |
224 | * Initialize part of the common data | |
225 | */ | |
226 | imgp->proc = p; | |
2bd9d75c | 227 | imgp->args = args; |
984263bc | 228 | imgp->attr = &attr; |
984263bc | 229 | imgp->entry_addr = 0; |
29802dbb | 230 | imgp->resident = 0; |
984263bc MD |
231 | imgp->vmspace_destroyed = 0; |
232 | imgp->interpreted = 0; | |
2abfe22f | 233 | imgp->interpreter_name[0] = 0; |
984263bc MD |
234 | imgp->auxargs = NULL; |
235 | imgp->vp = NULL; | |
236 | imgp->firstpage = NULL; | |
237 | imgp->ps_strings = 0; | |
adc42cf3 JM |
238 | imgp->execpath = imgp->freepath = NULL; |
239 | imgp->execpathp = 0; | |
18f40545 | 240 | imgp->image_header = NULL; |
2bd9d75c DRJ |
241 | |
242 | interpret: | |
984263bc MD |
243 | |
244 | /* | |
fad57d0e MD |
245 | * Translate the file name to a vnode. Unlock the cache entry to |
246 | * improve parallelism for programs exec'd in parallel. | |
984263bc | 247 | */ |
fad57d0e MD |
248 | if ((error = nlookup(nd)) != 0) |
249 | goto exec_fail; | |
28623bf9 | 250 | error = cache_vget(&nd->nl_nch, nd->nl_cred, LK_EXCLUSIVE, &imgp->vp); |
fad57d0e MD |
251 | KKASSERT(nd->nl_flags & NLC_NCPISLOCKED); |
252 | nd->nl_flags &= ~NLC_NCPISLOCKED; | |
28623bf9 | 253 | cache_unlock(&nd->nl_nch); |
fad57d0e | 254 | if (error) |
984263bc | 255 | goto exec_fail; |
984263bc MD |
256 | |
257 | /* | |
246693ac AHJ |
258 | * Check file permissions (also 'opens' file). |
259 | * Include also the top level mount in the check. | |
984263bc | 260 | */ |
246693ac | 261 | error = exec_check_permissions(imgp, nd->nl_nch.mount); |
984263bc | 262 | if (error) { |
a11aaa81 | 263 | vn_unlock(imgp->vp); |
984263bc MD |
264 | goto exec_fail_dealloc; |
265 | } | |
266 | ||
267 | error = exec_map_first_page(imgp); | |
a11aaa81 | 268 | vn_unlock(imgp->vp); |
984263bc MD |
269 | if (error) |
270 | goto exec_fail_dealloc; | |
271 | ||
315b8b8b JM |
272 | imgp->proc->p_osrel = 0; |
273 | ||
2bd9d75c | 274 | if (debug_execve_args && imgp->interpreted) { |
6ea70f76 SW |
275 | kprintf(" target is interpreted -- recursive pass\n"); |
276 | kprintf(" interpreter: %s\n", imgp->interpreter_name); | |
2bd9d75c DRJ |
277 | print_execve_args(args); |
278 | } | |
279 | ||
984263bc MD |
280 | /* |
281 | * If the current process has a special image activator it | |
282 | * wants to try first, call it. For example, emulating shell | |
283 | * scripts differently. | |
284 | */ | |
285 | error = -1; | |
286 | if ((img_first = imgp->proc->p_sysent->sv_imgact_try) != NULL) | |
287 | error = img_first(imgp); | |
288 | ||
29802dbb MD |
289 | /* |
290 | * If the vnode has a registered vmspace, exec the vmspace | |
291 | */ | |
292 | if (error == -1 && imgp->vp->v_resident) { | |
293 | error = exec_resident_imgact(imgp); | |
294 | } | |
295 | ||
984263bc MD |
296 | /* |
297 | * Loop through the list of image activators, calling each one. | |
298 | * An activator returns -1 if there is no match, 0 on success, | |
299 | * and an error otherwise. | |
300 | */ | |
301 | for (i = 0; error == -1 && execsw[i]; ++i) { | |
302 | if (execsw[i]->ex_imgact == NULL || | |
303 | execsw[i]->ex_imgact == img_first) { | |
304 | continue; | |
305 | } | |
306 | error = (*execsw[i]->ex_imgact)(imgp); | |
307 | } | |
308 | ||
309 | if (error) { | |
310 | if (error == -1) | |
311 | error = ENOEXEC; | |
312 | goto exec_fail_dealloc; | |
313 | } | |
314 | ||
315 | /* | |
316 | * Special interpreter operation, cleanup and loop up to try to | |
317 | * activate the interpreter. | |
318 | */ | |
319 | if (imgp->interpreted) { | |
320 | exec_unmap_first_page(imgp); | |
fad57d0e MD |
321 | nlookup_done(nd); |
322 | vrele(imgp->vp); | |
323 | imgp->vp = NULL; | |
324 | error = nlookup_init(nd, imgp->interpreter_name, UIO_SYSSPACE, | |
325 | NLC_FOLLOW); | |
326 | if (error) | |
327 | goto exec_fail; | |
984263bc MD |
328 | goto interpret; |
329 | } | |
330 | ||
adc42cf3 JM |
331 | /* |
332 | * Do the best to calculate the full path to the image file | |
333 | */ | |
334 | if (imgp->auxargs != NULL && | |
335 | ((args->fname != NULL && args->fname[0] == '/') || | |
336 | vn_fullpath(imgp->proc, | |
337 | imgp->vp, | |
338 | &imgp->execpath, | |
339 | &imgp->freepath, | |
340 | 0) != 0)) | |
341 | imgp->execpath = args->fname; | |
342 | ||
984263bc MD |
343 | /* |
344 | * Copy out strings (args and env) and initialize stack base | |
345 | */ | |
346 | stack_base = exec_copyout_strings(imgp); | |
347 | p->p_vmspace->vm_minsaddr = (char *)stack_base; | |
348 | ||
349 | /* | |
350 | * If custom stack fixup routine present for this process | |
29802dbb MD |
351 | * let it do the stack setup. If we are running a resident |
352 | * image there is no auxinfo or other image activator context | |
353 | * so don't try to add fixups to the stack. | |
354 | * | |
984263bc MD |
355 | * Else stuff argument count as first item on stack |
356 | */ | |
29802dbb | 357 | if (p->p_sysent->sv_fixup && imgp->resident == 0) |
984263bc MD |
358 | (*p->p_sysent->sv_fixup)(&stack_base, imgp); |
359 | else | |
2bd9d75c | 360 | suword(--stack_base, imgp->args->argc); |
984263bc MD |
361 | |
362 | /* | |
363 | * For security and other reasons, the file descriptor table cannot | |
364 | * be shared after an exec. | |
365 | */ | |
366 | if (p->p_fd->fd_refcnt > 1) { | |
367 | struct filedesc *tmp; | |
368 | ||
2994659f VS |
369 | error = fdcopy(p, &tmp); |
370 | if (error != 0) | |
371 | goto exec_fail; | |
0a4a9c77 | 372 | fdfree(p, tmp); |
984263bc MD |
373 | } |
374 | ||
375 | /* | |
376 | * For security and other reasons, signal handlers cannot | |
377 | * be shared after an exec. The new proces gets a copy of the old | |
378 | * handlers. In execsigs(), the new process will have its signals | |
379 | * reset. | |
380 | */ | |
6fa9e71a MD |
381 | ops = p->p_sigacts; |
382 | if (ops->ps_refcnt > 1) { | |
383 | nps = kmalloc(sizeof(*nps), M_SUBPROC, M_WAITOK); | |
384 | bcopy(ops, nps, sizeof(*nps)); | |
385 | refcount_init(&nps->ps_refcnt, 1); | |
386 | p->p_sigacts = nps; | |
387 | if (refcount_release(&ops->ps_refcnt)) { | |
388 | kfree(ops, M_SUBPROC); | |
389 | ops = NULL; | |
390 | } | |
984263bc MD |
391 | } |
392 | ||
0daa37a5 MD |
393 | /* |
394 | * For security and other reasons virtual kernels cannot be | |
395 | * inherited by an exec. This also allows a virtual kernel | |
396 | * to fork/exec unrelated applications. | |
397 | */ | |
4a22e893 MD |
398 | if (p->p_vkernel) |
399 | vkernel_exit(p); | |
0daa37a5 | 400 | |
984263bc MD |
401 | /* Stop profiling */ |
402 | stopprofclock(p); | |
403 | ||
404 | /* close files on exec */ | |
405 | fdcloseexec(p); | |
406 | ||
407 | /* reset caught signals */ | |
408 | execsigs(p); | |
409 | ||
410 | /* name this process - nameiexec(p, ndp) */ | |
28623bf9 MD |
411 | len = min(nd->nl_nch.ncp->nc_nlen, MAXCOMLEN); |
412 | bcopy(nd->nl_nch.ncp->nc_name, p->p_comm, len); | |
984263bc | 413 | p->p_comm[len] = 0; |
08f2f1bb | 414 | bcopy(p->p_comm, lp->lwp_thread->td_comm, MAXCOMLEN+1); |
984263bc MD |
415 | |
416 | /* | |
417 | * mark as execed, wakeup the process that vforked (if any) and tell | |
418 | * it that it now has its own resources back | |
419 | */ | |
4643740a MD |
420 | p->p_flags |= P_EXEC; |
421 | if (p->p_pptr && (p->p_flags & P_PPWAIT)) { | |
422 | p->p_flags &= ~P_PPWAIT; | |
984263bc MD |
423 | wakeup((caddr_t)p->p_pptr); |
424 | } | |
425 | ||
426 | /* | |
427 | * Implement image setuid/setgid. | |
428 | * | |
429 | * Don't honor setuid/setgid if the filesystem prohibits it or if | |
430 | * the process is being traced. | |
431 | */ | |
432 | if ((((attr.va_mode & VSUID) && p->p_ucred->cr_uid != attr.va_uid) || | |
433 | ((attr.va_mode & VSGID) && p->p_ucred->cr_gid != attr.va_gid)) && | |
434 | (imgp->vp->v_mount->mnt_flag & MNT_NOSUID) == 0 && | |
4643740a | 435 | (p->p_flags & P_TRACED) == 0) { |
984263bc MD |
436 | /* |
437 | * Turn off syscall tracing for set-id programs, except for | |
438 | * root. Record any set-id flags first to make sure that | |
439 | * we do not regain any tracing during a possible block. | |
440 | */ | |
41c20dac | 441 | setsugid(); |
5c627295 MD |
442 | if (p->p_tracenode && ktrace_suid == 0 && |
443 | priv_check(td, PRIV_ROOT) != 0) { | |
29f58392 MD |
444 | ktrdestroy(&p->p_tracenode); |
445 | p->p_traceflag = 0; | |
984263bc MD |
446 | } |
447 | /* Close any file descriptors 0..2 that reference procfs */ | |
448 | setugidsafety(p); | |
449 | /* Make sure file descriptors 0..2 are in use. */ | |
f3a2d8c4 | 450 | error = fdcheckstd(lp); |
984263bc MD |
451 | if (error != 0) |
452 | goto exec_fail_dealloc; | |
453 | /* | |
454 | * Set the new credentials. | |
455 | */ | |
e9a372eb | 456 | cratom(&p->p_ucred); |
984263bc | 457 | if (attr.va_mode & VSUID) |
41c20dac | 458 | change_euid(attr.va_uid); |
984263bc MD |
459 | if (attr.va_mode & VSGID) |
460 | p->p_ucred->cr_gid = attr.va_gid; | |
98a7f915 MD |
461 | |
462 | /* | |
463 | * Clear local varsym variables | |
464 | */ | |
465 | varsymset_clean(&p->p_varsymset); | |
984263bc | 466 | } else { |
41c20dac MD |
467 | if (p->p_ucred->cr_uid == p->p_ucred->cr_ruid && |
468 | p->p_ucred->cr_gid == p->p_ucred->cr_rgid) | |
4643740a | 469 | p->p_flags &= ~P_SUGID; |
984263bc MD |
470 | } |
471 | ||
472 | /* | |
473 | * Implement correct POSIX saved-id behavior. | |
474 | */ | |
115ccd83 MD |
475 | if (p->p_ucred->cr_svuid != p->p_ucred->cr_uid || |
476 | p->p_ucred->cr_svgid != p->p_ucred->cr_gid) { | |
477 | cratom(&p->p_ucred); | |
478 | p->p_ucred->cr_svuid = p->p_ucred->cr_uid; | |
479 | p->p_ucred->cr_svgid = p->p_ucred->cr_gid; | |
480 | } | |
984263bc MD |
481 | |
482 | /* | |
a2ee730d MD |
483 | * Store the vp for use in procfs. Be sure to keep p_textvp |
484 | * consistent if we block during the switch-over. | |
984263bc | 485 | */ |
a2ee730d MD |
486 | ovp = p->p_textvp; |
487 | vref(imgp->vp); /* ref new vp */ | |
fad57d0e | 488 | p->p_textvp = imgp->vp; |
a2ee730d MD |
489 | if (ovp) /* release old vp */ |
490 | vrele(ovp); | |
984263bc | 491 | |
8ba5f7ef AH |
492 | /* Release old namecache handle to text file */ |
493 | if (p->p_textnch.ncp) | |
494 | cache_drop(&p->p_textnch); | |
495 | ||
496 | if (nd->nl_nch.mount) | |
497 | cache_copy(&nd->nl_nch, &p->p_textnch); | |
498 | ||
984263bc MD |
499 | /* |
500 | * Notify others that we exec'd, and clear the P_INEXEC flag | |
501 | * as we're now a bona fide freshly-execed process. | |
502 | */ | |
503 | KNOTE(&p->p_klist, NOTE_EXEC); | |
4643740a | 504 | p->p_flags &= ~P_INEXEC; |
7c37ea07 MD |
505 | if (p->p_stops) |
506 | wakeup(&p->p_stype); | |
984263bc MD |
507 | |
508 | /* | |
509 | * If tracing the process, trap to debugger so breakpoints | |
510 | * can be set before the program executes. | |
511 | */ | |
512 | STOPEVENT(p, S_EXEC, 0); | |
513 | ||
4643740a | 514 | if (p->p_flags & P_TRACED) |
84204577 | 515 | ksignal(p, SIGTRAP); |
984263bc MD |
516 | |
517 | /* clear "fork but no exec" flag, as we _are_ execing */ | |
518 | p->p_acflag &= ~AFORK; | |
519 | ||
520 | /* Set values passed into the program in registers. */ | |
08f2f1bb | 521 | exec_setregs(imgp->entry_addr, (u_long)(uintptr_t)stack_base, |
a2ee730d | 522 | imgp->ps_strings); |
984263bc | 523 | |
349433c9 MD |
524 | /* Set the access time on the vnode */ |
525 | vn_mark_atime(imgp->vp, td); | |
526 | ||
19bfc8ab MD |
527 | /* |
528 | * Free any previous argument cache | |
529 | */ | |
530 | pa = p->p_args; | |
984263bc | 531 | p->p_args = NULL; |
19bfc8ab MD |
532 | if (pa && refcount_release(&pa->ar_ref)) { |
533 | kfree(pa, M_PARGS); | |
534 | pa = NULL; | |
535 | } | |
984263bc | 536 | |
19bfc8ab MD |
537 | /* |
538 | * Cache arguments if they fit inside our allowance | |
539 | */ | |
2bd9d75c | 540 | i = imgp->args->begin_envv - imgp->args->begin_argv; |
19bfc8ab MD |
541 | if (sizeof(struct pargs) + i <= ps_arg_cache_limit) { |
542 | pa = kmalloc(sizeof(struct pargs) + i, M_PARGS, M_WAITOK); | |
543 | refcount_init(&pa->ar_ref, 1); | |
544 | pa->ar_length = i; | |
545 | bcopy(imgp->args->begin_argv, pa->ar_args, i); | |
546 | KKASSERT(p->p_args == NULL); | |
547 | p->p_args = pa; | |
984263bc MD |
548 | } |
549 | ||
550 | exec_fail_dealloc: | |
551 | ||
552 | /* | |
553 | * free various allocated resources | |
554 | */ | |
555 | if (imgp->firstpage) | |
556 | exec_unmap_first_page(imgp); | |
557 | ||
984263bc | 558 | if (imgp->vp) { |
984263bc | 559 | vrele(imgp->vp); |
fad57d0e | 560 | imgp->vp = NULL; |
984263bc MD |
561 | } |
562 | ||
bf52a6ac MD |
563 | if (imgp->freepath) |
564 | kfree(imgp->freepath, M_TEMP); | |
565 | ||
a6f89c72 DR |
566 | if (error == 0) { |
567 | ++mycpu->gd_cnt.v_exec; | |
19bfc8ab | 568 | lwkt_reltoken(&p->p_token); |
984263bc | 569 | return (0); |
a6f89c72 | 570 | } |
984263bc MD |
571 | |
572 | exec_fail: | |
dc52e1cc MD |
573 | /* |
574 | * we're done here, clear P_INEXEC if we were the ones that | |
575 | * set it. Otherwise if vmspace_destroyed is still set we | |
576 | * raced another thread and that thread is responsible for | |
577 | * clearing it. | |
578 | */ | |
7c37ea07 | 579 | if (imgp->vmspace_destroyed & 2) { |
4643740a | 580 | p->p_flags &= ~P_INEXEC; |
7c37ea07 MD |
581 | if (p->p_stops) |
582 | wakeup(&p->p_stype); | |
583 | } | |
19bfc8ab | 584 | lwkt_reltoken(&p->p_token); |
984263bc | 585 | if (imgp->vmspace_destroyed) { |
5417cd57 SS |
586 | /* |
587 | * Sorry, no more process anymore. exit gracefully. | |
588 | * However we can't die right here, because our | |
589 | * caller might have to clean up, so indicate a | |
90947cb1 | 590 | * lethal error by returning -1. |
5417cd57 SS |
591 | */ |
592 | return(-1); | |
984263bc MD |
593 | } else { |
594 | return(error); | |
595 | } | |
596 | } | |
597 | ||
2bd9d75c DRJ |
598 | /* |
599 | * execve() system call. | |
600 | */ | |
601 | int | |
753fd850 | 602 | sys_execve(struct execve_args *uap) |
2bd9d75c | 603 | { |
fad57d0e | 604 | struct nlookupdata nd; |
2bd9d75c DRJ |
605 | struct image_args args; |
606 | int error; | |
607 | ||
118cec38 | 608 | bzero(&args, sizeof(args)); |
3919ced0 | 609 | |
3919ced0 | 610 | error = nlookup_init(&nd, uap->fname, UIO_USERSPACE, NLC_FOLLOW); |
fad57d0e MD |
611 | if (error == 0) { |
612 | error = exec_copyin_args(&args, uap->fname, PATH_USERSPACE, | |
613 | uap->argv, uap->envv); | |
614 | } | |
2abfe22f MD |
615 | if (error == 0) |
616 | error = kern_execve(&nd, &args); | |
fad57d0e | 617 | nlookup_done(&nd); |
2bd9d75c DRJ |
618 | exec_free_args(&args); |
619 | ||
5417cd57 | 620 | if (error < 0) { |
90947cb1 | 621 | /* We hit a lethal error condition. Let's die now. */ |
5417cd57 SS |
622 | exit1(W_EXITCODE(0, SIGABRT)); |
623 | /* NOTREACHED */ | |
624 | } | |
625 | ||
2bd9d75c DRJ |
626 | /* |
627 | * The syscall result is returned in registers to the new program. | |
628 | * Linux will register %edx as an atexit function and we must be | |
629 | * sure to set it to 0. XXX | |
630 | */ | |
631 | if (error == 0) | |
632 | uap->sysmsg_result64 = 0; | |
633 | ||
634 | return (error); | |
635 | } | |
636 | ||
984263bc | 637 | int |
7c34d798 | 638 | exec_map_page(struct image_params *imgp, vm_pindex_t pageno, |
5c5185ae | 639 | struct lwbuf **plwb, const char **pdata) |
984263bc | 640 | { |
1b9d3514 MD |
641 | int rv; |
642 | vm_page_t ma; | |
06ecca5a | 643 | vm_page_t m; |
984263bc MD |
644 | vm_object_t object; |
645 | ||
fad57d0e | 646 | /* |
7540ab49 | 647 | * The file has to be mappable. |
fad57d0e | 648 | */ |
7540ab49 | 649 | if ((object = imgp->vp->v_object) == NULL) |
fad57d0e | 650 | return (EIO); |
984263bc | 651 | |
7c34d798 SS |
652 | if (pageno >= object->size) |
653 | return (EIO); | |
654 | ||
b12defdc | 655 | vm_object_hold(object); |
7c34d798 | 656 | m = vm_page_grab(object, pageno, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); |
1b9d3514 MD |
657 | while ((m->valid & VM_PAGE_BITS_ALL) != VM_PAGE_BITS_ALL) { |
658 | ma = m; | |
984263bc | 659 | |
06ecca5a MD |
660 | /* |
661 | * get_pages unbusies all the requested pages except the | |
a55afca2 MD |
662 | * primary page (at index 0 in this case). The primary |
663 | * page may have been wired during the pagein (e.g. by | |
664 | * the buffer cache) so vnode_pager_freepage() must be | |
665 | * used to properly release it. | |
06ecca5a | 666 | */ |
1b9d3514 | 667 | rv = vm_pager_get_page(object, &ma, 1); |
7c34d798 | 668 | m = vm_page_lookup(object, pageno); |
984263bc | 669 | |
06ecca5a MD |
670 | if (rv != VM_PAGER_OK || m == NULL || m->valid == 0) { |
671 | if (m) { | |
672 | vm_page_protect(m, VM_PROT_NONE); | |
a55afca2 | 673 | vnode_pager_freepage(m); |
984263bc | 674 | } |
471bd290 | 675 | vm_object_drop(object); |
984263bc MD |
676 | return EIO; |
677 | } | |
678 | } | |
b12defdc | 679 | vm_page_hold(m); |
06ecca5a | 680 | vm_page_wakeup(m); /* unbusy the page */ |
b12defdc | 681 | vm_object_drop(object); |
984263bc | 682 | |
7a683a24 | 683 | *plwb = lwbuf_alloc(m, *plwb); |
5c5185ae | 684 | *pdata = (void *)lwbuf_kva(*plwb); |
7c34d798 SS |
685 | |
686 | return (0); | |
687 | } | |
688 | ||
7484bdd2 MD |
689 | /* |
690 | * Map the first page of an executable image. | |
691 | * | |
692 | * NOTE: If the mapping fails we have to NULL-out firstpage which may | |
693 | * still be pointing to our supplied lwp structure. | |
694 | */ | |
7c34d798 SS |
695 | int |
696 | exec_map_first_page(struct image_params *imgp) | |
697 | { | |
698 | int err; | |
699 | ||
700 | if (imgp->firstpage) | |
701 | exec_unmap_first_page(imgp); | |
702 | ||
7a683a24 | 703 | imgp->firstpage = &imgp->firstpage_cache; |
7c34d798 SS |
704 | err = exec_map_page(imgp, 0, &imgp->firstpage, &imgp->image_header); |
705 | ||
7484bdd2 MD |
706 | if (err) { |
707 | imgp->firstpage = NULL; | |
7c34d798 | 708 | return err; |
7484bdd2 | 709 | } |
984263bc MD |
710 | |
711 | return 0; | |
712 | } | |
713 | ||
714 | void | |
5c5185ae | 715 | exec_unmap_page(struct lwbuf *lwb) |
984263bc | 716 | { |
18f40545 MD |
717 | vm_page_t m; |
718 | ||
5fd012e0 | 719 | crit_enter(); |
5c5185ae SG |
720 | if (lwb != NULL) { |
721 | m = lwbuf_page(lwb); | |
722 | lwbuf_free(lwb); | |
e4ba7818 | 723 | vm_page_unhold(m); |
984263bc | 724 | } |
5fd012e0 | 725 | crit_exit(); |
984263bc MD |
726 | } |
727 | ||
7c34d798 SS |
728 | void |
729 | exec_unmap_first_page(struct image_params *imgp) | |
730 | { | |
731 | exec_unmap_page(imgp->firstpage); | |
732 | imgp->firstpage = NULL; | |
733 | imgp->image_header = NULL; | |
734 | } | |
735 | ||
984263bc MD |
736 | /* |
737 | * Destroy old address space, and allocate a new stack | |
738 | * The new stack is only SGROWSIZ large because it is grown | |
739 | * automatically in trap.c. | |
dc52e1cc MD |
740 | * |
741 | * This is the point of no return. | |
984263bc MD |
742 | */ |
743 | int | |
29802dbb | 744 | exec_new_vmspace(struct image_params *imgp, struct vmspace *vmcopy) |
984263bc | 745 | { |
984263bc MD |
746 | struct vmspace *vmspace = imgp->proc->p_vmspace; |
747 | vm_offset_t stack_addr = USRSTACK - maxssiz; | |
dc52e1cc | 748 | struct proc *p; |
29802dbb | 749 | vm_map_t map; |
dc52e1cc | 750 | int error; |
984263bc | 751 | |
dc52e1cc MD |
752 | /* |
753 | * Indicate that we cannot gracefully error out any more, kill | |
754 | * any other threads present, and set P_INEXEC to indicate that | |
755 | * we are now messing with the process structure proper. | |
756 | * | |
757 | * If killalllwps() races return an error which coupled with | |
758 | * vmspace_destroyed will cause us to exit. This is what we | |
759 | * want since another thread is patiently waiting for us to exit | |
760 | * in that case. | |
761 | */ | |
762 | p = curproc; | |
984263bc MD |
763 | imgp->vmspace_destroyed = 1; |
764 | ||
dc52e1cc MD |
765 | if (curthread->td_proc->p_nthreads > 1) { |
766 | error = killalllwps(1); | |
767 | if (error) | |
768 | return (error); | |
769 | } | |
770 | imgp->vmspace_destroyed |= 2; /* we are responsible for P_INEXEC */ | |
4643740a | 771 | p->p_flags |= P_INEXEC; |
08f2f1bb | 772 | |
7c37ea07 MD |
773 | /* |
774 | * Tell procfs to release its hold on the process. It | |
775 | * will return EAGAIN. | |
776 | */ | |
777 | if (p->p_stops) | |
778 | wakeup(&p->p_stype); | |
779 | ||
82354ad8 MD |
780 | /* |
781 | * After setting P_INEXEC wait for any remaining references to | |
782 | * the process (p) to go away. | |
783 | * | |
784 | * In particular, a vfork/exec sequence will replace p->p_vmspace | |
785 | * and we must interlock anyone trying to access the space (aka | |
786 | * procfs or sys_process.c calling procfs_domem()). | |
787 | * | |
788 | * If P_PPWAIT is set the parent vfork()'d and has a PHOLD() on us. | |
789 | */ | |
790 | PSTALL(p, "exec1", ((p->p_flags & P_PPWAIT) ? 1 : 0)); | |
791 | ||
984263bc MD |
792 | /* |
793 | * Blow away entire process VM, if address space not shared, | |
794 | * otherwise, create a new VM space so that other threads are | |
29802dbb MD |
795 | * not disrupted. If we are execing a resident vmspace we |
796 | * create a duplicate of it and remap the stack. | |
984263bc | 797 | */ |
29802dbb MD |
798 | map = &vmspace->vm_map; |
799 | if (vmcopy) { | |
800 | vmspace_exec(imgp->proc, vmcopy); | |
801 | vmspace = imgp->proc->p_vmspace; | |
802 | pmap_remove_pages(vmspace_pmap(vmspace), stack_addr, USRSTACK); | |
803 | map = &vmspace->vm_map; | |
a2ee730d | 804 | } else if (vmspace->vm_sysref.refcnt == 1) { |
fef0fdf2 | 805 | shmexit(vmspace); |
239b4df9 | 806 | if (vmspace->vm_upcalls) |
08f2f1bb | 807 | upc_release(vmspace, ONLY_LWP_IN_PROC(imgp->proc)); |
88181b08 | 808 | pmap_remove_pages(vmspace_pmap(vmspace), |
b0c15cdf | 809 | 0, VM_MAX_USER_ADDRESS); |
88181b08 | 810 | vm_map_remove(map, 0, VM_MAX_USER_ADDRESS); |
984263bc | 811 | } else { |
29802dbb | 812 | vmspace_exec(imgp->proc, NULL); |
984263bc MD |
813 | vmspace = imgp->proc->p_vmspace; |
814 | map = &vmspace->vm_map; | |
815 | } | |
816 | ||
817 | /* Allocate a new stack */ | |
818 | error = vm_map_stack(&vmspace->vm_map, stack_addr, (vm_size_t)maxssiz, | |
c809941b | 819 | 0, VM_PROT_ALL, VM_PROT_ALL, 0); |
984263bc MD |
820 | if (error) |
821 | return (error); | |
822 | ||
823 | /* vm_ssize and vm_maxsaddr are somewhat antiquated concepts in the | |
824 | * VM_STACK case, but they are still used to monitor the size of the | |
825 | * process stack so we can check the stack rlimit. | |
826 | */ | |
827 | vmspace->vm_ssize = sgrowsiz >> PAGE_SHIFT; | |
828 | vmspace->vm_maxsaddr = (char *)USRSTACK - maxssiz; | |
829 | ||
830 | return(0); | |
831 | } | |
832 | ||
833 | /* | |
834 | * Copy out argument and environment strings from the old process | |
835 | * address space into the temporary string buffer. | |
836 | */ | |
837 | int | |
2bd9d75c | 838 | exec_copyin_args(struct image_args *args, char *fname, |
2abfe22f | 839 | enum exec_path_segflg segflg, char **argv, char **envv) |
984263bc | 840 | { |
984263bc | 841 | char *argp, *envp; |
2bd9d75c | 842 | int error = 0; |
984263bc MD |
843 | size_t length; |
844 | ||
18b3f457 | 845 | args->buf = objcache_get(exec_objcache, M_WAITOK); |
2bd9d75c DRJ |
846 | if (args->buf == NULL) |
847 | return (ENOMEM); | |
848 | args->begin_argv = args->buf; | |
849 | args->endp = args->begin_argv; | |
850 | args->space = ARG_MAX; | |
2bd9d75c DRJ |
851 | |
852 | args->fname = args->buf + ARG_MAX; | |
853 | ||
984263bc | 854 | /* |
2bd9d75c | 855 | * Copy the file name. |
984263bc | 856 | */ |
2bd9d75c DRJ |
857 | if (segflg == PATH_SYSSPACE) { |
858 | error = copystr(fname, args->fname, PATH_MAX, &length); | |
859 | } else if (segflg == PATH_USERSPACE) { | |
860 | error = copyinstr(fname, args->fname, PATH_MAX, &length); | |
861 | } | |
984263bc | 862 | |
2bd9d75c | 863 | /* |
66be6566 MD |
864 | * Extract argument strings. argv may not be NULL. The argv |
865 | * array is terminated by a NULL entry. We special-case the | |
866 | * situation where argv[0] is NULL by passing { filename, NULL } | |
867 | * to the new program to guarentee that the interpreter knows what | |
868 | * file to open in case we exec an interpreted file. Note that | |
869 | * a NULL argv[0] terminates the argv[] array. | |
870 | * | |
871 | * XXX the special-casing of argv[0] is historical and needs to be | |
872 | * revisited. | |
2bd9d75c | 873 | */ |
66be6566 MD |
874 | if (argv == NULL) |
875 | error = EFAULT; | |
876 | if (error == 0) { | |
877 | while ((argp = (caddr_t)(intptr_t)fuword(argv++)) != NULL) { | |
878 | if (argp == (caddr_t)-1) { | |
2bd9d75c | 879 | error = EFAULT; |
66be6566 | 880 | break; |
2bd9d75c DRJ |
881 | } |
882 | error = copyinstr(argp, args->endp, | |
d0e92318 | 883 | args->space, &length); |
66be6566 MD |
884 | if (error) { |
885 | if (error == ENAMETOOLONG) | |
886 | error = E2BIG; | |
887 | break; | |
888 | } | |
2bd9d75c DRJ |
889 | args->space -= length; |
890 | args->endp += length; | |
891 | args->argc++; | |
984263bc | 892 | } |
66be6566 MD |
893 | if (args->argc == 0 && error == 0) { |
894 | length = strlen(args->fname) + 1; | |
895 | if (length > args->space) { | |
896 | error = E2BIG; | |
897 | } else { | |
898 | bcopy(args->fname, args->endp, length); | |
899 | args->space -= length; | |
900 | args->endp += length; | |
901 | args->argc++; | |
902 | } | |
903 | } | |
984263bc MD |
904 | } |
905 | ||
2bd9d75c | 906 | args->begin_envv = args->endp; |
984263bc MD |
907 | |
908 | /* | |
66be6566 | 909 | * extract environment strings. envv may be NULL. |
984263bc | 910 | */ |
2abfe22f | 911 | if (envv && error == 0) { |
984263bc | 912 | while ((envp = (caddr_t) (intptr_t) fuword(envv++))) { |
2bd9d75c DRJ |
913 | if (envp == (caddr_t) -1) { |
914 | error = EFAULT; | |
66be6566 | 915 | break; |
984263bc | 916 | } |
d0e92318 MD |
917 | error = copyinstr(envp, args->endp, |
918 | args->space, &length); | |
66be6566 MD |
919 | if (error) { |
920 | if (error == ENAMETOOLONG) | |
921 | error = E2BIG; | |
922 | break; | |
923 | } | |
2bd9d75c DRJ |
924 | args->space -= length; |
925 | args->endp += length; | |
926 | args->envc++; | |
984263bc MD |
927 | } |
928 | } | |
2bd9d75c DRJ |
929 | return (error); |
930 | } | |
931 | ||
932 | void | |
933 | exec_free_args(struct image_args *args) | |
934 | { | |
2abfe22f | 935 | if (args->buf) { |
18b3f457 | 936 | objcache_put(exec_objcache, args->buf); |
2abfe22f MD |
937 | args->buf = NULL; |
938 | } | |
984263bc MD |
939 | } |
940 | ||
941 | /* | |
942 | * Copy strings out to the new process address space, constructing | |
d0e92318 MD |
943 | * new arg and env vector tables. Return a pointer to the base |
944 | * so that it can be used as the initial stack pointer. | |
945 | * | |
946 | * The format is, roughly: | |
947 | * | |
948 | * [argv[]] <-- vectp | |
949 | * [envp[]] | |
950 | * [ELF_Auxargs] | |
951 | * | |
952 | * [args & env] <-- destp | |
953 | * [sgap] | |
954 | * [SPARE_USRSPACE] | |
955 | * [execpath] | |
956 | * [szsigcode] | |
957 | * [ps_strings] top of user stack | |
958 | * | |
984263bc MD |
959 | */ |
960 | register_t * | |
2bd9d75c | 961 | exec_copyout_strings(struct image_params *imgp) |
984263bc | 962 | { |
17a7ca1f | 963 | int argc, envc, sgap; |
d0e92318 MD |
964 | int gap; |
965 | int argsenvspace; | |
984263bc MD |
966 | char **vectp; |
967 | char *stringp, *destp; | |
968 | register_t *stack_base; | |
969 | struct ps_strings *arginfo; | |
adc42cf3 | 970 | size_t execpath_len; |
984263bc MD |
971 | int szsigcode; |
972 | ||
973 | /* | |
974 | * Calculate string base and vector table pointers. | |
975 | * Also deal with signal trampoline code for this exec type. | |
976 | */ | |
adc42cf3 JM |
977 | if (imgp->execpath != NULL && imgp->auxargs != NULL) |
978 | execpath_len = strlen(imgp->execpath) + 1; | |
979 | else | |
980 | execpath_len = 0; | |
984263bc MD |
981 | arginfo = (struct ps_strings *)PS_STRINGS; |
982 | szsigcode = *(imgp->proc->p_sysent->sv_szsigcode); | |
d0e92318 MD |
983 | |
984 | argsenvspace = roundup((ARG_MAX - imgp->args->space), sizeof(char *)); | |
985 | gap = stackgap_random; | |
986 | cpu_ccfence(); | |
987 | if (gap != 0) { | |
988 | if (gap < 0) | |
989 | sgap = ALIGN(-gap); | |
990 | else | |
1bd7d69f | 991 | sgap = ALIGN(karc4random() & (gap - 1)); |
d0e92318 MD |
992 | } else { |
993 | sgap = 0; | |
994 | } | |
995 | ||
d0e92318 MD |
996 | /* |
997 | * Calculate destp, which points to [args & env] and above. | |
998 | */ | |
1bd7d69f MD |
999 | destp = (caddr_t)arginfo - |
1000 | szsigcode - | |
d0e92318 MD |
1001 | roundup(execpath_len, sizeof(char *)) - |
1002 | SPARE_USRSPACE - | |
1003 | sgap - | |
1004 | argsenvspace; | |
984263bc MD |
1005 | |
1006 | /* | |
1007 | * install sigcode | |
1008 | */ | |
d0e92318 | 1009 | if (szsigcode) { |
984263bc | 1010 | copyout(imgp->proc->p_sysent->sv_sigcode, |
d0e92318 MD |
1011 | ((caddr_t)arginfo - szsigcode), szsigcode); |
1012 | } | |
984263bc | 1013 | |
adc42cf3 JM |
1014 | /* |
1015 | * Copy the image path for the rtld | |
1016 | */ | |
d0e92318 | 1017 | if (execpath_len) { |
adc42cf3 JM |
1018 | imgp->execpathp = (uintptr_t)arginfo |
1019 | - szsigcode | |
d0e92318 | 1020 | - roundup(execpath_len, sizeof(char *)); |
adc42cf3 JM |
1021 | copyout(imgp->execpath, (void *)imgp->execpathp, execpath_len); |
1022 | } | |
1023 | ||
984263bc | 1024 | /* |
d0e92318 | 1025 | * Calculate base for argv[], envp[], and ELF_Auxargs. |
984263bc | 1026 | */ |
d0e92318 MD |
1027 | vectp = (char **)destp - (AT_COUNT * 2); |
1028 | vectp -= imgp->args->argc + imgp->args->envc + 2; | |
984263bc | 1029 | |
984263bc MD |
1030 | stack_base = (register_t *)vectp; |
1031 | ||
2bd9d75c DRJ |
1032 | stringp = imgp->args->begin_argv; |
1033 | argc = imgp->args->argc; | |
1034 | envc = imgp->args->envc; | |
984263bc MD |
1035 | |
1036 | /* | |
d0e92318 | 1037 | * Copy out strings - arguments and environment (at destp) |
984263bc | 1038 | */ |
2bd9d75c | 1039 | copyout(stringp, destp, ARG_MAX - imgp->args->space); |
984263bc MD |
1040 | |
1041 | /* | |
1042 | * Fill in "ps_strings" struct for ps, w, etc. | |
1043 | */ | |
1044 | suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp); | |
3f938eea | 1045 | suword32(&arginfo->ps_nargvstr, argc); |
984263bc MD |
1046 | |
1047 | /* | |
1048 | * Fill in argument portion of vector table. | |
1049 | */ | |
1050 | for (; argc > 0; --argc) { | |
1051 | suword(vectp++, (long)(intptr_t)destp); | |
1052 | while (*stringp++ != 0) | |
1053 | destp++; | |
1054 | destp++; | |
1055 | } | |
1056 | ||
7a44d1cb | 1057 | /* a null vector table pointer separates the argp's from the envp's */ |
984263bc MD |
1058 | suword(vectp++, 0); |
1059 | ||
1060 | suword(&arginfo->ps_envstr, (long)(intptr_t)vectp); | |
3f938eea | 1061 | suword32(&arginfo->ps_nenvstr, envc); |
984263bc MD |
1062 | |
1063 | /* | |
1064 | * Fill in environment portion of vector table. | |
1065 | */ | |
1066 | for (; envc > 0; --envc) { | |
1067 | suword(vectp++, (long)(intptr_t)destp); | |
1068 | while (*stringp++ != 0) | |
1069 | destp++; | |
1070 | destp++; | |
1071 | } | |
1072 | ||
1073 | /* end of vector table is a null pointer */ | |
1074 | suword(vectp, 0); | |
1075 | ||
1076 | return (stack_base); | |
1077 | } | |
1078 | ||
1079 | /* | |
1080 | * Check permissions of file to execute. | |
1081 | * Return 0 for success or error code on failure. | |
1082 | */ | |
1083 | int | |
246693ac | 1084 | exec_check_permissions(struct image_params *imgp, struct mount *topmnt) |
984263bc MD |
1085 | { |
1086 | struct proc *p = imgp->proc; | |
1087 | struct vnode *vp = imgp->vp; | |
1088 | struct vattr *attr = imgp->attr; | |
1089 | int error; | |
1090 | ||
1091 | /* Get file attributes */ | |
87de5057 | 1092 | error = VOP_GETATTR(vp, attr); |
984263bc MD |
1093 | if (error) |
1094 | return (error); | |
1095 | ||
1096 | /* | |
1097 | * 1) Check if file execution is disabled for the filesystem that this | |
1098 | * file resides on. | |
1099 | * 2) Insure that at least one execute bit is on - otherwise root | |
1100 | * will always succeed, and we don't want to happen unless the | |
1101 | * file really is executable. | |
1102 | * 3) Insure that the file is a regular file. | |
1103 | */ | |
1104 | if ((vp->v_mount->mnt_flag & MNT_NOEXEC) || | |
246693ac | 1105 | ((topmnt != NULL) && (topmnt->mnt_flag & MNT_NOEXEC)) || |
984263bc MD |
1106 | ((attr->va_mode & 0111) == 0) || |
1107 | (attr->va_type != VREG)) { | |
1108 | return (EACCES); | |
1109 | } | |
1110 | ||
1111 | /* | |
1112 | * Zero length files can't be exec'd | |
1113 | */ | |
1114 | if (attr->va_size == 0) | |
1115 | return (ENOEXEC); | |
1116 | ||
1117 | /* | |
1118 | * Check for execute permission to file based on current credentials. | |
1119 | */ | |
90a83564 | 1120 | error = VOP_EACCESS(vp, VEXEC, p->p_ucred); |
984263bc MD |
1121 | if (error) |
1122 | return (error); | |
1123 | ||
1124 | /* | |
1125 | * Check number of open-for-writes on the file and deny execution | |
1126 | * if there are any. | |
1127 | */ | |
1128 | if (vp->v_writecount) | |
1129 | return (ETXTBSY); | |
1130 | ||
1131 | /* | |
7540ab49 MD |
1132 | * Call filesystem specific open routine, which allows us to read, |
1133 | * write, and mmap the file. Without the VOP_OPEN we can only | |
1134 | * stat the file. | |
984263bc | 1135 | */ |
87de5057 | 1136 | error = VOP_OPEN(vp, FREAD, p->p_ucred, NULL); |
984263bc MD |
1137 | if (error) |
1138 | return (error); | |
1139 | ||
1140 | return (0); | |
1141 | } | |
1142 | ||
1143 | /* | |
1144 | * Exec handler registration | |
1145 | */ | |
1146 | int | |
77153250 | 1147 | exec_register(const struct execsw *execsw_arg) |
984263bc MD |
1148 | { |
1149 | const struct execsw **es, **xs, **newexecsw; | |
1150 | int count = 2; /* New slot and trailing NULL */ | |
1151 | ||
1152 | if (execsw) | |
1153 | for (es = execsw; *es; es++) | |
1154 | count++; | |
efda3bd0 | 1155 | newexecsw = kmalloc(count * sizeof(*es), M_TEMP, M_WAITOK); |
984263bc MD |
1156 | xs = newexecsw; |
1157 | if (execsw) | |
1158 | for (es = execsw; *es; es++) | |
1159 | *xs++ = *es; | |
1160 | *xs++ = execsw_arg; | |
1161 | *xs = NULL; | |
1162 | if (execsw) | |
efda3bd0 | 1163 | kfree(execsw, M_TEMP); |
984263bc MD |
1164 | execsw = newexecsw; |
1165 | return 0; | |
1166 | } | |
1167 | ||
1168 | int | |
77153250 | 1169 | exec_unregister(const struct execsw *execsw_arg) |
984263bc MD |
1170 | { |
1171 | const struct execsw **es, **xs, **newexecsw; | |
1172 | int count = 1; | |
1173 | ||
1174 | if (execsw == NULL) | |
ae7e74d4 | 1175 | panic("unregister with no handlers left?"); |
984263bc MD |
1176 | |
1177 | for (es = execsw; *es; es++) { | |
1178 | if (*es == execsw_arg) | |
1179 | break; | |
1180 | } | |
1181 | if (*es == NULL) | |
1182 | return ENOENT; | |
1183 | for (es = execsw; *es; es++) | |
1184 | if (*es != execsw_arg) | |
1185 | count++; | |
efda3bd0 | 1186 | newexecsw = kmalloc(count * sizeof(*es), M_TEMP, M_WAITOK); |
984263bc MD |
1187 | xs = newexecsw; |
1188 | for (es = execsw; *es; es++) | |
1189 | if (*es != execsw_arg) | |
1190 | *xs++ = *es; | |
1191 | *xs = NULL; | |
1192 | if (execsw) | |
efda3bd0 | 1193 | kfree(execsw, M_TEMP); |
984263bc MD |
1194 | execsw = newexecsw; |
1195 | return 0; | |
1196 | } |