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