root/kern/init_main.c

DEFINITIONS

1. main
2. check_console
3. start_init
4. start_update
5. start_cleaner
6. start_reaper
7. start_crypto

    1 /*      $OpenBSD: init_main.c,v 1.143 2007/07/25 23:11:52 art Exp $     */
    2 /*      $NetBSD: init_main.c,v 1.84.4.1 1996/06/02 09:08:06 mrg Exp $   */
    4 /*
    5  * Copyright (c) 1995 Christopher G. Demetriou.  All rights reserved.
    6  * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
    7  *      The Regents of the University of California.  All rights reserved.
    8  * (c) UNIX System Laboratories, Inc.
    9  * All or some portions of this file are derived from material licensed
   10  * to the University of California by American Telephone and Telegraph
   11  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   12  * the permission of UNIX System Laboratories, Inc.
   13  *
   14  * Redistribution and use in source and binary forms, with or without
   15  * modification, are permitted provided that the following conditions
   16  * are met:
   17  * 1. Redistributions of source code must retain the above copyright
   18  *    notice, this list of conditions and the following disclaimer.
   19  * 2. Redistributions in binary form must reproduce the above copyright
   20  *    notice, this list of conditions and the following disclaimer in the
   21  *    documentation and/or other materials provided with the distribution.
   22  * 3. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  *      @(#)init_main.c 8.9 (Berkeley) 1/21/94
   39  */
   41 #include <sys/param.h>
   42 #include <sys/filedesc.h>
   43 #include <sys/file.h>
   44 #include <sys/errno.h>
   45 #include <sys/exec.h>
   46 #include <sys/kernel.h>
   47 #include <sys/kthread.h>
   48 #include <sys/mount.h>
   49 #include <sys/proc.h>
   50 #include <sys/resourcevar.h>
   51 #include <sys/signalvar.h>
   52 #include <sys/systm.h>
   53 #include <sys/namei.h>
   54 #include <sys/vnode.h>
   55 #include <sys/tty.h>
   56 #include <sys/conf.h>
   57 #include <sys/buf.h>
   58 #include <sys/device.h>
   59 #include <sys/socketvar.h>
   60 #include <sys/lockf.h>
   61 #include <sys/protosw.h>
   62 #include <sys/reboot.h>
   63 #include <sys/user.h>
   64 #ifdef SYSVSHM
   65 #include <sys/shm.h>
   66 #endif
   67 #ifdef SYSVSEM
   68 #include <sys/sem.h>
   69 #endif
   70 #ifdef SYSVMSG
   71 #include <sys/msg.h>
   72 #endif
   73 #include <sys/domain.h>
   74 #include <sys/mbuf.h>
   75 #include <sys/pipe.h>
   76 #include <sys/workq.h>
   78 #include <sys/syscall.h>
   79 #include <sys/syscallargs.h>
   81 #include <dev/rndvar.h>
   83 #include <ufs/ufs/quota.h>
   85 #include <machine/cpu.h>
   87 #include <uvm/uvm.h>
   89 #include <net/if.h>
   90 #include <net/raw_cb.h>
   92 #if defined(CRYPTO)
   93 #include <crypto/cryptodev.h>
   94 #include <crypto/cryptosoft.h>
   95 #endif
   97 #if defined(NFSSERVER) || defined(NFSCLIENT)
   98 extern void nfs_init(void);
   99 #endif
  101 #include "softraid.h"
  103 const char      copyright[] =
  104 "Copyright (c) 1982, 1986, 1989, 1991, 1993\n"
  105 "\tThe Regents of the University of California.  All rights reserved.\n"
  106 "Copyright (c) 1995-2007 OpenBSD. All rights reserved.  http://www.OpenBSD.org\n";
  108 /* Components of the first process -- never freed. */
  109 struct  session session0;
  110 struct  pgrp pgrp0;
  111 struct  proc proc0;
  112 struct  process process0;
  113 struct  pcred cred0;
  114 struct  plimit limit0;
  115 struct  vmspace vmspace0;
  116 struct  sigacts sigacts0;
  117 struct  proc *initproc;
  119 int     cmask = CMASK;
  120 extern  struct user *proc0paddr;
  122 struct  vnode *rootvp, *swapdev_vp;
  123 int     boothowto;
  124 struct  timeval boottime;
  125 int     ncpus =  1;
  126 __volatile int start_init_exec;         /* semaphore for start_init() */
  128 #if !defined(NO_PROPOLICE)
  129 long    __guard[8];
  130 #endif
  132 /* XXX return int so gcc -Werror won't complain */
  133 int     main(void *);
  134 void    check_console(struct proc *);
  135 void    start_init(void *);
  136 void    start_cleaner(void *);
  137 void    start_update(void *);
  138 void    start_reaper(void *);
  139 void    start_crypto(void *);
  140 void    init_exec(void);
  141 void    kqueue_init(void);
  142 void    workq_init(void);
  144 extern char sigcode[], esigcode[];
  145 #ifdef SYSCALL_DEBUG
  146 extern char *syscallnames[];
  147 #endif
  149 struct emul emul_native = {
  150         "native",
NULL,
sendsig,
SYS_syscall,
SYS_MAXSYSCALL,
sysent,
  156 #ifdef SYSCALL_DEBUG
syscallnames,
  158 #else
NULL,
  160 #endif
  161         0,
copyargs,
setregs,
NULL,
sigcode,
esigcode,
EMUL_ENABLED | EMUL_NATIVE,
  168 };
  171 /*
  172  * System startup; initialize the world, create process 0, mount root
  173  * filesystem, and fork to create init and pagedaemon.  Most of the
  174  * hard work is done in the lower-level initialization routines including
  175  * startup(), which does memory initialization and autoconfiguration.
  176  */
  177 /* XXX return int, so gcc -Werror won't complain */
  178 int
