d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
95ceae8e7d
freebsd-skq/sys/kern/kern_sysctl.c

1389 lines
30 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
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
* $Id: kern_sysctl.c,v 1.37 1995/11/12 06:43:01 bde 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/malloc.h>
#include <sys/proc.h>
#include <sys/file.h>
#include <sys/vnode.h>
#include <sys/unistd.h>
#include <sys/buf.h>
#include <sys/ioctl.h>
#include <sys/tty.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 <vm/vm.h>
#include <sys/sysctl.h>
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
#include <sys/user.h>
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
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_MAXFILESPERPROC, maxfilesperproc,
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, &maxfilesperproc, 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
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_MAXFILES, maxfiles, CTLFLAG_RW, &maxfiles, 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
#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];
int hostnamelen;
static int
sysctl_kern_hostname SYSCTL_HANDLER_ARGS
{
int error = sysctl_handle_string(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);
if (req->newptr && (error == 0 || error == ENOMEM))
hostnamelen = req->newlen;
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;
}
SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname, CTLTYPE_STRING|CTLFLAG_RW,
&hostname, sizeof(hostname), sysctl_kern_hostname, "");
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];
int domainnamelen;
static int
sysctl_kern_domainname SYSCTL_HANDLER_ARGS
{
int error = sysctl_handle_string(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);
if (req->newptr && (error == 0 || error == ENOMEM))
domainnamelen = req->newlen;
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;
}
SYSCTL_PROC(_kern, KERN_DOMAINNAME, domainname, CTLTYPE_STRING|CTLFLAG_RW,
&domainname, sizeof(domainname), sysctl_kern_domainname, "");
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
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 (arg2)
error = SYSCTL_OUT(req, arg1, arg2);
else
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
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 ((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
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
sysctl_old_kernel(struct sysctl_req *req, void *p, int l)
{
int i = min(req->oldlen - req->oldidx, l);
if (i) {
bcopy(p, req->oldptr + req->oldidx, i);
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
}
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);
else
return (0);
}
int
sysctl_new_kernel(struct sysctl_req *req, void *p, int l)
{
int i = req->newlen - req->newidx;
if (i < l)
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
}
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
sysctl_old_user(struct sysctl_req *req, void *p, int l)
{
int error , i = min(req->oldlen - req->oldidx, l);
error = copyout(p, req->oldptr + req->oldidx, i);
req->oldidx += i;
if (error)
return (error);
if (i < l)
return (ENOMEM);
return (error);
}
int
sysctl_new_user(struct sysctl_req *req, void *p, int l)
{
int error, i = req->newlen - req->newidx;
if (i < l)
return (EINVAL);
error = copyin(req->newptr + req->newidx, p, l);
req->newidx += l;
return (error);
}
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
#ifdef DEBUG
static sysctlfn debug_sysctl;
#endif
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
/*
* Locking and stats
*/
static struct sysctl_lock {
int sl_lock;
int sl_want;
int sl_locked;
} memlock;
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.
* We work entirely in kernel-space at this time.
*/
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++;
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++;
}
}
return EJUSTRETURN;
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
__sysctl(p, uap, retval)
struct proc *p;
register struct sysctl_args *uap;
int *retval;
{
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[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);
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
return (userland_sysctl(p, name, uap->namelen,
uap->old, uap->oldlenp, 0,
uap->new, uap->newlen, retval));
}
convert more sysctl variables.
1995-11-10 09:58:53 +00:00
static sysctlfn kern_sysctl;
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)
{
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, dolock = 1, i, oldlen = 0;
u_int savelen = 0;
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
sysctlfn *fn;
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
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 {
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 = copyin(oldlenp, &req.oldlen,
sizeof(req.oldlen));
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
oldlen = req.oldlen;
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
}
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;
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
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 (!error || error == ENOMEM) {
Fix a minor buglet.
1995-11-10 16:22:41 +00:00
if (retval)
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
*retval = req.oldlen;
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
*oldlenp = req.oldlen;
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 {
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
i = copyout(&req.oldlen, oldlenp,
sizeof(req.oldlen));
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 (i)
error = i;
}
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);
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
switch (name[0]) {
case CTL_KERN:
fn = kern_sysctl;
sysctl incorrectly check name[2] instead of name[1]
1994-09-19 21:07:00 +00:00
if (name[1] != KERN_VNODE) /* XXX */
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
dolock = 0;
break;
case CTL_HW:
fn = hw_sysctl;
break;
case CTL_VM:
fn = vm_sysctl;
break;
case CTL_NET:
fn = net_sysctl;
break;
case CTL_FS:
fn = fs_sysctl;
break;
#ifdef DEBUG
case CTL_DEBUG:
fn = debug_sysctl;
break;
#endif
default:
return (EOPNOTSUPP);
}
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 (old != NULL) {
if (!useracc(old, oldlen, B_WRITE))
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (EFAULT);
while (memlock.sl_lock) {
memlock.sl_want = 1;
Use tsleep() rather than sleep so that 'ps' is more informative about the wait.
1994-10-06 21:07:04 +00:00
(void) tsleep((caddr_t)&memlock, PRIBIO+1, "sysctl", 0);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
memlock.sl_locked++;
}
memlock.sl_lock = 1;
if (dolock)
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
vslock(old, oldlen);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
savelen = oldlen;
}
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
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
error = (*fn)(name + 1, namelen - 1, old, &oldlen,
new, newlen, p);
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 (old != NULL) {
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if (dolock)
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
vsunlock(old, savelen, B_WRITE);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
memlock.sl_lock = 0;
if (memlock.sl_want) {
memlock.sl_want = 0;
wakeup((caddr_t)&memlock);
}
}
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
#if 0
if (error) {
printf("SYSCTL_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
for(i=0;i<namelen;i++)
Fix some of the sysctl broke, and add a lot more to it.
1995-11-08 08:48:36 +00:00
printf("%d ", name[i]);
printf("= %d\n", error);
}
#endif
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if (error)
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 (retval)
*retval = oldlen;
if (oldlenp) {
if (inkernel) {
*oldlenp = oldlen;
} else {
error = copyout(&oldlen, oldlenp, sizeof(oldlen));
}
}
return (error);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
/*
* Attributes stored in the kernel.
*/
Change default security level to -1, so that users don't get bitten by upcoming makefile change.
1994-08-10 02:41:09 +00:00
int securelevel = -1;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
/*
* kernel related system variables.
*/
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
static int
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
int *name;
u_int namelen;
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
struct proc *p;
{
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 error, level;
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
dev_t ndumpdev;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
/* all sysctl names at this level are terminal */
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF
|| name[0] == KERN_NTP_PLL))
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (ENOTDIR); /* overloaded */
switch (name[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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
case KERN_SECURELVL:
level = securelevel;
if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||
newp == NULL)
return (error);
if (level < securelevel && p->p_pid != 1)
return (EPERM);
securelevel = level;
return (0);
case KERN_VNODE:
return (sysctl_vnode(oldp, oldlenp));
case KERN_PROC:
return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp));
case KERN_FILE:
return (sysctl_file(oldp, oldlenp));
#ifdef GPROF
case KERN_PROF:
return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp,
newp, newlen));
#endif
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
case KERN_NTP_PLL:
return (ntp_sysctl(name + 1, namelen - 1, oldp, oldlenp,
newp, newlen, p));
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
case KERN_DUMPDEV:
ndumpdev = dumpdev;
error = sysctl_struct(oldp, oldlenp, newp, newlen, &ndumpdev,
sizeof ndumpdev);
if (!error && ndumpdev != dumpdev) {
error = setdumpdev(ndumpdev);
}
return error;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
/*
* hardware related system variables.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
int *name;
u_int namelen;
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
struct proc *p;
{
kern_clock.c: define dk_names[][]. kern_sysctl.c: call dev_sysctl for hw.devconf mib subtree kern_devconf.c: sysctl-accessible device-configuration and -management interface
1994-10-16 03:52:14 +00:00
/* almost all sysctl names at this level are terminal */
if (namelen != 1 && name[0] != HW_DEVCONF)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (ENOTDIR); /* overloaded */
switch (name[0]) {
case HW_PHYSMEM:
return (sysctl_rdint(oldp, oldlenp, newp, ctob(physmem)));
case HW_USERMEM:
return (sysctl_rdint(oldp, oldlenp, newp,
ctob(physmem - cnt.v_wire_count)));
kern_clock.c: define dk_names[][]. kern_sysctl.c: call dev_sysctl for hw.devconf mib subtree kern_devconf.c: sysctl-accessible device-configuration and -management interface
1994-10-16 03:52:14 +00:00
case HW_DEVCONF:
return (dev_sysctl(name + 1, namelen - 1, oldp, oldlenp,
newp, newlen, p));
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
#ifdef DEBUG
/*
* Debugging related system variables.
*/
struct ctldebug debug0, debug1, debug2, debug3, debug4;
struct ctldebug debug5, debug6, debug7, debug8, debug9;
struct ctldebug debug10, debug11, debug12, debug13, debug14;
struct ctldebug debug15, debug16, debug17, debug18, debug19;
static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = {
&debug0, &debug1, &debug2, &debug3, &debug4,
&debug5, &debug6, &debug7, &debug8, &debug9,
&debug10, &debug11, &debug12, &debug13, &debug14,
&debug15, &debug16, &debug17, &debug18, &debug19,
};
Move declarations of public functions to <sys/sysctl.h>. Make some private data static. Comment about MAXPATHLEN bytes of bloat for the kernel name.
1994-11-14 13:58:30 +00:00
static int
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
int *name;
u_int namelen;
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
struct proc *p;
{
struct ctldebug *cdp;
/* all sysctl names at this level are name and field */
if (namelen != 2)
return (ENOTDIR); /* overloaded */
cdp = debugvars[name[0]];
if (cdp->debugname == 0)
return (EOPNOTSUPP);
switch (name[1]) {
case CTL_DEBUG_NAME:
return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
case CTL_DEBUG_VALUE:
return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
#endif /* DEBUG */
/*
* Validate parameters and get old / set new parameters
* for an integer-valued sysctl function.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_int(oldp, oldlenp, newp, newlen, valp)
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
int *valp;
{
int error = 0;
if (oldp && *oldlenp < sizeof(int))
return (ENOMEM);
if (newp && newlen != sizeof(int))
return (EINVAL);
*oldlenp = sizeof(int);
if (oldp)
error = copyout(valp, oldp, sizeof(int));
if (error == 0 && newp)
error = copyin(newp, valp, sizeof(int));
return (error);
}
/*
* As above, but read-only.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_rdint(oldp, oldlenp, newp, val)
void *oldp;
size_t *oldlenp;
void *newp;
int val;
{
int error = 0;
if (oldp && *oldlenp < sizeof(int))
return (ENOMEM);
if (newp)
return (EPERM);
*oldlenp = sizeof(int);
if (oldp)
error = copyout((caddr_t)&val, oldp, sizeof(int));
return (error);
}
/*
* Validate parameters and get old / set new parameters
* for a string-valued sysctl function.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_string(oldp, oldlenp, newp, newlen, str, maxlen)
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
char *str;
int maxlen;
{
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
int len, error = 0, rval = 0;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
len = strlen(str) + 1;
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
if (oldp && *oldlenp < len) {
Fix bug in sysctl_string so that when a string has a length that is to short, it gets filled uop to its length. This matches the getdomainname and gethostname manual pages. (getbootfile also uses this function and I think it should have the same behaviour) This also fixes a bug with keyinit where the seed was not saved in /etc/skeykeys. So S/Key should be fully functional again. Reviewed by: Submitted by: Obtained from:
1994-12-18 13:56:50 +00:00
len = *oldlenp;
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
rval = ENOMEM;
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if (newp && newlen >= maxlen)
return (EINVAL);
if (oldp) {
*oldlenp = len;
error = copyout(str, oldp, len);
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
if (error)
rval = error;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
if ((error == 0 || error == ENOMEM) && newp) {
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
error = copyin(newp, str, newlen);
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
if (error)
rval = error;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
str[newlen] = 0;
}
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
return (rval);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
/*
* As above, but read-only.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_rdstring(oldp, oldlenp, newp, str)
void *oldp;
size_t *oldlenp;
void *newp;
char *str;
{
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
int len, error = 0, rval = 0;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
len = strlen(str) + 1;
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
if (oldp && *oldlenp < len) {
len = *oldlenp;
rval = ENOMEM;
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if (newp)
return (EPERM);
*oldlenp = len;
if (oldp)
error = copyout(str, oldp, len);
Fix the sysctl string routines to return as much of the string as possible and return ENOMEM if the entire string cannot be returned. This brings the routines in line with how the man page says they work, and how the calling routines are expecting them to work. This allows the dummy uname() routine in libc to obtain the version string, since the kernel version string is longer than that normally returned by the uname() routine. This is 3/4 of the fix for PR# 462. Reviewed by: Bruce Evans
1995-07-31 10:07:31 +00:00
if (error)
rval = error;
return (rval);
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
}
/*
* Validate parameters and get old / set new parameters
* for a structure oriented sysctl function.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_struct(oldp, oldlenp, newp, newlen, sp, len)
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
void *sp;
int len;
{
int error = 0;
if (oldp && *oldlenp < len)
return (ENOMEM);
if (newp && newlen > len)
return (EINVAL);
if (oldp) {
*oldlenp = len;
error = copyout(sp, oldp, len);
}
if (error == 0 && newp)
error = copyin(newp, sp, len);
return (error);
}
/*
* Validate parameters and get old parameters
* for a structure oriented sysctl function.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_rdstruct(oldp, oldlenp, newp, sp, len)
void *oldp;
size_t *oldlenp;
void *newp, *sp;
int len;
{
int error = 0;
if (oldp && *oldlenp < len)
return (ENOMEM);
if (newp)
return (EPERM);
*oldlenp = len;
if (oldp)
error = copyout(sp, oldp, len);
return (error);
}
/*
* Get file structures.
*/
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_file(where, sizep)
char *where;
size_t *sizep;
{
int buflen, error;
struct file *fp;
char *start = where;
buflen = *sizep;
if (where == NULL) {
/*
* overestimate by 10 files
*/
*sizep = sizeof(filehead) + (nfiles + 10) * sizeof(struct file);
return (0);
}
/*
* first copyout filehead
*/
if (buflen < sizeof(filehead)) {
*sizep = 0;
return (0);
}
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 = copyout((caddr_t)&filehead, where, sizeof(filehead));
if (error)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (error);
buflen -= sizeof(filehead);
where += sizeof(filehead);
/*
* followed by an array of file structures
*/
for (fp = filehead; fp != NULL; fp = fp->f_filef) {
if (buflen < sizeof(struct file)) {
*sizep = where - start;
return (ENOMEM);
}
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 = copyout((caddr_t)fp, where, sizeof (struct file));
if (error)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (error);
buflen -= sizeof(struct file);
where += sizeof(struct file);
}
*sizep = where - start;
return (0);
}
/*
* try over estimating by 5 procs
*/
#define KERN_PROCSLOP (5 * sizeof (struct kinfo_proc))
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
sysctl_doproc(name, namelen, where, sizep)
int *name;
u_int namelen;
char *where;
size_t *sizep;
{
register struct proc *p;
register struct kinfo_proc *dp = (struct kinfo_proc *)where;
register int needed = 0;
int buflen = where != NULL ? *sizep : 0;
int doingzomb;
struct eproc eproc;
int error = 0;
if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
return (EINVAL);
p = (struct proc *)allproc;
doingzomb = 0;
again:
for (; p != NULL; p = p->p_next) {
/*
* Skip embryonic processes.
*/
if (p->p_stat == SIDL)
continue;
/*
* TODO - make more efficient (see notes below).
* do by session.
*/
switch (name[0]) {
case KERN_PROC_PID:
/* could do this with just a lookup */
if (p->p_pid != (pid_t)name[1])
continue;
break;
case KERN_PROC_PGRP:
/* could do this by traversing pgrp */
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
if (p->p_pgrp == NULL || p->p_pgrp->pg_id != (pid_t)name[1])
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
continue;
break;
case KERN_PROC_TTY:
if ((p->p_flag & P_CONTROLT) == 0 ||
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
p->p_session == NULL ||
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
p->p_session->s_ttyp == NULL ||
p->p_session->s_ttyp->t_dev != (dev_t)name[1])
continue;
break;
case KERN_PROC_UID:
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
if (p->p_ucred == NULL || p->p_ucred->cr_uid != (uid_t)name[1])
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
continue;
break;
case KERN_PROC_RUID:
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
if (p->p_ucred == NULL || p->p_cred->p_ruid != (uid_t)name[1])
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
continue;
break;
}
if (buflen >= sizeof(struct kinfo_proc)) {
fill_eproc(p, &eproc);
Remove trailing whitespace.
1995-05-30 08:16:23 +00:00
error = copyout((caddr_t)p, &dp->kp_proc,
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
sizeof(struct proc));
if (error)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (error);
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 = copyout((caddr_t)&eproc, &dp->kp_eproc,
sizeof(eproc));
if (error)
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
return (error);
dp++;
buflen -= sizeof(struct kinfo_proc);
}
needed += sizeof(struct kinfo_proc);
}
if (doingzomb == 0) {
p = zombproc;
doingzomb++;
goto again;
}
if (where != NULL) {
*sizep = (caddr_t)dp - where;
if (needed > *sizep)
return (ENOMEM);
} else {
needed += KERN_PROCSLOP;
*sizep = needed;
}
return (0);
}
/*
* Fill in an eproc structure for the specified process.
*/
void
fill_eproc(p, ep)
register struct proc *p;
register struct eproc *ep;
{
register struct tty *tp;
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
bzero(ep, sizeof(*ep));
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
ep->e_paddr = p;
Fixed panic in fill_eproc() caused by inadequate checking for NULL pointers.
1995-07-28 18:04:47 +00:00
if (p->p_cred) {
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
ep->e_pcred = *p->p_cred;
Fixed panic in fill_eproc() caused by inadequate checking for NULL pointers.
1995-07-28 18:04:47 +00:00
if (p->p_ucred)
ep->e_ucred = *p->p_ucred;
}
if (p->p_stat != SIDL && p->p_stat != SZOMB && p->p_vmspace != NULL) {
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
register struct vmspace *vm = p->p_vmspace;
#ifdef pmap_resident_count
ep->e_vm.vm_rssize = pmap_resident_count(&vm->vm_pmap); /*XXX*/
#else
ep->e_vm.vm_rssize = vm->vm_rssize;
#endif
ep->e_vm.vm_tsize = vm->vm_tsize;
ep->e_vm.vm_dsize = vm->vm_dsize;
ep->e_vm.vm_ssize = vm->vm_ssize;
#ifndef sparc
ep->e_vm.vm_pmap = vm->vm_pmap;
#endif
}
if (p->p_pptr)
ep->e_ppid = p->p_pptr->p_pid;
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
if (p->p_pgrp) {
ep->e_sess = p->p_pgrp->pg_session;
ep->e_pgid = p->p_pgrp->pg_id;
ep->e_jobc = p->p_pgrp->pg_jobc;
}
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if ((p->p_flag & P_CONTROLT) &&
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
(ep->e_sess != NULL) &&
((tp = ep->e_sess->s_ttyp) != NULL)) {
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
ep->e_tdev = tp->t_dev;
ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
ep->e_tsess = tp->t_session;
} else
ep->e_tdev = NODEV;
Remove trailing whitespace.
1995-05-30 08:16:23 +00:00
if (ep->e_sess && ep->e_sess->s_ttyvp)
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
ep->e_flag = EPROC_CTTY;
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
if (SESS_LEADER(p))
ep->e_flag |= EPROC_SLEADER;
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
if (p->p_wmesg) {
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN);
Fixed multiple bugs that cause null pointers to be followed or FREEed data to be accessed if a process blocks when it is being run down.
1994-12-28 06:15:08 +00:00
ep->e_wmesg[WMESGLEN] = 0;
}
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
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
ogetkerninfo(p, uap, retval)
struct proc *p;
register struct getkerninfo_args *uap;
int *retval;
{
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,
0, 0, 0, 0);
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,
0, 0, 0, 0);
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,
0, 0, 0, 0);
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,
0, 0, 0, 0);
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,
0, 0, 0, 0);
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,
0, 0, 0, 0);
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,
0, 0, 0, 0);
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