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$");
|
|
|
|
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
2002-10-27 07:12:34 +00:00
|
|
|
#include "opt_mac.h"
|
1997-12-16 17:40:42 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
1999-06-27 11:44:22 +00:00
|
|
|
#include <sys/systm.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>
|
2001-09-01 18:19:21 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.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>
|
2008-11-26 22:32:07 +00:00
|
|
|
#include <sys/vimage.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
|
|
|
/*
|
2002-04-02 05:50:07 +00:00
|
|
|
* Locking - this locks the sysctl tree in memory.
|
1995-11-20 12:42:39 +00:00
|
|
|
*/
|
2002-04-02 05:50:07 +00:00
|
|
|
static struct sx sysctllock;
|
2002-04-02 04:20:38 +00:00
|
|
|
|
2002-04-02 05:50:07 +00:00
|
|
|
#define SYSCTL_LOCK() sx_xlock(&sysctllock)
|
2002-10-26 18:19:46 +00:00
|
|
|
#define SYSCTL_UNLOCK() sx_xunlock(&sysctllock)
|
2008-12-29 12:58:45 +00:00
|
|
|
#define SYSCTL_LOCK_ASSERT() sx_assert(&sysctllock, SX_XLOCKED)
|
2003-03-11 20:01:51 +00:00
|
|
|
#define SYSCTL_INIT() sx_init(&sysctllock, "sysctl lock")
|
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
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
struct sysctl_oid_list sysctl__children; /* root list */
|
1995-11-08 08:48:36 +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;
|
|
|
|
|
|
|
|
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
|
|
|
*/
|
1995-11-20 12:42:39 +00:00
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
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);
|
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;
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
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...
|
|
|
|
*/
|
|
|
|
TAILQ_FOREACH(e, clist, link) {
|
|
|
|
error = sysctl_remove_oid(e->entry, 0, 0);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
return(EBUSY);
|
|
|
|
/* Now really delete the entries */
|
|
|
|
e = TAILQ_FIRST(clist);
|
|
|
|
while (e != NULL) {
|
|
|
|
e1 = TAILQ_NEXT(e, link);
|
|
|
|
error = sysctl_remove_oid(e->entry, 1, 0);
|
|
|
|
if (error)
|
|
|
|
panic("sysctl_remove_oid: corrupt tree, entry: %s",
|
|
|
|
e->entry->oid_name);
|
|
|
|
free(e, M_SYSCTLOID);
|
|
|
|
e = e1;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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);
|
|
|
|
e = sysctl_ctx_entry_find(clist, oidp);
|
|
|
|
if (e != NULL) {
|
|
|
|
TAILQ_REMOVE(clist, e, link);
|
|
|
|
free(e, M_SYSCTLOID);
|
|
|
|
return (0);
|
|
|
|
} else
|
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
struct sysctl_oid *p;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
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) {
|
|
|
|
SLIST_FOREACH(p, SYSCTL_CHILDREN(oidp), oid_link) {
|
|
|
|
if (!recurse)
|
|
|
|
return (ENOTEMPTY);
|
|
|
|
error = sysctl_remove_oid(p, del, recurse);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (del)
|
|
|
|
free(SYSCTL_CHILDREN(oidp), M_SYSCTLOID);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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) {
|
2005-02-07 07:40:39 +00:00
|
|
|
if (oidp->oid_descr)
|
|
|
|
free((void *)(uintptr_t)(const void *)oidp->oid_descr, M_SYSCTLOID);
|
2000-07-28 22:40:04 +00:00
|
|
|
free((void *)(uintptr_t)(const void *)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,
|
2001-01-05 07:00:45 +00:00
|
|
|
int number, const char *name, int kind, void *arg1, int arg2,
|
|
|
|
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;
|
|
|
|
ssize_t len;
|
2000-07-28 22:40:04 +00:00
|
|
|
char *newname;
|
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
|
|
|
|
|
|
|
/* You have to hook up somewhere.. */
|
|
|
|
if (parent == NULL)
|
|
|
|
return(NULL);
|
|
|
|
/* Check if the node already exists, otherwise create it */
|
|
|
|
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);
|
|
|
|
return (oidp);
|
|
|
|
} else {
|
|
|
|
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;
|
|
|
|
SLIST_NEXT(oidp, oid_link) = NULL;
|
|
|
|
oidp->oid_number = number;
|
|
|
|
oidp->oid_refcnt = 1;
|
|
|
|
len = strlen(name);
|
2003-02-19 05:47:46 +00:00
|
|
|
newname = malloc(len + 1, M_SYSCTLOID, M_WAITOK);
|
2000-07-28 22:40:04 +00:00
|
|
|
bcopy(name, newname, len + 1);
|
|
|
|
newname[len] = '\0';
|
|
|
|
oidp->oid_name = newname;
|
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;
|
|
|
|
if ((kind & CTLTYPE) == CTLTYPE_NODE) {
|
|
|
|
/* Allocate space for children */
|
2004-07-28 06:42:41 +00:00
|
|
|
SYSCTL_CHILDREN_SET(oidp, malloc(sizeof(struct sysctl_oid_list),
|
|
|
|
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
|
|
|
SLIST_INIT(SYSCTL_CHILDREN(oidp));
|
|
|
|
} else {
|
|
|
|
oidp->oid_arg1 = arg1;
|
|
|
|
oidp->oid_arg2 = arg2;
|
|
|
|
}
|
|
|
|
oidp->oid_fmt = fmt;
|
2001-12-16 02:55:41 +00:00
|
|
|
if (descr) {
|
|
|
|
int len = strlen(descr) + 1;
|
2005-02-07 07:40:39 +00:00
|
|
|
oidp->oid_descr = malloc(len, M_SYSCTLOID, M_WAITOK);
|
|
|
|
if (oidp->oid_descr)
|
|
|
|
strcpy((char *)(uintptr_t)(const void *)oidp->oid_descr, descr);
|
2001-12-16 02:55:41 +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
|
|
|
/* Update the context, if used */
|
|
|
|
if (clist != NULL)
|
|
|
|
sysctl_ctx_entry_add(clist, oidp);
|
|
|
|
/* Register this oid */
|
|
|
|
sysctl_register_oid(oidp);
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
ssize_t len;
|
|
|
|
char *newname;
|
|
|
|
void *oldname;
|
|
|
|
|
|
|
|
oldname = (void *)(uintptr_t)(const void *)oidp->oid_name;
|
|
|
|
len = strlen(name);
|
|
|
|
newname = malloc(len + 1, M_SYSCTLOID, M_WAITOK);
|
|
|
|
bcopy(name, newname, len + 1);
|
|
|
|
newname[len] = '\0';
|
|
|
|
oidp->oid_name = newname;
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (oid->oid_parent == parent)
|
|
|
|
return (0);
|
|
|
|
oidp = sysctl_find_oidname(oid->oid_name, parent);
|
|
|
|
if (oidp != NULL)
|
|
|
|
return (EEXIST);
|
|
|
|
sysctl_unregister_oid(oid);
|
|
|
|
oid->oid_parent = parent;
|
|
|
|
oid->oid_number = OID_AUTO;
|
|
|
|
sysctl_register_oid(oid);
|
|
|
|
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
|
|
|
|
2002-04-02 05:50:07 +00:00
|
|
|
SYSCTL_INIT();
|
2001-06-13 10:58:39 +00:00
|
|
|
SET_FOREACH(oidp, sysctl_set)
|
|
|
|
sysctl_register_oid(*oidp);
|
|
|
|
}
|
1999-02-16 10:49:55 +00:00
|
|
|
SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_register_all, 0);
|
|
|
|
|
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
|
|
|
|
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(
|
1999-02-16 10:49:55 +00:00
|
|
|
oidp->oid_arg1, i+2);
|
1995-11-08 08:48:36 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CTLTYPE_INT: printf(" Int\n"); break;
|
|
|
|
case CTLTYPE_STRING: printf(" String\n"); break;
|
|
|
|
case CTLTYPE_QUAD: printf(" Quad\n"); break;
|
|
|
|
case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break;
|
|
|
|
default: printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
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);
|
1999-02-16 10:49:55 +00:00
|
|
|
sysctl_sysctl_debug_dump_node(&sysctl__children, 0);
|
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];
|
|
|
|
|
|
|
|
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)
|
|
|
|
return (error);
|
|
|
|
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)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
1999-03-23 14:23:15 +00:00
|
|
|
lsp2 = (struct sysctl_oid_list *)oid->oid_arg1;
|
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
|
|
|
}
|
|
|
|
return (SYSCTL_OUT(req, "", 1));
|
|
|
|
}
|
|
|
|
|
2005-02-10 12:16:08 +00:00
|
|
|
static SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD, 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
|
|
|
|
|
|
|
*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);
|
1999-02-16 10:49:55 +00:00
|
|
|
lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
|
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);
|
1999-02-16 10:49:55 +00:00
|
|
|
lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
|
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;
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
|
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];
|
|
|
|
|
2000-07-28 22:40:04 +00:00
|
|
|
i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid);
|
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);
|
|
|
|
}
|
|
|
|
|
2005-02-10 12:16:08 +00:00
|
|
|
static SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD, sysctl_sysctl_next, "");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
static int
|
1999-02-16 10:49:55 +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
|
|
|
int i;
|
|
|
|
struct sysctl_oid *oidp;
|
|
|
|
struct sysctl_oid_list *lsp = &sysctl__children;
|
1995-12-04 16:48:58 +00:00
|
|
|
char *p;
|
|
|
|
|
2008-12-29 12:58:45 +00:00
|
|
|
SYSCTL_LOCK_ASSERT();
|
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
if (!*name)
|
2004-12-31 14:52:53 +00:00
|
|
|
return (ENOENT);
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
p = name + strlen(name) - 1 ;
|
|
|
|
if (*p == '.')
|
|
|
|
*p = '\0';
|
|
|
|
|
|
|
|
*len = 0;
|
|
|
|
|
|
|
|
for (p = name; *p && *p != '.'; p++)
|
|
|
|
;
|
|
|
|
i = *p;
|
|
|
|
if (i == '.')
|
|
|
|
*p = '\0';
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
oidp = SLIST_FIRST(lsp);
|
1995-12-04 16:48:58 +00:00
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
while (oidp && *len < CTL_MAXNAME) {
|
|
|
|
if (strcmp(name, oidp->oid_name)) {
|
|
|
|
oidp = SLIST_NEXT(oidp, oid_link);
|
1995-12-04 16:48:58 +00:00
|
|
|
continue;
|
|
|
|
}
|
1999-02-16 10:49:55 +00:00
|
|
|
*oid++ = oidp->oid_number;
|
1995-12-04 16:48:58 +00:00
|
|
|
(*len)++;
|
|
|
|
|
|
|
|
if (!i) {
|
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;
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
|
|
|
|
oidp = SLIST_FIRST(lsp);
|
1995-12-04 16:48:58 +00:00
|
|
|
name = p+1;
|
|
|
|
for (p = name; *p && *p != '.'; p++)
|
|
|
|
;
|
|
|
|
i = *p;
|
|
|
|
if (i == '.')
|
|
|
|
*p = '\0';
|
|
|
|
}
|
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;
|
|
|
|
int error, oid[CTL_MAXNAME], len;
|
|
|
|
struct sysctl_oid *op = 0;
|
|
|
|
|
2008-12-29 12:58:45 +00:00
|
|
|
SYSCTL_LOCK_ASSERT();
|
|
|
|
|
1995-12-04 16:48:58 +00:00
|
|
|
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';
|
|
|
|
|
|
|
|
error = name2oid(p, oid, &len, &op);
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
1995-12-17 21:11:22 +00:00
|
|
|
SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0,
|
1995-12-04 16:48:58 +00:00
|
|
|
sysctl_sysctl_name2oid, "I", "");
|
|
|
|
|
|
|
|
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
|
|
|
|
1999-12-01 02:25:19 +00:00
|
|
|
error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
1995-12-04 16:48:58 +00:00
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
if (!oid->oid_fmt)
|
1999-12-01 02:25:19 +00:00
|
|
|
return (ENOENT);
|
|
|
|
error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1);
|
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
|
|
|
|
2005-02-10 12:16:08 +00:00
|
|
|
static SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD, 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;
|
|
|
|
|
|
|
|
error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
2005-02-07 07:40:39 +00:00
|
|
|
if (!oid->oid_descr)
|
2001-12-16 02:55:41 +00:00
|
|
|
return (ENOENT);
|
2005-02-07 07:40:39 +00:00
|
|
|
error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1);
|
2001-12-16 02:55:41 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2005-02-10 12:16:08 +00:00
|
|
|
static SYSCTL_NODE(_sysctl, 5, oiddescr, CTLFLAG_RD, 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error, s, tt;
|
|
|
|
|
|
|
|
tt = *(int *)oidp->oid_arg1;
|
|
|
|
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);
|
|
|
|
|
|
|
|
*(int *)oidp->oid_arg1 = tt;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-08-24 08:39:39 +00:00
|
|
|
/*
|
1999-03-30 09:00:45 +00:00
|
|
|
* Handle a long, signed or unsigned. arg1 points to it.
|
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.
|
|
|
|
*/
|
1999-03-30 09:00:45 +00:00
|
|
|
if (!arg1)
|
|
|
|
return (EINVAL);
|
2004-10-11 22:04:16 +00:00
|
|
|
tmplong = *(long *)arg1;
|
|
|
|
#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);
|
|
|
|
|
2004-10-11 22:04:16 +00:00
|
|
|
#ifdef SCTL_MASK32
|
|
|
|
if (req->flags & SCTL_MASK32) {
|
|
|
|
error = SYSCTL_IN(req, &tmpint, sizeof(int));
|
|
|
|
*(long *)arg1 = (long)tmpint;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
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
|
|
|
/*
|
|
|
|
* Handle a 64 bit int, signed or unsigned. arg1 points to it.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
sysctl_handle_quad(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
uint64_t tmpout;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to get a coherent snapshot by making a copy of the data.
|
|
|
|
*/
|
|
|
|
if (!arg1)
|
|
|
|
return (EINVAL);
|
|
|
|
tmpout = *(uint64_t *)arg1;
|
|
|
|
error = SYSCTL_OUT(req, &tmpout, sizeof(uint64_t));
|
|
|
|
|
|
|
|
if (error || !req->newptr)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
error = SYSCTL_IN(req, arg1, sizeof(uint64_t));
|
|
|
|
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
|
|
|
{
|
1995-11-12 19:52:09 +00:00
|
|
|
int error=0;
|
2002-07-28 21:06:14 +00:00
|
|
|
char *tmparg;
|
|
|
|
size_t outlen;
|
1995-10-28 12:59:25 +00:00
|
|
|
|
2002-07-28 21:06:14 +00:00
|
|
|
/*
|
|
|
|
* Attempt to get a coherent snapshot by copying to a
|
|
|
|
* temporary kernel buffer.
|
|
|
|
*/
|
|
|
|
retry:
|
|
|
|
outlen = strlen((char *)arg1)+1;
|
2003-02-19 05:47:46 +00:00
|
|
|
tmparg = malloc(outlen, M_SYSCTLTMP, M_WAITOK);
|
2002-10-17 20:03:38 +00:00
|
|
|
|
|
|
|
if (strlcpy(tmparg, (char *)arg1, outlen) >= outlen) {
|
2002-07-28 21:06:14 +00:00
|
|
|
free(tmparg, M_SYSCTLTMP);
|
|
|
|
goto retry;
|
|
|
|
}
|
2002-10-17 20:03:38 +00:00
|
|
|
|
2002-07-28 21:06:14 +00:00
|
|
|
error = SYSCTL_OUT(req, tmparg, outlen);
|
|
|
|
free(tmparg, M_SYSCTLTMP);
|
1995-10-28 12:59:25 +00:00
|
|
|
|
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
|
|
|
}
|
1995-11-13 13:54:09 +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;
|
2003-10-05 05:38:30 +00:00
|
|
|
req.lock = REQ_LOCKED;
|
1996-06-10 16:23:42 +00:00
|
|
|
|
2002-04-02 05:50:07 +00:00
|
|
|
SYSCTL_LOCK();
|
1996-06-10 16:23:42 +00:00
|
|
|
error = sysctl_root(0, name, namelen, &req);
|
2008-12-29 12:58:45 +00:00
|
|
|
SYSCTL_UNLOCK();
|
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);
|
|
|
|
|
2008-12-29 12:58:45 +00:00
|
|
|
/*
|
|
|
|
* XXX: Prone to a possible race condition between lookup and
|
|
|
|
* execution? Maybe put locking around it?
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
{
|
1998-08-24 08:39:39 +00:00
|
|
|
int error = 0;
|
2004-02-26 00:27:04 +00:00
|
|
|
size_t i, len, origidx;
|
1995-11-12 19:52:09 +00:00
|
|
|
|
2004-02-26 00:27:04 +00:00
|
|
|
origidx = req->oldidx;
|
|
|
|
req->oldidx += l;
|
|
|
|
if (req->oldptr == NULL)
|
|
|
|
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;
|
|
|
|
error = copyout(p, (char *)req->oldptr + origidx, i);
|
1995-11-13 13:54:09 +00:00
|
|
|
}
|
1995-11-12 19:52:09 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
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;
|
2006-01-25 01:03:34 +00:00
|
|
|
size_t i, wiredlen;
|
|
|
|
char *cp, dummy;
|
2004-02-26 00:27:04 +00:00
|
|
|
|
|
|
|
wiredlen = (len > 0 && len < req->oldlen) ? len : req->oldlen;
|
|
|
|
ret = 0;
|
2003-10-05 05:38:30 +00:00
|
|
|
if (req->lock == REQ_LOCKED && req->oldptr &&
|
|
|
|
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;
|
|
|
|
}
|
2006-01-25 01:03:34 +00:00
|
|
|
/*
|
|
|
|
* Touch all the wired pages to avoid PTE modified
|
|
|
|
* bit emulation traps on Alpha while holding locks
|
|
|
|
* in the sysctl handler.
|
|
|
|
*/
|
|
|
|
for (i = (wiredlen + PAGE_SIZE - 1) / PAGE_SIZE,
|
|
|
|
cp = req->oldptr; i > 0; i--, cp += PAGE_SIZE) {
|
|
|
|
copyin(cp, &dummy, 1);
|
|
|
|
copyout(&dummy, cp, 1);
|
|
|
|
}
|
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
|
|
|
{
|
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
|
|
|
|
1999-12-01 02:25:19 +00:00
|
|
|
oid = SLIST_FIRST(&sysctl__children);
|
1995-11-06 16:18:52 +00:00
|
|
|
indx = 0;
|
1999-02-16 10:49:55 +00:00
|
|
|
while (oid && indx < CTL_MAXNAME) {
|
|
|
|
if (oid->oid_number == name[indx]) {
|
1995-11-06 16:18:52 +00:00
|
|
|
indx++;
|
1999-02-16 10:49:55 +00:00
|
|
|
if (oid->oid_kind & CTLFLAG_NOLOCK)
|
2003-10-05 05:38:30 +00:00
|
|
|
req->lock = REQ_UNLOCKED;
|
1999-02-16 10:49:55 +00:00
|
|
|
if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
|
1999-12-01 02:25:19 +00:00
|
|
|
if (oid->oid_handler != NULL ||
|
|
|
|
indx == namelen) {
|
|
|
|
*noid = oid;
|
|
|
|
if (nindx != NULL)
|
|
|
|
*nindx = indx;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
oid = SLIST_FIRST(
|
|
|
|
(struct sysctl_oid_list *)oid->oid_arg1);
|
|
|
|
} else if (indx == namelen) {
|
|
|
|
*noid = oid;
|
|
|
|
if (nindx != NULL)
|
|
|
|
*nindx = indx;
|
|
|
|
return (0);
|
1995-11-06 16:18:52 +00:00
|
|
|
} else {
|
1999-12-01 02:25:19 +00:00
|
|
|
return (ENOTDIR);
|
1995-11-06 16:18:52 +00:00
|
|
|
}
|
|
|
|
} else {
|
1999-02-16 10:49:55 +00:00
|
|
|
oid = SLIST_NEXT(oid, oid_link);
|
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
|
|
|
|
2008-12-29 12:58:45 +00:00
|
|
|
SYSCTL_LOCK_ASSERT();
|
|
|
|
|
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"));
|
|
|
|
|
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)) {
|
2002-03-22 14:58:27 +00:00
|
|
|
if (oid->oid_kind & CTLFLAG_PRISON)
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check(req->td, PRIV_SYSCTL_WRITEJAIL);
|
2002-03-22 14:58:27 +00:00
|
|
|
else
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(req->td, PRIV_SYSCTL_WRITE);
|
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
|
2008-12-29 12:58:45 +00:00
|
|
|
|
|
|
|
/* XXX: Handlers are not guaranteed to be Giant safe! */
|
|
|
|
mtx_lock(&Giant);
|
2004-02-22 12:31:44 +00:00
|
|
|
error = oid->oid_handler(oid, arg1, arg2, req);
|
2008-12-29 12:58:45 +00:00
|
|
|
mtx_unlock(&Giant);
|
2004-02-22 12:31:44 +00:00
|
|
|
|
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
|
2001-09-12 08:38:13 +00:00
|
|
|
__sysctl(struct thread *td, struct sysctl_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-01 18:19:21 +00:00
|
|
|
int error, 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) {
|
|
|
|
int i = copyout(&j, uap->oldlenp, sizeof(j));
|
|
|
|
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
|
|
|
{
|
1995-11-20 12:42:39 +00:00
|
|
|
int error = 0;
|
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;
|
2003-10-05 05:38:30 +00:00
|
|
|
req.lock = REQ_LOCKED;
|
1995-11-20 12:42:39 +00:00
|
|
|
|
2002-04-02 05:50:07 +00:00
|
|
|
SYSCTL_LOCK();
|
2008-11-26 22:32:07 +00:00
|
|
|
CURVNET_SET(TD_TO_VNET(curthread));
|
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;
|
|
|
|
error = sysctl_root(0, name, namelen, &req);
|
2008-12-12 12:06:28 +00:00
|
|
|
if (error != EAGAIN)
|
|
|
|
break;
|
|
|
|
uio_yield();
|
|
|
|
}
|
1995-10-28 12:59:25 +00:00
|
|
|
|
2008-11-26 22:32:07 +00:00
|
|
|
CURVNET_RESTORE();
|
2002-04-02 05:50:07 +00:00
|
|
|
SYSCTL_UNLOCK();
|
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);
|
|
|
|
|
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
|
|
|
}
|