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/mac.h>
  59 #include <sys/mount.h>
  60 #include <sys/mutex.h>
  61 #include <sys/syscallsubr.h>
  62 #include <sys/sysctl.h>
  63 #include <sys/proc.h>
  64 #include <sys/resourcevar.h>
  65 #include <sys/systm.h>
  66 #include <sys/signalvar.h>
  67 #include <sys/vnode.h>
  68 #include <sys/sysent.h>
  69 #include <sys/reboot.h>
  70 #include <sys/sched.h>
  71 #include <sys/sx.h>
  72 #include <sys/sysproto.h>
  73 #include <sys/vmmeter.h>
  74 #include <sys/unistd.h>
  75 #include <sys/malloc.h>
  76 #include <sys/conf.h>
  77
  78 #include <machine/cpu.h>
  79
  80 #include <security/audit/audit.h>
  81
  82 #include <vm/vm.h>
  83 #include <vm/vm_param.h>
  84 #include <vm/pmap.h>
  85 #include <vm/vm_map.h>
  86 #include <sys/copyright.h>
  87
  88 #include <ddb/ddb.h>
  89 #include <ddb/db_sym.h>
  90
  91 void mi_startup(void);                          /* Should be elsewhere */
  92
  93 /* Components of the first process -- never freed. */
  94 static struct session session0;
  95 static struct pgrp pgrp0;
  96 struct  proc proc0;
  97 struct  thread thread0 __aligned(8);
  98 struct  ksegrp ksegrp0;
  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, copyright)
 292 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t, version)
 293
 294 #ifdef WITNESS
 295 static char wit_warn[] =
 296      "WARNING: WITNESS option enabled, expect reduced performance.\n";
 297 SYSINIT(witwarn, SI_SUB_COPYRIGHT, SI_ORDER_SECOND + 1,
 298    print_caddr_t, wit_warn)
 299 #endif
 300
 301 #ifdef DIAGNOSTIC
 302 static char diag_warn[] =
 303      "WARNING: DIAGNOSTIC option enabled, expect reduced performance.\n";
 304 SYSINIT(diagwarn, SI_SUB_COPYRIGHT, SI_ORDER_SECOND + 2,
 305     print_caddr_t, diag_warn)
 306 #endif
 307
 308 static void
 309 set_boot_verbose(void *data __unused)
 310 {
 311
 312         if (boothowto & RB_VERBOSE)
 313                 bootverbose++;
 314 }
 315 SYSINIT(boot_verbose, SI_SUB_TUNABLES, SI_ORDER_ANY, set_boot_verbose, NULL)
 316
 317 struct sysentvec null_sysvec = {
 318         0,
 319         NULL,
 320         0,
 321         0,
 322         NULL,
 323         0,
 324         NULL,
 325         NULL,
 326         NULL,
 327         NULL,
 328         NULL,
 329         NULL,
 330         NULL,
 331         "null",
 332         NULL,
 333         NULL,
 334         0,
 335         PAGE_SIZE,
 336         VM_MIN_ADDRESS,
 337         VM_MAXUSER_ADDRESS,
 338         USRSTACK,
 339         PS_STRINGS,
 340         VM_PROT_ALL,
 341         NULL,
 342         NULL,
 343         NULL
 344 };
 345
 346 /*
 347  ***************************************************************************
 348  ****
 349  **** The two following SYSINIT's are proc0 specific glue code.  I am not
 350  **** convinced that they can not be safely combined, but their order of
 351  **** operation has been maintained as the same as the original init_main.c
 352  **** for right now.
 353  ****
 354  **** These probably belong in init_proc.c or kern_proc.c, since they
 355  **** deal with proc0 (the fork template process).
 356  ****
 357  ***************************************************************************
 358  */
 359 /* ARGSUSED*/
 360 static void
 361 proc0_init(void *dummy __unused)
 362 {
 363         struct proc *p;
 364         unsigned i;
 365         struct thread *td;
 366         struct ksegrp *kg;
 367
 368         GIANT_REQUIRED;
 369         p = &proc0;
 370         td = &thread0;
 371         kg = &ksegrp0;
 372
 373         /*
 374          * Initialize magic number.
 375          */
 376         p->p_magic = P_MAGIC;
 377
 378         /*
 379          * Initialize thread, process and ksegrp structures.
 380          */
 381         procinit();     /* set up proc zone */
 382         threadinit();   /* set up thead, upcall and KSEGRP zones */
 383
 384         /*
 385          * Initialise scheduler resources.
 386          * Add scheduler specific parts to proc, ksegrp, thread as needed.
 387          */
 388         schedinit();    /* scheduler gets its house in order */
 389         /*
 390          * Initialize sleep queue hash table
 391          */
 392         sleepinit();
 393
 394         /*
 395          * additional VM structures
 396          */
 397         vm_init2();
 398
 399         /*
 400          * Create process 0 (the swapper).
 401          */
 402         LIST_INSERT_HEAD(&allproc, p, p_list);
 403         LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
 404         mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
 405         p->p_pgrp = &pgrp0;
 406         LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
 407         LIST_INIT(&pgrp0.pg_members);
 408         LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
 409
 410         pgrp0.pg_session = &session0;
 411         mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
 412         session0.s_count = 1;
 413         session0.s_leader = p;
 414
 415         p->p_sysent = &null_sysvec;
 416         p->p_flag = P_SYSTEM;
 417         p->p_sflag = PS_INMEM;
 418         p->p_state = PRS_NORMAL;
 419         knlist_init(&p->p_klist, &p->p_mtx, NULL, NULL, NULL);
 420         STAILQ_INIT(&p->p_ktr);
 421         p->p_nice = NZERO;
 422         td->td_state = TDS_RUNNING;
 423         kg->kg_pri_class = PRI_TIMESHARE;
 424         kg->kg_user_pri = PUSER;
 425         kg->kg_base_user_pri = PUSER;
 426         td->td_priority = PVM;
 427         td->td_base_pri = PUSER;
 428         td->td_oncpu = 0;
 429         p->p_peers = 0;
 430         p->p_leader = p;
 431
 432
 433         bcopy("swapper", p->p_comm, sizeof ("swapper"));
 434
 435         callout_init(&p->p_itcallout, CALLOUT_MPSAFE);
 436         callout_init(&td->td_slpcallout, CALLOUT_MPSAFE);
 437
 438         /* Create credentials. */
 439         p->p_ucred = crget();
 440         p->p_ucred->cr_ngroups = 1;     /* group 0 */
 441         p->p_ucred->cr_uidinfo = uifind(0);
 442         p->p_ucred->cr_ruidinfo = uifind(0);
 443         p->p_ucred->cr_prison = NULL;   /* Don't jail it. */
 444 #ifdef AUDIT
 445         audit_proc_alloc(p);
 446         audit_proc_kproc0(p);
 447 #endif
 448 #ifdef MAC
 449         mac_create_proc0(p->p_ucred);
 450 #endif
 451         td->td_ucred = crhold(p->p_ucred);
 452
 453         /* Create sigacts. */
 454         p->p_sigacts = sigacts_alloc();
 455
 456         /* Initialize signal state for process 0. */
 457         siginit(&proc0);
 458
 459         /* Create the file descriptor table. */
 460         p->p_fd = fdinit(NULL);
 461         p->p_fdtol = NULL;
 462
 463         /* Create the limits structures. */
 464         p->p_limit = lim_alloc();
 465         for (i = 0; i < RLIM_NLIMITS; i++)
 466                 p->p_limit->pl_rlimit[i].rlim_cur =
 467                     p->p_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
 468         p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur =
 469             p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
 470         p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
 471             p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
 472         i = ptoa(cnt.v_free_count);
 473         p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = i;
 474         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i;
 475         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3;
 476         p->p_cpulimit = RLIM_INFINITY;
 477
 478         p->p_stats = pstats_alloc();
 479
 480         /* Allocate a prototype map so we have something to fork. */
 481         pmap_pinit0(vmspace_pmap(&vmspace0));
 482         p->p_vmspace = &vmspace0;
 483         vmspace0.vm_refcnt = 1;
 484         vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser,
 485             p->p_sysent->sv_maxuser);
 486         vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
 487
 488         /*
 489          * Charge root for one process.
 490          */
 491         (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
 492 }
 493 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL)
 494
 495 /* ARGSUSED*/
 496 static void
 497 proc0_post(void *dummy __unused)
 498 {
 499         struct timespec ts;
 500         struct proc *p;
 501
 502         /*
 503          * Now we can look at the time, having had a chance to verify the
 504          * time from the filesystem.  Pretend that proc0 started now.
 505          */
 506         sx_slock(&allproc_lock);
 507         LIST_FOREACH(p, &allproc, p_list) {
 508                 microuptime(&p->p_stats->p_start);
 509                 p->p_rux.rux_runtime = 0;
 510         }
 511         sx_sunlock(&allproc_lock);
 512         PCPU_SET(switchtime, cpu_ticks());
 513         PCPU_SET(switchticks, ticks);
 514
 515         /*
 516          * Give the ``random'' number generator a thump.
 517          */
 518         nanotime(&ts);
 519         srandom(ts.tv_sec ^ ts.tv_nsec);
 520 }
 521 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL)
 522
 523 /*
 524  ***************************************************************************
 525  ****
 526  **** The following SYSINIT's and glue code should be moved to the
 527  **** respective files on a per subsystem basis.
 528  ****
 529  ***************************************************************************
 530  */
 531
 532
 533 /*
 534  ***************************************************************************
 535  ****
 536  **** The following code probably belongs in another file, like
 537  **** kern/init_init.c.
 538  ****
 539  ***************************************************************************
 540  */
 541
 542 /*
 543  * List of paths to try when searching for "init".
 544  */
 545 static char init_path[MAXPATHLEN] =
 546 #ifdef  INIT_PATH
 547     __XSTRING(INIT_PATH);
 548 #else
 549     "/sbin/init:/sbin/oinit:/sbin/init.bak:/rescue/init:/stand/sysinstall";
 550 #endif
 551 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0,
 552         "Path used to search the init process");
 553
 554 /*
 555  * Shutdown timeout of init(8).
 556  * Unused within kernel, but used to control init(8), hence do not remove.
 557  */
 558 #ifndef INIT_SHUTDOWN_TIMEOUT
 559 #define INIT_SHUTDOWN_TIMEOUT 120
 560 #endif
 561 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
 562 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
 563         CTLFLAG_RW, &init_shutdown_timeout, 0, "");
 564
 565 /*
 566  * Start the initial user process; try exec'ing each pathname in init_path.
 567  * The program is invoked with one argument containing the boot flags.
 568  */
 569 static void
 570 start_init(void *dummy)
 571 {
 572         vm_offset_t addr;
 573         struct execve_args args;
 574         int options, error;
 575         char *var, *path, *next, *s;
 576         char *ucp, **uap, *arg0, *arg1;
 577         struct thread *td;
 578         struct proc *p;
 579
 580         mtx_lock(&Giant);
 581
 582         GIANT_REQUIRED;
 583
 584         td = curthread;
 585         p = td->td_proc;
 586
 587         vfs_mountroot();
 588
 589         /*
 590          * Need just enough stack to hold the faked-up "execve()" arguments.
 591          */
 592         addr = p->p_sysent->sv_usrstack - PAGE_SIZE;
 593         if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE,
 594                         FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
 595                 panic("init: couldn't allocate argument space");
 596         p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
 597         p->p_vmspace->vm_ssize = 1;
 598
 599         if ((var = getenv("init_path")) != NULL) {
 600                 strlcpy(init_path, var, sizeof(init_path));
 601                 freeenv(var);
 602         }
 603
 604         for (path = init_path; *path != '\0'; path = next) {
 605                 while (*path == ':')
 606                         path++;
 607                 if (*path == '\0')
 608                         break;
 609                 for (next = path; *next != '\0' && *next != ':'; next++)
 610                         /* nothing */ ;
 611                 if (bootverbose)
 612                         printf("start_init: trying %.*s\n", (int)(next - path),
 613                             path);
 614
 615                 /*
 616                  * Move out the boot flag argument.
 617                  */
 618                 options = 0;
 619                 ucp = (char *)p->p_sysent->sv_usrstack;
 620                 (void)subyte(--ucp, 0);         /* trailing zero */
 621                 if (boothowto & RB_SINGLE) {
 622                         (void)subyte(--ucp, 's');
 623                         options = 1;
 624                 }
 625 #ifdef notyet
 626                 if (boothowto & RB_FASTBOOT) {
 627                         (void)subyte(--ucp, 'f');
 628                         options = 1;
 629                 }
 630 #endif
 631
 632 #ifdef BOOTCDROM
 633                 (void)subyte(--ucp, 'C');
 634                 options = 1;
 635 #endif
 636
 637                 if (options == 0)
 638                         (void)subyte(--ucp, '-');
 639                 (void)subyte(--ucp, '-');               /* leading hyphen */
 640                 arg1 = ucp;
 641
 642                 /*
 643                  * Move out the file name (also arg 0).
 644                  */
 645                 (void)subyte(--ucp, 0);
 646                 for (s = next - 1; s >= path; s--)
 647                         (void)subyte(--ucp, *s);
 648                 arg0 = ucp;
 649
 650                 /*
 651                  * Move out the arg pointers.
 652                  */
 653                 uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1));
 654                 (void)suword((caddr_t)--uap, (long)0);  /* terminator */
 655                 (void)suword((caddr_t)--uap, (long)(intptr_t)arg1);
 656                 (void)suword((caddr_t)--uap, (long)(intptr_t)arg0);
 657
 658                 /*
 659                  * Point at the arguments.
 660                  */
 661                 args.fname = arg0;
 662                 args.argv = uap;
 663                 args.envv = NULL;
 664
 665                 /*
 666                  * Now try to exec the program.  If can't for any reason
 667                  * other than it doesn't exist, complain.
 668                  *
 669                  * Otherwise, return via fork_trampoline() all the way
 670                  * to user mode as init!
 671                  */
 672                 if ((error = execve(td, &args)) == 0) {
 673                         mtx_unlock(&Giant);
 674                         return;
 675                 }
 676                 if (error != ENOENT)
 677                         printf("exec %.*s: error %d\n", (int)(next - path),
 678                             path, error);
 679         }
 680         printf("init: not found in path %s\n", init_path);
 681         panic("no init");
 682 }
 683
 684 /*
 685  * Like kthread_create(), but runs in it's own address space.
 686  * We do this early to reserve pid 1.
 687  *
 688  * Note special case - do not make it runnable yet.  Other work
 689  * in progress will change this more.
 690  */
 691 static void
 692 create_init(const void *udata __unused)
 693 {
 694         struct ucred *newcred, *oldcred;
 695         int error;
 696
 697         error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc);
 698         if (error)
 699                 panic("cannot fork init: %d\n", error);
 700         KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1"));
 701         /* divorce init's credentials from the kernel's */
 702         newcred = crget();
 703         PROC_LOCK(initproc);
 704         initproc->p_flag |= P_SYSTEM;
 705         oldcred = initproc->p_ucred;
 706         crcopy(newcred, oldcred);
 707 #ifdef MAC
 708         mac_create_proc1(newcred);
 709 #endif
 710 #ifdef AUDIT
 711         audit_proc_init(initproc);
 712 #endif
 713         initproc->p_ucred = newcred;
 714         PROC_UNLOCK(initproc);
 715         crfree(oldcred);
 716         cred_update_thread(FIRST_THREAD_IN_PROC(initproc));
 717         mtx_lock_spin(&sched_lock);
 718         initproc->p_sflag |= PS_INMEM;
 719         mtx_unlock_spin(&sched_lock);
 720         cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL);
 721 }
 722 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL)
 723
 724 /*
 725  * Make it runnable now.
 726  */
 727 static void
 728 kick_init(const void *udata __unused)
 729 {
 730         struct thread *td;
 731
 732         td = FIRST_THREAD_IN_PROC(initproc);
 733         mtx_lock_spin(&sched_lock);
 734         TD_SET_CAN_RUN(td);
 735         setrunqueue(td, SRQ_BORING);    /* XXXKSE */
 736         mtx_unlock_spin(&sched_lock);
 737 }
 738 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL)