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