The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_mib.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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  * 4. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      @(#)kern_sysctl.c       8.4 (Berkeley) 4/14/94
   36  */
   37 
   38 #include <sys/cdefs.h>
   39 __FBSDID("$FreeBSD: releng/11.0/sys/kern/kern_mib.c 295941 2016-02-23 23:37:10Z bdrewery $");
   40 
   41 #include "opt_compat.h"
   42 #include "opt_posix.h"
   43 #include "opt_config.h"
   44 
   45 #include <sys/param.h>
   46 #include <sys/jail.h>
   47 #include <sys/kernel.h>
   48 #include <sys/lock.h>
   49 #include <sys/mutex.h>
   50 #include <sys/proc.h>
   51 #include <sys/random.h>
   52 #include <sys/sbuf.h>
   53 #include <sys/smp.h>
   54 #include <sys/sx.h>
   55 #include <sys/sysctl.h>
   56 #include <sys/systm.h>
   57 #include <sys/unistd.h>
   58 
   59 SYSCTL_ROOT_NODE(0,       sysctl, CTLFLAG_RW, 0,
   60         "Sysctl internal magic");
   61 SYSCTL_ROOT_NODE(CTL_KERN,        kern,   CTLFLAG_RW|CTLFLAG_CAPRD, 0,
   62         "High kernel, proc, limits &c");
   63 SYSCTL_ROOT_NODE(CTL_VM,          vm,     CTLFLAG_RW, 0,
   64         "Virtual memory");
   65 SYSCTL_ROOT_NODE(CTL_VFS,         vfs,     CTLFLAG_RW, 0,
   66         "File system");
   67 SYSCTL_ROOT_NODE(CTL_NET,         net,    CTLFLAG_RW, 0,
   68         "Network, (see socket.h)");
   69 SYSCTL_ROOT_NODE(CTL_DEBUG,  debug,  CTLFLAG_RW, 0,
   70         "Debugging");
   71 SYSCTL_NODE(_debug, OID_AUTO,  sizeof,  CTLFLAG_RW, 0,
   72         "Sizeof various things");
   73 SYSCTL_ROOT_NODE(CTL_HW,          hw,     CTLFLAG_RW, 0,
   74         "hardware");
   75 SYSCTL_ROOT_NODE(CTL_MACHDEP, machdep, CTLFLAG_RW, 0,
   76         "machine dependent");
   77 SYSCTL_ROOT_NODE(CTL_USER,        user,   CTLFLAG_RW, 0,
   78         "user-level");
   79 SYSCTL_ROOT_NODE(CTL_P1003_1B,  p1003_1b,   CTLFLAG_RW, 0,
   80         "p1003_1b, (see p1003_1b.h)");
   81 
   82 SYSCTL_ROOT_NODE(OID_AUTO,  compat, CTLFLAG_RW, 0,
   83         "Compatibility code");
   84 SYSCTL_ROOT_NODE(OID_AUTO, security, CTLFLAG_RW, 0, 
   85         "Security");
   86 #ifdef REGRESSION
   87 SYSCTL_ROOT_NODE(OID_AUTO, regression, CTLFLAG_RW, 0,
   88      "Regression test MIB");
   89 #endif
   90 
   91 SYSCTL_STRING(_kern, OID_AUTO, ident, CTLFLAG_RD|CTLFLAG_MPSAFE,
   92     kern_ident, 0, "Kernel identifier");
   93 
   94 SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD|CTLFLAG_CAPRD,
   95     SYSCTL_NULL_INT_PTR, BSD, "Operating system revision");
   96 
   97 SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD|CTLFLAG_MPSAFE,
   98     version, 0, "Kernel version");
   99 
  100 SYSCTL_STRING(_kern, OID_AUTO, compiler_version, CTLFLAG_RD|CTLFLAG_MPSAFE,
  101     compiler_version, 0, "Version of compiler used to compile kernel");
  102 
  103 SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD|CTLFLAG_MPSAFE|
  104     CTLFLAG_CAPRD, ostype, 0, "Operating system type");
  105 
  106 SYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
  107     &maxproc, 0, "Maximum number of processes");
  108 
  109 SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid, CTLFLAG_RW,
  110     &maxprocperuid, 0, "Maximum processes allowed per userid");
  111 
  112 SYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RDTUN | CTLFLAG_NOFETCH,
  113     &maxusers, 0, "Hint for kernel tuning");
  114 
  115 SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD|CTLFLAG_CAPRD,
  116     SYSCTL_NULL_INT_PTR, ARG_MAX, "Maximum bytes of argument to execve(2)");
  117 
  118 SYSCTL_INT(_kern, KERN_POSIX1, posix1version, CTLFLAG_RD|CTLFLAG_CAPRD,
  119     SYSCTL_NULL_INT_PTR, _POSIX_VERSION, "Version of POSIX attempting to comply to");
  120 
  121 SYSCTL_INT(_kern, KERN_NGROUPS, ngroups, CTLFLAG_RDTUN |
  122     CTLFLAG_NOFETCH | CTLFLAG_CAPRD, &ngroups_max, 0,
  123     "Maximum number of supplemental groups a user can belong to");
  124 
  125 SYSCTL_INT(_kern, KERN_JOB_CONTROL, job_control, CTLFLAG_RD|CTLFLAG_CAPRD,
  126     SYSCTL_NULL_INT_PTR, 1, "Whether job control is available");
  127 
  128 #ifdef _POSIX_SAVED_IDS
  129 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD,
  130     SYSCTL_NULL_INT_PTR, 1, "Whether saved set-group/user ID is available");
  131 #else
  132 SYSCTL_INT(_kern, KERN_SAVED_IDS, saved_ids, CTLFLAG_RD|CTLFLAG_CAPRD,
  133     SYSCTL_NULL_INT_PTR, 0, "Whether saved set-group/user ID is available");
  134 #endif
  135 
  136 char kernelname[MAXPATHLEN] = "/kernel";        /* XXX bloat */
  137 
  138 SYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile, CTLFLAG_RW,
  139     kernelname, sizeof kernelname, "Name of kernel file booted");
  140 
  141 SYSCTL_INT(_hw, HW_NCPU, ncpu, CTLFLAG_RD|CTLFLAG_CAPRD,
  142     &mp_ncpus, 0, "Number of active CPUs");
  143 
  144 SYSCTL_INT(_hw, HW_BYTEORDER, byteorder, CTLFLAG_RD|CTLFLAG_CAPRD,
  145     SYSCTL_NULL_INT_PTR, BYTE_ORDER, "System byte order");
  146 
  147 SYSCTL_INT(_hw, HW_PAGESIZE, pagesize, CTLFLAG_RD|CTLFLAG_CAPRD,
  148     SYSCTL_NULL_INT_PTR, PAGE_SIZE, "System memory page size");
  149 
  150 static int
  151 sysctl_kern_arnd(SYSCTL_HANDLER_ARGS)
  152 {
  153         char buf[256];
  154         size_t len;
  155 
  156         /*-
  157          * This is one of the very few legitimate uses of read_random(9).
  158          * Use of arc4random(9) is not recommended as that will ignore
  159          * an unsafe (i.e. unseeded) random(4).
  160          *
  161          * If random(4) is not seeded, then this returns 0, so the
  162          * sysctl will return a zero-length buffer.
  163          */
  164         len = read_random(buf, MIN(req->oldlen, sizeof(buf)));
  165         return (SYSCTL_OUT(req, buf, len));
  166 }
  167 
  168 SYSCTL_PROC(_kern, KERN_ARND, arandom,
  169     CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD, NULL, 0,
  170     sysctl_kern_arnd, "", "arc4rand");
  171 
  172 static int
  173 sysctl_hw_physmem(SYSCTL_HANDLER_ARGS)
  174 {
  175         u_long val;
  176 
  177         val = ctob(physmem);
  178         return (sysctl_handle_long(oidp, &val, 0, req));
  179 }
  180 
  181 SYSCTL_PROC(_hw, HW_PHYSMEM, physmem, CTLTYPE_ULONG | CTLFLAG_RD,
  182         0, 0, sysctl_hw_physmem, "LU", "");
  183 
  184 static int
  185 sysctl_hw_realmem(SYSCTL_HANDLER_ARGS)
  186 {
  187         u_long val;
  188         val = ctob(realmem);
  189         return (sysctl_handle_long(oidp, &val, 0, req));
  190 }
  191 SYSCTL_PROC(_hw, HW_REALMEM, realmem, CTLTYPE_ULONG | CTLFLAG_RD,
  192         0, 0, sysctl_hw_realmem, "LU", "");
  193 static int
  194 sysctl_hw_usermem(SYSCTL_HANDLER_ARGS)
  195 {
  196         u_long val;
  197 
  198         val = ctob(physmem - vm_cnt.v_wire_count);
  199         return (sysctl_handle_long(oidp, &val, 0, req));
  200 }
  201 
  202 SYSCTL_PROC(_hw, HW_USERMEM, usermem, CTLTYPE_ULONG | CTLFLAG_RD,
  203         0, 0, sysctl_hw_usermem, "LU", "");
  204 
  205 SYSCTL_LONG(_hw, OID_AUTO, availpages, CTLFLAG_RD, &physmem, 0, "");
  206 
  207 u_long pagesizes[MAXPAGESIZES] = { PAGE_SIZE };
  208 
  209 static int
  210 sysctl_hw_pagesizes(SYSCTL_HANDLER_ARGS)
  211 {
  212         int error;
  213 #ifdef SCTL_MASK32
  214         int i;
  215         uint32_t pagesizes32[MAXPAGESIZES];
  216 
  217         if (req->flags & SCTL_MASK32) {
  218                 /*
  219                  * Recreate the "pagesizes" array with 32-bit elements.  Truncate
  220                  * any page size greater than UINT32_MAX to zero.
  221                  */
  222                 for (i = 0; i < MAXPAGESIZES; i++)
  223                         pagesizes32[i] = (uint32_t)pagesizes[i];
  224 
  225                 error = SYSCTL_OUT(req, pagesizes32, sizeof(pagesizes32));
  226         } else
  227 #endif
  228                 error = SYSCTL_OUT(req, pagesizes, sizeof(pagesizes));
  229         return (error);
  230 }
  231 SYSCTL_PROC(_hw, OID_AUTO, pagesizes, CTLTYPE_ULONG | CTLFLAG_RD,
  232     NULL, 0, sysctl_hw_pagesizes, "LU", "Supported page sizes");
  233 
  234 #ifdef SCTL_MASK32
  235 int adaptive_machine_arch = 1;
  236 SYSCTL_INT(_debug, OID_AUTO, adaptive_machine_arch, CTLFLAG_RW,
  237     &adaptive_machine_arch, 1,
  238     "Adapt reported machine architecture to the ABI of the binary");
  239 #endif
  240 
  241 static int
  242 sysctl_hw_machine_arch(SYSCTL_HANDLER_ARGS)
  243 {
  244         int error;
  245         static const char machine_arch[] = MACHINE_ARCH;
  246 #ifdef SCTL_MASK32
  247         static const char machine_arch32[] = MACHINE_ARCH32;
  248 
  249         if ((req->flags & SCTL_MASK32) != 0 && adaptive_machine_arch)
  250                 error = SYSCTL_OUT(req, machine_arch32, sizeof(machine_arch32));
  251         else
  252 #endif
  253                 error = SYSCTL_OUT(req, machine_arch, sizeof(machine_arch));
  254         return (error);
  255 
  256 }
  257 SYSCTL_PROC(_hw, HW_MACHINE_ARCH, machine_arch, CTLTYPE_STRING | CTLFLAG_RD,
  258     NULL, 0, sysctl_hw_machine_arch, "A", "System architecture");
  259 
  260 SYSCTL_STRING(_kern, OID_AUTO, supported_archs, CTLFLAG_RD | CTLFLAG_MPSAFE,
  261 #ifdef COMPAT_FREEBSD32
  262     MACHINE_ARCH " " MACHINE_ARCH32, 0, "Supported architectures for binaries");
  263 #else
  264     MACHINE_ARCH, 0, "Supported architectures for binaries");
  265 #endif
  266 
  267 static int
  268 sysctl_hostname(SYSCTL_HANDLER_ARGS)
  269 {
  270         struct prison *pr, *cpr;
  271         size_t pr_offset;
  272         char tmpname[MAXHOSTNAMELEN];
  273         int descend, error, len;
  274 
  275         /*
  276          * This function can set: hostname domainname hostuuid.
  277          * Keep that in mind when comments say "hostname".
  278          */
  279         pr_offset = (size_t)arg1;
  280         len = arg2;
  281         KASSERT(len <= sizeof(tmpname),
  282             ("length %d too long for %s", len, __func__));
  283 
  284         pr = req->td->td_ucred->cr_prison;
  285         if (!(pr->pr_allow & PR_ALLOW_SET_HOSTNAME) && req->newptr)
  286                 return (EPERM);
  287         /*
  288          * Make a local copy of hostname to get/set so we don't have to hold
  289          * the jail mutex during the sysctl copyin/copyout activities.
  290          */
  291         mtx_lock(&pr->pr_mtx);
  292         bcopy((char *)pr + pr_offset, tmpname, len);
  293         mtx_unlock(&pr->pr_mtx);
  294 
  295         error = sysctl_handle_string(oidp, tmpname, len, req);
  296 
  297         if (req->newptr != NULL && error == 0) {
  298                 /*
  299                  * Copy the locally set hostname to all jails that share
  300                  * this host info.
  301                  */
  302                 sx_slock(&allprison_lock);
  303                 while (!(pr->pr_flags & PR_HOST))
  304                         pr = pr->pr_parent;
  305                 mtx_lock(&pr->pr_mtx);
  306                 bcopy(tmpname, (char *)pr + pr_offset, len);
  307                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, cpr, descend)
  308                         if (cpr->pr_flags & PR_HOST)
  309                                 descend = 0;
  310                         else
  311                                 bcopy(tmpname, (char *)cpr + pr_offset, len);
  312                 mtx_unlock(&pr->pr_mtx);
  313                 sx_sunlock(&allprison_lock);
  314         }
  315         return (error);
  316 }
  317 
  318 SYSCTL_PROC(_kern, KERN_HOSTNAME, hostname,
  319     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
  320     (void *)(offsetof(struct prison, pr_hostname)), MAXHOSTNAMELEN,
  321     sysctl_hostname, "A", "Hostname");
  322 SYSCTL_PROC(_kern, KERN_NISDOMAINNAME, domainname,
  323     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
  324     (void *)(offsetof(struct prison, pr_domainname)), MAXHOSTNAMELEN,
  325     sysctl_hostname, "A", "Name of the current YP/NIS domain");
  326 SYSCTL_PROC(_kern, KERN_HOSTUUID, hostuuid,
  327     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
  328     (void *)(offsetof(struct prison, pr_hostuuid)), HOSTUUIDLEN,
  329     sysctl_hostname, "A", "Host UUID");
  330 
  331 static int      regression_securelevel_nonmonotonic = 0;
  332 
  333 #ifdef REGRESSION
  334 SYSCTL_INT(_regression, OID_AUTO, securelevel_nonmonotonic, CTLFLAG_RW,
  335     &regression_securelevel_nonmonotonic, 0, "securelevel may be lowered");
  336 #endif
  337 
  338 static int
  339 sysctl_kern_securelvl(SYSCTL_HANDLER_ARGS)
  340 {
  341         struct prison *pr, *cpr;
  342         int descend, error, level;
  343 
  344         pr = req->td->td_ucred->cr_prison;
  345 
  346         /*
  347          * Reading the securelevel is easy, since the current jail's level
  348          * is known to be at least as secure as any higher levels.  Perform
  349          * a lockless read since the securelevel is an integer.
  350          */
  351         level = pr->pr_securelevel;
  352         error = sysctl_handle_int(oidp, &level, 0, req);
  353         if (error || !req->newptr)
  354                 return (error);
  355         /* Permit update only if the new securelevel exceeds the old. */
  356         sx_slock(&allprison_lock);
  357         mtx_lock(&pr->pr_mtx);
  358         if (!regression_securelevel_nonmonotonic &&
  359             level < pr->pr_securelevel) {
  360                 mtx_unlock(&pr->pr_mtx);
  361                 sx_sunlock(&allprison_lock);
  362                 return (EPERM);
  363         }
  364         pr->pr_securelevel = level;
  365         /*
  366          * Set all child jails to be at least this level, but do not lower
  367          * them (even if regression_securelevel_nonmonotonic).
  368          */
  369         FOREACH_PRISON_DESCENDANT_LOCKED(pr, cpr, descend) {
  370                 if (cpr->pr_securelevel < level)
  371                         cpr->pr_securelevel = level;
  372         }
  373         mtx_unlock(&pr->pr_mtx);
  374         sx_sunlock(&allprison_lock);
  375         return (error);
  376 }
  377 
  378 SYSCTL_PROC(_kern, KERN_SECURELVL, securelevel,
  379     CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0, sysctl_kern_securelvl,
  380     "I", "Current secure level");
  381 
  382 #ifdef INCLUDE_CONFIG_FILE
  383 /* Actual kernel configuration options. */
  384 extern char kernconfstring[];
  385 
  386 SYSCTL_STRING(_kern, OID_AUTO, conftxt, CTLFLAG_RD, kernconfstring, 0,
  387     "Kernel configuration file");
  388 #endif
  389 
  390 static int
  391 sysctl_hostid(SYSCTL_HANDLER_ARGS)
  392 {
  393         struct prison *pr, *cpr;
  394         u_long tmpid;
  395         int descend, error;
  396 
  397         /*
  398          * Like sysctl_hostname, except it operates on a u_long
  399          * instead of a string, and is used only for hostid.
  400          */
  401         pr = req->td->td_ucred->cr_prison;
  402         if (!(pr->pr_allow & PR_ALLOW_SET_HOSTNAME) && req->newptr)
  403                 return (EPERM);
  404         tmpid = pr->pr_hostid;
  405         error = sysctl_handle_long(oidp, &tmpid, 0, req);
  406 
  407         if (req->newptr != NULL && error == 0) {
  408                 sx_slock(&allprison_lock);
  409                 while (!(pr->pr_flags & PR_HOST))
  410                         pr = pr->pr_parent;
  411                 mtx_lock(&pr->pr_mtx);
  412                 pr->pr_hostid = tmpid;
  413                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, cpr, descend)
  414                         if (cpr->pr_flags & PR_HOST)
  415                                 descend = 0;
  416                         else
  417                                 cpr->pr_hostid = tmpid;
  418                 mtx_unlock(&pr->pr_mtx);
  419                 sx_sunlock(&allprison_lock);
  420         }
  421         return (error);
  422 }
  423 
  424 SYSCTL_PROC(_kern, KERN_HOSTID, hostid,
  425     CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE | CTLFLAG_CAPRD,
  426     NULL, 0, sysctl_hostid, "LU", "Host ID");
  427 
  428 /*
  429  * The osrelease string is copied from the global (osrelease in vers.c) into
  430  * prison0 by a sysinit and is inherited by child jails if not changed at jail
  431  * creation, so we always return the copy from the current prison data.
  432  */
  433 static int
  434 sysctl_osrelease(SYSCTL_HANDLER_ARGS)
  435 {
  436         struct prison *pr;
  437 
  438         pr = req->td->td_ucred->cr_prison;
  439         return (SYSCTL_OUT(req, pr->pr_osrelease, strlen(pr->pr_osrelease) + 1));
  440 
  441 }
  442 
  443 SYSCTL_PROC(_kern, KERN_OSRELEASE, osrelease,
  444     CTLTYPE_STRING | CTLFLAG_CAPRD | CTLFLAG_RD | CTLFLAG_MPSAFE,
  445     NULL, 0, sysctl_osrelease, "A", "Operating system release");
  446 
  447 /*
  448  * The osreldate number is copied from the global (osreldate in vers.c) into
  449  * prison0 by a sysinit and is inherited by child jails if not changed at jail
  450  * creation, so we always return the value from the current prison data.
  451  */
  452 static int
  453 sysctl_osreldate(SYSCTL_HANDLER_ARGS)
  454 {
  455         struct prison *pr;
  456 
  457         pr = req->td->td_ucred->cr_prison;
  458         return (SYSCTL_OUT(req, &pr->pr_osreldate, sizeof(pr->pr_osreldate)));
  459 
  460 }
  461 
  462 /*
  463  * NOTICE: The *userland* release date is available in
  464  * /usr/include/osreldate.h
  465  */
  466 SYSCTL_PROC(_kern, KERN_OSRELDATE, osreldate,
  467     CTLTYPE_INT | CTLFLAG_CAPRD | CTLFLAG_RD | CTLFLAG_MPSAFE,
  468     NULL, 0, sysctl_osreldate, "I", "Kernel release date");
  469 
  470 SYSCTL_NODE(_kern, OID_AUTO, features, CTLFLAG_RD, 0, "Kernel Features");
  471 
  472 #ifdef COMPAT_FREEBSD4
  473 FEATURE(compat_freebsd4, "Compatible with FreeBSD 4");
  474 #endif
  475 
  476 #ifdef COMPAT_FREEBSD5
  477 FEATURE(compat_freebsd5, "Compatible with FreeBSD 5");
  478 #endif
  479 
  480 #ifdef COMPAT_FREEBSD6
  481 FEATURE(compat_freebsd6, "Compatible with FreeBSD 6");
  482 #endif
  483 
  484 #ifdef COMPAT_FREEBSD7
  485 FEATURE(compat_freebsd7, "Compatible with FreeBSD 7");
  486 #endif
  487 
  488 /*
  489  * This is really cheating.  These actually live in the libc, something
  490  * which I'm not quite sure is a good idea anyway, but in order for
  491  * getnext and friends to actually work, we define dummies here.
  492  *
  493  * XXXRW: These probably should be CTLFLAG_CAPRD.
  494  */
  495 SYSCTL_STRING(_user, USER_CS_PATH, cs_path, CTLFLAG_RD,
  496     "", 0, "PATH that finds all the standard utilities");
  497 SYSCTL_INT(_user, USER_BC_BASE_MAX, bc_base_max, CTLFLAG_RD,
  498     SYSCTL_NULL_INT_PTR, 0, "Max ibase/obase values in bc(1)");
  499 SYSCTL_INT(_user, USER_BC_DIM_MAX, bc_dim_max, CTLFLAG_RD,
  500     SYSCTL_NULL_INT_PTR, 0, "Max array size in bc(1)");
  501 SYSCTL_INT(_user, USER_BC_SCALE_MAX, bc_scale_max, CTLFLAG_RD,
  502     SYSCTL_NULL_INT_PTR, 0, "Max scale value in bc(1)");
  503 SYSCTL_INT(_user, USER_BC_STRING_MAX, bc_string_max, CTLFLAG_RD,
  504     SYSCTL_NULL_INT_PTR, 0, "Max string length in bc(1)");
  505 SYSCTL_INT(_user, USER_COLL_WEIGHTS_MAX, coll_weights_max, CTLFLAG_RD,
  506     SYSCTL_NULL_INT_PTR, 0, "Maximum number of weights assigned to an LC_COLLATE locale entry");
  507 SYSCTL_INT(_user, USER_EXPR_NEST_MAX, expr_nest_max, CTLFLAG_RD,
  508     SYSCTL_NULL_INT_PTR, 0, "");
  509 SYSCTL_INT(_user, USER_LINE_MAX, line_max, CTLFLAG_RD,
  510     SYSCTL_NULL_INT_PTR, 0, "Max length (bytes) of a text-processing utility's input line");
  511 SYSCTL_INT(_user, USER_RE_DUP_MAX, re_dup_max, CTLFLAG_RD,
  512     SYSCTL_NULL_INT_PTR, 0, "Maximum number of repeats of a regexp permitted");
  513 SYSCTL_INT(_user, USER_POSIX2_VERSION, posix2_version, CTLFLAG_RD,
  514     SYSCTL_NULL_INT_PTR, 0,
  515     "The version of POSIX 1003.2 with which the system attempts to comply");
  516 SYSCTL_INT(_user, USER_POSIX2_C_BIND, posix2_c_bind, CTLFLAG_RD,
  517     SYSCTL_NULL_INT_PTR, 0, "Whether C development supports the C bindings option");
  518 SYSCTL_INT(_user, USER_POSIX2_C_DEV, posix2_c_dev, CTLFLAG_RD,
  519     SYSCTL_NULL_INT_PTR, 0, "Whether system supports the C development utilities option");
  520 SYSCTL_INT(_user, USER_POSIX2_CHAR_TERM, posix2_char_term, CTLFLAG_RD,
  521     SYSCTL_NULL_INT_PTR, 0, "");
  522 SYSCTL_INT(_user, USER_POSIX2_FORT_DEV, posix2_fort_dev, CTLFLAG_RD,
  523     SYSCTL_NULL_INT_PTR, 0, "Whether system supports FORTRAN development utilities");
  524 SYSCTL_INT(_user, USER_POSIX2_FORT_RUN, posix2_fort_run, CTLFLAG_RD,
  525     SYSCTL_NULL_INT_PTR, 0, "Whether system supports FORTRAN runtime utilities");
  526 SYSCTL_INT(_user, USER_POSIX2_LOCALEDEF, posix2_localedef, CTLFLAG_RD,
  527     SYSCTL_NULL_INT_PTR, 0, "Whether system supports creation of locales");
  528 SYSCTL_INT(_user, USER_POSIX2_SW_DEV, posix2_sw_dev, CTLFLAG_RD,
  529     SYSCTL_NULL_INT_PTR, 0, "Whether system supports software development utilities");
  530 SYSCTL_INT(_user, USER_POSIX2_UPE, posix2_upe, CTLFLAG_RD,
  531     SYSCTL_NULL_INT_PTR, 0, "Whether system supports the user portability utilities");
  532 SYSCTL_INT(_user, USER_STREAM_MAX, stream_max, CTLFLAG_RD,
  533     SYSCTL_NULL_INT_PTR, 0, "Min Maximum number of streams a process may have open at one time");
  534 SYSCTL_INT(_user, USER_TZNAME_MAX, tzname_max, CTLFLAG_RD,
  535     SYSCTL_NULL_INT_PTR, 0, "Min Maximum number of types supported for timezone names");
  536 
  537 #include <sys/vnode.h>
  538 SYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD,
  539     SYSCTL_NULL_INT_PTR, sizeof(struct vnode), "sizeof(struct vnode)");
  540 
  541 SYSCTL_INT(_debug_sizeof, OID_AUTO, proc, CTLFLAG_RD,
  542     SYSCTL_NULL_INT_PTR, sizeof(struct proc), "sizeof(struct proc)");
  543 
  544 static int
  545 sysctl_kern_pid_max(SYSCTL_HANDLER_ARGS)
  546 {
  547         int error, pm;
  548 
  549         pm = pid_max;
  550         error = sysctl_handle_int(oidp, &pm, 0, req);
  551         if (error || !req->newptr)
  552                 return (error);
  553         sx_xlock(&proctree_lock);
  554         sx_xlock(&allproc_lock);
  555 
  556         /*
  557          * Only permit the values less then PID_MAX.
  558          * As a safety measure, do not allow to limit the pid_max too much.
  559          */
  560         if (pm < 300 || pm > PID_MAX)
  561                 error = EINVAL;
  562         else
  563                 pid_max = pm;
  564         sx_xunlock(&allproc_lock);
  565         sx_xunlock(&proctree_lock);
  566         return (error);
  567 }
  568 SYSCTL_PROC(_kern, OID_AUTO, pid_max, CTLTYPE_INT |
  569     CTLFLAG_RWTUN | CTLFLAG_NOFETCH | CTLFLAG_MPSAFE,
  570     0, 0, sysctl_kern_pid_max, "I", "Maximum allowed pid");
  571 
  572 #include <sys/bio.h>
  573 #include <sys/buf.h>
  574 SYSCTL_INT(_debug_sizeof, OID_AUTO, bio, CTLFLAG_RD,
  575     SYSCTL_NULL_INT_PTR, sizeof(struct bio), "sizeof(struct bio)");
  576 SYSCTL_INT(_debug_sizeof, OID_AUTO, buf, CTLFLAG_RD,
  577     SYSCTL_NULL_INT_PTR, sizeof(struct buf), "sizeof(struct buf)");
  578 
  579 #include <sys/user.h>
  580 SYSCTL_INT(_debug_sizeof, OID_AUTO, kinfo_proc, CTLFLAG_RD,
  581     SYSCTL_NULL_INT_PTR, sizeof(struct kinfo_proc), "sizeof(struct kinfo_proc)");
  582 
  583 /* Used by kernel debuggers. */
  584 const int pcb_size = sizeof(struct pcb);
  585 SYSCTL_INT(_debug_sizeof, OID_AUTO, pcb, CTLFLAG_RD,
  586     SYSCTL_NULL_INT_PTR, sizeof(struct pcb), "sizeof(struct pcb)");
  587 
  588 /* XXX compatibility, remove for 6.0 */
  589 #include <sys/imgact.h>
  590 #include <sys/imgact_elf.h>
  591 SYSCTL_INT(_kern, OID_AUTO, fallback_elf_brand, CTLFLAG_RW,
  592     &__elfN(fallback_brand), sizeof(__elfN(fallback_brand)),
  593     "compatibility for kern.fallback_elf_brand");

Cache object: 0f851cc2f8ca32731a98c34773a82c1a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.