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