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