Use the fields in the sysentvec and in the vm map header in place of the

constants VM_MIN_ADDRESS, VM_MAXUSER_ADDRESS, USRSTACK and PS_STRINGS.
This is mainly so that they can be variable even for the native abi, based
on different machine types.  Get stack protections from the sysentvec too.
This makes it trivial to map the stack non-executable for certain abis, on
machines that support it.

7 files changed, 66 insertions, 38 deletions

diff --git a/sys/kern/imgact_aout.c b/sys/kern/imgact_aout.c
index 8903988..e96054a 100644
--- a/sys/kern/imgact_aout.c
+++ b/sys/kern/imgact_aout.c
@@ -140,7 +140,7 @@ exec_aout_imgact(imgp)
 		file_offset = 0;
 		/* Pass PS_STRINGS for BSD/OS binaries only. */
 		if (N_GETMID(*a_out) == MID_ZERO)
-			imgp->ps_strings = PS_STRINGS;
+			imgp->ps_strings = aout_sysvec.sv_psstrings;
 		break;
 	default:
 		/* NetBSD compatibility */
@@ -192,7 +192,7 @@ exec_aout_imgact(imgp)
 	/*
 	 * Destroy old process VM and create a new one (with a new stack)
 	 */
-	exec_new_vmspace(imgp, VM_MIN_ADDRESS, VM_MAXUSER_ADDRESS, USRSTACK);
+	exec_new_vmspace(imgp, &aout_sysvec);
 
 	/*
 	 * The vm space can be changed by exec_new_vmspace
@@ -299,8 +299,8 @@ aout_coredump(td, vp, limit)
 		    IO_UNIT | IO_DIRECT, cred, NOCRED, (int *) NULL, td);
 	if (error == 0)
 		error = vn_rdwr_inchunks(UIO_WRITE, vp,
-		    (caddr_t)trunc_page(USRSTACK - ctob(vm->vm_ssize)),
-		    round_page(ctob(vm->vm_ssize)),
+		    (caddr_t)trunc_page(p->p_sysent->sv_usrstack -
+		    ctob(vm->vm_ssize)), round_page(ctob(vm->vm_ssize)),
 		    (off_t)ctob(uarea_pages + kstack_pages) +
 		        ctob(vm->vm_dsize), UIO_USERSPACE,
 		    IO_UNIT | IO_DIRECT, cred, NOCRED, (int *) NULL, td);
diff --git a/sys/kern/imgact_elf.c b/sys/kern/imgact_elf.c
index 01e1bd2..7ff8dd8 100644
--- a/sys/kern/imgact_elf.c
+++ b/sys/kern/imgact_elf.c
@@ -699,8 +699,7 @@ __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
 	if ((error = exec_extract_strings(imgp)) != 0)
 		goto fail;
 
-	exec_new_vmspace(imgp, sv->sv_minuser, sv->sv_maxuser,
-	    sv->sv_usrstack);
+	exec_new_vmspace(imgp, sv);
 
 	vmspace = imgp->proc->p_vmspace;
 
diff --git a/sys/kern/imgact_gzip.c b/sys/kern/imgact_gzip.c
index 3268413..1ea1ad4 100644
--- a/sys/kern/imgact_gzip.c
+++ b/sys/kern/imgact_gzip.c
@@ -229,7 +229,7 @@ do_aout_hdr(struct imgact_gzip * gz)
 	/*
 	 * Destroy old process VM and create a new one (with a new stack)
 	 */
-	exec_new_vmspace(gz->ip, VM_MIN_ADDRESS, VM_MAXUSER_ADDRESS, USRSTACK);
+	exec_new_vmspace(gz->ip, &aout_sysvec);
 
 	vmspace = gz->ip->proc->p_vmspace;
 
diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c
index 93afb1d..49bb739 100644
--- a/sys/kern/init_main.c
+++ b/sys/kern/init_main.c
@@ -435,8 +435,8 @@ KASSERT((ke->ke_kgrlist.tqe_next != ke), ("linked to self!"));
 	pmap_pinit0(vmspace_pmap(&vmspace0));
 	p->p_vmspace = &vmspace0;
 	vmspace0.vm_refcnt = 1;
-	vm_map_init(&vmspace0.vm_map, round_page(VM_MIN_ADDRESS),
-	    trunc_page(VM_MAXUSER_ADDRESS));
+	vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser,
+	    p->p_sysent->sv_maxuser);
 	vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
 
 	/*
@@ -571,7 +571,7 @@ start_init(void *dummy)
 	/*
 	 * Need just enough stack to hold the faked-up "execve()" arguments.
 	 */
-	addr = trunc_page(USRSTACK - PAGE_SIZE);
+	addr = p->p_sysent->sv_usrstack - PAGE_SIZE;
 	if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE,
 			FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
 		panic("init: couldn't allocate argument space");
