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.
|
|
|
|
*
|
1995-12-04 16:48:58 +00:00
|
|
|
* Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
|
|
|
|
* project, to make these variables more userfriendly.
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
#include "opt_capsicum.h"
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
2009-03-11 21:48:36 +00:00
|
|
|
#include "opt_ktrace.h"
|
1997-12-16 17:40:42 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
2010-11-29 18:18:07 +00:00
|
|
|
#include <sys/fail.h>
|
1999-06-27 11:44:22 +00:00
|
|
|
#include <sys/systm.h>
|
2014-03-16 10:55:57 +00:00
|
|
|
#include <sys/capsicum.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/sysctl.h>
|
1995-12-04 16:48:58 +00:00
|
|
|
#include <sys/malloc.h>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <sys/proc.h>
|
2009-06-17 15:01:01 +00:00
|
|
|
#include <sys/jail.h>
|
2001-09-01 18:19:21 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
2010-09-16 16:13:12 +00:00
|
|
|
#include <sys/sbuf.h>
|
2002-04-02 04:20:38 +00:00
|
|
|
#include <sys/sx.h>
|
1996-04-07 13:03:06 +00:00
|
|
|
#include <sys/sysproto.h>
|
2008-12-12 12:06:28 +00:00
|
|
|
#include <sys/uio.h>
|
2009-03-11 21:48:36 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
#endif
|
2006-10-22 11:52:19 +00:00
|
|
|
|
Build on Jeff Roberson's linker-set based dynamic per-CPU allocator
(DPCPU), as suggested by Peter Wemm, and implement a new per-virtual
network stack memory allocator. Modify vnet to use the allocator
instead of monolithic global container structures (vinet, ...). This
change solves many binary compatibility problems associated with
VIMAGE, and restores ELF symbols for virtualized global variables.
Each virtualized global variable exists as a "reference copy", and also
once per virtual network stack. Virtualized global variables are
tagged at compile-time, placing the in a special linker set, which is
loaded into a contiguous region of kernel memory. Virtualized global
variables in the base kernel are linked as normal, but those in modules
are copied and relocated to a reserved portion of the kernel's vnet
region with the help of a the kernel linker.
Virtualized global variables exist in per-vnet memory set up when the
network stack instance is created, and are initialized statically from
the reference copy. Run-time access occurs via an accessor macro, which
converts from the current vnet and requested symbol to a per-vnet
address. When "options VIMAGE" is not compiled into the kernel, normal
global ELF symbols will be used instead and indirection is avoided.
This change restores static initialization for network stack global
variables, restores support for non-global symbols and types, eliminates
the need for many subsystem constructors, eliminates large per-subsystem
structures that caused many binary compatibility issues both for
monitoring applications (netstat) and kernel modules, removes the
per-function INIT_VNET_*() macros throughout the stack, eliminates the
need for vnet_symmap ksym(2) munging, and eliminates duplicate
definitions of virtualized globals under VIMAGE_GLOBALS.
Bump __FreeBSD_version and update UPDATING.
Portions submitted by: bz
Reviewed by: bz, zec
Discussed with: gnn, jamie, jeff, jhb, julian, sam
Suggested by: peter
Approved by: re (kensmith)
2009-07-14 22:48:30 +00:00
|
|
|
#include <net/vnet.h>
|
|
|
|
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
|
|
|
|
1995-12-05 21:51:45 +00:00
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_extern.h>
|
1995-12-05 21:51:45 +00:00
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic");
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids");
|
2002-07-28 21:06:14 +00:00
|
|
|
static MALLOC_DEFINE(M_SYSCTLTMP, "sysctltmp", "sysctl temp output buffer");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
1995-11-20 12:42:39 +00:00
|
|
|
/*
|
2009-02-06 14:51:32 +00:00
|
|
|
* The sysctllock protects the MIB tree. It also protects sysctl
|
|
|
|
* contexts used with dynamic sysctls. The sysctl_register_oid() and
|
|
|
|
* sysctl_unregister_oid() routines require the sysctllock to already
|
|
|
|
* be held, so the sysctl_lock() and sysctl_unlock() routines are
|
|
|
|
* provided for the few places in the kernel which need to use that
|
|
|
|
* API rather than using the dynamic API. Use of the dynamic API is
|
|
|
|
* strongly encouraged for most code.
|
|
|
|
*
|
2009-05-14 22:01:32 +00:00
|
|
|
* The sysctlmemlock is used to limit the amount of user memory wired for
|
|
|
|
* sysctl requests. This is implemented by serializing any userland
|
|
|
|
* sysctl requests larger than a single page via an exclusive lock.
|
1995-11-20 12:42:39 +00:00
|
|
|
*/
|
2002-04-02 05:50:07 +00:00
|
|
|
static struct sx sysctllock;
|
2009-05-14 22:01:32 +00:00
|
|
|
static struct sx sysctlmemlock;
|
2002-04-02 04:20:38 +00:00
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
#define SYSCTL_XLOCK() sx_xlock(&sysctllock)
|
|
|
|
#define SYSCTL_XUNLOCK() sx_xunlock(&sysctllock)
|
|
|
|
#define SYSCTL_ASSERT_XLOCKED() sx_assert(&sysctllock, SA_XLOCKED)
|
2003-03-11 20:01:51 +00:00
|
|
|
#define SYSCTL_INIT() sx_init(&sysctllock, "sysctl lock")
|
2010-11-29 18:18:07 +00:00
|
|
|
#define SYSCTL_SLEEP(ch, wmesg, timo) \
|
|
|
|
sx_sleep(ch, &sysctllock, 0, wmesg, timo)
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2000-07-04 11:25:35 +00:00
|
|
|
static int sysctl_root(SYSCTL_HANDLER_ARGS);
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2014-06-28 03:56:17 +00:00
|
|
|
/* Root list */
|
|
|
|
struct sysctl_oid_list sysctl__children = SLIST_HEAD_INITIALIZER(&sysctl__children);
|
1995-11-08 08:48:36 +00:00
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
static int sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del,
|
|
|
|
int recurse);
|
2014-06-28 03:56:17 +00:00
|
|
|
static int sysctl_old_kernel(struct sysctl_req *, const void *, size_t);
|
|
|
|
static int sysctl_new_kernel(struct sysctl_req *, void *, size_t);
|
2009-02-06 14:51:32 +00:00
|
|
|
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
static struct sysctl_oid *
|
|
|
|
sysctl_find_oidname(const char *name, struct sysctl_oid_list *list)
|
|
|
|
{
|
|
|
|
struct sysctl_oid *oidp;
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
SLIST_FOREACH(oidp, list, oid_link) {
|
|
|
|
if (strcmp(oidp->oid_name, name) == 0) {
|
|
|
|
return (oidp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
/*
|
|
|
|
* Initialization of the MIB tree.
|
|
|
|
*
|
1999-02-16 10:49:55 +00:00
|
|
|
* Order by number in each list.
|
1995-12-04 16:48:58 +00:00
|
|
|
*/
|
2009-02-06 14:51:32 +00:00
|
|
|
void
|
|
|
|
sysctl_lock(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
SYSCTL_XLOCK();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
sysctl_unlock(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
SYSCTL_XUNLOCK();
|
|
|
|
}
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2014-06-28 03:56:17 +00:00
|
|
|
static int
|
|
|
|
sysctl_root_handler_locked(struct sysctl_oid *oid, void *arg1, intptr_t arg2,
|
|
|
|
struct sysctl_req *req)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
oid->oid_running++;
|
|
|
|
SYSCTL_XUNLOCK();
|
|
|
|
|
|
|
|
if (!(oid->oid_kind & CTLFLAG_MPSAFE))
|
|
|
|
mtx_lock(&Giant);
|
|
|
|
error = oid->oid_handler(oid, arg1, arg2, req);
|
|
|
|
if (!(oid->oid_kind & CTLFLAG_MPSAFE))
|
|
|
|
mtx_unlock(&Giant);
|
|
|
|
|
|
|
|
SYSCTL_XLOCK();
|
|
|
|
oid->oid_running--;
|
|
|
|
if (oid->oid_running == 0 && (oid->oid_kind & CTLFLAG_DYING) != 0)
|
|
|
|
wakeup(&oid->oid_running);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
sysctl_load_tunable_by_oid_locked(struct sysctl_oid *oidp)
|
|
|
|
{
|
|
|
|
struct sysctl_req req;
|
|
|
|
struct sysctl_oid *curr;
|
2014-07-05 06:12:48 +00:00
|
|
|
char *penv = NULL;
|
2014-06-28 03:56:17 +00:00
|
|
|
char path[64];
|
|
|
|
ssize_t rem = sizeof(path);
|
|
|
|
ssize_t len;
|
|
|
|
int val_int;
|
|
|
|
long val_long;
|
|
|
|
int64_t val_64;
|
2014-07-05 06:12:48 +00:00
|
|
|
quad_t val_quad;
|
2014-06-28 03:56:17 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
path[--rem] = 0;
|
|
|
|
|
|
|
|
for (curr = oidp; curr != NULL; curr = SYSCTL_PARENT(curr)) {
|
|
|
|
len = strlen(curr->oid_name);
|
|
|
|
rem -= len;
|
|
|
|
if (curr != oidp)
|
|
|
|
rem -= 1;
|
|
|
|
if (rem < 0) {
|
|
|
|
printf("OID path exceeds %d bytes\n", (int)sizeof(path));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memcpy(path + rem, curr->oid_name, len);
|
|
|
|
if (curr != oidp)
|
|
|
|
path[rem + len] = '.';
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
|
|
|
|
req.td = curthread;
|
|
|
|
req.oldfunc = sysctl_old_kernel;
|
|
|
|
req.newfunc = sysctl_new_kernel;
|
|
|
|
req.lock = REQ_UNWIRED;
|
|
|
|
|
|
|
|
switch (oidp->oid_kind & CTLTYPE) {
|
|
|
|
case CTLTYPE_INT:
|
2014-07-05 06:12:48 +00:00
|
|
|
if (getenv_int(path + rem, &val_int) == 0)
|
|
|
|
return;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = sizeof(val_int);
|
|
|
|
req.newptr = &val_int;
|
|
|
|
break;
|
|
|
|
case CTLTYPE_UINT:
|
2014-07-05 06:12:48 +00:00
|
|
|
if (getenv_uint(path + rem, (unsigned int *)&val_int) == 0)
|
|
|
|
return;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = sizeof(val_int);
|
|
|
|
req.newptr = &val_int;
|
|
|
|
break;
|
|
|
|
case CTLTYPE_LONG:
|
2014-07-05 06:12:48 +00:00
|
|
|
if (getenv_long(path + rem, &val_long) == 0)
|
|
|
|
return;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = sizeof(val_long);
|
|
|
|
req.newptr = &val_long;
|
|
|
|
break;
|
|
|
|
case CTLTYPE_ULONG:
|
2014-07-05 06:12:48 +00:00
|
|
|
if (getenv_ulong(path + rem, (unsigned long *)&val_long) == 0)
|
|
|
|
return;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = sizeof(val_long);
|
|
|
|
req.newptr = &val_long;
|
|
|
|
break;
|
|
|
|
case CTLTYPE_S64:
|
2014-07-05 06:12:48 +00:00
|
|
|
if (getenv_quad(path + rem, &val_quad) == 0)
|
|
|
|
return;
|
|
|
|
val_64 = val_quad;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = sizeof(val_64);
|
|
|
|
req.newptr = &val_64;
|
|
|
|
break;
|
|
|
|
case CTLTYPE_U64:
|
2014-07-05 06:12:48 +00:00
|
|
|
/* XXX there is no getenv_uquad() */
|
|
|
|
if (getenv_quad(path + rem, &val_quad) == 0)
|
|
|
|
return;
|
|
|
|
val_64 = val_quad;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = sizeof(val_64);
|
|
|
|
req.newptr = &val_64;
|
|
|
|
break;
|
|
|
|
case CTLTYPE_STRING:
|
2014-07-05 06:12:48 +00:00
|
|
|
penv = getenv(path + rem);
|
|
|
|
if (penv == NULL)
|
|
|
|
return;
|
2014-06-28 03:56:17 +00:00
|
|
|
req.newlen = strlen(penv);
|
|
|
|
req.newptr = penv;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
error = sysctl_root_handler_locked(oidp, oidp->oid_arg1,
|
|
|
|
oidp->oid_arg2, &req);
|
|
|
|
if (error != 0) {
|
|
|
|
printf("Setting sysctl '%s' to '%s' failed: %d\n",
|
|
|
|
path, penv, error);
|
|
|
|
}
|
|
|
|
freeenv(penv);
|
|
|
|
}
|
|
|
|
|
2001-07-25 17:13:58 +00:00
|
|
|
void
|
|
|
|
sysctl_register_oid(struct sysctl_oid *oidp)
|
1995-11-08 08:48:36 +00:00
|
|
|
{
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid_list *parent = oidp->oid_parent;
|
|
|
|
struct sysctl_oid *p;
|
|
|
|
struct sysctl_oid *q;
|
|
|
|
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
/*
|
|
|
|
* First check if another oid with the same name already
|
|
|
|
* exists in the parent's list.
|
|
|
|
*/
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
p = sysctl_find_oidname(oidp->oid_name, parent);
|
|
|
|
if (p != NULL) {
|
|
|
|
if ((p->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
|
|
|
p->oid_refcnt++;
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
printf("can't re-use a leaf (%s)!\n", p->oid_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
1999-02-16 10:49:55 +00:00
|
|
|
/*
|
|
|
|
* If this oid has a number OID_AUTO, give it a number which
|
2001-07-25 17:21:18 +00:00
|
|
|
* is greater than any current oid.
|
|
|
|
* NOTE: DO NOT change the starting value here, change it in
|
|
|
|
* <sys/sysctl.h>, and make sure it is at least 256 to
|
|
|
|
* accomodate e.g. net.inet.raw as a static sysctl node.
|
1999-02-16 10:49:55 +00:00
|
|
|
*/
|
|
|
|
if (oidp->oid_number == OID_AUTO) {
|
2001-07-25 17:21:18 +00:00
|
|
|
static int newoid = CTL_AUTO_START;
|
2001-01-24 04:35:13 +00:00
|
|
|
|
|
|
|
oidp->oid_number = newoid++;
|
|
|
|
if (newoid == 0x7fffffff)
|
|
|
|
panic("out of oids");
|
1999-02-16 10:49:55 +00:00
|
|
|
}
|
2001-10-12 09:16:36 +00:00
|
|
|
#if 0
|
|
|
|
else if (oidp->oid_number >= CTL_AUTO_START) {
|
|
|
|
/* do not panic; this happens when unregistering sysctl sets */
|
|
|
|
printf("static sysctl oid too high: %d", oidp->oid_number);
|
|
|
|
}
|
|
|
|
#endif
|
1995-11-11 00:09:21 +00:00
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
/*
|
|
|
|
* Insert the oid into the parent's list in order.
|
|
|
|
*/
|
|
|
|
q = NULL;
|
|
|
|
SLIST_FOREACH(p, parent, oid_link) {
|
|
|
|
if (oidp->oid_number < p->oid_number)
|
|
|
|
break;
|
|
|
|
q = p;
|
|
|
|
}
|
|
|
|
if (q)
|
|
|
|
SLIST_INSERT_AFTER(q, oidp, oid_link);
|
|
|
|
else
|
|
|
|
SLIST_INSERT_HEAD(parent, oidp, oid_link);
|
2014-06-28 03:56:17 +00:00
|
|
|
|
|
|
|
if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE &&
|
|
|
|
#ifdef VIMAGE
|
|
|
|
(oidp->oid_kind & CTLFLAG_VNET) == 0 &&
|
|
|
|
#endif
|
|
|
|
(oidp->oid_kind & CTLFLAG_TUN) != 0 &&
|
|
|
|
(oidp->oid_kind & CTLFLAG_NOFETCH) == 0) {
|
|
|
|
sysctl_load_tunable_by_oid_locked(oidp);
|
|
|
|
}
|
1995-11-08 08:48:36 +00:00
|
|
|
}
|
|
|
|
|
2001-07-25 17:13:58 +00:00
|
|
|
void
|
|
|
|
sysctl_unregister_oid(struct sysctl_oid *oidp)
|
1995-11-08 08:48:36 +00:00
|
|
|
{
|
2003-05-29 21:19:18 +00:00
|
|
|
struct sysctl_oid *p;
|
|
|
|
int error;
|
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
2003-05-29 21:19:18 +00:00
|
|
|
error = ENOENT;
|
|
|
|
if (oidp->oid_number == OID_AUTO) {
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
SLIST_FOREACH(p, oidp->oid_parent, oid_link) {
|
|
|
|
if (p == oidp) {
|
|
|
|
SLIST_REMOVE(oidp->oid_parent, oidp,
|
|
|
|
sysctl_oid, oid_link);
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This can happen when a module fails to register and is
|
|
|
|
* being unloaded afterwards. It should not be a panic()
|
|
|
|
* for normal use.
|
|
|
|
*/
|
|
|
|
if (error)
|
|
|
|
printf("%s: failed to unregister sysctl\n", __func__);
|
1999-02-16 10:49:55 +00:00
|
|
|
}
|
1995-12-04 16:48:58 +00:00
|
|
|
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
/* Initialize a new context to keep track of dynamically added sysctls. */
|
|
|
|
int
|
|
|
|
sysctl_ctx_init(struct sysctl_ctx_list *c)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (c == NULL) {
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
2009-02-06 14:51:32 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* No locking here, the caller is responsible for not adding
|
|
|
|
* new nodes to a context until after this function has
|
|
|
|
* returned.
|
|
|
|
*/
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
TAILQ_INIT(c);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free the context, and destroy all dynamic oids registered in this context */
|
|
|
|
int
|
|
|
|
sysctl_ctx_free(struct sysctl_ctx_list *clist)
|
|
|
|
{
|
|
|
|
struct sysctl_ctx_entry *e, *e1;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
/*
|
|
|
|
* First perform a "dry run" to check if it's ok to remove oids.
|
|
|
|
* XXX FIXME
|
|
|
|
* XXX This algorithm is a hack. But I don't know any
|
|
|
|
* XXX better solution for now...
|
|
|
|
*/
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
TAILQ_FOREACH(e, clist, link) {
|
2009-02-06 14:51:32 +00:00
|
|
|
error = sysctl_remove_oid_locked(e->entry, 0, 0);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Restore deregistered entries, either from the end,
|
|
|
|
* or from the place where error occured.
|
|
|
|
* e contains the entry that was not unregistered
|
|
|
|
*/
|
|
|
|
if (error)
|
|
|
|
e1 = TAILQ_PREV(e, sysctl_ctx_list, link);
|
|
|
|
else
|
|
|
|
e1 = TAILQ_LAST(clist, sysctl_ctx_list);
|
|
|
|
while (e1 != NULL) {
|
|
|
|
sysctl_register_oid(e1->entry);
|
|
|
|
e1 = TAILQ_PREV(e1, sysctl_ctx_list, link);
|
|
|
|
}
|
2009-02-06 14:51:32 +00:00
|
|
|
if (error) {
|
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
return(EBUSY);
|
2009-02-06 14:51:32 +00:00
|
|
|
}
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
/* Now really delete the entries */
|
|
|
|
e = TAILQ_FIRST(clist);
|
|
|
|
while (e != NULL) {
|
|
|
|
e1 = TAILQ_NEXT(e, link);
|
2009-02-06 14:51:32 +00:00
|
|
|
error = sysctl_remove_oid_locked(e->entry, 1, 0);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if (error)
|
|
|
|
panic("sysctl_remove_oid: corrupt tree, entry: %s",
|
|
|
|
e->entry->oid_name);
|
|
|
|
free(e, M_SYSCTLOID);
|
|
|
|
e = e1;
|
|
|
|
}
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an entry to the context */
|
|
|
|
struct sysctl_ctx_entry *
|
|
|
|
sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
|
|
|
|
{
|
|
|
|
struct sysctl_ctx_entry *e;
|
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if (clist == NULL || oidp == NULL)
|
|
|
|
return(NULL);
|
2003-02-19 05:47:46 +00:00
|
|
|
e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
e->entry = oidp;
|
|
|
|
TAILQ_INSERT_HEAD(clist, e, link);
|
|
|
|
return (e);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find an entry in the context */
|
|
|
|
struct sysctl_ctx_entry *
|
|
|
|
sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
|
|
|
|
{
|
|
|
|
struct sysctl_ctx_entry *e;
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if (clist == NULL || oidp == NULL)
|
|
|
|
return(NULL);
|
2001-02-04 13:13:25 +00:00
|
|
|
TAILQ_FOREACH(e, clist, link) {
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if(e->entry == oidp)
|
|
|
|
return(e);
|
|
|
|
}
|
|
|
|
return (e);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete an entry from the context.
|
|
|
|
* NOTE: this function doesn't free oidp! You have to remove it
|
|
|
|
* with sysctl_remove_oid().
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
|
|
|
|
{
|
|
|
|
struct sysctl_ctx_entry *e;
|
|
|
|
|
|
|
|
if (clist == NULL || oidp == NULL)
|
|
|
|
return (EINVAL);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
e = sysctl_ctx_entry_find(clist, oidp);
|
|
|
|
if (e != NULL) {
|
|
|
|
TAILQ_REMOVE(clist, e, link);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
free(e, M_SYSCTLOID);
|
|
|
|
return (0);
|
2009-02-06 14:51:32 +00:00
|
|
|
} else {
|
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
return (ENOENT);
|
2009-02-06 14:51:32 +00:00
|
|
|
}
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove dynamically created sysctl trees.
|
|
|
|
* oidp - top of the tree to be removed
|
|
|
|
* del - if 0 - just deregister, otherwise free up entries as well
|
|
|
|
* recurse - if != 0 traverse the subtree to be deleted
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
sysctl_remove_oid(struct sysctl_oid *oidp, int del, int recurse)
|
2009-02-06 14:51:32 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
SYSCTL_XLOCK();
|
|
|
|
error = sysctl_remove_oid_locked(oidp, del, recurse);
|
|
|
|
SYSCTL_XUNLOCK();
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-03-21 09:40:01 +00:00
|
|
|
int
|
|
|
|
sysctl_remove_name(struct sysctl_oid *parent, const char *name,
|
|
|
|
int del, int recurse)
|
|
|
|
{
|
|
|
|
struct sysctl_oid *p, *tmp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = ENOENT;
|
|
|
|
SYSCTL_XLOCK();
|
|
|
|
SLIST_FOREACH_SAFE(p, SYSCTL_CHILDREN(parent), oid_link, tmp) {
|
|
|
|
if (strcmp(p->oid_name, name) == 0) {
|
|
|
|
error = sysctl_remove_oid_locked(p, del, recurse);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SYSCTL_XUNLOCK();
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
static int
|
|
|
|
sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del, int recurse)
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
{
|
2011-03-21 09:40:01 +00:00
|
|
|
struct sysctl_oid *p, *tmp;
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
int error;
|
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if (oidp == NULL)
|
|
|
|
return(EINVAL);
|
|
|
|
if ((oidp->oid_kind & CTLFLAG_DYN) == 0) {
|
|
|
|
printf("can't remove non-dynamic nodes!\n");
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* WARNING: normal method to do this should be through
|
|
|
|
* sysctl_ctx_free(). Use recursing as the last resort
|
|
|
|
* method to purge your sysctl tree of leftovers...
|
|
|
|
* However, if some other code still references these nodes,
|
|
|
|
* it will panic.
|
|
|
|
*/
|
|
|
|
if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
|
|
|
if (oidp->oid_refcnt == 1) {
|
2011-03-21 09:40:01 +00:00
|
|
|
SLIST_FOREACH_SAFE(p,
|
|
|
|
SYSCTL_CHILDREN(oidp), oid_link, tmp) {
|
2013-08-09 01:04:44 +00:00
|
|
|
if (!recurse) {
|
|
|
|
printf("Warning: failed attempt to "
|
|
|
|
"remove oid %s with child %s\n",
|
|
|
|
oidp->oid_name, p->oid_name);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
return (ENOTEMPTY);
|
2013-08-09 01:04:44 +00:00
|
|
|
}
|
2009-02-06 14:51:32 +00:00
|
|
|
error = sysctl_remove_oid_locked(p, del,
|
|
|
|
recurse);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (oidp->oid_refcnt > 1 ) {
|
|
|
|
oidp->oid_refcnt--;
|
|
|
|
} else {
|
|
|
|
if (oidp->oid_refcnt == 0) {
|
|
|
|
printf("Warning: bad oid_refcnt=%u (%s)!\n",
|
|
|
|
oidp->oid_refcnt, oidp->oid_name);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
sysctl_unregister_oid(oidp);
|
|
|
|
if (del) {
|
2010-11-29 18:18:07 +00:00
|
|
|
/*
|
|
|
|
* Wait for all threads running the handler to drain.
|
|
|
|
* This preserves the previous behavior when the
|
|
|
|
* sysctl lock was held across a handler invocation,
|
|
|
|
* and is necessary for module unload correctness.
|
|
|
|
*/
|
|
|
|
while (oidp->oid_running > 0) {
|
|
|
|
oidp->oid_kind |= CTLFLAG_DYING;
|
|
|
|
SYSCTL_SLEEP(&oidp->oid_running, "oidrm", 0);
|
|
|
|
}
|
2005-02-07 07:40:39 +00:00
|
|
|
if (oidp->oid_descr)
|
2013-03-01 18:49:14 +00:00
|
|
|
free(__DECONST(char *, oidp->oid_descr),
|
|
|
|
M_SYSCTLOID);
|
|
|
|
free(__DECONST(char *, oidp->oid_name), M_SYSCTLOID);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
free(oidp, M_SYSCTLOID);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Create new sysctls at run time.
|
|
|
|
* clist may point to a valid context initialized with sysctl_ctx_init().
|
|
|
|
*/
|
|
|
|
struct sysctl_oid *
|
|
|
|
sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
|
2011-03-21 09:40:01 +00:00
|
|
|
int number, const char *name, int kind, void *arg1, intptr_t arg2,
|
2001-01-05 07:00:45 +00:00
|
|
|
int (*handler)(SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr)
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
{
|
|
|
|
struct sysctl_oid *oidp;
|
|
|
|
|
|
|
|
/* You have to hook up somewhere.. */
|
|
|
|
if (parent == NULL)
|
|
|
|
return(NULL);
|
|
|
|
/* Check if the node already exists, otherwise create it */
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
oidp = sysctl_find_oidname(name, parent);
|
|
|
|
if (oidp != NULL) {
|
|
|
|
if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
|
|
|
oidp->oid_refcnt++;
|
|
|
|
/* Update the context */
|
|
|
|
if (clist != NULL)
|
|
|
|
sysctl_ctx_entry_add(clist, oidp);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
return (oidp);
|
|
|
|
} else {
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
printf("can't re-use a leaf (%s)!\n", name);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
}
|
2003-02-19 05:47:46 +00:00
|
|
|
oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK|M_ZERO);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
oidp->oid_parent = parent;
|
2014-06-28 03:56:17 +00:00
|
|
|
SLIST_INIT(&oidp->oid_children);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
oidp->oid_number = number;
|
|
|
|
oidp->oid_refcnt = 1;
|
2013-03-01 18:49:14 +00:00
|
|
|
oidp->oid_name = strdup(name, M_SYSCTLOID);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
oidp->oid_handler = handler;
|
|
|
|
oidp->oid_kind = CTLFLAG_DYN | kind;
|
2014-06-28 03:56:17 +00:00
|
|
|
oidp->oid_arg1 = arg1;
|
|
|
|
oidp->oid_arg2 = arg2;
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
oidp->oid_fmt = fmt;
|
2014-06-28 03:56:17 +00:00
|
|
|
if (descr != NULL)
|
2013-03-01 18:49:14 +00:00
|
|
|
oidp->oid_descr = strdup(descr, M_SYSCTLOID);
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
/* Update the context, if used */
|
|
|
|
if (clist != NULL)
|
|
|
|
sysctl_ctx_entry_add(clist, oidp);
|
|
|
|
/* Register this oid */
|
|
|
|
sysctl_register_oid(oidp);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
These patches implement dynamic sysctls. It's possible now to add
and remove sysctl oids at will during runtime - they don't rely on
linker sets. Also, the node oids can be referenced by more than
one kernel user, which means that it's possible to create partially
overlapping trees.
Add sysctl contexts to help programmers manage multiple dynamic
oids in convenient way.
Please see the manpages for detailed discussion, and example module
for typical use.
This work is based on ideas and code snippets coming from many
people, among them: Arun Sharma, Jonathan Lemon, Doug Rabson,
Brian Feldman, Kelly Yancey, Poul-Henning Kamp and others. I'd like
to specially thank Brian Feldman for detailed review and style
fixes.
PR: kern/16928
Reviewed by: dfr, green, phk
2000-07-15 10:26:04 +00:00
|
|
|
return (oidp);
|
|
|
|
}
|
|
|
|
|
2007-11-30 21:29:08 +00:00
|
|
|
/*
|
|
|
|
* Rename an existing oid.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
sysctl_rename_oid(struct sysctl_oid *oidp, const char *name)
|
|
|
|
{
|
|
|
|
char *newname;
|
2013-03-01 18:49:14 +00:00
|
|
|
char *oldname;
|
2007-11-30 21:29:08 +00:00
|
|
|
|
2013-03-01 18:49:14 +00:00
|
|
|
newname = strdup(name, M_SYSCTLOID);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XLOCK();
|
2013-03-01 18:49:14 +00:00
|
|
|
oldname = __DECONST(char *, oidp->oid_name);
|
2007-11-30 21:29:08 +00:00
|
|
|
oidp->oid_name = newname;
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
2007-11-30 21:29:08 +00:00
|
|
|
free(oldname, M_SYSCTLOID);
|
|
|
|
}
|
|
|
|
|
2004-02-27 17:13:23 +00:00
|
|
|
/*
|
|
|
|
* Reparent an existing oid.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
sysctl_move_oid(struct sysctl_oid *oid, struct sysctl_oid_list *parent)
|
|
|
|
{
|
|
|
|
struct sysctl_oid *oidp;
|
|
|
|
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XLOCK();
|
|
|
|
if (oid->oid_parent == parent) {
|
|
|
|
SYSCTL_XUNLOCK();
|
2004-02-27 17:13:23 +00:00
|
|
|
return (0);
|
2009-02-06 14:51:32 +00:00
|
|
|
}
|
2004-02-27 17:13:23 +00:00
|
|
|
oidp = sysctl_find_oidname(oid->oid_name, parent);
|
2009-02-06 14:51:32 +00:00
|
|
|
if (oidp != NULL) {
|
|
|
|
SYSCTL_XUNLOCK();
|
2004-02-27 17:13:23 +00:00
|
|
|
return (EEXIST);
|
2009-02-06 14:51:32 +00:00
|
|
|
}
|
2004-02-27 17:13:23 +00:00
|
|
|
sysctl_unregister_oid(oid);
|
|
|
|
oid->oid_parent = parent;
|
|
|
|
oid->oid_number = OID_AUTO;
|
|
|
|
sysctl_register_oid(oid);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
2004-02-27 17:13:23 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
/*
|
|
|
|
* Register the kernel's oids on startup.
|
|
|
|
*/
|
2001-06-13 10:58:39 +00:00
|
|
|
SET_DECLARE(sysctl_set, struct sysctl_oid);
|
1995-11-08 08:48:36 +00:00
|
|
|
|
2001-07-25 17:13:58 +00:00
|
|
|
static void
|
|
|
|
sysctl_register_all(void *arg)
|
1998-09-05 17:13:28 +00:00
|
|
|
{
|
2001-06-13 10:58:39 +00:00
|
|
|
struct sysctl_oid **oidp;
|
1998-09-05 17:13:28 +00:00
|
|
|
|
2009-05-14 22:01:32 +00:00
|
|
|
sx_init(&sysctlmemlock, "sysctl mem");
|
2002-04-02 05:50:07 +00:00
|
|
|
SYSCTL_INIT();
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XLOCK();
|
2001-06-13 10:58:39 +00:00
|
|
|
SET_FOREACH(oidp, sysctl_set)
|
|
|
|
sysctl_register_oid(*oidp);
|
2009-02-06 14:51:32 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
2001-06-13 10:58:39 +00:00
|
|
|
}
|
2014-06-28 03:56:17 +00:00
|
|
|
SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_FIRST, sysctl_register_all, 0);
|
1999-02-16 10:49:55 +00:00
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
/*
|
|
|
|
* "Staff-functions"
|
|
|
|
*
|
1995-12-06 13:27:39 +00:00
|
|
|
* These functions implement a presently undocumented interface
|
|
|
|
* used by the sysctl program to walk the tree, and get the type
|
|
|
|
* so it can print the value.
|
|
|
|
* This interface is under work and consideration, and should probably
|
|
|
|
* be killed with a big axe by the first person who can find the time.
|
|
|
|
* (be aware though, that the proper interface isn't as obvious as it
|
|
|
|
* may seem, there are various conflicting requirements.
|
|
|
|
*
|
1995-12-04 16:48:58 +00:00
|
|
|
* {0,0} printf the entire MIB-tree.
|
|
|
|
* {0,1,...} return the name of the "..." OID.
|
1999-01-10 07:45:33 +00:00
|
|
|
* {0,2,...} return the next OID.
|
1995-12-04 16:48:58 +00:00
|
|
|
* {0,3} return the OID of the name in "new"
|
1995-12-06 13:27:39 +00:00
|
|
|
* {0,4,...} return the kind & format info for the "..." OID.
|
2001-12-16 02:55:41 +00:00
|
|
|
* {0,5,...} return the description the "..." OID.
|
1995-12-04 16:48:58 +00:00
|
|
|
*/
|
|
|
|
|
2004-10-27 19:26:01 +00:00
|
|
|
#ifdef SYSCTL_DEBUG
|
1995-11-08 08:48:36 +00:00
|
|
|
static void
|
1999-02-16 10:49:55 +00:00
|
|
|
sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i)
|
1995-11-08 08:48:36 +00:00
|
|
|
{
|
1999-02-16 10:49:55 +00:00
|
|
|
int k;
|
|
|
|
struct sysctl_oid *oidp;
|
1995-11-08 08:48:36 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
1999-02-16 10:49:55 +00:00
|
|
|
SLIST_FOREACH(oidp, l, oid_link) {
|
1995-11-08 08:48:36 +00:00
|
|
|
|
|
|
|
for (k=0; k<i; k++)
|
|
|
|
printf(" ");
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
printf("%d %s ", oidp->oid_number, oidp->oid_name);
|
1995-11-08 08:48:36 +00:00
|
|
|
|
|
|
|
printf("%c%c",
|
1999-02-16 10:49:55 +00:00
|
|
|
oidp->oid_kind & CTLFLAG_RD ? 'R':' ',
|
|
|
|
oidp->oid_kind & CTLFLAG_WR ? 'W':' ');
|
1995-11-08 08:48:36 +00:00
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_handler)
|
1996-04-13 13:28:54 +00:00
|
|
|
printf(" *Handler");
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
switch (oidp->oid_kind & CTLTYPE) {
|
1995-11-12 19:52:09 +00:00
|
|
|
case CTLTYPE_NODE:
|
1996-04-13 13:28:54 +00:00
|
|
|
printf(" Node\n");
|
1999-02-16 10:49:55 +00:00
|
|
|
if (!oidp->oid_handler) {
|
1995-11-08 08:48:36 +00:00
|
|
|
sysctl_sysctl_debug_dump_node(
|
2014-06-28 03:56:17 +00:00
|
|
|
SYSCTL_CHILDREN(oidp), i + 2);
|
1995-11-08 08:48:36 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CTLTYPE_INT: printf(" Int\n"); break;
|
2011-01-19 23:00:25 +00:00
|
|
|
case CTLTYPE_UINT: printf(" u_int\n"); break;
|
|
|
|
case CTLTYPE_LONG: printf(" Long\n"); break;
|
|
|
|
case CTLTYPE_ULONG: printf(" u_long\n"); break;
|
1995-11-08 08:48:36 +00:00
|
|
|
case CTLTYPE_STRING: printf(" String\n"); break;
|
2011-01-19 23:00:25 +00:00
|
|
|
case CTLTYPE_U64: printf(" uint64_t\n"); break;
|
|
|
|
case CTLTYPE_S64: printf(" int64_t\n"); break;
|
1995-11-08 08:48:36 +00:00
|
|
|
case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break;
|
|
|
|
default: printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_sysctl_debug(SYSCTL_HANDLER_ARGS)
|
1995-11-08 08:48:36 +00:00
|
|
|
{
|
2001-11-28 03:11:16 +00:00
|
|
|
int error;
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(req->td, PRIV_SYSCTL_DEBUG);
|
2001-11-28 03:11:16 +00:00
|
|
|
if (error)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (error);
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
1999-02-16 10:49:55 +00:00
|
|
|
sysctl_sysctl_debug_dump_node(&sysctl__children, 0);
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
2004-12-31 14:52:53 +00:00
|
|
|
return (ENOENT);
|
1995-11-08 08:48:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD,
|
1995-12-04 16:48:58 +00:00
|
|
|
0, 0, sysctl_sysctl_debug, "-", "");
|
2004-10-27 19:26:01 +00:00
|
|
|
#endif
|
1995-11-06 16:18:52 +00:00
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_sysctl_name(SYSCTL_HANDLER_ARGS)
|
1995-12-04 16:48:58 +00:00
|
|
|
{
|
|
|
|
int *name = (int *) arg1;
|
|
|
|
u_int namelen = arg2;
|
1999-02-16 10:49:55 +00:00
|
|
|
int error = 0;
|
|
|
|
struct sysctl_oid *oid;
|
1999-03-23 14:23:15 +00:00
|
|
|
struct sysctl_oid_list *lsp = &sysctl__children, *lsp2;
|
1995-12-04 16:48:58 +00:00
|
|
|
char buf[10];
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
1995-12-04 16:48:58 +00:00
|
|
|
while (namelen) {
|
|
|
|
if (!lsp) {
|
1998-12-04 22:54:57 +00:00
|
|
|
snprintf(buf,sizeof(buf),"%d",*name);
|
1995-12-04 16:48:58 +00:00
|
|
|
if (req->oldidx)
|
|
|
|
error = SYSCTL_OUT(req, ".", 1);
|
|
|
|
if (!error)
|
|
|
|
error = SYSCTL_OUT(req, buf, strlen(buf));
|
|
|
|
if (error)
|
2010-11-29 18:18:07 +00:00
|
|
|
goto out;
|
1995-12-04 16:48:58 +00:00
|
|
|
namelen--;
|
|
|
|
name++;
|
|
|
|
continue;
|
|
|
|
}
|
1999-03-23 14:23:15 +00:00
|
|
|
lsp2 = 0;
|
1999-02-16 10:49:55 +00:00
|
|
|
SLIST_FOREACH(oid, lsp, oid_link) {
|
|
|
|
if (oid->oid_number != *name)
|
1995-12-04 16:48:58 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (req->oldidx)
|
|
|
|
error = SYSCTL_OUT(req, ".", 1);
|
|
|
|
if (!error)
|
1999-02-16 10:49:55 +00:00
|
|
|
error = SYSCTL_OUT(req, oid->oid_name,
|
|
|
|
strlen(oid->oid_name));
|
1995-12-04 16:48:58 +00:00
|
|
|
if (error)
|
2010-11-29 18:18:07 +00:00
|
|
|
goto out;
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
namelen--;
|
|
|
|
name++;
|
|
|
|
|
1999-03-23 14:23:15 +00:00
|
|
|
if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
|
1995-12-04 16:48:58 +00:00
|
|
|
break;
|
1995-11-06 16:18:52 +00:00
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oid->oid_handler)
|
1995-12-04 16:48:58 +00:00
|
|
|
break;
|
|
|
|
|
2010-11-29 18:17:53 +00:00
|
|
|
lsp2 = SYSCTL_CHILDREN(oid);
|
1995-12-04 16:48:58 +00:00
|
|
|
break;
|
|
|
|
}
|
1999-03-23 14:23:15 +00:00
|
|
|
lsp = lsp2;
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
2010-11-29 18:18:07 +00:00
|
|
|
error = SYSCTL_OUT(req, "", 1);
|
|
|
|
out:
|
|
|
|
SYSCTL_XUNLOCK();
|
|
|
|
return (error);
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
/*
|
|
|
|
* XXXRW/JA: Shouldn't return name data for nodes that we don't permit in
|
|
|
|
* capability mode.
|
|
|
|
*/
|
|
|
|
static SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD | CTLFLAG_CAPRD,
|
|
|
|
sysctl_sysctl_name, "");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
static int
|
2000-07-28 22:40:04 +00:00
|
|
|
sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
|
1999-02-16 10:49:55 +00:00
|
|
|
int *next, int *len, int level, struct sysctl_oid **oidpp)
|
1995-12-04 16:48:58 +00:00
|
|
|
{
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid *oidp;
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
1995-12-04 16:48:58 +00:00
|
|
|
*len = level;
|
1999-02-16 10:49:55 +00:00
|
|
|
SLIST_FOREACH(oidp, lsp, oid_link) {
|
|
|
|
*next = oidp->oid_number;
|
|
|
|
*oidpp = oidp;
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2002-08-10 19:56:45 +00:00
|
|
|
if (oidp->oid_kind & CTLFLAG_SKIP)
|
|
|
|
continue;
|
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
if (!namelen) {
|
1999-02-16 10:49:55 +00:00
|
|
|
if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_handler)
|
1995-12-04 16:48:58 +00:00
|
|
|
/* We really should call the handler here...*/
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
2010-11-29 18:17:53 +00:00
|
|
|
lsp = SYSCTL_CHILDREN(oidp);
|
2000-07-28 22:40:04 +00:00
|
|
|
if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
|
1999-02-16 10:49:55 +00:00
|
|
|
len, level+1, oidpp))
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
2003-02-22 17:58:06 +00:00
|
|
|
goto emptynode;
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_number < *name)
|
1995-12-04 16:48:58 +00:00
|
|
|
continue;
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_number > *name) {
|
|
|
|
if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_handler)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
2010-11-29 18:17:53 +00:00
|
|
|
lsp = SYSCTL_CHILDREN(oidp);
|
2000-07-28 22:40:04 +00:00
|
|
|
if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
|
1999-02-16 10:49:55 +00:00
|
|
|
next+1, len, level+1, oidpp))
|
1995-12-04 16:48:58 +00:00
|
|
|
return (0);
|
1996-04-13 13:28:54 +00:00
|
|
|
goto next;
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
1999-02-16 10:49:55 +00:00
|
|
|
if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
|
1995-12-04 16:48:58 +00:00
|
|
|
continue;
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_handler)
|
1995-12-04 16:48:58 +00:00
|
|
|
continue;
|
|
|
|
|
2010-11-29 18:17:53 +00:00
|
|
|
lsp = SYSCTL_CHILDREN(oidp);
|
2000-07-28 22:40:04 +00:00
|
|
|
if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
|
1999-02-16 10:49:55 +00:00
|
|
|
len, level+1, oidpp))
|
1995-12-04 16:48:58 +00:00
|
|
|
return (0);
|
1996-04-13 13:28:54 +00:00
|
|
|
next:
|
1995-12-04 16:48:58 +00:00
|
|
|
namelen = 1;
|
2003-02-22 17:58:06 +00:00
|
|
|
emptynode:
|
1995-12-04 16:48:58 +00:00
|
|
|
*len = level;
|
|
|
|
}
|
2004-12-31 14:52:53 +00:00
|
|
|
return (1);
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_sysctl_next(SYSCTL_HANDLER_ARGS)
|
1995-12-04 16:48:58 +00:00
|
|
|
{
|
|
|
|
int *name = (int *) arg1;
|
|
|
|
u_int namelen = arg2;
|
|
|
|
int i, j, error;
|
|
|
|
struct sysctl_oid *oid;
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid_list *lsp = &sysctl__children;
|
1995-12-04 16:48:58 +00:00
|
|
|
int newoid[CTL_MAXNAME];
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
2000-07-28 22:40:04 +00:00
|
|
|
i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid);
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
1995-12-04 16:48:58 +00:00
|
|
|
if (i)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (ENOENT);
|
1995-12-06 13:27:39 +00:00
|
|
|
error = SYSCTL_OUT(req, newoid, j * sizeof (int));
|
1995-12-04 16:48:58 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
/*
|
|
|
|
* XXXRW/JA: Shouldn't return next data for nodes that we don't permit in
|
|
|
|
* capability mode.
|
|
|
|
*/
|
|
|
|
static SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD | CTLFLAG_CAPRD,
|
|
|
|
sysctl_sysctl_next, "");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
static int
|
2009-03-11 21:48:36 +00:00
|
|
|
name2oid(char *name, int *oid, int *len, struct sysctl_oid **oidpp)
|
1995-12-04 16:48:58 +00:00
|
|
|
{
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid *oidp;
|
|
|
|
struct sysctl_oid_list *lsp = &sysctl__children;
|
1995-12-04 16:48:58 +00:00
|
|
|
char *p;
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
2008-12-29 12:58:45 +00:00
|
|
|
|
2013-03-01 18:49:14 +00:00
|
|
|
for (*len = 0; *len < CTL_MAXNAME;) {
|
|
|
|
p = strsep(&name, ".");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2013-03-01 18:49:14 +00:00
|
|
|
oidp = SLIST_FIRST(lsp);
|
|
|
|
for (;; oidp = SLIST_NEXT(oidp, oid_link)) {
|
|
|
|
if (oidp == NULL)
|
|
|
|
return (ENOENT);
|
|
|
|
if (strcmp(p, oidp->oid_name) == 0)
|
|
|
|
break;
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
1999-02-16 10:49:55 +00:00
|
|
|
*oid++ = oidp->oid_number;
|
1995-12-04 16:48:58 +00:00
|
|
|
(*len)++;
|
|
|
|
|
2013-03-01 18:49:14 +00:00
|
|
|
if (name == NULL || *name == '\0') {
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidpp)
|
|
|
|
*oidpp = oidp;
|
1995-12-04 16:48:58 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
|
1995-12-04 16:48:58 +00:00
|
|
|
break;
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oidp->oid_handler)
|
1995-12-04 16:48:58 +00:00
|
|
|
break;
|
|
|
|
|
2010-11-29 18:17:53 +00:00
|
|
|
lsp = SYSCTL_CHILDREN(oidp);
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
2004-12-31 14:52:53 +00:00
|
|
|
return (ENOENT);
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS)
|
1995-12-04 16:48:58 +00:00
|
|
|
{
|
|
|
|
char *p;
|
2010-11-29 21:53:21 +00:00
|
|
|
int error, oid[CTL_MAXNAME], len = 0;
|
1995-12-04 16:48:58 +00:00
|
|
|
struct sysctl_oid *op = 0;
|
|
|
|
|
|
|
|
if (!req->newlen)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (ENOENT);
|
1999-03-30 09:00:45 +00:00
|
|
|
if (req->newlen >= MAXPATHLEN) /* XXX arbitrary, undocumented */
|
|
|
|
return (ENAMETOOLONG);
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
error = SYSCTL_IN(req, p, req->newlen);
|
|
|
|
if (error) {
|
|
|
|
free(p, M_SYSCTL);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
p [req->newlen] = '\0';
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
1995-12-04 16:48:58 +00:00
|
|
|
error = name2oid(p, oid, &len, &op);
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
free(p, M_SYSCTL);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
1995-12-06 13:27:39 +00:00
|
|
|
error = SYSCTL_OUT(req, oid, len * sizeof *oid);
|
1995-12-04 16:48:58 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
/*
|
|
|
|
* XXXRW/JA: Shouldn't return name2oid data for nodes that we don't permit in
|
|
|
|
* capability mode.
|
|
|
|
*/
|
2011-01-18 21:14:18 +00:00
|
|
|
SYSCTL_PROC(_sysctl, 3, name2oid,
|
2011-07-17 23:05:24 +00:00
|
|
|
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE
|
|
|
|
| CTLFLAG_CAPRW, 0, 0, sysctl_sysctl_name2oid, "I", "");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_sysctl_oidfmt(SYSCTL_HANDLER_ARGS)
|
1995-12-04 16:48:58 +00:00
|
|
|
{
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid *oid;
|
1999-12-01 02:25:19 +00:00
|
|
|
int error;
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
1999-12-01 02:25:19 +00:00
|
|
|
error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
|
|
|
|
if (error)
|
2010-11-29 18:18:07 +00:00
|
|
|
goto out;
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
if (oid->oid_fmt == NULL) {
|
|
|
|
error = ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
1999-12-01 02:25:19 +00:00
|
|
|
error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind));
|
|
|
|
if (error)
|
2010-11-29 18:18:07 +00:00
|
|
|
goto out;
|
1999-12-01 02:25:19 +00:00
|
|
|
error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1);
|
2010-11-29 18:18:07 +00:00
|
|
|
out:
|
|
|
|
SYSCTL_XUNLOCK();
|
1995-12-06 13:27:39 +00:00
|
|
|
return (error);
|
1995-12-04 16:48:58 +00:00
|
|
|
}
|
|
|
|
|
1999-01-10 05:33:43 +00:00
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
static SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD|CTLFLAG_MPSAFE|CTLFLAG_CAPRD,
|
Mark most often used sysctl's as MPSAFE.
After running a `make buildkernel', I noticed most of the Giant locks in
sysctl are only caused by a very small amount of sysctl's:
- sysctl.name2oid. This one is locked by SYSCTL_LOCK, just like
sysctl.oidfmt.
- kern.ident, kern.osrelease, kern.version, etc. These are just constant
strings.
- kern.arandom, used by the stack protector. It is already protected by
arc4_mtx.
I also saw the following sysctl's show up. Not as often as the ones
above, but still quite often:
- security.jail.jailed. Also mark security.jail.list as MPSAFE. They
don't need locking or already use allprison_lock.
- kern.devname, used by devname(3), ttyname(3), etc.
This seems to reduce Giant locking inside sysctl by ~75% in my primitive
test setup.
2009-01-28 19:58:05 +00:00
|
|
|
sysctl_sysctl_oidfmt, "");
|
1999-01-10 05:33:43 +00:00
|
|
|
|
2001-12-16 02:55:41 +00:00
|
|
|
static int
|
|
|
|
sysctl_sysctl_oiddescr(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
struct sysctl_oid *oid;
|
|
|
|
int error;
|
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
2001-12-16 02:55:41 +00:00
|
|
|
error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
|
|
|
|
if (error)
|
2010-11-29 18:18:07 +00:00
|
|
|
goto out;
|
2001-12-16 02:55:41 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
if (oid->oid_descr == NULL) {
|
|
|
|
error = ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-02-07 07:40:39 +00:00
|
|
|
error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1);
|
2010-11-29 18:18:07 +00:00
|
|
|
out:
|
|
|
|
SYSCTL_XUNLOCK();
|
2001-12-16 02:55:41 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
static SYSCTL_NODE(_sysctl, 5, oiddescr, CTLFLAG_RD|CTLFLAG_CAPRD,
|
|
|
|
sysctl_sysctl_oiddescr, "");
|
2001-12-16 02:55:41 +00:00
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
/*
|
|
|
|
* Default "handler" functions.
|
|
|
|
*/
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1995-11-12 19:52:09 +00:00
|
|
|
/*
|
1998-12-27 18:03:29 +00:00
|
|
|
* Handle an int, signed or unsigned.
|
1995-11-12 19:52:09 +00:00
|
|
|
* Two cases:
|
|
|
|
* a variable: point arg1 at it.
|
|
|
|
* a constant: pass it in arg2.
|
|
|
|
*/
|
|
|
|
|
1995-10-28 13:07:28 +00:00
|
|
|
int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_handle_int(SYSCTL_HANDLER_ARGS)
|
1995-10-28 12:59:25 +00:00
|
|
|
{
|
2002-07-28 21:06:14 +00:00
|
|
|
int tmpout, error = 0;
|
1995-10-28 12:59:25 +00:00
|
|
|
|
2002-07-28 21:06:14 +00:00
|
|
|
/*
|
|
|
|
* Attempt to get a coherent snapshot by making a copy of the data.
|
|
|
|
*/
|
1995-11-12 19:52:09 +00:00
|
|
|
if (arg1)
|
2002-07-28 21:06:14 +00:00
|
|
|
tmpout = *(int *)arg1;
|
1996-12-15 14:38:46 +00:00
|
|
|
else
|
2002-07-28 21:06:14 +00:00
|
|
|
tmpout = arg2;
|
|
|
|
error = SYSCTL_OUT(req, &tmpout, sizeof(int));
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1995-11-12 19:52:09 +00:00
|
|
|
if (error || !req->newptr)
|
|
|
|
return (error);
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1995-11-12 19:52:09 +00:00
|
|
|
if (!arg1)
|
|
|
|
error = EPERM;
|
|
|
|
else
|
|
|
|
error = SYSCTL_IN(req, arg1, sizeof(int));
|
|
|
|
return (error);
|
1995-10-28 12:59:25 +00:00
|
|
|
}
|
|
|
|
|
2006-02-16 15:40:36 +00:00
|
|
|
/*
|
|
|
|
* Based on on sysctl_handle_int() convert milliseconds into ticks.
|
Build on Jeff Roberson's linker-set based dynamic per-CPU allocator
(DPCPU), as suggested by Peter Wemm, and implement a new per-virtual
network stack memory allocator. Modify vnet to use the allocator
instead of monolithic global container structures (vinet, ...). This
change solves many binary compatibility problems associated with
VIMAGE, and restores ELF symbols for virtualized global variables.
Each virtualized global variable exists as a "reference copy", and also
once per virtual network stack. Virtualized global variables are
tagged at compile-time, placing the in a special linker set, which is
loaded into a contiguous region of kernel memory. Virtualized global
variables in the base kernel are linked as normal, but those in modules
are copied and relocated to a reserved portion of the kernel's vnet
region with the help of a the kernel linker.
Virtualized global variables exist in per-vnet memory set up when the
network stack instance is created, and are initialized statically from
the reference copy. Run-time access occurs via an accessor macro, which
converts from the current vnet and requested symbol to a per-vnet
address. When "options VIMAGE" is not compiled into the kernel, normal
global ELF symbols will be used instead and indirection is avoided.
This change restores static initialization for network stack global
variables, restores support for non-global symbols and types, eliminates
the need for many subsystem constructors, eliminates large per-subsystem
structures that caused many binary compatibility issues both for
monitoring applications (netstat) and kernel modules, removes the
per-function INIT_VNET_*() macros throughout the stack, eliminates the
need for vnet_symmap ksym(2) munging, and eliminates duplicate
definitions of virtualized globals under VIMAGE_GLOBALS.
Bump __FreeBSD_version and update UPDATING.
Portions submitted by: bz
Reviewed by: bz, zec
Discussed with: gnn, jamie, jeff, jhb, julian, sam
Suggested by: peter
Approved by: re (kensmith)
2009-07-14 22:48:30 +00:00
|
|
|
* Note: this is used by TCP.
|
2006-02-16 15:40:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error, s, tt;
|
|
|
|
|
Permit buiding kernels with options VIMAGE, restricted to only a single
active network stack instance. Turning on options VIMAGE at compile
time yields the following changes relative to default kernel build:
1) V_ accessor macros for virtualized variables resolve to structure
fields via base pointers, instead of being resolved as fields in global
structs or plain global variables. As an example, V_ifnet becomes:
options VIMAGE: ((struct vnet_net *) vnet_net)->_ifnet
default build: vnet_net_0._ifnet
options VIMAGE_GLOBALS: ifnet
2) INIT_VNET_* macros will declare and set up base pointers to be used
by V_ accessor macros, instead of resolving to whitespace:
INIT_VNET_NET(ifp->if_vnet); becomes
struct vnet_net *vnet_net = (ifp->if_vnet)->mod_data[VNET_MOD_NET];
3) Memory for vnet modules registered via vnet_mod_register() is now
allocated at run time in sys/kern/kern_vimage.c, instead of per vnet
module structs being declared as globals. If required, vnet modules
can now request the framework to provide them with allocated bzeroed
memory by filling in the vmi_size field in their vmi_modinfo structures.
4) structs socket, ifnet, inpcbinfo, tcpcb and syncache_head are
extended to hold a pointer to the parent vnet. options VIMAGE builds
will fill in those fields as required.
5) curvnet is introduced as a new global variable in options VIMAGE
builds, always pointing to the default and only struct vnet.
6) struct sysctl_oid has been extended with additional two fields to
store major and minor virtualization module identifiers, oid_v_subs and
oid_v_mod. SYSCTL_V_* family of macros will fill in those fields
accordingly, and store the offset in the appropriate vnet container
struct in oid_arg1.
In sysctl handlers dealing with virtualized sysctls, the
SYSCTL_RESOLVE_V_ARG1() macro will compute the address of the target
variable and make it available in arg1 variable for further processing.
Unused fields in structs vnet_inet, vnet_inet6 and vnet_ipfw have
been deleted.
Reviewed by: bz, rwatson
Approved by: julian (mentor)
2009-04-30 13:36:26 +00:00
|
|
|
tt = *(int *)arg1;
|
2006-02-16 15:40:36 +00:00
|
|
|
s = (int)((int64_t)tt * 1000 / hz);
|
|
|
|
|
|
|
|
error = sysctl_handle_int(oidp, &s, 0, req);
|
|
|
|
if (error || !req->newptr)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
tt = (int)((int64_t)s * hz / 1000);
|
|
|
|
if (tt < 1)
|
|
|
|
return (EINVAL);
|
|
|
|
|
Permit buiding kernels with options VIMAGE, restricted to only a single
active network stack instance. Turning on options VIMAGE at compile
time yields the following changes relative to default kernel build:
1) V_ accessor macros for virtualized variables resolve to structure
fields via base pointers, instead of being resolved as fields in global
structs or plain global variables. As an example, V_ifnet becomes:
options VIMAGE: ((struct vnet_net *) vnet_net)->_ifnet
default build: vnet_net_0._ifnet
options VIMAGE_GLOBALS: ifnet
2) INIT_VNET_* macros will declare and set up base pointers to be used
by V_ accessor macros, instead of resolving to whitespace:
INIT_VNET_NET(ifp->if_vnet); becomes
struct vnet_net *vnet_net = (ifp->if_vnet)->mod_data[VNET_MOD_NET];
3) Memory for vnet modules registered via vnet_mod_register() is now
allocated at run time in sys/kern/kern_vimage.c, instead of per vnet
module structs being declared as globals. If required, vnet modules
can now request the framework to provide them with allocated bzeroed
memory by filling in the vmi_size field in their vmi_modinfo structures.
4) structs socket, ifnet, inpcbinfo, tcpcb and syncache_head are
extended to hold a pointer to the parent vnet. options VIMAGE builds
will fill in those fields as required.
5) curvnet is introduced as a new global variable in options VIMAGE
builds, always pointing to the default and only struct vnet.
6) struct sysctl_oid has been extended with additional two fields to
store major and minor virtualization module identifiers, oid_v_subs and
oid_v_mod. SYSCTL_V_* family of macros will fill in those fields
accordingly, and store the offset in the appropriate vnet container
struct in oid_arg1.
In sysctl handlers dealing with virtualized sysctls, the
SYSCTL_RESOLVE_V_ARG1() macro will compute the address of the target
variable and make it available in arg1 variable for further processing.
Unused fields in structs vnet_inet, vnet_inet6 and vnet_ipfw have
been deleted.
Reviewed by: bz, rwatson
Approved by: julian (mentor)
2009-04-30 13:36:26 +00:00
|
|
|
*(int *)arg1 = tt;
|
2006-02-16 15:40:36 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-08-24 08:39:39 +00:00
|
|
|
/*
|
2013-02-11 23:05:10 +00:00
|
|
|
* Handle a long, signed or unsigned.
|
|
|
|
* Two cases:
|
|
|
|
* a variable: point arg1 at it.
|
|
|
|
* a constant: pass it in arg2.
|
1998-08-24 08:39:39 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_handle_long(SYSCTL_HANDLER_ARGS)
|
1998-08-24 08:39:39 +00:00
|
|
|
{
|
|
|
|
int error = 0;
|
2004-10-11 22:04:16 +00:00
|
|
|
long tmplong;
|
|
|
|
#ifdef SCTL_MASK32
|
|
|
|
int tmpint;
|
|
|
|
#endif
|
1998-08-24 08:39:39 +00:00
|
|
|
|
2002-07-28 21:06:14 +00:00
|
|
|
/*
|
|
|
|
* Attempt to get a coherent snapshot by making a copy of the data.
|
|
|
|
*/
|
2013-02-11 21:50:00 +00:00
|
|
|
if (arg1)
|
|
|
|
tmplong = *(long *)arg1;
|
|
|
|
else
|
|
|
|
tmplong = arg2;
|
2004-10-11 22:04:16 +00:00
|
|
|
#ifdef SCTL_MASK32
|
|
|
|
if (req->flags & SCTL_MASK32) {
|
|
|
|
tmpint = tmplong;
|
|
|
|
error = SYSCTL_OUT(req, &tmpint, sizeof(int));
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
error = SYSCTL_OUT(req, &tmplong, sizeof(long));
|
1998-08-24 08:39:39 +00:00
|
|
|
|
|
|
|
if (error || !req->newptr)
|
|
|
|
return (error);
|
|
|
|
|
2013-02-11 21:50:00 +00:00
|
|
|
if (!arg1)
|
|
|
|
error = EPERM;
|
2004-10-11 22:04:16 +00:00
|
|
|
#ifdef SCTL_MASK32
|
2013-02-11 21:50:00 +00:00
|
|
|
else if (req->flags & SCTL_MASK32) {
|
2004-10-11 22:04:16 +00:00
|
|
|
error = SYSCTL_IN(req, &tmpint, sizeof(int));
|
|
|
|
*(long *)arg1 = (long)tmpint;
|
2013-02-11 21:50:00 +00:00
|
|
|
}
|
2004-10-11 22:04:16 +00:00
|
|
|
#endif
|
2013-02-11 21:50:00 +00:00
|
|
|
else
|
2004-10-11 22:04:16 +00:00
|
|
|
error = SYSCTL_IN(req, arg1, sizeof(long));
|
1998-08-24 08:39:39 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2007-06-04 18:14:28 +00:00
|
|
|
/*
|
2013-02-11 23:05:10 +00:00
|
|
|
* Handle a 64 bit int, signed or unsigned.
|
|
|
|
* Two cases:
|
|
|
|
* a variable: point arg1 at it.
|
|
|
|
* a constant: pass it in arg2.
|
2007-06-04 18:14:28 +00:00
|
|
|
*/
|
|
|
|
int
|
2011-01-19 23:00:25 +00:00
|
|
|
sysctl_handle_64(SYSCTL_HANDLER_ARGS)
|
2007-06-04 18:14:28 +00:00
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
uint64_t tmpout;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to get a coherent snapshot by making a copy of the data.
|
|
|
|
*/
|
2013-02-11 21:50:00 +00:00
|
|
|
if (arg1)
|
|
|
|
tmpout = *(uint64_t *)arg1;
|
|
|
|
else
|
|
|
|
tmpout = arg2;
|
2007-06-04 18:14:28 +00:00
|
|
|
error = SYSCTL_OUT(req, &tmpout, sizeof(uint64_t));
|
|
|
|
|
|
|
|
if (error || !req->newptr)
|
|
|
|
return (error);
|
|
|
|
|
2013-02-11 21:50:00 +00:00
|
|
|
if (!arg1)
|
|
|
|
error = EPERM;
|
|
|
|
else
|
|
|
|
error = SYSCTL_IN(req, arg1, sizeof(uint64_t));
|
2007-06-04 18:14:28 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
1995-10-28 13:07:28 +00:00
|
|
|
int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_handle_string(SYSCTL_HANDLER_ARGS)
|
1995-10-28 12:59:25 +00:00
|
|
|
{
|
2002-07-28 21:06:14 +00:00
|
|
|
size_t outlen;
|
2014-07-10 21:46:57 +00:00
|
|
|
int error = 0, ro_string = 0;
|
2002-10-17 20:03:38 +00:00
|
|
|
|
2014-06-28 03:59:04 +00:00
|
|
|
/*
|
|
|
|
* A zero-length buffer indicates a fixed size read-only
|
|
|
|
* string:
|
|
|
|
*/
|
2014-07-10 21:46:57 +00:00
|
|
|
if (arg2 == 0) {
|
2014-06-28 03:59:04 +00:00
|
|
|
arg2 = strlen((char *)arg1) + 1;
|
2014-07-10 21:46:57 +00:00
|
|
|
ro_string = 1;
|
|
|
|
}
|
1995-10-28 12:59:25 +00:00
|
|
|
|
2014-06-28 03:56:17 +00:00
|
|
|
if (req->oldptr != NULL) {
|
|
|
|
char *tmparg;
|
|
|
|
|
2014-07-10 21:46:57 +00:00
|
|
|
if (ro_string) {
|
|
|
|
tmparg = arg1;
|
|
|
|
} else {
|
|
|
|
/* try to make a coherent snapshot of the string */
|
|
|
|
tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
|
|
|
|
memcpy(tmparg, arg1, arg2);
|
|
|
|
}
|
2014-06-27 22:05:21 +00:00
|
|
|
|
2014-06-28 03:56:17 +00:00
|
|
|
outlen = strnlen(tmparg, arg2 - 1) + 1;
|
|
|
|
error = SYSCTL_OUT(req, tmparg, outlen);
|
2014-06-27 22:05:21 +00:00
|
|
|
|
2014-07-10 21:46:57 +00:00
|
|
|
if (!ro_string)
|
|
|
|
free(tmparg, M_SYSCTLTMP);
|
2014-06-28 03:56:17 +00:00
|
|
|
} else {
|
|
|
|
outlen = strnlen((char *)arg1, arg2 - 1) + 1;
|
|
|
|
error = SYSCTL_OUT(req, NULL, outlen);
|
|
|
|
}
|
1999-03-30 09:00:45 +00:00
|
|
|
if (error || !req->newptr)
|
1995-11-12 19:52:09 +00:00
|
|
|
return (error);
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1999-03-30 09:00:45 +00:00
|
|
|
if ((req->newlen - req->newidx) >= arg2) {
|
|
|
|
error = EINVAL;
|
1995-11-12 19:52:09 +00:00
|
|
|
} else {
|
|
|
|
arg2 = (req->newlen - req->newidx);
|
|
|
|
error = SYSCTL_IN(req, arg1, arg2);
|
|
|
|
((char *)arg1)[arg2] = '\0';
|
1995-10-28 12:59:25 +00:00
|
|
|
}
|
1995-11-06 16:18:52 +00:00
|
|
|
return (error);
|
1995-10-28 12:59:25 +00:00
|
|
|
}
|
|
|
|
|
1995-11-12 19:52:09 +00:00
|
|
|
/*
|
|
|
|
* Handle any kind of opaque data.
|
|
|
|
* arg1 points to it, arg2 is the size.
|
|
|
|
*/
|
|
|
|
|
1995-10-28 13:07:28 +00:00
|
|
|
int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
|
1995-10-28 12:59:25 +00:00
|
|
|
{
|
2003-10-05 09:37:47 +00:00
|
|
|
int error, tries;
|
|
|
|
u_int generation;
|
2003-10-05 13:31:33 +00:00
|
|
|
struct sysctl_req req2;
|
1995-10-28 12:59:25 +00:00
|
|
|
|
2002-07-28 21:06:14 +00:00
|
|
|
/*
|
2003-10-05 09:37:47 +00:00
|
|
|
* Attempt to get a coherent snapshot, by using the thread
|
|
|
|
* pre-emption counter updated from within mi_switch() to
|
|
|
|
* determine if we were pre-empted during a bcopy() or
|
|
|
|
* copyout(). Make 3 attempts at doing this before giving up.
|
|
|
|
* If we encounter an error, stop immediately.
|
2002-07-28 21:06:14 +00:00
|
|
|
*/
|
2003-10-05 09:37:47 +00:00
|
|
|
tries = 0;
|
2003-10-05 13:31:33 +00:00
|
|
|
req2 = *req;
|
|
|
|
retry:
|
|
|
|
generation = curthread->td_generation;
|
|
|
|
error = SYSCTL_OUT(req, arg1, arg2);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
tries++;
|
|
|
|
if (generation != curthread->td_generation && tries < 3) {
|
|
|
|
*req = req2;
|
|
|
|
goto retry;
|
|
|
|
}
|
1995-11-12 19:52:09 +00:00
|
|
|
|
|
|
|
error = SYSCTL_IN(req, arg1, arg2);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1995-11-13 13:54:09 +00:00
|
|
|
/*
|
|
|
|
* Transfer functions to/from kernel space.
|
|
|
|
* XXX: rather untested at this point
|
|
|
|
*/
|
|
|
|
static int
|
1998-08-24 08:39:39 +00:00
|
|
|
sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l)
|
1995-11-12 19:52:09 +00:00
|
|
|
{
|
1998-08-24 08:39:39 +00:00
|
|
|
size_t i = 0;
|
1995-11-13 13:54:09 +00:00
|
|
|
|
|
|
|
if (req->oldptr) {
|
1998-08-24 08:39:39 +00:00
|
|
|
i = l;
|
2001-03-08 01:20:43 +00:00
|
|
|
if (req->oldlen <= req->oldidx)
|
|
|
|
i = 0;
|
|
|
|
else
|
|
|
|
if (i > req->oldlen - req->oldidx)
|
|
|
|
i = req->oldlen - req->oldidx;
|
1995-11-13 13:54:09 +00:00
|
|
|
if (i > 0)
|
1996-08-31 14:48:13 +00:00
|
|
|
bcopy(p, (char *)req->oldptr + req->oldidx, i);
|
1995-10-28 12:59:25 +00:00
|
|
|
}
|
2009-05-15 14:41:44 +00:00
|
|
|
req->oldidx += l;
|
1996-06-10 16:23:42 +00:00
|
|
|
if (req->oldptr && i != l)
|
1995-11-12 19:52:09 +00:00
|
|
|
return (ENOMEM);
|
1995-11-13 13:54:09 +00:00
|
|
|
return (0);
|
1995-11-12 19:52:09 +00:00
|
|
|
}
|
|
|
|
|
1995-11-13 13:54:09 +00:00
|
|
|
static int
|
1998-08-24 08:39:39 +00:00
|
|
|
sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l)
|
1995-11-12 19:52:09 +00:00
|
|
|
{
|
1995-11-13 13:54:09 +00:00
|
|
|
if (!req->newptr)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
1995-11-13 13:54:09 +00:00
|
|
|
if (req->newlen - req->newidx < l)
|
1995-11-12 19:52:09 +00:00
|
|
|
return (EINVAL);
|
1996-08-31 14:48:13 +00:00
|
|
|
bcopy((char *)req->newptr + req->newidx, p, l);
|
1995-11-12 19:52:09 +00:00
|
|
|
req->newidx += l;
|
1995-11-06 16:18:52 +00:00
|
|
|
return (0);
|
1995-10-28 12:59:25 +00:00
|
|
|
}
|
|
|
|
|
1996-06-10 16:23:42 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old,
|
2004-10-11 22:04:16 +00:00
|
|
|
size_t *oldlenp, void *new, size_t newlen, size_t *retval, int flags)
|
1996-06-10 16:23:42 +00:00
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
struct sysctl_req req;
|
|
|
|
|
|
|
|
bzero(&req, sizeof req);
|
|
|
|
|
2001-11-08 02:13:18 +00:00
|
|
|
req.td = td;
|
2004-10-11 22:04:16 +00:00
|
|
|
req.flags = flags;
|
1996-06-10 16:23:42 +00:00
|
|
|
|
|
|
|
if (oldlenp) {
|
|
|
|
req.oldlen = *oldlenp;
|
|
|
|
}
|
2004-03-16 06:53:03 +00:00
|
|
|
req.validlen = req.oldlen;
|
1996-06-10 16:23:42 +00:00
|
|
|
|
|
|
|
if (old) {
|
|
|
|
req.oldptr= old;
|
|
|
|
}
|
|
|
|
|
2001-06-03 04:58:51 +00:00
|
|
|
if (new != NULL) {
|
1996-06-10 16:23:42 +00:00
|
|
|
req.newlen = newlen;
|
|
|
|
req.newptr = new;
|
|
|
|
}
|
|
|
|
|
|
|
|
req.oldfunc = sysctl_old_kernel;
|
|
|
|
req.newfunc = sysctl_new_kernel;
|
2011-01-26 22:48:09 +00:00
|
|
|
req.lock = REQ_UNWIRED;
|
1996-06-10 16:23:42 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
1996-06-10 16:23:42 +00:00
|
|
|
error = sysctl_root(0, name, namelen, &req);
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
2003-10-05 13:31:33 +00:00
|
|
|
|
2004-03-16 06:53:03 +00:00
|
|
|
if (req.lock == REQ_WIRED && req.validlen > 0)
|
|
|
|
vsunlock(req.oldptr, req.validlen);
|
1996-06-10 16:23:42 +00:00
|
|
|
|
|
|
|
if (error && error != ENOMEM)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (retval) {
|
2004-03-16 06:53:03 +00:00
|
|
|
if (req.oldptr && req.oldidx > req.validlen)
|
|
|
|
*retval = req.validlen;
|
1996-06-10 16:23:42 +00:00
|
|
|
else
|
|
|
|
*retval = req.oldidx;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2001-05-19 05:45:55 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp,
|
2004-10-11 22:04:16 +00:00
|
|
|
void *new, size_t newlen, size_t *retval, int flags)
|
2001-05-19 05:45:55 +00:00
|
|
|
{
|
|
|
|
int oid[CTL_MAXNAME];
|
2001-06-22 19:54:38 +00:00
|
|
|
size_t oidlen, plen;
|
|
|
|
int error;
|
2001-05-19 05:45:55 +00:00
|
|
|
|
|
|
|
oid[0] = 0; /* sysctl internal magic */
|
|
|
|
oid[1] = 3; /* name2oid */
|
|
|
|
oidlen = sizeof(oid);
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
error = kernel_sysctl(td, oid, 2, oid, &oidlen,
|
2004-10-11 22:04:16 +00:00
|
|
|
(void *)name, strlen(name), &plen, flags);
|
2001-05-19 05:45:55 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
error = kernel_sysctl(td, oid, plen / sizeof(int), old, oldlenp,
|
2004-10-11 22:04:16 +00:00
|
|
|
new, newlen, retval, flags);
|
2001-05-19 05:45:55 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1995-11-13 13:54:09 +00:00
|
|
|
/*
|
|
|
|
* Transfer function to/from user space.
|
|
|
|
*/
|
|
|
|
static int
|
1998-08-24 08:39:39 +00:00
|
|
|
sysctl_old_user(struct sysctl_req *req, const void *p, size_t l)
|
1995-11-12 19:52:09 +00:00
|
|
|
{
|
2004-02-26 00:27:04 +00:00
|
|
|
size_t i, len, origidx;
|
Handle spurious page faults that may occur in no-fault sections of the
kernel.
When access restrictions are added to a page table entry, we flush the
corresponding virtual address mapping from the TLB. In contrast, when
access restrictions are removed from a page table entry, we do not
flush the virtual address mapping from the TLB. This is exactly as
recommended in AMD's documentation. In effect, when access
restrictions are removed from a page table entry, AMD's MMUs will
transparently refresh a stale TLB entry. In short, this saves us from
having to perform potentially costly TLB flushes. In contrast,
Intel's MMUs are allowed to generate a spurious page fault based upon
the stale TLB entry. Usually, such spurious page faults are handled
by vm_fault() without incident. However, when we are executing
no-fault sections of the kernel, we are not allowed to execute
vm_fault(). This change introduces special-case handling for spurious
page faults that occur in no-fault sections of the kernel.
In collaboration with: kib
Tested by: gibbs (an earlier version)
I would also like to acknowledge Hiroki Sato's assistance in
diagnosing this problem.
MFC after: 1 week
2012-03-22 04:52:51 +00:00
|
|
|
int error;
|
1995-11-12 19:52:09 +00:00
|
|
|
|
2004-02-26 00:27:04 +00:00
|
|
|
origidx = req->oldidx;
|
2009-05-15 14:41:44 +00:00
|
|
|
req->oldidx += l;
|
|
|
|
if (req->oldptr == NULL)
|
2004-02-26 00:27:04 +00:00
|
|
|
return (0);
|
2005-08-08 18:54:35 +00:00
|
|
|
/*
|
|
|
|
* If we have not wired the user supplied buffer and we are currently
|
|
|
|
* holding locks, drop a witness warning, as it's possible that
|
|
|
|
* write operations to the user page can sleep.
|
|
|
|
*/
|
|
|
|
if (req->lock != REQ_WIRED)
|
2003-03-04 21:03:05 +00:00
|
|
|
WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
|
|
|
|
"sysctl_old_user()");
|
2004-02-26 00:27:04 +00:00
|
|
|
i = l;
|
2004-03-16 06:53:03 +00:00
|
|
|
len = req->validlen;
|
2004-02-26 00:27:04 +00:00
|
|
|
if (len <= origidx)
|
|
|
|
i = 0;
|
|
|
|
else {
|
|
|
|
if (i > len - origidx)
|
|
|
|
i = len - origidx;
|
Handle spurious page faults that may occur in no-fault sections of the
kernel.
When access restrictions are added to a page table entry, we flush the
corresponding virtual address mapping from the TLB. In contrast, when
access restrictions are removed from a page table entry, we do not
flush the virtual address mapping from the TLB. This is exactly as
recommended in AMD's documentation. In effect, when access
restrictions are removed from a page table entry, AMD's MMUs will
transparently refresh a stale TLB entry. In short, this saves us from
having to perform potentially costly TLB flushes. In contrast,
Intel's MMUs are allowed to generate a spurious page fault based upon
the stale TLB entry. Usually, such spurious page faults are handled
by vm_fault() without incident. However, when we are executing
no-fault sections of the kernel, we are not allowed to execute
vm_fault(). This change introduces special-case handling for spurious
page faults that occur in no-fault sections of the kernel.
In collaboration with: kib
Tested by: gibbs (an earlier version)
I would also like to acknowledge Hiroki Sato's assistance in
diagnosing this problem.
MFC after: 1 week
2012-03-22 04:52:51 +00:00
|
|
|
if (req->lock == REQ_WIRED) {
|
|
|
|
error = copyout_nofault(p, (char *)req->oldptr +
|
|
|
|
origidx, i);
|
|
|
|
} else
|
|
|
|
error = copyout(p, (char *)req->oldptr + origidx, i);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
1995-11-13 13:54:09 +00:00
|
|
|
}
|
2004-02-26 00:27:04 +00:00
|
|
|
if (i < l)
|
1995-11-12 19:52:09 +00:00
|
|
|
return (ENOMEM);
|
1995-11-13 13:54:09 +00:00
|
|
|
return (0);
|
1995-11-12 19:52:09 +00:00
|
|
|
}
|
|
|
|
|
1995-11-13 13:54:09 +00:00
|
|
|
static int
|
1998-08-24 08:39:39 +00:00
|
|
|
sysctl_new_user(struct sysctl_req *req, void *p, size_t l)
|
1995-11-12 19:52:09 +00:00
|
|
|
{
|
1995-11-14 09:26:17 +00:00
|
|
|
int error;
|
1995-11-13 13:54:09 +00:00
|
|
|
|
|
|
|
if (!req->newptr)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (0);
|
1995-11-13 13:54:09 +00:00
|
|
|
if (req->newlen - req->newidx < l)
|
1995-11-12 19:52:09 +00:00
|
|
|
return (EINVAL);
|
2005-08-08 21:06:42 +00:00
|
|
|
WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
|
|
|
|
"sysctl_new_user()");
|
1996-08-31 14:48:13 +00:00
|
|
|
error = copyin((char *)req->newptr + req->newidx, p, l);
|
1995-11-12 19:52:09 +00:00
|
|
|
req->newidx += l;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2002-07-22 08:25:37 +00:00
|
|
|
/*
|
|
|
|
* Wire the user space destination buffer. If set to a value greater than
|
|
|
|
* zero, the len parameter limits the maximum amount of wired memory.
|
|
|
|
*/
|
2004-02-26 00:27:04 +00:00
|
|
|
int
|
2002-07-22 08:25:37 +00:00
|
|
|
sysctl_wire_old_buffer(struct sysctl_req *req, size_t len)
|
|
|
|
{
|
2004-02-26 00:27:04 +00:00
|
|
|
int ret;
|
2009-05-15 21:34:58 +00:00
|
|
|
size_t wiredlen;
|
2004-02-26 00:27:04 +00:00
|
|
|
|
|
|
|
wiredlen = (len > 0 && len < req->oldlen) ? len : req->oldlen;
|
|
|
|
ret = 0;
|
2011-01-26 22:48:09 +00:00
|
|
|
if (req->lock != REQ_WIRED && req->oldptr &&
|
2003-10-05 05:38:30 +00:00
|
|
|
req->oldfunc == sysctl_old_user) {
|
2004-03-16 01:28:45 +00:00
|
|
|
if (wiredlen != 0) {
|
|
|
|
ret = vslock(req->oldptr, wiredlen);
|
2004-06-11 02:20:37 +00:00
|
|
|
if (ret != 0) {
|
|
|
|
if (ret != ENOMEM)
|
|
|
|
return (ret);
|
|
|
|
wiredlen = 0;
|
|
|
|
}
|
2004-02-26 00:27:04 +00:00
|
|
|
}
|
2004-03-16 01:28:45 +00:00
|
|
|
req->lock = REQ_WIRED;
|
2004-03-16 06:53:03 +00:00
|
|
|
req->validlen = wiredlen;
|
2002-07-22 08:25:37 +00:00
|
|
|
}
|
2004-03-16 01:28:45 +00:00
|
|
|
return (0);
|
2002-07-22 08:25:37 +00:00
|
|
|
}
|
|
|
|
|
1995-11-06 16:18:52 +00:00
|
|
|
int
|
1999-12-01 02:25:19 +00:00
|
|
|
sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
|
|
|
|
int *nindx, struct sysctl_req *req)
|
1995-11-06 16:18:52 +00:00
|
|
|
{
|
2010-11-29 18:18:00 +00:00
|
|
|
struct sysctl_oid_list *lsp;
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid *oid;
|
1999-12-01 02:25:19 +00:00
|
|
|
int indx;
|
1995-11-06 16:18:52 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
2010-11-29 18:18:00 +00:00
|
|
|
lsp = &sysctl__children;
|
1995-11-06 16:18:52 +00:00
|
|
|
indx = 0;
|
2010-11-29 18:18:00 +00:00
|
|
|
while (indx < CTL_MAXNAME) {
|
|
|
|
SLIST_FOREACH(oid, lsp, oid_link) {
|
|
|
|
if (oid->oid_number == name[indx])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (oid == NULL)
|
|
|
|
return (ENOENT);
|
|
|
|
|
|
|
|
indx++;
|
|
|
|
if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
|
|
|
if (oid->oid_handler != NULL || indx == namelen) {
|
1999-12-01 02:25:19 +00:00
|
|
|
*noid = oid;
|
|
|
|
if (nindx != NULL)
|
|
|
|
*nindx = indx;
|
2010-11-29 18:18:07 +00:00
|
|
|
KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
|
|
|
|
("%s found DYING node %p", __func__, oid));
|
1999-12-01 02:25:19 +00:00
|
|
|
return (0);
|
1995-11-06 16:18:52 +00:00
|
|
|
}
|
2010-11-29 18:18:00 +00:00
|
|
|
lsp = SYSCTL_CHILDREN(oid);
|
|
|
|
} else if (indx == namelen) {
|
|
|
|
*noid = oid;
|
|
|
|
if (nindx != NULL)
|
|
|
|
*nindx = indx;
|
2010-11-29 18:18:07 +00:00
|
|
|
KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
|
|
|
|
("%s found DYING node %p", __func__, oid));
|
2010-11-29 18:18:00 +00:00
|
|
|
return (0);
|
1995-11-06 16:18:52 +00:00
|
|
|
} else {
|
2010-11-29 18:18:00 +00:00
|
|
|
return (ENOTDIR);
|
1995-11-06 16:18:52 +00:00
|
|
|
}
|
|
|
|
}
|
1999-12-01 02:25:19 +00:00
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Traverse our tree, and find the right node, execute whatever it points
|
|
|
|
* to, and return the resulting error code.
|
|
|
|
*/
|
|
|
|
|
2002-09-28 17:15:38 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_root(SYSCTL_HANDLER_ARGS)
|
1999-12-01 02:25:19 +00:00
|
|
|
{
|
|
|
|
struct sysctl_oid *oid;
|
2003-01-14 19:35:33 +00:00
|
|
|
int error, indx, lvl;
|
1999-12-01 02:25:19 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_ASSERT_XLOCKED();
|
2008-12-29 12:58:45 +00:00
|
|
|
|
1999-12-01 02:25:19 +00:00
|
|
|
error = sysctl_find_oid(arg1, arg2, &oid, &indx, req);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
|
|
|
/*
|
|
|
|
* You can't call a sysctl when it's a node, but has
|
|
|
|
* no handler. Inform the user that it's a node.
|
|
|
|
* The indx may or may not be the same as namelen.
|
|
|
|
*/
|
|
|
|
if (oid->oid_handler == NULL)
|
|
|
|
return (EISDIR);
|
|
|
|
}
|
|
|
|
|
2001-09-26 19:51:25 +00:00
|
|
|
/* Is this sysctl writable? */
|
|
|
|
if (req->newptr && !(oid->oid_kind & CTLFLAG_WR))
|
1995-11-06 16:18:52 +00:00
|
|
|
return (EPERM);
|
|
|
|
|
2002-03-22 14:58:27 +00:00
|
|
|
KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL"));
|
|
|
|
|
2011-07-17 23:05:24 +00:00
|
|
|
#ifdef CAPABILITY_MODE
|
|
|
|
/*
|
|
|
|
* If the process is in capability mode, then don't permit reading or
|
|
|
|
* writing unless specifically granted for the node.
|
|
|
|
*/
|
|
|
|
if (IN_CAPABILITY_MODE(req->td)) {
|
|
|
|
if (req->oldptr && !(oid->oid_kind & CTLFLAG_CAPRD))
|
|
|
|
return (EPERM);
|
|
|
|
if (req->newptr && !(oid->oid_kind & CTLFLAG_CAPWR))
|
|
|
|
return (EPERM);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-09-26 19:51:25 +00:00
|
|
|
/* Is this sysctl sensitive to securelevels? */
|
|
|
|
if (req->newptr && (oid->oid_kind & CTLFLAG_SECURE)) {
|
2003-01-14 19:35:33 +00:00
|
|
|
lvl = (oid->oid_kind & CTLMASK_SECURE) >> CTLSHIFT_SECURE;
|
|
|
|
error = securelevel_gt(req->td->td_ucred, lvl);
|
2002-03-22 14:58:27 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2001-09-26 19:51:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Is this sysctl writable by only privileged users? */
|
|
|
|
if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) {
|
2009-08-13 10:26:34 +00:00
|
|
|
int priv;
|
|
|
|
|
2002-03-22 14:58:27 +00:00
|
|
|
if (oid->oid_kind & CTLFLAG_PRISON)
|
2009-08-13 10:26:34 +00:00
|
|
|
priv = PRIV_SYSCTL_WRITEJAIL;
|
|
|
|
#ifdef VIMAGE
|
|
|
|
else if ((oid->oid_kind & CTLFLAG_VNET) &&
|
|
|
|
prison_owns_vnet(req->td->td_ucred))
|
|
|
|
priv = PRIV_SYSCTL_WRITEJAIL;
|
|
|
|
#endif
|
2002-03-22 14:58:27 +00:00
|
|
|
else
|
2009-08-13 10:26:34 +00:00
|
|
|
priv = PRIV_SYSCTL_WRITE;
|
|
|
|
error = priv_check(req->td, priv);
|
2002-03-22 14:58:27 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2001-09-26 19:51:25 +00:00
|
|
|
}
|
1995-12-17 21:11:22 +00:00
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (!oid->oid_handler)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (EINVAL);
|
1995-11-06 16:18:52 +00:00
|
|
|
|
2004-02-22 12:31:44 +00:00
|
|
|
if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
2004-07-28 06:42:41 +00:00
|
|
|
arg1 = (int *)arg1 + indx;
|
2004-02-22 12:31:44 +00:00
|
|
|
arg2 -= indx;
|
|
|
|
} else {
|
|
|
|
arg1 = oid->oid_arg1;
|
|
|
|
arg2 = oid->oid_arg2;
|
|
|
|
}
|
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_system_check_sysctl(req->td->td_ucred, oid, arg1, arg2,
|
2004-02-22 12:31:44 +00:00
|
|
|
req);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
#endif
|
2014-02-07 13:47:33 +00:00
|
|
|
#ifdef VIMAGE
|
|
|
|
if ((oid->oid_kind & CTLFLAG_VNET) && arg1 != NULL)
|
|
|
|
arg1 = (void *)(curvnet->vnet_data_base + (uintptr_t)arg1);
|
|
|
|
#endif
|
2014-06-28 03:56:17 +00:00
|
|
|
error = sysctl_root_handler_locked(oid, arg1, arg2, req);
|
2004-02-22 12:31:44 +00:00
|
|
|
|
2010-11-29 18:18:07 +00:00
|
|
|
KFAIL_POINT_ERROR(_debug_fail_point, sysctl_running, error);
|
|
|
|
|
1999-12-01 02:25:19 +00:00
|
|
|
return (error);
|
1995-11-06 16:18:52 +00:00
|
|
|
}
|
|
|
|
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
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;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
int
|
2011-09-16 13:58:51 +00:00
|
|
|
sys___sysctl(struct thread *td, struct sysctl_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2009-02-06 14:51:32 +00:00
|
|
|
int error, i, name[CTL_MAXNAME];
|
1998-08-24 08:39:39 +00:00
|
|
|
size_t j;
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
|
|
|
|
return (EINVAL);
|
1995-10-28 12:59:25 +00:00
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
error = copyin(uap->name, &name, uap->namelen * sizeof(int));
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
error = userland_sysctl(td, name, uap->namelen,
|
1995-11-09 20:22:12 +00:00
|
|
|
uap->old, uap->oldlenp, 0,
|
2004-10-11 22:04:16 +00:00
|
|
|
uap->new, uap->newlen, &j, 0);
|
1995-11-13 13:54:09 +00:00
|
|
|
if (error && error != ENOMEM)
|
2008-12-29 12:58:45 +00:00
|
|
|
return (error);
|
2009-01-01 00:19:51 +00:00
|
|
|
if (uap->oldlenp) {
|
2009-02-06 14:51:32 +00:00
|
|
|
i = copyout(&j, uap->oldlenp, sizeof(j));
|
2009-01-01 00:19:51 +00:00
|
|
|
if (i)
|
|
|
|
return (i);
|
|
|
|
}
|
1995-11-13 13:54:09 +00:00
|
|
|
return (error);
|
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
|
2001-09-12 08:38:13 +00:00
|
|
|
userland_sysctl(struct thread *td, int *name, u_int namelen, void *old,
|
2004-10-11 22:04:16 +00:00
|
|
|
size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval,
|
|
|
|
int flags)
|
1995-11-09 20:22:12 +00:00
|
|
|
{
|
2009-05-14 22:01:32 +00:00
|
|
|
int error = 0, memlocked;
|
2004-03-16 06:53:03 +00:00
|
|
|
struct sysctl_req req;
|
1995-11-12 19:52:09 +00:00
|
|
|
|
|
|
|
bzero(&req, sizeof req);
|
1995-11-09 20:22:12 +00:00
|
|
|
|
2001-11-08 02:13:18 +00:00
|
|
|
req.td = td;
|
2004-10-11 22:04:16 +00:00
|
|
|
req.flags = flags;
|
1995-11-14 09:26:17 +00:00
|
|
|
|
1995-11-09 20:22:12 +00:00
|
|
|
if (oldlenp) {
|
|
|
|
if (inkernel) {
|
1995-11-12 19:52:09 +00:00
|
|
|
req.oldlen = *oldlenp;
|
1995-11-09 20:22:12 +00:00
|
|
|
} else {
|
1995-11-13 13:54:09 +00:00
|
|
|
error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp));
|
1995-11-09 20:22:12 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
2004-03-16 06:53:03 +00:00
|
|
|
req.validlen = req.oldlen;
|
1995-11-09 20:22:12 +00:00
|
|
|
|
1995-11-12 19:52:09 +00:00
|
|
|
if (old) {
|
1999-10-30 06:32:05 +00:00
|
|
|
if (!useracc(old, req.oldlen, VM_PROT_WRITE))
|
1995-11-12 19:52:09 +00:00
|
|
|
return (EFAULT);
|
|
|
|
req.oldptr= old;
|
|
|
|
}
|
1995-11-06 16:18:52 +00:00
|
|
|
|
2001-06-03 04:58:51 +00:00
|
|
|
if (new != NULL) {
|
2007-09-02 09:59:33 +00:00
|
|
|
if (!useracc(new, newlen, VM_PROT_READ))
|
1995-11-12 19:52:09 +00:00
|
|
|
return (EFAULT);
|
|
|
|
req.newlen = newlen;
|
|
|
|
req.newptr = new;
|
1995-10-28 12:59:25 +00:00
|
|
|
}
|
|
|
|
|
1995-11-12 19:52:09 +00:00
|
|
|
req.oldfunc = sysctl_old_user;
|
|
|
|
req.newfunc = sysctl_new_user;
|
2011-01-26 22:48:09 +00:00
|
|
|
req.lock = REQ_UNWIRED;
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2009-03-11 21:48:36 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
if (KTRPOINT(curthread, KTR_SYSCTL))
|
|
|
|
ktrsysctl(name, namelen);
|
|
|
|
#endif
|
2009-05-14 22:01:32 +00:00
|
|
|
|
|
|
|
if (req.oldlen > PAGE_SIZE) {
|
|
|
|
memlocked = 1;
|
|
|
|
sx_xlock(&sysctlmemlock);
|
|
|
|
} else
|
|
|
|
memlocked = 0;
|
2009-06-15 19:01:53 +00:00
|
|
|
CURVNET_SET(TD_TO_VNET(td));
|
1995-11-12 19:52:09 +00:00
|
|
|
|
2008-12-12 12:06:28 +00:00
|
|
|
for (;;) {
|
2004-03-16 06:53:03 +00:00
|
|
|
req.oldidx = 0;
|
|
|
|
req.newidx = 0;
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XLOCK();
|
2004-03-16 06:53:03 +00:00
|
|
|
error = sysctl_root(0, name, namelen, &req);
|
2010-11-29 18:18:07 +00:00
|
|
|
SYSCTL_XUNLOCK();
|
2008-12-12 12:06:28 +00:00
|
|
|
if (error != EAGAIN)
|
|
|
|
break;
|
2011-05-13 05:27:58 +00:00
|
|
|
kern_yield(PRI_USER);
|
2008-12-12 12:06:28 +00:00
|
|
|
}
|
1995-10-28 12:59:25 +00:00
|
|
|
|
2008-11-26 22:32:07 +00:00
|
|
|
CURVNET_RESTORE();
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2008-12-29 12:58:45 +00:00
|
|
|
if (req.lock == REQ_WIRED && req.validlen > 0)
|
|
|
|
vsunlock(req.oldptr, req.validlen);
|
2009-05-14 22:01:32 +00:00
|
|
|
if (memlocked)
|
|
|
|
sx_xunlock(&sysctlmemlock);
|
2008-12-29 12:58:45 +00:00
|
|
|
|
1995-11-13 13:54:09 +00:00
|
|
|
if (error && error != ENOMEM)
|
1995-11-06 16:18:52 +00:00
|
|
|
return (error);
|
1995-11-13 13:54:09 +00:00
|
|
|
|
|
|
|
if (retval) {
|
2004-03-16 06:53:03 +00:00
|
|
|
if (req.oldptr && req.oldidx > req.validlen)
|
|
|
|
*retval = req.validlen;
|
1995-11-13 13:54:09 +00:00
|
|
|
else
|
|
|
|
*retval = req.oldidx;
|
1995-11-06 16:18:52 +00:00
|
|
|
}
|
1995-11-13 13:54:09 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2010-09-16 16:13:12 +00:00
|
|
|
|
|
|
|
/*
|
2011-01-27 00:34:12 +00:00
|
|
|
* Drain into a sysctl struct. The user buffer should be wired if a page
|
|
|
|
* fault would cause issue.
|
2010-09-16 16:13:12 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sbuf_sysctl_drain(void *arg, const char *data, int len)
|
|
|
|
{
|
|
|
|
struct sysctl_req *req = arg;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = SYSCTL_OUT(req, data, len);
|
|
|
|
KASSERT(error >= 0, ("Got unexpected negative value %d", error));
|
|
|
|
return (error == 0 ? len : -error);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct sbuf *
|
|
|
|
sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length,
|
|
|
|
struct sysctl_req *req)
|
|
|
|
{
|
|
|
|
|
|
|
|
s = sbuf_new(s, buf, length, SBUF_FIXEDLEN);
|
|
|
|
sbuf_set_drain(s, sbuf_sysctl_drain, req);
|
|
|
|
return (s);
|
|
|
|
}
|