freebsd-dev/sbin/sysctl/sysctl.c
Gavin Atkinson 24b2aa3259 Implement the "-i" option to sysctl(8), to ignore failures while
retrieving individual OIDs.  This allows the same list of OIDs to be
passed to sysctl(8) across different systems where particular OIDs may not
exist, and still get as much information as possible from them.

PR:		bin/123644
Submitted by:	dhw
Approved by:	ed (mentor)
MFC after:	2 weeks
2010-01-31 19:33:25 +00:00

757 lines
16 KiB
C

/*
* Copyright (c) 1993
* The Regents of the University of California. All rights reserved.
*
* 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.
* 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.
*/
#ifndef lint
static const char copyright[] =
"@(#) Copyright (c) 1993\n\
The Regents of the University of California. All rights reserved.\n";
#endif /* not lint */
#ifndef lint
#if 0
static char sccsid[] = "@(#)from: sysctl.c 8.1 (Berkeley) 6/6/93";
#endif
static const char rcsid[] =
"$FreeBSD$";
#endif /* not lint */
#include <sys/param.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/vmmeter.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static int aflag, bflag, dflag, eflag, hflag, iflag;
static int Nflag, nflag, oflag, qflag, xflag, warncount;
static int oidfmt(int *, int, char *, u_int *);
static void parse(char *);
static int show_var(int *, int);
static int sysctl_all(int *oid, int len);
static int name2oid(char *, int *);
static void set_T_dev_t(char *, void **, size_t *);
static int set_IK(const char *, int *);
static void
usage(void)
{
(void)fprintf(stderr, "%s\n%s\n",
"usage: sysctl [-bdehNnoqx] name[=value] ...",
" sysctl [-bdehNnoqx] -a");
exit(1);
}
int
main(int argc, char **argv)
{
int ch;
setlocale(LC_NUMERIC, "");
setbuf(stdout,0);
setbuf(stderr,0);
while ((ch = getopt(argc, argv, "AabdehiNnoqwxX")) != -1) {
switch (ch) {
case 'A':
/* compatibility */
aflag = oflag = 1;
break;
case 'a':
aflag = 1;
break;
case 'b':
bflag = 1;
break;
case 'd':
dflag = 1;
break;
case 'e':
eflag = 1;
break;
case 'h':
hflag = 1;
break;
case 'i':
iflag = 1;
break;
case 'N':
Nflag = 1;
break;
case 'n':
nflag = 1;
break;
case 'o':
oflag = 1;
break;
case 'q':
qflag = 1;
break;
case 'w':
/* compatibility */
/* ignored */
break;
case 'X':
/* compatibility */
aflag = xflag = 1;
break;
case 'x':
xflag = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (Nflag && nflag)
usage();
if (aflag && argc == 0)
exit(sysctl_all(0, 0));
if (argc == 0)
usage();
warncount = 0;
while (argc-- > 0)
parse(*argv++);
exit(warncount);
}
/*
* Parse a name into a MIB entry.
* Lookup and print out the MIB entry if it exists.
* Set a new value if requested.
*/
static void
parse(char *string)
{
int len, i, j;
void *newval = 0;
int intval;
unsigned int uintval;
long longval;
unsigned long ulongval;
size_t newsize = 0;
quad_t quadval;
int mib[CTL_MAXNAME];
char *cp, *bufp, buf[BUFSIZ], *endptr, fmt[BUFSIZ];
u_int kind;
bufp = buf;
if (snprintf(buf, BUFSIZ, "%s", string) >= BUFSIZ)
errx(1, "oid too long: '%s'", string);
if ((cp = strchr(string, '=')) != NULL) {
*strchr(buf, '=') = '\0';
*cp++ = '\0';
while (isspace(*cp))
cp++;
newval = cp;
newsize = strlen(cp);
}
len = name2oid(bufp, mib);
if (len < 0) {
if (iflag)
return;
if (qflag)
exit(1);
else
errx(1, "unknown oid '%s'", bufp);
}
if (oidfmt(mib, len, fmt, &kind))
err(1, "couldn't find format of oid '%s'", bufp);
if (newval == NULL) {
if ((kind & CTLTYPE) == CTLTYPE_NODE) {
if (dflag) {
i = show_var(mib, len);
if (!i && !bflag)
putchar('\n');
}
sysctl_all(mib, len);
} else {
i = show_var(mib, len);
if (!i && !bflag)
putchar('\n');
}
} else {
if ((kind & CTLTYPE) == CTLTYPE_NODE)
errx(1, "oid '%s' isn't a leaf node", bufp);
if (!(kind & CTLFLAG_WR)) {
if (kind & CTLFLAG_TUN) {
warnx("oid '%s' is a read only tunable", bufp);
errx(1, "Tunable values are set in /boot/loader.conf");
} else {
errx(1, "oid '%s' is read only", bufp);
}
}
if ((kind & CTLTYPE) == CTLTYPE_INT ||
(kind & CTLTYPE) == CTLTYPE_UINT ||
(kind & CTLTYPE) == CTLTYPE_LONG ||
(kind & CTLTYPE) == CTLTYPE_ULONG ||
(kind & CTLTYPE) == CTLTYPE_QUAD) {
if (strlen(newval) == 0)
errx(1, "empty numeric value");
}
switch (kind & CTLTYPE) {
case CTLTYPE_INT:
if (strcmp(fmt, "IK") == 0) {
if (!set_IK(newval, &intval))
errx(1, "invalid value '%s'",
(char *)newval);
} else {
intval = (int)strtol(newval, &endptr,
0);
if (endptr == newval || *endptr != '\0')
errx(1, "invalid integer '%s'",
(char *)newval);
}
newval = &intval;
newsize = sizeof(intval);
break;
case CTLTYPE_UINT:
uintval = (int) strtoul(newval, &endptr, 0);
if (endptr == newval || *endptr != '\0')
errx(1, "invalid unsigned integer '%s'",
(char *)newval);
newval = &uintval;
newsize = sizeof(uintval);
break;
case CTLTYPE_LONG:
longval = strtol(newval, &endptr, 0);
if (endptr == newval || *endptr != '\0')
errx(1, "invalid long integer '%s'",
(char *)newval);
newval = &longval;
newsize = sizeof(longval);
break;
case CTLTYPE_ULONG:
ulongval = strtoul(newval, &endptr, 0);
if (endptr == newval || *endptr != '\0')
errx(1, "invalid unsigned long integer"
" '%s'", (char *)newval);
newval = &ulongval;
newsize = sizeof(ulongval);
break;
case CTLTYPE_STRING:
break;
case CTLTYPE_QUAD:
sscanf(newval, "%qd", &quadval);
newval = &quadval;
newsize = sizeof(quadval);
break;
case CTLTYPE_OPAQUE:
if (strcmp(fmt, "T,dev_t") == 0) {
set_T_dev_t (newval, &newval, &newsize);
break;
}
/* FALLTHROUGH */
default:
errx(1, "oid '%s' is type %d,"
" cannot set that", bufp,
kind & CTLTYPE);
}
i = show_var(mib, len);
if (sysctl(mib, len, 0, 0, newval, newsize) == -1) {
if (!i && !bflag)
putchar('\n');
switch (errno) {
case EOPNOTSUPP:
errx(1, "%s: value is not available",
string);
case ENOTDIR:
errx(1, "%s: specification is incomplete",
string);
case ENOMEM:
errx(1, "%s: type is unknown to this program",
string);
default:
warn("%s", string);
warncount++;
return;
}
}
if (!bflag)
printf(" -> ");
i = nflag;
nflag = 1;
j = show_var(mib, len);
if (!j && !bflag)
putchar('\n');
nflag = i;
}
}
/* These functions will dump out various interesting structures. */
static int
S_clockinfo(int l2, void *p)
{
struct clockinfo *ci = (struct clockinfo*)p;
if (l2 != sizeof(*ci)) {
warnx("S_clockinfo %d != %d", l2, sizeof(*ci));
return (1);
}
printf(hflag ? "{ hz = %'d, tick = %'d, profhz = %'d, stathz = %'d }" :
"{ hz = %d, tick = %d, profhz = %d, stathz = %d }",
ci->hz, ci->tick, ci->profhz, ci->stathz);
return (0);
}
static int
S_loadavg(int l2, void *p)
{
struct loadavg *tv = (struct loadavg*)p;
if (l2 != sizeof(*tv)) {
warnx("S_loadavg %d != %d", l2, sizeof(*tv));
return (1);
}
printf(hflag ? "{ %'.2f %'.2f %'.2f }" : "{ %.2f %.2f %.2f }",
(double)tv->ldavg[0]/(double)tv->fscale,
(double)tv->ldavg[1]/(double)tv->fscale,
(double)tv->ldavg[2]/(double)tv->fscale);
return (0);
}
static int
S_timeval(int l2, void *p)
{
struct timeval *tv = (struct timeval*)p;
time_t tv_sec;
char *p1, *p2;
if (l2 != sizeof(*tv)) {
warnx("S_timeval %d != %d", l2, sizeof(*tv));
return (1);
}
printf(hflag ? "{ sec = %'jd, usec = %'ld } " :
"{ sec = %jd, usec = %ld } ",
(intmax_t)tv->tv_sec, tv->tv_usec);
tv_sec = tv->tv_sec;
p1 = strdup(ctime(&tv_sec));
for (p2=p1; *p2 ; p2++)
if (*p2 == '\n')
*p2 = '\0';
fputs(p1, stdout);
return (0);
}
static int
S_vmtotal(int l2, void *p)
{
struct vmtotal *v = (struct vmtotal *)p;
int pageKilo = getpagesize() / 1024;
if (l2 != sizeof(*v)) {
warnx("S_vmtotal %d != %d", l2, sizeof(*v));
return (1);
}
printf(
"\nSystem wide totals computed every five seconds:"
" (values in kilobytes)\n");
printf("===============================================\n");
printf(
"Processes:\t\t(RUNQ: %hd Disk Wait: %hd Page Wait: "
"%hd Sleep: %hd)\n",
v->t_rq, v->t_dw, v->t_pw, v->t_sl);
printf(
"Virtual Memory:\t\t(Total: %dK, Active %dK)\n",
v->t_vm * pageKilo, v->t_avm * pageKilo);
printf("Real Memory:\t\t(Total: %dK Active %dK)\n",
v->t_rm * pageKilo, v->t_arm * pageKilo);
printf("Shared Virtual Memory:\t(Total: %dK Active: %dK)\n",
v->t_vmshr * pageKilo, v->t_avmshr * pageKilo);
printf("Shared Real Memory:\t(Total: %dK Active: %dK)\n",
v->t_rmshr * pageKilo, v->t_armshr * pageKilo);
printf("Free Memory Pages:\t%dK\n", v->t_free * pageKilo);
return (0);
}
static int
T_dev_t(int l2, void *p)
{
dev_t *d = (dev_t *)p;
if (l2 != sizeof(*d)) {
warnx("T_dev_T %d != %d", l2, sizeof(*d));
return (1);
}
printf("%s", devname(*d, S_IFCHR));
return (0);
}
static void
set_T_dev_t(char *path, void **val, size_t *size)
{
static struct stat statb;
if (strcmp(path, "none") && strcmp(path, "off")) {
int rc = stat (path, &statb);
if (rc) {
err(1, "cannot stat %s", path);
}
if (!S_ISCHR(statb.st_mode)) {
errx(1, "must specify a device special file.");
}
} else {
statb.st_rdev = NODEV;
}
*val = (void *) &statb.st_rdev;
*size = sizeof(statb.st_rdev);
}
static int
set_IK(const char *str, int *val)
{
float temp;
int len, kelv;
const char *p;
char *endptr;
if ((len = strlen(str)) == 0)
return (0);
p = &str[len - 1];
if (*p == 'C' || *p == 'F') {
temp = strtof(str, &endptr);
if (endptr == str || endptr != p)
return (0);
if (*p == 'F')
temp = (temp - 32) * 5 / 9;
kelv = temp * 10 + 2732;
} else {
kelv = (int)strtol(str, &endptr, 10);
if (endptr == str || *endptr != '\0')
return (0);
}
*val = kelv;
return (1);
}
/*
* These functions uses a presently undocumented interface to the kernel
* to walk the tree and get the type so it can print the value.
* This interface is under work and consideration, and should probably
* be killed with a big axe by the first person who can find the time.
* (be aware though, that the proper interface isn't as obvious as it
* may seem, there are various conflicting requirements.
*/
static int
name2oid(char *name, int *oidp)
{
int oid[2];
int i;
size_t j;
oid[0] = 0;
oid[1] = 3;
j = CTL_MAXNAME * sizeof(int);
i = sysctl(oid, 2, oidp, &j, name, strlen(name));
if (i < 0)
return (i);
j /= sizeof(int);
return (j);
}
static int
oidfmt(int *oid, int len, char *fmt, u_int *kind)
{
int qoid[CTL_MAXNAME+2];
u_char buf[BUFSIZ];
int i;
size_t j;
qoid[0] = 0;
qoid[1] = 4;
memcpy(qoid + 2, oid, len * sizeof(int));
j = sizeof(buf);
i = sysctl(qoid, len + 2, buf, &j, 0, 0);
if (i)
err(1, "sysctl fmt %d %d %d", i, j, errno);
if (kind)
*kind = *(u_int *)buf;
if (fmt)
strcpy(fmt, (char *)(buf + sizeof(u_int)));
return (0);
}
/*
* This formats and outputs the value of one variable
*
* Returns zero if anything was actually output.
* Returns one if didn't know what to do with this.
* Return minus one if we had errors.
*/
static int
show_var(int *oid, int nlen)
{
u_char buf[BUFSIZ], *val, *oval, *p;
char name[BUFSIZ], *fmt;
const char *sep, *sep1;
int qoid[CTL_MAXNAME+2];
uintmax_t umv;
intmax_t mv;
int i, hexlen;
size_t intlen;
size_t j, len;
u_int kind;
int (*func)(int, void *);
bzero(buf, BUFSIZ);
bzero(name, BUFSIZ);
qoid[0] = 0;
memcpy(qoid + 2, oid, nlen * sizeof(int));
qoid[1] = 1;
j = sizeof(name);
i = sysctl(qoid, nlen + 2, name, &j, 0, 0);
if (i || !j)
err(1, "sysctl name %d %d %d", i, j, errno);
if (Nflag) {
printf("%s", name);
return (0);
}
if (eflag)
sep = "=";
else
sep = ": ";
if (dflag) { /* just print description */
qoid[1] = 5;
j = sizeof(buf);
i = sysctl(qoid, nlen + 2, buf, &j, 0, 0);
if (!nflag)
printf("%s%s", name, sep);
printf("%s", buf);
return (0);
}
/* find an estimate of how much we need for this var */
j = 0;
i = sysctl(oid, nlen, 0, &j, 0, 0);
j += j; /* we want to be sure :-) */
val = oval = malloc(j + 1);
if (val == NULL) {
warnx("malloc failed");
return (1);
}
len = j;
i = sysctl(oid, nlen, val, &len, 0, 0);
if (i || !len) {
free(oval);
return (1);
}
if (bflag) {
fwrite(val, 1, len, stdout);
free(oval);
return (0);
}
val[len] = '\0';
fmt = buf;
oidfmt(oid, nlen, fmt, &kind);
p = val;
switch (*fmt) {
case 'A':
if (!nflag)
printf("%s%s", name, sep);
printf("%.*s", len, p);
free(oval);
return (0);
case 'I':
case 'L':
case 'Q':
if (!nflag)
printf("%s%s", name, sep);
switch (*fmt) {
case 'I': intlen = sizeof(int); break;
case 'L': intlen = sizeof(long); break;
case 'Q': intlen = sizeof(quad_t); break;
}
hexlen = 2 + (intlen * CHAR_BIT + 3) / 4;
sep1 = "";
while (len >= intlen) {
switch (*fmt) {
case 'I':
umv = *(u_int *)p;
mv = *(int *)p;
break;
case 'L':
umv = *(u_long *)p;
mv = *(long *)p;
break;
case 'Q':
umv = *(u_quad_t *)p;
mv = *(quad_t *)p;
break;
}
fputs(sep1, stdout);
if (fmt[1] == 'U')
printf(hflag ? "%'ju" : "%ju", umv);
else if (fmt[1] == 'X')
printf("%#0*jx", hexlen, umv);
else if (fmt[1] == 'K') {
if (mv < 0)
printf("%jd", mv);
else
printf("%.1fC", (mv - 2732.0) / 10);
} else
printf(hflag ? "%'jd" : "%jd", mv);
sep1 = " ";
len -= intlen;
p += intlen;
}
free(oval);
return (0);
case 'P':
if (!nflag)
printf("%s%s", name, sep);
printf("%p", *(void **)p);
free(oval);
return (0);
case 'T':
case 'S':
i = 0;
if (strcmp(fmt, "S,clockinfo") == 0)
func = S_clockinfo;
else if (strcmp(fmt, "S,timeval") == 0)
func = S_timeval;
else if (strcmp(fmt, "S,loadavg") == 0)
func = S_loadavg;
else if (strcmp(fmt, "S,vmtotal") == 0)
func = S_vmtotal;
else if (strcmp(fmt, "T,dev_t") == 0)
func = T_dev_t;
else
func = NULL;
if (func) {
if (!nflag)
printf("%s%s", name, sep);
i = (*func)(len, p);
free(oval);
return (i);
}
/* FALLTHROUGH */
default:
if (!oflag && !xflag) {
free(oval);
return (1);
}
if (!nflag)
printf("%s%s", name, sep);
printf("Format:%s Length:%d Dump:0x", fmt, len);
while (len-- && (xflag || p < val + 16))
printf("%02x", *p++);
if (!xflag && len > 16)
printf("...");
free(oval);
return (0);
}
free(oval);
return (1);
}
static int
sysctl_all(int *oid, int len)
{
int name1[22], name2[22];
int i, j;
size_t l1, l2;
name1[0] = 0;
name1[1] = 2;
l1 = 2;
if (len) {
memcpy(name1+2, oid, len * sizeof(int));
l1 += len;
} else {
name1[2] = 1;
l1++;
}
for (;;) {
l2 = sizeof(name2);
j = sysctl(name1, l1, name2, &l2, 0, 0);
if (j < 0) {
if (errno == ENOENT)
return (0);
else
err(1, "sysctl(getnext) %d %d", j, l2);
}
l2 /= sizeof(int);
if (len < 0 || l2 < (unsigned int)len)
return (0);
for (i = 0; i < len; i++)
if (name2[i] != oid[i])
return (0);
i = show_var(name2, l2);
if (!i && !bflag)
putchar('\n');
memcpy(name1+2, name2, l2 * sizeof(int));
l1 = 2 + l2;
}
}