xref: /dragonfly/sys/kern/subr_param.c (revision a3127495)
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  * 3. 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  * $FreeBSD: src/sys/kern/subr_param.c,v 1.42.2.10 2002/03/09 21:05:47 silby Exp $
36  */
37 
38 #include "opt_param.h"
39 #include "opt_maxusers.h"
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
44 #include <sys/malloc.h>
45 #include <sys/sysctl.h>
46 #include <vm/pmap.h>
47 #include <machine/vmparam.h>
48 
49 /*
50  * System parameter formulae.
51  */
52 
53 #ifndef HZ_DEFAULT
54 #define	HZ_DEFAULT	100
55 #endif
56 #define	NPROC		(20 + 16 * maxusers)
57 #ifndef NBUF
58 #define NBUF		0
59 #endif
60 #ifndef MAXFILES
61 #define	MAXFILES	(maxproc * 16)
62 #endif
63 #ifndef MAXPOSIXLOCKSPERUID
64 #define MAXPOSIXLOCKSPERUID (maxproc * 4)
65 #endif
66 
67 static int sysctl_kern_vmm_guest(SYSCTL_HANDLER_ARGS);
68 
69 int	hz;
70 int	stathz;
71 int	profhz;
72 int	ustick;				/* tick interval in microseconds */
73 int	nstick;				/* tick interval in nanoseconds */
74 int	maxusers;			/* base tunable */
75 int	maxproc;			/* maximum # of processes */
76 int	maxprocperuid;			/* max # of procs per user */
77 int	maxfiles;			/* system wide open files limit */
78 int	maxfilesrootres;		/* descriptors reserved for root use */
79 int	minfilesperproc;		/* per-proc min open files (safety) */
80 int	maxfilesperproc;		/* per-proc open files limit */
81 int	maxfilesperuser;		/* per-user open files limit */
82 int	maxposixlocksperuid;		/* max # POSIX locks per uid */
83 int	ncallout;			/* maximum # of timer events */
84 int	mbuf_wait = 32;			/* mbuf sleep time in ticks */
85 long	nbuf;
86 long	nswbuf_mem;
87 long	nswbuf_kva;
88 long	nswbuf_raw;
89 long	maxswzone;			/* max swmeta KVA storage */
90 long	maxbcache;			/* max buffer cache KVA storage */
91 enum vmm_guest_type vmm_guest = VMM_GUEST_NONE;	/* Running as VM guest? */
92 u_quad_t	maxtsiz;			/* max text size */
93 u_quad_t	dfldsiz;			/* initial data size limit */
94 u_quad_t	maxdsiz;			/* max data size */
95 u_quad_t	dflssiz;			/* initial stack size limit */
96 u_quad_t	maxssiz;			/* max stack size */
97 u_quad_t	sgrowsiz;			/* amount to grow stack */
98 
99 SYSCTL_PROC(_kern, OID_AUTO, vmm_guest, CTLFLAG_RD | CTLTYPE_STRING,
100     NULL, 0, sysctl_kern_vmm_guest, "A",
101     "Virtual machine guest type");
102 
103 /*
104  * These have to be allocated somewhere; allocating
105  * them here forces loader errors if this file is omitted
106  * (if they've been externed everywhere else; hah!).
107  */
108 struct	buf *swbuf_mem;
109 struct	buf *swbuf_kva;
110 struct	buf *swbuf_raw;
111 
112 struct vmm_bname {
113 	const char *str;
114 	enum vmm_guest_type type;
115 };
116 
117 static struct vmm_bname vmm_bnames[] = {
118 	{ "QEMU",	VMM_GUEST_QEMU },	/* QEMU */
119 	{ "Plex86",	VMM_GUEST_PLEX86 },	/* Plex86 */
120 	{ "Bochs",	VMM_GUEST_BOCHS },	/* Bochs */
121 	{ "Xen",	VMM_GUEST_XEN },	/* Xen */
122 	{ "BHYVE",	VMM_GUEST_BHYVE },	/* bhyve */
123 	{ "Seabios",	VMM_GUEST_KVM},		/* KVM */
124 	{ NULL, 0 }
125 };
126 
127 static struct vmm_bname vmm_pnames[] = {
128 	{ "VMware Virtual Platform",	VMM_GUEST_VMWARE },	/* VMWare VM */
129 	{ "Virtual Machine",		VMM_GUEST_HYPERV },	/* MS Hyper-V */
130 	{ "VirtualBox",			VMM_GUEST_VBOX },	/* Sun VirtualBox */
131 	{ "Parallels Virtual Platform",	VMM_GUEST_PARALLELS },	/* Parallels VM */
132 	{ "KVM",			VMM_GUEST_KVM },	/* KVM */
133 	{ NULL, 0 }
134 };
135 
136 static const char *const vmm_guest_sysctl_names[] = {
137 	"none",
138 	"qemu",
139 	"plex86",
140 	"bochs",
141 	"xen",
142 	"bhyve",
143 	"kvm",
144 	"vmware",
145 	"hyperv",
146 	"vbox",
147 	"parallels",
148 	"vkernel",
149 	"unknown",
150 	NULL
151 };
152 CTASSERT(NELEM(vmm_guest_sysctl_names) - 1 == VMM_GUEST_LAST);
153 
154 char		vmm_vendor[16];
155 SYSCTL_STRING(_kern, OID_AUTO, vmm_vendor, CTLFLAG_RD, vmm_vendor, 0,
156     "Virtual machine vendor");
157 
158 /*
159  * Detect known Virtual Machine hosts by inspecting the emulated BIOS.
160  */
161 enum vmm_guest_type
162 detect_virtual(void)
163 {
164 	char *sysenv;
165 	int i;
166 
167 	sysenv = kgetenv("smbios.bios.vendor");
168 	if (sysenv != NULL) {
169 		for (i = 0; vmm_bnames[i].str != NULL; i++)
170 			if (strcmp(sysenv, vmm_bnames[i].str) == 0) {
171 				kfreeenv(sysenv);
172 				return (vmm_bnames[i].type);
173 			}
174 		kfreeenv(sysenv);
175 	}
176 	sysenv = kgetenv("smbios.system.product");
177 	if (sysenv != NULL) {
178 		for (i = 0; vmm_pnames[i].str != NULL; i++)
179 			if (strcmp(sysenv, vmm_pnames[i].str) == 0) {
180 				kfreeenv(sysenv);
181 				return (vmm_pnames[i].type);
182 			}
183 		kfreeenv(sysenv);
184 	}
185 	return (VMM_GUEST_NONE);
186 }
187 
188 /*
189  * Boot time overrides that are not scaled against main memory
190  */
191 void
192 init_param1(void)
193 {
194 	hz = HZ_DEFAULT;
195 	TUNABLE_INT_FETCH("kern.hz", &hz);
196 	stathz = hz * 128 / 100;
197 	profhz = stathz;
198 	ustick = 1000000 / hz;
199 	nstick = 1000000000 / hz;
200 	/* can adjust 30ms in 60s */
201 	ntp_default_tick_delta = howmany(30000000, 60 * hz);
202 
203 #ifdef VM_SWZONE_SIZE_MAX
204 	maxswzone = VM_SWZONE_SIZE_MAX;
205 #endif
206 	TUNABLE_LONG_FETCH("kern.maxswzone", &maxswzone);
207 #ifdef VM_BCACHE_SIZE_MAX
208 	maxbcache = VM_BCACHE_SIZE_MAX;
209 #endif
210 	TUNABLE_LONG_FETCH("kern.maxbcache", &maxbcache);
211 	maxtsiz = MAXTSIZ;
212 	TUNABLE_QUAD_FETCH("kern.maxtsiz", &maxtsiz);
213 	dfldsiz = DFLDSIZ;
214 	TUNABLE_QUAD_FETCH("kern.dfldsiz", &dfldsiz);
215 	maxdsiz = MAXDSIZ;
216 	TUNABLE_QUAD_FETCH("kern.maxdsiz", &maxdsiz);
217 	dflssiz = DFLSSIZ;
218 	TUNABLE_QUAD_FETCH("kern.dflssiz", &dflssiz);
219 	maxssiz = MAXSSIZ;
220 	TUNABLE_QUAD_FETCH("kern.maxssiz", &maxssiz);
221 	sgrowsiz = SGROWSIZ;
222 	TUNABLE_QUAD_FETCH("kern.sgrowsiz", &sgrowsiz);
223 }
224 
225 /*
226  * Boot time overrides that are scaled against main memory
227  */
228 void
229 init_param2(int physpages)
230 {
231 	size_t limsize;
232 
233 	/*
234 	 * Calculate manually becaus the VM page queues / system is not set
235 	 * up yet.
236 	 */
237 	limsize = (size_t)physpages * PAGE_SIZE;
238 	if (limsize > KvaSize)
239 		limsize = KvaSize;
240 	if (maxswzone > limsize / 2)	/* maxswzone size (1/2 of phys mem) */
241 		maxswzone = limsize / 2;
242 
243 	limsize /= 1024 * 1024;		/* smaller of KVM or physmem in MB */
244 
245 	/* Base parameters */
246 	maxusers = MAXUSERS;
247 	TUNABLE_INT_FETCH("kern.maxusers", &maxusers);
248 	if (maxusers == 0) {
249 		maxusers = limsize / 8;		/* ~384 per 3G */
250 		if (maxusers < 32)
251 			maxusers = 32;
252 		/* no upper limit */
253 	}
254 
255 	/*
256 	 * The following can be overridden after boot via sysctl.  Note:
257 	 * unless overriden, these macros are ultimately based on maxusers.
258 	 *
259 	 * Limit maxproc so that kmap entries cannot be exhausted by
260 	 * processes.  This limitation can be a bit problematic because
261 	 * processes can have a wide range of complexity.
262 	 */
263 	maxproc = NPROC;
264 	TUNABLE_INT_FETCH("kern.maxproc", &maxproc);
265 	if (maxproc < 32)
266 		maxproc = 32;
267 	if (maxproc > limsize * 40)
268 		maxproc = limsize * 40;
269 
270 	/*
271 	 * Maximum number of open files
272 	 */
273 	maxfiles = MAXFILES;
274 	TUNABLE_INT_FETCH("kern.maxfiles", &maxfiles);
275 	if (maxfiles < 128)
276 		maxfiles = 128;
277 
278 	/*
279 	 * Limit file descriptors so no single user can exhaust the
280 	 * system.
281 	 *
282 	 * WARNING: Do not set minfilesperproc too high or the user
283 	 *	    can exhaust the system with a combination of fork()
284 	 *	    and open().  Actual worst case is:
285 	 *
286 	 *	    (minfilesperproc * maxprocperuid) + maxfilesperuser
287 	 */
288 	maxprocperuid = maxproc / 4;
289 	if (maxprocperuid < 128)
290 		maxprocperuid = maxproc / 2;
291 	minfilesperproc = 8;
292 	maxfilesperproc = maxfiles / 4;
293 	maxfilesperuser = maxfilesperproc * 2;
294 	maxfilesrootres = maxfiles / 20;
295 
296 	/*
297 	 * Severe hack to try to prevent pipe() descriptors from
298 	 * blowing away kernel memory.
299 	 */
300 	if (KvaSize <= (vm_offset_t)(1536LL * 1024 * 1024) &&
301 	    maxfilesperuser > 20000) {
302 		maxfilesperuser = 20000;
303 	}
304 
305 	maxposixlocksperuid = MAXPOSIXLOCKSPERUID;
306 	TUNABLE_INT_FETCH("kern.maxposixlocksperuid", &maxposixlocksperuid);
307 
308 	/*
309 	 * Unless overriden, NBUF is typically 0 (auto-sized later).
310 	 */
311 	nbuf = NBUF;
312 	TUNABLE_LONG_FETCH("kern.nbuf", &nbuf);
313 
314 	/*
315 	 * Calculate the size of the callout wheel.  Limit to approximately
316 	 * 5 minutes worth of table (maxproc would have to be pretty huge),
317 	 * as more is not likely to gain us anything.
318 	 */
319 	ncallout = 16 + maxproc + maxfiles;
320 	if (ncallout > 5*60*hz)
321 		ncallout = 5*60*hz;
322 	TUNABLE_INT_FETCH("kern.ncallout", &ncallout);
323 }
324 
325 /*
326  * Sysctl stringifying handler for kern.vmm_guest.
327  */
328 static int
329 sysctl_kern_vmm_guest(SYSCTL_HANDLER_ARGS)
330 {
331 	return (SYSCTL_OUT(req, vmm_guest_sysctl_names[vmm_guest],
332 	    strlen(vmm_guest_sysctl_names[vmm_guest])));
333 }
334