init_main.c revision 1.170
1 /* $NetBSD: init_main.c,v 1.170 2000/05/28 18:52:32 jhawk Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Christopher G. Demetriou. All rights reserved. 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.16 (Berkeley) 5/14/95 42 */ 43 44 #include "fs_nfs.h" 45 #include "opt_nfsserver.h" 46 #include "opt_sysv.h" 47 #include "opt_maxuprc.h" 48 #include "opt_multiprocessor.h" 49 50 #include "rnd.h" 51 52 #include <sys/param.h> 53 #include <sys/acct.h> 54 #include <sys/filedesc.h> 55 #include <sys/file.h> 56 #include <sys/errno.h> 57 #include <sys/exec.h> 58 #include <sys/callout.h> 59 #include <sys/kernel.h> 60 #include <sys/mount.h> 61 #include <sys/map.h> 62 #include <sys/proc.h> 63 #include <sys/kthread.h> 64 #include <sys/resourcevar.h> 65 #include <sys/signalvar.h> 66 #include <sys/systm.h> 67 #include <sys/vnode.h> 68 #include <sys/tty.h> 69 #include <sys/conf.h> 70 #include <sys/disklabel.h> 71 #include <sys/buf.h> 72 #include <sys/device.h> 73 #include <sys/socketvar.h> 74 #include <sys/protosw.h> 75 #include <sys/reboot.h> 76 #include <sys/user.h> 77 #ifdef SYSVSHM 78 #include <sys/shm.h> 79 #endif 80 #ifdef SYSVSEM 81 #include <sys/sem.h> 82 #endif 83 #ifdef SYSVMSG 84 #include <sys/msg.h> 85 #endif 86 #include <sys/domain.h> 87 #include <sys/mbuf.h> 88 #include <sys/namei.h> 89 #if NRND > 0 90 #include <sys/rnd.h> 91 #endif 92 93 #include <sys/syscall.h> 94 #include <sys/syscallargs.h> 95 96 #include <ufs/ufs/quota.h> 97 98 #include <miscfs/genfs/genfs.h> 99 #include <miscfs/syncfs/syncfs.h> 100 101 #include <machine/cpu.h> 102 103 #include <vm/vm.h> 104 #include <vm/vm_pageout.h> 105 106 #include <uvm/uvm.h> 107 108 #include <net/if.h> 109 #include <net/raw_cb.h> 110 111 char copyright[] = "\ 112 Copyright (c) 1996, 1997, 1998, 1999, 2000 113 The NetBSD Foundation, Inc. All rights reserved. 114 Copyright (c) 1982, 1986, 1989, 1991, 1993 115 The Regents of the University of California. All rights reserved. 116 117 "; 118 119 /* Components of the first process -- never freed. */ 120 struct session session0; 121 struct pgrp pgrp0; 122 struct proc proc0; 123 struct pcred cred0; 124 struct filedesc0 filedesc0; 125 struct cwdinfo cwdi0; 126 struct plimit limit0; 127 struct vmspace vmspace0; 128 struct sigacts sigacts0; 129 #ifndef curproc 130 struct proc *curproc = &proc0; 131 #endif 132 struct proc *initproc; 133 134 int cmask = CMASK; 135 extern struct user *proc0paddr; 136 137 struct vnode *rootvp, *swapdev_vp; 138 int boothowto; 139 int cold = 1; /* still working on startup */ 140 struct timeval boottime; 141 142 __volatile int start_init_exec; /* semaphore for start_init() */ 143 144 static void check_console __P((struct proc *p)); 145 static void start_init __P((void *)); 146 static void start_pagedaemon __P((void *)); 147 static void start_reaper __P((void *)); 148 void main __P((void)); 149 150 extern char sigcode[], esigcode[]; 151 #ifdef SYSCALL_DEBUG 152 extern char *syscallnames[]; 153 #endif 154 155 struct emul emul_netbsd = { 156 "netbsd", 157 NULL, 158 sendsig, 159 SYS_syscall, 160 SYS_MAXSYSCALL, 161 sysent, 162 #ifdef SYSCALL_DEBUG 163 syscallnames, 164 #else 165 NULL, 166 #endif 167 0, 168 copyargs, 169 setregs, 170 sigcode, 171 esigcode, 172 }; 173 174 /* 175 * System startup; initialize the world, create process 0, mount root 176 * filesystem, and fork to create init and pagedaemon. Most of the 177 * hard work is done in the lower-level initialization routines including 178 * startup(), which does memory initialization and autoconfiguration. 179 */ 180 void 181 main() 182 { 183 struct proc *p; 184 struct pdevinit *pdev; 185 int i, s, error; 186 extern struct pdevinit pdevinit[]; 187 extern void roundrobin __P((void *)); 188 extern void schedcpu __P((void *)); 189 extern void disk_init __P((void)); 190 #if defined(NFSSERVER) || defined(NFS) 191 extern void nfs_init __P((void)); 192 #endif 193 194 /* 195 * Initialize the current process pointer (curproc) before 196 * any possible traps/probes to simplify trap processing. 197 */ 198 p = &proc0; 199 curproc = p; 200 /* 201 * Attempt to find console and initialize 202 * in case of early panic or other messages. 203 */ 204 consinit(); 205 printf("%s", copyright); 206 207 uvm_init(); 208 209 /* Do machine-dependent initialization. */ 210 cpu_startup(); 211 212 /* Initialize callouts. */ 213 callout_startup(); 214 215 /* 216 * Initialize mbuf's. Do this now because we might attempt to 217 * allocate mbufs or mbuf clusters during autoconfiguration. 218 */ 219 mbinit(); 220 221 /* Initialize sockets. */ 222 soinit(); 223 224 /* 225 * The following 3 things must be done before autoconfiguration. 226 */ 227 disk_init(); /* initialize disk list */ 228 tty_init(); /* initialize tty list */ 229 #if NRND > 0 230 rnd_init(); /* initialize RNG */ 231 #endif 232 233 /* 234 * Initialize process and pgrp structures. 235 */ 236 procinit(); 237 238 /* 239 * Create process 0 (the swapper). 240 */ 241 s = proclist_lock_write(); 242 LIST_INSERT_HEAD(&allproc, p, p_list); 243 LIST_INSERT_HEAD(PIDHASH(p->p_pid), p, p_hash); 244 proclist_unlock_write(s); 245 246 p->p_pgrp = &pgrp0; 247 LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash); 248 LIST_INIT(&pgrp0.pg_members); 249 LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist); 250 251 pgrp0.pg_session = &session0; 252 session0.s_count = 1; 253 session0.s_sid = p->p_pid; 254 session0.s_leader = p; 255 256 /* 257 * Set P_NOCLDWAIT so that kernel threads are reparented to 258 * init(8) when they exit. init(8) can easily wait them out 259 * for us. 260 */ 261 p->p_flag = P_INMEM | P_SYSTEM | P_NOCLDWAIT; 262 p->p_stat = SONPROC; 263 p->p_nice = NZERO; 264 p->p_emul = &emul_netbsd; 265 strncpy(p->p_comm, "swapper", MAXCOMLEN); 266 267 callout_init(&p->p_realit_ch); 268 callout_init(&p->p_tsleep_ch); 269 270 /* Create credentials. */ 271 cred0.p_refcnt = 1; 272 p->p_cred = &cred0; 273 p->p_ucred = crget(); 274 p->p_ucred->cr_ngroups = 1; /* group 0 */ 275 276 /* Create the file descriptor table. */ 277 finit(); 278 p->p_fd = &filedesc0.fd_fd; 279 fdinit1(&filedesc0); 280 281 /* Create the CWD info. */ 282 p->p_cwdi = &cwdi0; 283 cwdi0.cwdi_cmask = cmask; 284 cwdi0.cwdi_refcnt = 1; 285 286 /* Create the limits structures. */ 287 p->p_limit = &limit0; 288 for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++) 289 limit0.pl_rlimit[i].rlim_cur = 290 limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY; 291 292 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles; 293 limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = 294 maxfiles < NOFILE ? maxfiles : NOFILE; 295 296 limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc; 297 limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = 298 maxproc < MAXUPRC ? maxproc : MAXUPRC; 299 300 i = ptoa(uvmexp.free); 301 limit0.pl_rlimit[RLIMIT_RSS].rlim_max = i; 302 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i; 303 limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3; 304 limit0.pl_corename = defcorename; 305 limit0.p_refcnt = 1; 306 307 /* 308 * Initialize proc0's vmspace, which uses the kernel pmap. 309 * All kernel processes (which never have user space mappings) 310 * share proc0's vmspace, and thus, the kernel pmap. 311 */ 312 uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS), 313 trunc_page(VM_MAX_ADDRESS), TRUE); 314 p->p_vmspace = &vmspace0; 315 316 p->p_addr = proc0paddr; /* XXX */ 317 318 /* 319 * We continue to place resource usage info in the 320 * user struct so they're pageable. 321 */ 322 p->p_stats = &p->p_addr->u_stats; 323 324 /* 325 * Charge root for one process. 326 */ 327 (void)chgproccnt(0, 1); 328 329 rqinit(); 330 331 /* Configure virtual memory system, set vm rlimits. */ 332 uvm_init_limits(p); 333 334 /* Initialize the file systems. */ 335 #if defined(NFSSERVER) || defined(NFS) 336 nfs_init(); /* initialize server/shared data */ 337 #endif 338 vfsinit(); 339 340 /* Configure the system hardware. This will enable interrupts. */ 341 configure(); 342 343 #ifdef SYSVSHM 344 /* Initialize System V style shared memory. */ 345 shminit(); 346 #endif 347 348 #ifdef SYSVSEM 349 /* Initialize System V style semaphores. */ 350 seminit(); 351 #endif 352 353 #ifdef SYSVMSG 354 /* Initialize System V style message queues. */ 355 msginit(); 356 #endif 357 358 /* Attach pseudo-devices. */ 359 for (pdev = pdevinit; pdev->pdev_attach != NULL; pdev++) 360 (*pdev->pdev_attach)(pdev->pdev_count); 361 362 /* 363 * Initialize protocols. Block reception of incoming packets 364 * until everything is ready. 365 */ 366 s = splimp(); 367 ifinit(); 368 domaininit(); 369 splx(s); 370 371 #ifdef GPROF 372 /* Initialize kernel profiling. */ 373 kmstartup(); 374 #endif 375 376 /* Initialize system accouting. */ 377 acct_init(); 378 379 /* 380 * Initialize signal-related data structures, and signal state 381 * for proc0. 382 */ 383 signal_init(); 384 p->p_sigacts = &sigacts0; 385 siginit(p); 386 387 /* Kick off timeout driven events by calling first time. */ 388 roundrobin(NULL); 389 schedcpu(NULL); 390 391 /* 392 * Create process 1 (init(8)). We do this now, as Unix has 393 * historically had init be process 1, and changing this would 394 * probably upset a lot of people. 395 * 396 * Note that process 1 won't immediately exec init(8), but will 397 * wait for us to inform it that the root file system has been 398 * mounted. 399 */ 400 if (fork1(p, 0, SIGCHLD, NULL, 0, start_init, NULL, NULL, &initproc)) 401 panic("fork init"); 402 403 /* 404 * Create any kernel threads who's creation was deferred because 405 * initproc had not yet been created. 406 */ 407 kthread_run_deferred_queue(); 408 409 /* 410 * Now that device driver threads have been created, wait for 411 * them to finish any deferred autoconfiguration. Note we don't 412 * need to lock this semaphore, since we haven't booted any 413 * secondary processors, yet. 414 */ 415 while (config_pending) 416 (void) tsleep((void *)&config_pending, PWAIT, "cfpend", 0); 417 418 /* 419 * Now that autoconfiguration has completed, we can determine 420 * the root and dump devices. 421 */ 422 cpu_rootconf(); 423 cpu_dumpconf(); 424 425 /* Mount the root file system. */ 426 do { 427 domountroothook(); 428 if ((error = vfs_mountroot())) { 429 printf("cannot mount root, error = %d\n", error); 430 boothowto |= RB_ASKNAME; 431 setroot(root_device, 432 (rootdev != NODEV) ? DISKPART(rootdev) : 0); 433 } 434 } while (error != 0); 435 mountroothook_destroy(); 436 437 mountlist.cqh_first->mnt_flag |= MNT_ROOTFS; 438 mountlist.cqh_first->mnt_op->vfs_refcount++; 439 440 /* 441 * Get the vnode for '/'. Set filedesc0.fd_fd.fd_cdir to 442 * reference it. 443 */ 444 if (VFS_ROOT(mountlist.cqh_first, &rootvnode)) 445 panic("cannot find root vnode"); 446 cwdi0.cwdi_cdir = rootvnode; 447 VREF(cwdi0.cwdi_cdir); 448 VOP_UNLOCK(rootvnode, 0); 449 cwdi0.cwdi_rdir = NULL; 450 451 /* 452 * Now that root is mounted, we can fixup initproc's CWD 453 * info. All other processes are kthreads, which merely 454 * share proc0's CWD info. 455 */ 456 initproc->p_cwdi->cwdi_cdir = rootvnode; 457 VREF(initproc->p_cwdi->cwdi_cdir); 458 initproc->p_cwdi->cwdi_rdir = NULL; 459 460 /* 461 * Now can look at time, having had a chance to verify the time 462 * from the file system. Reset p->p_rtime as it may have been 463 * munched in mi_switch() after the time got set. 464 */ 465 proclist_lock_read(); 466 s = splclock(); /* so we can read time */ 467 for (p = LIST_FIRST(&allproc); p != NULL; 468 p = LIST_NEXT(p, p_list)) { 469 p->p_stats->p_start = curcpu()->ci_schedstate.spc_runtime = 470 mono_time = boottime = time; 471 p->p_rtime.tv_sec = p->p_rtime.tv_usec = 0; 472 } 473 splx(s); 474 proclist_unlock_read(); 475 476 /* Create the pageout daemon kernel thread. */ 477 uvm_swap_init(); 478 if (kthread_create1(start_pagedaemon, NULL, NULL, "pagedaemon")) 479 panic("fork pagedaemon"); 480 481 /* Create the process reaper kernel thread. */ 482 if (kthread_create1(start_reaper, NULL, NULL, "reaper")) 483 panic("fork reaper"); 484 485 /* Create the filesystem syncer kernel thread. */ 486 if (kthread_create1(sched_sync, NULL, NULL, "ioflush")) 487 panic("fork syncer"); 488 489 #if defined(MULTIPROCESSOR) 490 /* Boot the secondary processors. */ 491 cpu_boot_secondary_processors(); 492 #endif 493 494 /* 495 * Okay, now we can let init(8) exec! It's off to userland! 496 */ 497 start_init_exec = 1; 498 wakeup((void *)&start_init_exec); 499 500 /* The scheduler is an infinite loop. */ 501 uvm_scheduler(); 502 /* NOTREACHED */ 503 } 504 505 static void 506 check_console(p) 507 struct proc *p; 508 { 509 struct nameidata nd; 510 int error; 511 512 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/dev/console", p); 513 error = namei(&nd); 514 if (error == 0) 515 vrele(nd.ni_vp); 516 else if (error == ENOENT) 517 printf("warning: no /dev/console\n"); 518 else 519 printf("warning: lookup /dev/console: error %d\n", error); 520 } 521 522 /* 523 * List of paths to try when searching for "init". 524 */ 525 static char *initpaths[] = { 526 "/sbin/init", 527 "/sbin/oinit", 528 "/sbin/init.bak", 529 NULL, 530 }; 531 532 /* 533 * Start the initial user process; try exec'ing each pathname in "initpaths". 534 * The program is invoked with one argument containing the boot flags. 535 */ 536 static void 537 start_init(arg) 538 void *arg; 539 { 540 struct proc *p = arg; 541 vaddr_t addr; 542 struct sys_execve_args /* { 543 syscallarg(const char *) path; 544 syscallarg(char * const *) argp; 545 syscallarg(char * const *) envp; 546 } */ args; 547 int options, i, error; 548 register_t retval[2]; 549 char flags[4], *flagsp; 550 char **pathp, *path, *slash, *ucp, **uap, *arg0, *arg1 = NULL; 551 552 /* 553 * Now in process 1. 554 */ 555 strncpy(p->p_comm, "init", MAXCOMLEN); 556 557 /* 558 * Wait for main() to tell us that it's safe to exec. 559 */ 560 while (start_init_exec == 0) 561 (void) tsleep((void *)&start_init_exec, PWAIT, "initexec", 0); 562 563 /* 564 * This is not the right way to do this. We really should 565 * hand-craft a descriptor onto /dev/console to hand to init, 566 * but that's a _lot_ more work, and the benefit from this easy 567 * hack makes up for the "good is the enemy of the best" effect. 568 */ 569 check_console(p); 570 571 /* 572 * Need just enough stack to hold the faked-up "execve()" arguments. 573 */ 574 addr = USRSTACK - PAGE_SIZE; 575 if (uvm_map(&p->p_vmspace->vm_map, &addr, PAGE_SIZE, 576 NULL, UVM_UNKNOWN_OFFSET, 577 UVM_MAPFLAG(UVM_PROT_ALL, UVM_PROT_ALL, UVM_INH_COPY, 578 UVM_ADV_NORMAL, 579 UVM_FLAG_FIXED|UVM_FLAG_OVERLAY|UVM_FLAG_COPYONW)) 580 != KERN_SUCCESS) 581 panic("init: couldn't allocate argument space"); 582 p->p_vmspace->vm_maxsaddr = (caddr_t)addr; 583 584 for (pathp = &initpaths[0]; (path = *pathp) != NULL; pathp++) { 585 ucp = (char *)(addr + PAGE_SIZE); 586 587 /* 588 * Construct the boot flag argument. 589 */ 590 flagsp = flags; 591 *flagsp++ = '-'; 592 options = 0; 593 594 if (boothowto & RB_SINGLE) { 595 *flagsp++ = 's'; 596 options = 1; 597 } 598 #ifdef notyet 599 if (boothowto & RB_FASTBOOT) { 600 *flagsp++ = 'f'; 601 options = 1; 602 } 603 #endif 604 605 /* 606 * Move out the flags (arg 1), if necessary. 607 */ 608 if (options != 0) { 609 *flagsp++ = '\0'; 610 i = flagsp - flags; 611 #ifdef DEBUG 612 printf("init: copying out flags `%s' %d\n", flags, i); 613 #endif 614 (void)copyout((caddr_t)flags, (caddr_t)(ucp -= i), i); 615 arg1 = ucp; 616 } 617 618 /* 619 * Move out the file name (also arg 0). 620 */ 621 i = strlen(path) + 1; 622 #ifdef DEBUG 623 printf("init: copying out path `%s' %d\n", path, i); 624 #endif 625 (void)copyout((caddr_t)path, (caddr_t)(ucp -= i), i); 626 arg0 = ucp; 627 628 /* 629 * Move out the arg pointers. 630 */ 631 uap = (char **)((long)ucp & ~ALIGNBYTES); 632 (void)suword((caddr_t)--uap, 0); /* terminator */ 633 if (options != 0) 634 (void)suword((caddr_t)--uap, (long)arg1); 635 slash = strrchr(path, '/'); 636 if (slash) 637 (void)suword((caddr_t)--uap, 638 (long)arg0 + (slash + 1 - path)); 639 else 640 (void)suword((caddr_t)--uap, (long)arg0); 641 642 /* 643 * Point at the arguments. 644 */ 645 SCARG(&args, path) = arg0; 646 SCARG(&args, argp) = uap; 647 SCARG(&args, envp) = NULL; 648 649 /* 650 * Now try to exec the program. If can't for any reason 651 * other than it doesn't exist, complain. 652 */ 653 error = sys_execve(p, &args, retval); 654 if (error == 0 || error == EJUSTRETURN) 655 return; 656 if (error != ENOENT) 657 printf("exec %s: error %d\n", path, error); 658 } 659 printf("init: not found\n"); 660 panic("no init"); 661 } 662 663 /* ARGSUSED */ 664 static void 665 start_pagedaemon(arg) 666 void *arg; 667 { 668 669 uvm_pageout(); 670 /* NOTREACHED */ 671 } 672 673 /* ARGSUSED */ 674 static void 675 start_reaper(arg) 676 void *arg; 677 { 678 679 reaper(); 680 /* NOTREACHED */ 681 } 682
Indexes created Mon Sep 22 10:09:38 GMT 2025