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