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