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) 692