xref: /freebsd/sys/kern/init_main.c (revision c9dbb1cc52b063bbd9ab078a7afc89a8696da659)
1 /*-
2  * Copyright (c) 1995 Terrence R. Lambert
3  * All rights reserved.
4  *
5  * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  * (c) UNIX System Laboratories, Inc.
8  * All or some portions of this file are derived from material licensed
9  * to the University of California by American Telephone and Telegraph
10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
11  * the permission of UNIX System Laboratories, Inc.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. All advertising materials mentioning features or use of this software
22  *    must display the following acknowledgement:
23  *	This product includes software developed by the University of
24  *	California, Berkeley and its contributors.
25  * 4. Neither the name of the University nor the names of its contributors
26  *    may be used to endorse or promote products derived from this software
27  *    without specific prior written permission.
28  *
29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39  * SUCH DAMAGE.
40  *
41  *	@(#)init_main.c	8.9 (Berkeley) 1/21/94
42  */
43 
44 #include <sys/cdefs.h>
45 __FBSDID("$FreeBSD$");
46 
47 #include "opt_ddb.h"
48 #include "opt_init_path.h"
49 #include "opt_verbose_sysinit.h"
50 
51 #include <sys/param.h>
52 #include <sys/kernel.h>
53 #include <sys/exec.h>
54 #include <sys/file.h>
55 #include <sys/filedesc.h>
56 #include <sys/jail.h>
57 #include <sys/ktr.h>
58 #include <sys/lock.h>
59 #include <sys/loginclass.h>
60 #include <sys/mount.h>
61 #include <sys/mutex.h>
62 #include <sys/syscallsubr.h>
63 #include <sys/sysctl.h>
64 #include <sys/proc.h>
65 #include <sys/racct.h>
66 #include <sys/resourcevar.h>
67 #include <sys/systm.h>
68 #include <sys/signalvar.h>
69 #include <sys/vnode.h>
70 #include <sys/sysent.h>
71 #include <sys/reboot.h>
72 #include <sys/sched.h>
73 #include <sys/sx.h>
74 #include <sys/sysproto.h>
75 #include <sys/vmmeter.h>
76 #include <sys/unistd.h>
77 #include <sys/malloc.h>
78 #include <sys/conf.h>
79 #include <sys/cpuset.h>
80 
81 #include <machine/cpu.h>
82 
83 #include <security/audit/audit.h>
84 #include <security/mac/mac_framework.h>
85 
86 #include <vm/vm.h>
87 #include <vm/vm_param.h>
88 #include <vm/pmap.h>
89 #include <vm/vm_map.h>
90 #include <vm/vm_domain.h>
91 #include <sys/copyright.h>
92 
93 #include <ddb/ddb.h>
94 #include <ddb/db_sym.h>
95 
96 void mi_startup(void);				/* Should be elsewhere */
97 
98 /* Components of the first process -- never freed. */
99 static struct session session0;
100 static struct pgrp pgrp0;
101 struct	proc proc0;
102 struct	thread thread0 __aligned(16);
103 struct	vmspace vmspace0;
104 struct	proc *initproc;
105 
106 #ifndef BOOTHOWTO
107 #define	BOOTHOWTO	0
108 #endif
109 int	boothowto = BOOTHOWTO;	/* initialized so that it can be patched */
110 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0,
111 	"Boot control flags, passed from loader");
112 
113 #ifndef BOOTVERBOSE
114 #define	BOOTVERBOSE	0
115 #endif
116 int	bootverbose = BOOTVERBOSE;
117 SYSCTL_INT(_debug, OID_AUTO, bootverbose, CTLFLAG_RW, &bootverbose, 0,
118 	"Control the output of verbose kernel messages");
119 
120 #ifdef INVARIANTS
121 FEATURE(invariants, "Kernel compiled with INVARIANTS, may affect performance");
122 #endif
123 
124 /*
125  * This ensures that there is at least one entry so that the sysinit_set
126  * symbol is not undefined.  A sybsystem ID of SI_SUB_DUMMY is never
127  * executed.
128  */
129 SYSINIT(placeholder, SI_SUB_DUMMY, SI_ORDER_ANY, NULL, NULL);
130 
131 /*
132  * The sysinit table itself.  Items are checked off as the are run.
133  * If we want to register new sysinit types, add them to newsysinit.
134  */
135 SET_DECLARE(sysinit_set, struct sysinit);
136 struct sysinit **sysinit, **sysinit_end;
137 struct sysinit **newsysinit, **newsysinit_end;
138 
139 /*
140  * Merge a new sysinit set into the current set, reallocating it if
141  * necessary.  This can only be called after malloc is running.
142  */
143 void
144 sysinit_add(struct sysinit **set, struct sysinit **set_end)
145 {
146 	struct sysinit **newset;
147 	struct sysinit **sipp;
148 	struct sysinit **xipp;
149 	int count;
150 
151 	count = set_end - set;
152 	if (newsysinit)
153 		count += newsysinit_end - newsysinit;
154 	else
155 		count += sysinit_end - sysinit;
156 	newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
157 	if (newset == NULL)
158 		panic("cannot malloc for sysinit");
159 	xipp = newset;
160 	if (newsysinit)
161 		for (sipp = newsysinit; sipp < newsysinit_end; sipp++)
162 			*xipp++ = *sipp;
163 	else
164 		for (sipp = sysinit; sipp < sysinit_end; sipp++)
165 			*xipp++ = *sipp;
166 	for (sipp = set; sipp < set_end; sipp++)
167 		*xipp++ = *sipp;
168 	if (newsysinit)
169 		free(newsysinit, M_TEMP);
170 	newsysinit = newset;
171 	newsysinit_end = newset + count;
172 }
173 
174 #if defined (DDB) && defined(VERBOSE_SYSINIT)
175 static const char *
176 symbol_name(vm_offset_t va, db_strategy_t strategy)
177 {
178 	const char *name;
179 	c_db_sym_t sym;
180 	db_expr_t  offset;
181 
182 	if (va == 0)
183 		return (NULL);
184 	sym = db_search_symbol(va, strategy, &offset);
185 	if (offset != 0)
186 		return (NULL);
187 	db_symbol_values(sym, &name, NULL);
188 	return (name);
189 }
190 #endif
191 
192 /*
193  * System startup; initialize the world, create process 0, mount root
194  * filesystem, and fork to create init and pagedaemon.  Most of the
195  * hard work is done in the lower-level initialization routines including
196  * startup(), which does memory initialization and autoconfiguration.
197  *
198  * This allows simple addition of new kernel subsystems that require
199  * boot time initialization.  It also allows substitution of subsystem
200  * (for instance, a scheduler, kernel profiler, or VM system) by object
201  * module.  Finally, it allows for optional "kernel threads".
202  */
203 void
204 mi_startup(void)
205 {
206 
207 	register struct sysinit **sipp;		/* system initialization*/
208 	register struct sysinit **xipp;		/* interior loop of sort*/
209 	register struct sysinit *save;		/* bubble*/
210 
211 #if defined(VERBOSE_SYSINIT)
212 	int last;
213 	int verbose;
214 #endif
215 
216 	if (boothowto & RB_VERBOSE)
217 		bootverbose++;
218 
219 	if (sysinit == NULL) {
220 		sysinit = SET_BEGIN(sysinit_set);
221 		sysinit_end = SET_LIMIT(sysinit_set);
222 	}
223 
224 restart:
225 	/*
226 	 * Perform a bubble sort of the system initialization objects by
227 	 * their subsystem (primary key) and order (secondary key).
228 	 */
229 	for (sipp = sysinit; sipp < sysinit_end; sipp++) {
230 		for (xipp = sipp + 1; xipp < sysinit_end; xipp++) {
231 			if ((*sipp)->subsystem < (*xipp)->subsystem ||
232 			     ((*sipp)->subsystem == (*xipp)->subsystem &&
233 			      (*sipp)->order <= (*xipp)->order))
234 				continue;	/* skip*/
235 			save = *sipp;
236 			*sipp = *xipp;
237 			*xipp = save;
238 		}
239 	}
240 
241 #if defined(VERBOSE_SYSINIT)
242 	last = SI_SUB_COPYRIGHT;
243 	verbose = 0;
244 #if !defined(DDB)
245 	printf("VERBOSE_SYSINIT: DDB not enabled, symbol lookups disabled.\n");
246 #endif
247 #endif
248 
249 	/*
250 	 * Traverse the (now) ordered list of system initialization tasks.
251 	 * Perform each task, and continue on to the next task.
252 	 */
253 	for (sipp = sysinit; sipp < sysinit_end; sipp++) {
254 
255 		if ((*sipp)->subsystem == SI_SUB_DUMMY)
256 			continue;	/* skip dummy task(s)*/
257 
258 		if ((*sipp)->subsystem == SI_SUB_DONE)
259 			continue;
260 
261 #if defined(VERBOSE_SYSINIT)
262 		if ((*sipp)->subsystem > last) {
263 			verbose = 1;
264 			last = (*sipp)->subsystem;
265 			printf("subsystem %x\n", last);
266 		}
267 		if (verbose) {
268 #if defined(DDB)
269 			const char *func, *data;
270 
271 			func = symbol_name((vm_offset_t)(*sipp)->func,
272 			    DB_STGY_PROC);
273 			data = symbol_name((vm_offset_t)(*sipp)->udata,
274 			    DB_STGY_ANY);
275 			if (func != NULL && data != NULL)
276 				printf("   %s(&%s)... ", func, data);
277 			else if (func != NULL)
278 				printf("   %s(%p)... ", func, (*sipp)->udata);
279 			else
280 #endif
281 				printf("   %p(%p)... ", (*sipp)->func,
282 				    (*sipp)->udata);
283 		}
284 #endif
285 
286 		/* Call function */
287 		(*((*sipp)->func))((*sipp)->udata);
288 
289 #if defined(VERBOSE_SYSINIT)
290 		if (verbose)
291 			printf("done.\n");
292 #endif
293 
294 		/* Check off the one we're just done */
295 		(*sipp)->subsystem = SI_SUB_DONE;
296 
297 		/* Check if we've installed more sysinit items via KLD */
298 		if (newsysinit != NULL) {
299 			if (sysinit != SET_BEGIN(sysinit_set))
300 				free(sysinit, M_TEMP);
301 			sysinit = newsysinit;
302 			sysinit_end = newsysinit_end;
303 			newsysinit = NULL;
304 			newsysinit_end = NULL;
305 			goto restart;
306 		}
307 	}
308 
309 	mtx_assert(&Giant, MA_OWNED | MA_NOTRECURSED);
310 	mtx_unlock(&Giant);
311 
312 	/*
313 	 * Now hand over this thread to swapper.
314 	 */
315 	swapper();
316 	/* NOTREACHED*/
317 }
318 
319 
320 /*
321  ***************************************************************************
322  ****
323  **** The following SYSINIT's belong elsewhere, but have not yet
324  **** been moved.
325  ****
326  ***************************************************************************
327  */
328 static void
329 print_caddr_t(void *data)
330 {
331 	printf("%s", (char *)data);
332 }
333 
334 static void
335 print_version(void *data __unused)
336 {
337 	int len;
338 
339 	/* Strip a trailing newline from version. */
340 	len = strlen(version);
341 	while (len > 0 && version[len - 1] == '\n')
342 		len--;
343 	printf("%.*s %s\n", len, version, machine);
344 	printf("%s\n", compiler_version);
345 }
346 
347 SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t,
348     copyright);
349 SYSINIT(trademark, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t,
350     trademark);
351 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_THIRD, print_version, NULL);
352 
353 #ifdef WITNESS
354 static char wit_warn[] =
355      "WARNING: WITNESS option enabled, expect reduced performance.\n";
356 SYSINIT(witwarn, SI_SUB_COPYRIGHT, SI_ORDER_THIRD + 1,
357    print_caddr_t, wit_warn);
358 SYSINIT(witwarn2, SI_SUB_LAST, SI_ORDER_THIRD + 1,
359    print_caddr_t, wit_warn);
360 #endif
361 
362 #ifdef DIAGNOSTIC
363 static char diag_warn[] =
364      "WARNING: DIAGNOSTIC option enabled, expect reduced performance.\n";
365 SYSINIT(diagwarn, SI_SUB_COPYRIGHT, SI_ORDER_THIRD + 2,
366     print_caddr_t, diag_warn);
367 SYSINIT(diagwarn2, SI_SUB_LAST, SI_ORDER_THIRD + 2,
368     print_caddr_t, diag_warn);
369 #endif
370 
371 static int
372 null_fetch_syscall_args(struct thread *td __unused,
373     struct syscall_args *sa __unused)
374 {
375 
376 	panic("null_fetch_syscall_args");
377 }
378 
379 static void
380 null_set_syscall_retval(struct thread *td __unused, int error __unused)
381 {
382 
383 	panic("null_set_syscall_retval");
384 }
385 
386 struct sysentvec null_sysvec = {
387 	.sv_size	= 0,
388 	.sv_table	= NULL,
389 	.sv_mask	= 0,
390 	.sv_sigsize	= 0,
391 	.sv_sigtbl	= NULL,
392 	.sv_errsize	= 0,
393 	.sv_errtbl	= NULL,
394 	.sv_transtrap	= NULL,
395 	.sv_fixup	= NULL,
396 	.sv_sendsig	= NULL,
397 	.sv_sigcode	= NULL,
398 	.sv_szsigcode	= NULL,
399 	.sv_prepsyscall	= NULL,
400 	.sv_name	= "null",
401 	.sv_coredump	= NULL,
402 	.sv_imgact_try	= NULL,
403 	.sv_minsigstksz	= 0,
404 	.sv_pagesize	= PAGE_SIZE,
405 	.sv_minuser	= VM_MIN_ADDRESS,
406 	.sv_maxuser	= VM_MAXUSER_ADDRESS,
407 	.sv_usrstack	= USRSTACK,
408 	.sv_psstrings	= PS_STRINGS,
409 	.sv_stackprot	= VM_PROT_ALL,
410 	.sv_copyout_strings	= NULL,
411 	.sv_setregs	= NULL,
412 	.sv_fixlimit	= NULL,
413 	.sv_maxssiz	= NULL,
414 	.sv_flags	= 0,
415 	.sv_set_syscall_retval = null_set_syscall_retval,
416 	.sv_fetch_syscall_args = null_fetch_syscall_args,
417 	.sv_syscallnames = NULL,
418 	.sv_schedtail	= NULL,
419 	.sv_thread_detach = NULL,
420 };
421 
422 /*
423  ***************************************************************************
424  ****
425  **** The two following SYSINIT's are proc0 specific glue code.  I am not
426  **** convinced that they can not be safely combined, but their order of
427  **** operation has been maintained as the same as the original init_main.c
428  **** for right now.
429  ****
430  **** These probably belong in init_proc.c or kern_proc.c, since they
431  **** deal with proc0 (the fork template process).
432  ****
433  ***************************************************************************
434  */
435 /* ARGSUSED*/
436 static void
437 proc0_init(void *dummy __unused)
438 {
439 	struct proc *p;
440 	struct thread *td;
441 	struct ucred *newcred;
442 	vm_paddr_t pageablemem;
443 	int i;
444 
445 	GIANT_REQUIRED;
446 	p = &proc0;
447 	td = &thread0;
448 
449 	/*
450 	 * Initialize magic number and osrel.
451 	 */
452 	p->p_magic = P_MAGIC;
453 	p->p_osrel = osreldate;
454 
455 	/*
456 	 * Initialize thread and process structures.
457 	 */
458 	procinit();	/* set up proc zone */
459 	threadinit();	/* set up UMA zones */
460 
461 	/*
462 	 * Initialise scheduler resources.
463 	 * Add scheduler specific parts to proc, thread as needed.
464 	 */
465 	schedinit();	/* scheduler gets its house in order */
466 
467 	/*
468 	 * Create process 0 (the swapper).
469 	 */
470 	LIST_INSERT_HEAD(&allproc, p, p_list);
471 	LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
472 	mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
473 	p->p_pgrp = &pgrp0;
474 	LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
475 	LIST_INIT(&pgrp0.pg_members);
476 	LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
477 
478 	pgrp0.pg_session = &session0;
479 	mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
480 	refcount_init(&session0.s_count, 1);
481 	session0.s_leader = p;
482 
483 	p->p_sysent = &null_sysvec;
484 	p->p_flag = P_SYSTEM | P_INMEM;
485 	p->p_flag2 = 0;
486 	p->p_state = PRS_NORMAL;
487 	knlist_init_mtx(&p->p_klist, &p->p_mtx);
488 	STAILQ_INIT(&p->p_ktr);
489 	p->p_nice = NZERO;
490 	/* pid_max cannot be greater than PID_MAX */
491 	td->td_tid = PID_MAX + 1;
492 	LIST_INSERT_HEAD(TIDHASH(td->td_tid), td, td_hash);
493 	td->td_state = TDS_RUNNING;
494 	td->td_pri_class = PRI_TIMESHARE;
495 	td->td_user_pri = PUSER;
496 	td->td_base_user_pri = PUSER;
497 	td->td_lend_user_pri = PRI_MAX;
498 	td->td_priority = PVM;
499 	td->td_base_pri = PVM;
500 	td->td_oncpu = 0;
501 	td->td_flags = TDF_INMEM;
502 	td->td_pflags = TDP_KTHREAD;
503 	td->td_cpuset = cpuset_thread0();
504 	vm_domain_policy_init(&td->td_vm_dom_policy);
505 	vm_domain_policy_set(&td->td_vm_dom_policy, VM_POLICY_NONE, -1);
506 	vm_domain_policy_init(&p->p_vm_dom_policy);
507 	vm_domain_policy_set(&p->p_vm_dom_policy, VM_POLICY_NONE, -1);
508 	prison0_init();
509 	p->p_peers = 0;
510 	p->p_leader = p;
511 	p->p_reaper = p;
512 	LIST_INIT(&p->p_reaplist);
513 
514 	strncpy(p->p_comm, "kernel", sizeof (p->p_comm));
515 	strncpy(td->td_name, "swapper", sizeof (td->td_name));
516 
517 	callout_init_mtx(&p->p_itcallout, &p->p_mtx, 0);
518 	callout_init_mtx(&p->p_limco, &p->p_mtx, 0);
519 	callout_init(&td->td_slpcallout, 1);
520 
521 	/* Create credentials. */
522 	newcred = crget();
523 	newcred->cr_ngroups = 1;	/* group 0 */
524 	newcred->cr_uidinfo = uifind(0);
525 	newcred->cr_ruidinfo = uifind(0);
526 	newcred->cr_prison = &prison0;
527 	newcred->cr_loginclass = loginclass_find("default");
528 	proc_set_cred_init(p, newcred);
529 #ifdef AUDIT
530 	audit_cred_kproc0(newcred);
531 #endif
532 #ifdef MAC
533 	mac_cred_create_swapper(newcred);
534 #endif
535 	/* Create sigacts. */
536 	p->p_sigacts = sigacts_alloc();
537 
538 	/* Initialize signal state for process 0. */
539 	siginit(&proc0);
540 
541 	/* Create the file descriptor table. */
542 	p->p_fd = fdinit(NULL, false);
543 	p->p_fdtol = NULL;
544 
545 	/* Create the limits structures. */
546 	p->p_limit = lim_alloc();
547 	for (i = 0; i < RLIM_NLIMITS; i++)
548 		p->p_limit->pl_rlimit[i].rlim_cur =
549 		    p->p_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
550 	p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur =
551 	    p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
552 	p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
553 	    p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
554 	p->p_limit->pl_rlimit[RLIMIT_DATA].rlim_cur = dfldsiz;
555 	p->p_limit->pl_rlimit[RLIMIT_DATA].rlim_max = maxdsiz;
556 	p->p_limit->pl_rlimit[RLIMIT_STACK].rlim_cur = dflssiz;
557 	p->p_limit->pl_rlimit[RLIMIT_STACK].rlim_max = maxssiz;
558 	/* Cast to avoid overflow on i386/PAE. */
559 	pageablemem = ptoa((vm_paddr_t)vm_cnt.v_free_count);
560 	p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_cur =
561 	    p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = pageablemem;
562 	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = pageablemem / 3;
563 	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = pageablemem;
564 	p->p_cpulimit = RLIM_INFINITY;
565 
566 	PROC_LOCK(p);
567 	thread_cow_get_proc(td, p);
568 	PROC_UNLOCK(p);
569 
570 	/* Initialize resource accounting structures. */
571 	racct_create(&p->p_racct);
572 
573 	p->p_stats = pstats_alloc();
574 
575 	/* Allocate a prototype map so we have something to fork. */
576 	p->p_vmspace = &vmspace0;
577 	vmspace0.vm_refcnt = 1;
578 	pmap_pinit0(vmspace_pmap(&vmspace0));
579 
580 	/*
581 	 * proc0 is not expected to enter usermode, so there is no special
582 	 * handling for sv_minuser here, like is done for exec_new_vmspace().
583 	 */
584 	vm_map_init(&vmspace0.vm_map, vmspace_pmap(&vmspace0),
585 	    p->p_sysent->sv_minuser, p->p_sysent->sv_maxuser);
586 
587 	/*
588 	 * Call the init and ctor for the new thread and proc.  We wait
589 	 * to do this until all other structures are fairly sane.
590 	 */
591 	EVENTHANDLER_INVOKE(process_init, p);
592 	EVENTHANDLER_INVOKE(thread_init, td);
593 	EVENTHANDLER_INVOKE(process_ctor, p);
594 	EVENTHANDLER_INVOKE(thread_ctor, td);
595 
596 	/*
597 	 * Charge root for one process.
598 	 */
599 	(void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
600 	PROC_LOCK(p);
601 	racct_add_force(p, RACCT_NPROC, 1);
602 	PROC_UNLOCK(p);
603 }
604 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL);
605 
606 /* ARGSUSED*/
607 static void
608 proc0_post(void *dummy __unused)
609 {
610 	struct timespec ts;
611 	struct proc *p;
612 	struct rusage ru;
613 	struct thread *td;
614 
615 	/*
616 	 * Now we can look at the time, having had a chance to verify the
617 	 * time from the filesystem.  Pretend that proc0 started now.
618 	 */
619 	sx_slock(&allproc_lock);
620 	FOREACH_PROC_IN_SYSTEM(p) {
621 		microuptime(&p->p_stats->p_start);
622 		PROC_STATLOCK(p);
623 		rufetch(p, &ru);	/* Clears thread stats */
624 		PROC_STATUNLOCK(p);
625 		p->p_rux.rux_runtime = 0;
626 		p->p_rux.rux_uticks = 0;
627 		p->p_rux.rux_sticks = 0;
628 		p->p_rux.rux_iticks = 0;
629 		FOREACH_THREAD_IN_PROC(p, td) {
630 			td->td_runtime = 0;
631 		}
632 	}
633 	sx_sunlock(&allproc_lock);
634 	PCPU_SET(switchtime, cpu_ticks());
635 	PCPU_SET(switchticks, ticks);
636 
637 	/*
638 	 * Give the ``random'' number generator a thump.
639 	 */
640 	nanotime(&ts);
641 	srandom(ts.tv_sec ^ ts.tv_nsec);
642 }
643 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL);
644 
645 static void
646 random_init(void *dummy __unused)
647 {
648 
649 	/*
650 	 * After CPU has been started we have some randomness on most
651 	 * platforms via get_cyclecount().  For platforms that don't
652 	 * we will reseed random(9) in proc0_post() as well.
653 	 */
654 	srandom(get_cyclecount());
655 }
656 SYSINIT(random, SI_SUB_RANDOM, SI_ORDER_FIRST, random_init, NULL);
657 
658 /*
659  ***************************************************************************
660  ****
661  **** The following SYSINIT's and glue code should be moved to the
662  **** respective files on a per subsystem basis.
663  ****
664  ***************************************************************************
665  */
666 
667 
668 /*
669  ***************************************************************************
670  ****
671  **** The following code probably belongs in another file, like
672  **** kern/init_init.c.
673  ****
674  ***************************************************************************
675  */
676 
677 /*
678  * List of paths to try when searching for "init".
679  */
680 static char init_path[MAXPATHLEN] =
681 #ifdef	INIT_PATH
682     __XSTRING(INIT_PATH);
683 #else
684     "/sbin/init:/sbin/oinit:/sbin/init.bak:/rescue/init";
685 #endif
686 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0,
687 	"Path used to search the init process");
688 
689 /*
690  * Shutdown timeout of init(8).
691  * Unused within kernel, but used to control init(8), hence do not remove.
692  */
693 #ifndef INIT_SHUTDOWN_TIMEOUT
694 #define INIT_SHUTDOWN_TIMEOUT 120
695 #endif
696 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
697 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
698 	CTLFLAG_RW, &init_shutdown_timeout, 0, "Shutdown timeout of init(8). "
699 	"Unused within kernel, but used to control init(8)");
700 
701 /*
702  * Start the initial user process; try exec'ing each pathname in init_path.
703  * The program is invoked with one argument containing the boot flags.
704  */
705 static void
706 start_init(void *dummy)
707 {
708 	vm_offset_t addr;
709 	struct execve_args args;
710 	int options, error;
711 	char *var, *path, *next, *s;
712 	char *ucp, **uap, *arg0, *arg1;
713 	struct thread *td;
714 	struct proc *p;
715 
716 	mtx_lock(&Giant);
717 
718 	GIANT_REQUIRED;
719 
720 	td = curthread;
721 	p = td->td_proc;
722 
723 	vfs_mountroot();
724 
725 	/* Wipe GELI passphrase from the environment. */
726 	kern_unsetenv("kern.geom.eli.passphrase");
727 
728 	/*
729 	 * Need just enough stack to hold the faked-up "execve()" arguments.
730 	 */
731 	addr = p->p_sysent->sv_usrstack - PAGE_SIZE;
732 	if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE, 0,
733 	    VMFS_NO_SPACE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
734 		panic("init: couldn't allocate argument space");
735 	p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
736 	p->p_vmspace->vm_ssize = 1;
737 
738 	if ((var = kern_getenv("init_path")) != NULL) {
739 		strlcpy(init_path, var, sizeof(init_path));
740 		freeenv(var);
741 	}
742 
743 	for (path = init_path; *path != '\0'; path = next) {
744 		while (*path == ':')
745 			path++;
746 		if (*path == '\0')
747 			break;
748 		for (next = path; *next != '\0' && *next != ':'; next++)
749 			/* nothing */ ;
750 		if (bootverbose)
751 			printf("start_init: trying %.*s\n", (int)(next - path),
752 			    path);
753 
754 		/*
755 		 * Move out the boot flag argument.
756 		 */
757 		options = 0;
758 		ucp = (char *)p->p_sysent->sv_usrstack;
759 		(void)subyte(--ucp, 0);		/* trailing zero */
760 		if (boothowto & RB_SINGLE) {
761 			(void)subyte(--ucp, 's');
762 			options = 1;
763 		}
764 #ifdef notyet
765                 if (boothowto & RB_FASTBOOT) {
766 			(void)subyte(--ucp, 'f');
767 			options = 1;
768 		}
769 #endif
770 
771 #ifdef BOOTCDROM
772 		(void)subyte(--ucp, 'C');
773 		options = 1;
774 #endif
775 
776 		if (options == 0)
777 			(void)subyte(--ucp, '-');
778 		(void)subyte(--ucp, '-');		/* leading hyphen */
779 		arg1 = ucp;
780 
781 		/*
782 		 * Move out the file name (also arg 0).
783 		 */
784 		(void)subyte(--ucp, 0);
785 		for (s = next - 1; s >= path; s--)
786 			(void)subyte(--ucp, *s);
787 		arg0 = ucp;
788 
789 		/*
790 		 * Move out the arg pointers.
791 		 */
792 		uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1));
793 		(void)suword((caddr_t)--uap, (long)0);	/* terminator */
794 		(void)suword((caddr_t)--uap, (long)(intptr_t)arg1);
795 		(void)suword((caddr_t)--uap, (long)(intptr_t)arg0);
796 
797 		/*
798 		 * Point at the arguments.
799 		 */
800 		args.fname = arg0;
801 		args.argv = uap;
802 		args.envv = NULL;
803 
804 		/*
805 		 * Now try to exec the program.  If can't for any reason
806 		 * other than it doesn't exist, complain.
807 		 *
808 		 * Otherwise, return via fork_trampoline() all the way
809 		 * to user mode as init!
810 		 */
811 		if ((error = sys_execve(td, &args)) == 0) {
812 			mtx_unlock(&Giant);
813 			return;
814 		}
815 		if (error != ENOENT)
816 			printf("exec %.*s: error %d\n", (int)(next - path),
817 			    path, error);
818 	}
819 	printf("init: not found in path %s\n", init_path);
820 	panic("no init");
821 }
822 
823 /*
824  * Like kproc_create(), but runs in it's own address space.
825  * We do this early to reserve pid 1.
826  *
827  * Note special case - do not make it runnable yet.  Other work
828  * in progress will change this more.
829  */
830 static void
831 create_init(const void *udata __unused)
832 {
833 	struct ucred *newcred, *oldcred;
834 	struct thread *td;
835 	int error;
836 
837 	error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc,
838 	    NULL, 0, NULL);
839 	if (error)
840 		panic("cannot fork init: %d\n", error);
841 	KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1"));
842 	/* divorce init's credentials from the kernel's */
843 	newcred = crget();
844 	sx_xlock(&proctree_lock);
845 	PROC_LOCK(initproc);
846 	initproc->p_flag |= P_SYSTEM | P_INMEM;
847 	initproc->p_treeflag |= P_TREE_REAPER;
848 	LIST_INSERT_HEAD(&initproc->p_reaplist, &proc0, p_reapsibling);
849 	oldcred = initproc->p_ucred;
850 	crcopy(newcred, oldcred);
851 #ifdef MAC
852 	mac_cred_create_init(newcred);
853 #endif
854 #ifdef AUDIT
855 	audit_cred_proc1(newcred);
856 #endif
857 	proc_set_cred(initproc, newcred);
858 	td = FIRST_THREAD_IN_PROC(initproc);
859 	crfree(td->td_ucred);
860 	td->td_ucred = crhold(initproc->p_ucred);
861 	PROC_UNLOCK(initproc);
862 	sx_xunlock(&proctree_lock);
863 	crfree(oldcred);
864 	cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL);
865 }
866 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL);
867 
868 /*
869  * Make it runnable now.
870  */
871 static void
872 kick_init(const void *udata __unused)
873 {
874 	struct thread *td;
875 
876 	td = FIRST_THREAD_IN_PROC(initproc);
877 	thread_lock(td);
878 	TD_SET_CAN_RUN(td);
879 	sched_add(td, SRQ_BORING);
880 	thread_unlock(td);
881 }
882 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_MIDDLE, kick_init, NULL);
883