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_thread_init(void); 222 extern void clock_process_init(void); 223 extern void clock_tick_mp_init(void); 224 extern void cu_init(void); 225 extern void callout_mp_init(void); 226 extern void cpu_seq_tbl_init(void); 227 228 void (*init_tbl[])(void) = { 229 system_taskq_init, 230 binit, 231 space_init, 232 dnlc_init, 233 vfsinit, 234 finit, 235 strinit, 236 serializer_init, 237 softcall_init, 238 ttyinit, 239 as_init, 240 pvn_init, 241 anon_init, 242 segvn_init, 243 flk_init, 244 cpu_seq_tbl_init, 245 schedctl_init, 246 fdb_init, 247 deadman_init, 248 clock_timer_init, 249 clock_realtime_init, 250 clock_highres_init, 251 clock_thread_init, 252 clock_process_init, 253 NULL 254 }; 255 256 257 #if defined(__sparc) 258 extern void siron_mp_init(); 259 #endif 260 261 /* 262 * Any per cpu resources should be initialized via 263 * an entry in mp_init_tbl(). 264 */ 265 void (*mp_init_tbl[])(void) = { 266 ftrace_init, 267 cyclic_mp_init, 268 #if defined(__sparc) 269 siron_mp_init, 270 #endif 271 clock_tick_mp_init, 272 cu_init, 273 callout_mp_init, 274 0 275 }; 276 277 int maxusers; /* kitchen-sink knob for dynamic configuration */ 278 279 /* 280 * pidmax -- highest pid value assigned by the system 281 * Settable in /etc/system 282 */ 283 int pidmax = DEFAULT_MAXPID; 284 285 /* 286 * jump_pid - if set, this value is where pid numbers should start 287 * after the first few system pids (0-3) are used. If 0, pids are 288 * chosen in the usual way. This variable can be used to quickly 289 * create large pids (by setting it to 100000, for example). pids 290 * less than this value will never be chosen. 291 */ 292 pid_t jump_pid = DEFAULT_JUMPPID; 293 294 /* 295 * autoup -- used in struct var for dynamic config of the age a delayed-write 296 * buffer must be in seconds before bdflush will write it out. 297 */ 298 #define DEFAULT_AUTOUP 30 299 int autoup = DEFAULT_AUTOUP; 300 301 /* 302 * bufhwm -- tuneable variable for struct var for v_bufhwm. 303 * high water mark for buffer cache mem usage in units of K bytes. 304 * 305 * bufhwm_pct -- ditto, but given in % of physmem. 306 */ 307 int bufhwm = 0; 308 int bufhwm_pct = 0; 309 310 /* 311 * Process table. 312 */ 313 int maxpid; 314 int max_nprocs; /* set in param_init() */ 315 int maxuprc; /* set in param_init() */ 316 int reserved_procs; 317 int nthread = 1; 318 319 /* 320 * UFS tunables 321 */ 322 int ufs_ninode; /* declared here due to backwards compatibility */ 323 int ndquot; /* declared here due to backwards compatibility */ 324 325 /* 326 * Exec switch table. This is used by the generic exec module 327 * to switch out to the desired executable type, based on the 328 * magic number. The currently supported types are ELF, a.out 329 * (both NMAGIC and ZMAGIC), interpreter (#!) files, 330 * and Java executables. 331 */ 332 /* 333 * Magic numbers 334 */ 335 short elfmagic = 0x7f45; 336 short intpmagic = 0x2321; 337 short jmagic = 0x504b; 338 339 #if defined(__sparc) 340 short aout_nmagic = NMAGIC; 341 short aout_zmagic = ZMAGIC; 342 short aout_omagic = OMAGIC; 343 #endif 344 short nomagic = 0; 345 346 /* 347 * Magic strings 348 */ 349 #define ELF32MAGIC_STRING "\x7f""ELF\x1" 350 #define ELF64MAGIC_STRING "\x7f""ELF\x2" 351 #define INTPMAGIC_STRING "#!" 352 #define JAVAMAGIC_STRING "PK\003\004" 353 #define AOUT_OMAGIC_STRING "\x1""\x07" /* 0407 */ 354 #define AOUT_NMAGIC_STRING "\x1""\x08" /* 0410 */ 355 #define AOUT_ZMAGIC_STRING "\x1""\x0b" /* 0413 */ 356 #define NOMAGIC_STRING "" 357 358 #define SHBIN_CNTL(x) ((x)&037) 359 #define SHBINMAGIC_STRING {SHBIN_CNTL('k'), SHBIN_CNTL('s'), SHBIN_CNTL('h'), 0} 360 #define SHBINMAGIC_LEN 4 361 362 char elf32magicstr[] = ELF32MAGIC_STRING; 363 char elf64magicstr[] = ELF64MAGIC_STRING; 364 char intpmagicstr[] = INTPMAGIC_STRING; 365 char shbinmagicstr[] = SHBINMAGIC_STRING; 366 char javamagicstr[] = JAVAMAGIC_STRING; 367 #if defined(__sparc) 368 char aout_nmagicstr[] = AOUT_NMAGIC_STRING; 369 char aout_zmagicstr[] = AOUT_ZMAGIC_STRING; 370 char aout_omagicstr[] = AOUT_OMAGIC_STRING; 371 #endif 372 char nomagicstr[] = NOMAGIC_STRING; 373 374 char *execswnames[] = { 375 "elfexec", /* Elf32 */ 376 #ifdef _LP64 377 "elfexec", /* Elf64 */ 378 #endif 379 "intpexec", 380 "shbinexec", 381 "javaexec", 382 #if defined(__sparc) 383 "aoutexec", 384 "aoutexec", 385 "aoutexec", 386 #endif 387 NULL, 388 NULL, 389 NULL 390 }; 391 392 struct execsw execsw[] = { 393 { elf32magicstr, 0, 5, NULL, NULL, NULL }, 394 #ifdef _LP64 395 { elf64magicstr, 0, 5, NULL, NULL, NULL }, 396 #endif 397 { intpmagicstr, 0, 2, NULL, NULL, NULL }, 398 { shbinmagicstr, 0, SHBINMAGIC_LEN, NULL, NULL, NULL }, 399 { javamagicstr, 0, 4, NULL, NULL, NULL }, 400 #if defined(__sparc) 401 { aout_zmagicstr, 2, 2, NULL, NULL, NULL }, 402 { aout_nmagicstr, 2, 2, NULL, NULL, NULL }, 403 { aout_omagicstr, 2, 2, NULL, NULL, NULL }, 404 #endif 405 { nomagicstr, 0, 0, NULL, NULL, NULL }, 406 { nomagicstr, 0, 0, NULL, NULL, NULL }, 407 { nomagicstr, 0, 0, NULL, NULL, NULL }, 408 { nomagicstr, 0, 0, NULL, NULL, NULL } 409 }; 410 int nexectype = sizeof (execsw) / sizeof (execsw[0]); /* # of exec types */ 411 kmutex_t execsw_lock; /* Used for allocation of execsw entries */ 412 413 /* 414 * symbols added to make changing proc.max-file-descriptor 415 * simple via /etc/system 416 */ 417 #define RLIM_FD_CUR 0x10000 418 #define RLIM_FD_MAX 0x10000 419 420 uint_t rlim_fd_cur = RLIM_FD_CUR; 421 uint_t rlim_fd_max = RLIM_FD_MAX; 422 423 /* 424 * (Default resource limits were formerly declared here, but are now provided by 425 * the more general resource controls framework.) 426 */ 427 428 /* 429 * STREAMS tunables 430 */ 431 int nstrpush = 9; /* maximum # of modules/drivers on a stream */ 432 ssize_t strctlsz = 1024; /* maximum size of user-generated M_PROTO */ 433 ssize_t strmsgsz = 0x10000; /* maximum size of user-generated M_DATA */ 434 /* for `strmsgsz', zero means unlimited */ 435 /* 436 * Filesystem tunables 437 */ 438 int rstchown = 1; /* POSIX_CHOWN_RESTRICTED is enabled */ 439 int ngroups_max = NGROUPS_MAX_DEFAULT; 440 441 /* 442 * generic scheduling stuff 443 * 444 * Configurable parameters for RT and TS are in the respective 445 * scheduling class modules. 446 */ 447 448 pri_t maxclsyspri = MAXCLSYSPRI; 449 pri_t minclsyspri = MINCLSYSPRI; 450 char sys_name[] = "SYS"; 451 452 extern pri_t sys_init(id_t, int, classfuncs_t **); 453 extern classfuncs_t sys_classfuncs; 454 455 sclass_t sclass[] = { 456 { "SYS", sys_init, &sys_classfuncs, STATIC_SCHED, 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 { "", NULL, NULL, NULL, 0 }, 463 { "", NULL, NULL, NULL, 0 }, 464 { "", NULL, NULL, NULL, 0 }, 465 { "", NULL, NULL, NULL, 0 } 466 }; 467 468 int loaded_classes = 1; /* for loaded classes */ 469 kmutex_t class_lock; /* lock for class[] */ 470 471 int nclass = sizeof (sclass) / sizeof (sclass_t); 472 char initcls[] = "TS"; 473 char *defaultclass = initcls; 474 475 /* 476 * Tunable system parameters. 477 */ 478 479 /* 480 * The integers tune_* are done this way so that the tune 481 * data structure may be "tuned" if necessary from the /etc/system 482 * file. The tune data structure is initialized in param_init(); 483 */ 484 485 tune_t tune; 486 487 /* 488 * If freemem < t_getpgslow, then start to steal pages from processes. 489 */ 490 int tune_t_gpgslo = 25; 491 492 /* 493 * Rate at which fsflush is run, in seconds. 494 */ 495 #define DEFAULT_TUNE_T_FSFLUSHR 1 496 int tune_t_fsflushr = DEFAULT_TUNE_T_FSFLUSHR; 497 498 /* 499 * The minimum available resident (not swappable) memory to maintain 500 * in order to avoid deadlock. In pages. 501 */ 502 int tune_t_minarmem = 25; 503 504 /* 505 * The minimum available swappable memory to maintain in order to avoid 506 * deadlock. In pages. 507 */ 508 int tune_t_minasmem = 25; 509 510 int tune_t_flckrec = 512; /* max # of active frlocks */ 511 512 /* 513 * Number of currently available pages that cannot be 'locked' 514 * This is set in init_pages_pp_maximum, and must be initialized 515 * to zero here to detect an override in /etc/system 516 */ 517 pgcnt_t pages_pp_maximum = 0; 518 519 int boothowto; /* boot flags passed to kernel */ 520 struct var v; /* System Configuration Information */ 521 522 /* 523 * System Configuration Information 524 */ 525 526 /* 527 * The physical system's host identifier, expressed as a decimal string. 528 * Code should only directly access this value when writing to it (setting the 529 * physical system's host identifier). Code that reads the physical system's 530 * host identifier should use zone_get_hostid(NULL) instead. 531 */ 532 char hw_serial[HW_HOSTID_LEN] = "0"; 533 534 #if defined(__sparc) 535 536 /* 537 * On sparc machines, read hw_serial from the firmware at boot time 538 * and simply assert Oracle is the hardware provider. 539 */ 540 char architecture[] = "sparcv9"; 541 char architecture_32[] = "sparc"; 542 char hw_provider[] = "Oracle Corporation"; 543 544 #elif defined(__amd64) 545 546 char architecture[] = "amd64"; 547 char architecture_32[] = "i386"; 548 char hw_provider[SYS_NMLN] = ""; 549 550 #else 551 #error "unknown processor architecture" 552 #endif 553 554 char srpc_domain[SYS_NMLN] = ""; 555 char platform[SYS_NMLN] = ""; /* read from the devinfo root node */ 556 557 /* Initialize isa_list */ 558 char *isa_list = architecture; 559 560 static pgcnt_t original_physmem = 0; 561 562 #define MIN_DEFAULT_MAXUSERS 8u 563 #define MAX_DEFAULT_MAXUSERS 2048u 564 #define MAX_MAXUSERS 4096u 565 566 void 567 param_preset(void) 568 { 569 original_physmem = physmem; 570 } 571 572 void 573 param_calc(int platform_max_nprocs) 574 { 575 /* 576 * Default to about one "user" per megabyte, taking into 577 * account both physical and virtual constraints. 578 * Note: 2^20 is a meg; shifting right by (20 - PAGESHIFT) 579 * converts pages to megs without integer overflow. 580 */ 581 #if defined(__sparc) 582 if (physmem > original_physmem) { 583 physmem = original_physmem; 584 cmn_err(CE_NOTE, "physmem limited to %ld", physmem); 585 } 586 #endif 587 if (maxusers == 0) { 588 pgcnt_t physmegs = physmem >> (20 - PAGESHIFT); 589 pgcnt_t virtmegs = vmem_size(heap_arena, VMEM_FREE) >> 20; 590 maxusers = MIN(MAX(MIN(physmegs, virtmegs), 591 MIN_DEFAULT_MAXUSERS), MAX_DEFAULT_MAXUSERS); 592 } 593 if (maxusers > MAX_MAXUSERS) { 594 maxusers = MAX_MAXUSERS; 595 cmn_err(CE_NOTE, "maxusers limited to %d", MAX_MAXUSERS); 596 } 597 598 #ifdef DEBUG 599 /* 600 * The purpose of maxusers is to prevent memory overcommit. 601 * DEBUG kernels take more space, so reduce maxusers a bit. 602 */ 603 maxusers = (3 * maxusers) / 4; 604 #endif 605 606 /* 607 * We need to dynamically change any variables now so that 608 * the setting of maxusers and pidmax propagate to the other 609 * variables that are dependent on them. 610 */ 611 if (reserved_procs == 0) 612 reserved_procs = 5; 613 if (pidmax < reserved_procs || pidmax > MAX_MAXPID) 614 maxpid = MAX_MAXPID; 615 else 616 maxpid = pidmax; 617 618 /* 619 * This allows platform-dependent code to constrain the maximum 620 * number of processes allowed in case there are e.g. VM limitations 621 * with how many contexts are available. 622 */ 623 if (max_nprocs == 0) 624 max_nprocs = (10 + 16 * maxusers); 625 if (platform_max_nprocs > 0 && max_nprocs > platform_max_nprocs) 626 max_nprocs = platform_max_nprocs; 627 if (max_nprocs > maxpid) 628 max_nprocs = maxpid; 629 630 if (maxuprc == 0) 631 maxuprc = (max_nprocs - reserved_procs); 632 } 633 634 void 635 param_init(void) 636 { 637 /* 638 * Set each individual element of struct var v to be the 639 * default value. This is done this way 640 * so that a user can set the assigned integer value in the 641 * /etc/system file *IF* tuning is needed. 642 */ 643 v.v_proc = max_nprocs; /* v_proc - max # of processes system wide */ 644 v.v_maxupttl = max_nprocs - reserved_procs; 645 v.v_maxsyspri = (int)maxclsyspri; /* max global pri for sysclass */ 646 v.v_maxup = MIN(maxuprc, v.v_maxupttl); /* max procs per user */ 647 v.v_autoup = autoup; /* v_autoup - delay for delayed writes */ 648 649 /* 650 * Set each individual element of struct tune to be the 651 * default value. Each struct element This is done this way 652 * so that a user can set the assigned integer value in the 653 * /etc/system file *IF* tuning is needed. 654 */ 655 tune.t_gpgslo = tune_t_gpgslo; 656 tune.t_fsflushr = tune_t_fsflushr; 657 tune.t_minarmem = tune_t_minarmem; 658 tune.t_minasmem = tune_t_minasmem; 659 tune.t_flckrec = tune_t_flckrec; 660 661 /* 662 * Initialization for file descriptors to correct mistaken settings in 663 * /etc/system. Initialization of limits performed by resource control 664 * system. 665 */ 666 if (rlim_fd_cur > rlim_fd_max) 667 rlim_fd_cur = rlim_fd_max; 668 669 /* 670 * calculations needed if hz was set in /etc/system 671 */ 672 if (hires_tick) 673 hz = hires_hz; 674 675 tick_per_msec = hz / MILLISEC; 676 msec_per_tick = MILLISEC / hz; 677 usec_per_tick = MICROSEC / hz; 678 nsec_per_tick = NANOSEC / hz; 679 max_hres_adj = nsec_per_tick >> ADJ_SHIFT; 680 681 /* 682 * Consumers of relative timedwait functions must specify how accurately 683 * the given timeout must expire. This is currently TR_CLOCK_TICK for 684 * the vast majority of consumers, but nsec_per_tick becomes an 685 * artificial value in a tickless world. Each caller of such routines 686 * should re-evaluate their usage and specify the appropriate 687 * resolution. 688 */ 689 time_res[TR_NANOSEC] = NANOSEC / NANOSEC; 690 time_res[TR_MICROSEC] = NANOSEC / MICROSEC; 691 time_res[TR_MILLISEC] = NANOSEC / MILLISEC; 692 time_res[TR_SEC] = NANOSEC / SEC; 693 time_res[TR_CLOCK_TICK] = nsec_per_tick; 694 } 695 696 /* 697 * Validate tuneable parameters following /etc/system processing, 698 * but prior to param_init(). 699 */ 700 void 701 param_check(void) 702 { 703 #if defined(__x86) 704 if (physmem != original_physmem) { 705 cmn_err(CE_NOTE, "physmem cannot be modified to 0x%lx" 706 " via /etc/system. Please use eeprom(8) instead.", 707 physmem); 708 physmem = original_physmem; 709 } 710 #endif 711 if (ngroups_max < NGROUPS_UMIN) 712 ngroups_max = NGROUPS_UMIN; 713 if (ngroups_max > NGROUPS_UMAX) 714 ngroups_max = NGROUPS_UMAX; 715 716 /* If we have many groups then the ucred proto message also grows. */ 717 if (ngroups_max > NGROUPS_OLDMAX && 718 strctlsz < (ngroups_max - NGROUPS_OLDMAX) * sizeof (gid_t) + 1024) { 719 strctlsz = (ngroups_max - NGROUPS_OLDMAX) * sizeof (gid_t) + 720 1024; 721 } 722 723 if (autoup <= 0) { 724 autoup = DEFAULT_AUTOUP; 725 cmn_err(CE_WARN, "autoup <= 0; defaulting to %d", autoup); 726 } 727 728 if (tune_t_fsflushr <= 0) { 729 tune_t_fsflushr = DEFAULT_TUNE_T_FSFLUSHR; 730 cmn_err(CE_WARN, "tune_t_fsflushr <= 0; defaulting to %d", 731 tune_t_fsflushr); 732 } 733 734 if (jump_pid < 0 || jump_pid >= pidmax) { 735 jump_pid = 0; 736 cmn_err(CE_WARN, "jump_pid < 0 or >= pidmax; ignored"); 737 } 738 739 if (snoop_interval < SNOOP_INTERVAL_MIN) { 740 snoop_interval = SNOOP_INTERVAL_DEFAULT; 741 cmn_err(CE_WARN, "snoop_interval < minimum (%d); defaulting" 742 " to %d", SNOOP_INTERVAL_MIN, SNOOP_INTERVAL_DEFAULT); 743 } 744 } 745