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_init_path.h"
  48 #include "opt_mac.h"
  49
  50 #include <sys/param.h>
  51 #include <sys/kernel.h>
  52 #include <sys/exec.h>
  53 #include <sys/file.h>
  54 #include <sys/filedesc.h>
  55 #include <sys/ktr.h>
  56 #include <sys/lock.h>
  57 #include <sys/mac.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
  77 #include <machine/cpu.h>
  78
  79 #include <security/audit/audit.h>
  80
  81 #include <vm/vm.h>
  82 #include <vm/vm_param.h>
  83 #include <vm/pmap.h>
  84 #include <vm/vm_map.h>
  85 #include <sys/copyright.h>
  86
  87 void mi_startup(void);                          /* Should be elsewhere */
  88
  89 /* Components of the first process -- never freed. */
  90 static struct session session0;
  91 static struct pgrp pgrp0;
  92 struct  proc proc0;
  93 struct  thread thread0 __aligned(8);
  94 struct  ksegrp ksegrp0;
  95 struct  vmspace vmspace0;
  96 struct  proc *initproc;
  97
  98 int     boothowto = 0;          /* initialized so that it can be patched */
  99 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0, "");
 100 int     bootverbose;
 101 SYSCTL_INT(_debug, OID_AUTO, bootverbose, CTLFLAG_RW, &bootverbose, 0, "");
 102
 103 /*
 104  * This ensures that there is at least one entry so that the sysinit_set
 105  * symbol is not undefined.  A sybsystem ID of SI_SUB_DUMMY is never
 106  * executed.
 107  */
 108 SYSINIT(placeholder, SI_SUB_DUMMY, SI_ORDER_ANY, NULL, NULL)
 109
 110 /*
 111  * The sysinit table itself.  Items are checked off as the are run.
 112  * If we want to register new sysinit types, add them to newsysinit.
 113  */
 114 SET_DECLARE(sysinit_set, struct sysinit);
 115 struct sysinit **sysinit, **sysinit_end;
 116 struct sysinit **newsysinit, **newsysinit_end;
 117
 118 /*
 119  * Merge a new sysinit set into the current set, reallocating it if
 120  * necessary.  This can only be called after malloc is running.
 121  */
 122 void
 123 sysinit_add(struct sysinit **set, struct sysinit **set_end)
 124 {
 125         struct sysinit **newset;
 126         struct sysinit **sipp;
 127         struct sysinit **xipp;
 128         int count;
 129
 130         count = set_end - set;
 131         if (newsysinit)
 132                 count += newsysinit_end - newsysinit;
 133         else
 134                 count += sysinit_end - sysinit;
 135         newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
 136         if (newset == NULL)
 137                 panic("cannot malloc for sysinit");
 138         xipp = newset;
 139         if (newsysinit)
 140                 for (sipp = newsysinit; sipp < newsysinit_end; sipp++)
 141                         *xipp++ = *sipp;
 142         else
 143                 for (sipp = sysinit; sipp < sysinit_end; sipp++)
 144                         *xipp++ = *sipp;
 145         for (sipp = set; sipp < set_end; sipp++)
 146                 *xipp++ = *sipp;
 147         if (newsysinit)
 148                 free(newsysinit, M_TEMP);
 149         newsysinit = newset;
 150         newsysinit_end = newset + count;
 151 }
 152
 153 /*
 154  * System startup; initialize the world, create process 0, mount root
 155  * filesystem, and fork to create init and pagedaemon.  Most of the
 156  * hard work is done in the lower-level initialization routines including
 157  * startup(), which does memory initialization and autoconfiguration.
 158  *
 159  * This allows simple addition of new kernel subsystems that require
 160  * boot time initialization.  It also allows substitution of subsystem
 161  * (for instance, a scheduler, kernel profiler, or VM system) by object
 162  * module.  Finally, it allows for optional "kernel threads".
 163  */
 164 void
 165 mi_startup(void)
 166 {
 167
 168         register struct sysinit **sipp;         /* system initialization*/
 169         register struct sysinit **xipp;         /* interior loop of sort*/
 170         register struct sysinit *save;          /* bubble*/
 171
 172         if (sysinit == NULL) {
 173                 sysinit = SET_BEGIN(sysinit_set);
 174                 sysinit_end = SET_LIMIT(sysinit_set);
 175         }
 176
 177 restart:
 178         /*
 179          * Perform a bubble sort of the system initialization objects by
 180          * their subsystem (primary key) and order (secondary key).
 181          */
 182         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
 183                 for (xipp = sipp + 1; xipp < sysinit_end; xipp++) {
 184                         if ((*sipp)->subsystem < (*xipp)->subsystem ||
 185                              ((*sipp)->subsystem == (*xipp)->subsystem &&
 186                               (*sipp)->order <= (*xipp)->order))
 187                                 continue;       /* skip*/
 188                         save = *sipp;
 189                         *sipp = *xipp;
 190                         *xipp = save;
 191                 }
 192         }
 193
 194         /*
 195          * Traverse the (now) ordered list of system initialization tasks.
 196          * Perform each task, and continue on to the next task.
 197          *
 198          * The last item on the list is expected to be the scheduler,
 199          * which will not return.
 200          */
 201         for (sipp = sysinit; sipp < sysinit_end; sipp++) {
 202
 203                 if ((*sipp)->subsystem == SI_SUB_DUMMY)
 204                         continue;       /* skip dummy task(s)*/
 205
 206                 if ((*sipp)->subsystem == SI_SUB_DONE)
 207                         continue;
 208
 209                 /* Call function */
 210                 (*((*sipp)->func))((*sipp)->udata);
 211
 212                 /* Check off the one we're just done */
 213                 (*sipp)->subsystem = SI_SUB_DONE;
 214
 215                 /* Check if we've installed more sysinit items via KLD */
 216                 if (newsysinit != NULL) {
 217                         if (sysinit != SET_BEGIN(sysinit_set))
 218                                 free(sysinit, M_TEMP);
 219                         sysinit = newsysinit;
 220                         sysinit_end = newsysinit_end;
 221                         newsysinit = NULL;
 222                         newsysinit_end = NULL;
 223                         goto restart;
 224                 }
 225         }
 226
 227         panic("Shouldn't get here!");
 228         /* NOTREACHED*/
 229 }
 230
 231
 232 /*
 233  ***************************************************************************
 234  ****
 235  **** The following SYSINIT's belong elsewhere, but have not yet
 236  **** been moved.
 237  ****
 238  ***************************************************************************
 239  */
 240 static void
 241 print_caddr_t(void *data __unused)
 242 {
 243         printf("%s", (char *)data);
 244 }
 245 SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t, copyright)
 246 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t, version)
 247
 248 #ifdef WITNESS
 249 static char wit_warn[] =
 250      "WARNING: WITNESS option enabled, expect reduced performance.\n";
 251 SYSINIT(witwarn, SI_SUB_COPYRIGHT, SI_ORDER_SECOND + 1,
 252    print_caddr_t, wit_warn)
 253 #endif
 254
 255 #ifdef DIAGNOSTIC
 256 static char diag_warn[] =
 257      "WARNING: DIAGNOSTIC option enabled, expect reduced performance.\n";
 258 SYSINIT(diagwarn, SI_SUB_COPYRIGHT, SI_ORDER_SECOND + 2,
 259     print_caddr_t, diag_warn)
 260 #endif
 261
 262 static void
 263 set_boot_verbose(void *data __unused)
 264 {
 265
 266         if (boothowto & RB_VERBOSE)
 267                 bootverbose++;
 268 }
 269 SYSINIT(boot_verbose, SI_SUB_TUNABLES, SI_ORDER_ANY, set_boot_verbose, NULL)
 270
 271 struct sysentvec null_sysvec = {
 272         0,
 273         NULL,
 274         0,
 275         0,
 276         NULL,
 277         0,
 278         NULL,
 279         NULL,
 280         NULL,
 281         NULL,
 282         NULL,
 283         NULL,
 284         NULL,
 285         "null",
 286         NULL,
 287         NULL,
 288         0,
 289         PAGE_SIZE,
 290         VM_MIN_ADDRESS,
 291         VM_MAXUSER_ADDRESS,
 292         USRSTACK,
 293         PS_STRINGS,
 294         VM_PROT_ALL,
 295         NULL,
 296         NULL,
 297         NULL
 298 };
 299
 300 /*
 301  ***************************************************************************
 302  ****
 303  **** The two following SYSINIT's are proc0 specific glue code.  I am not
 304  **** convinced that they can not be safely combined, but their order of
 305  **** operation has been maintained as the same as the original init_main.c
 306  **** for right now.
 307  ****
 308  **** These probably belong in init_proc.c or kern_proc.c, since they
 309  **** deal with proc0 (the fork template process).
 310  ****
 311  ***************************************************************************
 312  */
 313 /* ARGSUSED*/
 314 static void
 315 proc0_init(void *dummy __unused)
 316 {
 317         struct proc *p;
 318         unsigned i;
 319         struct thread *td;
 320         struct ksegrp *kg;
 321
 322         GIANT_REQUIRED;
 323         p = &proc0;
 324         td = &thread0;
 325         kg = &ksegrp0;
 326
 327         /*
 328          * Initialize magic number.
 329          */
 330         p->p_magic = P_MAGIC;
 331
 332         /*
 333          * Initialize thread, process and ksegrp structures.
 334          */
 335         procinit();     /* set up proc zone */
 336         threadinit();   /* set up thead, upcall and KSEGRP zones */
 337
 338         /*
 339          * Initialise scheduler resources.
 340          * Add scheduler specific parts to proc, ksegrp, thread as needed.
 341          */
 342         schedinit();    /* scheduler gets its house in order */
 343         /*
 344          * Initialize sleep queue hash table
 345          */
 346         sleepinit();
 347
 348         /*
 349          * additional VM structures
 350          */
 351         vm_init2();
 352
 353         /*
 354          * Create process 0 (the swapper).
 355          */
 356         LIST_INSERT_HEAD(&allproc, p, p_list);
 357         LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
 358         mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
 359         p->p_pgrp = &pgrp0;
 360         LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
 361         LIST_INIT(&pgrp0.pg_members);
 362         LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
 363
 364         pgrp0.pg_session = &session0;
 365         mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
 366         session0.s_count = 1;
 367         session0.s_leader = p;
 368
 369         p->p_sysent = &null_sysvec;
 370         p->p_flag = P_SYSTEM;
 371         p->p_sflag = PS_INMEM;
 372         p->p_state = PRS_NORMAL;
 373         knlist_init(&p->p_klist, &p->p_mtx, NULL, NULL, NULL);
 374         STAILQ_INIT(&p->p_ktr);
 375         p->p_nice = NZERO;
 376         td->td_state = TDS_RUNNING;
 377         kg->kg_pri_class = PRI_TIMESHARE;
 378         kg->kg_user_pri = PUSER;
 379         td->td_priority = PVM;
 380         td->td_base_pri = PUSER;
 381         td->td_oncpu = 0;
 382         p->p_peers = 0;
 383         p->p_leader = p;
 384
 385
 386         bcopy("swapper", p->p_comm, sizeof ("swapper"));
 387
 388         callout_init(&p->p_itcallout, CALLOUT_MPSAFE);
 389         callout_init(&td->td_slpcallout, CALLOUT_MPSAFE);
 390
 391         /* Create credentials. */
 392         p->p_ucred = crget();
 393         p->p_ucred->cr_ngroups = 1;     /* group 0 */
 394         p->p_ucred->cr_uidinfo = uifind(0);
 395         p->p_ucred->cr_ruidinfo = uifind(0);
 396         p->p_ucred->cr_prison = NULL;   /* Don't jail it. */
 397 #ifdef AUDIT
 398         audit_proc_alloc(p);
 399         audit_proc_kproc0(p);
 400 #endif
 401 #ifdef MAC
 402         mac_create_proc0(p->p_ucred);
 403 #endif
 404         td->td_ucred = crhold(p->p_ucred);
 405
 406         /* Create sigacts. */
 407         p->p_sigacts = sigacts_alloc();
 408
 409         /* Initialize signal state for process 0. */
 410         siginit(&proc0);
 411
 412         /* Create the file descriptor table. */
 413         p->p_fd = fdinit(NULL);
 414         p->p_fdtol = NULL;
 415
 416         /* Create the limits structures. */
 417         p->p_limit = lim_alloc();
 418         for (i = 0; i < RLIM_NLIMITS; i++)
 419                 p->p_limit->pl_rlimit[i].rlim_cur =
 420                     p->p_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
 421         p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur =
 422             p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
 423         p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
 424             p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
 425         i = ptoa(cnt.v_free_count);
 426         p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = i;
 427         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i;
 428         p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3;
 429         p->p_cpulimit = RLIM_INFINITY;
 430
 431         p->p_stats = pstats_alloc();
 432
 433         /* Allocate a prototype map so we have something to fork. */
 434         pmap_pinit0(vmspace_pmap(&vmspace0));
 435         p->p_vmspace = &vmspace0;
 436         vmspace0.vm_refcnt = 1;
 437         vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser,
 438             p->p_sysent->sv_maxuser);
 439         vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
 440
 441         /*
 442          * Charge root for one process.
 443          */
 444         (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
 445 }
 446 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL)
 447
 448 /* ARGSUSED*/
 449 static void
 450 proc0_post(void *dummy __unused)
 451 {
 452         struct timespec ts;
 453         struct proc *p;
 454
 455         /*
 456          * Now we can look at the time, having had a chance to verify the
 457          * time from the filesystem.  Pretend that proc0 started now.
 458          */
 459         sx_slock(&allproc_lock);
 460         LIST_FOREACH(p, &allproc, p_list) {
 461                 microuptime(&p->p_stats->p_start);
 462                 p->p_rux.rux_runtime = 0;
 463         }
 464         sx_sunlock(&allproc_lock);
 465         PCPU_SET(switchtime, cpu_ticks());
 466         PCPU_SET(switchticks, ticks);
 467
 468         /*
 469          * Give the ``random'' number generator a thump.
 470          */
 471         nanotime(&ts);
 472         srandom(ts.tv_sec ^ ts.tv_nsec);
 473 }
 474 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL)
 475
 476 /*
 477  ***************************************************************************
 478  ****
 479  **** The following SYSINIT's and glue code should be moved to the
 480  **** respective files on a per subsystem basis.
 481  ****
 482  ***************************************************************************
 483  */
 484
 485
 486 /*
 487  ***************************************************************************
 488  ****
 489  **** The following code probably belongs in another file, like
 490  **** kern/init_init.c.
 491  ****
 492  ***************************************************************************
 493  */
 494
 495 /*
 496  * List of paths to try when searching for "init".
 497  */
 498 static char init_path[MAXPATHLEN] =
 499 #ifdef  INIT_PATH
 500     __XSTRING(INIT_PATH);
 501 #else
 502     "/sbin/init:/sbin/oinit:/sbin/init.bak:/rescue/init:/stand/sysinstall";
 503 #endif
 504 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0,
 505         "Path used to search the init process");
 506
 507 /*
 508  * Shutdown timeout of init(8).
 509  * Unused within kernel, but used to control init(8), hence do not remove.
 510  */
 511 #ifndef INIT_SHUTDOWN_TIMEOUT
 512 #define INIT_SHUTDOWN_TIMEOUT 120
 513 #endif
 514 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
 515 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
 516         CTLFLAG_RW, &init_shutdown_timeout, 0, "");
 517
 518 /*
 519  * Start the initial user process; try exec'ing each pathname in init_path.
 520  * The program is invoked with one argument containing the boot flags.
 521  */
 522 static void
 523 start_init(void *dummy)
 524 {
 525         vm_offset_t addr;
 526         struct execve_args args;
 527         int options, error;
 528         char *var, *path, *next, *s;
 529         char *ucp, **uap, *arg0, *arg1;
 530         struct thread *td;
 531         struct proc *p;
 532
 533         mtx_lock(&Giant);
 534
 535         GIANT_REQUIRED;
 536
 537         td = curthread;
 538         p = td->td_proc;
 539
 540         vfs_mountroot();
 541
 542         /*
 543          * Need just enough stack to hold the faked-up "execve()" arguments.
 544          */
 545         addr = p->p_sysent->sv_usrstack - PAGE_SIZE;
 546         if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE,
 547                         FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
 548                 panic("init: couldn't allocate argument space");
 549         p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
 550         p->p_vmspace->vm_ssize = 1;
 551
 552         if ((var = getenv("init_path")) != NULL) {
 553                 strlcpy(init_path, var, sizeof(init_path));
 554                 freeenv(var);
 555         }
 556
 557         for (path = init_path; *path != '\0'; path = next) {
 558                 while (*path == ':')
 559                         path++;
 560                 if (*path == '\0')
 561                         break;
 562                 for (next = path; *next != '\0' && *next != ':'; next++)
 563                         /* nothing */ ;
 564                 if (bootverbose)
 565                         printf("start_init: trying %.*s\n", (int)(next - path),
 566                             path);
 567
 568                 /*
 569                  * Move out the boot flag argument.
 570                  */
 571                 options = 0;
 572                 ucp = (char *)p->p_sysent->sv_usrstack;
 573                 (void)subyte(--ucp, 0);         /* trailing zero */
 574                 if (boothowto & RB_SINGLE) {
 575                         (void)subyte(--ucp, 's');
 576                         options = 1;
 577                 }
 578 #ifdef notyet
 579                 if (boothowto & RB_FASTBOOT) {
 580                         (void)subyte(--ucp, 'f');
 581                         options = 1;
 582                 }
 583 #endif
 584
 585 #ifdef BOOTCDROM
 586                 (void)subyte(--ucp, 'C');
 587                 options = 1;
 588 #endif
 589
 590                 if (options == 0)
 591                         (void)subyte(--ucp, '-');
 592                 (void)subyte(--ucp, '-');               /* leading hyphen */
 593                 arg1 = ucp;
 594
 595                 /*
 596                  * Move out the file name (also arg 0).
 597                  */
 598                 (void)subyte(--ucp, 0);
 599                 for (s = next - 1; s >= path; s--)
 600                         (void)subyte(--ucp, *s);
 601                 arg0 = ucp;
 602
 603                 /*
 604                  * Move out the arg pointers.
 605                  */
 606                 uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1));
 607                 (void)suword((caddr_t)--uap, (long)0);  /* terminator */
 608                 (void)suword((caddr_t)--uap, (long)(intptr_t)arg1);
 609                 (void)suword((caddr_t)--uap, (long)(intptr_t)arg0);
 610
 611                 /*
 612                  * Point at the arguments.
 613                  */
 614                 args.fname = arg0;
 615                 args.argv = uap;
 616                 args.envv = NULL;
 617
 618                 /*
 619                  * Now try to exec the program.  If can't for any reason
 620                  * other than it doesn't exist, complain.
 621                  *
 622                  * Otherwise, return via fork_trampoline() all the way
 623                  * to user mode as init!
 624                  */
 625                 if ((error = execve(td, &args)) == 0) {
 626                         mtx_unlock(&Giant);
 627                         return;
 628                 }
 629                 if (error != ENOENT)
 630                         printf("exec %.*s: error %d\n", (int)(next - path),
 631                             path, error);
 632         }
 633         printf("init: not found in path %s\n", init_path);
 634         panic("no init");
 635 }
 636
 637 /*
 638  * Like kthread_create(), but runs in it's own address space.
 639  * We do this early to reserve pid 1.
 640  *
 641  * Note special case - do not make it runnable yet.  Other work
 642  * in progress will change this more.
 643  */
 644 static void
 645 create_init(const void *udata __unused)
 646 {
 647         struct ucred *newcred, *oldcred;
 648         int error;
 649
 650         error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc);
 651         if (error)
 652                 panic("cannot fork init: %d\n", error);
 653         KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1"));
 654         /* divorce init's credentials from the kernel's */
 655         newcred = crget();
 656         PROC_LOCK(initproc);
 657         initproc->p_flag |= P_SYSTEM;
 658         oldcred = initproc->p_ucred;
 659         crcopy(newcred, oldcred);
 660 #ifdef MAC
 661         mac_create_proc1(newcred);
 662 #endif
 663 #ifdef AUDIT
 664         audit_proc_init(initproc);
 665 #endif
 666         initproc->p_ucred = newcred;
 667         PROC_UNLOCK(initproc);
 668         crfree(oldcred);
 669         cred_update_thread(FIRST_THREAD_IN_PROC(initproc));
 670         mtx_lock_spin(&sched_lock);
 671         initproc->p_sflag |= PS_INMEM;
 672         mtx_unlock_spin(&sched_lock);
 673         cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL);
 674 }
 675 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL)
 676
 677 /*
 678  * Make it runnable now.
 679  */
 680 static void
 681 kick_init(const void *udata __unused)
 682 {
 683         struct thread *td;
 684
 685         td = FIRST_THREAD_IN_PROC(initproc);
 686         mtx_lock_spin(&sched_lock);
 687         TD_SET_CAN_RUN(td);
 688         setrunqueue(td, SRQ_BORING);    /* XXXKSE */
 689         mtx_unlock_spin(&sched_lock);
 690 }
 691 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL)