void
conf_sysctl(FILE *output, char *prefix, struct ipsysctl *x)
{
int tmp = 0;
for (; x != NULL && x->name != NULL; tmp = 0, x++) {
if (x->def_larg) { /* this sysctl takes a value */
tmp = sysctl_int(x->mib, 0, 1);
if (tmp == x->def_larg || tmp == -1)
continue;
fprintf(output, "%s %s %i\n", prefix, x->name, tmp);
continue;
}
switch(x->enable) { /* on/off */
case 0: /* default is enabled */
if (sysctl_int(x->mib, 0, 1) == 0)
fprintf(output, "no %s %s\n", prefix, x->name);
break;
case 1: /* default is not enabled */
if (sysctl_int(x->mib, 0, 1) == 1)
fprintf(output, "%s %s\n", prefix, x->name);
break;
case 2: /* show either way */
if ((tmp = sysctl_int(x->mib, 0, 1)) == 1)
fprintf(output, "%s %s\n", prefix, x->name);
else if (tmp == 0)
fprintf(output, "no %s %s\n", prefix, x->name);
break;
}
}
}
/*
* machine dependent system variables.
*/
int
cpu_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
{
dev_t consdev;
dev_t dev;
switch (name[0]) {
case CPU_CONSDEV:
if (namelen != 1)
return (ENOTDIR); /* overloaded */
if (cn_tab != NULL)
consdev = cn_tab->cn_dev;
else
consdev = NODEV;
return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
sizeof consdev));
case CPU_CHR2BLK:
if (namelen != 2)
return (ENOTDIR); /* overloaded */
dev = chrtoblk((dev_t)name[1]);
return sysctl_rdstruct(oldp, oldlenp, newp, &dev, sizeof(dev));
case CPU_BIOS:
return bios_sysctl(name + 1, namelen - 1, oldp, oldlenp,
newp, newlen, p);
case CPU_CPUVENDOR:
return (sysctl_rdstring(oldp, oldlenp, newp, cpu_vendor));
case CPU_CPUFEATURE:
return (sysctl_rdint(oldp, oldlenp, newp, cpu_feature));
case CPU_KBDRESET:
if (securelevel > 0)
return (sysctl_rdint(oldp, oldlenp, newp,
kbd_reset));
else
return (sysctl_int(oldp, oldlenp, newp, newlen,
&kbd_reset));
case CPU_ALLOWAPERTURE:
if (namelen != 1)
return (ENOTDIR); /* overloaded */
#ifdef APERTURE
if (securelevel > 0)
return (sysctl_int_lower(oldp, oldlenp, newp, newlen,
&allowaperture));
else
return (sysctl_int(oldp, oldlenp, newp, newlen,
&allowaperture));
#else
return (sysctl_rdint(oldp, oldlenp, newp, 0));
#endif
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
int
cpu_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
{
int oldval, ret;
/* all sysctl names at this level are terminal */
if (namelen != 1)
return (ENOTDIR); /* overloaded */
switch (name[0]) {
case CPU_CONSDEV: {
dev_t consdev;
if (cn_tab != NULL)
consdev = cn_tab->cn_dev;
else
consdev = NODEV;
return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
sizeof consdev));
}
case CPU_LED_BLINK:
oldval = led_blink;
ret = sysctl_int(oldp, oldlenp, newp, newlen, &led_blink);
if (oldval != led_blink)
blink_led(NULL);
return (ret);
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
int
sysctl_wdog(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen)
{
int error, period;
if (wdog_ctl_cb == NULL)
return (EOPNOTSUPP);
switch (name[0]) {
case KERN_WATCHDOG_PERIOD:
period = wdog_period;
error = sysctl_int(oldp, oldlenp, newp, newlen, &period);
if (error)
return (error);
if (newp) {
timeout_del(&wdog_timeout);
wdog_period = (*wdog_ctl_cb)(wdog_ctl_cb_arg, period);
}
break;
case KERN_WATCHDOG_AUTO:
error = sysctl_int(oldp, oldlenp, newp, newlen, &wdog_auto);
if (error)
return (error);
if (wdog_auto && wdog_cookie == NULL)
wdog_cookie = shutdownhook_establish(wdog_shutdown,
NULL);
else if (!wdog_auto && wdog_cookie) {
shutdownhook_disestablish(wdog_cookie);
wdog_cookie = NULL;
}
break;
default:
return (EINVAL);
}
if (wdog_auto && wdog_period > 0) {
(void) (*wdog_ctl_cb)(wdog_ctl_cb_arg, wdog_period);
timeout_add(&wdog_timeout, wdog_period * hz / 2);
} else
timeout_del(&wdog_timeout);
return (error);
}
/*
* Return pty-related information.
*/
int
sysctl_pty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen)
{
int error, oldmax;
if (namelen != 1)
return (ENOTDIR);
switch (name[0]) {
case KERN_TTY_MAXPTYS:
if (!newp)
return (sysctl_rdint(oldp, oldlenp, newp, maxptys));
rw_enter_write(&pt_softc_lock);
oldmax = maxptys;
error = sysctl_int(oldp, oldlenp, newp, newlen, &maxptys);
/*
* We can't set the max lower than the current active
* value or to a value bigger than NPTY_MAX.
*/
if (error == 0 && (maxptys > NPTY_MAX || maxptys < npty)) {
maxptys = oldmax;
error = ERANGE;
}
rw_exit_write(&pt_softc_lock);
return (error);
case KERN_TTY_NPTYS:
return (sysctl_rdint(oldp, oldlenp, newp, npty));
#ifdef notyet
case KERN_TTY_GID:
return (sysctl_int(oldp, oldlenp, newp, newlen, &tty_gid));
#endif
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
int
ipsysctl(int set, char *cmd, char *arg, int type)
{
int32_t larg;
const char *errmsg = NULL;
struct ipsysctl *x;
struct sysctltab *stab;
for (stab = sysctls; stab-> name != NULL; stab++)
if(stab->pf == type)
break;
if (stab->pf != type) {
printf("%% table lookup failed (%d)\n", type);
return 0;
}
x = (struct ipsysctl *) genget(cmd, (char **)stab->sysctl,
sizeof(struct ipsysctl));
if (x == 0) {
printf("%% Invalid argument %s\n", cmd);
return 0;
} else if (Ambiguous(x)) {
printf("%% Ambiguous argument %s\n", cmd);
return 0;
}
if (set) {
if (arg) {
larg = strtonum(arg, 0, INT_MAX, &errmsg);
if (errmsg) {
printf("%% Invalid argument %s: %s\n", arg,
errmsg);
return(0);
}
} else
larg = 1;
} else
larg = x->def_larg;
sysctl_int(x->mib, larg, 0);
return(1);
}
/*
* Return timecounter-related information.
*/
int
sysctl_tc(int *name, u_int namelen, void *oldp, size_t *oldlenp,
void *newp, size_t newlen)
{
if (namelen != 1)
return (ENOTDIR);
switch (name[0]) {
case KERN_TIMECOUNTER_TICK:
return (sysctl_rdint(oldp, oldlenp, newp, tc_tick));
case KERN_TIMECOUNTER_TIMESTEPWARNINGS:
return (sysctl_int(oldp, oldlenp, newp, newlen,
×tepwarnings));
case KERN_TIMECOUNTER_HARDWARE:
return (sysctl_tc_hardware(oldp, oldlenp, newp, newlen));
case KERN_TIMECOUNTER_CHOICE:
return (sysctl_tc_choice(oldp, oldlenp, newp, newlen));
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
/*
* Return kernel profiling information.
*/
int
sysctl_doprof(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen)
{
struct gmonparam *gp = &_gmonparam;
int error;
/* all sysctl names at this level are terminal */
if (namelen != 1)
return (ENOTDIR); /* overloaded */
switch (name[0]) {
case GPROF_STATE:
error = sysctl_int(oldp, oldlenp, newp, newlen, &gp->state);
if (error)
return (error);
if (gp->state == GMON_PROF_OFF)
stopprofclock(&proc0);
else
startprofclock(&proc0);
return (0);
case GPROF_COUNT:
return (sysctl_struct(oldp, oldlenp, newp, newlen,
gp->kcount, gp->kcountsize));
case GPROF_FROMS:
return (sysctl_struct(oldp, oldlenp, newp, newlen,
gp->froms, gp->fromssize));
case GPROF_TOS:
return (sysctl_struct(oldp, oldlenp, newp, newlen,
gp->tos, gp->tossize));
case GPROF_GMONPARAM:
return (sysctl_rdstruct(oldp, oldlenp, newp, gp, sizeof *gp));
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
/*
* fast filesystem related variables.
*/
int
ffs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
{
extern int doclusterread, doclusterwrite, doreallocblks, doasyncfree;
#ifdef FFS_SOFTUPDATES
extern int max_softdeps, tickdelay, stat_worklist_push;
extern int stat_blk_limit_push, stat_ino_limit_push, stat_blk_limit_hit;
extern int stat_ino_limit_hit, stat_sync_limit_hit, stat_indir_blk_ptrs;
extern int stat_inode_bitmap, stat_direct_blk_ptrs, stat_dir_entry;
#endif
/* all sysctl names at this level are terminal */
if (namelen != 1)
return (ENOTDIR); /* overloaded */
switch (name[0]) {
case FFS_CLUSTERREAD:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&doclusterread));
case FFS_CLUSTERWRITE:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&doclusterwrite));
case FFS_REALLOCBLKS:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&doreallocblks));
case FFS_ASYNCFREE:
return (sysctl_int(oldp, oldlenp, newp, newlen, &doasyncfree));
#ifdef FFS_SOFTUPDATES
case FFS_MAX_SOFTDEPS:
return (sysctl_int(oldp, oldlenp, newp, newlen, &max_softdeps));
case FFS_SD_TICKDELAY:
return (sysctl_int(oldp, oldlenp, newp, newlen, &tickdelay));
case FFS_SD_WORKLIST_PUSH:
return (sysctl_rdint(oldp, oldlenp, newp, stat_worklist_push));
case FFS_SD_BLK_LIMIT_PUSH:
return (sysctl_rdint(oldp, oldlenp, newp, stat_blk_limit_push));
case FFS_SD_INO_LIMIT_PUSH:
return (sysctl_rdint(oldp, oldlenp, newp, stat_ino_limit_push));
case FFS_SD_BLK_LIMIT_HIT:
return (sysctl_rdint(oldp, oldlenp, newp, stat_blk_limit_hit));
case FFS_SD_INO_LIMIT_HIT:
return (sysctl_rdint(oldp, oldlenp, newp, stat_ino_limit_hit));
case FFS_SD_SYNC_LIMIT_HIT:
return (sysctl_rdint(oldp, oldlenp, newp, stat_sync_limit_hit));
case FFS_SD_INDIR_BLK_PTRS:
return (sysctl_rdint(oldp, oldlenp, newp, stat_indir_blk_ptrs));
case FFS_SD_INODE_BITMAP:
return (sysctl_rdint(oldp, oldlenp, newp, stat_inode_bitmap));
case FFS_SD_DIRECT_BLK_PTRS:
return (sysctl_rdint(oldp, oldlenp, newp, stat_direct_blk_ptrs));
case FFS_SD_DIR_ENTRY:
return (sysctl_rdint(oldp, oldlenp, newp, stat_dir_entry));
#endif
#ifdef UFS_DIRHASH
case FFS_DIRHASH_DIRSIZE:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&ufs_mindirhashsize));
case FFS_DIRHASH_MAXMEM:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&ufs_dirhashmaxmem));
case FFS_DIRHASH_MEM:
return (sysctl_rdint(oldp, oldlenp, newp, ufs_dirhashmem));
#endif
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
static int
zfs_vfs_sysctl(int *name, __unused u_int namelen, user_addr_t oldp, size_t *oldlenp,
user_addr_t newp, size_t newlen, __unused vfs_context_t context)
{
int error;
switch(name[0]) {
case ZFS_SYSCTL_FOOTPRINT: {
zfs_footprint_stats_t *footprint;
size_t copyinsize;
size_t copyoutsize;
int max_caches;
int act_caches;
if (newp) {
return (EINVAL);
}
if (!oldp) {
*oldlenp = sizeof (zfs_footprint_stats_t);
return (0);
}
copyinsize = *oldlenp;
if (copyinsize < sizeof (zfs_footprint_stats_t)) {
*oldlenp = sizeof (zfs_footprint_stats_t);
return (ENOMEM);
}
footprint = kmem_alloc(copyinsize, KM_SLEEP);
max_caches = copyinsize - sizeof (zfs_footprint_stats_t);
max_caches += sizeof (kmem_cache_stats_t);
max_caches /= sizeof (kmem_cache_stats_t);
footprint->version = ZFS_FOOTPRINT_VERSION;
footprint->memory_stats.current = zfs_footprint.current;
footprint->memory_stats.target = zfs_footprint.target;
footprint->memory_stats.highest = zfs_footprint.highest;
footprint->memory_stats.maximum = zfs_footprint.maximum;
arc_get_stats(&footprint->arc_stats);
kmem_cache_stats(&footprint->cache_stats[0], max_caches, &act_caches);
footprint->caches_count = act_caches;
footprint->thread_count = zfs_threads;
copyoutsize = sizeof (zfs_footprint_stats_t) +
((act_caches - 1) * sizeof (kmem_cache_stats_t));
error = copyout(footprint, oldp, copyoutsize);
kmem_free(footprint, copyinsize);
return (error);
}
case ZFS_SYSCTL_CONFIG_DEBUGMSG:
error = sysctl_int(oldp, oldlenp, newp, newlen, &zfs_msg_buf_enabled);
return error;
case ZFS_SYSCTL_CONFIG_DPRINTF:
#ifdef ZFS_DEBUG
error = sysctl_int(oldp, oldlenp, newp, newlen, &zfs_dprintf_enabled);
#else
error = ENOTSUP;
#endif
return error;
}
return (ENOTSUP);
}
int
ddb_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
{
int error, ctlval;
/* All sysctl names at this level are terminal. */
if (namelen != 1)
return (ENOTDIR);
switch (name[0]) {
case DBCTL_RADIX:
return sysctl_int(oldp, oldlenp, newp, newlen, &db_radix);
case DBCTL_MAXWIDTH:
return sysctl_int(oldp, oldlenp, newp, newlen, &db_max_width);
case DBCTL_TABSTOP:
return sysctl_int(oldp, oldlenp, newp, newlen, &db_tab_stop_width);
case DBCTL_MAXLINE:
return sysctl_int(oldp, oldlenp, newp, newlen, &db_max_line);
case DBCTL_PANIC:
if (securelevel > 0)
return (sysctl_int_lower(oldp, oldlenp, newp, newlen,
&db_panic));
else {
ctlval = db_panic;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen,
&ctlval)) || newp == NULL)
return (error);
if (ctlval != 1 && ctlval != 0)
return (EINVAL);
db_panic = ctlval;
return (0);
}
break;
case DBCTL_CONSOLE:
if (securelevel > 0)
return (sysctl_int_lower(oldp, oldlenp, newp, newlen,
&db_console));
else {
ctlval = db_console;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen,
&ctlval)) || newp == NULL)
return (error);
if (ctlval != 1 && ctlval != 0)
return (EINVAL);
db_console = ctlval;
return (0);
}
break;
case DBCTL_LOG:
return (sysctl_int(oldp, oldlenp, newp, newlen, &db_log));
case DBCTL_TRIGGER:
if (newp && db_console) {
struct process *pr = curproc->p_p;
if (securelevel < 1 ||
(pr->ps_flags & PS_CONTROLT && cn_tab &&
cn_tab->cn_dev == pr->ps_session->s_ttyp->t_dev)) {
Debugger();
newp = NULL;
} else
return (ENODEV);
}
return (sysctl_rdint(oldp, oldlenp, newp, 0));
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
/*
* Userland access to struct shminfo.
*/
int
sysctl_sysvshm(int *name, u_int namelen, void *oldp, size_t *oldlenp,
void *newp, size_t newlen)
{
int error, val;
struct shmid_ds **newsegs;
unsigned short *newseqs;
if (namelen != 2) {
switch (name[0]) {
case KERN_SHMINFO_SHMMAX:
case KERN_SHMINFO_SHMMIN:
case KERN_SHMINFO_SHMMNI:
case KERN_SHMINFO_SHMSEG:
case KERN_SHMINFO_SHMALL:
break;
default:
return (ENOTDIR); /* overloaded */
}
}
switch (name[0]) {
case KERN_SHMINFO_SHMMAX:
if ((error = sysctl_int(oldp, oldlenp, newp, newlen,
&shminfo.shmmax)) || newp == NULL)
return (error);
/* If new shmmax > shmall, crank shmall */
if (atop(round_page(shminfo.shmmax)) > shminfo.shmall)
shminfo.shmall = atop(round_page(shminfo.shmmax));
return (0);
case KERN_SHMINFO_SHMMIN:
val = shminfo.shmmin;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmmin)
return (error);
if (val <= 0)
return (EINVAL); /* shmmin must be >= 1 */
shminfo.shmmin = val;
return (0);
case KERN_SHMINFO_SHMMNI:
val = shminfo.shmmni;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmmni)
return (error);
if (val < shminfo.shmmni || val > 0xffff)
return (EINVAL);
/* Expand shmsegs and shmseqs arrays */
newsegs = malloc(val * sizeof(struct shmid_ds *),
M_SHM, M_WAITOK|M_ZERO);
bcopy(shmsegs, newsegs,
shminfo.shmmni * sizeof(struct shmid_ds *));
free(shmsegs, M_SHM);
shmsegs = newsegs;
newseqs = malloc(val * sizeof(unsigned short), M_SHM,
M_WAITOK|M_ZERO);
bcopy(shmseqs, newseqs,
shminfo.shmmni * sizeof(unsigned short));
free(shmseqs, M_SHM);
shmseqs = newseqs;
shminfo.shmmni = val;
return (0);
case KERN_SHMINFO_SHMSEG:
val = shminfo.shmseg;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmseg)
return (error);
if (val <= 0)
return (EINVAL); /* shmseg must be >= 1 */
shminfo.shmseg = val;
return (0);
case KERN_SHMINFO_SHMALL:
val = shminfo.shmall;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
val == shminfo.shmall)
return (error);
if (val < shminfo.shmall)
return (EINVAL); /* can't decrease shmall */
shminfo.shmall = val;
return (0);
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
