Locking for the per-process resource limits structure.

- struct plimit includes a mutex to protect a reference count.  The plimit
  structure is treated similarly to struct ucred in that is is always copy
  on write, so having a reference to a structure is sufficient to read from
  it without needing a further lock.
- The proc lock protects the p_limit pointer and must be held while reading
  limits from a process to keep the limit structure from changing out from
  under you while reading from it.
- Various global limits that are ints are not protected by a lock since
  int writes are atomic on all the archs we support and thus a lock
  wouldn't buy us anything.
- All accesses to individual resource limits from a process are abstracted
  behind a simple lim_rlimit(), lim_max(), and lim_cur() API that return
  either an rlimit, or the current or max individual limit of the specified
  resource from a process.
- dosetrlimit() was renamed to kern_setrlimit() to match existing style of
  other similar syscall helper functions.
- The alpha OSF/1 compat layer no longer calls getrlimit() and setrlimit()
  (it didn't used the stackgap when it should have) but uses lim_rlimit()
  and kern_setrlimit() instead.
- The svr4 compat no longer uses the stackgap for resource limits calls,
  but uses lim_rlimit() and kern_setrlimit() instead.
- The ibcs2 compat no longer uses the stackgap for resource limits.  It
  also no longer uses the stackgap for accessing sysctl's for the
  ibcs2_sysconf() syscall but uses kernel_sysctl() instead.  As a result,
  ibcs2_sysconf() no longer needs Giant.
- The p_rlimit macro no longer exists.

Submitted by:	mtm (mostly, I only did a few cleanups and catchups)
Tested on:	i386
Compiled on:	alpha, amd64

1 files changed, 16 insertions, 9 deletions

diff --git a/sys/vm/vm_map.c b/sys/vm/vm_map.c
index f06fd78..5c93a84 100644
--- a/sys/vm/vm_map.c
+++ b/sys/vm/vm_map.c
@@ -2467,6 +2467,7 @@ vm_map_stack(vm_map_t map, vm_offset_t addrbos, vm_size_t max_ssize,
 	vm_offset_t bot, top;
 	vm_size_t init_ssize;
 	int orient, rv;
+	rlim_t vmemlim;
 
 	/*
 	 * The stack orientation is piggybacked with the cow argument.
@@ -2483,6 +2484,10 @@ vm_map_stack(vm_map_t map, vm_offset_t addrbos, vm_size_t max_ssize,
 
 	init_ssize = (max_ssize < sgrowsiz) ? max_ssize : sgrowsiz;
 
+	PROC_LOCK(curthread->td_proc);
+	vmemlim = lim_cur(curthread->td_proc, RLIMIT_VMEM);
+	PROC_UNLOCK(curthread->td_proc);
+
 	vm_map_lock(map);
 
 	/* If addr is already mapped, no go */
@@ -2492,8 +2497,7 @@ vm_map_stack(vm_map_t map, vm_offset_t addrbos, vm_size_t max_ssize,
 	}
 
 	/* If we would blow our VMEM resource limit, no go */
-	if (map->size + init_ssize >
-	    curthread->td_proc->p_rlimit[RLIMIT_VMEM].rlim_cur) {
+	if (map->size + init_ssize > vmemlim) {
 		vm_map_unlock(map);
 		return (KERN_NO_SPACE);
 	}
@@ -2566,11 +2570,17 @@ vm_map_growstack(struct proc *p, vm_offset_t addr)
 	vm_map_t map = &vm->vm_map;
 	vm_offset_t end;
 	size_t grow_amount, max_grow;
+	rlim_t stacklim, vmemlim;
 	int is_procstack, rv;
 
 	GIANT_REQUIRED;
 
 Retry:
+	PROC_LOCK(p);
+	stacklim = lim_cur(p, RLIMIT_STACK);
+	vmemlim = lim_cur(curthread->td_proc, RLIMIT_VMEM);
+	PROC_UNLOCK(p);
+
 	vm_map_lock_read(map);
 
 	/* If addr is already in the entry range, no need to grow.*/
@@ -2658,8 +2668,7 @@ Retry:
 	 * If this is the main process stack, see if we're over the stack
 	 * limit.
 	 */
-	if (is_procstack && (ctob(vm->vm_ssize) + grow_amount >
-			     p->p_rlimit[RLIMIT_STACK].rlim_cur)) {
+	if (is_procstack && (ctob(vm->vm_ssize) + grow_amount > stacklim)) {
 		vm_map_unlock_read(map);
 		return (KERN_NO_SPACE);
 	}
@@ -2668,14 +2677,12 @@ Retry:
 	grow_amount = roundup (grow_amount, sgrowsiz);
 	if (grow_amount > stack_entry->avail_ssize)
 		grow_amount = stack_entry->avail_ssize;
-	if (is_procstack && (ctob(vm->vm_ssize) + grow_amount >
-			     p->p_rlimit[RLIMIT_STACK].rlim_cur)) {
-		grow_amount = p->p_rlimit[RLIMIT_STACK].rlim_cur -
-			      ctob(vm->vm_ssize);
+	if (is_procstack && (ctob(vm->vm_ssize) + grow_amount > stacklim)) {
+		grow_amount = stacklim - ctob(vm->vm_ssize);
 	}
 
 	/* If we would blow our VMEM resource limit, no go */
-	if (map->size + grow_amount > p->p_rlimit[RLIMIT_VMEM].rlim_cur) {
+	if (map->size + grow_amount > vmemlim) {
 		vm_map_unlock_read(map);
 		return (KERN_NO_SPACE);
 	}