main(void *framep)
  180 {
  181         struct proc *p;
  182         struct pdevinit *pdev;
  183         struct timeval rtv;
quad_t lim;
  185         int s, i;
  186         extern struct pdevinit pdevinit[];
  187         extern void scheduler_start(void);
  188         extern void disk_init(void);
  189         extern void endtsleep(void *);
  190         extern void realitexpire(void *);
  192         /*
  193          * Initialize the current process pointer (curproc) before
  194          * any possible traps/probes to simplify trap processing.
  195          */
curproc = p = &proc0;
p->p_cpu = curcpu();
  199         /*
  200          * Initialize timeouts.
  201          */
timeout_startup();
  204         /*
  205          * Attempt to find console and initialize
  206          * in case of early panic or other messages.
  207          */
config_init();          /* init autoconfiguration data structures */
consinit();
printf("%s\n", copyright);
KERNEL_LOCK_INIT();
uvm_init();
disk_init();            /* must come before autoconfiguration */
tty_init();             /* initialise tty's */
cpu_startup();
  220         /*
  221          * Initialize mbuf's.  Do this now because we might attempt to
  222          * allocate mbufs or mbuf clusters during autoconfiguration.
  223          */
mbinit();
  226         /* Initialize sockets. */
soinit();
  229         /*
  230          * Initialize process and pgrp structures.
  231          */
procinit();
  234         /* Initialize file locking. */
lf_init();
  237         /*
  238          * Initialize filedescriptors.
  239          */
filedesc_init();
  242         /*
  243          * Initialize pipes.
  244          */
pipe_init();
  247         /*
  248          * Initialize kqueues.
  249          */
kqueue_init();
  252         /*
  253          * Create process 0 (the swapper).
  254          */
process0.ps_mainproc = p;
TAILQ_INIT(&process0.ps_threads);
TAILQ_INSERT_TAIL(&process0.ps_threads, p, p_thr_link);
p->p_p = &process0;
LIST_INSERT_HEAD(&allproc, p, p_list);
p->p_pgrp = &pgrp0;
LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
LIST_INIT(&pgrp0.pg_members);
LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
pgrp0.pg_session = &session0;
session0.s_count = 1;
session0.s_leader = p;
atomic_setbits_int(&p->p_flag, P_SYSTEM | P_NOCLDWAIT);
p->p_stat = SONPROC;
p->p_nice = NZERO;
p->p_emul = &emul_native;
bcopy("swapper", p->p_comm, sizeof ("swapper"));
  278         /* Init timeouts. */
timeout_set(&p->p_sleep_to, endtsleep, p);
timeout_set(&p->p_realit_to, realitexpire, p);
  282         /* Create credentials. */
cred0.p_refcnt = 1;
p->p_cred = &cred0;
p->p_ucred = crget();
p->p_ucred->cr_ngroups = 1;     /* group 0 */
  288         /* Initialize signal state for process 0. */
signal_init();
p->p_sigacts = &sigacts0;
siginit(p);
  293         /* Create the file descriptor table. */
p->p_fd = fdinit(NULL);
  296         /* Create the limits structures. */
p->p_p->ps_limit = &limit0;
  298         for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
limit0.pl_rlimit[i].rlim_cur =
limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;
limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = MIN(NOFILE_MAX,
  303             (maxfiles - NOFILE > NOFILE) ?  maxfiles - NOFILE : NOFILE);
limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = MAXUPRC;
lim = ptoa(uvmexp.free);
limit0.pl_rlimit[RLIMIT_RSS].rlim_max = lim;
limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim;
limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
limit0.p_refcnt = 1;
  311         /* Allocate a prototype map so we have something to fork. */
uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS),
trunc_page(VM_MAX_ADDRESS), TRUE);
p->p_vmspace = &vmspace0;
p->p_addr = proc0paddr;                         /* XXX */
  318         /*
  319          * We continue to place resource usage info in the
  320          * user struct so they're pageable.
  321          */
