The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/common/conf/param.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 8a94f833fe740ad4651571372bf5a4ba


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.