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/kern/init_main.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  * SPDX-License-Identifier: BSD-4-Clause
    3  *
    4  * Copyright (c) 1995 Terrence R. Lambert
    5  * All rights reserved.
    6  *
    7  * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
    8  *      The Regents of the University of California.  All rights reserved.
    9  * (c) UNIX System Laboratories, Inc.
   10  * All or some portions of this file are derived from material licensed
   11  * to the University of California by American Telephone and Telegraph
   12  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   13  * the permission of UNIX System Laboratories, Inc.
   14  *
   15  * Redistribution and use in source and binary forms, with or without
   16  * modification, are permitted provided that the following conditions
   17  * are met:
   18  * 1. Redistributions of source code must retain the above copyright
   19  *    notice, this list of conditions and the following disclaimer.
   20  * 2. Redistributions in binary form must reproduce the above copyright
   21  *    notice, this list of conditions and the following disclaimer in the
   22  *    documentation and/or other materials provided with the distribution.
   23  * 3. All advertising materials mentioning features or use of this software
   24  *    must display the following acknowledgement:
   25  *      This product includes software developed by the University of
   26  *      California, Berkeley and its contributors.
   27  * 4. Neither the name of the University nor the names of its contributors
   28  *    may be used to endorse or promote products derived from this software
   29  *    without specific prior written permission.
   30  *
   31  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   32  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   33  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   34  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   35  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   39  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   40  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   41  * SUCH DAMAGE.
   42  *
   43  *      @(#)init_main.c 8.9 (Berkeley) 1/21/94
   44  */
   45 
   46 #include <sys/cdefs.h>
   47 __FBSDID("$FreeBSD$");
   48 
   49 #include "opt_ddb.h"
   50 #include "opt_kdb.h"
   51 #include "opt_init_path.h"
   52 #include "opt_verbose_sysinit.h"
   53 
   54 #include <sys/param.h>
   55 #include <sys/systm.h>
   56 #include <sys/boottrace.h>
   57 #include <sys/conf.h>
   58 #include <sys/cpuset.h>
   59 #include <sys/dtrace_bsd.h>
   60 #include <sys/epoch.h>
   61 #include <sys/eventhandler.h>
   62 #include <sys/exec.h>
   63 #include <sys/file.h>
   64 #include <sys/filedesc.h>
   65 #include <sys/imgact.h>
   66 #include <sys/jail.h>
   67 #include <sys/kernel.h>
   68 #include <sys/ktr.h>
   69 #include <sys/lock.h>
   70 #include <sys/loginclass.h>
   71 #include <sys/malloc.h>
   72 #include <sys/mount.h>
   73 #include <sys/mutex.h>
   74 #include <sys/proc.h>
   75 #include <sys/racct.h>
   76 #include <sys/reboot.h>
   77 #include <sys/resourcevar.h>
   78 #include <sys/sched.h>
   79 #include <sys/signalvar.h>
   80 #include <sys/sx.h>
   81 #include <sys/syscallsubr.h>
   82 #include <sys/sysctl.h>
   83 #include <sys/sysent.h>
   84 #include <sys/sysproto.h>
   85 #include <sys/unistd.h>
   86 #include <sys/vmmeter.h>
   87 #include <sys/vnode.h>
   88 
   89 #include <machine/cpu.h>
   90 
   91 #include <security/audit/audit.h>
   92 #include <security/mac/mac_framework.h>
   93 
   94 #include <vm/vm.h>
   95 #include <vm/vm_param.h>
   96 #include <vm/vm_extern.h>
   97 #include <vm/pmap.h>
   98 #include <vm/vm_map.h>
   99 #include <sys/copyright.h>
  100 
  101 #include <ddb/ddb.h>
  102 #include <ddb/db_sym.h>
  103 
  104 void mi_startup(void);                          /* Should be elsewhere */
  105 
  106 /* Components of the first process -- never freed. */
  107 static struct session session0;
  108 static struct pgrp pgrp0;
  109 struct  proc proc0;
  110 struct thread0_storage thread0_st __aligned(32);
  111 struct  vmspace vmspace0;
  112 struct  proc *initproc;
  113 
  114 int
  115 linux_alloc_current_noop(struct thread *td __unused, int flags __unused)
  116 {
  117         return (0);
  118 }
  119 int (*lkpi_alloc_current)(struct thread *, int) = linux_alloc_current_noop;
  120 
  121 #ifndef BOOTHOWTO
  122 #define BOOTHOWTO       0
  123 #endif
  124 int     boothowto = BOOTHOWTO;  /* initialized so that it can be patched */
  125 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0,
  126         "Boot control flags, passed from loader");
  127 
  128 #ifndef BOOTVERBOSE
  129 #define BOOTVERBOSE     0
  130 #endif
  131 int     bootverbose = BOOTVERBOSE;
  132 SYSCTL_INT(_debug, OID_AUTO, bootverbose, CTLFLAG_RW, &bootverbose, 0,
  133         "Control the output of verbose kernel messages");
  134 
  135 #ifdef VERBOSE_SYSINIT
  136 /*
  137  * We'll use the defined value of VERBOSE_SYSINIT from the kernel config to
  138  * dictate the default VERBOSE_SYSINIT behavior.  Significant values for this
  139  * option and associated tunable are:
  140  * - 0, 'compiled in but silent by default'
  141  * - 1, 'compiled in but verbose by default' (default)
  142  */
  143 int     verbose_sysinit = VERBOSE_SYSINIT;
  144 TUNABLE_INT("debug.verbose_sysinit", &verbose_sysinit);
  145 #endif
  146 
  147 #ifdef INVARIANTS
  148 FEATURE(invariants, "Kernel compiled with INVARIANTS, may affect performance");
  149 #endif
  150 
  151 /*
  152  * This ensures that there is at least one entry so that the sysinit_set
  153  * symbol is not undefined.  A sybsystem ID of SI_SUB_DUMMY is never
  154  * executed.
  155  */
  156 SYSINIT(placeholder, SI_SUB_DUMMY, SI_ORDER_ANY, NULL, NULL);
  157 
  158 /*
  159  * The sysinit table itself.  Items are checked off as the are run.
  160  * If we want to register new sysinit types, add them to newsysinit.
  161  */
  162 SET_DECLARE(sysinit_set, struct sysinit);
  163 struct sysinit **sysinit, **sysinit_end;
  164 struct sysinit **newsysinit, **newsysinit_end;
  165 
  166 /*
  167  * Merge a new sysinit set into the current set, reallocating it if
  168  * necessary.  This can only be called after malloc is running.
  169  */
  170 void
  171 sysinit_add(struct sysinit **set, struct sysinit **set_end)
  172 {
  173         struct sysinit **newset;
  174         struct sysinit **sipp;
  175         struct sysinit **xipp;
  176         int count;
  177 
  178         count = set_end - set;
  179         if (newsysinit)
  180                 count += newsysinit_end - newsysinit;
  181         else
  182                 count += sysinit_end - sysinit;
  183         newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
  184         if (newset == NULL)
  185                 panic("cannot malloc for sysinit");
  186         xipp = newset;
  187         if (newsysinit)
  188                 for (sipp = newsysinit; sipp < newsysinit_end; sipp++)
  189                         *xipp++ = *sipp;
  190         else
  191                 for (sipp = sysinit; sipp < sysinit_end; sipp++)
  192                         *xipp++ = *sipp;
  193         for (sipp = set; sipp < set_end; sipp++)
  194                 *xipp++ = *sipp;
  195         if (newsysinit)
  196                 free(newsysinit, M_TEMP);
  197         newsysinit = newset;
  198         newsysinit_end = newset + count;
  199 }
  200 
  201 #if defined (DDB) && defined(VERBOSE_SYSINIT)
  202 static const char *
  203 symbol_name(vm_offset_t va, db_strategy_t strategy)
  204 {
  205         const char *name;
  206         c_db_sym_t sym;
  207         db_expr_t  offset;
  208 
  209         if (va == 0)
  210                 return (NULL);
  211         sym = db_search_symbol(va, strategy, &offset);
  212         if (offset != 0)
  213                 return (NULL);
  214         db_symbol_values(sym, &name, NULL);
  215         return (name);
  216 }
  217 #endif
  218 
  219 /*
  220  * System startup; initialize the world, create process 0, mount root
  221  * filesystem, and fork to create init and pagedaemon.  Most of the
  222  * hard work is done in the lower-level initialization routines including
  223  * startup(), which does memory initialization and autoconfiguration.
  224  *
  225  * This allows simple addition of new kernel subsystems that require
  226  * boot time initialization.  It also allows substitution of subsystem
  227  * (for instance, a scheduler, kernel profiler, or VM system) by object
  228  * module.  Finally, it allows for optional "kernel threads".
  229  */
  230 void
  231 mi_startup(void)
  232 {
  233 
  234         struct sysinit **sipp;  /* system initialization*/
  235         struct sysinit **xipp;  /* interior loop of sort*/
  236         struct sysinit *save;   /* bubble*/
  237 
  238         int last;
  239 #if defined(VERBOSE_SYSINIT)
  240         int verbose;
  241 #endif
  242 
  243         TSENTER();
  244 
  245         if (boothowto & RB_VERBOSE)
  246                 bootverbose++;
  247 
  248         if (sysinit == NULL) {
  249                 sysinit = SET_BEGIN(sysinit_set);
  250                 sysinit_end = SET_LIMIT(sysinit_set);
  251         }
  252 
  253 restart:
  254         /*
  255          * Perform a bubble sort of the system initialization objects by
  256          * their subsystem (primary key) and order (secondary key).
  257          */
  258         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
  259                 for (xipp = sipp + 1; xipp < sysinit_end; xipp++) {
  260                         if ((*sipp)->subsystem < (*xipp)->subsystem ||
  261                              ((*sipp)->subsystem == (*xipp)->subsystem &&
  262                               (*sipp)->order <= (*xipp)->order))
  263                                 continue;       /* skip*/
  264                         save = *sipp;
  265                         *sipp = *xipp;
  266                         *xipp = save;
  267                 }
  268         }
  269 
  270         last = SI_SUB_COPYRIGHT;
  271 #if defined(VERBOSE_SYSINIT)
  272         verbose = 0;
  273 #if !defined(DDB)
  274         printf("VERBOSE_SYSINIT: DDB not enabled, symbol lookups disabled.\n");
  275 #endif
  276 #endif
  277 
  278         /*
  279          * Traverse the (now) ordered list of system initialization tasks.
  280          * Perform each task, and continue on to the next task.
  281          */
  282         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
  283                 if ((*sipp)->subsystem == SI_SUB_DUMMY)
  284                         continue;       /* skip dummy task(s)*/
  285 
  286                 if ((*sipp)->subsystem == SI_SUB_DONE)
  287                         continue;
  288 
  289                 if ((*sipp)->subsystem > last)
  290                         BOOTTRACE_INIT("sysinit 0x%7x", (*sipp)->subsystem);
  291 
  292 #if defined(VERBOSE_SYSINIT)
  293                 if ((*sipp)->subsystem > last && verbose_sysinit != 0) {
  294                         verbose = 1;
  295                         printf("subsystem %x\n", last);
  296                 }
  297                 if (verbose) {
  298 #if defined(DDB)
  299                         const char *func, *data;
  300 
  301                         func = symbol_name((vm_offset_t)(*sipp)->func,
  302                             DB_STGY_PROC);
  303                         data = symbol_name((vm_offset_t)(*sipp)->udata,
  304                             DB_STGY_ANY);
  305                         if (func != NULL && data != NULL)
  306                                 printf("   %s(&%s)... ", func, data);
  307                         else if (func != NULL)
  308                                 printf("   %s(%p)... ", func, (*sipp)->udata);
  309                         else
  310 #endif
  311                                 printf("   %p(%p)... ", (*sipp)->func,
  312                                     (*sipp)->udata);
  313                 }
  314 #endif
  315 
  316                 /* Call function */
  317                 (*((*sipp)->func))((*sipp)->udata);
  318 
  319 #if defined(VERBOSE_SYSINIT)
  320                 if (verbose)
  321                         printf("done.\n");
  322 #endif
  323 
  324                 /* Check off the one we're just done */
  325                 last = (*sipp)->subsystem;
  326                 (*sipp)->subsystem = SI_SUB_DONE;
  327 
  328                 /* Check if we've installed more sysinit items via KLD */
  329                 if (newsysinit != NULL) {
  330                         if (sysinit != SET_BEGIN(sysinit_set))
  331                                 free(sysinit, M_TEMP);
  332                         sysinit = newsysinit;
  333                         sysinit_end = newsysinit_end;
  334                         newsysinit = NULL;
  335                         newsysinit_end = NULL;
  336                         goto restart;
  337                 }
  338         }
  339 
  340         TSEXIT();       /* Here so we don't overlap with start_init. */
  341         BOOTTRACE("mi_startup done");
  342 
  343         mtx_assert(&Giant, MA_OWNED | MA_NOTRECURSED);
  344         mtx_unlock(&Giant);
  345 
  346         /*
  347          * Now hand over this thread to swapper.
  348          */
  349         swapper();
  350         /* NOTREACHED*/
  351 }
  352 
  353 static void
  354 print_caddr_t(void *data)
  355 {
  356         printf("%s", (char *)data);
  357 }
  358 
  359 static void
  360 print_version(void *data __unused)
  361 {
  362         int len;
  363 
  364         /* Strip a trailing newline from version. */
  365         len = strlen(version);
  366         while (len > 0 && version[len - 1] == '\n')
  367                 len--;
  368         printf("%.*s %s\n", len, version, machine);
  369         printf("%s\n", compiler_version);
  370 }
  371 
  372 SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t,
  373     copyright);
  374 SYSINIT(trademark, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t,
  375     trademark);
  376 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_THIRD, print_version, NULL);
  377 
  378 #ifdef WITNESS
  379 static char wit_warn[] =
  380      "WARNING: WITNESS option enabled, expect reduced performance.\n";
  381 SYSINIT(witwarn, SI_SUB_COPYRIGHT, SI_ORDER_FOURTH,
  382    print_caddr_t, wit_warn);
  383 SYSINIT(witwarn2, SI_SUB_LAST, SI_ORDER_FOURTH,
  384    print_caddr_t, wit_warn);
  385 #endif
  386 
  387 #ifdef DIAGNOSTIC
  388 static char diag_warn[] =
  389      "WARNING: DIAGNOSTIC option enabled, expect reduced performance.\n";
  390 SYSINIT(diagwarn, SI_SUB_COPYRIGHT, SI_ORDER_FIFTH,
  391     print_caddr_t, diag_warn);
  392 SYSINIT(diagwarn2, SI_SUB_LAST, SI_ORDER_FIFTH,
  393     print_caddr_t, diag_warn);
  394 #endif
  395 
  396 static int
  397 null_fetch_syscall_args(struct thread *td __unused)
  398 {
  399 
  400         panic("null_fetch_syscall_args");
  401 }
  402 
  403 static void
  404 null_set_syscall_retval(struct thread *td __unused, int error __unused)
  405 {
  406 
  407         panic("null_set_syscall_retval");
  408 }
  409 
  410 static void
  411 null_set_fork_retval(struct thread *td __unused)
  412 {
  413 
  414 }
  415 
  416 struct sysentvec null_sysvec = {
  417         .sv_size        = 0,
  418         .sv_table       = NULL,
  419         .sv_fixup       = NULL,
  420         .sv_sendsig     = NULL,
  421         .sv_sigcode     = NULL,
  422         .sv_szsigcode   = NULL,
  423         .sv_name        = "null",
  424         .sv_coredump    = NULL,
  425         .sv_imgact_try  = NULL,
  426         .sv_minsigstksz = 0,
  427         .sv_minuser     = VM_MIN_ADDRESS,
  428         .sv_maxuser     = VM_MAXUSER_ADDRESS,
  429         .sv_usrstack    = USRSTACK,
  430         .sv_psstrings   = PS_STRINGS,
  431         .sv_psstringssz = sizeof(struct ps_strings),
  432         .sv_stackprot   = VM_PROT_ALL,
  433         .sv_copyout_strings     = NULL,
  434         .sv_setregs     = NULL,
  435         .sv_fixlimit    = NULL,
  436         .sv_maxssiz     = NULL,
  437         .sv_flags       = 0,
  438         .sv_set_syscall_retval = null_set_syscall_retval,
  439         .sv_fetch_syscall_args = null_fetch_syscall_args,
  440         .sv_syscallnames = NULL,
  441         .sv_schedtail   = NULL,
  442         .sv_thread_detach = NULL,
  443         .sv_trap        = NULL,
  444         .sv_set_fork_retval = null_set_fork_retval,
  445         .sv_regset_begin = NULL,
  446         .sv_regset_end  = NULL,
  447 };
  448 
  449 /*
  450  * The two following SYSINIT's are proc0 specific glue code.  I am not
  451  * convinced that they can not be safely combined, but their order of
  452  * operation has been maintained as the same as the original init_main.c
  453  * for right now.
  454  */
  455 /* ARGSUSED*/
  456 static void
  457 proc0_init(void *dummy __unused)
  458 {
  459         struct proc *p;
  460         struct thread *td;
  461         struct ucred *newcred;
  462         struct uidinfo tmpuinfo;
  463         struct loginclass tmplc = {
  464                 .lc_name = "",
  465         };
  466         vm_paddr_t pageablemem;
  467         int i;
  468 
  469         GIANT_REQUIRED;
  470         p = &proc0;
  471         td = &thread0;
  472 
  473         /*
  474          * Initialize magic number and osrel.
  475          */
  476         p->p_magic = P_MAGIC;
  477         p->p_osrel = osreldate;
  478 
  479         /*
  480          * Initialize thread and process structures.
  481          */
  482         procinit();     /* set up proc zone */
  483         threadinit();   /* set up UMA zones */
  484 
  485         /*
  486          * Initialise scheduler resources.
  487          * Add scheduler specific parts to proc, thread as needed.
  488          */
  489         schedinit();    /* scheduler gets its house in order */
  490 
  491         /*
  492          * Create process 0 (the swapper).
  493          */
  494         LIST_INSERT_HEAD(&allproc, p, p_list);
  495         LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
  496         mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
  497         p->p_pgrp = &pgrp0;
  498         LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
  499         LIST_INIT(&pgrp0.pg_members);
  500         LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
  501 
  502         pgrp0.pg_session = &session0;
  503         mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
  504         refcount_init(&session0.s_count, 1);
  505         session0.s_leader = p;
  506 
  507         p->p_sysent = &null_sysvec;
  508         p->p_flag = P_SYSTEM | P_INMEM | P_KPROC;
  509         p->p_flag2 = 0;
  510         p->p_state = PRS_NORMAL;
  511         p->p_klist = knlist_alloc(&p->p_mtx);
  512         STAILQ_INIT(&p->p_ktr);
  513         p->p_nice = NZERO;
  514         td->td_tid = THREAD0_TID;
  515         tidhash_add(td);
  516         TD_SET_STATE(td, TDS_RUNNING);
  517         td->td_pri_class = PRI_TIMESHARE;
  518         td->td_user_pri = PUSER;
  519         td->td_base_user_pri = PUSER;
  520         td->td_lend_user_pri = PRI_MAX;
  521         td->td_priority = PVM;
  522         td->td_base_pri = PVM;
  523         td->td_oncpu = curcpu;
  524         td->td_flags = TDF_INMEM;
  525         td->td_pflags = TDP_KTHREAD;
  526         td->td_cpuset = cpuset_thread0();
  527         td->td_domain.dr_policy = td->td_cpuset->cs_domain;
  528         prison0_init();
  529         p->p_peers = 0;
  530         p->p_leader = p;
  531         p->p_reaper = p;
  532         p->p_treeflag |= P_TREE_REAPER;
  533         LIST_INIT(&p->p_reaplist);
  534 
  535         strncpy(p->p_comm, "kernel", sizeof (p->p_comm));
  536         strncpy(td->td_name, "swapper", sizeof (td->td_name));
  537 
  538         callout_init_mtx(&p->p_itcallout, &p->p_mtx, 0);
  539         callout_init_mtx(&p->p_limco, &p->p_mtx, 0);
  540         callout_init(&td->td_slpcallout, 1);
  541         TAILQ_INIT(&p->p_kqtim_stop);
  542 
  543         /* Create credentials. */
  544         newcred = crget();
  545         newcred->cr_ngroups = 1;        /* group 0 */
  546         /* A hack to prevent uifind from tripping over NULL pointers. */
  547         curthread->td_ucred = newcred;
  548         tmpuinfo.ui_uid = 1;
  549         newcred->cr_uidinfo = newcred->cr_ruidinfo = &tmpuinfo;
  550         newcred->cr_uidinfo = uifind(0);
  551         newcred->cr_ruidinfo = uifind(0);
  552         newcred->cr_loginclass = &tmplc;
  553         newcred->cr_loginclass = loginclass_find("default");
  554         /* End hack. creds get properly set later with thread_cow_get_proc */
  555         curthread->td_ucred = NULL;
  556         newcred->cr_prison = &prison0;
  557         newcred->cr_users++; /* avoid assertion failure */
  558         proc_set_cred_init(p, newcred);
  559         newcred->cr_users--;
  560         crfree(newcred);
  561 #ifdef AUDIT
  562         audit_cred_kproc0(newcred);
  563 #endif
  564 #ifdef MAC
  565         mac_cred_create_swapper(newcred);
  566 #endif
  567         /* Create sigacts. */
  568         p->p_sigacts = sigacts_alloc();
  569 
  570         /* Initialize signal state for process 0. */
  571         siginit(&proc0);
  572 
  573         /* Create the file descriptor table. */
  574         p->p_pd = pdinit(NULL, false);
  575         p->p_fd = fdinit();
  576         p->p_fdtol = NULL;
  577 
  578         /* Create the limits structures. */
  579         p->p_limit = lim_alloc();
  580         for (i = 0; i < RLIM_NLIMITS; i++)
  581                 p->p_limit->pl_rlimit[i].rlim_cur =
  582                     p->p_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
  583         p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur =
  584             p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
  585         p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
  586             p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
  587         p->p_limit->pl_rlimit[RLIMIT_DATA].rlim_cur = dfldsiz;
  588         p->p_limit->pl_rlimit[RLIMIT_DATA].rlim_max = maxdsiz;
  589         p->p_limit->pl_rlimit[RLIMIT_STACK].rlim_cur = dflssiz;
  590         p->p_limit->pl_rlimit[RLIMIT_STACK].rlim_max = maxssiz;
  591         /* Cast to avoid overflow on i386/PAE. */
  592         pageablemem = ptoa((vm_paddr_t)vm_free_count());
  593         p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_cur =
  594             p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = pageablemem;
  595         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = pageablemem / 3;
  596         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = pageablemem;
  597         p->p_cpulimit = RLIM_INFINITY;
  598 
  599         PROC_LOCK(p);
  600         thread_cow_get_proc(td, p);
  601         PROC_UNLOCK(p);
  602 
  603         /* Initialize resource accounting structures. */
  604         racct_create(&p->p_racct);
  605 
  606         p->p_stats = pstats_alloc();
  607 
  608         /* Allocate a prototype map so we have something to fork. */
  609         p->p_vmspace = &vmspace0;
  610         refcount_init(&vmspace0.vm_refcnt, 1);
  611         pmap_pinit0(vmspace_pmap(&vmspace0));
  612 
  613         /*
  614          * proc0 is not expected to enter usermode, so there is no special
  615          * handling for sv_minuser here, like is done for exec_new_vmspace().
  616          */
  617         vm_map_init(&vmspace0.vm_map, vmspace_pmap(&vmspace0),
  618             p->p_sysent->sv_minuser, p->p_sysent->sv_maxuser);
  619 
  620         /*
  621          * Call the init and ctor for the new thread and proc.  We wait
  622          * to do this until all other structures are fairly sane.
  623          */
  624         EVENTHANDLER_DIRECT_INVOKE(process_init, p);
  625         EVENTHANDLER_DIRECT_INVOKE(thread_init, td);
  626 #ifdef KDTRACE_HOOKS
  627         kdtrace_proc_ctor(p);
  628         kdtrace_thread_ctor(td);
  629 #endif
  630         EVENTHANDLER_DIRECT_INVOKE(process_ctor, p);
  631         EVENTHANDLER_DIRECT_INVOKE(thread_ctor, td);
  632 
  633         /*
  634          * Charge root for one process.
  635          */
  636         (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
  637         PROC_LOCK(p);
  638         racct_add_force(p, RACCT_NPROC, 1);
  639         PROC_UNLOCK(p);
  640 }
  641 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL);
  642 
  643 /* ARGSUSED*/
  644 static void
  645 proc0_post(void *dummy __unused)
  646 {
  647         struct proc *p;
  648         struct rusage ru;
  649         struct thread *td;
  650 
  651         /*
  652          * Now we can look at the time, having had a chance to verify the
  653          * time from the filesystem.  Pretend that proc0 started now.
  654          */
  655         sx_slock(&allproc_lock);
  656         FOREACH_PROC_IN_SYSTEM(p) {
  657                 PROC_LOCK(p);
  658                 if (p->p_state == PRS_NEW) {
  659                         PROC_UNLOCK(p);
  660                         continue;
  661                 }
  662                 microuptime(&p->p_stats->p_start);
  663                 PROC_STATLOCK(p);
  664                 rufetch(p, &ru);        /* Clears thread stats */
  665                 p->p_rux.rux_runtime = 0;
  666                 p->p_rux.rux_uticks = 0;
  667                 p->p_rux.rux_sticks = 0;
  668                 p->p_rux.rux_iticks = 0;
  669                 PROC_STATUNLOCK(p);
  670                 FOREACH_THREAD_IN_PROC(p, td) {
  671                         td->td_runtime = 0;
  672                 }
  673                 PROC_UNLOCK(p);
  674         }
  675         sx_sunlock(&allproc_lock);
  676         PCPU_SET(switchtime, cpu_ticks());
  677         PCPU_SET(switchticks, ticks);
  678 }
  679 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL);
  680 
  681 /*
  682  ***************************************************************************
  683  ****
  684  **** The following SYSINIT's and glue code should be moved to the
  685  **** respective files on a per subsystem basis.
  686  ****
  687  ***************************************************************************
  688  */
  689 
  690 /*
  691  * List of paths to try when searching for "init".
  692  */
  693 static char init_path[MAXPATHLEN] =
  694 #ifdef  INIT_PATH
  695     __XSTRING(INIT_PATH);
  696 #else
  697     "/sbin/init:/sbin/oinit:/sbin/init.bak:/rescue/init";
  698 #endif
  699 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0,
  700         "Path used to search the init process");
  701 
  702 /*
  703  * Shutdown timeout of init(8).
  704  * Unused within kernel, but used to control init(8), hence do not remove.
  705  */
  706 #ifndef INIT_SHUTDOWN_TIMEOUT
  707 #define INIT_SHUTDOWN_TIMEOUT 120
  708 #endif
  709 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
  710 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
  711         CTLFLAG_RW, &init_shutdown_timeout, 0, "Shutdown timeout of init(8). "
  712         "Unused within kernel, but used to control init(8)");
  713 
  714 /*
  715  * Start the initial user process; try exec'ing each pathname in init_path.
  716  * The program is invoked with one argument containing the boot flags.
  717  */
  718 static void
  719 start_init(void *dummy)
  720 {
  721         struct image_args args;
  722         int error;
  723         char *var, *path;
  724         char *free_init_path, *tmp_init_path;
  725         struct thread *td;
  726         struct proc *p;
  727         struct vmspace *oldvmspace;
  728 
  729         TSENTER();      /* Here so we don't overlap with mi_startup. */
  730 
  731         td = curthread;
  732         p = td->td_proc;
  733 
  734         vfs_mountroot();
  735 
  736         /* Wipe GELI passphrase from the environment. */
  737         kern_unsetenv("kern.geom.eli.passphrase");
  738 
  739         /* For Multicons, report which console is primary to both */
  740         if (boothowto & RB_MULTIPLE) {
  741                 if (boothowto & RB_SERIAL)
  742                         printf("Dual Console: Serial Primary, Video Secondary\n");
  743                 else
  744                         printf("Dual Console: Video Primary, Serial Secondary\n");
  745         }
  746 
  747         if ((var = kern_getenv("init_path")) != NULL) {
  748                 strlcpy(init_path, var, sizeof(init_path));
  749                 freeenv(var);
  750         }
  751         free_init_path = tmp_init_path = strdup(init_path, M_TEMP);
  752 
  753         while ((path = strsep(&tmp_init_path, ":")) != NULL) {
  754                 if (bootverbose)
  755                         printf("start_init: trying %s\n", path);
  756 
  757                 memset(&args, 0, sizeof(args));
  758                 error = exec_alloc_args(&args);
  759                 if (error != 0)
  760                         panic("%s: Can't allocate space for init arguments %d",
  761                             __func__, error);
  762 
  763                 error = exec_args_add_fname(&args, path, UIO_SYSSPACE);
  764                 if (error != 0)
  765                         panic("%s: Can't add fname %d", __func__, error);
  766                 error = exec_args_add_arg(&args, path, UIO_SYSSPACE);
  767                 if (error != 0)
  768                         panic("%s: Can't add argv[0] %d", __func__, error);
  769                 if (boothowto & RB_SINGLE)
  770                         error = exec_args_add_arg(&args, "-s", UIO_SYSSPACE);
  771                 if (error != 0)
  772                         panic("%s: Can't add argv[0] %d", __func__, error);
  773 
  774                 /*
  775                  * Now try to exec the program.  If can't for any reason
  776                  * other than it doesn't exist, complain.
  777                  *
  778                  * Otherwise, return via fork_trampoline() all the way
  779                  * to user mode as init!
  780                  */
  781                 KASSERT((td->td_pflags & TDP_EXECVMSPC) == 0,
  782                     ("nested execve"));
  783                 oldvmspace = p->p_vmspace;
  784                 error = kern_execve(td, &args, NULL, oldvmspace);
  785                 KASSERT(error != 0,
  786                     ("kern_execve returned success, not EJUSTRETURN"));
  787                 if (error == EJUSTRETURN) {
  788                         exec_cleanup(td, oldvmspace);
  789                         free(free_init_path, M_TEMP);
  790                         TSEXIT();
  791                         return;
  792                 }
  793                 if (error != ENOENT)
  794                         printf("exec %s: error %d\n", path, error);
  795         }
  796         free(free_init_path, M_TEMP);
  797         printf("init: not found in path %s\n", init_path);
  798         panic("no init");
  799 }
  800 
  801 /*
  802  * Like kproc_create(), but runs in its own address space.  We do this
  803  * early to reserve pid 1.  Note special case - do not make it
  804  * runnable yet, init execution is started when userspace can be served.
  805  */
  806 static void
  807 create_init(const void *udata __unused)
  808 {
  809         struct fork_req fr;
  810         struct ucred *newcred, *oldcred;
  811         struct thread *td;
  812         int error;
  813 
  814         bzero(&fr, sizeof(fr));
  815         fr.fr_flags = RFFDG | RFPROC | RFSTOPPED;
  816         fr.fr_procp = &initproc;
  817         error = fork1(&thread0, &fr);
  818         if (error)
  819                 panic("cannot fork init: %d\n", error);
  820         KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1"));
  821         /* divorce init's credentials from the kernel's */
  822         newcred = crget();
  823         sx_xlock(&proctree_lock);
  824         PROC_LOCK(initproc);
  825         initproc->p_flag |= P_SYSTEM | P_INMEM;
  826         initproc->p_treeflag |= P_TREE_REAPER;
  827         oldcred = initproc->p_ucred;
  828         crcopy(newcred, oldcred);
  829 #ifdef MAC
  830         mac_cred_create_init(newcred);
  831 #endif
  832 #ifdef AUDIT
  833         audit_cred_proc1(newcred);
  834 #endif
  835         proc_set_cred(initproc, newcred);
  836         td = FIRST_THREAD_IN_PROC(initproc);
  837         crcowfree(td);
  838         td->td_realucred = crcowget(initproc->p_ucred);
  839         td->td_ucred = td->td_realucred;
  840         PROC_UNLOCK(initproc);
  841         sx_xunlock(&proctree_lock);
  842         crfree(oldcred);
  843         cpu_fork_kthread_handler(FIRST_THREAD_IN_PROC(initproc),
  844             start_init, NULL);
  845 }
  846 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL);
  847 
  848 /*
  849  * Make it runnable now.
  850  */
  851 static void
  852 kick_init(const void *udata __unused)
  853 {
  854         struct thread *td;
  855 
  856         td = FIRST_THREAD_IN_PROC(initproc);
  857         thread_lock(td);
  858         TD_SET_CAN_RUN(td);
  859         sched_add(td, SRQ_BORING);
  860 }
  861 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_MIDDLE, kick_init, NULL);
  862 
  863 /*
  864  * DDB(4).
  865  */
  866 #ifdef DDB
  867 static void
  868 db_show_print_syinit(struct sysinit *sip, bool ddb)
  869 {
  870         const char *sname, *funcname;
  871         c_db_sym_t sym;
  872         db_expr_t  offset;
  873 
  874 #define xprint(...)                                                     \
  875         if (ddb)                                                        \
  876                 db_printf(__VA_ARGS__);                                 \
  877         else                                                            \
  878                 printf(__VA_ARGS__)
  879 
  880         if (sip == NULL) {
  881                 xprint("%s: no sysinit * given\n", __func__);
  882                 return;
  883         }
  884 
  885         sym = db_search_symbol((vm_offset_t)sip, DB_STGY_ANY, &offset);
  886         db_symbol_values(sym, &sname, NULL);
  887         sym = db_search_symbol((vm_offset_t)sip->func, DB_STGY_PROC, &offset);
  888         db_symbol_values(sym, &funcname, NULL);
  889         xprint("%s(%p)\n", (sname != NULL) ? sname : "", sip);
  890         xprint("  %#08x %#08x\n", sip->subsystem, sip->order);
  891         xprint("  %p(%s)(%p)\n",
  892             sip->func, (funcname != NULL) ? funcname : "", sip->udata);
  893 #undef xprint
  894 }
  895 
  896 DB_SHOW_COMMAND_FLAGS(sysinit, db_show_sysinit, DB_CMD_MEMSAFE)
  897 {
  898         struct sysinit **sipp;
  899 
  900         db_printf("SYSINIT vs Name(Ptr)\n");
  901         db_printf("  Subsystem  Order\n");
  902         db_printf("  Function(Name)(Arg)\n");
  903         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
  904                 db_show_print_syinit(*sipp, true);
  905                 if (db_pager_quit)
  906                         break;
  907         }
  908 }
  909 #endif /* DDB */

Cache object: 06e610e96a8edf6bc6375f1fe46288c7


[ 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.