sys/kern/subr_param.c

   1 /*-
   2  * Copyright (c) 1980, 1986, 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  * (c) UNIX System Laboratories, Inc.
   5  * All or some portions of this file are derived from material licensed
   6  * to the University of California by American Telephone and Telegraph
   7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   8  * the permission of UNIX System Laboratories, Inc.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)param.c     8.3 (Berkeley) 8/20/94
  35  */
  36
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 #include "opt_param.h"
  41 #include "opt_msgbuf.h"
  42 #include "opt_maxusers.h"
  43
  44 #include <sys/limits.h>
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/kernel.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/msgbuf.h>
  50
  51 #include <vm/vm_param.h>
  52
  53 /*
  54  * System parameter formulae.
  55  */
  56
  57 #ifndef HZ
  58 #  if defined(__mips__) || defined(__arm__)
  59 #    define     HZ 100
  60 #  else
  61 #    define     HZ 1000
  62 #  endif
  63 #  ifndef HZ_VM
  64 #    define     HZ_VM 100
  65 #  endif
  66 #else
  67 #  ifndef HZ_VM
  68 #    define     HZ_VM HZ
  69 #  endif
  70 #endif
  71 #define NPROC (20 + 16 * maxusers)
  72 #ifndef NBUF
  73 #define NBUF 0
  74 #endif
  75 #ifndef MAXFILES
  76 #define MAXFILES (maxproc * 2)
  77 #endif
  78
  79 static int sysctl_kern_vm_guest(SYSCTL_HANDLER_ARGS);
  80
  81 int     hz;
  82 int     tick;
  83 int     maxusers;                       /* base tunable */
  84 int     maxproc;                        /* maximum # of processes */
  85 int     maxprocperuid;                  /* max # of procs per user */
  86 int     maxfiles;                       /* sys. wide open files limit */
  87 int     maxfilesperproc;                /* per-proc open files limit */
  88 int     msgbufsize;                     /* size of kernel message buffer */
  89 int     ncallout;                       /* maximum # of timer events */
  90 int     nbuf;
  91 int     ngroups_max;                    /* max # groups per process */
  92 int     nswbuf;
  93 long    maxswzone;                      /* max swmeta KVA storage */
  94 long    maxbcache;                      /* max buffer cache KVA storage */
  95 long    maxpipekva;                     /* Limit on pipe KVA */
  96 int     vm_guest;                       /* Running as virtual machine guest? */
  97 u_long  maxtsiz;                        /* max text size */
  98 u_long  dfldsiz;                        /* initial data size limit */
  99 u_long  maxdsiz;                        /* max data size */
 100 u_long  dflssiz;                        /* initial stack size limit */
 101 u_long  maxssiz;                        /* max stack size */
 102 u_long  sgrowsiz;                       /* amount to grow stack */
 103
 104 SYSCTL_INT(_kern, OID_AUTO, hz, CTLFLAG_RDTUN, &hz, 0,
 105     "Number of clock ticks per second");
 106 SYSCTL_INT(_kern, OID_AUTO, ncallout, CTLFLAG_RDTUN, &ncallout, 0,
 107     "Number of pre-allocated timer events");
 108 SYSCTL_INT(_kern, OID_AUTO, nbuf, CTLFLAG_RDTUN, &nbuf, 0,
 109     "Number of buffers in the buffer cache");
 110 SYSCTL_INT(_kern, OID_AUTO, nswbuf, CTLFLAG_RDTUN, &nswbuf, 0,
 111     "Number of swap buffers");
 112 SYSCTL_INT(_kern, OID_AUTO, msgbufsize, CTLFLAG_RDTUN, &msgbufsize, 0,
 113     "Size of the kernel message buffer");
 114 SYSCTL_LONG(_kern, OID_AUTO, maxswzone, CTLFLAG_RDTUN, &maxswzone, 0,
 115     "Maximum memory for swap metadata");
 116 SYSCTL_LONG(_kern, OID_AUTO, maxbcache, CTLFLAG_RDTUN, &maxbcache, 0,
 117     "Maximum value of vfs.maxbufspace");
 118 SYSCTL_ULONG(_kern, OID_AUTO, maxtsiz, CTLFLAG_RW | CTLFLAG_TUN, &maxtsiz, 0,
 119     "Maximum text size");
 120 SYSCTL_ULONG(_kern, OID_AUTO, dfldsiz, CTLFLAG_RW | CTLFLAG_TUN, &dfldsiz, 0,
 121     "Initial data size limit");
 122 SYSCTL_ULONG(_kern, OID_AUTO, maxdsiz, CTLFLAG_RW | CTLFLAG_TUN, &maxdsiz, 0,
 123     "Maximum data size");
 124 SYSCTL_ULONG(_kern, OID_AUTO, dflssiz, CTLFLAG_RW | CTLFLAG_TUN, &dflssiz, 0,
 125     "Initial stack size limit");
 126 SYSCTL_ULONG(_kern, OID_AUTO, maxssiz, CTLFLAG_RW | CTLFLAG_TUN, &maxssiz, 0,
 127     "Maximum stack size");
 128 SYSCTL_ULONG(_kern, OID_AUTO, sgrowsiz, CTLFLAG_RW | CTLFLAG_TUN, &sgrowsiz, 0,
 129     "Amount to grow stack on a stack fault");
 130 SYSCTL_PROC(_kern, OID_AUTO, vm_guest, CTLFLAG_RD | CTLTYPE_STRING,
 131     NULL, 0, sysctl_kern_vm_guest, "A",
 132     "Virtual machine guest detected? (none|generic|xen)");
 133
 134 /*
 135  * These have to be allocated somewhere; allocating
 136  * them here forces loader errors if this file is omitted
 137  * (if they've been externed everywhere else; hah!).
 138  */
 139 struct  buf *swbuf;
 140
 141 /*
 142  * The elements of this array are ordered based upon the values of the
 143  * corresponding enum VM_GUEST members.
 144  */
 145 static const char *const vm_guest_sysctl_names[] = {
 146         "none",
 147         "generic",
 148         "xen",
 149         NULL
 150 };
 151
 152 #ifndef XEN
 153 static const char *const vm_bnames[] = {
 154         "QEMU",                         /* QEMU */
 155         "Plex86",                       /* Plex86 */
 156         "Bochs",                        /* Bochs */
 157         "Xen",                          /* Xen */
 158         NULL
 159 };
 160
 161 static const char *const vm_pnames[] = {
 162         "VMware Virtual Platform",      /* VMWare VM */
 163         "Virtual Machine",              /* Microsoft VirtualPC */
 164         "VirtualBox",                   /* Sun xVM VirtualBox */
 165         "Parallels Virtual Platform",   /* Parallels VM */
 166         NULL
 167 };
 168
 169
 170 /*
 171  * Detect known Virtual Machine hosts by inspecting the emulated BIOS.
 172  */
 173 static enum VM_GUEST
 174 detect_virtual(void)
 175 {
 176         char *sysenv;
 177         int i;
 178
 179         sysenv = getenv("smbios.bios.vendor");
 180         if (sysenv != NULL) {
 181                 for (i = 0; vm_bnames[i] != NULL; i++)
 182                         if (strcmp(sysenv, vm_bnames[i]) == 0) {
 183                                 freeenv(sysenv);
 184                                 return (VM_GUEST_VM);
 185                         }
 186                 freeenv(sysenv);
 187         }
 188         sysenv = getenv("smbios.system.product");
 189         if (sysenv != NULL) {
 190                 for (i = 0; vm_pnames[i] != NULL; i++)
 191                         if (strcmp(sysenv, vm_pnames[i]) == 0) {
 192                                 freeenv(sysenv);
 193                                 return (VM_GUEST_VM);
 194                         }
 195                 freeenv(sysenv);
 196         }
 197         return (VM_GUEST_NO);
 198 }
 199 #endif
 200
 201 /*
 202  * Boot time overrides that are not scaled against main memory
 203  */
 204 void
 205 init_param1(void)
 206 {
 207 #ifndef XEN
 208         vm_guest = detect_virtual();
 209 #else
 210         vm_guest = VM_GUEST_XEN;
 211 #endif
 212         hz = -1;
 213         TUNABLE_INT_FETCH("kern.hz", &hz);
 214         if (hz == -1)
 215                 hz = vm_guest > VM_GUEST_NO ? HZ_VM : HZ;
 216         tick = 1000000 / hz;
 217
 218 #ifdef VM_SWZONE_SIZE_MAX
 219         maxswzone = VM_SWZONE_SIZE_MAX;
 220 #endif
 221         TUNABLE_LONG_FETCH("kern.maxswzone", &maxswzone);
 222 #ifdef VM_BCACHE_SIZE_MAX
 223         maxbcache = VM_BCACHE_SIZE_MAX;
 224 #endif
 225         TUNABLE_LONG_FETCH("kern.maxbcache", &maxbcache);
 226         msgbufsize = MSGBUF_SIZE;
 227         TUNABLE_INT_FETCH("kern.msgbufsize", &msgbufsize);
 228
 229         maxtsiz = MAXTSIZ;
 230         TUNABLE_ULONG_FETCH("kern.maxtsiz", &maxtsiz);
 231         dfldsiz = DFLDSIZ;
 232         TUNABLE_ULONG_FETCH("kern.dfldsiz", &dfldsiz);
 233         maxdsiz = MAXDSIZ;
 234         TUNABLE_ULONG_FETCH("kern.maxdsiz", &maxdsiz);
 235         dflssiz = DFLSSIZ;
 236         TUNABLE_ULONG_FETCH("kern.dflssiz", &dflssiz);
 237         maxssiz = MAXSSIZ;
 238         TUNABLE_ULONG_FETCH("kern.maxssiz", &maxssiz);
 239         sgrowsiz = SGROWSIZ;
 240         TUNABLE_ULONG_FETCH("kern.sgrowsiz", &sgrowsiz);
 241
 242         /*
 243          * Let the administrator set {NGROUPS_MAX}, but disallow values
 244          * less than NGROUPS_MAX which would violate POSIX.1-2008 or
 245          * greater than INT_MAX-1 which would result in overflow.
 246          */
 247         ngroups_max = NGROUPS_MAX;
 248         TUNABLE_INT_FETCH("kern.ngroups", &ngroups_max);
 249         if (ngroups_max < NGROUPS_MAX)
 250                 ngroups_max = NGROUPS_MAX;
 251 }
 252
 253 /*
 254  * Boot time overrides that are scaled against main memory
 255  */
 256 void
 257 init_param2(long physpages)
 258 {
 259
 260         /* Base parameters */
 261         maxusers = MAXUSERS;
 262         TUNABLE_INT_FETCH("kern.maxusers", &maxusers);
 263         if (maxusers == 0) {
 264                 maxusers = physpages / (2 * 1024 * 1024 / PAGE_SIZE);
 265                 if (maxusers < 32)
 266                         maxusers = 32;
 267                 if (maxusers > 384)
 268                         maxusers = 384;
 269         }
 270
 271         /*
 272          * The following can be overridden after boot via sysctl.  Note:
 273          * unless overriden, these macros are ultimately based on maxusers.
 274          */
 275         maxproc = NPROC;
 276         TUNABLE_INT_FETCH("kern.maxproc", &maxproc);
 277         /*
 278          * Limit maxproc so that kmap entries cannot be exhausted by
 279          * processes.
 280          */
 281         if (maxproc > (physpages / 12))
 282                 maxproc = physpages / 12;
 283         maxfiles = MAXFILES;
 284         TUNABLE_INT_FETCH("kern.maxfiles", &maxfiles);
 285         maxprocperuid = (maxproc * 9) / 10;
 286         maxfilesperproc = (maxfiles * 9) / 10;
 287
 288         /*
 289          * Cannot be changed after boot.
 290          */
 291         nbuf = NBUF;
 292         TUNABLE_INT_FETCH("kern.nbuf", &nbuf);
 293
 294         ncallout = 16 + maxproc + maxfiles;
 295         TUNABLE_INT_FETCH("kern.ncallout", &ncallout);
 296 }
 297
 298 /*
 299  * Boot time overrides that are scaled against the kmem map
 300  */
 301 void
 302 init_param3(long kmempages)
 303 {
 304
 305         /*
 306          * The default for maxpipekva is max(5% of the kmem map, 512KB).
 307          * See sys_pipe.c for more details.
 308          */
 309         maxpipekva = (kmempages / 20) * PAGE_SIZE;
 310         if (maxpipekva < 512 * 1024)
 311                 maxpipekva = 512 * 1024;
 312         TUNABLE_LONG_FETCH("kern.ipc.maxpipekva", &maxpipekva);
 313 }
 314
 315 /*
 316  * Sysctl stringiying handler for kern.vm_guest.
 317  */
 318 static int
 319 sysctl_kern_vm_guest(SYSCTL_HANDLER_ARGS)
 320 {
 321         return (SYSCTL_OUT(req, vm_guest_sysctl_names[vm_guest],
 322             strlen(vm_guest_sysctl_names[vm_guest])));
 323 }