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