19454b2d8SWarner Losh /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 4df8bae1dSRodney W. Grimes * Copyright (c) 1980, 1986, 1989, 1993 5df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 6df8bae1dSRodney W. Grimes * (c) UNIX System Laboratories, Inc. 7df8bae1dSRodney W. Grimes * All or some portions of this file are derived from material licensed 8df8bae1dSRodney W. Grimes * to the University of California by American Telephone and Telegraph 9df8bae1dSRodney W. Grimes * Co. or Unix System Laboratories, Inc. and are reproduced herein with 10df8bae1dSRodney W. Grimes * the permission of UNIX System Laboratories, Inc. 11df8bae1dSRodney W. Grimes * 12df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 13df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 14df8bae1dSRodney W. Grimes * are met: 15df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 16df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 17df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 18df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 19df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 2069a28758SEd Maste * 3. Neither the name of the University nor the names of its contributors 21df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 22df8bae1dSRodney W. Grimes * without specific prior written permission. 23df8bae1dSRodney W. Grimes * 24df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34df8bae1dSRodney W. Grimes * SUCH DAMAGE. 35df8bae1dSRodney W. Grimes */ 36df8bae1dSRodney W. Grimes 37677b542eSDavid E. O'Brien #include <sys/cdefs.h> 384bd49128SPeter Wemm #include "opt_param.h" 394053b05bSSergey Kandaurov #include "opt_msgbuf.h" 40cd853791SKonstantin Belousov #include "opt_maxphys.h" 41ee342e1bSPeter Wemm #include "opt_maxusers.h" 4250c73f36SGarrett Wollman 43df8bae1dSRodney W. Grimes #include <sys/param.h> 44ee342e1bSPeter Wemm #include <sys/systm.h> 45756a5412SGleb Smirnoff #include <sys/buf.h> 46ee342e1bSPeter Wemm #include <sys/kernel.h> 4702c6fc21SKonstantin Belousov #include <sys/limits.h> 484053b05bSSergey Kandaurov #include <sys/msgbuf.h> 4902c6fc21SKonstantin Belousov #include <sys/sysctl.h> 5002c6fc21SKonstantin Belousov #include <sys/proc.h> 513b1f974bSKonstantin Belousov #include <sys/vnode.h> 52df8bae1dSRodney W. Grimes 53e9a3f785SAlan Cox #include <vm/vm.h> 547419d1e2SDag-Erling Smørgrav #include <vm/vm_param.h> 55e9a3f785SAlan Cox #include <vm/pmap.h> 56cbc89bfbSPaul Saab 57df8bae1dSRodney W. Grimes /* 58df8bae1dSRodney W. Grimes * System parameter formulae. 59df8bae1dSRodney W. Grimes */ 60df8bae1dSRodney W. Grimes 61df8bae1dSRodney W. Grimes #ifndef HZ 62bcebf6a1SNathan Whitehorn # define HZ 1000 637f03c419SMaxim Sobolev # ifndef HZ_VM 64347e22a6SMike Silbersack # define HZ_VM 100 657f03c419SMaxim Sobolev # endif 667f03c419SMaxim Sobolev #else 677f03c419SMaxim Sobolev # ifndef HZ_VM 687f03c419SMaxim Sobolev # define HZ_VM HZ 697f03c419SMaxim Sobolev # endif 708f650450SPeter Wemm #endif 71ee342e1bSPeter Wemm #define NPROC (20 + 16 * maxusers) 72ee342e1bSPeter Wemm #ifndef NBUF 73ee342e1bSPeter Wemm #define NBUF 0 74ee342e1bSPeter Wemm #endif 755a00f364SDag-Erling Smørgrav #ifndef MAXFILES 761f57d8c6SKonstantin Belousov #define MAXFILES (40 + 32 * maxusers) 775a00f364SDag-Erling Smørgrav #endif 78dd0b2081SDavid Greenman 793610a226SIvan Voras static int sysctl_kern_vm_guest(SYSCTL_HANDLER_ARGS); 803610a226SIvan Voras 815b999a6bSDavide Italiano int hz; /* system clock's frequency */ 825b999a6bSDavide Italiano int tick; /* usec per tick (1000000 / hz) */ 8335a33d14SHans Petter Selasky time_t tick_seconds_max; /* max hz * seconds an integer can hold */ 845b999a6bSDavide Italiano struct bintime tick_bt; /* bintime per tick (1s / hz) */ 855b999a6bSDavide Italiano sbintime_t tick_sbt; 86ee342e1bSPeter Wemm int maxusers; /* base tunable */ 87ee342e1bSPeter Wemm int maxproc; /* maximum # of processes */ 88ee342e1bSPeter Wemm int maxprocperuid; /* max # of procs per user */ 89ee342e1bSPeter Wemm int maxfiles; /* sys. wide open files limit */ 90ee342e1bSPeter Wemm int maxfilesperproc; /* per-proc open files limit */ 914053b05bSSergey Kandaurov int msgbufsize; /* size of kernel message buffer */ 92cd853791SKonstantin Belousov int nbuf; /* number of bcache bufs */ 93ee75e7deSKonstantin Belousov int bio_transient_maxcnt; 94412f9500SBrooks Davis int ngroups_max; /* max # groups per process */ 95ee342e1bSPeter Wemm int nswbuf; 9602c6fc21SKonstantin Belousov pid_t pid_max = PID_MAX; 97cd853791SKonstantin Belousov u_long maxswzone; /* max swmeta KVA storage */ 98cd853791SKonstantin Belousov u_long maxbcache; /* max buffer cache KVA storage */ 99cd853791SKonstantin Belousov u_long maxpipekva; /* Limit on pipe KVA */ 100cd853791SKonstantin Belousov u_long maxphys; /* max raw I/O transfer size */ 10101e1933dSJohn Baldwin int vm_guest = VM_GUEST_NO; /* Running as virtual machine guest? */ 1027419d1e2SDag-Erling Smørgrav u_long maxtsiz; /* max text size */ 1037419d1e2SDag-Erling Smørgrav u_long dfldsiz; /* initial data size limit */ 1047419d1e2SDag-Erling Smørgrav u_long maxdsiz; /* max data size */ 1057419d1e2SDag-Erling Smørgrav u_long dflssiz; /* initial stack size limit */ 1067419d1e2SDag-Erling Smørgrav u_long maxssiz; /* max stack size */ 1077419d1e2SDag-Erling Smørgrav u_long sgrowsiz; /* amount to grow stack */ 108df8bae1dSRodney W. Grimes 109af3b2549SHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, hz, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &hz, 0, 1109b84ba1cSJohn Baldwin "Number of clock ticks per second"); 111ee29897fSHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, hz_max, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, HZ_MAXIMUM, 112ee29897fSHans Petter Selasky "Maximum hz value supported"); 113ee29897fSHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, hz_min, CTLFLAG_RD, SYSCTL_NULL_INT_PTR, HZ_MINIMUM, 114ee29897fSHans Petter Selasky "Minimum hz value supported"); 115af3b2549SHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, nbuf, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &nbuf, 0, 1169b84ba1cSJohn Baldwin "Number of buffers in the buffer cache"); 117af3b2549SHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, nswbuf, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &nswbuf, 0, 118b9f2a7daSJohn Baldwin "Number of swap buffers"); 119af3b2549SHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, msgbufsize, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &msgbufsize, 0, 1204053b05bSSergey Kandaurov "Size of the kernel message buffer"); 121af3b2549SHans Petter Selasky SYSCTL_LONG(_kern, OID_AUTO, maxswzone, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &maxswzone, 0, 1229b84ba1cSJohn Baldwin "Maximum memory for swap metadata"); 123af3b2549SHans Petter Selasky SYSCTL_LONG(_kern, OID_AUTO, maxbcache, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &maxbcache, 0, 1249b84ba1cSJohn Baldwin "Maximum value of vfs.maxbufspace"); 125af3b2549SHans Petter Selasky SYSCTL_INT(_kern, OID_AUTO, bio_transient_maxcnt, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, 126ee75e7deSKonstantin Belousov &bio_transient_maxcnt, 0, 127ee75e7deSKonstantin Belousov "Maximum number of transient BIOs mappings"); 128af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern, OID_AUTO, maxtsiz, CTLFLAG_RWTUN | CTLFLAG_NOFETCH, &maxtsiz, 0, 1299b84ba1cSJohn Baldwin "Maximum text size"); 130af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern, OID_AUTO, dfldsiz, CTLFLAG_RWTUN | CTLFLAG_NOFETCH, &dfldsiz, 0, 1319b84ba1cSJohn Baldwin "Initial data size limit"); 132af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern, OID_AUTO, maxdsiz, CTLFLAG_RWTUN | CTLFLAG_NOFETCH, &maxdsiz, 0, 1339b84ba1cSJohn Baldwin "Maximum data size"); 134af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern, OID_AUTO, dflssiz, CTLFLAG_RWTUN | CTLFLAG_NOFETCH, &dflssiz, 0, 1359b84ba1cSJohn Baldwin "Initial stack size limit"); 136af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern, OID_AUTO, maxssiz, CTLFLAG_RWTUN | CTLFLAG_NOFETCH, &maxssiz, 0, 1379b84ba1cSJohn Baldwin "Maximum stack size"); 138af3b2549SHans Petter Selasky SYSCTL_ULONG(_kern, OID_AUTO, sgrowsiz, CTLFLAG_RWTUN | CTLFLAG_NOFETCH, &sgrowsiz, 0, 139ceb0f715SAndrey Zonov "Amount to grow stack on a stack fault"); 1407029da5cSPawel Biernacki SYSCTL_PROC(_kern, OID_AUTO, vm_guest, 1417029da5cSPawel Biernacki CTLFLAG_RD | CTLTYPE_STRING | CTLFLAG_MPSAFE, NULL, 0, 1427029da5cSPawel Biernacki sysctl_kern_vm_guest, "A", 14301e1933dSJohn Baldwin "Virtual machine guest detected?"); 1447c45a9c4SAlfred Perlstein 145df8bae1dSRodney W. Grimes /* 1460b993ee5SAlan Cox * The elements of this array are ordered based upon the values of the 1470b993ee5SAlan Cox * corresponding enum VM_GUEST members. 1480b993ee5SAlan Cox */ 14934820bbfSBjoern A. Zeeb static const char *const vm_guest_sysctl_names[] = { 1501177d38cSStephen J. Kiernan [VM_GUEST_NO] = "none", 1511177d38cSStephen J. Kiernan [VM_GUEST_VM] = "generic", 1521177d38cSStephen J. Kiernan [VM_GUEST_XEN] = "xen", 1531177d38cSStephen J. Kiernan [VM_GUEST_HV] = "hv", 1541177d38cSStephen J. Kiernan [VM_GUEST_VMWARE] = "vmware", 1551177d38cSStephen J. Kiernan [VM_GUEST_KVM] = "kvm", 1561177d38cSStephen J. Kiernan [VM_GUEST_BHYVE] = "bhyve", 1571177d38cSStephen J. Kiernan [VM_GUEST_VBOX] = "vbox", 1581177d38cSStephen J. Kiernan [VM_GUEST_PARALLELS] = "parallels", 15934820bbfSBjoern A. Zeeb }; 160*b0aaf8beSMateusz Guzik _Static_assert(nitems(vm_guest_sysctl_names) == VM_GUEST_LAST, 161733a6684SMateusz Guzik "new vm guest type not added to vm_guest_sysctl_names"); 16234820bbfSBjoern A. Zeeb 1639722d88fSJason Evans /* 16466a11b9fSMatthew Dillon * Boot time overrides that are not scaled against main memory 165ee342e1bSPeter Wemm */ 166ee342e1bSPeter Wemm void 16766a11b9fSMatthew Dillon init_param1(void) 168ee342e1bSPeter Wemm { 16901e1933dSJohn Baldwin 1709d6ae1e3SColin Percival TSENTER(); 17139cddbd7SKonstantin Belousov 17239cddbd7SKonstantin Belousov /* 17339cddbd7SKonstantin Belousov * arm64 and riscv currently hard-code the thread0 kstack size 17439cddbd7SKonstantin Belousov * to KSTACK_PAGES, ignoring the tunable. 17539cddbd7SKonstantin Belousov */ 176edc82223SKonstantin Belousov TUNABLE_INT_FETCH("kern.kstack_pages", &kstack_pages); 17739cddbd7SKonstantin Belousov 1787f03c419SMaxim Sobolev hz = -1; 179ee342e1bSPeter Wemm TUNABLE_INT_FETCH("kern.hz", &hz); 1809bd2cbe4SJung-uk Kim if (hz == -1) 1813dc30911SIvan Voras hz = vm_guest > VM_GUEST_NO ? HZ_VM : HZ; 182ee29897fSHans Petter Selasky 183ee29897fSHans Petter Selasky /* range check the "hz" value */ 184ee29897fSHans Petter Selasky if (__predict_false(hz < HZ_MINIMUM)) 185ee29897fSHans Petter Selasky hz = HZ_MINIMUM; 186ee29897fSHans Petter Selasky else if (__predict_false(hz > HZ_MAXIMUM)) 187ee29897fSHans Petter Selasky hz = HZ_MAXIMUM; 188ee29897fSHans Petter Selasky 189ee342e1bSPeter Wemm tick = 1000000 / hz; 1905b999a6bSDavide Italiano tick_sbt = SBT_1S / hz; 1915b999a6bSDavide Italiano tick_bt = sbttobt(tick_sbt); 19235a33d14SHans Petter Selasky tick_seconds_max = INT_MAX / hz; 193ee342e1bSPeter Wemm 1945d8cce17SJohn Baldwin /* 1955d8cce17SJohn Baldwin * Arrange for ticks to wrap 10 minutes after boot to help catch 1965d8cce17SJohn Baldwin * sign problems sooner. 1975d8cce17SJohn Baldwin */ 1985d8cce17SJohn Baldwin ticks = INT_MAX - (hz * 10 * 60); 1995d8cce17SJohn Baldwin 2003b1f974bSKonstantin Belousov vn_lock_pair_pause_max = hz / 100; 2013b1f974bSKonstantin Belousov if (vn_lock_pair_pause_max == 0) 2023b1f974bSKonstantin Belousov vn_lock_pair_pause_max = 1; 2033b1f974bSKonstantin Belousov 204e1616f3aSMatthew Dillon #ifdef VM_SWZONE_SIZE_MAX 2052f9e4e80SMatthew Dillon maxswzone = VM_SWZONE_SIZE_MAX; 206e1616f3aSMatthew Dillon #endif 2075bd65606SJohn Baldwin TUNABLE_LONG_FETCH("kern.maxswzone", &maxswzone); 208e1616f3aSMatthew Dillon #ifdef VM_BCACHE_SIZE_MAX 2092f9e4e80SMatthew Dillon maxbcache = VM_BCACHE_SIZE_MAX; 210e1616f3aSMatthew Dillon #endif 2115bd65606SJohn Baldwin TUNABLE_LONG_FETCH("kern.maxbcache", &maxbcache); 2124053b05bSSergey Kandaurov msgbufsize = MSGBUF_SIZE; 2134053b05bSSergey Kandaurov TUNABLE_INT_FETCH("kern.msgbufsize", &msgbufsize); 214cbc89bfbSPaul Saab 215cbc89bfbSPaul Saab maxtsiz = MAXTSIZ; 2167419d1e2SDag-Erling Smørgrav TUNABLE_ULONG_FETCH("kern.maxtsiz", &maxtsiz); 217cbc89bfbSPaul Saab dfldsiz = DFLDSIZ; 2187419d1e2SDag-Erling Smørgrav TUNABLE_ULONG_FETCH("kern.dfldsiz", &dfldsiz); 219cbc89bfbSPaul Saab maxdsiz = MAXDSIZ; 2207419d1e2SDag-Erling Smørgrav TUNABLE_ULONG_FETCH("kern.maxdsiz", &maxdsiz); 221cbc89bfbSPaul Saab dflssiz = DFLSSIZ; 2227419d1e2SDag-Erling Smørgrav TUNABLE_ULONG_FETCH("kern.dflssiz", &dflssiz); 223cbc89bfbSPaul Saab maxssiz = MAXSSIZ; 2247419d1e2SDag-Erling Smørgrav TUNABLE_ULONG_FETCH("kern.maxssiz", &maxssiz); 225cbc89bfbSPaul Saab sgrowsiz = SGROWSIZ; 2267419d1e2SDag-Erling Smørgrav TUNABLE_ULONG_FETCH("kern.sgrowsiz", &sgrowsiz); 227412f9500SBrooks Davis 228412f9500SBrooks Davis /* 229412f9500SBrooks Davis * Let the administrator set {NGROUPS_MAX}, but disallow values 230412f9500SBrooks Davis * less than NGROUPS_MAX which would violate POSIX.1-2008 or 231412f9500SBrooks Davis * greater than INT_MAX-1 which would result in overflow. 232412f9500SBrooks Davis */ 233412f9500SBrooks Davis ngroups_max = NGROUPS_MAX; 234412f9500SBrooks Davis TUNABLE_INT_FETCH("kern.ngroups", &ngroups_max); 235412f9500SBrooks Davis if (ngroups_max < NGROUPS_MAX) 236412f9500SBrooks Davis ngroups_max = NGROUPS_MAX; 23702c6fc21SKonstantin Belousov 23802c6fc21SKonstantin Belousov /* 23902c6fc21SKonstantin Belousov * Only allow to lower the maximal pid. 2403fa615bcSKonstantin Belousov * Prevent setting up a non-bootable system if pid_max is too low. 24102c6fc21SKonstantin Belousov */ 24202c6fc21SKonstantin Belousov TUNABLE_INT_FETCH("kern.pid_max", &pid_max); 24302c6fc21SKonstantin Belousov if (pid_max > PID_MAX) 24402c6fc21SKonstantin Belousov pid_max = PID_MAX; 2453fa615bcSKonstantin Belousov else if (pid_max < 300) 2463fa615bcSKonstantin Belousov pid_max = 300; 247ee75e7deSKonstantin Belousov 248ee75e7deSKonstantin Belousov TUNABLE_INT_FETCH("vfs.unmapped_buf_allowed", &unmapped_buf_allowed); 2499d6ae1e3SColin Percival TSEXIT(); 250ee342e1bSPeter Wemm } 25166a11b9fSMatthew Dillon 25266a11b9fSMatthew Dillon /* 25366a11b9fSMatthew Dillon * Boot time overrides that are scaled against main memory 25466a11b9fSMatthew Dillon */ 25566a11b9fSMatthew Dillon void 256447b3772SPeter Wemm init_param2(long physpages) 25766a11b9fSMatthew Dillon { 25866a11b9fSMatthew Dillon 2599d6ae1e3SColin Percival TSENTER(); 26066a11b9fSMatthew Dillon /* Base parameters */ 2610b94a0e9SMatthew Dillon maxusers = MAXUSERS; 2620b94a0e9SMatthew Dillon TUNABLE_INT_FETCH("kern.maxusers", &maxusers); 2630b94a0e9SMatthew Dillon if (maxusers == 0) { 2644fbd563eSMatthew Dillon maxusers = physpages / (2 * 1024 * 1024 / PAGE_SIZE); 26566a11b9fSMatthew Dillon if (maxusers < 32) 26666a11b9fSMatthew Dillon maxusers = 32; 26779f62ed6SAlfred Perlstein #ifdef VM_MAX_AUTOTUNE_MAXUSERS 26879f62ed6SAlfred Perlstein if (maxusers > VM_MAX_AUTOTUNE_MAXUSERS) 26979f62ed6SAlfred Perlstein maxusers = VM_MAX_AUTOTUNE_MAXUSERS; 27079f62ed6SAlfred Perlstein #endif 2717b6d92c0SAlfred Perlstein /* 27279f62ed6SAlfred Perlstein * Scales down the function in which maxusers grows once 27379f62ed6SAlfred Perlstein * we hit 384. 2747b6d92c0SAlfred Perlstein */ 27579f62ed6SAlfred Perlstein if (maxusers > 384) 27679f62ed6SAlfred Perlstein maxusers = 384 + ((maxusers - 384) / 8); 27766a11b9fSMatthew Dillon } 27866a11b9fSMatthew Dillon 27966a11b9fSMatthew Dillon /* 28066a11b9fSMatthew Dillon * The following can be overridden after boot via sysctl. Note: 2812b7d656fSGordon Bergling * unless overridden, these macros are ultimately based on maxusers. 28277a7d074SMike Silbersack * Limit maxproc so that kmap entries cannot be exhausted by 28377a7d074SMike Silbersack * processes. 28477a7d074SMike Silbersack */ 285ead46972SAndre Oppermann maxproc = NPROC; 286ead46972SAndre Oppermann TUNABLE_INT_FETCH("kern.maxproc", &maxproc); 28777a7d074SMike Silbersack if (maxproc > (physpages / 12)) 28877a7d074SMike Silbersack maxproc = physpages / 12; 2891f57d8c6SKonstantin Belousov if (maxproc > pid_max) 2901f57d8c6SKonstantin Belousov maxproc = pid_max; 291ebacce5eSMike Silbersack maxprocperuid = (maxproc * 9) / 10; 292ead46972SAndre Oppermann 293ead46972SAndre Oppermann /* 294ead46972SAndre Oppermann * The default limit for maxfiles is 1/12 of the number of 295ead46972SAndre Oppermann * physical page but not less than 16 times maxusers. 296ead46972SAndre Oppermann * At most it can be 1/6 the number of physical pages. 297ead46972SAndre Oppermann */ 298ead46972SAndre Oppermann maxfiles = imax(MAXFILES, physpages / 8); 299ead46972SAndre Oppermann TUNABLE_INT_FETCH("kern.maxfiles", &maxfiles); 300ead46972SAndre Oppermann if (maxfiles > (physpages / 4)) 301ead46972SAndre Oppermann maxfiles = physpages / 4; 302ead46972SAndre Oppermann maxfilesperproc = (maxfiles / 10) * 9; 30332766cd2SAdrian Chadd TUNABLE_INT_FETCH("kern.maxfilesperproc", &maxfilesperproc); 30466a11b9fSMatthew Dillon 30566a11b9fSMatthew Dillon /* 306347194c1SMike Silbersack * Cannot be changed after boot. 307347194c1SMike Silbersack */ 308347194c1SMike Silbersack nbuf = NBUF; 309347194c1SMike Silbersack TUNABLE_INT_FETCH("kern.nbuf", &nbuf); 310ee75e7deSKonstantin Belousov TUNABLE_INT_FETCH("kern.bio_transient_maxcnt", &bio_transient_maxcnt); 311cd853791SKonstantin Belousov maxphys = MAXPHYS; 312cd853791SKonstantin Belousov TUNABLE_ULONG_FETCH("kern.maxphys", &maxphys); 313cd853791SKonstantin Belousov if (maxphys == 0) { 314cd853791SKonstantin Belousov maxphys = MAXPHYS; 315cd853791SKonstantin Belousov } else if (__bitcountl(maxphys) != 1) { /* power of two */ 316cd853791SKonstantin Belousov if (flsl(maxphys) == NBBY * sizeof(maxphys)) 317cd853791SKonstantin Belousov maxphys = MAXPHYS; 318cd853791SKonstantin Belousov else 319cd853791SKonstantin Belousov maxphys = 1UL << flsl(maxphys); 320cd853791SKonstantin Belousov } 321cd853791SKonstantin Belousov if (maxphys < PAGE_SIZE) 322cd853791SKonstantin Belousov maxphys = MAXPHYS; 323347194c1SMike Silbersack 324ead46972SAndre Oppermann /* 325756a5412SGleb Smirnoff * Physical buffers are pre-allocated buffers (struct buf) that 326756a5412SGleb Smirnoff * are used as temporary holders for I/O, such as paging I/O. 327756a5412SGleb Smirnoff */ 328756a5412SGleb Smirnoff TUNABLE_INT_FETCH("kern.nswbuf", &nswbuf); 329756a5412SGleb Smirnoff 330756a5412SGleb Smirnoff /* 331e9a3f785SAlan Cox * The default for maxpipekva is min(1/64 of the kernel address space, 332e9a3f785SAlan Cox * max(1/64 of main memory, 512KB)). See sys_pipe.c for more details. 333347194c1SMike Silbersack */ 334cd853791SKonstantin Belousov maxpipekva = ptoa(physpages / 64); 335ead46972SAndre Oppermann TUNABLE_LONG_FETCH("kern.ipc.maxpipekva", &maxpipekva); 336289016f2SMike Silbersack if (maxpipekva < 512 * 1024) 337289016f2SMike Silbersack maxpipekva = 512 * 1024; 338e9a3f785SAlan Cox if (maxpipekva > (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) / 64) 339e9a3f785SAlan Cox maxpipekva = (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) / 340e9a3f785SAlan Cox 64; 3419d6ae1e3SColin Percival TSEXIT(); 34266a11b9fSMatthew Dillon } 3433610a226SIvan Voras 3443610a226SIvan Voras /* 34546038d7fSKonstantin Belousov * Sysctl stringifying handler for kern.vm_guest. 3463610a226SIvan Voras */ 3473610a226SIvan Voras static int 3483610a226SIvan Voras sysctl_kern_vm_guest(SYSCTL_HANDLER_ARGS) 3493610a226SIvan Voras { 350acfc962fSIan Lepore return (SYSCTL_OUT_STR(req, vm_guest_sysctl_names[vm_guest])); 3513610a226SIvan Voras } 352