p->p_stats = &p->p_addr->u_stats;
  324         /*
  325          * Charge root for one process.
  326          */
  327         (void)chgproccnt(0, 1);
  329         /* Initialize run queues */
rqinit();
  332         /* Initialize work queues */
workq_init();
  335         /* Configure the devices */
cpu_configure();
  338         /* Configure virtual memory system, set vm rlimits. */
uvm_init_limits(p);
  341         /* Initialize the file systems. */
  342 #if defined(NFSSERVER) || defined(NFSCLIENT)
nfs_init();                     /* initialize server/shared data */
  344 #endif
vfsinit();
  347         /* Start real time and statistics clocks. */
initclocks();
  350         /* Lock the kernel on behalf of proc0. */
KERNEL_PROC_LOCK(p);
  353 #ifdef SYSVSHM
  354         /* Initialize System V style shared memory. */
shminit();
  356 #endif
  358 #ifdef SYSVSEM
  359         /* Initialize System V style semaphores. */
seminit();
  361 #endif
  363 #ifdef SYSVMSG
  364         /* Initialize System V style message queues. */
msginit();
  366 #endif
  368         /* Attach pseudo-devices. */
randomattach();
  370         for (pdev = pdevinit; pdev->pdev_attach != NULL; pdev++)
  371                 if (pdev->pdev_count > 0)
  372                         (*pdev->pdev_attach)(pdev->pdev_count);
  374 #ifdef CRYPTO
swcr_init();
  376 #endif /* CRYPTO */
  378         /*
  379          * Initialize protocols.  Block reception of incoming packets
  380          * until everything is ready.
  381          */
s = splnet();
ifinit();
domaininit();
if_attachdomain();
splx(s);
  388 #ifdef GPROF
  389         /* Initialize kernel profiling. */
kmstartup();
  391 #endif
  393 #if !defined(NO_PROPOLICE)
  394         {
  395                 volatile long newguard[8];
  396                 int i;
arc4random_bytes((long *)newguard, sizeof(newguard));
  400                 for (i = sizeof(__guard)/sizeof(__guard[0]) - 1; i; i--)
__guard[i] = newguard[i];
  402         }
  403 #endif
  405         /* init exec and emul */
init_exec();
  408         /* Start the scheduler */
scheduler_start();
  411         /*
  412          * Create process 1 (init(8)).  We do this now, as Unix has
  413          * historically had init be process 1, and changing this would
  414          * probably upset a lot of people.
  415          *
  416          * Note that process 1 won't immediately exec init(8), but will
  417          * wait for us to inform it that the root file system has been
  418          * mounted.
  419          */
  420         if (fork1(p, SIGCHLD, FORK_FORK, NULL, 0, start_init, NULL, NULL,
  421             &initproc))
panic("fork init");
  424         /*
  425          * Create any kernel threads whose creation was deferred because
  426          * initproc had not yet been created.
  427          */
kthread_run_deferred_queue();
  430         /*
  431          * Now that device driver threads have been created, wait for
  432          * them to finish any deferred autoconfiguration.  Note we don't
  433          * need to lock this semaphore, since we haven't booted any
  434          * secondary processors, yet.
  435          */
  436         while (config_pending)
  437                 (void) tsleep((void *)&config_pending, PWAIT, "cfpend", 0);
dostartuphooks();
  441 #if NSOFTRAID > 0
config_rootfound("softraid", NULL);
  443 #endif
  445         /* Configure root/swap devices */
diskconf();
  448         /* Mount the root file system. */
  449         if (vfs_mountroot())
panic("cannot mount root");
CIRCLEQ_FIRST(&mountlist)->mnt_flag |= MNT_ROOTFS;
  453         /* Get the vnode for '/'.  Set p->p_fd->fd_cdir to reference it. */
  454         if (VFS_ROOT(CIRCLEQ_FIRST(&mountlist), &rootvnode))
