xref: /freebsd/sys/kern/init_main.c (revision 74b07c5412065adfab90021f6ded2bdf7304744d)
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_init_path.h"
48 #include "opt_mac.h"
49 
50 #include <sys/param.h>
51 #include <sys/kernel.h>
52 #include <sys/exec.h>
53 #include <sys/file.h>
54 #include <sys/filedesc.h>
55 #include <sys/ktr.h>
56 #include <sys/lock.h>
57 #include <sys/mac.h>
58 #include <sys/mount.h>
59 #include <sys/mutex.h>
60 #include <sys/syscallsubr.h>
61 #include <sys/sysctl.h>
62 #include <sys/proc.h>
63 #include <sys/resourcevar.h>
64 #include <sys/systm.h>
65 #include <sys/signalvar.h>
66 #include <sys/vnode.h>
67 #include <sys/sysent.h>
68 #include <sys/reboot.h>
69 #include <sys/sched.h>
70 #include <sys/sx.h>
71 #include <sys/sysproto.h>
72 #include <sys/vmmeter.h>
73 #include <sys/unistd.h>
74 #include <sys/malloc.h>
75 #include <sys/conf.h>
76 
77 #include <machine/cpu.h>
78 
79 #include <security/audit/audit.h>
80 
81 #include <vm/vm.h>
82 #include <vm/vm_param.h>
83 #include <vm/pmap.h>
84 #include <vm/vm_map.h>
85 #include <sys/copyright.h>
86 
87 void mi_startup(void);				/* Should be elsewhere */
88 
89 /* Components of the first process -- never freed. */
90 static struct session session0;
91 static struct pgrp pgrp0;
92 struct	proc proc0;
93 struct	thread thread0 __aligned(8);
94 struct	ksegrp ksegrp0;
95 struct	vmspace vmspace0;
96 struct	proc *initproc;
97 
98 int	boothowto = 0;		/* initialized so that it can be patched */
99 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0, "");
100 int	bootverbose;
101 SYSCTL_INT(_debug, OID_AUTO, bootverbose, CTLFLAG_RW, &bootverbose, 0, "");
102 
103 /*
104  * This ensures that there is at least one entry so that the sysinit_set
105  * symbol is not undefined.  A sybsystem ID of SI_SUB_DUMMY is never
106  * executed.
107  */
108 SYSINIT(placeholder, SI_SUB_DUMMY, SI_ORDER_ANY, NULL, NULL)
109 
110 /*
111  * The sysinit table itself.  Items are checked off as the are run.
112  * If we want to register new sysinit types, add them to newsysinit.
113  */
114 SET_DECLARE(sysinit_set, struct sysinit);
115 struct sysinit **sysinit, **sysinit_end;
116 struct sysinit **newsysinit, **newsysinit_end;
117 
118 /*
119  * Merge a new sysinit set into the current set, reallocating it if
120  * necessary.  This can only be called after malloc is running.
121  */
122 void
123 sysinit_add(struct sysinit **set, struct sysinit **set_end)
124 {
125 	struct sysinit **newset;
126 	struct sysinit **sipp;
127 	struct sysinit **xipp;
128 	int count;
129 
130 	count = set_end - set;
131 	if (newsysinit)
132 		count += newsysinit_end - newsysinit;
133 	else
134 		count += sysinit_end - sysinit;
135 	newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
136 	if (newset == NULL)
137 		panic("cannot malloc for sysinit");
138 	xipp = newset;
139 	if (newsysinit)
140 		for (sipp = newsysinit; sipp < newsysinit_end; sipp++)
141 			*xipp++ = *sipp;
142 	else
143 		for (sipp = sysinit; sipp < sysinit_end; sipp++)
144 			*xipp++ = *sipp;
145 	for (sipp = set; sipp < set_end; sipp++)
146 		*xipp++ = *sipp;
147 	if (newsysinit)
148 		free(newsysinit, M_TEMP);
149 	newsysinit = newset;
150 	newsysinit_end = newset + count;
151 }
152 
153 /*
154  * System startup; initialize the world, create process 0, mount root
155  * filesystem, and fork to create init and pagedaemon.  Most of the
156  * hard work is done in the lower-level initialization routines including
157  * startup(), which does memory initialization and autoconfiguration.
158  *
159  * This allows simple addition of new kernel subsystems that require
160  * boot time initialization.  It also allows substitution of subsystem
161  * (for instance, a scheduler, kernel profiler, or VM system) by object
162  * module.  Finally, it allows for optional "kernel threads".
163  */
164 void
165 mi_startup(void)
166 {
167 
168 	register struct sysinit **sipp;		/* system initialization*/
169 	register struct sysinit **xipp;		/* interior loop of sort*/
170 	register struct sysinit *save;		/* bubble*/
171 
172 	if (sysinit == NULL) {
173 		sysinit = SET_BEGIN(sysinit_set);
174 		sysinit_end = SET_LIMIT(sysinit_set);
175 	}
176 
177 restart:
178 	/*
179 	 * Perform a bubble sort of the system initialization objects by
180 	 * their subsystem (primary key) and order (secondary key).
181 	 */
182 	for (sipp = sysinit; sipp < sysinit_end; sipp++) {
183 		for (xipp = sipp + 1; xipp < sysinit_end; xipp++) {
184 			if ((*sipp)->subsystem < (*xipp)->subsystem ||
185 			     ((*sipp)->subsystem == (*xipp)->subsystem &&
186 			      (*sipp)->order <= (*xipp)->order))
187 				continue;	/* skip*/
188 			save = *sipp;
189 			*sipp = *xipp;
190 			*xipp = save;
191 		}
192 	}
193 
194 	/*
195 	 * Traverse the (now) ordered list of system initialization tasks.
196 	 * Perform each task, and continue on to the next task.
197 	 *
198 	 * The last item on the list is expected to be the scheduler,
199 	 * which will not return.
200 	 */
201 	for (sipp = sysinit; sipp < sysinit_end; sipp++) {
202 
203 		if ((*sipp)->subsystem == SI_SUB_DUMMY)
204 			continue;	/* skip dummy task(s)*/
205 
206 		if ((*sipp)->subsystem == SI_SUB_DONE)
207 			continue;
208 
209 		/* Call function */
210 		(*((*sipp)->func))((*sipp)->udata);
211 
212 		/* Check off the one we're just done */
213 		(*sipp)->subsystem = SI_SUB_DONE;
214 
215 		/* Check if we've installed more sysinit items via KLD */
216 		if (newsysinit != NULL) {
217 			if (sysinit != SET_BEGIN(sysinit_set))
218 				free(sysinit, M_TEMP);
219 			sysinit = newsysinit;
220 			sysinit_end = newsysinit_end;
221 			newsysinit = NULL;
222 			newsysinit_end = NULL;
223 			goto restart;
224 		}
225 	}
226 
227 	panic("Shouldn't get here!");
228 	/* NOTREACHED*/
229 }
230 
231 
232 /*
233  ***************************************************************************
234  ****
235  **** The following SYSINIT's belong elsewhere, but have not yet
236  **** been moved.
237  ****
238  ***************************************************************************
239  */
240 static void
241 print_caddr_t(void *data __unused)
242 {
243 	printf("%s", (char *)data);
244 }
245 SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t, copyright)
246 SYSINIT(version, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t, version)
247 
248 #ifdef WITNESS
249 static char wit_warn[] =
250      "WARNING: WITNESS option enabled, expect reduced performance.\n";
251 SYSINIT(witwarn, SI_SUB_COPYRIGHT, SI_ORDER_SECOND + 1,
252    print_caddr_t, wit_warn)
253 #endif
254 
255 #ifdef DIAGNOSTIC
256 static char diag_warn[] =
257      "WARNING: DIAGNOSTIC option enabled, expect reduced performance.\n";
258 SYSINIT(diagwarn, SI_SUB_COPYRIGHT, SI_ORDER_SECOND + 2,
259     print_caddr_t, diag_warn)
260 #endif
261 
262 static void
263 set_boot_verbose(void *data __unused)
264 {
265 
266 	if (boothowto & RB_VERBOSE)
267 		bootverbose++;
268 }
269 SYSINIT(boot_verbose, SI_SUB_TUNABLES, SI_ORDER_ANY, set_boot_verbose, NULL)
270 
271 struct sysentvec null_sysvec = {
272 	0,
273 	NULL,
274 	0,
275 	0,
276 	NULL,
277 	0,
278 	NULL,
279 	NULL,
280 	NULL,
281 	NULL,
282 	NULL,
283 	NULL,
284 	NULL,
285 	"null",
286 	NULL,
287 	NULL,
288 	0,
289 	PAGE_SIZE,
290 	VM_MIN_ADDRESS,
291 	VM_MAXUSER_ADDRESS,
292 	USRSTACK,
293 	PS_STRINGS,
294 	VM_PROT_ALL,
295 	NULL,
296 	NULL,
297 	NULL
298 };
299 
300 /*
301  ***************************************************************************
302  ****
303  **** The two following SYSINIT's are proc0 specific glue code.  I am not
304  **** convinced that they can not be safely combined, but their order of
305  **** operation has been maintained as the same as the original init_main.c
306  **** for right now.
307  ****
308  **** These probably belong in init_proc.c or kern_proc.c, since they
309  **** deal with proc0 (the fork template process).
310  ****
311  ***************************************************************************
312  */
313 /* ARGSUSED*/
314 static void
315 proc0_init(void *dummy __unused)
316 {
317 	struct proc *p;
318 	unsigned i;
319 	struct thread *td;
320 	struct ksegrp *kg;
321 
322 	GIANT_REQUIRED;
323 	p = &proc0;
324 	td = &thread0;
325 	kg = &ksegrp0;
326 
327 	/*
328 	 * Initialize magic number.
329 	 */
330 	p->p_magic = P_MAGIC;
331 
332 	/*
333 	 * Initialize thread, process and ksegrp structures.
334 	 */
335 	procinit();	/* set up proc zone */
336 	threadinit();	/* set up thead, upcall and KSEGRP zones */
337 
338 	/*
339 	 * Initialise scheduler resources.
340 	 * Add scheduler specific parts to proc, ksegrp, thread as needed.
341 	 */
342 	schedinit();	/* scheduler gets its house in order */
343 	/*
344 	 * Initialize sleep queue hash table
345 	 */
346 	sleepinit();
347 
348 	/*
349 	 * additional VM structures
350 	 */
351 	vm_init2();
352 
353 	/*
354 	 * Create process 0 (the swapper).
355 	 */
356 	LIST_INSERT_HEAD(&allproc, p, p_list);
357 	LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
358 	mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
359 	p->p_pgrp = &pgrp0;
360 	LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
361 	LIST_INIT(&pgrp0.pg_members);
362 	LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
363 
364 	pgrp0.pg_session = &session0;
365 	mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
366 	session0.s_count = 1;
367 	session0.s_leader = p;
368 
369 	p->p_sysent = &null_sysvec;
370 	p->p_flag = P_SYSTEM;
371 	p->p_sflag = PS_INMEM;
372 	p->p_state = PRS_NORMAL;
373 	knlist_init(&p->p_klist, &p->p_mtx, NULL, NULL, NULL);
374 	STAILQ_INIT(&p->p_ktr);
375 	p->p_nice = NZERO;
376 	td->td_state = TDS_RUNNING;
377 	kg->kg_pri_class = PRI_TIMESHARE;
378 	kg->kg_user_pri = PUSER;
379 	td->td_priority = PVM;
380 	td->td_base_pri = PUSER;
381 	td->td_oncpu = 0;
382 	p->p_peers = 0;
383 	p->p_leader = p;
384 
385 
386 	bcopy("swapper", p->p_comm, sizeof ("swapper"));
387 
388 	callout_init(&p->p_itcallout, CALLOUT_MPSAFE);
389 	callout_init(&td->td_slpcallout, CALLOUT_MPSAFE);
390 
391 	/* Create credentials. */
392 	p->p_ucred = crget();
393 	p->p_ucred->cr_ngroups = 1;	/* group 0 */
394 	p->p_ucred->cr_uidinfo = uifind(0);
395 	p->p_ucred->cr_ruidinfo = uifind(0);
396 	p->p_ucred->cr_prison = NULL;	/* Don't jail it. */
397 #ifdef AUDIT
398 	audit_proc_alloc(p);
399 	audit_proc_kproc0(p);
400 #endif
401 #ifdef MAC
402 	mac_create_proc0(p->p_ucred);
403 #endif
404 	td->td_ucred = crhold(p->p_ucred);
405 
406 	/* Create sigacts. */
407 	p->p_sigacts = sigacts_alloc();
408 
409 	/* Initialize signal state for process 0. */
410 	siginit(&proc0);
411 
412 	/* Create the file descriptor table. */
413 	p->p_fd = fdinit(NULL);
414 	p->p_fdtol = NULL;
415 
416 	/* Create the limits structures. */
417 	p->p_limit = lim_alloc();
418 	for (i = 0; i < RLIM_NLIMITS; i++)
419 		p->p_limit->pl_rlimit[i].rlim_cur =
420 		    p->p_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
421 	p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur =
422 	    p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
423 	p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
424 	    p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
425 	i = ptoa(cnt.v_free_count);
426 	p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = i;
427 	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i;
428 	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3;
429 	p->p_cpulimit = RLIM_INFINITY;
430 
431 	p->p_stats = pstats_alloc();
432 
433 	/* Allocate a prototype map so we have something to fork. */
434 	pmap_pinit0(vmspace_pmap(&vmspace0));
435 	p->p_vmspace = &vmspace0;
436 	vmspace0.vm_refcnt = 1;
437 	vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser,
438 	    p->p_sysent->sv_maxuser);
439 	vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
440 
441 	/*
442 	 * Charge root for one process.
443 	 */
444 	(void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
445 }
446 SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL)
447 
448 /* ARGSUSED*/
449 static void
450 proc0_post(void *dummy __unused)
451 {
452 	struct timespec ts;
453 	struct proc *p;
454 
455 	/*
456 	 * Now we can look at the time, having had a chance to verify the
457 	 * time from the filesystem.  Pretend that proc0 started now.
458 	 */
459 	sx_slock(&allproc_lock);
460 	LIST_FOREACH(p, &allproc, p_list) {
461 		microuptime(&p->p_stats->p_start);
462 		p->p_rux.rux_runtime.sec = 0;
463 		p->p_rux.rux_runtime.frac = 0;
464 	}
465 	sx_sunlock(&allproc_lock);
466 	binuptime(PCPU_PTR(switchtime));
467 	PCPU_SET(switchticks, ticks);
468 
469 	/*
470 	 * Give the ``random'' number generator a thump.
471 	 */
472 	nanotime(&ts);
473 	srandom(ts.tv_sec ^ ts.tv_nsec);
474 }
475 SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL)
476 
477 /*
478  ***************************************************************************
479  ****
480  **** The following SYSINIT's and glue code should be moved to the
481  **** respective files on a per subsystem basis.
482  ****
483  ***************************************************************************
484  */
485 
486 
487 /*
488  ***************************************************************************
489  ****
490  **** The following code probably belongs in another file, like
491  **** kern/init_init.c.
492  ****
493  ***************************************************************************
494  */
495 
496 /*
497  * List of paths to try when searching for "init".
498  */
499 static char init_path[MAXPATHLEN] =
500 #ifdef	INIT_PATH
501     __XSTRING(INIT_PATH);
502 #else
503     "/sbin/init:/sbin/oinit:/sbin/init.bak:/rescue/init:/stand/sysinstall";
504 #endif
505 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0,
506 	"Path used to search the init process");
507 
508 /*
509  * Shutdown timeout of init(8).
510  * Unused within kernel, but used to control init(8), hence do not remove.
511  */
512 #ifndef INIT_SHUTDOWN_TIMEOUT
513 #define INIT_SHUTDOWN_TIMEOUT 120
514 #endif
515 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
516 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
517 	CTLFLAG_RW, &init_shutdown_timeout, 0, "");
518 
519 /*
520  * Start the initial user process; try exec'ing each pathname in init_path.
521  * The program is invoked with one argument containing the boot flags.
522  */
523 static void
524 start_init(void *dummy)
525 {
526 	vm_offset_t addr;
527 	struct execve_args args;
528 	int options, error;
529 	char *var, *path, *next, *s;
530 	char *ucp, **uap, *arg0, *arg1;
531 	struct thread *td;
532 	struct proc *p;
533 
534 	mtx_lock(&Giant);
535 
536 	GIANT_REQUIRED;
537 
538 	td = curthread;
539 	p = td->td_proc;
540 
541 	vfs_mountroot();
542 
543 	/*
544 	 * Need just enough stack to hold the faked-up "execve()" arguments.
545 	 */
546 	addr = p->p_sysent->sv_usrstack - PAGE_SIZE;
547 	if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE,
548 			FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
549 		panic("init: couldn't allocate argument space");
550 	p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
551 	p->p_vmspace->vm_ssize = 1;
552 
553 	if ((var = getenv("init_path")) != NULL) {
554 		strlcpy(init_path, var, sizeof(init_path));
555 		freeenv(var);
556 	}
557 
558 	for (path = init_path; *path != '\0'; path = next) {
559 		while (*path == ':')
560 			path++;
561 		if (*path == '\0')
562 			break;
563 		for (next = path; *next != '\0' && *next != ':'; next++)
564 			/* nothing */ ;
565 		if (bootverbose)
566 			printf("start_init: trying %.*s\n", (int)(next - path),
567 			    path);
568 
569 		/*
570 		 * Move out the boot flag argument.
571 		 */
572 		options = 0;
573 		ucp = (char *)p->p_sysent->sv_usrstack;
574 		(void)subyte(--ucp, 0);		/* trailing zero */
575 		if (boothowto & RB_SINGLE) {
576 			(void)subyte(--ucp, 's');
577 			options = 1;
578 		}
579 #ifdef notyet
580                 if (boothowto & RB_FASTBOOT) {
581 			(void)subyte(--ucp, 'f');
582 			options = 1;
583 		}
584 #endif
585 
586 #ifdef BOOTCDROM
587 		(void)subyte(--ucp, 'C');
588 		options = 1;
589 #endif
590 
591 		if (options == 0)
592 			(void)subyte(--ucp, '-');
593 		(void)subyte(--ucp, '-');		/* leading hyphen */
594 		arg1 = ucp;
595 
596 		/*
597 		 * Move out the file name (also arg 0).
598 		 */
599 		(void)subyte(--ucp, 0);
600 		for (s = next - 1; s >= path; s--)
601 			(void)subyte(--ucp, *s);
602 		arg0 = ucp;
603 
604 		/*
605 		 * Move out the arg pointers.
606 		 */
607 		uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1));
608 		(void)suword((caddr_t)--uap, (long)0);	/* terminator */
609 		(void)suword((caddr_t)--uap, (long)(intptr_t)arg1);
610 		(void)suword((caddr_t)--uap, (long)(intptr_t)arg0);
611 
612 		/*
613 		 * Point at the arguments.
614 		 */
615 		args.fname = arg0;
616 		args.argv = uap;
617 		args.envv = NULL;
618 
619 		/*
620 		 * Now try to exec the program.  If can't for any reason
621 		 * other than it doesn't exist, complain.
622 		 *
623 		 * Otherwise, return via fork_trampoline() all the way
624 		 * to user mode as init!
625 		 */
626 		if ((error = execve(td, &args)) == 0) {
627 			mtx_unlock(&Giant);
628 			return;
629 		}
630 		if (error != ENOENT)
631 			printf("exec %.*s: error %d\n", (int)(next - path),
632 			    path, error);
633 	}
634 	printf("init: not found in path %s\n", init_path);
635 	panic("no init");
636 }
637 
638 /*
639  * Like kthread_create(), but runs in it's own address space.
640  * We do this early to reserve pid 1.
641  *
642  * Note special case - do not make it runnable yet.  Other work
643  * in progress will change this more.
644  */
645 static void
646 create_init(const void *udata __unused)
647 {
648 	struct ucred *newcred, *oldcred;
649 	int error;
650 
651 	error = fork1(&thread0, RFFDG | RFPROC | RFSTOPPED, 0, &initproc);
652 	if (error)
653 		panic("cannot fork init: %d\n", error);
654 	KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1"));
655 	/* divorce init's credentials from the kernel's */
656 	newcred = crget();
657 	PROC_LOCK(initproc);
658 	initproc->p_flag |= P_SYSTEM;
659 	oldcred = initproc->p_ucred;
660 	crcopy(newcred, oldcred);
661 #ifdef MAC
662 	mac_create_proc1(newcred);
663 #endif
664 #ifdef AUDIT
665 	audit_proc_init(initproc);
666 #endif
667 	initproc->p_ucred = newcred;
668 	PROC_UNLOCK(initproc);
669 	crfree(oldcred);
670 	cred_update_thread(FIRST_THREAD_IN_PROC(initproc));
671 	mtx_lock_spin(&sched_lock);
672 	initproc->p_sflag |= PS_INMEM;
673 	mtx_unlock_spin(&sched_lock);
674 	cpu_set_fork_handler(FIRST_THREAD_IN_PROC(initproc), start_init, NULL);
675 }
676 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL)
677 
678 /*
679  * Make it runnable now.
680  */
681 static void
682 kick_init(const void *udata __unused)
683 {
684 	struct thread *td;
685 
686 	td = FIRST_THREAD_IN_PROC(initproc);
687 	mtx_lock_spin(&sched_lock);
688 	TD_SET_CAN_RUN(td);
689 	setrunqueue(td, SRQ_BORING);	/* XXXKSE */
690 	mtx_unlock_spin(&sched_lock);
691 }
692 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL)
693