910 lines
23 KiB
C
910 lines
23 KiB
C
/*
|
|
* sysctl system call.
|
|
*
|
|
* Copyright (c) 1982, 1986, 1989, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Mike Karels at Berkeley Software Design, Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
#include <sys/param.h>
|
|
#include <sys/user.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/file.h>
|
|
#include <sys/inode.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/tty.h>
|
|
#include <sys/vm.h>
|
|
#include <sys/map.h>
|
|
#include <sys/sysctl.h>
|
|
#include <machine/cpu.h>
|
|
#include <sys/conf.h>
|
|
|
|
sysctlfn kern_sysctl;
|
|
sysctlfn hw_sysctl;
|
|
#ifdef DEBUG
|
|
sysctlfn debug_sysctl;
|
|
#endif
|
|
sysctlfn vm_sysctl;
|
|
sysctlfn fs_sysctl;
|
|
#ifdef INET
|
|
sysctlfn net_sysctl;
|
|
#endif
|
|
sysctlfn cpu_sysctl;
|
|
|
|
struct sysctl_args {
|
|
int *name;
|
|
u_int namelen;
|
|
void *old;
|
|
size_t *oldlenp;
|
|
void *new;
|
|
size_t newlen;
|
|
};
|
|
|
|
static int sysctl_clockrate (char *where, size_t *sizep);
|
|
static int sysctl_inode (char *where, size_t *sizep);
|
|
static int sysctl_file (char *where, size_t *sizep);
|
|
static int sysctl_doproc (int *name, u_int namelen, char *where, size_t *sizep);
|
|
|
|
void
|
|
__sysctl()
|
|
{
|
|
register struct sysctl_args *uap = (struct sysctl_args*) u.u_arg;
|
|
int error;
|
|
u_int oldlen = 0;
|
|
sysctlfn *fn;
|
|
int name [CTL_MAXNAME];
|
|
|
|
if (uap->new != NULL && ! suser())
|
|
return;
|
|
/*
|
|
* all top-level sysctl names are non-terminal
|
|
*/
|
|
if (uap->namelen > CTL_MAXNAME || uap->namelen < 2) {
|
|
u.u_error = EINVAL;
|
|
return;
|
|
}
|
|
error = copyin ((caddr_t) uap->name, (caddr_t) &name, uap->namelen * sizeof(int));
|
|
if (error) {
|
|
u.u_error = error;
|
|
return;
|
|
}
|
|
|
|
switch (name[0]) {
|
|
case CTL_KERN:
|
|
fn = kern_sysctl;
|
|
break;
|
|
case CTL_HW:
|
|
fn = hw_sysctl;
|
|
break;
|
|
case CTL_VM:
|
|
fn = vm_sysctl;
|
|
break;
|
|
#ifdef INET
|
|
case CTL_NET:
|
|
fn = net_sysctl;
|
|
break;
|
|
#endif
|
|
#ifdef notyet
|
|
case CTL_FS:
|
|
fn = fs_sysctl;
|
|
break;
|
|
#endif
|
|
case CTL_MACHDEP:
|
|
fn = cpu_sysctl;
|
|
break;
|
|
#ifdef DEBUG
|
|
case CTL_DEBUG:
|
|
fn = debug_sysctl;
|
|
break;
|
|
#endif
|
|
default:
|
|
u.u_error = EOPNOTSUPP;
|
|
return;
|
|
}
|
|
|
|
if (uap->oldlenp && (error = copyin ((caddr_t) uap->oldlenp,
|
|
(caddr_t) &oldlen, sizeof(oldlen)))) {
|
|
u.u_error = error;
|
|
return;
|
|
}
|
|
if (uap->old != NULL) {
|
|
while (memlock.sl_lock) {
|
|
memlock.sl_want = 1;
|
|
sleep((caddr_t)&memlock, PRIBIO+1);
|
|
memlock.sl_locked++;
|
|
}
|
|
memlock.sl_lock = 1;
|
|
}
|
|
error = (*fn) (name + 1, uap->namelen - 1, uap->old, &oldlen,
|
|
uap->new, uap->newlen);
|
|
if (uap->old != NULL) {
|
|
memlock.sl_lock = 0;
|
|
if (memlock.sl_want) {
|
|
memlock.sl_want = 0;
|
|
wakeup((caddr_t)&memlock);
|
|
}
|
|
}
|
|
if (error) {
|
|
u.u_error = error;
|
|
return;
|
|
}
|
|
if (uap->oldlenp) {
|
|
error = copyout ((caddr_t) &oldlen, (caddr_t) uap->oldlenp, sizeof(oldlen));
|
|
if (error) {
|
|
u.u_error = error;
|
|
return;
|
|
}
|
|
}
|
|
u.u_rval = oldlen;
|
|
}
|
|
|
|
/*
|
|
* kernel related system variables.
|
|
*/
|
|
int
|
|
kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
|
|
int *name;
|
|
u_int namelen;
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
{
|
|
int error, level;
|
|
u_long longhostid;
|
|
char bsd[10];
|
|
|
|
/* all sysctl names at this level are terminal */
|
|
if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF))
|
|
return (ENOTDIR); /* overloaded */
|
|
|
|
switch (name[0]) {
|
|
case KERN_OSTYPE:
|
|
case KERN_OSRELEASE:
|
|
/* code is cheaper than D space */
|
|
bsd[0]='2';bsd[1]='.';bsd[2]='1';bsd[3]='1';bsd[4]='B';
|
|
bsd[5]='S';bsd[6]='D';bsd[7]='\0';
|
|
return (sysctl_rdstring(oldp, oldlenp, newp, bsd));
|
|
case KERN_OSREV:
|
|
return (sysctl_rdlong(oldp, oldlenp, newp, (long)BSD));
|
|
case KERN_VERSION:
|
|
return (sysctl_rdstring(oldp, oldlenp, newp, version));
|
|
case KERN_MAXINODES:
|
|
return(sysctl_rdint(oldp, oldlenp, newp, NINODE));
|
|
case KERN_MAXPROC:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, NPROC));
|
|
case KERN_MAXFILES:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, NFILE));
|
|
case KERN_ARGMAX:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, NCARGS));
|
|
case KERN_SECURELVL:
|
|
level = securelevel;
|
|
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||
|
|
newp == NULL)
|
|
return (error);
|
|
if (level < securelevel && u.u_procp->p_pid != 1)
|
|
return (EPERM);
|
|
securelevel = level;
|
|
return (0);
|
|
case KERN_HOSTNAME:
|
|
error = sysctl_string(oldp, oldlenp, newp, newlen,
|
|
hostname, sizeof(hostname));
|
|
if (newp && !error)
|
|
hostnamelen = newlen;
|
|
return (error);
|
|
case KERN_HOSTID:
|
|
longhostid = hostid;
|
|
error = sysctl_long(oldp, oldlenp, newp, newlen, (long*) &longhostid);
|
|
hostid = longhostid;
|
|
return (error);
|
|
case KERN_CLOCKRATE:
|
|
return (sysctl_clockrate(oldp, oldlenp));
|
|
case KERN_BOOTTIME:
|
|
return (sysctl_rdstruct(oldp, oldlenp, newp, &boottime,
|
|
sizeof(struct timeval)));
|
|
case KERN_INODE:
|
|
return (sysctl_inode(oldp, oldlenp));
|
|
case KERN_PROC:
|
|
return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp));
|
|
case KERN_FILE:
|
|
return (sysctl_file(oldp, oldlenp));
|
|
#ifdef GPROF
|
|
case KERN_PROF:
|
|
return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp,
|
|
newp, newlen));
|
|
#endif
|
|
case KERN_NGROUPS:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, NGROUPS));
|
|
case KERN_JOB_CONTROL:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, 1));
|
|
case KERN_POSIX1:
|
|
case KERN_SAVED_IDS:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, 0));
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
/*
|
|
* hardware related system variables.
|
|
*/
|
|
int
|
|
hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
|
|
int *name;
|
|
u_int namelen;
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
{
|
|
/* all sysctl names at this level are terminal */
|
|
if (namelen != 1)
|
|
return (ENOTDIR); /* overloaded */
|
|
|
|
switch (name[0]) {
|
|
case HW_MACHINE:
|
|
return (sysctl_rdstring(oldp, oldlenp, newp, "pic32"));
|
|
case HW_MODEL:
|
|
return (sysctl_rdstring(oldp, oldlenp, newp, "mips"));
|
|
case HW_NCPU:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, 1)); /* XXX */
|
|
case HW_BYTEORDER:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, ENDIAN));
|
|
case HW_PHYSMEM:
|
|
return (sysctl_rdlong(oldp, oldlenp, newp, physmem));
|
|
#ifdef UCB_METER
|
|
case HW_USERMEM:
|
|
return (sysctl_rdlong(oldp, oldlenp, newp, freemem));
|
|
#endif
|
|
case HW_PAGESIZE:
|
|
return (sysctl_rdint(oldp, oldlenp, newp, DEV_BSIZE));
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
* Debugging related system variables.
|
|
*/
|
|
struct ctldebug debug0, debug1, debug2, debug3, debug4;
|
|
struct ctldebug debug5, debug6, debug7, debug8, debug9;
|
|
struct ctldebug debug10, debug11, debug12, debug13, debug14;
|
|
struct ctldebug debug15, debug16, debug17, debug18, debug19;
|
|
static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = {
|
|
&debug0, &debug1, &debug2, &debug3, &debug4,
|
|
&debug5, &debug6, &debug7, &debug8, &debug9,
|
|
&debug10, &debug11, &debug12, &debug13, &debug14,
|
|
&debug15, &debug16, &debug17, &debug18, &debug19,
|
|
};
|
|
|
|
int
|
|
debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
|
|
int *name;
|
|
u_int namelen;
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
{
|
|
struct ctldebug *cdp;
|
|
|
|
/* all sysctl names at this level are name and field */
|
|
if (namelen != 2)
|
|
return (ENOTDIR); /* overloaded */
|
|
cdp = debugvars[name[0]];
|
|
if (cdp->debugname == 0)
|
|
return (EOPNOTSUPP);
|
|
switch (name[1]) {
|
|
case CTL_DEBUG_NAME:
|
|
return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
|
|
case CTL_DEBUG_VALUE:
|
|
return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
/*
|
|
* Bit of a hack. 2.11 currently uses 'short avenrun[3]' and a fixed scale
|
|
* of 256. In order not to break all the applications which nlist() for
|
|
* 'avenrun' we build a local 'averunnable' structure here to return to the
|
|
* user. Eventually (after all applications which look up the load average
|
|
* the old way) have been converted we can change things.
|
|
*
|
|
* We do not call vmtotal(), that could get rather expensive, rather we rely
|
|
* on the 5 second update.
|
|
*
|
|
* The swapmap case is 2.11BSD extension.
|
|
*/
|
|
int
|
|
vm_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
|
|
int *name;
|
|
u_int namelen;
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
{
|
|
struct loadavg averunnable; /* loadavg in resource.h */
|
|
|
|
/* all sysctl names at this level are terminal */
|
|
if (namelen != 1)
|
|
return (ENOTDIR); /* overloaded */
|
|
|
|
switch (name[0]) {
|
|
case VM_LOADAVG:
|
|
averunnable.fscale = 256;
|
|
averunnable.ldavg[0] = avenrun[0];
|
|
averunnable.ldavg[1] = avenrun[1];
|
|
averunnable.ldavg[2] = avenrun[2];
|
|
return (sysctl_rdstruct(oldp, oldlenp, newp, &averunnable,
|
|
sizeof(averunnable)));
|
|
case VM_METER:
|
|
#ifdef notsure
|
|
vmtotal(); /* could be expensive to do this every time */
|
|
#endif
|
|
return (sysctl_rdstruct(oldp, oldlenp, newp, &total,
|
|
sizeof(total)));
|
|
case VM_SWAPMAP:
|
|
if (oldp == NULL) {
|
|
*oldlenp = (char *)swapmap[0].m_limit -
|
|
(char *)swapmap[0].m_map;
|
|
return(0);
|
|
}
|
|
return (sysctl_rdstruct(oldp, oldlenp, newp, swapmap,
|
|
(int)swapmap[0].m_limit - (int)swapmap[0].m_map));
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
/*
|
|
* Validate parameters and get old / set new parameters
|
|
* for an integer-valued sysctl function.
|
|
*/
|
|
int
|
|
sysctl_int(oldp, oldlenp, newp, newlen, valp)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
int *valp;
|
|
{
|
|
int error = 0;
|
|
|
|
if (oldp && *oldlenp < sizeof(int))
|
|
return (ENOMEM);
|
|
if (newp && newlen != sizeof(int))
|
|
return (EINVAL);
|
|
*oldlenp = sizeof(int);
|
|
if (oldp)
|
|
error = copyout ((caddr_t) valp, (caddr_t) oldp, sizeof(int));
|
|
if (error == 0 && newp)
|
|
error = copyin ((caddr_t) newp, (caddr_t) valp, sizeof(int));
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* As above, but read-only.
|
|
*/
|
|
int
|
|
sysctl_rdint(oldp, oldlenp, newp, val)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
int val;
|
|
{
|
|
int error = 0;
|
|
|
|
if (oldp && *oldlenp < sizeof(int))
|
|
return (ENOMEM);
|
|
if (newp)
|
|
return (EPERM);
|
|
*oldlenp = sizeof(int);
|
|
if (oldp)
|
|
error = copyout((caddr_t)&val, oldp, sizeof(int));
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Validate parameters and get old / set new parameters
|
|
* for an long-valued sysctl function.
|
|
*/
|
|
int
|
|
sysctl_long(oldp, oldlenp, newp, newlen, valp)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
long *valp;
|
|
{
|
|
int error = 0;
|
|
|
|
if (oldp && *oldlenp < sizeof(long))
|
|
return (ENOMEM);
|
|
if (newp && newlen != sizeof(long))
|
|
return (EINVAL);
|
|
*oldlenp = sizeof(long);
|
|
if (oldp)
|
|
error = copyout ((caddr_t) valp, (caddr_t) oldp, sizeof(long));
|
|
if (error == 0 && newp)
|
|
error = copyin ((caddr_t) newp, (caddr_t) valp, sizeof(long));
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* As above, but read-only.
|
|
*/
|
|
int
|
|
sysctl_rdlong(oldp, oldlenp, newp, val)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
long val;
|
|
{
|
|
int error = 0;
|
|
|
|
if (oldp && *oldlenp < sizeof(long))
|
|
return (ENOMEM);
|
|
if (newp)
|
|
return (EPERM);
|
|
*oldlenp = sizeof(long);
|
|
if (oldp)
|
|
error = copyout((caddr_t)&val, oldp, sizeof(long));
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Validate parameters and get old / set new parameters
|
|
* for a string-valued sysctl function.
|
|
*/
|
|
int
|
|
sysctl_string(oldp, oldlenp, newp, newlen, str, maxlen)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
char *str;
|
|
int maxlen;
|
|
{
|
|
int len, error = 0;
|
|
|
|
len = strlen(str) + 1;
|
|
if (oldp && *oldlenp < len)
|
|
return (ENOMEM);
|
|
if (newp && newlen >= maxlen)
|
|
return (EINVAL);
|
|
if (oldp) {
|
|
*oldlenp = len;
|
|
error = copyout (str, oldp, len);
|
|
}
|
|
if (error == 0 && newp) {
|
|
error = copyin (newp, str, newlen);
|
|
str[newlen] = 0;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* As above, but read-only.
|
|
*/
|
|
int
|
|
sysctl_rdstring(oldp, oldlenp, newp, str)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
const char *str;
|
|
{
|
|
int len, error = 0;
|
|
|
|
len = strlen(str) + 1;
|
|
if (oldp && *oldlenp < len)
|
|
return (ENOMEM);
|
|
if (newp)
|
|
return (EPERM);
|
|
*oldlenp = len;
|
|
if (oldp)
|
|
error = copyout ((caddr_t) str, oldp, len);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Validate parameters and get old / set new parameters
|
|
* for a structure oriented sysctl function.
|
|
*/
|
|
int
|
|
sysctl_struct(oldp, oldlenp, newp, newlen, sp, len)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp;
|
|
size_t newlen;
|
|
void *sp;
|
|
int len;
|
|
{
|
|
int error = 0;
|
|
|
|
if (oldp && *oldlenp < len)
|
|
return (ENOMEM);
|
|
if (newp && newlen > len)
|
|
return (EINVAL);
|
|
if (oldp) {
|
|
*oldlenp = len;
|
|
error = copyout(sp, oldp, len);
|
|
}
|
|
if (error == 0 && newp)
|
|
error = copyin(newp, sp, len);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Validate parameters and get old parameters
|
|
* for a structure oriented sysctl function.
|
|
*/
|
|
int
|
|
sysctl_rdstruct(oldp, oldlenp, newp, sp, len)
|
|
void *oldp;
|
|
size_t *oldlenp;
|
|
void *newp, *sp;
|
|
int len;
|
|
{
|
|
int error = 0;
|
|
|
|
if (oldp && *oldlenp < len)
|
|
return (ENOMEM);
|
|
if (newp)
|
|
return (EPERM);
|
|
*oldlenp = len;
|
|
if (oldp)
|
|
error = copyout(sp, oldp, len);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Get file structures.
|
|
*/
|
|
int
|
|
sysctl_file(where, sizep)
|
|
char *where;
|
|
size_t *sizep;
|
|
{
|
|
int buflen, error;
|
|
register struct file *fp;
|
|
struct file *fpp;
|
|
char *start = where;
|
|
register int i;
|
|
|
|
buflen = *sizep;
|
|
if (where == NULL) {
|
|
for (i = 0, fp = file; fp < file+NFILE; fp++)
|
|
if (fp->f_count) i++;
|
|
|
|
#define FPTRSZ sizeof (struct file *)
|
|
#define FILESZ sizeof (struct file)
|
|
/*
|
|
* overestimate by 5 files
|
|
*/
|
|
*sizep = (i + 5) * (FILESZ + FPTRSZ);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* array of extended file structures: first the address then the
|
|
* file structure.
|
|
*/
|
|
for (fp = file; fp < file+NFILE; fp++) {
|
|
if (fp->f_count == 0)
|
|
continue;
|
|
if (buflen < (FPTRSZ + FILESZ)) {
|
|
*sizep = where - start;
|
|
return (ENOMEM);
|
|
}
|
|
fpp = fp;
|
|
if ((error = copyout ((caddr_t) &fpp, (caddr_t) where, FPTRSZ)) ||
|
|
(error = copyout ((caddr_t) fp, (caddr_t) (where + FPTRSZ), FILESZ)))
|
|
return (error);
|
|
buflen -= (FPTRSZ + FILESZ);
|
|
where += (FPTRSZ + FILESZ);
|
|
}
|
|
*sizep = where - start;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* This one is in kern_clock.c in 4.4 but placed here for the reasons
|
|
* given earlier (back around line 367).
|
|
*/
|
|
int
|
|
sysctl_clockrate (where, sizep)
|
|
char *where;
|
|
size_t *sizep;
|
|
{
|
|
struct clockinfo clkinfo;
|
|
|
|
/*
|
|
* Construct clockinfo structure.
|
|
*/
|
|
clkinfo.hz = hz;
|
|
clkinfo.tick = usechz;
|
|
clkinfo.profhz = 0;
|
|
clkinfo.stathz = hz;
|
|
return(sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof (clkinfo)));
|
|
}
|
|
|
|
/*
|
|
* Dump inode list (via sysctl).
|
|
* Copyout address of inode followed by inode.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
sysctl_inode (where, sizep)
|
|
char *where;
|
|
size_t *sizep;
|
|
{
|
|
register struct inode *ip;
|
|
register char *bp = where;
|
|
struct inode *ipp;
|
|
char *ewhere;
|
|
int error, numi;
|
|
|
|
for (numi = 0, ip = inode; ip < inode+NINODE; ip++)
|
|
if (ip->i_count) numi++;
|
|
|
|
#define IPTRSZ sizeof (struct inode *)
|
|
#define INODESZ sizeof (struct inode)
|
|
if (where == NULL) {
|
|
*sizep = (numi + 5) * (IPTRSZ + INODESZ);
|
|
return (0);
|
|
}
|
|
ewhere = where + *sizep;
|
|
|
|
for (ip = inode; ip < inode+NINODE; ip++) {
|
|
if (ip->i_count == 0)
|
|
continue;
|
|
if (bp + IPTRSZ + INODESZ > ewhere) {
|
|
*sizep = bp - where;
|
|
return (ENOMEM);
|
|
}
|
|
ipp = ip;
|
|
if ((error = copyout ((caddr_t)&ipp, bp, IPTRSZ)) ||
|
|
(error = copyout ((caddr_t)ip, bp + IPTRSZ, INODESZ)))
|
|
return (error);
|
|
bp += IPTRSZ + INODESZ;
|
|
}
|
|
|
|
*sizep = bp - where;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Three pieces of information we need about a process are not kept in
|
|
* the proc table: real uid, controlling terminal device, and controlling
|
|
* terminal tty struct pointer. For these we must look in either the u
|
|
* area or the swap area. If the process is still in memory this is
|
|
* easy but if the process has been swapped out we have to read in the
|
|
* u area.
|
|
*
|
|
* XXX - We rely on the fact that u_ttyp, u_ttyd, and u_ruid are all within
|
|
* XXX - the first 1kb of the u area. If this ever changes the logic below
|
|
* XXX - will break (and badly). At the present time (97/9/2) the u area
|
|
* XXX - is 856 bytes long.
|
|
*/
|
|
void
|
|
fill_from_u (p, rup, ttp, tdp)
|
|
struct proc *p;
|
|
uid_t *rup;
|
|
struct tty **ttp;
|
|
dev_t *tdp;
|
|
{
|
|
register struct buf *bp;
|
|
dev_t ttyd;
|
|
uid_t ruid;
|
|
struct tty *ttyp;
|
|
struct user *up;
|
|
|
|
if (p->p_stat == SZOMB) {
|
|
ruid = (uid_t)-2;
|
|
ttyp = NULL;
|
|
ttyd = NODEV;
|
|
goto out;
|
|
}
|
|
if (p->p_flag & SLOAD) {
|
|
ttyd = ((struct user *)p->p_addr)->u_ttyd;
|
|
ttyp = ((struct user *)p->p_addr)->u_ttyp;
|
|
ruid = ((struct user *)p->p_addr)->u_ruid;
|
|
} else {
|
|
bp = geteblk();
|
|
bp->b_dev = swapdev;
|
|
bp->b_blkno = (daddr_t)p->p_addr;
|
|
bp->b_bcount = DEV_BSIZE; /* XXX */
|
|
bp->b_flags = B_READ;
|
|
|
|
(*bdevsw[major(swapdev)].d_strategy)(bp);
|
|
biowait(bp);
|
|
|
|
if (u.u_error) {
|
|
ttyd = NODEV;
|
|
ttyp = NULL;
|
|
ruid = (uid_t)-2;
|
|
} else {
|
|
up = (struct user*) bp->b_addr;
|
|
ruid = up->u_ruid; /* u_ruid = offset 164 */
|
|
ttyd = up->u_ttyd; /* u_ttyd = offset 654 */
|
|
ttyp = up->u_ttyp; /* u_ttyp = offset 652 */
|
|
}
|
|
bp->b_flags |= B_AGE;
|
|
brelse(bp);
|
|
u.u_error = 0; /* XXX */
|
|
}
|
|
out:
|
|
if (rup)
|
|
*rup = ruid;
|
|
if (ttp)
|
|
*ttp = ttyp;
|
|
if (tdp)
|
|
*tdp = ttyd;
|
|
}
|
|
|
|
/*
|
|
* Fill in an eproc structure for the specified process. Slightly
|
|
* inefficient because we have to access the u area again for the
|
|
* information not kept in the proc structure itself. Can't afford
|
|
* to expand the proc struct so we take a slight speed hit here.
|
|
*/
|
|
static void
|
|
fill_eproc(p, ep)
|
|
register struct proc *p;
|
|
register struct eproc *ep;
|
|
{
|
|
struct tty *ttyp;
|
|
|
|
ep->e_paddr = p;
|
|
fill_from_u(p, &ep->e_ruid, &ttyp, &ep->e_tdev);
|
|
if (ttyp)
|
|
ep->e_tpgid = ttyp->t_pgrp;
|
|
else
|
|
ep->e_tpgid = 0;
|
|
}
|
|
|
|
/*
|
|
* try over estimating by 5 procs
|
|
*/
|
|
#define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc))
|
|
|
|
int
|
|
sysctl_doproc(name, namelen, where, sizep)
|
|
int *name;
|
|
u_int namelen;
|
|
char *where;
|
|
size_t *sizep;
|
|
{
|
|
register struct proc *p;
|
|
register struct kinfo_proc *dp = (struct kinfo_proc *)where;
|
|
int needed = 0;
|
|
int buflen = where != NULL ? *sizep : 0;
|
|
int doingzomb;
|
|
struct eproc eproc;
|
|
int error = 0;
|
|
dev_t ttyd;
|
|
uid_t ruid;
|
|
struct tty *ttyp;
|
|
|
|
if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
|
|
return (EINVAL);
|
|
p = (struct proc *)allproc;
|
|
doingzomb = 0;
|
|
again:
|
|
for (; p != NULL; p = p->p_nxt) {
|
|
/*
|
|
* Skip embryonic processes.
|
|
*/
|
|
if (p->p_stat == SIDL)
|
|
continue;
|
|
/*
|
|
* TODO: sysctl_oproc - make more efficient (see notes below).
|
|
* do by session.
|
|
*/
|
|
switch (name[0]) {
|
|
|
|
case KERN_PROC_PID:
|
|
/* could do this with just a lookup */
|
|
if (p->p_pid != (pid_t)name[1])
|
|
continue;
|
|
break;
|
|
|
|
case KERN_PROC_PGRP:
|
|
/* could do this by traversing pgrp */
|
|
if (p->p_pgrp != (pid_t)name[1])
|
|
continue;
|
|
break;
|
|
|
|
case KERN_PROC_TTY:
|
|
fill_from_u(p, &ruid, &ttyp, &ttyd);
|
|
if (!ttyp || ttyd != (dev_t)name[1])
|
|
continue;
|
|
break;
|
|
|
|
case KERN_PROC_UID:
|
|
if (p->p_uid != (uid_t)name[1])
|
|
continue;
|
|
break;
|
|
|
|
case KERN_PROC_RUID:
|
|
fill_from_u(p, &ruid, &ttyp, &ttyd);
|
|
if (ruid != (uid_t)name[1])
|
|
continue;
|
|
break;
|
|
|
|
case KERN_PROC_ALL:
|
|
break;
|
|
default:
|
|
return(EINVAL);
|
|
}
|
|
if (buflen >= sizeof(struct kinfo_proc)) {
|
|
fill_eproc(p, &eproc);
|
|
error = copyout ((caddr_t) p, (caddr_t) &dp->kp_proc,
|
|
sizeof(struct proc));
|
|
if (error)
|
|
return (error);
|
|
error = copyout ((caddr_t)&eproc, (caddr_t) &dp->kp_eproc,
|
|
sizeof(eproc));
|
|
if (error)
|
|
return (error);
|
|
dp++;
|
|
buflen -= sizeof(struct kinfo_proc);
|
|
}
|
|
needed += sizeof(struct kinfo_proc);
|
|
}
|
|
if (doingzomb == 0) {
|
|
p = zombproc;
|
|
doingzomb++;
|
|
goto again;
|
|
}
|
|
if (where != NULL) {
|
|
*sizep = (caddr_t)dp - where;
|
|
if (needed > *sizep)
|
|
return (ENOMEM);
|
|
} else {
|
|
needed += KERN_PROCSLOP;
|
|
*sizep = needed;
|
|
}
|
|
return (0);
|
|
}
|