panic("cannot find root vnode");
p->p_fd->fd_cdir = rootvnode;
VREF(p->p_fd->fd_cdir);
VOP_UNLOCK(rootvnode, 0, p);
p->p_fd->fd_rdir = NULL;
  461         /*
  462          * Now that root is mounted, we can fixup initproc's CWD
  463          * info.  All other processes are kthreads, which merely
  464          * share proc0's CWD info.
  465          */
initproc->p_fd->fd_cdir = rootvnode;
VREF(initproc->p_fd->fd_cdir);
initproc->p_fd->fd_rdir = NULL;
  470         /*
  471          * Now can look at time, having had a chance to verify the time
  472          * from the file system.  Reset p->p_rtime as it may have been
  473          * munched in mi_switch() after the time got set.
  474          */
  475 #ifdef __HAVE_TIMECOUNTER
microtime(&boottime);
  477 #else
boottime = mono_time = time;    
  479 #endif
LIST_FOREACH(p, &allproc, p_list) {
p->p_stats->p_start = boottime;
microuptime(&p->p_cpu->ci_schedstate.spc_runtime);
p->p_rtime.tv_sec = p->p_rtime.tv_usec = 0;
  484         }
uvm_swap_init();
  488         /* Create the pageout daemon kernel thread. */
  489         if (kthread_create(uvm_pageout, NULL, NULL, "pagedaemon"))
panic("fork pagedaemon");
  492         /* Create the reaper daemon kernel thread. */
  493         if (kthread_create(start_reaper, NULL, NULL, "reaper"))
panic("fork reaper");
  496         /* Create the cleaner daemon kernel thread. */
  497         if (kthread_create(start_cleaner, NULL, NULL, "cleaner"))
panic("fork cleaner");
  500         /* Create the update daemon kernel thread. */
  501         if (kthread_create(start_update, NULL, NULL, "update"))
panic("fork update");
  504         /* Create the aiodone daemon kernel thread. */ 
  505         if (kthread_create(uvm_aiodone_daemon, NULL, NULL, "aiodoned"))
panic("fork aiodoned");
  508 #ifdef CRYPTO
  509         /* Create the crypto kernel thread. */
  510         if (kthread_create(start_crypto, NULL, NULL, "crypto"))
panic("crypto thread");
  512 #endif /* CRYPTO */
microtime(&rtv);
srandom((u_long)(rtv.tv_sec ^ rtv.tv_usec));
randompid = 1;
  519 #if defined(MULTIPROCESSOR)
  520         /* Boot the secondary processors. */
cpu_boot_secondary_processors();
  522 #endif
domountroothooks();
  526         /*
  527          * Okay, now we can let init(8) exec!  It's off to userland!
  528          */
start_init_exec = 1;
wakeup((void *)&start_init_exec);
  532         /* The scheduler is an infinite loop. */
uvm_scheduler();
  534         /* NOTREACHED */
  535 }
  537 /*
  538  * List of paths to try when searching for "init".
  539  */
  540 static char *initpaths[] = {
  541         "/sbin/init",
  542         "/sbin/oinit",
  543         "/sbin/init.bak",
NULL,
  545 };
  547 void
check_console(struct proc *p)
  549 {
  550         struct nameidata nd;
  551         int error;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/dev/console", p);
error = namei(&nd);
  555         if (error) {
  556                 if (error == ENOENT)
printf("warning: /dev/console does not exist\n");
  558                 else
printf("warning: /dev/console error %d\n", error);
  560         } else
vrele(nd.ni_vp);
  562 }
  564 /*
  565  * Start the initial user process; try exec'ing each pathname in "initpaths".
  566  * The program is invoked with one argument containing the boot flags.
  567  */
  568 void
