Module Name: src
Committed By: rmind
Date: Sat May 14 17:12:28 UTC 2011
Modified Files:
src/sys/kern: kern_resource.c
Log Message:
Improve/fix comments, give more meaningful names for variables.
To generate a diff of this commit:
cvs rdiff -u -r1.162 -r1.163 src/sys/kern/kern_resource.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/kern/kern_resource.c
diff -u src/sys/kern/kern_resource.c:1.162 src/sys/kern/kern_resource.c:1.163
--- src/sys/kern/kern_resource.c:1.162 Sun May 1 02:46:19 2011
+++ src/sys/kern/kern_resource.c Sat May 14 17:12:28 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: kern_resource.c,v 1.162 2011/05/01 02:46:19 christos Exp $ */
+/* $NetBSD: kern_resource.c,v 1.163 2011/05/14 17:12:28 rmind Exp $ */
/*-
* Copyright (c) 1982, 1986, 1991, 1993
@@ -37,14 +37,13 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_resource.c,v 1.162 2011/05/01 02:46:19 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_resource.c,v 1.163 2011/05/14 17:12:28 rmind Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/resourcevar.h>
-#include <sys/malloc.h>
#include <sys/kmem.h>
#include <sys/namei.h>
#include <sys/pool.h>
@@ -763,10 +762,6 @@
}
/*
- * sysctl interface in five parts
- */
-
-/*
* sysctl_proc_findproc: a routine for sysctl proc subtree helpers that
* need to pick a valid process by PID.
*
@@ -855,7 +850,7 @@
node.sysctl_data = cnbuf;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
- /* Return if error, or if we are only retrieving the core name. */
+ /* Return if error, or if caller is only getting the core name. */
if (error || newp == NULL) {
goto done;
}
@@ -886,129 +881,137 @@
}
/*
- * sysctl helper routine for checking/setting a process's stop flags,
- * one for fork and one for exec.
+ * sysctl_proc_stop: helper routine for checking/setting the stop flags.
*/
static int
sysctl_proc_stop(SYSCTLFN_ARGS)
{
- struct proc *ptmp;
- int i, f, error = 0;
+ struct proc *p;
+ int isset, flag, error = 0;
struct sysctlnode node;
if (namelen != 0)
- return (EINVAL);
+ return EINVAL;
/* Find the process. Hold a reference (p_reflock), if found. */
- error = sysctl_proc_findproc(l, (pid_t)name[-2], &ptmp);
+ error = sysctl_proc_findproc(l, (pid_t)name[-2], &p);
if (error)
return error;
/* XXX-elad */
- error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, ptmp,
+ error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, p,
KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
- if (error)
+ if (error) {
goto out;
+ }
+ /* Determine the flag. */
switch (rnode->sysctl_num) {
case PROC_PID_STOPFORK:
- f = PS_STOPFORK;
+ flag = PS_STOPFORK;
break;
case PROC_PID_STOPEXEC:
- f = PS_STOPEXEC;
+ flag = PS_STOPEXEC;
break;
case PROC_PID_STOPEXIT:
- f = PS_STOPEXIT;
+ flag = PS_STOPEXIT;
break;
default:
error = EINVAL;
goto out;
}
-
- i = (ptmp->p_flag & f) ? 1 : 0;
+ isset = (p->p_flag & flag) ? 1 : 0;
node = *rnode;
- node.sysctl_data = &i;
+ node.sysctl_data = &isset;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
- if (error || newp == NULL)
+
+ /* Return if error, or if callers is only getting the flag. */
+ if (error || newp == NULL) {
goto out;
+ }
- mutex_enter(ptmp->p_lock);
+ /* Check if caller can set the flags. */
error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_STOPFLAG,
- ptmp, KAUTH_ARG(f), NULL, NULL);
- if (!error) {
- if (i) {
- ptmp->p_sflag |= f;
- } else {
- ptmp->p_sflag &= ~f;
- }
+ p, KAUTH_ARG(flag), NULL, NULL);
+ if (error) {
+ goto out;
+ }
+ mutex_enter(p->p_lock);
+ if (isset) {
+ p->p_sflag |= flag;
+ } else {
+ p->p_sflag &= ~flag;
}
- mutex_exit(ptmp->p_lock);
+ mutex_exit(p->p_lock);
out:
- rw_exit(&ptmp->p_reflock);
+ rw_exit(&p->p_reflock);
return error;
}
/*
- * sysctl helper routine for a process's rlimits as exposed by sysctl.
+ * sysctl_proc_plimit: helper routine to get/set rlimits of a process.
*/
static int
sysctl_proc_plimit(SYSCTLFN_ARGS)
{
- struct proc *ptmp;
+ struct proc *p;
u_int limitno;
int which, error = 0;
struct rlimit alim;
struct sysctlnode node;
if (namelen != 0)
- return (EINVAL);
+ return EINVAL;
which = name[-1];
if (which != PROC_PID_LIMIT_TYPE_SOFT &&
which != PROC_PID_LIMIT_TYPE_HARD)
- return (EINVAL);
+ return EINVAL;
limitno = name[-2] - 1;
if (limitno >= RLIM_NLIMITS)
- return (EINVAL);
+ return EINVAL;
if (name[-3] != PROC_PID_LIMIT)
- return (EINVAL);
+ return EINVAL;
/* Find the process. Hold a reference (p_reflock), if found. */
- error = sysctl_proc_findproc(l, (pid_t)name[-4], &ptmp);
+ error = sysctl_proc_findproc(l, (pid_t)name[-4], &p);
if (error)
return error;
/* XXX-elad */
- error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, ptmp,
+ error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, p,
KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
if (error)
goto out;
- /* Check if we can view limits. */
+ /* Check if caller can retrieve the limits. */
if (newp == NULL) {
error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_RLIMIT,
- ptmp, KAUTH_ARG(KAUTH_REQ_PROCESS_RLIMIT_GET), &alim,
+ p, KAUTH_ARG(KAUTH_REQ_PROCESS_RLIMIT_GET), &alim,
KAUTH_ARG(which));
if (error)
goto out;
}
+ /* Retrieve the limits. */
node = *rnode;
- memcpy(&alim, &ptmp->p_rlimit[limitno], sizeof(alim));
- if (which == PROC_PID_LIMIT_TYPE_HARD)
+ memcpy(&alim, &p->p_rlimit[limitno], sizeof(alim));
+ if (which == PROC_PID_LIMIT_TYPE_HARD) {
node.sysctl_data = &alim.rlim_max;
- else
+ } else {
node.sysctl_data = &alim.rlim_cur;
-
+ }
error = sysctl_lookup(SYSCTLFN_CALL(&node));
+
+ /* Return if error, or if we are only retrieving the limits. */
if (error || newp == NULL) {
goto out;
}
- error = dosetrlimit(l, ptmp, limitno, &alim);
+ error = dosetrlimit(l, p, limitno, &alim);
out:
- rw_exit(&ptmp->p_reflock);
+ rw_exit(&p->p_reflock);
return error;
}
