d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
40b0c0d936
freebsd-nq/sys/kern/kern_sysctl.c

1144 lines
27 KiB
C
Raw Normal View History

BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
/*-
* 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.
*
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
* Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
* project, to make these variables more userfriendly.
*
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
* 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.
*
* @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
* $Id: kern_sysctl.c,v 1.54 1995/12/05 21:51:33 bde Exp $
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
*/
#include <sys/param.h>
#include <sys/systm.h>
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#include <sys/sysproto.h>
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <sys/unistd.h>
The death of `options NODUMP'. Now the dump area can be dynamically configured (and unconfigured) on the fly. A sysctl(3) MIB variable is provided to inspect and modify the dump device setting.
1995-05-12 19:17:31 +00:00
#include <sys/conf.h>
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
#include <sys/sysctl.h>
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
#include <sys/malloc.h>
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
Include <vm/vm.h> or <vm/vm_page.h> explicitly to avoid breaking when vnode_if.h doesn't include vm stuff.
1995-12-05 21:51:45 +00:00
#include <vm/vm.h>
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
/*
* Locking and stats
*/
static struct sysctl_lock {
int sl_lock;
int sl_want;
int sl_locked;
} memlock;
static int sysctl_root SYSCTL_HANDLER_ARGS;
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
extern struct linker_set sysctl_;
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
/*
* MIB definitions. XXX Very few of these, if any, belong here.
*/
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, 0, sysctl, CTLFLAG_RW, 0,
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
"Sysctl internal magic");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_KERN, kern, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"High kernel, proc, limits &c");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_VM, vm, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"Virtual memory");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_FS, fs, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"File system");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_NET, net, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"Network, (see socket.h)");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_DEBUG, debug, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"Debugging");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_HW, hw, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"hardware");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_MACHDEP, machdep, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"machine dependent");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSCTL_NODE(, CTL_USER, user, CTLFLAG_RW, 0,
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
"user-level");
SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD, osrelease, 0, "");
SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD, 0, BSD, "");
SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD, version, 0, "");
SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD, ostype, 0, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
extern int osreldate;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_OSRELDATE, osreldate, CTLFLAG_RD, &osreldate, 0, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RD, &maxproc, 0, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid,
Sorry, the last commit screwed up for me, this is the right one (I hope!) Please refer to the previous commit message about sysctl variables.
1995-10-28 13:07:28 +00:00
CTLFLAG_RD, &maxprocperuid, 0, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD, 0, ARG_MAX, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD, 0, _POSIX_VERSION, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RD, 0, NGROUPS_MAX, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD, 0, 1, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
#ifdef _POSIX_SAVED_IDS
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD, 0, 1, "");
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
#else
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD, 0, 0, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
#endif
char kernelname[MAXPATHLEN] = "/kernel"; /* XXX bloat */
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile,
Sorry, the last commit screwed up for me, this is the right one (I hope!) Please refer to the previous commit message about sysctl variables.
1995-10-28 13:07:28 +00:00
CTLFLAG_RW, kernelname, sizeof kernelname, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD, 0, 1, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD, 0, BYTE_ORDER, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
SYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD, 0, PAGE_SIZE, "");
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
char hostname[MAXHOSTNAMELEN];
Get rid of hostnamelen variable.
1995-11-14 09:37:22 +00:00
SYSCTL_STRING(_kern, KERN_HOSTNAME, hostname, CTLFLAG_RW,
hostname, sizeof(hostname), "");
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
int securelevel = -1;
static int
sysctl_kern_securelvl SYSCTL_HANDLER_ARGS
{
int error, level;
level = securelevel;
error = sysctl_handle_int(oidp, &level, 0, req);
if (error || !req->newptr)
return (error);
if (level < securelevel && req->p->p_pid != 1)
return (EPERM);
securelevel = level;
return (error);
}
SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel, CTLTYPE_INT|CTLFLAG_RW,
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
0, 0, sysctl_kern_securelvl, "I", "");
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
char domainname[MAXHOSTNAMELEN];
SYSCTL_STRING(_kern, KERN_DOMAINNAME, domainname, CTLFLAG_RW,
&domainname, sizeof(domainname), "");
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
long hostid;
/* Some trouble here, if sizeof (int) != sizeof (long) */
SYSCTL_INT(_kern, KERN_HOSTID, hostid, CTLFLAG_RW, &hostid, 0, "");
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
/*
* This is really cheating. These actually live in the libc, something
* which I'm not quite sure is a good idea anyway, but in order for
* getnext and friends to actually work, we define dummies here.
*/
SYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RW, "", 0, "");
SYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RW, 0, 0, "");
SYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RW, 0, 0, "");
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
/*
* End of MIB definitions.
*/
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
/*
* Initialization of the MIB tree.
*
* Order by number in each linker_set.
*/
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
static int
Fixed type of sysctl_order_cmp(). KNFized sysctl_order_cmp(). Staticized definition of kern_sysctl() to match its declaration.
1995-11-11 00:09:21 +00:00
sysctl_order_cmp(const void *a, const void *b)
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
{
Fixed type of sysctl_order_cmp(). KNFized sysctl_order_cmp(). Staticized definition of kern_sysctl() to match its declaration.
1995-11-11 00:09:21 +00:00
const struct sysctl_oid **pa, **pb;
pa = (const struct sysctl_oid **)a;
pb = (const struct sysctl_oid **)b;
if (*pa == NULL)
return (1);
if (*pb == NULL)
return (-1);
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
return ((*pa)->oid_number - (*pb)->oid_number);
}
static void
sysctl_order(void *arg)
{
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
int j, k;
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
struct linker_set *l = (struct linker_set *) arg;
struct sysctl_oid **oidpp;
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
/* First, find the highest oid we have */
j = l->ls_length;
oidpp = (struct sysctl_oid **) l->ls_items;
for (k = 0; j--; oidpp++)
if (*oidpp && (*oidpp)->oid_number > k)
k = (*oidpp)->oid_number;
/* Next, replace all OID_AUTO oids with new numbers */
j = l->ls_length;
oidpp = (struct sysctl_oid **) l->ls_items;
k += 100;
for (; j--; oidpp++)
if (*oidpp && (*oidpp)->oid_number == OID_AUTO)
(*oidpp)->oid_number = k++;
/* Finally: sort by oid */
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
j = l->ls_length;
oidpp = (struct sysctl_oid **) l->ls_items;
for (; j--; oidpp++) {
if (!*oidpp)
continue;
if ((*oidpp)->oid_arg1 == arg) {
*oidpp = 0;
continue;
}
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (((*oidpp)->oid_kind & CTLTYPE) == CTLTYPE_NODE)
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
if (!(*oidpp)->oid_handler)
sysctl_order((*oidpp)->oid_arg1);
}
qsort(l->ls_items, l->ls_length, sizeof l->ls_items[0],
sysctl_order_cmp);
}
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_order, &sysctl_);
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
/*
* "Staff-functions"
*
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
* These functions implement a presently undocumented interface
* used by the sysctl program 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.
*
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
* {0,0} printf the entire MIB-tree.
* {0,1,...} return the name of the "..." OID.
* {0,2,...} return the next OID.
* {0,3} return the OID of the name in "new"
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
* {0,4,...} return the kind & format info for the "..." OID.
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
*/
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
static void
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
sysctl_sysctl_debug_dump_node(struct linker_set *l, int i)
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
{
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
int j, k;
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
struct sysctl_oid **oidpp;
j = l->ls_length;
oidpp = (struct sysctl_oid **) l->ls_items;
for (; j--; oidpp++) {
if (!*oidpp)
continue;
for (k=0; k<i; k++)
printf(" ");
if ((*oidpp)->oid_number > 100) {
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
printf("Junk! %p # %d %s k %x a1 %p a2 %x h %p\n",
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
*oidpp,
(*oidpp)->oid_number, (*oidpp)->oid_name,
(*oidpp)->oid_kind, (*oidpp)->oid_arg1,
(*oidpp)->oid_arg2, (*oidpp)->oid_handler);
continue;
}
printf("%d %s ", (*oidpp)->oid_number, (*oidpp)->oid_name);
printf("%c%c",
(*oidpp)->oid_kind & CTLFLAG_RD ? 'R':' ',
(*oidpp)->oid_kind & CTLFLAG_WR ? 'W':' ');
switch ((*oidpp)->oid_kind & CTLTYPE) {
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
case CTLTYPE_NODE:
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
if ((*oidpp)->oid_handler) {
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
printf(" Node(proc)\n");
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
} else {
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
printf(" Node\n");
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
sysctl_sysctl_debug_dump_node(
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
(*oidpp)->oid_arg1, i+2);
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
}
break;
case CTLTYPE_INT: printf(" Int\n"); break;
case CTLTYPE_STRING: printf(" String\n"); break;
case CTLTYPE_QUAD: printf(" Quad\n"); break;
case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break;
default: printf("\n");
}
}
}
static int
sysctl_sysctl_debug SYSCTL_HANDLER_ARGS
{
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
sysctl_sysctl_debug_dump_node(&sysctl_, 0);
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
return ENOENT;
}
SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD,
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
0, 0, sysctl_sysctl_debug, "-", "");
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
static int
sysctl_sysctl_name SYSCTL_HANDLER_ARGS
{
int *name = (int *) arg1;
u_int namelen = arg2;
int i, j, error = 0;
struct sysctl_oid **oidpp;
struct linker_set *lsp = &sysctl_;
char buf[10];
while (namelen) {
if (!lsp) {
sprintf(buf,"%d",*name);
if (req->oldidx)
error = SYSCTL_OUT(req, ".", 1);
if (!error)
error = SYSCTL_OUT(req, buf, strlen(buf));
if (error)
return (error);
namelen--;
name++;
continue;
}
oidpp = (struct sysctl_oid **) lsp->ls_items;
j = lsp->ls_length;
lsp = 0;
for (i = 0; i < j; i++, oidpp++) {
if (*oidpp && ((*oidpp)->oid_number != *name))
continue;
if (req->oldidx)
error = SYSCTL_OUT(req, ".", 1);
if (!error)
error = SYSCTL_OUT(req, (*oidpp)->oid_name,
strlen((*oidpp)->oid_name));
if (error)
return (error);
namelen--;
name++;
if (((*oidpp)->oid_kind & CTLTYPE) != CTLTYPE_NODE)
break;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
if ((*oidpp)->oid_handler)
break;
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
break;
}
}
return (SYSCTL_OUT(req, "", 1));
}
SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD, sysctl_sysctl_name, "");
static int
sysctl_sysctl_next_ls (struct linker_set *lsp, int *name, u_int namelen,
int *next, int *len, int level, struct sysctl_oid **oidp)
{
int i, j;
struct sysctl_oid **oidpp;
oidpp = (struct sysctl_oid **) lsp->ls_items;
j = lsp->ls_length;
*len = level;
for (i = 0; i < j; i++, oidpp++) {
if (!*oidpp)
continue;
*next = (*oidpp)->oid_number;
*oidp = *oidpp;
if (!namelen) {
if (((*oidpp)->oid_kind & CTLTYPE) != CTLTYPE_NODE)
return 0;
if ((*oidpp)->oid_handler)
/* We really should call the handler here...*/
return 0;
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
return (sysctl_sysctl_next_ls (lsp, 0, 0, next+1,
len, level+1, oidp));
}
if ((*oidpp)->oid_number < *name)
continue;
if ((*oidpp)->oid_number > *name) {
if (((*oidpp)->oid_kind & CTLTYPE) != CTLTYPE_NODE)
return 0;
if ((*oidpp)->oid_handler)
return 0;
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
if (!sysctl_sysctl_next_ls (lsp, name+1, namelen-1,
next+1, len, level+1, oidp))
return (0);
namelen = 1;
*len = level;
continue;
}
if (((*oidpp)->oid_kind & CTLTYPE) != CTLTYPE_NODE)
continue;
if ((*oidpp)->oid_handler)
continue;
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
if (!sysctl_sysctl_next_ls (lsp, name+1, namelen-1, next+1,
len, level+1, oidp))
return (0);
namelen = 1;
*len = level;
}
return 1;
}
static int
sysctl_sysctl_next SYSCTL_HANDLER_ARGS
{
int *name = (int *) arg1;
u_int namelen = arg2;
int i, j, error;
struct sysctl_oid *oid;
struct linker_set *lsp = &sysctl_;
int newoid[CTL_MAXNAME];
i = sysctl_sysctl_next_ls (lsp, name, namelen, newoid, &j, 1, &oid);
if (i)
return ENOENT;
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
error = SYSCTL_OUT(req, newoid, j * sizeof (int));
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
return (error);
}
SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD, sysctl_sysctl_next, "");
static int
name2oid (char *name, int *oid, int *len, struct sysctl_oid **oidp)
{
int i, j;
struct sysctl_oid **oidpp;
struct linker_set *lsp = &sysctl_;
char *p;
if (!*name)
return ENOENT;
p = name + strlen(name) - 1 ;
if (*p == '.')
*p = '\0';
*len = 0;
for (p = name; *p && *p != '.'; p++)
;
i = *p;
if (i == '.')
*p = '\0';
j = lsp->ls_length;
oidpp = (struct sysctl_oid **) lsp->ls_items;
while (j-- && *len < CTL_MAXNAME) {
if (!*oidpp)
continue;
if (strcmp(name, (*oidpp)->oid_name)) {
oidpp++;
continue;
}
*oid++ = (*oidpp)->oid_number;
(*len)++;
if (!i) {
if (oidp)
*oidp = *oidpp;
return (0);
}
if (((*oidpp)->oid_kind & CTLTYPE) != CTLTYPE_NODE)
break;
if ((*oidpp)->oid_handler)
break;
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
j = lsp->ls_length;
oidpp = (struct sysctl_oid **)lsp->ls_items;
name = p+1;
for (p = name; *p && *p != '.'; p++)
;
i = *p;
if (i == '.')
*p = '\0';
}
return ENOENT;
}
static int
sysctl_sysctl_name2oid SYSCTL_HANDLER_ARGS
{
char *p;
int error, oid[CTL_MAXNAME], len;
struct sysctl_oid *op = 0;
if (!req->newlen)
return ENOENT;
p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
error = SYSCTL_IN(req, p, req->newlen);
if (error) {
free(p, M_SYSCTL);
return (error);
}
p [req->newlen] = '\0';
error = name2oid(p, oid, &len, &op);
free(p, M_SYSCTL);
if (error)
return (error);
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
error = SYSCTL_OUT(req, oid, len * sizeof *oid);
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
return (error);
}
SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW, 0, 0,
sysctl_sysctl_name2oid, "I", "");
static int
sysctl_sysctl_oidfmt SYSCTL_HANDLER_ARGS
{
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
int *name = (int *) arg1, error;
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
u_int namelen = arg2;
int indx, j;
struct sysctl_oid **oidpp;
struct linker_set *lsp = &sysctl_;
j = lsp->ls_length;
oidpp = (struct sysctl_oid **) lsp->ls_items;
indx = 0;
while (j-- && indx < CTL_MAXNAME) {
if (*oidpp && ((*oidpp)->oid_number == name[indx])) {
indx++;
if (((*oidpp)->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
if ((*oidpp)->oid_handler)
goto found;
if (indx == namelen)
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
goto found;
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
j = lsp->ls_length;
oidpp = (struct sysctl_oid **)lsp->ls_items;
} else {
if (indx != namelen)
return EISDIR;
goto found;
}
} else {
oidpp++;
}
}
return ENOENT;
found:
if (!(*oidpp)->oid_fmt)
return ENOENT;
A couple of minor tweaks to the sysctl stuff.
1995-12-06 13:27:39 +00:00
error = SYSCTL_OUT(req,
&(*oidpp)->oid_kind, sizeof((*oidpp)->oid_kind));
if (!error)
error = SYSCTL_OUT(req, (*oidpp)->oid_fmt,
strlen((*oidpp)->oid_fmt)+1);
return (error);
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
}
SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD, sysctl_sysctl_oidfmt, "");
/*
* Default "handler" functions.
*/
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
/*
* Handle an integer, signed or unsigned.
* Two cases:
* a variable: point arg1 at it.
* a constant: pass it in arg2.
*/
Sorry, the last commit screwed up for me, this is the right one (I hope!) Please refer to the previous commit message about sysctl variables.
1995-10-28 13:07:28 +00:00
int
sysctl_handle_int SYSCTL_HANDLER_ARGS
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
{
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
int error = 0;
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (arg1)
error = SYSCTL_OUT(req, arg1, sizeof(int));
else if (arg2)
error = SYSCTL_OUT(req, &arg2, sizeof(int));
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (error || !req->newptr)
return (error);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (!arg1)
error = EPERM;
else
error = SYSCTL_IN(req, arg1, sizeof(int));
return (error);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
}
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
/*
* Handle our generic '\0' terminated 'C' string.
* Two cases:
* a variable string: point arg1 at it, arg2 is max length.
* a constant string: point arg1 at it, arg2 is zero.
*/
Sorry, the last commit screwed up for me, this is the right one (I hope!) Please refer to the previous commit message about sysctl variables.
1995-10-28 13:07:28 +00:00
int
sysctl_handle_string SYSCTL_HANDLER_ARGS
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
{
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
int error=0;
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
Do what is generally belived to be the right thing, though it may not be :-)
1995-11-14 20:43:29 +00:00
error = SYSCTL_OUT(req, arg1, strlen((char *)arg1)+1);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (error || !req->newptr || !arg2)
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
return (error);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if ((req->newlen - req->newidx) > arg2) {
error = E2BIG;
} else {
arg2 = (req->newlen - req->newidx);
error = SYSCTL_IN(req, arg1, arg2);
((char *)arg1)[arg2] = '\0';
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
}
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return (error);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
}
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
/*
* Handle any kind of opaque data.
* arg1 points to it, arg2 is the size.
*/
Sorry, the last commit screwed up for me, this is the right one (I hope!) Please refer to the previous commit message about sysctl variables.
1995-10-28 13:07:28 +00:00
int
sysctl_handle_opaque SYSCTL_HANDLER_ARGS
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
{
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
int error;
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
error = SYSCTL_OUT(req, arg1, arg2);
if (error || !req->newptr)
return (error);
error = SYSCTL_IN(req, arg1, arg2);
return (error);
}
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
/*
* Transfer functions to/from kernel space.
* XXX: rather untested at this point
*/
static int
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
sysctl_old_kernel(struct sysctl_req *req, void *p, int l)
{
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
int i = 0;
if (req->oldptr) {
i = min(req->oldlen - req->oldidx, l);
if (i > 0)
bcopy(p, req->oldptr + req->oldidx, i);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
req->oldidx += l;
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (i != l)
return (ENOMEM);
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
return (0);
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
static int
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
sysctl_new_kernel(struct sysctl_req *req, void *p, int l)
{
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (!req->newptr)
return 0;
if (req->newlen - req->newidx < l)
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
return (EINVAL);
bcopy(req->newptr + req->newidx, p, l);
req->newidx += l;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return (0);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
/*
* Transfer function to/from user space.
*/
static int
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
sysctl_old_user(struct sysctl_req *req, void *p, int l)
{
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
int error = 0, i = 0;
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
if (req->lock == 1 && req->oldptr) {
vslock(req->oldptr, req->oldlen);
req->lock = 2;
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (req->oldptr) {
i = min(req->oldlen - req->oldidx, l);
if (i > 0)
error = copyout(p, req->oldptr + req->oldidx, i);
}
req->oldidx += l;
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (error)
return (error);
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (req->oldptr && i < l)
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
return (ENOMEM);
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
return (0);
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
static int
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
sysctl_new_user(struct sysctl_req *req, void *p, int l)
{
A couple of nitpicks.
1995-11-14 09:26:17 +00:00
int error;
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (!req->newptr)
return 0;
if (req->newlen - req->newidx < l)
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
return (EINVAL);
error = copyin(req->newptr + req->newidx, p, l);
req->newidx += l;
return (error);
}
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
/*
* Traverse our tree, and find the right node, execute whatever it points
* at, and return the resulting error code.
*/
int
sysctl_root SYSCTL_HANDLER_ARGS
{
int *name = (int *) arg1;
A major sweep over the sysctl stuff. Move a lot of variables home to their own code (In good time before xmas :-) Introduce the string descrition of format. Add a couple more functions to poke into these marvels, while I try to decide what the correct interface should look like. Next is adding vars on the fly, and sysctl looking at them too. Removed a tine bit of defunct and #ifdefed notused code in swapgeneric.
1995-12-04 16:48:58 +00:00
u_int namelen = arg2;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
int indx, i, j;
struct sysctl_oid **oidpp;
struct linker_set *lsp = &sysctl_;
j = lsp->ls_length;
oidpp = (struct sysctl_oid **) lsp->ls_items;
indx = 0;
while (j-- && indx < CTL_MAXNAME) {
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
if (*oidpp && ((*oidpp)->oid_number == name[indx])) {
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
indx++;
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
if ((*oidpp)->oid_kind & CTLFLAG_NOLOCK)
req->lock = 0;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
if (((*oidpp)->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
if ((*oidpp)->oid_handler)
goto found;
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (indx == namelen)
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return ENOENT;
lsp = (struct linker_set*)(*oidpp)->oid_arg1;
j = lsp->ls_length;
oidpp = (struct sysctl_oid **)lsp->ls_items;
} else {
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (indx != namelen)
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return EISDIR;
goto found;
}
} else {
oidpp++;
}
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
return ENOENT;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
found:
/* If writing isn't allowed */
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (req->newptr && !((*oidpp)->oid_kind & CTLFLAG_WR))
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return (EPERM);
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (!(*oidpp)->oid_handler)
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return EINVAL;
if (((*oidpp)->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
i = ((*oidpp)->oid_handler) (*oidpp,
name + indx, namelen - indx,
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
req);
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
} else {
i = ((*oidpp)->oid_handler) (*oidpp,
(*oidpp)->oid_arg1, (*oidpp)->oid_arg2,
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
req);
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
}
return (i);
}
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#ifndef _SYS_SYSPROTO_H_
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
struct sysctl_args {
int *name;
u_int namelen;
void *old;
size_t *oldlenp;
void *new;
size_t newlen;
};
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#endif
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
int
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
__sysctl(struct proc *p, struct sysctl_args *uap, int *retval)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
{
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
int error, i, j, name[CTL_MAXNAME];
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
return (EINVAL);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
All of this is cosmetic. prototypes, #includes, printfs and so on. Makes GCC a lot more silent.
1994-10-02 17:35:40 +00:00
error = copyin(uap->name, &name, uap->namelen * sizeof(int));
if (error)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (error);
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
error = userland_sysctl(p, name, uap->namelen,
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
uap->old, uap->oldlenp, 0,
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
uap->new, uap->newlen, &j);
if (error && error != ENOMEM)
return (error);
if (uap->oldlenp) {
i = copyout(&j, uap->oldlenp, sizeof(j));
if (i)
return (i);
}
return (error);
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
}
/*
* This is used from various compatibility syscalls too. That's why name
* must be in kernel space.
*/
int
userland_sysctl(struct proc *p, int *name, u_int namelen, void *old, size_t *oldlenp, int inkernel, void *new, size_t newlen, int *retval)
{
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
int error = 0;
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
struct sysctl_req req;
bzero(&req, sizeof req);
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
A couple of nitpicks.
1995-11-14 09:26:17 +00:00
req.p = p;
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
if (new != NULL && (error = suser(p->p_ucred, &p->p_acflag)))
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
return (error);
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
if (oldlenp) {
if (inkernel) {
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
req.oldlen = *oldlenp;
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
} else {
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp));
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
if (error)
return (error);
}
}
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (old) {
if (!useracc(old, req.oldlen, B_WRITE))
return (EFAULT);
req.oldptr= old;
}
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
if (newlen) {
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
if (!useracc(new, req.newlen, B_READ))
return (EFAULT);
req.newlen = newlen;
req.newptr = new;
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
}
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
req.oldfunc = sysctl_old_user;
req.newfunc = sysctl_new_user;
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
req.lock = 1;
/* XXX this should probably be done in a general way */
while (memlock.sl_lock) {
memlock.sl_want = 1;
(void) tsleep((caddr_t)&memlock, PRIBIO+1, "sysctl", 0);
memlock.sl_locked++;
}
memlock.sl_lock = 1;
The entire sysctl callback to read/write version. I havn't tested this as much as I'd like to, but the malloc stunt I tried for an interim for sure does worse. Now we can read and write from any kind of address-space, not only user and kernel, using callbacks. This may be over-generalization for now, but it's actually simpler.
1995-11-12 19:52:09 +00:00
error = sysctl_root(0, name, namelen, &req);
Rewamp the way we make sysctl variables to be easier to cope with. The goal is to make them "user-friendly" :-) In the end this will allow a SNMP style "getnext" function, sysctl editing in the boot-editor and/or debugger, LKMs can define sysctl vars when they get loaded, and remove them when unloaded and other interesting uses for dynamic sysctl variables.
1995-10-28 12:59:25 +00:00
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
if (req.lock == 2)
vsunlock(req.oldptr, req.oldlen, B_WRITE);
memlock.sl_lock = 0;
if (memlock.sl_want) {
memlock.sl_want = 0;
wakeup((caddr_t)&memlock);
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (error && error != ENOMEM)
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
return (error);
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
if (retval) {
if (req.oldptr && req.oldidx > req.oldlen)
*retval = req.oldlen;
else
*retval = req.oldidx;
On working the new sysctl vars a bit I realized that I needed more generality. This is here now. We can now access (the new) sysctl variables from the kernel too and using functions to handle access is more sane now. I will now attack sysctl variables in the rest of the kernel and get them all converted to newspeak.
1995-11-06 16:18:52 +00:00
}
Try to make my new scheme work more along the lines of the manual. There are still some gray areas here and there.
1995-11-13 13:54:09 +00:00
return (error);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
#ifdef COMPAT_43
#include <sys/socket.h>
#define KINFO_PROC (0<<8)
#define KINFO_RT (1<<8)
#define KINFO_VNODE (2<<8)
#define KINFO_FILE (3<<8)
#define KINFO_METER (4<<8)
#define KINFO_LOADAVG (5<<8)
#define KINFO_CLOCKRATE (6<<8)
This implements enough of the BSDI extensions to the net-2 ogetkerninfo() syscall to allow applications linked against their libc's uname() to work. Netscape 1.1N being a prime example, which prints: "uname() failed. cant tell what system we're running on". This change is a little ugly, but that's mainly because of the "interesting" semantics of the BSDI extension. Since ogetkerninfo() is only enabled by COMPAT_43, Netscape will only be affected on kernels with that option (eg: "GENERIC") Reviewed by: davidg
1995-07-09 02:49:30 +00:00
/* Non-standard BSDI extension - only present on their 4.3 net-2 releases */
#define KINFO_BSDI_SYSINFO (101<<8)
/*
* XXX this is bloat, but I hope it's better here than on the potentially
* limited kernel stack... -Peter
*/
struct {
int bsdi_machine; /* "i386" on BSD/386 */
/* ^^^ this is an offset to the string, relative to the struct start */
char *pad0;
long pad1;
long pad2;
long pad3;
u_long pad4;
u_long pad5;
u_long pad6;
int bsdi_ostype; /* "BSD/386" on BSD/386 */
int bsdi_osrelease; /* "1.1" on BSD/386 */
long pad7;
long pad8;
char *pad9;
long pad10;
long pad11;
int pad12;
long pad13;
quad_t pad14;
long pad15;
struct timeval pad16;
/* we dont set this, because BSDI's uname used gethostname() instead */
int bsdi_hostname; /* hostname on BSD/386 */
/* the actual string data is appended here */
} bsdi_si;
/*
* this data is appended to the end of the bsdi_si structure during copyout.
* The "char *" offsets are relative to the base of the bsdi_si struct.
* This contains "FreeBSD\02.0-BUILT-nnnnnn\0i386\0", and these strings
* should not exceed the length of the buffer here... (or else!! :-)
*/
char bsdi_strings[80]; /* It had better be less than this! */
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#ifndef _SYS_SYSPROTO_H_
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
struct getkerninfo_args {
int op;
char *where;
int *size;
int arg;
};
Included <sys/sysproto.h> to get central declarations for syscall args structs and prototypes for syscalls. Ifdefed duplicated decentralized declarations of args structs. It's convenient to have this visible but they are hard to maintain. Some are already different from the central declarations. 4.4lite2 puts them in comments in the function headers but I wanted to avoid the large changes for that.
1995-11-12 06:43:28 +00:00
#endif
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
The big 4.4BSD Lite to FreeBSD 2.0.0 (Development) patch. Reviewed by: Rodney W. Grimes Submitted by: John Dyson and David Greenman
1994-05-25 09:21:21 +00:00
int
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
ogetkerninfo(struct proc *p, struct getkerninfo_args *uap, int *retval)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
{
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
int error, name[6];
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
u_int size;
switch (uap->op & 0xff00) {
case KINFO_RT:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_NET;
name[1] = PF_ROUTE;
name[2] = 0;
name[3] = (uap->op & 0xff0000) >> 16;
name[4] = uap->op & 0xff;
name[5] = uap->arg;
error = userland_sysctl(p, name, 6, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
case KINFO_VNODE:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_KERN;
name[1] = KERN_VNODE;
error = userland_sysctl(p, name, 2, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
case KINFO_PROC:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_KERN;
name[1] = KERN_PROC;
name[2] = uap->op & 0xff;
name[3] = uap->arg;
error = userland_sysctl(p, name, 4, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
case KINFO_FILE:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_KERN;
name[1] = KERN_FILE;
error = userland_sysctl(p, name, 2, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
case KINFO_METER:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_VM;
name[1] = VM_METER;
error = userland_sysctl(p, name, 2, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
case KINFO_LOADAVG:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_VM;
name[1] = VM_LOADAVG;
error = userland_sysctl(p, name, 2, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
case KINFO_CLOCKRATE:
Make the old compat functions use the sysctl front door, rather than crashing through the walls. This should save Peters blood pressure and netscapes uname call.
1995-11-09 20:22:12 +00:00
name[0] = CTL_KERN;
name[1] = KERN_CLOCKRATE;
error = userland_sysctl(p, name, 2, uap->where, uap->size,
Mega commit for sysctl. Convert the remaining sysctl stuff to the new way of doing things. the devconf stuff is the reason for the large number of files. Cleaned up some compiler warnings while I were there.
1995-11-20 12:42:39 +00:00
0, 0, 0, &size);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
break;
This implements enough of the BSDI extensions to the net-2 ogetkerninfo() syscall to allow applications linked against their libc's uname() to work. Netscape 1.1N being a prime example, which prints: "uname() failed. cant tell what system we're running on". This change is a little ugly, but that's mainly because of the "interesting" semantics of the BSDI extension. Since ogetkerninfo() is only enabled by COMPAT_43, Netscape will only be affected on kernels with that option (eg: "GENERIC") Reviewed by: davidg
1995-07-09 02:49:30 +00:00
case KINFO_BSDI_SYSINFO: {
/*
* this is pretty crude, but it's just enough for uname()
* from BSDI's 1.x libc to work.
*
* In particular, it doesn't return the same results when
* the supplied buffer is too small. BSDI's version apparently
* will return the amount copied, and set the *size to how
* much was needed. The emulation framework here isn't capable
* of that, so we just set both to the amount copied.
* BSDI's 2.x product apparently fails with ENOMEM in this
* scenario.
*/
u_int needed;
u_int left;
char *s;
bzero((char *)&bsdi_si, sizeof(bsdi_si));
bzero(bsdi_strings, sizeof(bsdi_strings));
s = bsdi_strings;
bsdi_si.bsdi_ostype = (s - bsdi_strings) + sizeof(bsdi_si);
strcpy(s, ostype);
s += strlen(s) + 1;
bsdi_si.bsdi_osrelease = (s - bsdi_strings) + sizeof(bsdi_si);
strcpy(s, osrelease);
s += strlen(s) + 1;
bsdi_si.bsdi_machine = (s - bsdi_strings) + sizeof(bsdi_si);
strcpy(s, machine);
s += strlen(s) + 1;
needed = sizeof(bsdi_si) + (s - bsdi_strings);
if (uap->where == NULL) {
/* process is asking how much buffer to supply.. */
size = needed;
error = 0;
break;
}
/* if too much buffer supplied, trim it down */
if (size > needed)
size = needed;
/* how much of the buffer is remaining */
left = size;
if ((error = copyout((char *)&bsdi_si, uap->where, left)) != 0)
break;
/* is there any point in continuing? */
if (left > sizeof(bsdi_si)) {
left -= sizeof(bsdi_si);
error = copyout(&bsdi_strings,
uap->where + sizeof(bsdi_si), left);
}
break;
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
default:
return (EOPNOTSUPP);
}
if (error)
return (error);
*retval = size;
if (uap->size)
error = copyout((caddr_t)&size, (caddr_t)uap->size,
sizeof(size));
return (error);
}
#endif /* COMPAT_43 */
Reference in New Issue Copy Permalink