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, 26 insertions, 26 deletions

diff --git a/sys/compat/svr4/svr4_resource.c b/sys/compat/svr4/svr4_resource.c
index f04d591..6aed48d 100644
--- a/sys/compat/svr4/svr4_resource.c
+++ b/sys/compat/svr4/svr4_resource.c
@@ -136,9 +136,9 @@ svr4_sys_getrlimit(td, uap)
 	if (rl == -1)
 		return EINVAL;
 
-	/* For p_rlimit. */
-	mtx_assert(&Giant, MA_OWNED);
-	blim = td->td_proc->p_rlimit[rl];
+	PROC_LOCK(td->td_proc);
+	lim_rlimit(td->td_proc, rl, &blim);
+	PROC_UNLOCK(td->td_proc);
 
 	/*
 	 * Our infinity, is their maxfiles.
@@ -177,20 +177,20 @@ svr4_sys_setrlimit(td, uap)
 	struct svr4_sys_setrlimit_args *uap;
 {
 	int rl = svr4_to_native_rl(uap->which);
-	struct rlimit blim, *limp;
+	struct rlimit blim, curlim;
 	struct svr4_rlimit slim;
 	int error;
 
 	if (rl == -1)
 		return EINVAL;
 
-	/* For p_rlimit. */
-	mtx_assert(&Giant, MA_OWNED);
-	limp = &td->td_proc->p_rlimit[rl];
-
 	if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
 		return error;
 
+	PROC_LOCK(td->td_proc);
+	lim_rlimit(td->td_proc, rl, &curlim);
+	PROC_UNLOCK(td->td_proc);
+
 	/*
 	 * if the limit is SVR4_RLIM_INFINITY, then we set it to our
 	 * unlimited.
@@ -205,20 +205,20 @@ svr4_sys_setrlimit(td, uap)
 	else if (OKLIMIT(slim.rlim_max))
 		blim.rlim_max = (rlim_t) slim.rlim_max;
 	else if (slim.rlim_max == SVR4_RLIM_SAVED_MAX)
-		blim.rlim_max = limp->rlim_max;
+		blim.rlim_max = curlim.rlim_max;
 	else if (slim.rlim_max == SVR4_RLIM_SAVED_CUR)
-		blim.rlim_max = limp->rlim_cur;
+		blim.rlim_max = curlim.rlim_cur;
 
 	if (slim.rlim_cur == SVR4_RLIM_INFINITY)
 		blim.rlim_cur = RLIM_INFINITY;
 	else if (OKLIMIT(slim.rlim_cur))
 		blim.rlim_cur = (rlim_t) slim.rlim_cur;
 	else if (slim.rlim_cur == SVR4_RLIM_SAVED_MAX)
-		blim.rlim_cur = limp->rlim_max;
+		blim.rlim_cur = curlim.rlim_max;
 	else if (slim.rlim_cur == SVR4_RLIM_SAVED_CUR)
-		blim.rlim_cur = limp->rlim_cur;
+		blim.rlim_cur = curlim.rlim_cur;
 
-	return dosetrlimit(td, rl, &blim);
+	return (kern_setrlimit(td, rl, &blim));
 }
 
 
@@ -234,9 +234,9 @@ svr4_sys_getrlimit64(td, uap)
 	if (rl == -1)
 		return EINVAL;
 
-	/* For p_rlimit. */
-	mtx_assert(&Giant, MA_OWNED);
-	blim = td->td_proc->p_rlimit[rl];
+	PROC_LOCK(td->td_proc);
+	lim_rlimit(td->td_proc, rl, &blim);
+	PROC_UNLOCK(td->td_proc);
 
 	/*
 	 * Our infinity, is their maxfiles.
@@ -275,20 +275,20 @@ svr4_sys_setrlimit64(td, uap)
 	struct svr4_sys_setrlimit64_args *uap;
 {
 	int rl = svr4_to_native_rl(uap->which);
-	struct rlimit blim, *limp;
+	struct rlimit blim, curlim;
 	struct svr4_rlimit64 slim;
 	int error;
 
 	if (rl == -1)
 		return EINVAL;
 
-	/* For p_rlimit. */
-	mtx_assert(&Giant, MA_OWNED);
-	limp = &td->td_proc->p_rlimit[rl];
-
 	if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
 		return error;
 
+	PROC_LOCK(td->td_proc);
+	lim_rlimit(td->td_proc, rl, &curlim);
+	PROC_UNLOCK(td->td_proc);
+
 	/*
 	 * if the limit is SVR4_RLIM64_INFINITY, then we set it to our
 	 * unlimited.
@@ -303,18 +303,18 @@ svr4_sys_setrlimit64(td, uap)
 	else if (OKLIMIT64(slim.rlim_max))
 		blim.rlim_max = (rlim_t) slim.rlim_max;
 	else if (slim.rlim_max == SVR4_RLIM64_SAVED_MAX)
-		blim.rlim_max = limp->rlim_max;
+		blim.rlim_max = curlim.rlim_max;
 	else if (slim.rlim_max == SVR4_RLIM64_SAVED_CUR)
-		blim.rlim_max = limp->rlim_cur;
+		blim.rlim_max = curlim.rlim_cur;
 
 	if (slim.rlim_cur == SVR4_RLIM64_INFINITY)
 		blim.rlim_cur = RLIM_INFINITY;
 	else if (OKLIMIT64(slim.rlim_cur))
 		blim.rlim_cur = (rlim_t) slim.rlim_cur;
 	else if (slim.rlim_cur == SVR4_RLIM64_SAVED_MAX)
-		blim.rlim_cur = limp->rlim_max;
+		blim.rlim_cur = curlim.rlim_max;
 	else if (slim.rlim_cur == SVR4_RLIM64_SAVED_CUR)
-		blim.rlim_cur = limp->rlim_cur;
+		blim.rlim_cur = curlim.rlim_cur;
 
-	return dosetrlimit(td, rl, &blim);
+	return (kern_setrlimit(td, rl, &blim));
 }