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 * $FreeBSD$ 43 */ 44 45 #include "opt_init_path.h" 46 #include "opt_mac.h" 47 48 #include <sys/param.h> 49 #include <sys/kernel.h> 50 #include <sys/exec.h> 51 #include <sys/file.h> 52 #include <sys/filedesc.h> 53 #include <sys/ktr.h> 54 #include <sys/lock.h> 55 #include <sys/mac.h> 56 #include <sys/mount.h> 57 #include <sys/mutex.h> 58 #include <sys/syscallsubr.h> 59 #include <sys/sysctl.h> 60 #include <sys/proc.h> 61 #include <sys/resourcevar.h> 62 #include <sys/systm.h> 63 #include <sys/signalvar.h> 64 #include <sys/vnode.h> 65 #include <sys/sysent.h> 66 #include <sys/reboot.h> 67 #include <sys/sched.h> 68 #include <sys/sx.h> 69 #include <sys/sysproto.h> 70 #include <sys/vmmeter.h> 71 #include <sys/unistd.h> 72 #include <sys/malloc.h> 73 #include <sys/conf.h> 74 75 #include <machine/cpu.h> 76 77 #include <vm/vm.h> 78 #include <vm/vm_param.h> 79 #include <vm/pmap.h> 80 #include <vm/vm_map.h> 81 #include <sys/user.h> 82 #include <sys/copyright.h> 83 84 void mi_startup(void); /* Should be elsewhere */ 85 86 /* Components of the first process -- never freed. */ 87 static struct session session0; 88 static struct pgrp pgrp0; 89 struct proc proc0; 90 struct thread thread0; 91 struct kse kse0; 92 struct ksegrp ksegrp0; 93 static struct filedesc0 filedesc0; 94 static struct plimit limit0; 95 struct vmspace vmspace0; 96 struct proc *initproc; 97 98 int cmask = CMASK; 99 100 struct vnode *rootvp; 101 int boothowto = 0; /* initialized so that it can be patched */ 102 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0, ""); 103 int bootverbose; 104 SYSCTL_INT(_debug, OID_AUTO, bootverbose, CTLFLAG_RW, &bootverbose, 0, ""); 105 106 /* 107 * This ensures that there is at least one entry so that the sysinit_set 108 * symbol is not undefined. A sybsystem ID of SI_SUB_DUMMY is never 109 * executed. 110 */ 111 SYSINIT(placeholder, SI_SUB_DUMMY, SI_ORDER_ANY, NULL, NULL) 112 113 /* 114 * The sysinit table itself. Items are checked off as the are run. 115 * If we want to register new sysinit types, add them to newsysinit. 116 */ 117 SET_DECLARE(sysinit_set, struct sysinit); 118 struct sysinit **sysinit, **sysinit_end; 119 struct sysinit **newsysinit, **newsysinit_end; 120 121 /* 122 * Merge a new sysinit set into the current set, reallocating it if 123 * necessary. This can only be called after malloc is running. 124 */ 125 void 126 sysinit_add(struct sysinit **set, struct sysinit **set_end) 127 { 128 struct sysinit **newset; 129 struct sysinit **sipp; 130 struct sysinit **xipp; 131 int count; 132 133 count = set_end - set; 134 if (newsysinit) 135 count += newsysinit_end - newsysinit; 136 else 137 count += sysinit_end - sysinit; 138 newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT); 139 if (newset == NULL) 140 panic("cannot malloc for sysinit"); 141 xipp = newset; 142 if (newsysinit) 143 for (sipp = newsysinit; sipp < newsysinit_end; sipp++) 144 *xipp++ = *sipp; 145 else 146 for (sipp = sysinit; sipp < sysinit_end; sipp++) 147 *xipp++ = *sipp; 148 for (sipp = set; sipp < set_end; sipp++) 149 *xipp++ = *sipp; 150 if (newsysinit) 151 free(newsysinit, M_TEMP); 152 newsysinit = newset; 153 newsysinit_end = newset + count; 154 } 155 156 /* 157 * System startup; initialize the world, create process 0, mount root 158 * filesystem, and fork to create init and pagedaemon. Most of the 159 * hard work is done in the lower-level initialization routines including 160 * startup(), which does memory initialization and autoconfiguration. 161 * 162 * This allows simple addition of new kernel subsystems that require 163 * boot time initialization. It also allows substitution of subsystem 164 * (for instance, a scheduler, kernel profiler, or VM system) by object 165 * module. Finally, it allows for optional "kernel threads". 166 */ 167 void 168 mi_startup(void) 169 { 170 171 register struct sysinit **sipp; /* system initialization*/ 172 register struct sysinit **xipp; /* interior loop of sort*/ 173 register struct sysinit *save; /* bubble*/ 174 175 if (sysinit == NULL) { 176 sysinit = SET_BEGIN(sysinit_set); 177 sysinit_end = SET_LIMIT(sysinit_set); 178 } 179 180 restart: 181 /* 182 * Perform a bubble sort of the system initialization objects by 183 * their subsystem (primary key) and order (secondary key). 184 */ 185 for (sipp = sysinit; sipp < sysinit_end; sipp++) { 186 for (xipp = sipp + 1; xipp < sysinit_end; xipp++) { 187 if ((*sipp)->subsystem < (*xipp)->subsystem || 188 ((*sipp)->subsystem == (*xipp)->subsystem && 189 (*sipp)->order <= (*xipp)->order)) 190 continue; /* skip*/ 191 save = *sipp; 192 *sipp = *xipp; 193 *xipp = save; 194 } 195 } 196 197 /* 198 * Traverse the (now) ordered list of system initialization tasks. 199 * Perform each task, and continue on to the next task. 200 * 201 * The last item on the list is expected to be the scheduler, 202 * which will not return. 203 */ 204 for (sipp = sysinit; sipp < sysinit_end; sipp++) { 205 206 if ((*sipp)->subsystem == SI_SUB_DUMMY) 207 continue; /* skip dummy task(s)*/ 208 209 if ((*sipp)->subsystem == SI_SUB_DONE) 210 continue; 211 212 /* Call function */ 213 (*((*sipp)->func))((*sipp)->udata); 214 215 /* Check off the one we're just done */ 216 (*sipp)->subsystem = SI_SUB_DONE; 217 218 /* Check if we've installed more sysinit items via KLD */ 219 if (newsysinit != NULL) { 220 if (sysinit != SET_BEGIN(sysinit_set)) 221 free(sysinit, M_TEMP); 222 sysinit = newsysinit; 223 sysinit_end = newsysinit_end; 224 newsysinit = NULL; 225 newsysinit_end = NULL; 226 goto restart; 227 } 228 } 229 230 panic("Shouldn't get here!"); 231 /* NOTREACHED*/ 232 } 233 234 235 /* 236 *************************************************************************** 237 **** 238 **** The following SYSINIT's belong elsewhere, but have not yet 239 **** been moved. 240 **** 241 *************************************************************************** 242 */ 243 static void 244 print_caddr_t(void *data __unused) 245 { 246 printf("%s", (char *)data); 247 } 248 SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t, copyright) 249 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t, version) 250 251 static void 252 set_boot_verbose(void *data __unused) 253 { 254 255 if (boothowto & RB_VERBOSE) 256 bootverbose++; 257 } 258 SYSINIT(boot_verbose, SI_SUB_TUNABLES, SI_ORDER_ANY, set_boot_verbose, NULL) 259 260 struct sysentvec null_sysvec = { 261 0, 262 NULL, 263 0, 264 0, 265 NULL, 266 0, 267 NULL, 268 NULL, 269 NULL, 270 NULL, 271 NULL, 272 NULL, 273 NULL, 274 "null", 275 NULL, 276 NULL, 277 0, 278 PAGE_SIZE, 279 VM_MIN_ADDRESS, 280 VM_MAXUSER_ADDRESS, 281 USRSTACK, 282 PS_STRINGS, 283 VM_PROT_ALL, 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, 1); 388 callout_init(&td->td_slpcallout, 1); 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 fdp = &filedesc0; 409 p->p_fd = &fdp->fd_fd; 410 p->p_fdtol = NULL; 411 mtx_init(&fdp->fd_fd.fd_mtx, FILEDESC_LOCK_DESC, NULL, MTX_DEF); 412 fdp->fd_fd.fd_refcnt = 1; 413 fdp->fd_fd.fd_cmask = cmask; 414 fdp->fd_fd.fd_ofiles = fdp->fd_dfiles; 415 fdp->fd_fd.fd_ofileflags = fdp->fd_dfileflags; 416 fdp->fd_fd.fd_nfiles = NDFILE; 417 418 /* Create the limits structures. */ 419 p->p_limit = &limit0; 420 for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++) 421 limit0.pl_rlimit[i].rlim_cur = 422 limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY; 423 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = 424 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles; 425 limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = 426 limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc; 427 i = ptoa(cnt.v_free_count); 428 limit0.pl_rlimit[RLIMIT_RSS].rlim_max = i; 429 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i; 430 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3; 431 limit0.p_refcnt = 1; 432 p->p_cpulimit = RLIM_INFINITY; 433 434 /* Allocate a prototype map so we have something to fork. */ 435 pmap_pinit0(vmspace_pmap(&vmspace0)); 436 p->p_vmspace = &vmspace0; 437 vmspace0.vm_refcnt = 1; 438 vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser, 439 p->p_sysent->sv_maxuser); 440 vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0); 441 442 /* 443 * We continue to place resource usage info 444 * in the user struct so that it's pageable. 445 */ 446 p->p_stats = &p->p_uarea->u_stats; 447 448 /* 449 * Charge root for one process. 450 */ 451 (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0); 452 } 453 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL) 454 455 /* ARGSUSED*/ 456 static void 457 proc0_post(void *dummy __unused) 458 { 459 struct timespec ts; 460 struct proc *p; 461 462 /* 463 * Now we can look at the time, having had a chance to verify the 464 * time from the filesystem. Pretend that proc0 started now. 465 */ 466 sx_slock(&allproc_lock); 467 LIST_FOREACH(p, &allproc, p_list) { 468 microuptime(&p->p_stats->p_start); 469 p->p_runtime.sec = 0; 470 p->p_runtime.frac = 0; 471 } 472 sx_sunlock(&allproc_lock); 473 binuptime(PCPU_PTR(switchtime)); 474 PCPU_SET(switchticks, ticks); 475 476 /* 477 * Give the ``random'' number generator a thump. 478 */ 479 nanotime(&ts); 480 srandom(ts.tv_sec ^ ts.tv_nsec); 481 } 482 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL) 483 484 /* 485 *************************************************************************** 486 **** 487 **** The following SYSINIT's and glue code should be moved to the 488 **** respective files on a per subsystem basis. 489 **** 490 *************************************************************************** 491 */ 492 493 494 /* 495 *************************************************************************** 496 **** 497 **** The following code probably belongs in another file, like 498 **** kern/init_init.c. 499 **** 500 *************************************************************************** 501 */ 502 503 /* 504 * List of paths to try when searching for "init". 505 */ 506 static char init_path[MAXPATHLEN] = 507 #ifdef INIT_PATH 508 __XSTRING(INIT_PATH); 509 #else 510 "/sbin/init:/sbin/oinit:/sbin/init.bak:/stand/sysinstall"; 511 #endif 512 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0, 513 "Path used to search the init process"); 514 515 /* 516 * Start the initial user process; try exec'ing each pathname in init_path. 517 * The program is invoked with one argument containing the boot flags. 518 */ 519 static void 520 start_init(void *dummy) 521 { 522 vm_offset_t addr; 523 struct execve_args args; 524 int options, error; 525 char *var, *path, *next, *s; 526 char *ucp, **uap, *arg0, *arg1; 527 struct thread *td; 528 struct proc *p; 529 int init_does_devfs = 0; 530 531 mtx_lock(&Giant); 532 533 GIANT_REQUIRED; 534 535 td = curthread; 536 p = td->td_proc; 537 538 vfs_mountroot(); 539 540 /* Get the vnode for '/'. Set p->p_fd->fd_cdir to reference it. */ 541 if (VFS_ROOT(TAILQ_FIRST(&mountlist), &rootvnode)) 542 panic("cannot find root vnode"); 543 FILEDESC_LOCK(p->p_fd); 544 p->p_fd->fd_cdir = rootvnode; 545 VREF(p->p_fd->fd_cdir); 546 p->p_fd->fd_rdir = rootvnode; 547 VREF(p->p_fd->fd_rdir); 548 FILEDESC_UNLOCK(p->p_fd); 549 VOP_UNLOCK(rootvnode, 0, td); 550 #ifdef MAC 551 mac_create_root_mount(td->td_ucred, TAILQ_FIRST(&mountlist)); 552 #endif 553 554 /* 555 * For disk based systems, we probably cannot do this yet 556 * since the fs will be read-only. But a NFS root 557 * might be ok. It is worth a shot. 558 */ 559 error = kern_mkdir(td, "/dev", UIO_SYSSPACE, 0700); 560 if (error == EEXIST) 561 error = 0; 562 if (error == 0) 563 error = kernel_vmount(0, "fstype", "devfs", 564 "fspath", "/dev", NULL); 565 if (error != 0) 566 init_does_devfs = 1; 567 568 /* 569 * Need just enough stack to hold the faked-up "execve()" arguments. 570 */ 571 addr = p->p_sysent->sv_usrstack - PAGE_SIZE; 572 if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE, 573 FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0) 574 panic("init: couldn't allocate argument space"); 575 p->p_vmspace->vm_maxsaddr = (caddr_t)addr; 576 p->p_vmspace->vm_ssize = 1; 577 578 if ((var = getenv("init_path")) != NULL) { 579 strlcpy(init_path, var, sizeof(init_path)); 580 freeenv(var); 581 } 582 583 for (path = init_path; *path != '\0'; path = next) { 584 while (*path == ':') 585 path++; 586 if (*path == '\0') 587 break; 588 for (next = path; *next != '\0' && *next != ':'; next++) 589 /* nothing */ ; 590 if (bootverbose) 591 printf("start_init: trying %.*s\n", (int)(next - path), 592 path); 593 594 /* 595 * Move out the boot flag argument. 596 */ 597 options = 0; 598 ucp = (char *)p->p_sysent->sv_usrstack; 599 (void)subyte(--ucp, 0); /* trailing zero */ 600 if (boothowto & RB_SINGLE) { 601 (void)subyte(--ucp, 's'); 602 options = 1; 603 } 604 #ifdef notyet 605 if (boothowto & RB_FASTBOOT) { 606 (void)subyte(--ucp, 'f'); 607 options = 1; 608 } 609 #endif 610 611 #ifdef BOOTCDROM 612 (void)subyte(--ucp, 'C'); 613 options = 1; 614 #endif 615 if (init_does_devfs) { 616 (void)subyte(--ucp, 'd'); 617 options = 1; 618 } 619 620 if (options == 0) 621 (void)subyte(--ucp, '-'); 622 (void)subyte(--ucp, '-'); /* leading hyphen */ 623 arg1 = ucp; 624 625 /* 626 * Move out the file name (also arg 0). 627 */ 628 (void)subyte(--ucp, 0); 629 for (s = next - 1; s >= path; s--) 630 (void)subyte(--ucp, *s); 631 arg0 = ucp; 632 633 /* 634 * Move out the arg pointers. 635 */ 636 uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1)); 637 (void)suword((caddr_t)--uap, (long)0); /* terminator */ 638 (void)suword((caddr_t)--uap, (long)(intptr_t)arg1); 639 (void)suword((caddr_t)--uap, (long)(intptr_t)arg0); 640 641 /* 642 * Point at the arguments. 643 */ 644 args.fname = arg0; 645 args.argv = uap; 646 args.envv = NULL; 647 648 /* 649 * Now try to exec the program. If can't for any reason 650 * other than it doesn't exist, complain. 651 * 652 * Otherwise, return via fork_trampoline() all the way 653 * to user mode as init! 654 */ 655 if ((error = execve(td, &args)) == 0) { 656 mtx_unlock(&Giant); 657 return; 658 } 659 if (error != ENOENT) 660 printf("exec %.*s: error %d\n", (int)(next - path), 661 path, error); 662 } 663 printf("init: not found in path %s\n", init_path); 664 panic("no init"); 665 } 666 667 /* 668 * Like kthread_create(), but runs in it's own address space. 669 * We do this early to reserve pid 1. 670 * 671 * Note special case - do not make it runnable yet. Other work 672 * in progress will change this more. 673 */ 674 static void 675 create_init(const void *udata __unused) 676 { 677 struct ucred *newcred, *oldcred; 678 int error; 679 680 error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc); 681 if (error) 682 panic("cannot fork init: %d\n", error); 683 /* divorce init's credentials from the kernel's */ 684 newcred = crget(); 685 PROC_LOCK(initproc); 686 initproc->p_flag |= P_SYSTEM; 687 oldcred = initproc->p_ucred; 688 crcopy(newcred, oldcred); 689 #ifdef MAC 690 mac_create_proc1(newcred); 691 #endif 692 initproc->p_ucred = newcred; 693 PROC_UNLOCK(initproc); 694 crfree(oldcred); 695 cred_update_thread(FIRST_THREAD_IN_PROC(initproc)); 696 mtx_lock_spin(&sched_lock); 697 initproc->p_sflag |= PS_INMEM; 698 mtx_unlock_spin(&sched_lock); 699 cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL); 700 } 701 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL) 702 703 /* 704 * Make it runnable now. 705 */ 706 static void 707 kick_init(const void *udata __unused) 708 { 709 struct thread *td; 710 711 td = FIRST_THREAD_IN_PROC(initproc); 712 mtx_lock_spin(&sched_lock); 713 TD_SET_CAN_RUN(td); 714 setrunqueue(td); /* XXXKSE */ 715 mtx_unlock_spin(&sched_lock); 716 } 717 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL) 718