sys/kern/init_main.c

   1 /*-
   2  * Copyright (c) 1995 Terrence R. Lambert
   3  * All rights reserved.
   4  *
   5  * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  * (c) UNIX System Laboratories, Inc.
   8  * All or some portions of this file are derived from material licensed
   9  * to the University of California by American Telephone and Telegraph
  10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  11  * the permission of UNIX System Laboratories, Inc.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgement:
  23  *      This product includes software developed by the University of
  24  *      California, Berkeley and its contributors.
  25  * 4. Neither the name of the University nor the names of its contributors
  26  *    may be used to endorse or promote products derived from this software
  27  *    without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39  * SUCH DAMAGE.
  40  *
  41  *      @(#)init_main.c 8.9 (Berkeley) 1/21/94
  42  */
  43
  44 #include <sys/cdefs.h>
  45 __FBSDID("$FreeBSD$");
  46
  47 #include "opt_ddb.h"
  48 #include "opt_init_path.h"
  49 #include "opt_mac.h"
  50
  51 #include <sys/param.h>
  52 #include <sys/kernel.h>
  53 #include <sys/exec.h>
  54 #include <sys/file.h>
  55 #include <sys/filedesc.h>
  56 #include <sys/ktr.h>
  57 #include <sys/lock.h>
  58 #include <sys/mount.h>
  59 #include <sys/mutex.h>
  60 #include <sys/syscallsubr.h>
  61 #include <sys/sysctl.h>
  62 #include <sys/proc.h>
  63 #include <sys/resourcevar.h>
  64 #include <sys/systm.h>
  65 #include <sys/signalvar.h>
  66 #include <sys/vnode.h>
  67 #include <sys/sysent.h>
  68 #include <sys/reboot.h>
  69 #include <sys/sched.h>
  70 #include <sys/sx.h>
  71 #include <sys/sysproto.h>
  72 #include <sys/vmmeter.h>
  73 #include <sys/unistd.h>
  74 #include <sys/malloc.h>
  75 #include <sys/conf.h>
  76 #include <sys/cpuset.h>
  77
  78 #include <machine/cpu.h>
  79
  80 #include <security/audit/audit.h>
  81 #include <security/mac/mac_framework.h>
  82
  83 #include <vm/vm.h>
  84 #include <vm/vm_param.h>
  85 #include <vm/pmap.h>
  86 #include <vm/vm_map.h>
  87 #include <sys/copyright.h>
  88
  89 #include <ddb/ddb.h>
  90 #include <ddb/db_sym.h>
  91
  92 void mi_startup(void);                          /* Should be elsewhere */
  93
  94 /* Components of the first process -- never freed. */
  95 static struct session session0;
  96 static struct pgrp pgrp0;
  97 struct  proc proc0;
  98 struct  thread thread0 __aligned(16);
  99 struct  vmspace vmspace0;
 100 struct  proc *initproc;
 101
 102 int     boothowto = 0;          /* initialized so that it can be patched */
 103 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0, "");
 104 int     bootverbose;
 105 SYSCTL_INT(_debug, OID_AUTO, bootverbose, CTLFLAG_RW, &bootverbose, 0, "");
 106
 107 /*
 108  * This ensures that there is at least one entry so that the sysinit_set
 109  * symbol is not undefined.  A sybsystem ID of SI_SUB_DUMMY is never
 110  * executed.
 111  */
 112 SYSINIT(placeholder, SI_SUB_DUMMY, SI_ORDER_ANY, NULL, NULL);
 113
 114 /*
 115  * The sysinit table itself.  Items are checked off as the are run.
 116  * If we want to register new sysinit types, add them to newsysinit.
 117  */
 118 SET_DECLARE(sysinit_set, struct sysinit);
 119 struct sysinit **sysinit, **sysinit_end;
 120 struct sysinit **newsysinit, **newsysinit_end;
 121
 122 /*
 123  * Merge a new sysinit set into the current set, reallocating it if
 124  * necessary.  This can only be called after malloc is running.
 125  */
 126 void
 127 sysinit_add(struct sysinit **set, struct sysinit **set_end)
 128 {
 129         struct sysinit **newset;
 130         struct sysinit **sipp;
 131         struct sysinit **xipp;
 132         int count;
 133
 134         count = set_end - set;
 135         if (newsysinit)
 136                 count += newsysinit_end - newsysinit;
 137         else
 138                 count += sysinit_end - sysinit;
 139         newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
 140         if (newset == NULL)
 141                 panic("cannot malloc for sysinit");
 142         xipp = newset;
 143         if (newsysinit)
 144                 for (sipp = newsysinit; sipp < newsysinit_end; sipp++)
 145                         *xipp++ = *sipp;
 146         else
 147                 for (sipp = sysinit; sipp < sysinit_end; sipp++)
 148                         *xipp++ = *sipp;
 149         for (sipp = set; sipp < set_end; sipp++)
 150                 *xipp++ = *sipp;
 151         if (newsysinit)
 152                 free(newsysinit, M_TEMP);
 153         newsysinit = newset;
 154         newsysinit_end = newset + count;
 155 }
 156
 157 /*
 158  * System startup; initialize the world, create process 0, mount root
 159  * filesystem, and fork to create init and pagedaemon.  Most of the
 160  * hard work is done in the lower-level initialization routines including
 161  * startup(), which does memory initialization and autoconfiguration.
 162  *
 163  * This allows simple addition of new kernel subsystems that require
 164  * boot time initialization.  It also allows substitution of subsystem
 165  * (for instance, a scheduler, kernel profiler, or VM system) by object
 166  * module.  Finally, it allows for optional "kernel threads".
 167  */
 168 void
 169 mi_startup(void)
 170 {
 171
 172         register struct sysinit **sipp;         /* system initialization*/
 173         register struct sysinit **xipp;         /* interior loop of sort*/
 174         register struct sysinit *save;          /* bubble*/
 175
 176 #if defined(VERBOSE_SYSINIT)
 177         int last;
 178         int verbose;
 179 #endif
 180
 181         if (sysinit == NULL) {
 182                 sysinit = SET_BEGIN(sysinit_set);
 183                 sysinit_end = SET_LIMIT(sysinit_set);
 184         }
 185
 186 restart:
 187         /*
 188          * Perform a bubble sort of the system initialization objects by
 189          * their subsystem (primary key) and order (secondary key).
 190          */
 191         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
 192                 for (xipp = sipp + 1; xipp < sysinit_end; xipp++) {
 193                         if ((*sipp)->subsystem < (*xipp)->subsystem ||
 194                              ((*sipp)->subsystem == (*xipp)->subsystem &&
 195                               (*sipp)->order <= (*xipp)->order))
 196                                 continue;       /* skip*/
 197                         save = *sipp;
 198                         *sipp = *xipp;
 199                         *xipp = save;
 200                 }
 201         }
 202
 203 #if defined(VERBOSE_SYSINIT)
 204         last = SI_SUB_COPYRIGHT;
 205         verbose = 0;
 206 #if !defined(DDB)
 207         printf("VERBOSE_SYSINIT: DDB not enabled, symbol lookups disabled.\n");
 208 #endif
 209 #endif
 210
 211         /*
 212          * Traverse the (now) ordered list of system initialization tasks.
 213          * Perform each task, and continue on to the next task.
 214          *
 215          * The last item on the list is expected to be the scheduler,
 216          * which will not return.
 217          */
 218         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
 219
 220                 if ((*sipp)->subsystem == SI_SUB_DUMMY)
 221                         continue;       /* skip dummy task(s)*/
 222
 223                 if ((*sipp)->subsystem == SI_SUB_DONE)
 224                         continue;
 225
 226 #if defined(VERBOSE_SYSINIT)
 227                 if ((*sipp)->subsystem > last) {
 228                         verbose = 1;
 229                         last = (*sipp)->subsystem;
 230                         printf("subsystem %x\n", last);
 231                 }
 232                 if (verbose) {
 233 #if defined(DDB)
 234                         const char *name;
 235                         c_db_sym_t sym;
 236                         db_expr_t  offset;
 237
 238                         sym = db_search_symbol((vm_offset_t)(*sipp)->func,
 239                             DB_STGY_PROC, &offset);
 240                         db_symbol_values(sym, &name, NULL);
 241                         if (name != NULL)
 242                                 printf("   %s(%p)... ", name, (*sipp)->udata);
 243                         else
 244 #endif
 245                                 printf("   %p(%p)... ", (*sipp)->func,
 246                                     (*sipp)->udata);
 247                 }
 248 #endif
 249
 250                 /* Call function */
 251                 (*((*sipp)->func))((*sipp)->udata);
 252
 253 #if defined(VERBOSE_SYSINIT)
 254                 if (verbose)
 255                         printf("done.\n");
 256 #endif
 257
 258                 /* Check off the one we're just done */
 259                 (*sipp)->subsystem = SI_SUB_DONE;
 260
 261                 /* Check if we've installed more sysinit items via KLD */
 262                 if (newsysinit != NULL) {
 263                         if (sysinit != SET_BEGIN(sysinit_set))
 264                                 free(sysinit, M_TEMP);
 265                         sysinit = newsysinit;
 266                         sysinit_end = newsysinit_end;
 267                         newsysinit = NULL;
 268                         newsysinit_end = NULL;
 269                         goto restart;
 270                 }
 271         }
 272
 273         panic("Shouldn't get here!");
 274         /* NOTREACHED*/
 275 }
 276
 277
 278 /*
 279  ***************************************************************************
 280  ****
 281  **** The following SYSINIT's belong elsewhere, but have not yet
 282  **** been moved.
 283  ****
 284  ***************************************************************************
 285  */
 286 static void
 287 print_caddr_t(void *data __unused)
 288 {
 289         printf("%s", (char *)data);
 290 }
 291 SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t,
 292     copyright);
 293 SYSINIT(trademark, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t,
 294     trademark);
 295 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_THIRD, print_caddr_t, version);
 296
 297 #ifdef WITNESS
 298 static char wit_warn[] =
 299      "WARNING: WITNESS option enabled, expect reduced performance.\n";
 300 SYSINIT(witwarn, SI_SUB_COPYRIGHT, SI_ORDER_THIRD + 1,
 301    print_caddr_t, wit_warn);
 302 SYSINIT(witwarn2, SI_SUB_RUN_SCHEDULER, SI_ORDER_THIRD + 1,
 303    print_caddr_t, wit_warn);
 304 #endif
 305
 306 #ifdef DIAGNOSTIC
 307 static char diag_warn[] =
 308      "WARNING: DIAGNOSTIC option enabled, expect reduced performance.\n";
 309 SYSINIT(diagwarn, SI_SUB_COPYRIGHT, SI_ORDER_THIRD + 2,
 310     print_caddr_t, diag_warn);
 311 SYSINIT(diagwarn2, SI_SUB_RUN_SCHEDULER, SI_ORDER_THIRD + 2,
 312     print_caddr_t, diag_warn);
 313 #endif
 314
 315 static void
 316 set_boot_verbose(void *data __unused)
 317 {
 318
 319         if (boothowto & RB_VERBOSE)
 320                 bootverbose++;
 321 }
 322 SYSINIT(boot_verbose, SI_SUB_TUNABLES, SI_ORDER_ANY, set_boot_verbose, NULL);
 323
 324 struct sysentvec null_sysvec = {
 325         0,
 326         NULL,
 327         0,
 328         0,
 329         NULL,
 330         0,
 331         NULL,
 332         NULL,
 333         NULL,
 334         NULL,
 335         NULL,
 336         NULL,
 337         NULL,
 338         "null",
 339         NULL,
 340         NULL,
 341         0,
 342         PAGE_SIZE,
 343         VM_MIN_ADDRESS,
 344         VM_MAXUSER_ADDRESS,
 345         USRSTACK,
 346         PS_STRINGS,
 347         VM_PROT_ALL,
 348         NULL,
 349         NULL,
 350         NULL
 351 };
 352
 353 /*
 354  ***************************************************************************
 355  ****
 356  **** The two following SYSINIT's are proc0 specific glue code.  I am not
 357  **** convinced that they can not be safely combined, but their order of
 358  **** operation has been maintained as the same as the original init_main.c
 359  **** for right now.
 360  ****
 361  **** These probably belong in init_proc.c or kern_proc.c, since they
 362  **** deal with proc0 (the fork template process).
 363  ****
 364  ***************************************************************************
 365  */
 366 /* ARGSUSED*/
 367 static void
 368 proc0_init(void *dummy __unused)
 369 {
 370         struct proc *p;
 371         unsigned i;
 372         struct thread *td;
 373
 374         GIANT_REQUIRED;
 375         p = &proc0;
 376         td = &thread0;
 377
 378         /*
 379          * Initialize magic number and osrel.
 380          */
 381         p->p_magic = P_MAGIC;
 382         p->p_osrel = osreldate;
 383
 384         /*
 385          * Initialize thread and process structures.
 386          */
 387         procinit();     /* set up proc zone */
 388         threadinit();   /* set up UMA zones */
 389
 390         /*
 391          * Initialise scheduler resources.
 392          * Add scheduler specific parts to proc, thread as needed.
 393          */
 394         schedinit();    /* scheduler gets its house in order */
 395         /*
 396          * Initialize sleep queue hash table
 397          */
 398         sleepinit();
 399
 400         /*
 401          * additional VM structures
 402          */
 403         vm_init2();
 404
 405         /*
 406          * Create process 0 (the swapper).
 407          */
 408         LIST_INSERT_HEAD(&allproc, p, p_list);
 409         LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
 410         mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
 411         p->p_pgrp = &pgrp0;
 412         LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
 413         LIST_INIT(&pgrp0.pg_members);
 414         LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
 415
 416         pgrp0.pg_session = &session0;
 417         mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
 418         refcount_init(&session0.s_count, 1);
 419         session0.s_leader = p;
 420
 421         p->p_sysent = &null_sysvec;
 422         p->p_flag = P_SYSTEM | P_INMEM;
 423         p->p_state = PRS_NORMAL;
 424         knlist_init(&p->p_klist, &p->p_mtx, NULL, NULL, NULL);
 425         STAILQ_INIT(&p->p_ktr);
 426         p->p_nice = NZERO;
 427         td->td_tid = PID_MAX + 1;
 428         td->td_state = TDS_RUNNING;
 429         td->td_pri_class = PRI_TIMESHARE;
 430         td->td_user_pri = PUSER;
 431         td->td_base_user_pri = PUSER;
 432         td->td_priority = PVM;
 433         td->td_base_pri = PUSER;
 434         td->td_oncpu = 0;
 435         td->td_flags = TDF_INMEM|TDP_KTHREAD;
 436         td->td_cpuset = cpuset_thread0();
 437         p->p_peers = 0;
 438         p->p_leader = p;
 439
 440
 441         strncpy(p->p_comm, "kernel", sizeof (p->p_comm));
 442         strncpy(td->td_name, "swapper", sizeof (td->td_name));
 443
 444         callout_init(&p->p_itcallout, CALLOUT_MPSAFE);
 445         callout_init_mtx(&p->p_limco, &p->p_mtx, 0);
 446         callout_init(&td->td_slpcallout, CALLOUT_MPSAFE);
 447
 448         /* Create credentials. */
 449         p->p_ucred = crget();
 450         p->p_ucred->cr_ngroups = 1;     /* group 0 */
 451         p->p_ucred->cr_uidinfo = uifind(0);
 452         p->p_ucred->cr_ruidinfo = uifind(0);
 453         p->p_ucred->cr_prison = NULL;   /* Don't jail it. */
 454 #ifdef AUDIT
 455         audit_cred_kproc0(p->p_ucred);
 456 #endif
 457 #ifdef MAC
 458         mac_proc_create_swapper(p->p_ucred);
 459 #endif
 460         td->td_ucred = crhold(p->p_ucred);
 461
 462         /* Create sigacts. */
 463         p->p_sigacts = sigacts_alloc();
 464
 465         /* Initialize signal state for process 0. */
 466         siginit(&proc0);
 467
 468         /* Create the file descriptor table. */
 469         p->p_fd = fdinit(NULL);
 470         p->p_fdtol = NULL;
 471
 472         /* Create the limits structures. */
 473         p->p_limit = lim_alloc();
 474         for (i = 0; i < RLIM_NLIMITS; i++)
 475                 p->p_limit->pl_rlimit[i].rlim_cur =
 476                     p->p_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
 477         p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur =
 478             p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
 479         p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
 480             p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
 481         i = ptoa(cnt.v_free_count);
 482         p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = i;
 483         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i;
 484         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3;
 485         p->p_cpulimit = RLIM_INFINITY;
 486
 487         p->p_stats = pstats_alloc();
 488
 489         /* Allocate a prototype map so we have something to fork. */
 490         pmap_pinit0(vmspace_pmap(&vmspace0));
 491         p->p_vmspace = &vmspace0;
 492         vmspace0.vm_refcnt = 1;
 493         vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser,
 494             p->p_sysent->sv_maxuser);
 495         vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
 496
 497         /*-
 498          * call the init and ctor for the new thread and proc
 499          * we wait to do this until all other structures
 500          * are fairly sane.
 501          */
 502         EVENTHANDLER_INVOKE(process_init, p);
 503         EVENTHANDLER_INVOKE(thread_init, td);
 504         EVENTHANDLER_INVOKE(process_ctor, p);
 505         EVENTHANDLER_INVOKE(thread_ctor, td);
 506
 507         /*
 508          * Charge root for one process.
 509          */
 510         (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
 511 }
 512 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL);
 513
 514 /* ARGSUSED*/
 515 static void
 516 proc0_post(void *dummy __unused)
 517 {
 518         struct timespec ts;
 519         struct proc *p;
 520         struct rusage ru;
 521         struct thread *td;
 522
 523         /*
 524          * Now we can look at the time, having had a chance to verify the
 525          * time from the filesystem.  Pretend that proc0 started now.
 526          */
 527         sx_slock(&allproc_lock);
 528         FOREACH_PROC_IN_SYSTEM(p) {
 529                 microuptime(&p->p_stats->p_start);
 530                 PROC_SLOCK(p);
 531                 rufetch(p, &ru);        /* Clears thread stats */
 532                 PROC_SUNLOCK(p);
 533                 p->p_rux.rux_runtime = 0;
 534                 p->p_rux.rux_uticks = 0;
 535                 p->p_rux.rux_sticks = 0;
 536                 p->p_rux.rux_iticks = 0;
 537                 FOREACH_THREAD_IN_PROC(p, td) {
 538                         td->td_runtime = 0;
 539                 }
 540         }
 541         sx_sunlock(&allproc_lock);
 542         PCPU_SET(switchtime, cpu_ticks());
 543         PCPU_SET(switchticks, ticks);
 544
 545         /*
 546          * Give the ``random'' number generator a thump.
 547          */
 548         nanotime(&ts);
 549         srandom(ts.tv_sec ^ ts.tv_nsec);
 550 }
 551 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL);
 552
 553 /*
 554  ***************************************************************************
 555  ****
 556  **** The following SYSINIT's and glue code should be moved to the
 557  **** respective files on a per subsystem basis.
 558  ****
 559  ***************************************************************************
 560  */
 561
 562
 563 /*
 564  ***************************************************************************
 565  ****
 566  **** The following code probably belongs in another file, like
 567  **** kern/init_init.c.
 568  ****
 569  ***************************************************************************
 570  */
 571
 572 /*
 573  * List of paths to try when searching for "init".
 574  */
 575 static char init_path[MAXPATHLEN] =
 576 #ifdef  INIT_PATH
 577     __XSTRING(INIT_PATH);
 578 #else
 579     "/sbin/init:/sbin/oinit:/sbin/init.bak:/rescue/init:/stand/sysinstall";
 580 #endif
 581 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0,
 582         "Path used to search the init process");
 583
 584 /*
 585  * Shutdown timeout of init(8).
 586  * Unused within kernel, but used to control init(8), hence do not remove.
 587  */
 588 #ifndef INIT_SHUTDOWN_TIMEOUT
 589 #define INIT_SHUTDOWN_TIMEOUT 120
 590 #endif
 591 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
 592 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
 593         CTLFLAG_RW, &init_shutdown_timeout, 0, "");
 594
 595 /*
 596  * Start the initial user process; try exec'ing each pathname in init_path.
 597  * The program is invoked with one argument containing the boot flags.
 598  */
 599 static void
 600 start_init(void *dummy)
 601 {
 602         vm_offset_t addr;
 603         struct execve_args args;
 604         int options, error;
 605         char *var, *path, *next, *s;
 606         char *ucp, **uap, *arg0, *arg1;
 607         struct thread *td;
 608         struct proc *p;
 609
 610         mtx_lock(&Giant);
 611
 612         GIANT_REQUIRED;
 613
 614         td = curthread;
 615         p = td->td_proc;
 616
 617         vfs_mountroot();
 618
 619         /*
 620          * Need just enough stack to hold the faked-up "execve()" arguments.
 621          */
 622         addr = p->p_sysent->sv_usrstack - PAGE_SIZE;
 623         if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE,
 624                         FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
 625                 panic("init: couldn't allocate argument space");
 626         p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
 627         p->p_vmspace->vm_ssize = 1;
 628
 629         if ((var = getenv("init_path")) != NULL) {
 630                 strlcpy(init_path, var, sizeof(init_path));
 631                 freeenv(var);
 632         }
 633
 634         for (path = init_path; *path != '\0'; path = next) {
 635                 while (*path == ':')
 636                         path++;
 637                 if (*path == '\0')
 638                         break;
 639                 for (next = path; *next != '\0' && *next != ':'; next++)
 640                         /* nothing */ ;
 641                 if (bootverbose)
 642                         printf("start_init: trying %.*s\n", (int)(next - path),
 643                             path);
 644
 645                 /*
 646                  * Move out the boot flag argument.
 647                  */
 648                 options = 0;
 649                 ucp = (char *)p->p_sysent->sv_usrstack;
 650                 (void)subyte(--ucp, 0);         /* trailing zero */
 651                 if (boothowto & RB_SINGLE) {
 652                         (void)subyte(--ucp, 's');
 653                         options = 1;
 654                 }
 655 #ifdef notyet
 656                 if (boothowto & RB_FASTBOOT) {
 657                         (void)subyte(--ucp, 'f');
 658                         options = 1;
 659                 }
 660 #endif
 661
 662 #ifdef BOOTCDROM
 663                 (void)subyte(--ucp, 'C');
 664                 options = 1;
 665 #endif
 666
 667                 if (options == 0)
 668                         (void)subyte(--ucp, '-');
 669                 (void)subyte(--ucp, '-');               /* leading hyphen */
 670                 arg1 = ucp;
 671
 672                 /*
 673                  * Move out the file name (also arg 0).
 674                  */
 675                 (void)subyte(--ucp, 0);
 676                 for (s = next - 1; s >= path; s--)
 677                         (void)subyte(--ucp, *s);
 678                 arg0 = ucp;
 679
 680                 /*
 681                  * Move out the arg pointers.
 682                  */
 683                 uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1));
 684                 (void)suword((caddr_t)--uap, (long)0);  /* terminator */
 685                 (void)suword((caddr_t)--uap, (long)(intptr_t)arg1);
 686                 (void)suword((caddr_t)--uap, (long)(intptr_t)arg0);
 687
 688                 /*
 689                  * Point at the arguments.
 690                  */
 691                 args.fname = arg0;
 692                 args.argv = uap;
 693                 args.envv = NULL;
 694
 695                 /*
 696                  * Now try to exec the program.  If can't for any reason
 697                  * other than it doesn't exist, complain.
 698                  *
 699                  * Otherwise, return via fork_trampoline() all the way
 700                  * to user mode as init!
 701                  */
 702                 if ((error = execve(td, &args)) == 0) {
 703                         mtx_unlock(&Giant);
 704                         return;
 705                 }
 706                 if (error != ENOENT)
 707                         printf("exec %.*s: error %d\n", (int)(next - path),
 708                             path, error);
 709         }
 710         printf("init: not found in path %s\n", init_path);
 711         panic("no init");
 712 }
 713
 714 /*
 715  * Like kproc_create(), but runs in it's own address space.
 716  * We do this early to reserve pid 1.
 717  *
 718  * Note special case - do not make it runnable yet.  Other work
 719  * in progress will change this more.
 720  */
 721 static void
 722 create_init(const void *udata __unused)
 723 {
 724         struct ucred *newcred, *oldcred;
 725         int error;
 726
 727         error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc);
 728         if (error)
 729                 panic("cannot fork init: %d\n", error);
 730         KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1"));
 731         /* divorce init's credentials from the kernel's */
 732         newcred = crget();
 733         PROC_LOCK(initproc);
 734         initproc->p_flag |= P_SYSTEM | P_INMEM;
 735         oldcred = initproc->p_ucred;
 736         crcopy(newcred, oldcred);
 737 #ifdef MAC
 738         mac_proc_create_init(newcred);
 739 #endif
 740 #ifdef AUDIT
 741         audit_cred_proc1(newcred);
 742 #endif
 743         initproc->p_ucred = newcred;
 744         PROC_UNLOCK(initproc);
 745         crfree(oldcred);
 746         cred_update_thread(FIRST_THREAD_IN_PROC(initproc));
 747         cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL);
 748 }
 749 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL);
 750
 751 /*
 752  * Make it runnable now.
 753  */
 754 static void
 755 kick_init(const void *udata __unused)
 756 {
 757         struct thread *td;
 758
 759         td = FIRST_THREAD_IN_PROC(initproc);
 760         thread_lock(td);
 761         TD_SET_CAN_RUN(td);
 762         sched_add(td, SRQ_BORING);
 763         thread_unlock(td);
 764 }
 765 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL);