xref: /illumos-gate/usr/src/uts/common/conf/param.c (revision d96925c4)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
24  * Copyright (c) 1983, 2010, Oracle and/or its affiliates. All rights reserved.
25  * Copyright 2012 Milan Jurik. All rights reserved.
26  */
27 
28 #include <sys/types.h>
29 #include <sys/time.h>
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/signal.h>
33 #include <sys/sysmacros.h>
34 #include <sys/cmn_err.h>
35 #include <sys/user.h>
36 #include <sys/proc.h>
37 #include <sys/task.h>
38 #include <sys/project.h>
39 #include <sys/klwp.h>
40 #include <sys/vnode.h>
41 #include <sys/file.h>
42 #include <sys/fcntl.h>
43 #include <sys/flock.h>
44 #include <sys/var.h>
45 #include <sys/stream.h>
46 #include <sys/strsubr.h>
47 #include <sys/conf.h>
48 #include <sys/class.h>
49 #include <sys/ts.h>
50 #include <sys/rt.h>
51 #include <sys/exec.h>
52 #include <sys/exechdr.h>
53 #include <sys/buf.h>
54 #include <sys/resource.h>
55 #include <vm/seg.h>
56 #include <vm/pvn.h>
57 #include <vm/seg_kmem.h>
58 #include <sys/vmparam.h>
59 #include <sys/machparam.h>
60 #include <sys/utsname.h>
61 #include <sys/kmem.h>
62 #include <sys/stack.h>
63 #include <sys/modctl.h>
64 #include <sys/fdbuffer.h>
65 #include <sys/cyclic_impl.h>
66 #include <sys/disp.h>
67 #include <sys/tuneable.h>
68 #include <sys/systeminfo.h>
69 
70 #include <sys/vmem.h>
71 #include <sys/clock.h>
72 #include <sys/clock_impl.h>
73 #include <sys/serializer.h>
74 
75 /*
76  * The following few lines describe generic things that must be compiled
77  * into the booted executable (unix) rather than genunix or any other
78  * module because they're required by crash dump readers, etc.
79  */
80 struct modctl modules;		/* head of linked list of modules */
81 char *default_path;		/* default module loading path */
82 struct swapinfo *swapinfo;	/* protected by the swapinfo_lock */
83 proc_t *practive;		/* active process list */
84 uint_t nproc;			/* current number of processes */
85 proc_t p0;			/* process 0 */
86 struct plock p0lock;		/* p0's p_lock */
87 klwp_t lwp0;			/* t0's lwp */
88 task_t *task0p;			/* task 0 */
89 kproject_t *proj0p;		/* location of project 0 */
90 
91 /*
92  * The following are "implementation architecture" dependent constants made
93  * available here in the form of initialized data for use by "implementation
94  * architecture" independent modules. See machparam.h.
95  */
96 const unsigned long	_pagesize	= (unsigned long)PAGESIZE;
97 const unsigned int	_pageshift	= (unsigned int)PAGESHIFT;
98 const unsigned long	_pageoffset	= (unsigned long)PAGEOFFSET;
99 /*
100  * XXX - This value pagemask has to be a 64bit size because
101  * large file support uses this mask on offsets which are 64 bit size.
102  * using unsigned leaves the higher 32 bits value as zero thus
103  * corrupting offset calculations in the file system and VM.
104  */
105 const u_longlong_t	_pagemask	= (u_longlong_t)PAGEMASK;
106 const unsigned long	_mmu_pagesize	= (unsigned long)MMU_PAGESIZE;
107 const unsigned int	_mmu_pageshift	= (unsigned int)MMU_PAGESHIFT;
108 const unsigned long	_mmu_pageoffset	= (unsigned long)MMU_PAGEOFFSET;
109 const unsigned long	_mmu_pagemask	= (unsigned long)MMU_PAGEMASK;
110 uintptr_t		_kernelbase	= (uintptr_t)KERNELBASE;
111 uintptr_t		_userlimit	= (uintptr_t)USERLIMIT;
112 uintptr_t		_userlimit32	= (uintptr_t)USERLIMIT32;
113 const uintptr_t		_argsbase	= (uintptr_t)ARGSBASE;
114 const unsigned int	_diskrpm	= (unsigned int)DISKRPM;
115 const unsigned long	_pgthresh	= (unsigned long)PGTHRESH;
116 const unsigned int	_maxslp		= (unsigned int)MAXSLP;
117 const unsigned long	_maxhandspreadpages = (unsigned long)MAXHANDSPREADPAGES;
118 const int		_ncpu		= (int)NCPU;
119 const int		_ncpu_log2	= (int)NCPU_LOG2;
120 const int		_ncpu_p2	= (int)NCPU_P2;
121 const unsigned long	_defaultstksz	= (unsigned long)DEFAULTSTKSZ;
122 const unsigned int	_nbpg		= (unsigned int)MMU_PAGESIZE;
123 
124 /*
125  * System parameter formulae.
126  *
127  * This file is copied into each directory where we compile
128  * the kernel; it should be modified there to suit local taste
129  * if necessary.
130  */
131 
132 /*
133  * hz is 100, but we set hires_tick to get higher resolution clock behavior
134  * (currently defined to be 1000 hz).  Higher values seem to work, but are not
135  * supported.
136  *
137  * This is configured via hires_tick to allow users to explicitly customize it
138  * to 0 should the need arise.
139  *
140  * If we do decide to play with higher values, remember that hz should
141  * satisfy the following constraints to avoid integer round-off problems:
142  *
143  * (1) hz should be in the range 100 <= hz <= MICROSEC.  If hz exceeds
144  *     MICROSEC, usec_per_tick will be zero and lots of stuff will break.
145  *     Similarly, if hz < 100 then hz / 100 == 0 and stuff will break.
146  *
147  * (2) If hz <= 1000, it should be both a multiple of 100 and a
148  *	divisor of 1000.
149  *
150  * (3) If hz > 1000, it should be both a multiple of 1000 and a
151  *	divisor of MICROSEC.
152  *
153  * Thus the only reasonable values of hz (i.e. the values that won't
154  * cause roundoff error) are: 100, 200, 500, 1000, 2000, 4000, 5000,
155  * 8000, 10000, 20000, 25000, 40000, 50000, 100000, 125000, 200000,
156  * 250000, 500000, 1000000.  As of this writing (1996) a clock rate
157  * of more than about 10 kHz seems utterly ridiculous, although
158  * this observation will no doubt seem quaintly amusing one day.
159  */
160 #define	HIRES_HZ_DEFAULT	1000
161 
162 int hz = HZ_DEFAULT;
163 int hires_hz = HIRES_HZ_DEFAULT;
164 
165 int hires_tick = 1;
166 int cpu_decay_factor = 10;	/* this is no longer tied to clock */
167 int max_hres_adj;	/* maximum adjustment of hrtime per tick */
168 int tick_per_msec;	/* clock ticks per millisecond (zero if hz < 1000) */
169 
170 /*
171  * Milliseconds, Microseconds, and Nanoseconds per clock tick
172  *
173  * Note:
174  *  msec_per_tick is zero if hz > 1000
175  */
176 int msec_per_tick;
177 int usec_per_tick;
178 int nsec_per_tick;
179 
180 /*
181  * Time Resolution values. These are defined in condvar.h and initialized in
182  * param_init(). Consumers of cv_reltimedwait() and cv_reltimedwait_sig()
183  * need to specify how accurate the timeout argument should be through
184  * one of these values. The intention is to allow the underlying implementation
185  * to anticipate or defer the expiration of timeouts, preventing unnecessary
186  * wakeups by batch processing similarly expiring events.
187  */
188 time_res_t time_res[TR_COUNT];
189 
190 /*
191  * Setting "snooping" to a non-zero value will cause a deadman panic if
192  * snoop_interval microseconds elapse without lbolt increasing.  The default
193  * snoop_interval is 50 seconds.
194  */
195 #define	SNOOP_INTERVAL_MIN	(MICROSEC)
196 #define	SNOOP_INTERVAL_DEFAULT	(50 * MICROSEC)
197 
198 int snooping = 0;
199 uint_t snoop_interval = SNOOP_INTERVAL_DEFAULT;
200 
201 /*
202  * Tables of initialization functions, called from main().
203  */
204 
205 extern void system_taskq_init(void);
206 extern void binit(void);
207 extern void space_init(void);
208 extern void dnlc_init(void);
209 extern void vfsinit(void);
210 extern void finit(void);
211 extern void strinit(void);
212 extern void flk_init(void);
213 extern void ftrace_init(void);
214 extern void softcall_init(void);
215 extern void ttyinit(void);
216 extern void schedctl_init(void);
217 extern void deadman_init(void);
218 extern void clock_timer_init(void);
219 extern void clock_realtime_init(void);
220 extern void clock_highres_init(void);
221 extern void clock_tick_mp_init(void);
222 extern void cu_init(void);
223 extern void callout_mp_init(void);
224 extern void cpu_seq_tbl_init(void);
225 
226 void	(*init_tbl[])(void) = {
227 	system_taskq_init,
228 	binit,
229 	space_init,
230 	dnlc_init,
231 	vfsinit,
232 	finit,
233 	strinit,
234 	serializer_init,
235 	softcall_init,
236 	ttyinit,
237 	as_init,
238 	pvn_init,
239 	anon_init,
240 	segvn_init,
241 	flk_init,
242 	cpu_seq_tbl_init,
243 	schedctl_init,
244 	fdb_init,
245 	deadman_init,
246 	clock_timer_init,
247 	clock_realtime_init,
248 	clock_highres_init,
249 	0
250 };
251 
252 
253 #if defined(__sparc)
254 	extern void siron_mp_init();
255 #endif
256 
257 /*
258  * Any per cpu resources should be initialized via
259  * an entry in mp_init_tbl().
260  */
261 void	(*mp_init_tbl[])(void) = {
262 	ftrace_init,
263 	cyclic_mp_init,
264 #if defined(__sparc)
265 	siron_mp_init,
266 #endif
267 	clock_tick_mp_init,
268 	cu_init,
269 	callout_mp_init,
270 	0
271 };
272 
273 int maxusers;		/* kitchen-sink knob for dynamic configuration */
274 
275 /*
276  * pidmax -- highest pid value assigned by the system
277  * Settable in /etc/system
278  */
279 int pidmax = DEFAULT_MAXPID;
280 
281 /*
282  * jump_pid - if set, this value is where pid numbers should start
283  * after the first few system pids (0-3) are used.  If 0, pids are
284  * chosen in the usual way. This variable can be used to quickly
285  * create large pids (by setting it to 100000, for example). pids
286  * less than this value will never be chosen.
287  */
288 pid_t jump_pid = DEFAULT_JUMPPID;
289 
290 /*
291  * autoup -- used in struct var for dynamic config of the age a delayed-write
292  * buffer must be in seconds before bdflush will write it out.
293  */
294 #define	DEFAULT_AUTOUP	30
295 int autoup = DEFAULT_AUTOUP;
296 
297 /*
298  * bufhwm -- tuneable variable for struct var for v_bufhwm.
299  * high water mark for buffer cache mem usage in units of K bytes.
300  *
301  * bufhwm_pct -- ditto, but given in % of physmem.
302  */
303 int bufhwm = 0;
304 int bufhwm_pct = 0;
305 
306 /*
307  * Process table.
308  */
309 int maxpid;
310 int max_nprocs;		/* set in param_init() */
311 int maxuprc;		/* set in param_init() */
312 int reserved_procs;
313 int nthread = 1;
314 
315 /*
316  * UFS tunables
317  */
318 int ufs_ninode;		/* declared here due to backwards compatibility */
319 int ndquot;		/* declared here due to backwards compatibility */
320 
321 /*
322  * Exec switch table. This is used by the generic exec module
323  * to switch out to the desired executable type, based on the
324  * magic number. The currently supported types are ELF, a.out
325  * (both NMAGIC and ZMAGIC), interpreter (#!) files,
326  * and Java executables.
327  */
328 /*
329  * Magic numbers
330  */
331 short elfmagic = 0x7f45;
332 short intpmagic = 0x2321;
333 short jmagic = 0x504b;
334 
335 #if defined(__sparc)
336 short aout_nmagic = NMAGIC;
337 short aout_zmagic = ZMAGIC;
338 short aout_omagic = OMAGIC;
339 #endif
340 short nomagic = 0;
341 
342 /*
343  * Magic strings
344  */
345 #define	ELF32MAGIC_STRING	"\x7f""ELF\x1"
346 #define	ELF64MAGIC_STRING	"\x7f""ELF\x2"
347 #define	INTPMAGIC_STRING	"#!"
348 #define	JAVAMAGIC_STRING	"PK\003\004"
349 #define	AOUT_OMAGIC_STRING	"\x1""\x07"	/* 0407 */
350 #define	AOUT_NMAGIC_STRING	"\x1""\x08"	/* 0410 */
351 #define	AOUT_ZMAGIC_STRING	"\x1""\x0b"	/* 0413 */
352 #define	NOMAGIC_STRING		""
353 
354 #define	SHBIN_CNTL(x)	((x)&037)
355 #define	SHBINMAGIC_STRING {SHBIN_CNTL('k'), SHBIN_CNTL('s'), SHBIN_CNTL('h'), 0}
356 #define	SHBINMAGIC_LEN	4
357 
358 char elf32magicstr[] = ELF32MAGIC_STRING;
359 char elf64magicstr[] = ELF64MAGIC_STRING;
360 char intpmagicstr[] = INTPMAGIC_STRING;
361 char shbinmagicstr[] = SHBINMAGIC_STRING;
362 char javamagicstr[] = JAVAMAGIC_STRING;
363 #if defined(__sparc)
364 char aout_nmagicstr[] = AOUT_NMAGIC_STRING;
365 char aout_zmagicstr[] = AOUT_ZMAGIC_STRING;
366 char aout_omagicstr[] = AOUT_OMAGIC_STRING;
367 #endif
368 char nomagicstr[] = NOMAGIC_STRING;
369 
370 char *execswnames[] = {
371 	"elfexec",	/* Elf32 */
372 #ifdef _LP64
373 	"elfexec",	/* Elf64 */
374 #endif
375 	"intpexec",
376 	"shbinexec",
377 	"javaexec",
378 #if defined(__sparc)
379 	"aoutexec",
380 	"aoutexec",
381 	"aoutexec",
382 #endif
383 	NULL,
384 	NULL,
385 	NULL
386 };
387 
388 struct execsw execsw[] = {
389 	{ elf32magicstr, 0, 5, NULL, NULL, NULL },
390 #ifdef _LP64
391 	{ elf64magicstr, 0, 5, NULL, NULL, NULL },
392 #endif
393 	{ intpmagicstr, 0, 2, NULL, NULL, NULL },
394 	{ shbinmagicstr, 0, SHBINMAGIC_LEN, NULL, NULL, NULL },
395 	{ javamagicstr, 0, 4, NULL, NULL, NULL },
396 #if defined(__sparc)
397 	{ aout_zmagicstr, 2, 2, NULL, NULL, NULL },
398 	{ aout_nmagicstr, 2, 2, NULL, NULL, NULL },
399 	{ aout_omagicstr, 2, 2, NULL, NULL, NULL },
400 #endif
401 	{ nomagicstr, 0, 0, NULL, NULL, NULL },
402 	{ nomagicstr, 0, 0, NULL, NULL, NULL },
403 	{ nomagicstr, 0, 0, NULL, NULL, NULL },
404 	{ nomagicstr, 0, 0, NULL, NULL, NULL }
405 };
406 int nexectype = sizeof (execsw) / sizeof (execsw[0]);	/* # of exec types */
407 kmutex_t execsw_lock;	/* Used for allocation of execsw entries */
408 
409 /*
410  * symbols added to make changing proc.max-file-descriptor
411  * simple via /etc/system
412  */
413 #define	RLIM_FD_CUR 0x10000
414 #define	RLIM_FD_MAX 0x10000
415 
416 uint_t rlim_fd_cur = RLIM_FD_CUR;
417 uint_t rlim_fd_max = RLIM_FD_MAX;
418 
419 /*
420  * (Default resource limits were formerly declared here, but are now provided by
421  * the more general resource controls framework.)
422  */
423 
424 /*
425  * STREAMS tunables
426  */
427 int	nstrpush = 9;		/* maximum # of modules/drivers on a stream */
428 ssize_t	strctlsz = 1024;	/* maximum size of user-generated M_PROTO */
429 ssize_t	strmsgsz = 0x10000;	/* maximum size of user-generated M_DATA */
430 				/* for `strmsgsz', zero means unlimited */
431 /*
432  * Filesystem tunables
433  */
434 int	rstchown = 1;		/* POSIX_CHOWN_RESTRICTED is enabled */
435 int	ngroups_max = NGROUPS_MAX_DEFAULT;
436 
437 /*
438  * generic scheduling stuff
439  *
440  * Configurable parameters for RT and TS are in the respective
441  * scheduling class modules.
442  */
443 
444 pri_t maxclsyspri = MAXCLSYSPRI;
445 pri_t minclsyspri = MINCLSYSPRI;
446 char sys_name[] = "SYS";
447 
448 extern pri_t sys_init(id_t, int, classfuncs_t **);
449 extern classfuncs_t sys_classfuncs;
450 
451 sclass_t sclass[] = {
452 	{ "SYS",	sys_init,	&sys_classfuncs, STATIC_SCHED, 0 },
453 	{ "",	NULL,	NULL,	NULL, 0 },
454 	{ "",	NULL,	NULL,	NULL, 0 },
455 	{ "",	NULL,	NULL,	NULL, 0 },
456 	{ "",	NULL,	NULL,	NULL, 0 },
457 	{ "",	NULL,	NULL,	NULL, 0 },
458 	{ "",	NULL,	NULL,	NULL, 0 },
459 	{ "",	NULL,	NULL,	NULL, 0 },
460 	{ "",	NULL,	NULL,	NULL, 0 },
461 	{ "",	NULL,	NULL,	NULL, 0 }
462 };
463 
464 int loaded_classes = 1;		/* for loaded classes */
465 kmutex_t class_lock;		/* lock for class[] */
466 
467 int nclass = sizeof (sclass) / sizeof (sclass_t);
468 char initcls[] = "TS";
469 char *defaultclass = initcls;
470 
471 /*
472  * Tunable system parameters.
473  */
474 
475 /*
476  * The integers tune_* are done this way so that the tune
477  * data structure may be "tuned" if necessary from the /etc/system
478  * file. The tune data structure is initialized in param_init();
479  */
480 
481 tune_t tune;
482 
483 /*
484  * If freemem < t_getpgslow, then start to steal pages from processes.
485  */
486 int tune_t_gpgslo = 25;
487 
488 /*
489  * Rate at which fsflush is run, in seconds.
490  */
491 #define	DEFAULT_TUNE_T_FSFLUSHR	1
492 int tune_t_fsflushr = DEFAULT_TUNE_T_FSFLUSHR;
493 
494 /*
495  * The minimum available resident (not swappable) memory to maintain
496  * in order to avoid deadlock.  In pages.
497  */
498 int tune_t_minarmem = 25;
499 
500 /*
501  * The minimum available swappable memory to maintain in order to avoid
502  * deadlock.  In pages.
503  */
504 int tune_t_minasmem = 25;
505 
506 int tune_t_flckrec = 512;	/* max # of active frlocks */
507 
508 /*
509  * Number of currently available pages that cannot be 'locked'
510  * This is set in init_pages_pp_maximum, and must be initialized
511  * to zero here to detect an override in /etc/system
512  */
513 pgcnt_t pages_pp_maximum = 0;
514 
515 int boothowto;			/* boot flags passed to kernel */
516 struct var v;			/* System Configuration Information */
517 
518 /*
519  * System Configuration Information
520  */
521 
522 /*
523  * The physical system's host identifier, expressed as a decimal string.
524  * Code should only directly access this value when writing to it (setting the
525  * physical system's host identifier).  Code that reads the physical system's
526  * host identifier should use zone_get_hostid(NULL) instead.
527  */
528 char hw_serial[HW_HOSTID_LEN] = "0";
529 
530 #if defined(__sparc)
531 
532 /*
533  * On sparc machines, read hw_serial from the firmware at boot time
534  * and simply assert Oracle is the hardware provider.
535  */
536 char architecture[] = "sparcv9";
537 char architecture_32[] = "sparc";
538 char hw_provider[] = "Oracle Corporation";
539 
540 #elif defined(__i386)
541 
542 char architecture[] = "i386";
543 char architecture_32[] = "i386";
544 char hw_provider[SYS_NMLN] = "";
545 
546 #elif defined(__amd64)
547 
548 char architecture[] = "amd64";
549 char architecture_32[] = "i386";
550 char hw_provider[SYS_NMLN] = "";
551 
552 #else
553 #error "unknown processor architecture"
554 #endif
555 
556 char srpc_domain[SYS_NMLN] = "";
557 char platform[SYS_NMLN] = "";	/* read from the devinfo root node */
558 
559 /* Initialize isa_list */
560 char *isa_list = architecture;
561 
562 static pgcnt_t original_physmem = 0;
563 
564 #define	MIN_DEFAULT_MAXUSERS	8u
565 #define	MAX_DEFAULT_MAXUSERS	2048u
566 #define	MAX_MAXUSERS		4096u
567 
568 void
param_preset(void)569 param_preset(void)
570 {
571 	original_physmem = physmem;
572 }
573 
574 void
param_calc(int platform_max_nprocs)575 param_calc(int platform_max_nprocs)
576 {
577 	/*
578 	 * Default to about one "user" per megabyte, taking into
579 	 * account both physical and virtual constraints.
580 	 * Note: 2^20 is a meg; shifting right by (20 - PAGESHIFT)
581 	 * converts pages to megs without integer overflow.
582 	 */
583 #if defined(__sparc)
584 	if (physmem > original_physmem) {
585 		physmem = original_physmem;
586 		cmn_err(CE_NOTE, "physmem limited to %ld", physmem);
587 	}
588 #endif
589 	if (maxusers == 0) {
590 		pgcnt_t physmegs = physmem >> (20 - PAGESHIFT);
591 		pgcnt_t virtmegs = vmem_size(heap_arena, VMEM_FREE) >> 20;
592 		maxusers = MIN(MAX(MIN(physmegs, virtmegs),
593 		    MIN_DEFAULT_MAXUSERS), MAX_DEFAULT_MAXUSERS);
594 	}
595 	if (maxusers > MAX_MAXUSERS) {
596 		maxusers = MAX_MAXUSERS;
597 		cmn_err(CE_NOTE, "maxusers limited to %d", MAX_MAXUSERS);
598 	}
599 
600 #ifdef DEBUG
601 	/*
602 	 * The purpose of maxusers is to prevent memory overcommit.
603 	 * DEBUG kernels take more space, so reduce maxusers a bit.
604 	 */
605 	maxusers = (3 * maxusers) / 4;
606 #endif
607 
608 	/*
609 	 * We need to dynamically change any variables now so that
610 	 * the setting of maxusers and pidmax propagate to the other
611 	 * variables that are dependent on them.
612 	 */
613 	if (reserved_procs == 0)
614 		reserved_procs = 5;
615 	if (pidmax < reserved_procs || pidmax > MAX_MAXPID)
616 		maxpid = MAX_MAXPID;
617 	else
618 		maxpid = pidmax;
619 
620 	/*
621 	 * This allows platform-dependent code to constrain the maximum
622 	 * number of processes allowed in case there are e.g. VM limitations
623 	 * with how many contexts are available.
624 	 */
625 	if (max_nprocs == 0)
626 		max_nprocs = (10 + 16 * maxusers);
627 	if (platform_max_nprocs > 0 && max_nprocs > platform_max_nprocs)
628 		max_nprocs = platform_max_nprocs;
629 	if (max_nprocs > maxpid)
630 		max_nprocs = maxpid;
631 
632 	if (maxuprc == 0)
633 		maxuprc = (max_nprocs - reserved_procs);
634 }
635 
636 void
param_init(void)637 param_init(void)
638 {
639 	/*
640 	 * Set each individual element of struct var v to be the
641 	 * default value. This is done this way
642 	 * so that a user can set the assigned integer value in the
643 	 * /etc/system file *IF* tuning is needed.
644 	 */
645 	v.v_proc = max_nprocs;	/* v_proc - max # of processes system wide */
646 	v.v_maxupttl = max_nprocs - reserved_procs;
647 	v.v_maxsyspri = (int)maxclsyspri;  /* max global pri for sysclass */
648 	v.v_maxup = MIN(maxuprc, v.v_maxupttl); /* max procs per user */
649 	v.v_autoup = autoup;	/* v_autoup - delay for delayed writes */
650 
651 	/*
652 	 * Set each individual element of struct tune to be the
653 	 * default value. Each struct element This is done this way
654 	 *  so that a user can set the assigned integer value in the
655 	 * /etc/system file *IF* tuning is needed.
656 	 */
657 	tune.t_gpgslo = tune_t_gpgslo;
658 	tune.t_fsflushr = tune_t_fsflushr;
659 	tune.t_minarmem = tune_t_minarmem;
660 	tune.t_minasmem = tune_t_minasmem;
661 	tune.t_flckrec = tune_t_flckrec;
662 
663 	/*
664 	 * Initialization for file descriptors to correct mistaken settings in
665 	 * /etc/system.  Initialization of limits performed by resource control
666 	 * system.
667 	 */
668 	if (rlim_fd_cur > rlim_fd_max)
669 		rlim_fd_cur = rlim_fd_max;
670 
671 	/*
672 	 * calculations needed if hz was set in /etc/system
673 	 */
674 	if (hires_tick)
675 		hz = hires_hz;
676 
677 	tick_per_msec = hz / MILLISEC;
678 	msec_per_tick = MILLISEC / hz;
679 	usec_per_tick = MICROSEC / hz;
680 	nsec_per_tick = NANOSEC / hz;
681 	max_hres_adj = nsec_per_tick >> ADJ_SHIFT;
682 
683 	/*
684 	 * Consumers of relative timedwait functions must specify how accurately
685 	 * the given timeout must expire. This is currently TR_CLOCK_TICK for
686 	 * the vast majority of consumers, but nsec_per_tick becomes an
687 	 * artificial value in a tickless world. Each caller of such routines
688 	 * should re-evaluate their usage and specify the appropriate
689 	 * resolution.
690 	 */
691 	time_res[TR_NANOSEC] = NANOSEC / NANOSEC;
692 	time_res[TR_MICROSEC] = NANOSEC / MICROSEC;
693 	time_res[TR_MILLISEC] = NANOSEC / MILLISEC;
694 	time_res[TR_SEC] = NANOSEC / SEC;
695 	time_res[TR_CLOCK_TICK] = nsec_per_tick;
696 }
697 
698 /*
699  * Validate tuneable parameters following /etc/system processing,
700  * but prior to param_init().
701  */
702 void
param_check(void)703 param_check(void)
704 {
705 #if defined(__x86)
706 	if (physmem != original_physmem) {
707 		cmn_err(CE_NOTE, "physmem cannot be modified to 0x%lx"
708 		    " via /etc/system. Please use eeprom(1M) instead.",
709 		    physmem);
710 		physmem = original_physmem;
711 	}
712 #endif
713 	if (ngroups_max < NGROUPS_UMIN)
714 		ngroups_max = NGROUPS_UMIN;
715 	if (ngroups_max > NGROUPS_UMAX)
716 		ngroups_max = NGROUPS_UMAX;
717 
718 	/* If we have many groups then the ucred proto message also grows. */
719 	if (ngroups_max > NGROUPS_OLDMAX &&
720 	    strctlsz < (ngroups_max - NGROUPS_OLDMAX) * sizeof (gid_t) + 1024) {
721 		strctlsz = (ngroups_max - NGROUPS_OLDMAX) * sizeof (gid_t) +
722 		    1024;
723 	}
724 
725 	if (autoup <= 0) {
726 		autoup = DEFAULT_AUTOUP;
727 		cmn_err(CE_WARN, "autoup <= 0; defaulting to %d", autoup);
728 	}
729 
730 	if (tune_t_fsflushr <= 0) {
731 		tune_t_fsflushr = DEFAULT_TUNE_T_FSFLUSHR;
732 		cmn_err(CE_WARN, "tune_t_fsflushr <= 0; defaulting to %d",
733 		    tune_t_fsflushr);
734 	}
735 
736 	if (jump_pid < 0 || jump_pid >= pidmax) {
737 		jump_pid = 0;
738 		cmn_err(CE_WARN, "jump_pid < 0 or >= pidmax; ignored");
739 	}
740 
741 	if (snoop_interval < SNOOP_INTERVAL_MIN) {
742 		snoop_interval = SNOOP_INTERVAL_DEFAULT;
743 		cmn_err(CE_WARN, "snoop_interval < minimum (%d); defaulting"
744 		    " to %d", SNOOP_INTERVAL_MIN, SNOOP_INTERVAL_DEFAULT);
745 	}
746 }
747