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