Rename printf -> kprintf in sys/ and add some defines where necessary
[dragonfly.git] / sys / kern / kern_sysctl.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 1982, 1986, 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Mike Karels at Berkeley Software Design, Inc.
7 *
8 * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
9 * project, to make these variables more userfriendly.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the University of
22 * California, Berkeley and its contributors.
23 * 4. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 * @(#)kern_sysctl.c 8.4 (Berkeley) 4/14/94
40 * $FreeBSD: src/sys/kern/kern_sysctl.c,v 1.92.2.9 2003/05/01 22:48:09 trhodes Exp $
6ea70f76 41 * $DragonFly: src/sys/kern/kern_sysctl.c,v 1.25 2006/12/23 00:35:04 swildner Exp $
984263bc
MD
42 */
43
984263bc
MD
44#include <sys/param.h>
45#include <sys/systm.h>
46#include <sys/kernel.h>
47#include <sys/buf.h>
48#include <sys/sysctl.h>
49#include <sys/malloc.h>
50#include <sys/proc.h>
51#include <sys/sysproto.h>
853af6eb 52#include <sys/lock.h>
984263bc
MD
53#include <vm/vm.h>
54#include <vm/vm_extern.h>
55
56static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic");
57static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids");
58
853af6eb
JS
59static struct lock sysctl_lkp;
60static struct lock sysctl_ctx_lkp;
61
62static void sysctl_lock(int type);
63static void sysctl_unlock(void);
64static void sysctl_ctx_lock(int type);
65static void sysctl_ctx_unlock(void);
984263bc 66
853af6eb
JS
67static int sysctl_root(SYSCTL_HANDLER_ARGS);
68static void sysctl_register_oid_int(struct sysctl_oid *oipd);
69static void sysctl_unregister_oid_int(struct sysctl_oid *oipd);
70static struct sysctl_ctx_entry* sysctl_ctx_entry_find_int
71 (struct sysctl_ctx_list *, struct sysctl_oid *oidp);
984263bc
MD
72
73struct sysctl_oid_list sysctl__children; /* root list */
74
75static struct sysctl_oid *
853af6eb 76sysctl_find_oidname(const char *name, struct sysctl_oid_list *list, int lock)
984263bc
MD
77{
78 struct sysctl_oid *oidp;
79
80 SLIST_FOREACH(oidp, list, oid_link) {
81 if (strcmp(oidp->oid_name, name) == 0) {
853af6eb 82 break;
984263bc
MD
83 }
84 }
853af6eb 85 return (oidp);
984263bc
MD
86}
87
88/*
89 * Initialization of the MIB tree.
90 *
91 * Order by number in each list.
92 */
93
853af6eb
JS
94void
95sysctl_register_oid(struct sysctl_oid *oidp)
96{
97 sysctl_lock(LK_EXCLUSIVE);
98 sysctl_register_oid_int(oidp);
99 sysctl_unlock();
100}
101
102static void
103sysctl_register_oid_int(struct sysctl_oid *oidp)
984263bc
MD
104{
105 struct sysctl_oid_list *parent = oidp->oid_parent;
106 struct sysctl_oid *p;
107 struct sysctl_oid *q;
984263bc
MD
108
109 /*
110 * First check if another oid with the same name already
111 * exists in the parent's list.
112 */
853af6eb 113 p = sysctl_find_oidname(oidp->oid_name, parent, 0);
984263bc 114 if (p != NULL) {
853af6eb 115 if ((p->oid_kind & CTLTYPE) == CTLTYPE_NODE)
984263bc 116 p->oid_refcnt++;
853af6eb 117 else
6ea70f76 118 kprintf("can't re-use a leaf (%s)!\n", p->oid_name);
853af6eb 119 return;
984263bc 120 }
853af6eb 121
984263bc
MD
122 /*
123 * If this oid has a number OID_AUTO, give it a number which
124 * is greater than any current oid. Make sure it is at least
1e32b918 125 * 256 to leave space for pre-assigned oid numbers.
984263bc
MD
126 */
127 if (oidp->oid_number == OID_AUTO) {
1e32b918
MD
128 int newoid = 0x100; /* minimum AUTO oid */
129
130 /*
131 * Adjust based on highest oid in parent list
132 */
133 SLIST_FOREACH(p, parent, oid_link) {
134 if (newoid <= p->oid_number)
135 newoid = p->oid_number + 1;
136 }
137 oidp->oid_number = newoid;
984263bc
MD
138 }
139
140 /*
141 * Insert the oid into the parent's list in order.
142 */
143 q = NULL;
144 SLIST_FOREACH(p, parent, oid_link) {
145 if (oidp->oid_number < p->oid_number)
146 break;
147 q = p;
148 }
149 if (q)
150 SLIST_INSERT_AFTER(q, oidp, oid_link);
151 else
152 SLIST_INSERT_HEAD(parent, oidp, oid_link);
153}
154
853af6eb
JS
155void
156sysctl_unregister_oid(struct sysctl_oid *oidp)
157{
158 sysctl_lock(LK_EXCLUSIVE);
159 sysctl_unregister_oid_int(oidp);
160 sysctl_unlock();
161}
162
163static void
164sysctl_unregister_oid_int(struct sysctl_oid *oidp)
984263bc 165{
fef0fdf2 166 struct sysctl_oid *p;
984263bc 167
853af6eb 168 if (oidp->oid_number == OID_AUTO)
fc92d4aa 169 panic("Trying to unregister OID_AUTO entry: %p", oidp);
853af6eb
JS
170
171 SLIST_FOREACH(p, oidp->oid_parent, oid_link) {
172 if (p != oidp)
173 continue;
174 SLIST_REMOVE(oidp->oid_parent, oidp, sysctl_oid, oid_link);
175 return;
fef0fdf2
MD
176 }
177
178 /*
179 * This can happen when a module fails to register and is
180 * being unloaded afterwards. It should not be a panic()
181 * for normal use.
182 */
6ea70f76 183 kprintf("%s: failed to unregister sysctl\n", __func__);
984263bc
MD
184}
185
186/* Initialize a new context to keep track of dynamically added sysctls. */
187int
188sysctl_ctx_init(struct sysctl_ctx_list *c)
189{
853af6eb
JS
190 if (c == NULL)
191 return(EINVAL);
984263bc 192 TAILQ_INIT(c);
853af6eb 193 return(0);
984263bc
MD
194}
195
196/* Free the context, and destroy all dynamic oids registered in this context */
197int
198sysctl_ctx_free(struct sysctl_ctx_list *clist)
199{
200 struct sysctl_ctx_entry *e, *e1;
201 int error;
202
203 error = 0;
853af6eb 204 sysctl_ctx_lock(LK_EXCLUSIVE);
984263bc
MD
205 /*
206 * First perform a "dry run" to check if it's ok to remove oids.
207 * XXX FIXME
208 * XXX This algorithm is a hack. But I don't know any
209 * XXX better solution for now...
210 */
211 TAILQ_FOREACH(e, clist, link) {
212 error = sysctl_remove_oid(e->entry, 0, 0);
213 if (error)
214 break;
215 }
216 /*
217 * Restore deregistered entries, either from the end,
218 * or from the place where error occured.
219 * e contains the entry that was not unregistered
220 */
221 if (error)
222 e1 = TAILQ_PREV(e, sysctl_ctx_list, link);
223 else
224 e1 = TAILQ_LAST(clist, sysctl_ctx_list);
225 while (e1 != NULL) {
226 sysctl_register_oid(e1->entry);
227 e1 = TAILQ_PREV(e1, sysctl_ctx_list, link);
228 }
853af6eb
JS
229 if (error) {
230 sysctl_ctx_unlock();
984263bc 231 return(EBUSY);
853af6eb 232 }
984263bc
MD
233 /* Now really delete the entries */
234 e = TAILQ_FIRST(clist);
235 while (e != NULL) {
236 e1 = TAILQ_NEXT(e, link);
237 error = sysctl_remove_oid(e->entry, 1, 0);
238 if (error)
239 panic("sysctl_remove_oid: corrupt tree, entry: %s",
240 e->entry->oid_name);
efda3bd0 241 kfree(e, M_SYSCTLOID);
984263bc
MD
242 e = e1;
243 }
853af6eb 244 sysctl_ctx_unlock();
984263bc
MD
245 return (error);
246}
247
248/* Add an entry to the context */
249struct sysctl_ctx_entry *
250sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
251{
252 struct sysctl_ctx_entry *e;
253
254 if (clist == NULL || oidp == NULL)
255 return(NULL);
efda3bd0 256 e = kmalloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK);
984263bc 257 e->entry = oidp;
853af6eb 258 sysctl_ctx_lock(LK_EXCLUSIVE);
984263bc 259 TAILQ_INSERT_HEAD(clist, e, link);
853af6eb 260 sysctl_ctx_unlock();
984263bc
MD
261 return (e);
262}
263
264/* Find an entry in the context */
265struct sysctl_ctx_entry *
266sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
267{
268 struct sysctl_ctx_entry *e;
269
270 if (clist == NULL || oidp == NULL)
271 return(NULL);
853af6eb
JS
272
273 sysctl_ctx_lock(LK_SHARED);
274 e = sysctl_ctx_entry_find_int(clist, oidp);
275 sysctl_ctx_unlock();
276
277 return(e);
278}
279
280struct sysctl_ctx_entry *
281sysctl_ctx_entry_find_int(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
282{
283 struct sysctl_ctx_entry *e;
284
285 KKASSERT(clist != NULL && oidp != NULL);
286
984263bc
MD
287 for (e = TAILQ_FIRST(clist); e != NULL; e = TAILQ_NEXT(e, link)) {
288 if(e->entry == oidp)
853af6eb 289 break;
984263bc 290 }
853af6eb 291
984263bc
MD
292 return (e);
293}
294
295/*
296 * Delete an entry from the context.
297 * NOTE: this function doesn't free oidp! You have to remove it
298 * with sysctl_remove_oid().
299 */
300int
301sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
302{
303 struct sysctl_ctx_entry *e;
304
305 if (clist == NULL || oidp == NULL)
306 return (EINVAL);
853af6eb
JS
307
308 sysctl_ctx_lock(LK_EXCLUSIVE);
309 e = sysctl_ctx_entry_find_int(clist, oidp);
310 if (e == NULL) {
311 sysctl_ctx_unlock();
984263bc 312 return (ENOENT);
853af6eb
JS
313 }
314 TAILQ_REMOVE(clist, e, link);
efda3bd0 315 kfree(e, M_SYSCTLOID);
853af6eb
JS
316 sysctl_ctx_unlock();
317
318 return(0);
984263bc
MD
319}
320
321/*
322 * Remove dynamically created sysctl trees.
323 * oidp - top of the tree to be removed
324 * del - if 0 - just deregister, otherwise free up entries as well
325 * recurse - if != 0 traverse the subtree to be deleted
326 */
327int
328sysctl_remove_oid(struct sysctl_oid *oidp, int del, int recurse)
329{
330 struct sysctl_oid *p;
331 int error;
332
333 if (oidp == NULL)
334 return(EINVAL);
335 if ((oidp->oid_kind & CTLFLAG_DYN) == 0) {
6ea70f76 336 kprintf("can't remove non-dynamic nodes!\n");
984263bc
MD
337 return (EINVAL);
338 }
853af6eb 339 sysctl_lock(LK_EXCLUSIVE | LK_CANRECURSE);
984263bc
MD
340 /*
341 * WARNING: normal method to do this should be through
342 * sysctl_ctx_free(). Use recursing as the last resort
343 * method to purge your sysctl tree of leftovers...
344 * However, if some other code still references these nodes,
345 * it will panic.
346 */
347 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
348 if (oidp->oid_refcnt == 1) {
349 SLIST_FOREACH(p, SYSCTL_CHILDREN(oidp), oid_link) {
853af6eb
JS
350 if (!recurse) {
351 sysctl_unlock();
352 return(ENOTEMPTY);
353 }
984263bc 354 error = sysctl_remove_oid(p, del, recurse);
853af6eb
JS
355 if (error) {
356 sysctl_unlock();
357 return(error);
358 }
984263bc
MD
359 }
360 if (del)
efda3bd0 361 kfree(SYSCTL_CHILDREN(oidp), M_SYSCTLOID);
984263bc
MD
362 }
363 }
364 if (oidp->oid_refcnt > 1 ) {
365 oidp->oid_refcnt--;
366 } else {
367 if (oidp->oid_refcnt == 0) {
6ea70f76 368 kprintf("Warning: bad oid_refcnt=%u (%s)!\n",
853af6eb
JS
369 oidp->oid_refcnt, oidp->oid_name);
370 sysctl_unlock();
371 return(EINVAL);
984263bc 372 }
853af6eb 373 sysctl_unregister_oid_int(oidp);
984263bc
MD
374 if (del) {
375 if (oidp->oid_descr)
efda3bd0 376 kfree(__DECONST(char *,oidp->oid_descr),
853af6eb 377 M_SYSCTLOID);
efda3bd0
MD
378 kfree(__DECONST(char *, oidp->oid_name), M_SYSCTLOID);
379 kfree(oidp, M_SYSCTLOID);
984263bc
MD
380 }
381 }
853af6eb
JS
382 sysctl_unlock();
383 return(0);
984263bc
MD
384}
385
386/*
387 * Create new sysctls at run time.
388 * clist may point to a valid context initialized with sysctl_ctx_init().
389 */
390struct sysctl_oid *
391sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
392 int number, const char *name, int kind, void *arg1, int arg2,
393 int (*handler)(SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr)
394{
395 struct sysctl_oid *oidp;
396 ssize_t len;
397 char *newname;
398
399 /* You have to hook up somewhere.. */
400 if (parent == NULL)
401 return(NULL);
853af6eb 402 sysctl_lock(LK_EXCLUSIVE);
984263bc 403 /* Check if the node already exists, otherwise create it */
853af6eb 404 oidp = sysctl_find_oidname(name, parent, 0);
984263bc
MD
405 if (oidp != NULL) {
406 if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
407 oidp->oid_refcnt++;
408 /* Update the context */
409 if (clist != NULL)
410 sysctl_ctx_entry_add(clist, oidp);
853af6eb 411 sysctl_unlock();
984263bc
MD
412 return (oidp);
413 } else {
6ea70f76 414 kprintf("can't re-use a leaf (%s)!\n", name);
853af6eb 415 sysctl_unlock();
984263bc
MD
416 return (NULL);
417 }
418 }
efda3bd0 419 oidp = kmalloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK | M_ZERO);
984263bc
MD
420 oidp->oid_parent = parent;
421 SLIST_NEXT(oidp, oid_link) = NULL;
422 oidp->oid_number = number;
423 oidp->oid_refcnt = 1;
424 len = strlen(name);
efda3bd0 425 newname = kmalloc(len + 1, M_SYSCTLOID, M_WAITOK);
984263bc
MD
426 bcopy(name, newname, len + 1);
427 newname[len] = '\0';
428 oidp->oid_name = newname;
429 oidp->oid_handler = handler;
430 oidp->oid_kind = CTLFLAG_DYN | kind;
431 if ((kind & CTLTYPE) == CTLTYPE_NODE) {
6d9b622e
JS
432 struct sysctl_oid_list *children;
433
984263bc 434 /* Allocate space for children */
efda3bd0 435 children = kmalloc(sizeof(*children), M_SYSCTLOID, M_WAITOK);
6d9b622e
JS
436 SYSCTL_SET_CHILDREN(oidp, children);
437 SLIST_INIT(children);
984263bc
MD
438 } else {
439 oidp->oid_arg1 = arg1;
440 oidp->oid_arg2 = arg2;
441 }
442 oidp->oid_fmt = fmt;
443 if (descr) {
444 int len = strlen(descr) + 1;
efda3bd0 445 oidp->oid_descr = kmalloc(len, M_SYSCTLOID, M_WAITOK);
984263bc
MD
446 if (oidp->oid_descr)
447 strcpy((char *)(uintptr_t)(const void *)oidp->oid_descr, descr);
448 };
449 /* Update the context, if used */
450 if (clist != NULL)
451 sysctl_ctx_entry_add(clist, oidp);
452 /* Register this oid */
853af6eb
JS
453 sysctl_register_oid_int(oidp);
454 sysctl_unlock();
984263bc
MD
455 return (oidp);
456}
457
984263bc
MD
458/*
459 * Register the kernel's oids on startup.
460 */
dc62b251 461SET_DECLARE(sysctl_set, struct sysctl_oid);
984263bc
MD
462
463static void sysctl_register_all(void *arg)
464{
dc62b251 465 struct sysctl_oid **oidp;
984263bc 466
f2770c70
MD
467 lockinit(&sysctl_lkp, "sysctl", 0, 0);
468 lockinit(&sysctl_ctx_lkp, "sysctl ctx", 0, 0);
dc62b251 469 SET_FOREACH(oidp, sysctl_set)
853af6eb 470 sysctl_register_oid_int(*oidp);
984263bc
MD
471}
472
473SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_register_all, 0);
474
475/*
476 * "Staff-functions"
477 *
478 * These functions implement a presently undocumented interface
479 * used by the sysctl program to walk the tree, and get the type
480 * so it can print the value.
481 * This interface is under work and consideration, and should probably
482 * be killed with a big axe by the first person who can find the time.
483 * (be aware though, that the proper interface isn't as obvious as it
484 * may seem, there are various conflicting requirements.
485 *
6ea70f76 486 * {0,0} kprintf the entire MIB-tree.
984263bc
MD
487 * {0,1,...} return the name of the "..." OID.
488 * {0,2,...} return the next OID.
489 * {0,3} return the OID of the name in "new"
490 * {0,4,...} return the kind & format info for the "..." OID.
491 */
492
493static void
494sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i)
495{
496 int k;
497 struct sysctl_oid *oidp;
498
853af6eb 499 sysctl_lock(LK_SHARED);
984263bc
MD
500 SLIST_FOREACH(oidp, l, oid_link) {
501
502 for (k=0; k<i; k++)
6ea70f76 503 kprintf(" ");
984263bc 504
6ea70f76 505 kprintf("%d %s ", oidp->oid_number, oidp->oid_name);
984263bc 506
6ea70f76 507 kprintf("%c%c",
984263bc
MD
508 oidp->oid_kind & CTLFLAG_RD ? 'R':' ',
509 oidp->oid_kind & CTLFLAG_WR ? 'W':' ');
510
511 if (oidp->oid_handler)
6ea70f76 512 kprintf(" *Handler");
984263bc
MD
513
514 switch (oidp->oid_kind & CTLTYPE) {
515 case CTLTYPE_NODE:
6ea70f76 516 kprintf(" Node\n");
984263bc
MD
517 if (!oidp->oid_handler) {
518 sysctl_sysctl_debug_dump_node(
519 oidp->oid_arg1, i+2);
520 }
521 break;
6ea70f76
SW
522 case CTLTYPE_INT: kprintf(" Int\n"); break;
523 case CTLTYPE_STRING: kprintf(" String\n"); break;
524 case CTLTYPE_QUAD: kprintf(" Quad\n"); break;
525 case CTLTYPE_OPAQUE: kprintf(" Opaque/struct\n"); break;
526 default: kprintf("\n");
984263bc
MD
527 }
528
529 }
853af6eb 530 sysctl_unlock();
984263bc
MD
531}
532
533static int
534sysctl_sysctl_debug(SYSCTL_HANDLER_ARGS)
535{
536 int error;
537
dadab5e9 538 error = suser(req->td);
984263bc
MD
539 if (error)
540 return error;
541 sysctl_sysctl_debug_dump_node(&sysctl__children, 0);
542 return ENOENT;
543}
544
545SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD,
546 0, 0, sysctl_sysctl_debug, "-", "");
547
548static int
549sysctl_sysctl_name(SYSCTL_HANDLER_ARGS)
550{
551 int *name = (int *) arg1;
552 u_int namelen = arg2;
553 int error = 0;
554 struct sysctl_oid *oid;
555 struct sysctl_oid_list *lsp = &sysctl__children, *lsp2;
556 char buf[10];
557
853af6eb 558 sysctl_lock(LK_SHARED);
984263bc
MD
559 while (namelen) {
560 if (!lsp) {
f8c7a42d 561 ksnprintf(buf,sizeof(buf),"%d",*name);
984263bc
MD
562 if (req->oldidx)
563 error = SYSCTL_OUT(req, ".", 1);
564 if (!error)
565 error = SYSCTL_OUT(req, buf, strlen(buf));
853af6eb
JS
566 if (error) {
567 sysctl_unlock();
984263bc 568 return (error);
853af6eb 569 }
984263bc
MD
570 namelen--;
571 name++;
572 continue;
573 }
574 lsp2 = 0;
575 SLIST_FOREACH(oid, lsp, oid_link) {
576 if (oid->oid_number != *name)
577 continue;
578
579 if (req->oldidx)
580 error = SYSCTL_OUT(req, ".", 1);
581 if (!error)
582 error = SYSCTL_OUT(req, oid->oid_name,
583 strlen(oid->oid_name));
853af6eb
JS
584 if (error) {
585 sysctl_unlock();
984263bc 586 return (error);
853af6eb 587 }
984263bc
MD
588
589 namelen--;
590 name++;
591
592 if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
593 break;
594
595 if (oid->oid_handler)
596 break;
597
598 lsp2 = (struct sysctl_oid_list *)oid->oid_arg1;
599 break;
600 }
601 lsp = lsp2;
602 }
853af6eb 603 sysctl_unlock();
984263bc
MD
604 return (SYSCTL_OUT(req, "", 1));
605}
606
607SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD, sysctl_sysctl_name, "");
608
609static int
610sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
611 int *next, int *len, int level, struct sysctl_oid **oidpp)
612{
613 struct sysctl_oid *oidp;
614
615 *len = level;
853af6eb 616 sysctl_lock(LK_SHARED);
984263bc
MD
617 SLIST_FOREACH(oidp, lsp, oid_link) {
618 *next = oidp->oid_number;
619 *oidpp = oidp;
620
621 if (!namelen) {
853af6eb
JS
622 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) {
623 sysctl_unlock();
984263bc 624 return 0;
853af6eb
JS
625 }
626 if (oidp->oid_handler) {
984263bc 627 /* We really should call the handler here...*/
853af6eb 628 sysctl_unlock();
984263bc 629 return 0;
853af6eb 630 }
984263bc
MD
631 lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
632 if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
853af6eb
JS
633 len, level+1, oidpp)) {
634 sysctl_unlock();
984263bc 635 return 0;
853af6eb 636 }
fef0fdf2 637 goto emptynode;
984263bc
MD
638 }
639
640 if (oidp->oid_number < *name)
641 continue;
642
643 if (oidp->oid_number > *name) {
853af6eb
JS
644 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) {
645 sysctl_unlock();
984263bc 646 return 0;
853af6eb
JS
647 }
648 if (oidp->oid_handler) {
649 sysctl_unlock();
984263bc 650 return 0;
853af6eb 651 }
984263bc
MD
652 lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
653 if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
853af6eb
JS
654 next+1, len, level+1, oidpp)) {
655 sysctl_unlock();
984263bc 656 return (0);
853af6eb 657 }
984263bc
MD
658 goto next;
659 }
660 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
661 continue;
662
663 if (oidp->oid_handler)
664 continue;
665
666 lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
667 if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
853af6eb
JS
668 len, level+1, oidpp)) {
669 sysctl_unlock();
984263bc 670 return (0);
853af6eb 671 }
984263bc
MD
672 next:
673 namelen = 1;
674 *len = level;
fef0fdf2
MD
675 emptynode:
676 *len = level;
984263bc 677 }
853af6eb 678 sysctl_unlock();
984263bc
MD
679 return 1;
680}
681
682static int
683sysctl_sysctl_next(SYSCTL_HANDLER_ARGS)
684{
685 int *name = (int *) arg1;
686 u_int namelen = arg2;
687 int i, j, error;
688 struct sysctl_oid *oid;
689 struct sysctl_oid_list *lsp = &sysctl__children;
690 int newoid[CTL_MAXNAME];
691
692 i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid);
693 if (i)
694 return ENOENT;
695 error = SYSCTL_OUT(req, newoid, j * sizeof (int));
696 return (error);
697}
698
699SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD, sysctl_sysctl_next, "");
700
701static int
702name2oid (char *name, int *oid, int *len, struct sysctl_oid **oidpp)
703{
704 int i;
705 struct sysctl_oid *oidp;
706 struct sysctl_oid_list *lsp = &sysctl__children;
707 char *p;
708
709 if (!*name)
710 return ENOENT;
711
712 p = name + strlen(name) - 1 ;
713 if (*p == '.')
714 *p = '\0';
715
716 *len = 0;
717
718 for (p = name; *p && *p != '.'; p++)
719 ;
720 i = *p;
721 if (i == '.')
722 *p = '\0';
723
853af6eb 724 sysctl_lock(LK_SHARED);
984263bc
MD
725 oidp = SLIST_FIRST(lsp);
726
727 while (oidp && *len < CTL_MAXNAME) {
728 if (strcmp(name, oidp->oid_name)) {
729 oidp = SLIST_NEXT(oidp, oid_link);
730 continue;
731 }
732 *oid++ = oidp->oid_number;
733 (*len)++;
734
735 if (!i) {
736 if (oidpp)
737 *oidpp = oidp;
853af6eb 738 sysctl_unlock();
984263bc
MD
739 return (0);
740 }
741
742 if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
743 break;
744
745 if (oidp->oid_handler)
746 break;
747
748 lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
749 oidp = SLIST_FIRST(lsp);
750 name = p+1;
751 for (p = name; *p && *p != '.'; p++)
752 ;
753 i = *p;
754 if (i == '.')
755 *p = '\0';
756 }
853af6eb 757 sysctl_unlock();
984263bc
MD
758 return ENOENT;
759}
760
761static int
762sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS)
763{
764 char *p;
765 int error, oid[CTL_MAXNAME], len;
766 struct sysctl_oid *op = 0;
767
768 if (!req->newlen)
769 return ENOENT;
770 if (req->newlen >= MAXPATHLEN) /* XXX arbitrary, undocumented */
771 return (ENAMETOOLONG);
772
efda3bd0 773 p = kmalloc(req->newlen+1, M_SYSCTL, M_WAITOK);
984263bc
MD
774
775 error = SYSCTL_IN(req, p, req->newlen);
776 if (error) {
efda3bd0 777 kfree(p, M_SYSCTL);
984263bc
MD
778 return (error);
779 }
780
781 p [req->newlen] = '\0';
782
783 error = name2oid(p, oid, &len, &op);
784
efda3bd0 785 kfree(p, M_SYSCTL);
984263bc
MD
786
787 if (error)
788 return (error);
789
790 error = SYSCTL_OUT(req, oid, len * sizeof *oid);
791 return (error);
792}
793
794SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0,
795 sysctl_sysctl_name2oid, "I", "");
796
797static int
798sysctl_sysctl_oidfmt(SYSCTL_HANDLER_ARGS)
799{
800 struct sysctl_oid *oid;
801 int error;
802
803 error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
804 if (error)
805 return (error);
806
807 if (!oid->oid_fmt)
808 return (ENOENT);
809 error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind));
810 if (error)
811 return (error);
812 error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1);
813 return (error);
814}
815
816
817SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD, sysctl_sysctl_oidfmt, "");
818
819static int
820sysctl_sysctl_oiddescr(SYSCTL_HANDLER_ARGS)
821{
822 struct sysctl_oid *oid;
823 int error;
824
825 error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
826 if (error)
827 return (error);
828
829 if (!oid->oid_descr)
830 return (ENOENT);
831 error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1);
832 return (error);
833}
834
835SYSCTL_NODE(_sysctl, 5, oiddescr, CTLFLAG_RD, sysctl_sysctl_oiddescr, "");
836
837/*
838 * Default "handler" functions.
839 */
840
841/*
842 * Handle an int, signed or unsigned.
843 * Two cases:
844 * a variable: point arg1 at it.
845 * a constant: pass it in arg2.
846 */
847
848int
849sysctl_handle_int(SYSCTL_HANDLER_ARGS)
850{
851 int error = 0;
852
853 if (arg1)
854 error = SYSCTL_OUT(req, arg1, sizeof(int));
855 else
856 error = SYSCTL_OUT(req, &arg2, sizeof(int));
857
858 if (error || !req->newptr)
859 return (error);
860
861 if (!arg1)
862 error = EPERM;
863 else
864 error = SYSCTL_IN(req, arg1, sizeof(int));
865 return (error);
866}
867
868/*
869 * Handle a long, signed or unsigned. arg1 points to it.
870 */
871
872int
873sysctl_handle_long(SYSCTL_HANDLER_ARGS)
874{
875 int error = 0;
876
877 if (!arg1)
878 return (EINVAL);
879 error = SYSCTL_OUT(req, arg1, sizeof(long));
880
881 if (error || !req->newptr)
882 return (error);
883
884 error = SYSCTL_IN(req, arg1, sizeof(long));
885 return (error);
886}
887
5f2e2a8b
MD
888/*
889 * Handle a quad, signed or unsigned. arg1 points to it.
890 */
891
892int
893sysctl_handle_quad(SYSCTL_HANDLER_ARGS)
894{
895 int error = 0;
896
897 if (!arg1)
898 return (EINVAL);
899 error = SYSCTL_OUT(req, arg1, sizeof(quad_t));
900
901 if (error || !req->newptr)
902 return (error);
903
904 error = SYSCTL_IN(req, arg1, sizeof(quad_t));
905 return (error);
906}
907
984263bc
MD
908/*
909 * Handle our generic '\0' terminated 'C' string.
910 * Two cases:
911 * a variable string: point arg1 at it, arg2 is max length.
912 * a constant string: point arg1 at it, arg2 is zero.
913 */
914
915int
916sysctl_handle_string(SYSCTL_HANDLER_ARGS)
917{
918 int error=0;
919
920 error = SYSCTL_OUT(req, arg1, strlen((char *)arg1)+1);
921
922 if (error || !req->newptr)
923 return (error);
924
925 if ((req->newlen - req->newidx) >= arg2) {
926 error = EINVAL;
927 } else {
928 arg2 = (req->newlen - req->newidx);
929 error = SYSCTL_IN(req, arg1, arg2);
930 ((char *)arg1)[arg2] = '\0';
931 }
932
933 return (error);
934}
935
936/*
937 * Handle any kind of opaque data.
938 * arg1 points to it, arg2 is the size.
939 */
940
941int
942sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
943{
944 int error;
945
946 error = SYSCTL_OUT(req, arg1, arg2);
947
948 if (error || !req->newptr)
949 return (error);
950
951 error = SYSCTL_IN(req, arg1, arg2);
952
953 return (error);
954}
955
956/*
957 * Transfer functions to/from kernel space.
958 * XXX: rather untested at this point
959 */
960static int
961sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l)
962{
963 size_t i = 0;
964
965 if (req->oldptr) {
966 i = l;
967 if (i > req->oldlen - req->oldidx)
968 i = req->oldlen - req->oldidx;
969 if (i > 0)
970 bcopy(p, (char *)req->oldptr + req->oldidx, i);
971 }
972 req->oldidx += l;
973 if (req->oldptr && i != l)
974 return (ENOMEM);
975 return (0);
976}
977
978static int
979sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l)
980{
981
982 if (!req->newptr)
983 return 0;
984 if (req->newlen - req->newidx < l)
985 return (EINVAL);
986 bcopy((char *)req->newptr + req->newidx, p, l);
987 req->newidx += l;
988 return (0);
989}
990
991int
41c20dac 992kernel_sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval)
984263bc
MD
993{
994 int error = 0;
995 struct sysctl_req req;
996
997 bzero(&req, sizeof req);
998
dadab5e9 999 req.td = curthread;
984263bc
MD
1000
1001 if (oldlenp) {
1002 req.oldlen = *oldlenp;
1003 }
1004
1005 if (old) {
41c20dac 1006 req.oldptr = old;
984263bc
MD
1007 }
1008
1009 if (new != NULL) {
1010 req.newlen = newlen;
1011 req.newptr = new;
1012 }
1013
1014 req.oldfunc = sysctl_old_kernel;
1015 req.newfunc = sysctl_new_kernel;
1016 req.lock = 1;
1017
853af6eb 1018 sysctl_lock(LK_SHARED);
984263bc
MD
1019
1020 error = sysctl_root(0, name, namelen, &req);
1021
1022 if (req.lock == 2)
1023 vsunlock(req.oldptr, req.oldlen);
1024
853af6eb 1025 sysctl_unlock();
984263bc
MD
1026
1027 if (error && error != ENOMEM)
1028 return (error);
1029
1030 if (retval) {
1031 if (req.oldptr && req.oldidx > req.oldlen)
1032 *retval = req.oldlen;
1033 else
1034 *retval = req.oldidx;
1035 }
1036 return (error);
1037}
1038
1039int
41c20dac 1040kernel_sysctlbyname(char *name, void *old, size_t *oldlenp,
984263bc
MD
1041 void *new, size_t newlen, size_t *retval)
1042{
1043 int oid[CTL_MAXNAME];
1044 size_t oidlen, plen;
1045 int error;
1046
1047 oid[0] = 0; /* sysctl internal magic */
1048 oid[1] = 3; /* name2oid */
1049 oidlen = sizeof(oid);
1050
41c20dac
MD
1051 error = kernel_sysctl(oid, 2, oid, &oidlen, (void *)name,
1052 strlen(name), &plen);
984263bc
MD
1053 if (error)
1054 return (error);
1055
41c20dac 1056 error = kernel_sysctl(oid, plen / sizeof(int), old, oldlenp,
984263bc
MD
1057 new, newlen, retval);
1058 return (error);
1059}
1060
1061/*
1062 * Transfer function to/from user space.
1063 */
1064static int
1065sysctl_old_user(struct sysctl_req *req, const void *p, size_t l)
1066{
1067 int error = 0;
1068 size_t i = 0;
1069
1070 if (req->lock == 1 && req->oldptr) {
1071 vslock(req->oldptr, req->oldlen);
1072 req->lock = 2;
1073 }
1074 if (req->oldptr) {
1075 i = l;
1076 if (i > req->oldlen - req->oldidx)
1077 i = req->oldlen - req->oldidx;
1078 if (i > 0)
1079 error = copyout(p, (char *)req->oldptr + req->oldidx,
1080 i);
1081 }
1082 req->oldidx += l;
1083 if (error)
1084 return (error);
1085 if (req->oldptr && i < l)
1086 return (ENOMEM);
1087 return (0);
1088}
1089
1090static int
1091sysctl_new_user(struct sysctl_req *req, void *p, size_t l)
1092{
1093 int error;
1094
1095 if (!req->newptr)
1096 return 0;
1097 if (req->newlen - req->newidx < l)
1098 return (EINVAL);
1099 error = copyin((char *)req->newptr + req->newidx, p, l);
1100 req->newidx += l;
1101 return (error);
1102}
1103
1104int
1105sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
1106 int *nindx, struct sysctl_req *req)
1107{
1108 struct sysctl_oid *oid;
1109 int indx;
1110
853af6eb 1111 sysctl_lock(LK_SHARED);
984263bc
MD
1112 oid = SLIST_FIRST(&sysctl__children);
1113 indx = 0;
1114 while (oid && indx < CTL_MAXNAME) {
1115 if (oid->oid_number == name[indx]) {
1116 indx++;
1117 if (oid->oid_kind & CTLFLAG_NOLOCK)
1118 req->lock = 0;
1119 if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1120 if (oid->oid_handler != NULL ||
1121 indx == namelen) {
1122 *noid = oid;
1123 if (nindx != NULL)
1124 *nindx = indx;
853af6eb 1125 sysctl_unlock();
984263bc
MD
1126 return (0);
1127 }
1128 oid = SLIST_FIRST(
1129 (struct sysctl_oid_list *)oid->oid_arg1);
1130 } else if (indx == namelen) {
1131 *noid = oid;
1132 if (nindx != NULL)
1133 *nindx = indx;
853af6eb 1134 sysctl_unlock();
984263bc
MD
1135 return (0);
1136 } else {
853af6eb 1137 sysctl_unlock();
984263bc
MD
1138 return (ENOTDIR);
1139 }
1140 } else {
1141 oid = SLIST_NEXT(oid, oid_link);
1142 }
1143 }
853af6eb 1144 sysctl_unlock();
984263bc
MD
1145 return (ENOENT);
1146}
1147
1148/*
1149 * Traverse our tree, and find the right node, execute whatever it points
1150 * to, and return the resulting error code.
1151 */
1152
1153int
1154sysctl_root(SYSCTL_HANDLER_ARGS)
1155{
dadab5e9
MD
1156 struct thread *td = req->td;
1157 struct proc *p = td ? td->td_proc : NULL;
984263bc
MD
1158 struct sysctl_oid *oid;
1159 int error, indx;
1160
1161 error = sysctl_find_oid(arg1, arg2, &oid, &indx, req);
1162 if (error)
1163 return (error);
1164
1165 if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1166 /*
1167 * You can't call a sysctl when it's a node, but has
1168 * no handler. Inform the user that it's a node.
1169 * The indx may or may not be the same as namelen.
1170 */
1171 if (oid->oid_handler == NULL)
1172 return (EISDIR);
1173 }
1174
1175 /* If writing isn't allowed */
1176 if (req->newptr && (!(oid->oid_kind & CTLFLAG_WR) ||
1177 ((oid->oid_kind & CTLFLAG_SECURE) && securelevel > 0)))
1178 return (EPERM);
1179
1180 /* Most likely only root can write */
26a0694b 1181 if (!(oid->oid_kind & CTLFLAG_ANYBODY) && req->newptr && p &&
dadab5e9 1182 (error = suser_cred(p->p_ucred,
41c20dac 1183 (oid->oid_kind & CTLFLAG_PRISON) ? PRISON_ROOT : 0)))
984263bc
MD
1184 return (error);
1185
1186 if (!oid->oid_handler)
1187 return EINVAL;
1188
1189 if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE)
1190 error = oid->oid_handler(oid, (int *)arg1 + indx, arg2 - indx,
1191 req);
1192 else
1193 error = oid->oid_handler(oid, oid->oid_arg1, oid->oid_arg2,
1194 req);
1195 return (error);
1196}
1197
984263bc 1198int
753fd850 1199sys___sysctl(struct sysctl_args *uap)
984263bc
MD
1200{
1201 int error, i, name[CTL_MAXNAME];
1202 size_t j;
1203
1204 if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
1205 return (EINVAL);
1206
1207 error = copyin(uap->name, &name, uap->namelen * sizeof(int));
1208 if (error)
1209 return (error);
1210
41c20dac 1211 error = userland_sysctl(name, uap->namelen,
984263bc
MD
1212 uap->old, uap->oldlenp, 0,
1213 uap->new, uap->newlen, &j);
1214 if (error && error != ENOMEM)
1215 return (error);
1216 if (uap->oldlenp) {
1217 i = copyout(&j, uap->oldlenp, sizeof(j));
1218 if (i)
1219 return (i);
1220 }
1221 return (error);
1222}
1223
1224/*
1225 * This is used from various compatibility syscalls too. That's why name
1226 * must be in kernel space.
1227 */
1228int
41c20dac 1229userland_sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval)
984263bc
MD
1230{
1231 int error = 0;
1232 struct sysctl_req req, req2;
1233
1234 bzero(&req, sizeof req);
1235
984263bc
MD
1236 if (oldlenp) {
1237 if (inkernel) {
1238 req.oldlen = *oldlenp;
1239 } else {
1240 error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp));
1241 if (error)
1242 return (error);
1243 }
1244 }
1245
1246 if (old) {
1247 if (!useracc(old, req.oldlen, VM_PROT_WRITE))
1248 return (EFAULT);
1249 req.oldptr= old;
1250 }
1251
1252 if (new != NULL) {
1253 if (!useracc(new, req.newlen, VM_PROT_READ))
1254 return (EFAULT);
1255 req.newlen = newlen;
1256 req.newptr = new;
1257 }
1258
1259 req.oldfunc = sysctl_old_user;
1260 req.newfunc = sysctl_new_user;
1261 req.lock = 1;
5f2e2a8b 1262 req.td = curthread;
984263bc 1263
853af6eb 1264 sysctl_lock(LK_SHARED);
984263bc
MD
1265
1266 do {
1267 req2 = req;
1268 error = sysctl_root(0, name, namelen, &req2);
1269 } while (error == EAGAIN);
1270
1271 req = req2;
1272 if (req.lock == 2)
1273 vsunlock(req.oldptr, req.oldlen);
1274
853af6eb 1275 sysctl_unlock();
984263bc
MD
1276
1277 if (error && error != ENOMEM)
1278 return (error);
1279
1280 if (retval) {
1281 if (req.oldptr && req.oldidx > req.oldlen)
1282 *retval = req.oldlen;
1283 else
1284 *retval = req.oldidx;
1285 }
1286 return (error);
1287}
853af6eb
JS
1288
1289static void
1290sysctl_lock(int flag)
1291{
df4f70a6 1292 lockmgr(&sysctl_lkp, flag);
853af6eb
JS
1293}
1294
1295static void
1296sysctl_unlock(void)
1297{
df4f70a6 1298 lockmgr(&sysctl_lkp, LK_RELEASE);
853af6eb
JS
1299}
1300
1301static void
1302sysctl_ctx_lock(int flag)
1303{
df4f70a6 1304 lockmgr(&sysctl_ctx_lkp, flag);
853af6eb
JS
1305}
1306
1307static void
1308sysctl_ctx_unlock(void)
1309{
df4f70a6 1310 lockmgr(&sysctl_ctx_lkp, LK_RELEASE);
853af6eb 1311}
df4f70a6 1312