d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
2a13a5af9f
freebsd-dev/sys/kern/kern_sysctl.c

854 lines
20 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.
*
* 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
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
* $Id: kern_sysctl.c,v 1.51 1995/11/16 18:59:49 phk Exp $
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
*/
/*
* sysctl system call.
*/
#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>
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_;
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
/* BEGIN_MIB */
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_MAXVNODES, maxvnodes, CTLFLAG_RD, &desiredvnodes, 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_STRUCT(_kern, KERN_BOOTTIME, boottime,
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, &boottime, timeval, "");
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_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 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
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
SYSCTL_STRING(_hw, HW_MODEL, model, CTLFLAG_RD, cpu_model, 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(_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
/* END_MIB */
extern int vfs_update_wakeup;
extern int vfs_update_interval;
static int
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
sysctl_kern_updateinterval 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
{
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 error = sysctl_handle_int(oidp,
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
oidp->oid_arg1, oidp->oid_arg2, req);
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
if (!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
wakeup(&vfs_update_wakeup);
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
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
}
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_PROC(_kern, KERN_UPDATEINTERVAL, update, CTLTYPE_INT|CTLFLAG_RW,
&vfs_update_interval, 0, sysctl_kern_updateinterval, "");
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,
0, 0, sysctl_kern_securelvl, "");
static int
sysctl_kern_dumpdev SYSCTL_HANDLER_ARGS
{
int error;
dev_t ndumpdev;
ndumpdev = dumpdev;
error = sysctl_handle_opaque(oidp, &ndumpdev, sizeof ndumpdev, req);
if (!error && ndumpdev != dumpdev) {
error = setdumpdev(ndumpdev);
}
return (error);
}
SYSCTL_PROC(_kern, KERN_DUMPDEV, dumpdev, CTLTYPE_OPAQUE|CTLFLAG_RW,
0, sizeof dumpdev, sysctl_kern_dumpdev, "");
static int
sysctl_hw_physmem SYSCTL_HANDLER_ARGS
{
int error = sysctl_handle_int(oidp, 0, ctob(physmem), req);
return (error);
}
SYSCTL_PROC(_hw, HW_PHYSMEM, physmem, CTLTYPE_INT|CTLFLAG_RD,
0, 0, sysctl_hw_physmem, "");
static int
sysctl_hw_usermem SYSCTL_HANDLER_ARGS
{
int error = sysctl_handle_int(oidp, 0,
ctob(physmem - cnt.v_wire_count), req);
return (error);
}
SYSCTL_PROC(_hw, HW_USERMEM, usermem, CTLTYPE_INT|CTLFLAG_RD,
0, 0, sysctl_hw_usermem, "");
/* END_MIB */
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)
{
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 j;
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;
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
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,
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
char domainname[MAXHOSTNAMELEN];
Get rid of domainnamelen.
1995-11-14 09:10:54 +00:00
SYSCTL_STRING(_kern, KERN_DOMAINNAME, domainname, CTLFLAG_RW,
&domainname, sizeof(domainname), "");
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
long hostid;
/* Some trouble here, if sizeof (int) != sizeof (long) */
SYSCTL_INT(_kern, KERN_HOSTID, hostid, CTLFLAG_RW, &hostid, 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
/*
* 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;
int namelen = arg2;
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