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