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