1 /* $NetBSD: init_main.c,v 1.542 2023/07/07 12:34:50 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2008, 2009, 2019 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*
30 * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
31 * The Regents of the University of California. All rights reserved.
32 * (c) UNIX System Laboratories, Inc.
33 * All or some portions of this file are derived from material licensed
34 * to the University of California by American Telephone and Telegraph
35 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
36 * the permission of UNIX System Laboratories, Inc.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. Neither the name of the University nor the names of its contributors
47 * may be used to endorse or promote products derived from this software
48 * without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60 * SUCH DAMAGE.
61 *
62 * @(#)init_main.c 8.16 (Berkeley) 5/14/95
63 */
64
65 /*
66 * Copyright (c) 1995 Christopher G. Demetriou. All rights reserved.
67 *
68 * Redistribution and use in source and binary forms, with or without
69 * modification, are permitted provided that the following conditions
70 * are met:
71 * 1. Redistributions of source code must retain the above copyright
72 * notice, this list of conditions and the following disclaimer.
73 * 2. Redistributions in binary form must reproduce the above copyright
74 * notice, this list of conditions and the following disclaimer in the
75 * documentation and/or other materials provided with the distribution.
76 * 3. All advertising materials mentioning features or use of this software
77 * must display the following acknowledgement:
78 * This product includes software developed by the University of
79 * California, Berkeley and its contributors.
80 * 4. Neither the name of the University nor the names of its contributors
81 * may be used to endorse or promote products derived from this software
82 * without specific prior written permission.
83 *
84 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
85 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
86 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
87 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
88 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
89 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
90 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
91 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
92 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
93 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
94 * SUCH DAMAGE.
95 *
96 * @(#)init_main.c 8.16 (Berkeley) 5/14/95
97 */
98
99 #include <sys/cdefs.h>
100 __KERNEL_RCSID(0, "$NetBSD: init_main.c,v 1.542 2023/07/07 12:34:50 riastradh Exp $");
101
102 #include "opt_cnmagic.h"
103 #include "opt_ddb.h"
104 #include "opt_heartbeat.h"
105 #include "opt_inet.h"
106 #include "opt_ipsec.h"
107 #include "opt_modular.h"
108 #include "opt_ntp.h"
109 #include "opt_pipe.h"
110 #include "opt_syscall_debug.h"
111 #include "opt_sysv.h"
112 #include "opt_fileassoc.h"
113 #include "opt_ktrace.h"
114 #include "opt_pax.h"
115 #include "opt_compat_netbsd.h"
116 #include "opt_ptrace.h"
117 #include "opt_splash.h"
118 #include "opt_kernhist.h"
119 #include "opt_gprof.h"
120
121 #if defined(SPLASHSCREEN) && defined(makeoptions_SPLASHSCREEN_IMAGE)
122 extern void *_binary_splash_image_start;
123 extern void *_binary_splash_image_end;
124 #endif
125
126 #include "ksyms.h"
127
128 #include "veriexec.h"
129
130 #include <sys/param.h>
131 #include <sys/acct.h>
132 #include <sys/filedesc.h>
133 #include <sys/file.h>
134 #include <sys/errno.h>
135 #include <sys/callout.h>
136 #include <sys/cpu.h>
137 #include <sys/cpufreq.h>
138 #include <sys/spldebug.h>
139 #include <sys/kernel.h>
140 #include <sys/mount.h>
141 #include <sys/proc.h>
142 #include <sys/lwp.h>
143 #include <sys/kthread.h>
144 #include <sys/resourcevar.h>
145 #include <sys/signalvar.h>
146 #include <sys/systm.h>
147 #include <sys/vnode.h>
148 #include <sys/fstrans.h>
149 #include <sys/tty.h>
150 #include <sys/conf.h>
151 #include <sys/disklabel.h>
152 #include <sys/buf.h>
153 #include <sys/device.h>
154 #include <sys/exec.h>
155 #include <sys/socketvar.h>
156 #include <sys/protosw.h>
157 #include <sys/percpu.h>
158 #include <sys/pserialize.h>
159 #include <sys/pset.h>
160 #include <sys/sysctl.h>
161 #include <sys/reboot.h>
162 #include <sys/event.h>
163 #include <sys/mbuf.h>
164 #include <sys/sched.h>
165 #include <sys/sleepq.h>
166 #include <sys/ipi.h>
167 #include <sys/iostat.h>
168 #include <sys/vmem.h>
169 #include <sys/uuid.h>
170 #include <sys/extent.h>
171 #include <sys/disk.h>
172 #include <sys/msgbuf.h>
173 #include <sys/module.h>
174 #include <sys/module_hook.h>
175 #include <sys/event.h>
176 #include <sys/lockf.h>
177 #include <sys/once.h>
178 #include <sys/kcpuset.h>
179 #include <sys/ksyms.h>
180 #include <sys/uidinfo.h>
181 #include <sys/kprintf.h>
182 #include <sys/bufq.h>
183 #include <sys/threadpool.h>
184 #include <sys/futex.h>
185 #ifdef IPSEC
186 #include <netipsec/ipsec.h>
187 #endif
188 #include <sys/domain.h>
189 #include <sys/namei.h>
190 #include <sys/rnd.h>
191 #include <sys/pipe.h>
192 #if NVERIEXEC > 0
193 #include <sys/verified_exec.h>
194 #endif /* NVERIEXEC > 0 */
195 #ifdef KTRACE
196 #include <sys/ktrace.h>
197 #endif
198 #include <sys/kauth.h>
199 #include <net80211/ieee80211_netbsd.h>
200 #include <sys/cprng.h>
201 #include <sys/psref.h>
202 #include <sys/radixtree.h>
203 #include <sys/heartbeat.h>
204
205 #include <sys/syscall.h>
206 #include <sys/syscallargs.h>
207
208 #include <sys/pax.h>
209
210 #include <dev/clock_subr.h>
211
212 #include <secmodel/secmodel.h>
213
214 #include <ufs/ufs/quota.h>
215
216 #include <miscfs/genfs/genfs.h>
217 #include <miscfs/specfs/specdev.h>
218
219 #include <sys/cpu.h>
220
221 #include <uvm/uvm.h> /* extern struct uvm uvm */
222
223 #include <dev/cons.h>
224 #include <dev/splash/splash.h>
225
226 #include <net/bpf.h>
227 #include <net/if.h>
228 #include <net/pfil.h>
229 #include <net/raw_cb.h>
230 #include <net/if_llatbl.h>
231
232 #include <prop/proplib.h>
233
234 #include <sys/userconf.h>
235
236 extern time_t rootfstime;
237
238 #ifndef curlwp
239 struct lwp *curlwp = &lwp0;
240 #endif
241 struct proc *initproc;
242
243 struct vnode *rootvp, *swapdev_vp;
244 int boothowto;
245 int cold __read_mostly = 1; /* still working on startup */
246 int shutting_down __read_mostly; /* system is shutting down */
247
248 int start_init_exec; /* semaphore for start_init() */
249
250 static void check_console(struct lwp *l);
251 static void start_init(void *);
252 static void configure(void);
253 static void configure2(void);
254 static void configure3(void);
255 void main(void);
256
257 /*
258 * System startup; initialize the world, create process 0, mount root
259 * filesystem, and fork to create init and pagedaemon. Most of the
260 * hard work is done in the lower-level initialization routines including
261 * startup(), which does memory initialization and autoconfiguration.
262 */
263 void
main(void)264 main(void)
265 {
266 struct timespec time;
267 struct lwp *l;
268 struct proc *p;
269 int s, error;
270 #ifdef NVNODE_IMPLICIT
271 int usevnodes;
272 #endif
273 CPU_INFO_ITERATOR cii;
274 struct cpu_info *ci;
275
276 #ifdef DIAGNOSTIC
277 /*
278 * Verify that CPU_INFO_FOREACH() knows about the boot CPU
279 * and only the boot CPU at this point.
280 */
281 int cpucount = 0;
282 for (CPU_INFO_FOREACH(cii, ci)) {
283 KASSERT(ci == curcpu());
284 cpucount++;
285 }
286 KASSERT(cpucount == 1);
287 #endif
288
289 l = &lwp0;
290 #ifndef LWP0_CPU_INFO
291 l->l_cpu = curcpu();
292 #endif
293 l->l_pflag |= LP_RUNNING;
294
295 /*
296 * Attempt to find console and initialize
297 * in case of early panic or other messages.
298 */
299 consinit();
300 #ifdef CNMAGIC
301 cn_set_magic(CNMAGIC);
302 #endif
303
304 kernel_lock_init();
305 once_init();
306 todr_init();
307
308 mi_cpu_init();
309 kernconfig_lock_init();
310 kthread_sysinit();
311
312 /* Initialize the device switch tables. */
313 devsw_init();
314
315 /* Initialize event counters. */
316 evcnt_init();
317
318 uvm_init();
319 ubchist_init();
320 kcpuset_sysinit();
321
322 prop_kern_init();
323
324 #if ((NKSYMS > 0) || (NDDB > 0) || (NMODULAR > 0))
325 ksyms_init();
326 #endif
327 kprintf_init();
328
329 percpu_init();
330
331 /* Initialize lock caches. */
332 mutex_obj_init();
333
334 /* Initialize radix trees (used by numerous subsystems). */
335 radix_tree_init();
336
337 /* Passive serialization. */
338 pserialize_init();
339
340 /* Initialize the extent manager. */
341 extent_init();
342
343 /* Do machine-dependent initialization. */
344 cpu_startup();
345
346 /* Initialize the sysctl subsystem. */
347 sysctl_init();
348
349 /* Initialize callouts, part 1. */
350 callout_startup();
351
352 /* Initialize the kernel authorization subsystem. */
353 kauth_init();
354
355 secmodel_init();
356
357 spec_init();
358
359 /*
360 * Set BPF op vector. Can't do this in bpf attach, since
361 * network drivers attach before bpf.
362 */
363 bpf_setops();
364
365 /* Initialize what we can in ipi(9) before CPUs are detected. */
366 ipi_sysinit();
367
368 /* Start module system. */
369 module_init();
370 module_hook_init();
371
372 /*
373 * Initialize the kernel authorization subsystem and start the
374 * default security model, if any. We need to do this early
375 * enough so that subsystems relying on any of the aforementioned
376 * can work properly. Since the security model may dictate the
377 * credential inheritance policy, it is needed at least before
378 * any process is created, specifically proc0.
379 */
380 module_init_class(MODULE_CLASS_SECMODEL);
381
382 /* Initialize the buffer cache */
383 bufinit();
384 biohist_init();
385
386 #ifdef KERNHIST
387 sysctl_kernhist_init();
388 #endif
389
390
391 #if defined(SPLASHSCREEN) && defined(SPLASHSCREEN_IMAGE)
392 size_t splash_size = (&_binary_splash_image_end -
393 &_binary_splash_image_start) * sizeof(void *);
394 splash_setimage(&_binary_splash_image_start, splash_size);
395 #endif
396
397 /* Initialize sockets. */
398 soinit();
399
400 /*
401 * The following things must be done before autoconfiguration.
402 */
403 rnd_init(); /* initialize entropy pool */
404
405 cprng_init(); /* initialize cryptographic PRNG */
406
407 /* Initialize process and pgrp structures. */
408 procinit();
409 lwpinit();
410
411 /* Must be called after lwpinit (lwpinit_specificdata) */
412 psref_init();
413
414 /* Initialize signal-related data structures. */
415 signal_init();
416
417 /* Initialize resource management. */
418 resource_init();
419
420 /* Create process 0. */
421 proc0_init();
422 lwp0_init();
423
424 /* Disable preemption during boot. */
425 kpreempt_disable();
426
427 /* Initialize the threadpool system. */
428 threadpools_init();
429
430 /* Initialize the UID hash table. */
431 uid_init();
432
433 /* Charge root for one process. */
434 (void)chgproccnt(0, 1);
435
436 /* Initialize the run queues, turnstiles and sleep queues. */
437 sched_rqinit();
438 turnstile_init();
439 sleeptab_init(&sleeptab);
440
441 sched_init();
442
443 /* Initialize processor-sets */
444 psets_init();
445
446 /* Initialize cpufreq(9) */
447 cpufreq_init();
448
449 /* MI initialization of the boot cpu */
450 error = mi_cpu_attach(curcpu());
451 KASSERT(error == 0);
452
453 /* Initialize timekeeping. */
454 time_init();
455
456 /*
457 * Initialize mbuf's. Do this now because we might attempt to
458 * allocate mbufs or mbuf clusters during autoconfiguration.
459 */
460 mbinit();
461
462 /* Initialize I/O statistics. */
463 iostat_init();
464
465 /* Initialize the log device. */
466 loginit();
467
468 /* Second part of module system initialization. */
469 module_start_unload_thread();
470
471 /* Initialize autoconf data structures before any modules are loaded */
472 config_init_mi();
473
474 /* Initialize the file systems. */
475 #ifdef NVNODE_IMPLICIT
476 /*
477 * If maximum number of vnodes in namei vnode cache is not explicitly
478 * defined in kernel config, adjust the number such as we use roughly
479 * 10% of memory for vnodes and associated data structures in the
480 * assumed worst case. Do not provide fewer than NVNODE vnodes.
481 */
482 usevnodes = calc_cache_size(vmem_size(kmem_arena, VMEM_FREE|VMEM_ALLOC),
483 10, VNODE_KMEM_MAXPCT) / VNODE_COST;
484 if (usevnodes > desiredvnodes)
485 desiredvnodes = usevnodes;
486 #endif /* NVNODE_IMPLICIT */
487 #ifdef MAXFILES_IMPLICIT
488 /*
489 * If maximum number of files is not explicitly defined in
490 * kernel config, adjust the number so that it is somewhat
491 * more reasonable on machines with larger memory sizes.
492 * Arbitrary numbers are 20,000 files for 16GB RAM or more
493 * and 10,000 files for 1GB RAM or more.
494 *
495 * XXXtodo: adjust this and other values totally dynamically
496 */
497 if (ctob((uint64_t)physmem) >= 16ULL * 1024 * 1024 * 1024)
498 maxfiles = MAX(maxfiles, 20000);
499 if (ctob((uint64_t)physmem) >= 1024 * 1024 * 1024)
500 maxfiles = MAX(maxfiles, 10000);
501 #endif /* MAXFILES_IMPLICIT */
502
503 /* Initialize fstrans. */
504 fstrans_init();
505
506 vfsinit();
507 lf_init();
508
509 /* Initialize the file descriptor system. */
510 fd_sys_init();
511
512 /* Initialize cwd structures */
513 cwd_sys_init();
514
515 /* Initialize kqueue. */
516 kqueue_init();
517
518 inittimecounter();
519 ntp_init();
520
521 /* Initialize tty subsystem. */
522 tty_init();
523 ttyldisc_init();
524
525 /* Initialize the buffer cache, part 2. */
526 bufinit2();
527
528 /* Initialize the disk wedge subsystem. */
529 dkwedge_init();
530
531 /* Initialize pfil */
532 pfil_init();
533
534 /* Initialize interfaces. */
535 ifinit1();
536
537 spldebug_start();
538
539 /* Initialize sockets thread(s) */
540 soinit1();
541
542 /*
543 * Initialize the bufq strategy sub-system and any built-in
544 * strategy modules - they may be needed by some devices during
545 * auto-configuration
546 */
547 bufq_init();
548 module_init_class(MODULE_CLASS_BUFQ);
549
550 /* Configure the system hardware. This will enable interrupts. */
551 configure();
552 #ifdef __HAVE_LEGACY_INTRCNT
553 evcnt_attach_legacy_intrcnt();
554 #endif
555
556 /* Enable deferred processing of RNG samples */
557 rnd_init_softint();
558
559 /* Once all CPUs are detected, initialize the per-CPU cprng_fast. */
560 cprng_fast_init();
561
562 #ifdef HEARTBEAT
563 /*
564 * Now that softints can be established, start monitoring
565 * system heartbeat on all CPUs.
566 */
567 heartbeat_start();
568 #endif
569
570 ssp_init();
571
572 ubc_init(); /* must be after autoconfig */
573
574 mm_init();
575
576 configure2();
577
578 /* Initialize the rest of ipi(9) after CPUs have been detected. */
579 ipi_percpu_init();
580
581 futex_sys_init();
582
583 /* Now timer is working. Enable preemption. */
584 kpreempt_enable();
585
586 /* Get the threads going and into any sleeps before continuing. */
587 yield();
588
589 vmem_rehash_start(); /* must be before exec_init */
590
591 /* Initialize exec structures */
592 exec_init(1); /* seminit calls exithook_establish() */
593
594 #if NVERIEXEC > 0
595 /*
596 * Initialise the Veriexec subsystem.
597 */
598 veriexec_init();
599 #endif /* NVERIEXEC > 0 */
600
601 pax_init();
602
603 #ifdef IPSEC
604 /* Attach network crypto subsystem */
605 ipsec_attach();
606 #endif
607
608 /*
609 * Initialize protocols. Block reception of incoming packets
610 * until everything is ready.
611 */
612 s = splnet();
613 ifinit();
614 #if defined(INET) || defined(INET6)
615 lltableinit();
616 #endif
617 domaininit(true);
618 ifinit_post();
619 if_attachdomain();
620 splx(s);
621
622 #ifdef GPROF
623 /* Initialize kernel profiling. */
624 kmstartup();
625 #endif
626
627 /* Initialize system accounting. */
628 acct_init();
629
630 #ifndef PIPE_SOCKETPAIR
631 /* Initialize pipes. */
632 pipe_init();
633 #endif
634
635 #ifdef KTRACE
636 /* Initialize ktrace. */
637 ktrinit();
638 #endif
639
640 machdep_init();
641
642 procinit_sysctl();
643
644 scdebug_init();
645
646 /*
647 * Create process 1 (init(8)). We do this now, as Unix has
648 * historically had init be process 1, and changing this would
649 * probably upset a lot of people.
650 *
651 * Note that process 1 won't immediately exec init(8), but will
652 * wait for us to inform it that the root file system has been
653 * mounted.
654 */
655 if (fork1(l, 0, SIGCHLD, NULL, 0, start_init, NULL, NULL))
656 panic("fork init");
657
658 /*
659 * The initproc variable cannot be initialized in start_init as there
660 * is a race between vfs_mountroot and start_init.
661 */
662 mutex_enter(&proc_lock);
663 initproc = proc_find_raw(1);
664 mutex_exit(&proc_lock);
665
666 /*
667 * Load any remaining builtin modules, and hand back temporary
668 * storage to the VM system. Then require force when loading any
669 * remaining un-init'ed built-in modules to avoid later surprises.
670 */
671 module_init_class(MODULE_CLASS_ANY);
672 module_builtin_require_force();
673
674 /*
675 * Finalize configuration now that all real devices have been
676 * found. This needs to be done before the root device is
677 * selected, since finalization may create the root device.
678 */
679 config_finalize();
680
681 sysctl_finalize();
682
683 /*
684 * Now that autoconfiguration has completed, we can determine
685 * the root and dump devices.
686 */
687 cpu_rootconf();
688 cpu_dumpconf();
689
690 /* Mount the root file system. */
691 do {
692 domountroothook(root_device);
693 if ((error = vfs_mountroot())) {
694 printf("cannot mount root, error = %d\n", error);
695 boothowto |= RB_ASKNAME;
696 setroot(root_device,
697 (rootdev != NODEV) ? DISKPART(rootdev) : 0);
698 }
699 } while (error != 0);
700 mountroothook_destroy();
701
702 configure3();
703
704 /*
705 * Initialise the time-of-day clock, passing the time recorded
706 * in the root filesystem (if any) for use by systems that
707 * don't have a non-volatile time-of-day device.
708 */
709 inittodr(rootfstime);
710
711 /*
712 * Now can look at time, having had a chance to verify the time
713 * from the file system. Reset l->l_rtime as it may have been
714 * munched in mi_switch() after the time got set.
715 */
716 getnanotime(&time);
717
718 mutex_enter(&proc_lock);
719 LIST_FOREACH(p, &allproc, p_list) {
720 KASSERT((p->p_flag & PK_MARKER) == 0);
721 mutex_enter(p->p_lock);
722 TIMESPEC_TO_TIMEVAL(&p->p_stats->p_start, &time);
723 LIST_FOREACH(l, &p->p_lwps, l_sibling) {
724 lwp_lock(l);
725 memset(&l->l_rtime, 0, sizeof(l->l_rtime));
726 lwp_unlock(l);
727 }
728 mutex_exit(p->p_lock);
729 }
730 mutex_exit(&proc_lock);
731 binuptime(&curlwp->l_stime);
732
733 for (CPU_INFO_FOREACH(cii, ci)) {
734 ci->ci_schedstate.spc_lastmod = time_second;
735 }
736
737 /* Create the pageout daemon kernel thread. */
738 uvm_swap_init();
739 if (kthread_create(PRI_PGDAEMON, KTHREAD_MPSAFE, NULL, uvm_pageout,
740 NULL, NULL, "pgdaemon"))
741 panic("fork pagedaemon");
742
743 /* Create the filesystem syncer kernel thread. */
744 if (kthread_create(PRI_IOFLUSH, KTHREAD_MPSAFE, NULL, sched_sync,
745 NULL, NULL, "ioflush"))
746 panic("fork syncer");
747
748 /* Wait for final configure threads to complete. */
749 config_finalize_mountroot();
750
751 /*
752 * Okay, now we can let init(8) exec! It's off to userland!
753 */
754 mutex_enter(&proc_lock);
755 start_init_exec = 1;
756 cv_broadcast(&lbolt);
757 mutex_exit(&proc_lock);
758
759 /* The scheduler is an infinite loop. */
760 uvm_scheduler();
761 /* NOTREACHED */
762 }
763
764 /*
765 * Configure the system's hardware.
766 */
767 static void
configure(void)768 configure(void)
769 {
770
771 /*
772 * XXX
773 * callout_setfunc() requires mutex(9) so it can't be in config_init()
774 * on amiga and atari which use config_init() and autoconf(9) functions
775 * to initialize console devices.
776 */
777 config_twiddle_init();
778
779 pmf_init();
780
781 /* Initialize driver modules */
782 module_init_class(MODULE_CLASS_DRIVER);
783
784 userconf_init();
785 if (boothowto & RB_USERCONF)
786 userconf_prompt();
787
788 if ((boothowto & (AB_SILENT|AB_VERBOSE)) == AB_SILENT) {
789 printf_nolog("Detecting hardware...");
790 }
791
792 /*
793 * Do the machine-dependent portion of autoconfiguration. This
794 * sets the configuration machinery here in motion by "finding"
795 * the root bus. When this function returns, we expect interrupts
796 * to be enabled.
797 */
798 cpu_configure();
799 }
800
801 static void
configure2(void)802 configure2(void)
803 {
804 CPU_INFO_ITERATOR cii;
805 struct cpu_info *ci;
806 int s;
807
808 /* Fix up CPU topology info, which has all been collected by now. */
809 cpu_topology_init();
810
811 /*
812 * Now that we've found all the hardware, start the real time
813 * and statistics clocks.
814 */
815 initclocks();
816
817 cold = 0; /* clocks are running, we're warm now! */
818 s = splsched();
819 curcpu()->ci_schedstate.spc_flags |= SPCF_RUNNING;
820 splx(s);
821
822 /* Setup the runqueues and scheduler. */
823 runq_init();
824 synch_init();
825
826 /* Boot the secondary processors. */
827 for (CPU_INFO_FOREACH(cii, ci)) {
828 uvm_cpu_attach(ci);
829 }
830
831 /* Decide how to partition free memory. */
832 uvm_page_rebucket();
833
834 mp_online = true;
835 #if defined(MULTIPROCESSOR)
836 cpu_boot_secondary_processors();
837 #endif
838
839 /*
840 * Bus scans can make it appear as if the system has paused, so
841 * twiddle constantly while config_interrupts() jobs are running.
842 */
843 config_twiddle_fn(NULL);
844
845 /*
846 * Create threads to call back and finish configuration for
847 * devices that want interrupts enabled.
848 */
849 config_create_interruptthreads();
850 }
851
852 static void
configure3(void)853 configure3(void)
854 {
855
856 /*
857 * Create threads to call back and finish configuration for
858 * devices that want the mounted root file system.
859 */
860 config_create_mountrootthreads();
861
862 /* Get the threads going and into any sleeps before continuing. */
863 yield();
864 }
865
866 static void
rootconf_handle_wedges(void)867 rootconf_handle_wedges(void)
868 {
869 struct disklabel label;
870 struct partition *p;
871 struct vnode *vp;
872 daddr_t startblk;
873 uint64_t nblks;
874 device_t dev;
875 int error;
876
877 if (booted_nblks) {
878 /*
879 * bootloader passed geometry
880 */
881 dev = booted_device;
882 startblk = booted_startblk;
883 nblks = booted_nblks;
884
885 /*
886 * keep booted_device and booted_partition
887 * in case the kernel doesn't identify a wedge
888 */
889 } else {
890 /*
891 * bootloader passed partition number
892 *
893 * We cannot ask the partition device directly when it is
894 * covered by a wedge. Instead we look up the geometry in
895 * the disklabel.
896 */
897 vp = opendisk(booted_device);
898
899 if (vp == NULL)
900 return;
901
902 VOP_UNLOCK(vp);
903 error = VOP_IOCTL(vp, DIOCGDINFO, &label, FREAD, NOCRED);
904 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
905 VOP_CLOSE(vp, FREAD, NOCRED);
906 vput(vp);
907 if (error)
908 return;
909
910 KASSERT(booted_partition >= 0
911 && booted_partition < MAXPARTITIONS);
912
913 p = &label.d_partitions[booted_partition];
914
915 dev = booted_device;
916 startblk = p->p_offset;
917 nblks = p->p_size;
918 }
919
920 dev = dkwedge_find_partition(dev, startblk, nblks);
921 if (dev != NULL) {
922 booted_device = dev;
923 booted_partition = 0;
924 }
925 }
926
927 void
rootconf(void)928 rootconf(void)
929 {
930 if (booted_device != NULL)
931 rootconf_handle_wedges();
932
933 setroot(booted_device, booted_partition);
934 }
935
936 static void
check_console(struct lwp * l)937 check_console(struct lwp *l)
938 {
939 struct vnode *vp;
940 int error;
941
942 error = namei_simple_kernel("/dev/console",
943 NSM_FOLLOW_NOEMULROOT, &vp);
944 if (error == 0) {
945 vrele(vp);
946 } else if (error == ENOENT) {
947 if (boothowto & (AB_VERBOSE|AB_DEBUG))
948 printf("warning: no /dev/console\n");
949 } else {
950 printf("warning: lookup /dev/console: error %d\n", error);
951 }
952 }
953
954 /*
955 * List of paths to try when searching for "init".
956 */
957 static const char * const initpaths[] = {
958 "/sbin/init",
959 "/sbin/oinit",
960 "/sbin/init.bak",
961 "/rescue/init",
962 NULL,
963 };
964
965 /*
966 * Start the initial user process; try exec'ing each pathname in "initpaths".
967 * The program is invoked with one argument containing the boot flags.
968 */
969 static void
start_init(void * arg)970 start_init(void *arg)
971 {
972 struct lwp *l = arg;
973 struct proc *p = l->l_proc;
974 vaddr_t addr;
975 struct sys_execve_args /* {
976 syscallarg(const char *) path;
977 syscallarg(char * const *) argp;
978 syscallarg(char * const *) envp;
979 } */ args;
980 int options, i, error;
981 register_t retval[2];
982 char flags[4], *flagsp;
983 const char *path, *slash;
984 char *ucp, **uap, *arg0, *arg1, *argv[3];
985 char ipath[129];
986 int ipx, len;
987
988 /*
989 * Now in process 1.
990 */
991 strncpy(p->p_comm, "init", MAXCOMLEN);
992
993 /*
994 * Wait for main() to tell us that it's safe to exec.
995 */
996 mutex_enter(&proc_lock);
997 while (start_init_exec == 0)
998 cv_wait(&lbolt, &proc_lock);
999 mutex_exit(&proc_lock);
1000
1001 /*
1002 * This is not the right way to do this. We really should
1003 * hand-craft a descriptor onto /dev/console to hand to init,
1004 * but that's a _lot_ more work, and the benefit from this easy
1005 * hack makes up for the "good is the enemy of the best" effect.
1006 */
1007 check_console(l);
1008
1009 /*
1010 * Need just enough stack to hold the faked-up "execve()" arguments.
1011 */
1012 addr = (vaddr_t)STACK_ALLOC(USRSTACK, PAGE_SIZE);
1013 if (uvm_map(&p->p_vmspace->vm_map, &addr, PAGE_SIZE,
1014 NULL, UVM_UNKNOWN_OFFSET, 0,
1015 UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_RW, UVM_INH_COPY,
1016 UVM_ADV_NORMAL,
1017 UVM_FLAG_FIXED|UVM_FLAG_OVERLAY|UVM_FLAG_COPYONW)) != 0)
1018 panic("init: couldn't allocate argument space");
1019 p->p_vmspace->vm_maxsaddr = (void *)STACK_MAX(addr, PAGE_SIZE);
1020
1021 ipx = 0;
1022 while (1) {
1023 if (boothowto & RB_ASKNAME) {
1024 printf("init path");
1025 if (initpaths[ipx])
1026 printf(" (default %s)", initpaths[ipx]);
1027 printf(": ");
1028 len = cngetsn(ipath, sizeof(ipath)-1);
1029 if (len == 4 && strcmp(ipath, "halt") == 0) {
1030 kern_reboot(RB_HALT, NULL);
1031 } else if (len == 6 && strcmp(ipath, "reboot") == 0) {
1032 kern_reboot(0, NULL);
1033 #if defined(DDB)
1034 } else if (len == 3 && strcmp(ipath, "ddb") == 0) {
1035 console_debugger();
1036 continue;
1037 #endif
1038 } else if (len > 0 && ipath[0] == '/') {
1039 ipath[len] = '\0';
1040 path = ipath;
1041 } else if (len == 0 && initpaths[ipx] != NULL) {
1042 path = initpaths[ipx++];
1043 } else {
1044 printf("use absolute path, ");
1045 #if defined(DDB)
1046 printf("\"ddb\", ");
1047 #endif
1048 printf("\"halt\", or \"reboot\"\n");
1049 continue;
1050 }
1051 } else {
1052 if ((path = initpaths[ipx++]) == NULL) {
1053 ipx = 0;
1054 boothowto |= RB_ASKNAME;
1055 continue;
1056 }
1057 }
1058
1059 ucp = (char *)USRSTACK;
1060
1061 /*
1062 * Construct the boot flag argument.
1063 */
1064 flagsp = flags;
1065 *flagsp++ = '-';
1066 options = 0;
1067
1068 if (boothowto & RB_SINGLE) {
1069 *flagsp++ = 's';
1070 options = 1;
1071 }
1072 #ifdef notyet
1073 if (boothowto & RB_FASTBOOT) {
1074 *flagsp++ = 'f';
1075 options = 1;
1076 }
1077 #endif
1078
1079 /*
1080 * Move out the flags (arg 1), if necessary.
1081 */
1082 if (options != 0) {
1083 *flagsp++ = '\0';
1084 i = flagsp - flags;
1085 #ifdef DEBUG
1086 aprint_normal("init: copying out flags `%s' %d\n", flags, i);
1087 #endif
1088 arg1 = STACK_ALLOC(ucp, i);
1089 ucp = STACK_MAX(arg1, i);
1090 if ((error = copyout((void *)flags, arg1, i)) != 0)
1091 goto copyerr;
1092 } else
1093 arg1 = NULL;
1094
1095 /*
1096 * Move out the file name (also arg 0).
1097 */
1098 i = strlen(path) + 1;
1099 #ifdef DEBUG
1100 aprint_normal("init: copying out path `%s' %d\n", path, i);
1101 #else
1102 if (boothowto & RB_ASKNAME || path != initpaths[0])
1103 printf("init: trying %s\n", path);
1104 #endif
1105 arg0 = STACK_ALLOC(ucp, i);
1106 ucp = STACK_MAX(arg0, i);
1107 if ((error = copyout(path, arg0, i)) != 0)
1108 goto copyerr;
1109
1110 /*
1111 * Move out the arg pointers.
1112 */
1113 ucp = (void *)STACK_ALIGN(ucp, STACK_ALIGNBYTES);
1114 uap = (char **)STACK_ALLOC(ucp, sizeof(argv));
1115 SCARG(&args, path) = arg0;
1116 SCARG(&args, argp) = uap;
1117 SCARG(&args, envp) = NULL;
1118 slash = strrchr(path, '/');
1119
1120 argv[0] = slash ? arg0 + (slash + 1 - path) : arg0;
1121 argv[1] = arg1;
1122 argv[2] = NULL;
1123 if ((error = copyout(argv, uap, sizeof(argv))) != 0)
1124 goto copyerr;
1125
1126 /*
1127 * Now try to exec the program. If it can't for any reason
1128 * other than it doesn't exist, complain.
1129 */
1130 error = sys_execve(l, &args, retval);
1131 if (error == 0 || error == EJUSTRETURN) {
1132 KERNEL_UNLOCK_LAST(l);
1133 return;
1134 }
1135 printf("exec %s: error %d\n", path, error);
1136 }
1137 printf("init: not found\n");
1138 panic("no init");
1139 copyerr:
1140 panic("copyout %d", error);
1141 }
1142
1143 /*
1144 * calculate cache size (in bytes) from physmem and vsize.
1145 */
1146 vaddr_t
calc_cache_size(vsize_t vsize,int pct,int va_pct)1147 calc_cache_size(vsize_t vsize, int pct, int va_pct)
1148 {
1149 paddr_t t;
1150
1151 /* XXX should consider competing cache if any */
1152 /* XXX should consider submaps */
1153 t = (uintmax_t)physmem * pct / 100 * PAGE_SIZE;
1154 if (vsize != 0) {
1155 vsize = (uintmax_t)vsize * va_pct / 100;
1156 if (t > vsize) {
1157 t = vsize;
1158 }
1159 }
1160 return t;
1161 }
1162
1163 /*
1164 * Print the system start up banner.
1165 *
1166 * - Print a limited banner if AB_SILENT.
1167 * - Always send normal banner to the log.
1168 */
1169 #define MEM_PBUFSIZE sizeof("99999 MB")
1170
1171 void
banner(void)1172 banner(void)
1173 {
1174 static char notice[] = " Notice: this software is "
1175 "protected by copyright";
1176 char pbuf[81];
1177 void (*pr)(const char *, ...) __printflike(1, 2);
1178 int i;
1179
1180 if ((boothowto & AB_SILENT) != 0) {
1181 snprintf(pbuf, sizeof(pbuf), "%s %s (%s)",
1182 ostype, osrelease, kernel_ident);
1183 printf_nolog("%s", pbuf);
1184 for (i = 80 - strlen(pbuf) - sizeof(notice); i > 0; i--)
1185 printf(" ");
1186 printf_nolog("%s\n", notice);
1187 pr = aprint_normal;
1188 } else {
1189 pr = printf;
1190 }
1191
1192 memset(pbuf, 0, sizeof(pbuf));
1193 (*pr)("%s%s", copyright, version);
1194 format_bytes(pbuf, MEM_PBUFSIZE, ctob((uint64_t)physmem));
1195 (*pr)("total memory = %s\n", pbuf);
1196 format_bytes(pbuf, MEM_PBUFSIZE, ctob((uint64_t)uvm_availmem(false)));
1197 (*pr)("avail memory = %s\n", pbuf);
1198 }
1199