@@ -603,7 +603,7 @@ start_init(void *dummy)
 		 * Move out the boot flag argument.
 		 */
 		options = 0;
-		ucp = (char *)USRSTACK;
+		ucp = (char *)p->p_sysent->sv_usrstack;
 		(void)subyte(--ucp, 0);		/* trailing zero */
 		if (boothowto & RB_SINGLE) {
 			(void)subyte(--ucp, 's');
diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c
index 3bad18a..784ed5c 100644
--- a/sys/kern/kern_exec.c
+++ b/sys/kern/kern_exec.c
@@ -74,6 +74,9 @@ MALLOC_DEFINE(M_PARGS, "proc-args", "Process arguments");
 
 static MALLOC_DEFINE(M_ATEXEC, "atexec", "atexec callback");
 
+static int sysctl_kern_ps_strings(SYSCTL_HANDLER_ARGS);
+static int sysctl_kern_usrstack(SYSCTL_HANDLER_ARGS);
+
 /*
  * callout list for things to do at exec time
  */
@@ -86,13 +89,12 @@ TAILQ_HEAD(exec_list_head, execlist);
 static struct exec_list_head exec_list = TAILQ_HEAD_INITIALIZER(exec_list);
 
 /* XXX This should be vm_size_t. */
-static u_long ps_strings = PS_STRINGS;
-SYSCTL_ULONG(_kern, KERN_PS_STRINGS, ps_strings, CTLFLAG_RD, &ps_strings,
-    0, "");
+SYSCTL_PROC(_kern, KERN_PS_STRINGS, ps_strings, CTLTYPE_ULONG|CTLFLAG_RD,
+    NULL, 0, sysctl_kern_ps_strings, "LU", "");
 
 /* XXX This should be vm_size_t. */
-static u_long usrstack = USRSTACK;
-SYSCTL_ULONG(_kern, KERN_USRSTACK, usrstack, CTLFLAG_RD, &usrstack, 0, "");
+SYSCTL_PROC(_kern, KERN_USRSTACK, usrstack, CTLTYPE_ULONG|CTLFLAG_RD,
+    NULL, 0, sysctl_kern_usrstack, "LU", "");
 
 u_long ps_arg_cache_limit = PAGE_SIZE / 16;
 SYSCTL_ULONG(_kern, OID_AUTO, ps_arg_cache_limit, CTLFLAG_RW, 
@@ -107,6 +109,26 @@ static int regstkpages = 256;
 SYSCTL_INT(_machdep, OID_AUTO, regstkpages, CTLFLAG_RW, &regstkpages, 0, "");
 #endif
 
+static int
+sysctl_kern_ps_strings(SYSCTL_HANDLER_ARGS)
+{
+	struct proc *p;
+
+	p = curproc;
+	return (SYSCTL_OUT(req, &p->p_sysent->sv_psstrings,
+	   sizeof(p->p_sysent->sv_psstrings)));
+}
+
+static int
+sysctl_kern_usrstack(SYSCTL_HANDLER_ARGS)
+{
+	struct proc *p;
+
+	p = curproc;
+	return (SYSCTL_OUT(req, &p->p_sysent->sv_usrstack,
+	    sizeof(p->p_sysent->sv_usrstack)));
+}
+
 /*
  * Each of the items is a pointer to a `const struct execsw', hence the
  * double pointer here.
@@ -688,18 +710,20 @@ exec_unmap_first_page(imgp)
  *	automatically in trap.c.
  */
 int
-exec_new_vmspace(imgp, minuser, maxuser, stack_addr)
+exec_new_vmspace(imgp, sv)
 	struct image_params *imgp;
-	vm_offset_t minuser, maxuser, stack_addr;
+	struct sysentvec *sv;
 {
 	int error;
 	struct execlist *ep;
 	struct proc *p = imgp->proc;
 	struct vmspace *vmspace = p->p_vmspace;
+	vm_offset_t stack_addr;
+	vm_map_t map;
 
 	GIANT_REQUIRED;
 
-	stack_addr = stack_addr - maxssiz;
+	stack_addr = sv->sv_usrstack - maxssiz;
 
 	imgp->vmspace_destroyed = 1;
 
@@ -714,21 +738,23 @@ exec_new_vmspace(imgp, minuser, maxuser, stack_addr)
 	 * otherwise, create a new VM space so that other threads are
 	 * not disrupted
 	 */
-	if (vmspace->vm_refcnt == 1 &&
-	    vm_map_min(&vmspace->vm_map) == minuser &&
-	    vm_map_max(&vmspace->vm_map) == maxuser) {
+	map = &vmspace->vm_map;
+	if (vmspace->vm_refcnt == 1 && vm_map_min(map) == sv->sv_minuser &&
+	    vm_map_max(map) == sv->sv_maxuser) {
 		if (vmspace->vm_shm)
 			shmexit(p);
-		pmap_remove_pages(vmspace_pmap(vmspace), minuser, maxuser);
-		vm_map_remove(&vmspace->vm_map, minuser, maxuser);
+		pmap_remove_pages(vmspace_pmap(vmspace), vm_map_min(map),
+		    vm_map_max(map));
+		vm_map_remove(map, vm_map_min(map), vm_map_max(map));
 	} else {
-		vmspace_exec(p, minuser, maxuser);
+		vmspace_exec(p, sv->sv_minuser, sv->sv_maxuser);
 		vmspace = p->p_vmspace;
+		map = &vmspace->vm_map;
 	}
 
 	/* Allocate a new stack */
-	error = vm_map_stack(&vmspace->vm_map, stack_addr, (vm_size_t)maxssiz,
-	    VM_PROT_ALL, VM_PROT_ALL, 0);
+	error = vm_map_stack(map, stack_addr, (vm_size_t)maxssiz,
+	    sv->sv_stackprot, VM_PROT_ALL, 0);
 	if (error)
 		return (error);
 
@@ -740,8 +766,8 @@ exec_new_vmspace(imgp, minuser, maxuser, stack_addr)
 		 * store to grow upwards. This will do for now.
 		 */
 		vm_offset_t bsaddr;
-		bsaddr = USRSTACK - 2 * maxssiz;
-		error = vm_map_find(&vmspace->vm_map, 0, 0, &bsaddr,
+		bsaddr = p->p_sysent->sv_usrstack - 2 * maxssiz;
+		error = vm_map_find(map, 0, 0, &bsaddr,
 		    regstkpages * PAGE_SIZE, 0, VM_PROT_ALL, VM_PROT_ALL, 0);
 		FIRST_THREAD_IN_PROC(p)->td_md.md_bspstore = bsaddr;
 	}
@@ -752,7 +778,7 @@ exec_new_vmspace(imgp, minuser, maxuser, stack_addr)
 	 * process stack so we can check the stack rlimit.
 	 */
 	vmspace->vm_ssize = sgrowsiz >> PAGE_SHIFT;
-	vmspace->vm_maxsaddr = (char *)USRSTACK - maxssiz;
+	vmspace->vm_maxsaddr = (char *)sv->sv_usrstack - maxssiz;
 
 	return (0);
 }
@@ -851,7 +877,7 @@ exec_copyout_strings(imgp)
 	 */
 	p = imgp->proc;
 	szsigcode = 0;
-	arginfo = (struct ps_strings *)PS_STRINGS;
+	arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
 	if (p->p_sysent->sv_szsigcode != NULL)
 		szsigcode = *(p->p_sysent->sv_szsigcode);
 	destp =	(caddr_t)arginfo - szsigcode - SPARE_USRSPACE -
diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c
index d08df3a..1725d54 100644
--- a/sys/kern/kern_exit.c
+++ b/sys/kern/kern_exit.c
@@ -287,10 +287,10 @@ exit1(td, rv)
 	if (--vm->vm_refcnt == 0) {
 		if (vm->vm_shm)
 			shmexit(p);
-		pmap_remove_pages(vmspace_pmap(vm), VM_MIN_ADDRESS,
-		    VM_MAXUSER_ADDRESS);
-		(void) vm_map_remove(&vm->vm_map, VM_MIN_ADDRESS,
-		    VM_MAXUSER_ADDRESS);
+		pmap_remove_pages(vmspace_pmap(vm), vm_map_min(&vm->vm_map),
+		    vm_map_max(&vm->vm_map));
+		(void) vm_map_remove(&vm->vm_map, vm_map_min(&vm->vm_map),
+		    vm_map_max(&vm->vm_map));
 		vm->vm_freer = p;
 	}
 
diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c
index 8f02c13..535756c 100644
--- a/sys/kern/kern_resource.c
+++ b/sys/kern/kern_resource.c
@@ -52,6 +52,7 @@
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/sx.h>
+#include <sys/sysent.h>
 #include <sys/time.h>
 
 #include <vm/vm.h>
@@ -593,13 +594,15 @@ dosetrlimit(td, which, limp)
 			vm_prot_t prot;
 
 			if (limp->rlim_cur > alimp->rlim_cur) {
-				prot = VM_PROT_ALL;
+				prot = p->p_sysent->sv_stackprot;
 				size = limp->rlim_cur - alimp->rlim_cur;
-				addr = USRSTACK - limp->rlim_cur;
+				addr = p->p_sysent->sv_usrstack -
+				    limp->rlim_cur;
 			} else {
 				prot = VM_PROT_NONE;
 				size = alimp->rlim_cur - limp->rlim_cur;
-				addr = USRSTACK - alimp->rlim_cur;
+				addr = p->p_sysent->sv_usrstack -
+				    alimp->rlim_cur;
 			}
 			addr = trunc_page(addr);
 			size = round_page(size);