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