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 p->p_stats = pstats_alloc(); 426 427 /* Allocate a prototype map so we have something to fork. */ 428 pmap_pinit0(vmspace_pmap(&vmspace0)); 429 p->p_vmspace = &vmspace0; 430 vmspace0.vm_refcnt = 1; 431 vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser, 432 p->p_sysent->sv_maxuser); 433 vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0); 434 435 /* 436 * Charge root for one process. 437 */ 438 (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0); 439 } 440 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL) 441 442 /* ARGSUSED*/ 443 static void 444 proc0_post(void *dummy __unused) 445 { 446 struct timespec ts; 447 struct proc *p; 448 449 /* 450 * Now we can look at the time, having had a chance to verify the 451 * time from the filesystem. Pretend that proc0 started now. 452 */ 453 sx_slock(&allproc_lock); 454 LIST_FOREACH(p, &allproc, p_list) { 455 microuptime(&p->p_stats->p_start); 456 p->p_rux.rux_runtime.sec = 0; 457 p->p_rux.rux_runtime.frac = 0; 458 } 459 sx_sunlock(&allproc_lock); 460 binuptime(PCPU_PTR(switchtime)); 461 PCPU_SET(switchticks, ticks); 462 463 /* 464 * Give the ``random'' number generator a thump. 465 */ 466 nanotime(&ts); 467 srandom(ts.tv_sec ^ ts.tv_nsec); 468 } 469 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL) 470 471 /* 472 *************************************************************************** 473 **** 474 **** The following SYSINIT's and glue code should be moved to the 475 **** respective files on a per subsystem basis. 476 **** 477 *************************************************************************** 478 */ 479 480 481 /* 482 *************************************************************************** 483 **** 484 **** The following code probably belongs in another file, like 485 **** kern/init_init.c. 486 **** 487 *************************************************************************** 488 */ 489 490 /* 491 * List of paths to try when searching for "init". 492 */ 493 static char init_path[MAXPATHLEN] = 494 #ifdef INIT_PATH 495 __XSTRING(INIT_PATH); 496 #else 497 "/sbin/init:/sbin/oinit:/sbin/init.bak:/stand/sysinstall"; 498 #endif 499 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0, 500 "Path used to search the init process"); 501 502 /* 503 * Start the initial user process; try exec'ing each pathname in init_path. 504 * The program is invoked with one argument containing the boot flags. 505 */ 506 static void 507 start_init(void *dummy) 508 { 509 vm_offset_t addr; 510 struct execve_args args; 511 int options, error; 512 char *var, *path, *next, *s; 513 char *ucp, **uap, *arg0, *arg1; 514 struct thread *td; 515 struct proc *p; 516 int init_does_devfs = 0; 517 518 mtx_lock(&Giant); 519 520 GIANT_REQUIRED; 521 522 td = curthread; 523 p = td->td_proc; 524 525 vfs_mountroot(); 526 527 /* Get the vnode for '/'. Set p->p_fd->fd_cdir to reference it. */ 528 if (VFS_ROOT(TAILQ_FIRST(&mountlist), &rootvnode, td)) 529 panic("cannot find root vnode"); 530 FILEDESC_LOCK(p->p_fd); 531 p->p_fd->fd_cdir = rootvnode; 532 VREF(p->p_fd->fd_cdir); 533 p->p_fd->fd_rdir = rootvnode; 534 VREF(p->p_fd->fd_rdir); 535 FILEDESC_UNLOCK(p->p_fd); 536 VOP_UNLOCK(rootvnode, 0, td); 537 #ifdef MAC 538 mac_create_root_mount(td->td_ucred, TAILQ_FIRST(&mountlist)); 539 #endif 540 541 /* 542 * For disk based systems, we probably cannot do this yet 543 * since the fs will be read-only. But a NFS root 544 * might be ok. It is worth a shot. 545 */ 546 error = kern_mkdir(td, "/dev", UIO_SYSSPACE, 0700); 547 if (error == EEXIST) 548 error = 0; 549 if (error == 0) 550 error = kernel_vmount(0, "fstype", "devfs", 551 "fspath", "/dev", NULL); 552 if (error != 0) 553 init_does_devfs = 1; 554 555 /* 556 * Need just enough stack to hold the faked-up "execve()" arguments. 557 */ 558 addr = p->p_sysent->sv_usrstack - PAGE_SIZE; 559 if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE, 560 FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0) 561 panic("init: couldn't allocate argument space"); 562 p->p_vmspace->vm_maxsaddr = (caddr_t)addr; 563 p->p_vmspace->vm_ssize = 1; 564 565 if ((var = getenv("init_path")) != NULL) { 566 strlcpy(init_path, var, sizeof(init_path)); 567 freeenv(var); 568 } 569 570 for (path = init_path; *path != '\0'; path = next) { 571 while (*path == ':') 572 path++; 573 if (*path == '\0') 574 break; 575 for (next = path; *next != '\0' && *next != ':'; next++) 576 /* nothing */ ; 577 if (bootverbose) 578 printf("start_init: trying %.*s\n", (int)(next - path), 579 path); 580 581 /* 582 * Move out the boot flag argument. 583 */ 584 options = 0; 585 ucp = (char *)p->p_sysent->sv_usrstack; 586 (void)subyte(--ucp, 0); /* trailing zero */ 587 if (boothowto & RB_SINGLE) { 588 (void)subyte(--ucp, 's'); 589 options = 1; 590 } 591 #ifdef notyet 592 if (boothowto & RB_FASTBOOT) { 593 (void)subyte(--ucp, 'f'); 594 options = 1; 595 } 596 #endif 597 598 #ifdef BOOTCDROM 599 (void)subyte(--ucp, 'C'); 600 options = 1; 601 #endif 602 if (init_does_devfs) { 603 (void)subyte(--ucp, 'd'); 604 options = 1; 605 } 606 607 if (options == 0) 608 (void)subyte(--ucp, '-'); 609 (void)subyte(--ucp, '-'); /* leading hyphen */ 610 arg1 = ucp; 611 612 /* 613 * Move out the file name (also arg 0). 614 */ 615 (void)subyte(--ucp, 0); 616 for (s = next - 1; s >= path; s--) 617 (void)subyte(--ucp, *s); 618 arg0 = ucp; 619 620 /* 621 * Move out the arg pointers. 622 */ 623 uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1)); 624 (void)suword((caddr_t)--uap, (long)0); /* terminator */ 625 (void)suword((caddr_t)--uap, (long)(intptr_t)arg1); 626 (void)suword((caddr_t)--uap, (long)(intptr_t)arg0); 627 628 /* 629 * Point at the arguments. 630 */ 631 args.fname = arg0; 632 args.argv = uap; 633 args.envv = NULL; 634 635 /* 636 * Now try to exec the program. If can't for any reason 637 * other than it doesn't exist, complain. 638 * 639 * Otherwise, return via fork_trampoline() all the way 640 * to user mode as init! 641 */ 642 if ((error = execve(td, &args)) == 0) { 643 mtx_unlock(&Giant); 644 return; 645 } 646 if (error != ENOENT) 647 printf("exec %.*s: error %d\n", (int)(next - path), 648 path, error); 649 } 650 printf("init: not found in path %s\n", init_path); 651 panic("no init"); 652 } 653 654 /* 655 * Like kthread_create(), but runs in it's own address space. 656 * We do this early to reserve pid 1. 657 * 658 * Note special case - do not make it runnable yet. Other work 659 * in progress will change this more. 660 */ 661 static void 662 create_init(const void *udata __unused) 663 { 664 struct ucred *newcred, *oldcred; 665 int error; 666 667 error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc); 668 if (error) 669 panic("cannot fork init: %d\n", error); 670 KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1")); 671 /* divorce init's credentials from the kernel's */ 672 newcred = crget(); 673 PROC_LOCK(initproc); 674 initproc->p_flag |= P_SYSTEM; 675 oldcred = initproc->p_ucred; 676 crcopy(newcred, oldcred); 677 #ifdef MAC 678 mac_create_proc1(newcred); 679 #endif 680 initproc->p_ucred = newcred; 681 PROC_UNLOCK(initproc); 682 crfree(oldcred); 683 cred_update_thread(FIRST_THREAD_IN_PROC(initproc)); 684 mtx_lock_spin(&sched_lock); 685 initproc->p_sflag |= PS_INMEM; 686 mtx_unlock_spin(&sched_lock); 687 cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL); 688 } 689 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL) 690 691 /* 692 * Make it runnable now. 693 */ 694 static void 695 kick_init(const void *udata __unused) 696 { 697 struct thread *td; 698 699 td = FIRST_THREAD_IN_PROC(initproc); 700 mtx_lock_spin(&sched_lock); 701 TD_SET_CAN_RUN(td); 702 setrunqueue(td, SRQ_BORING); /* XXXKSE */ 703 mtx_unlock_spin(&sched_lock); 704 } 705 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL) 706