Add (but don't activate) code for a special VM option to make

downward growing stacks more general.
Add (but don't activate) code to use the new stack facility
when running threads, (specifically the linux threads support).
This allows people to use both linux compiled linuxthreads, and also the
native FreeBSD linux-threads port.

The code is conditional on VM_STACK. Not using this will
produce the old heavily tested system.

Submitted by: Richard Seaman <dick@tar.com>

5 files changed, 109 insertions, 70 deletions

diff --git a/sys/i386/i386/machdep.c b/sys/i386/i386/machdep.c
index 45c5e8f..cb4f514 100644
--- a/sys/i386/i386/machdep.c
+++ b/sys/i386/i386/machdep.c
@@ -35,7 +35,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)machdep.c	7.4 (Berkeley) 6/3/91
- *	$Id: machdep.c,v 1.318 1998/12/10 01:49:01 steve Exp $
+ *	$Id: machdep.c,v 1.319 1998/12/16 16:28:56 bde Exp $
  */
 
 #include "apm.h"
@@ -525,7 +525,11 @@ sendsig(catcher, sig, mask, code)
 	 *	and the stack can not be grown. useracc will return FALSE
 	 *	if access is denied.
 	 */
+#ifdef VM_STACK
+	if ((grow_stack (p, (int)fp) == FALSE) ||
+#else
 	if ((grow(p, (int)fp) == FALSE) ||
+#endif
 	    (useracc((caddr_t)fp, sizeof(struct sigframe), B_WRITE) == FALSE)) {
 		/*
 		 * Process has trashed its stack; give it an illegal
diff --git a/sys/i386/i386/trap.c b/sys/i386/i386/trap.c
index e672368..42b0c85 100644
--- a/sys/i386/i386/trap.c
+++ b/sys/i386/i386/trap.c
@@ -35,7 +35,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)trap.c	7.4 (Berkeley) 5/13/91
- *	$Id: trap.c,v 1.131 1998/12/16 15:21:50 bde Exp $
+ *	$Id: trap.c,v 1.132 1998/12/28 23:02:56 msmith Exp $
  */
 
 /*
@@ -665,6 +665,7 @@ trap_pfault(frame, usermode, eva)
 		/*
 		 * Grow the stack if necessary
 		 */
+#ifndef VM_STACK
 		if ((caddr_t)va > vm->vm_maxsaddr && va < USRSTACK) {
 			if (!grow(p, va)) {
 				rv = KERN_FAILURE;
@@ -673,6 +674,20 @@ trap_pfault(frame, usermode, eva)
 			}
 		}
 
+#else
+		/* grow_stack returns false only if va falls into
+		 * a growable stack region and the stack growth
+		 * fails.  It returns true if va was not within
+		 * a growable stack region, or if the stack 
+		 * growth succeeded.
+		 */
+		if (!grow_stack (p, va)) {
+			rv = KERN_FAILURE;
+			--p->p_lock;
+			goto nogo;
+		}
+#endif
+		
 		/* Fault in the user page: */
 		rv = vm_fault(map, va, ftype,
 			(ftype & VM_PROT_WRITE) ? VM_FAULT_DIRTY : 0);
@@ -775,6 +790,7 @@ trap_pfault(frame, usermode, eva)
 		/*
 		 * Grow the stack if necessary
 		 */
+#ifndef VM_STACK
 		if ((caddr_t)va > vm->vm_maxsaddr && va < USRSTACK) {
 			if (!grow(p, va)) {
 				rv = KERN_FAILURE;
@@ -782,6 +798,19 @@ trap_pfault(frame, usermode, eva)
 				goto nogo;
 			}
 		}
+#else
+		/* grow_stack returns false only if va falls into
+		 * a growable stack region and the stack growth
+		 * fails.  It returns true if va was not within
+		 * a growable stack region, or if the stack 
+		 * growth succeeded.
+		 */
+		if (!grow_stack (p, va)) {
+			rv = KERN_FAILURE;
+			--p->p_lock;
+			goto nogo;
+		}
+#endif
 
 		/* Fault in the user page: */
 		rv = vm_fault(map, va, ftype,
@@ -969,12 +998,19 @@ int trapwrite(addr)
 
 	++p->p_lock;
 
+#ifndef VM_STACK
 	if ((caddr_t)va >= vm->vm_maxsaddr && va < USRSTACK) {
 		if (!grow(p, va)) {
 			--p->p_lock;
 			return (1);
 		}
 	}
+#else
+	if (!grow_stack (p, va)) {
+		--p->p_lock;
+		return (1);
+	}
+#endif
 
 	/*
 	 * fault the data page
diff --git a/sys/i386/i386/vm_machdep.c b/sys/i386/i386/vm_machdep.c
index 761008e..d0bdc93 100644
--- a/sys/i386/i386/vm_machdep.c
+++ b/sys/i386/i386/vm_machdep.c
@@ -38,7 +38,7 @@
  *
  *	from: @(#)vm_machdep.c	7.3 (Berkeley) 5/13/91
  *	Utah $Hdr: vm_machdep.c 1.16.1.1 89/06/23$
- *	$Id: vm_machdep.c,v 1.113 1998/10/31 17:21:30 peter Exp $
+ *	$Id: vm_machdep.c,v 1.114 1998/12/16 15:21:51 bde Exp $
  */
 
 #include "npx.h"
@@ -507,6 +507,7 @@ cpu_reset_real()
 	while(1);
 }
 
+#ifndef VM_STACK
 /*
  * Grow the user stack to allow for 'sp'. This version grows the stack in
  *	chunks of SGROWSIZ.
@@ -559,6 +560,22 @@ grow(p, sp)
 
 	return (1);
 }
+#else
+int
+grow_stack(p, sp)
+	struct proc *p;
+	u_int sp;
+{
+	int rv;
+
+	rv = vm_map_growstack (p, sp);
+	if (rv != KERN_SUCCESS)
+		return (0);
+
+	return (1);
+}
+#endif
+
 
 static int cnt_prezero;
 
diff --git a/sys/i386/linux/linux_misc.c b/sys/i386/linux/linux_misc.c
index 3bdc805..02f9785 100644
--- a/sys/i386/linux/linux_misc.c
+++ b/sys/i386/linux/linux_misc.c
@@ -25,7 +25,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *  $Id: linux_misc.c,v 1.49 1998/12/24 21:21:20 julian Exp $
+ *  $Id: linux_misc.c,v 1.50 1998/12/30 21:01:33 sos Exp $
  */
 
 #include <sys/param.h>
@@ -688,45 +688,44 @@ linux_mmap(struct proc *p, struct linux_mmap_args *args)
     bsd_args.len = linux_args.len;
 #else
 
-    /*#if !defined(USE_VM_STACK) && !defined(USE_VM_STACK_FOR_EXEC)*/
+#ifndef VM_STACK
     /* Linux Threads will map into the proc stack space, unless
-       we prevent it.  This causes problems if we're not using
-       our VM_STACK options.
-    */
+     * we prevent it.  This causes problems if we're not using
+     * our VM_STACK options.
+     */
     if ((unsigned int)linux_args.addr + linux_args.len > (USRSTACK - MAXSSIZ))
-        return (EINVAL);
-    /*#endif*/
+	return (EINVAL);
+#endif
 
     if (linux_args.flags & LINUX_MAP_GROWSDOWN) {
 
-#ifdef USE_VM_STACK
-        /* USE_VM_STACK is defined (or not) in vm/vm_map.h */
-        bsd_args.flags |= MAP_STACK;      
+#ifdef VM_STACK
+	bsd_args.flags |= MAP_STACK;      
 #endif
 
 	/* The linux MAP_GROWSDOWN option does not limit auto
-	   growth of the region.  Linux mmap with this option
-	   takes as addr the inital BOS, and as len, the initial
-	   region size.  It can then grow down from addr without
-	   limit.  However, linux threads has an implicit internal
-	   limit to stack size of STACK_SIZE.  Its just not
-	   enforced explicitly in linux.  But, here we impose
-	   a limit of (STACK_SIZE - GUARD_SIZE) on the stack
-	   region, since we can do this with our mmap.
-
-	   Our mmap with MAP_STACK takes addr as the maximum
-	   downsize limit on BOS, and as len the max size of
-	   the region.  It them maps the top SGROWSIZ bytes,
-	   and autgrows the region down, up to the limit
-	   in addr.
-
-	   If we don't use the MAP_STACK option, the effect
-	   of this code is to allocate a stack region of a
-	   fixed size of (STACK_SIZE - GUARD_SIZE).
-	*/
+	 * growth of the region.  Linux mmap with this option
+	 * takes as addr the inital BOS, and as len, the initial
+	 * region size.  It can then grow down from addr without
+	 * limit.  However, linux threads has an implicit internal
+	 * limit to stack size of STACK_SIZE.  Its just not
+	 * enforced explicitly in linux.  But, here we impose
+	 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
+	 * region, since we can do this with our mmap.
+	 *
+	 * Our mmap with MAP_STACK takes addr as the maximum
+	 * downsize limit on BOS, and as len the max size of
+	 * the region.  It them maps the top SGROWSIZ bytes,
+	 * and autgrows the region down, up to the limit
+	 * in addr.
+	 *
+	 * If we don't use the MAP_STACK option, the effect
+	 * of this code is to allocate a stack region of a
+	 * fixed size of (STACK_SIZE - GUARD_SIZE).
+	 */
 
 	/* This gives us TOS */
-        bsd_args.addr = linux_args.addr + linux_args.len;
+	bsd_args.addr = linux_args.addr + linux_args.len;
 
 	/* This gives us our maximum stack size */
 	if (linux_args.len > STACK_SIZE - GUARD_SIZE)
@@ -735,15 +734,15 @@ linux_mmap(struct proc *p, struct linux_mmap_args *args)
 	    bsd_args.len  = STACK_SIZE - GUARD_SIZE;
 
 	/* This gives us a new BOS.  If we're using VM_STACK, then
-	   mmap will just map the top SGROWSIZ bytes, and let
-	   the stack grow down to the limit at BOS.  If we're
-	   not using VM_STACK we map the full stack, since we
-	   don't have a way to autogrow it.
-	*/
+	 * mmap will just map the top SGROWSIZ bytes, and let
+	 * the stack grow down to the limit at BOS.  If we're
+	 * not using VM_STACK we map the full stack, since we
+	 * don't have a way to autogrow it.
+	 */
 	bsd_args.addr -= bsd_args.len;
 
     } else {
-        bsd_args.addr = linux_args.addr;
+	bsd_args.addr = linux_args.addr;
 	bsd_args.len  = linux_args.len;
     }
 #endif /* COMPAT_LINUX_THREADS */
@@ -977,11 +976,11 @@ linux_waitpid(struct proc *p, struct linux_waitpid_args *args)
     tmp.options = args->options;
 #else
     /* This filters out the linux option _WCLONE.  I don't
-       think we need it, but I could be wrong.  If we need
-       it, we need to fix wait4, since it will give us an
-       error return of EINVAL if we pass in _WCLONE, and
-       of course, it won't do anything with it.
-    */
+     * think we need it, but I could be wrong.  If we need
+     * it, we need to fix wait4, since it will give us an
+     * error return of EINVAL if we pass in _WCLONE, and
+     * of course, it won't do anything with it.
+     */
     tmp.options = (args->options & (WNOHANG | WUNTRACED));
 #endif /* COMPAT_LINUX_THREADS */
     tmp.rusage = NULL;
@@ -990,7 +989,7 @@ linux_waitpid(struct proc *p, struct linux_waitpid_args *args)
 #ifndef COMPAT_LINUX_THREADS
 	return error;
 #else
-  	return error;
+	return error;
 #endif /* COMPAT_LINUX_THREADS */
     if (args->status) {
 	if (error = copyin(args->status, &tmpstat, sizeof(int)))
@@ -1028,11 +1027,11 @@ linux_wait4(struct proc *p, struct linux_wait4_args *args)
     tmp.options = args->options;
 #else
     /* This filters out the linux option _WCLONE.  I don't
-       think we need it, but I could be wrong.  If we need
-       it, we need to fix wait4, since it will give us an
-       error return of EINVAL if we pass in _WCLONE, and
-       of course, it won't do anything with it.
-    */
+     * think we need it, but I could be wrong.  If we need
+     * it, we need to fix wait4, since it will give us an
+     * error return of EINVAL if we pass in _WCLONE, and
+     * of course, it won't do anything with it.
+     */
     tmp.options = (args->options & (WNOHANG | WUNTRACED));
 #endif /* COMPAT_LINUX_THREADS */
     tmp.rusage = args->rusage;
diff --git a/sys/i386/linux/linux_sysvec.c b/sys/i386/linux/linux_sysvec.c
index 611899c..da1d78f 100644
--- a/sys/i386/linux/linux_sysvec.c
+++ b/sys/i386/linux/linux_sysvec.c
@@ -25,7 +25,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *  $Id: linux_sysvec.c,v 1.41 1998/12/19 02:55:33 julian Exp $
+ *  $Id: linux_sysvec.c,v 1.42 1998/12/19 19:05:57 sos Exp $
  */
 
 /* XXX we use functions that might not exist. */
@@ -50,10 +50,6 @@
 #include <vm/vm_prot.h>
 #include <vm/vm_page.h>
 #include <vm/vm_extern.h>
-#ifdef COMPAT_LINUX_THREADS
-#include <sys/lock.h>             /* needed, for now, by vm_map.h */
-#include <vm/vm_map.h>            /* needed, for now, for VM_STACK defines */
-#endif /* COMPAT_LINUX_THREADS */
 #include <sys/exec.h>
 #include <sys/kernel.h>
 #include <sys/module.h>
@@ -221,24 +217,11 @@ linux_sendsig(sig_t catcher, int sig, int mask, u_long code)
 	 *	and the stack can not be grown. useracc will return FALSE
 	 *	if access is denied.
 	 */
-#ifdef COMPAT_LINUX_THREADS
-#ifdef USE_VM_STACK
-#ifndef USE_VM_STACK_FOR_EXEC
-	if ((((caddr_t)fp > p->p_vmspace->vm_maxsaddr &&
-	      (caddr_t)fp < (caddr_t)USRSTACK &&
-	      grow(p, (int)fp) == FALSE) ||
-	     (((caddr_t)fp <= p->p_vmspace->vm_maxsaddr ||
-	       (caddr_t)fp >= (caddr_t)USRSTACK) &&
-	      grow_stack (p, (int)fp) == FALSE)) ||
-#else
+#ifdef VM_STACK
 	if ((grow_stack (p, (int)fp) == FALSE) ||
-#endif /* USE_VM_STACK_FOR_EXEC */
-#else
-	if ((grow(p, (int)fp) == FALSE) ||
-#endif /* USE_VM_STACK */
 #else
 	if ((grow(p, (int)fp) == FALSE) ||
-#endif /* COMPAT_LINUX_THREADS */
+#endif 
 	    (useracc((caddr_t)fp, sizeof (struct linux_sigframe), B_WRITE) == FALSE)) {
 		/*
 		 * Process has trashed its stack; give it an illegal