start_init(void *arg)
  570 {
  571         struct proc *p = arg;
vaddr_t addr;
  573         struct sys_execve_args /* {
  574                 syscallarg(const char *) path;
  575                 syscallarg(char *const *) argp;
  576                 syscallarg(char *const *) envp;
  577         } */ args;
  578         int options, error;
  579         long i;
register_t retval[2];
  581         char flags[4], *flagsp;
  582         char **pathp, *path, *ucp, **uap, *arg0, *arg1 = NULL;
  584         /*
  585          * Now in process 1.
  586          */
  588         /*
  589          * Wait for main() to tell us that it's safe to exec.
  590          */
  591         while (start_init_exec == 0)
  592                 (void) tsleep((void *)&start_init_exec, PWAIT, "initexec", 0);
check_console(p);
  596         /*
  597          * Need just enough stack to hold the faked-up "execve()" arguments.
  598          */
  599 #ifdef MACHINE_STACK_GROWS_UP
addr = USRSTACK;
  601 #else
addr = USRSTACK - PAGE_SIZE;
  603 #endif
  604         if (uvm_map(&p->p_vmspace->vm_map, &addr, PAGE_SIZE, 
NULL, UVM_UNKNOWN_OFFSET, 0,
UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_ALL, UVM_INH_COPY,
UVM_ADV_NORMAL, UVM_FLAG_FIXED|UVM_FLAG_OVERLAY|UVM_FLAG_COPYONW)))
panic("init: couldn't allocate argument space");
p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
  611         for (pathp = &initpaths[0]; (path = *pathp) != NULL; pathp++) {
  612 #ifdef MACHINE_STACK_GROWS_UP
ucp = (char *)addr;
  614 #else
ucp = (char *)(addr + PAGE_SIZE);
  616 #endif
  617                 /*
  618                  * Construct the boot flag argument.
  619                  */
flagsp = flags;
  621                 *flagsp++ = '-';
options = 0;
  624                 if (boothowto & RB_SINGLE) {
  625                         *flagsp++ = 's';
options = 1;
  627                 }
  628 #ifdef notyet
  629                 if (boothowto & RB_FASTBOOT) {
  630                         *flagsp++ = 'f';
options = 1;
  632                 }
  633 #endif
  635                 /*
  636                  * Move out the flags (arg 1), if necessary.
  637                  */
  638                 if (options != 0) {
  639                         *flagsp++ = '\0';
i = flagsp - flags;
  641 #ifdef DEBUG
printf("init: copying out flags `%s' %d\n", flags, i);
  643 #endif
  644 #ifdef MACHINE_STACK_GROWS_UP
arg1 = ucp;
  646                         (void)copyout((caddr_t)flags, (caddr_t)ucp, i);
ucp += i;
  648 #else
  649                         (void)copyout((caddr_t)flags, (caddr_t)(ucp -= i), i);
arg1 = ucp;
  651 #endif
  652                 }
  654                 /*
  655                  * Move out the file name (also arg 0).
  656                  */
i = strlen(path) + 1;
  658 #ifdef DEBUG
printf("init: copying out path `%s' %d\n", path, i);
  660 #endif
  661 #ifdef MACHINE_STACK_GROWS_UP
arg0 = ucp;
  663                 (void)copyout((caddr_t)path, (caddr_t)ucp, i);
ucp += i;
ucp = (caddr_t)ALIGN((u_long)ucp);
uap = (char **)ucp + 3;
  667 #else
  668                 (void)copyout((caddr_t)path, (caddr_t)(ucp -= i), i);
arg0 = ucp;
uap = (char **)((u_long)ucp & ~ALIGNBYTES);
  671 #endif
  673                 /*
  674                  * Move out the arg pointers.
  675                  */
i = 0;
copyout(&i, (caddr_t)--uap, sizeof(register_t)); /* terminator */
  678                 if (options != 0)
copyout(&arg1, (caddr_t)--uap, sizeof(register_t));
copyout(&arg0, (caddr_t)--uap, sizeof(register_t));
  682                 /*
  683                  * Point at the arguments.
  684                  */
SCARG(&args, path) = arg0;
SCARG(&args, argp) = uap;
SCARG(&args, envp) = NULL;
  689                 /*
  690                  * Now try to exec the program.  If can't for any reason
  691                  * other than it doesn't exist, complain.
  692                  */
  693                 if ((error = sys_execve(p, &args, retval)) == 0) {
KERNEL_PROC_UNLOCK(p);
  695                         return;
  696                 }
  697                 if (error != ENOENT)
printf("exec %s: error %d\n", path, error);
  699         }
printf("init: not found\n");
panic("no init");
  702 }
  704 void
start_update(void *arg)
  706 {
sched_sync(curproc);
  708         /* NOTREACHED */
  709 }
  711 void
start_cleaner(void *arg)
  713 {
buf_daemon(curproc);
  715         /* NOTREACHED */
  716 }
  718 void
start_reaper(void *arg)
  720 {
reaper();
  722         /* NOTREACHED */
  723 }
  725 #ifdef CRYPTO
  726 void
start_crypto(void *arg)
  728 {
crypto_thread();
  730         /* NOTREACHED */
  731 }
  732 #endif /* CRYPTO */