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. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 *
37 * @(#)init_main.c 8.9 (Berkeley) 1/21/94
38 * $FreeBSD: src/sys/kern/init_main.c,v 1.134.2.8 2003/06/06 20:21:32 tegge Exp $
39 */
40
41 #include "opt_init_path.h"
42
43 #include <sys/param.h>
44 #include <sys/file.h>
45 #include <sys/filedesc.h>
46 #include <sys/kernel.h>
47 #include <sys/mount.h>
48 #include <sys/sysctl.h>
49 #include <sys/proc.h>
50 #include <sys/resourcevar.h>
51 #include <sys/signalvar.h>
52 #include <sys/syscall.h>
53 #include <sys/systm.h>
54 #include <sys/vnode.h>
55 #include <sys/reboot.h>
56 #include <sys/sysmsg.h>
57 #include <sys/vmmeter.h>
58 #include <sys/unistd.h>
59 #include <sys/malloc.h>
60 #include <sys/machintr.h>
61
62 #include <sys/refcount.h>
63 #include <sys/file2.h>
64 #include <sys/thread2.h>
65 #include <sys/spinlock2.h>
66
67 #include <machine/cpu.h>
68
69 #include <vm/vm.h>
70 #include <vm/vm_param.h>
71 #include <sys/lock.h>
72 #include <vm/pmap.h>
73 #include <vm/vm_map.h>
74 #include <vm/vm_extern.h>
75 #include <sys/copyright.h>
76
77 int vfs_mountroot_devfs(void);
78
79 /* Components of the first process -- never freed. */
80 static struct session session0;
81 static struct pgrp pgrp0;
82 static struct sigacts sigacts0;
83 static struct filedesc filedesc0;
84 static struct plimit limit0;
85 static struct vmspace vmspace0;
86 static struct sysreaper initreaper;
87 struct proc *initproc;
88 struct proc proc0;
89 struct lwp lwp0;
90 struct thread thread0;
91 struct sys_kpmap *kpmap;
92
93 int cmask = CMASK;
94 u_int cpu_mi_feature;
95 cpumask_t usched_global_cpumask;
96 extern struct user *proc0paddr;
97
98 int boothowto = 0; /* initialized so that it can be patched */
99 SYSCTL_INT(_debug, OID_AUTO, boothowto, CTLFLAG_RD, &boothowto, 0,
100 "Reboot flags, from console subsystem");
101 SYSCTL_OPAQUE(_kern, OID_AUTO, usched_global_cpumask, CTLFLAG_RW,
102 &usched_global_cpumask, sizeof(usched_global_cpumask), "LU",
103 "global user scheduler cpumask");
104
105 /*
106 * This ensures that there is at least one entry so that the sysinit_set
107 * symbol is not undefined. A subsystem ID of SI_SPECIAL_DUMMY is never
108 * executed.
109 */
110 SYSINIT(placeholder, SI_SPECIAL_DUMMY, SI_ORDER_ANY, NULL, NULL);
111
112 /*
113 * The sysinit table itself. Items are checked off as the are run.
114 * If we want to register new sysinit types, add them to newsysinit.
115 */
116 SET_DECLARE(sysinit_set, struct sysinit);
117 static struct sysinit **sysinit, **sysinit_end;
118 static struct sysinit **newsysinit, **newsysinit_end;
119
120
121 /*
122 * Merge a new sysinit set into the current set, reallocating it if
123 * necessary. This can only be called after malloc is running.
124 */
125 void
sysinit_add(struct sysinit ** set,struct sysinit ** set_end)126 sysinit_add(struct sysinit **set, struct sysinit **set_end)
127 {
128 struct sysinit **newset;
129 struct sysinit **sipp;
130 struct sysinit **xipp;
131 int count;
132
133 count = set_end - set;
134 if (newsysinit)
135 count += newsysinit_end - newsysinit;
136 else
137 count += sysinit_end - sysinit;
138 newset = kmalloc(count * sizeof(*sipp), M_TEMP, M_WAITOK);
139 xipp = newset;
140 if (newsysinit) {
141 for (sipp = newsysinit; sipp < newsysinit_end; sipp++)
142 *xipp++ = *sipp;
143 } else {
144 for (sipp = sysinit; sipp < sysinit_end; sipp++)
145 *xipp++ = *sipp;
146 }
147 for (sipp = set; sipp < set_end; sipp++)
148 *xipp++ = *sipp;
149 if (newsysinit)
150 kfree(newsysinit, M_TEMP);
151 newsysinit = newset;
152 newsysinit_end = newset + count;
153 }
154
155 /*
156 * Callbacks from machine-dependant startup code (e.g. init386) to set
157 * up low level entities related to cpu #0's globaldata.
158 *
159 * Called from very low level boot code.
160 */
161 void
mi_proc0init(struct globaldata * gd,struct user * proc0paddr)162 mi_proc0init(struct globaldata *gd, struct user *proc0paddr)
163 {
164 lwkt_init_thread(&thread0, proc0paddr, LWKT_THREAD_STACK, 0, gd);
165 lwkt_set_comm(&thread0, "thread0");
166 RB_INIT(&proc0.p_lwp_tree);
167 spin_init(&proc0.p_spin, "iproc_proc0");
168 lwkt_token_init(&proc0.p_token, "iproc");
169 lwp0.lwp_tid = 1;
170 proc0.p_lasttid = lwp0.lwp_tid; /* +1 = next TID */
171 lwp_rb_tree_RB_INSERT(&proc0.p_lwp_tree, &lwp0);
172 lwp0.lwp_thread = &thread0;
173 lwp0.lwp_proc = &proc0;
174 proc0.p_usched = usched_init();
175 CPUMASK_ASSALLONES(lwp0.lwp_cpumask);
176 lwkt_token_init(&lwp0.lwp_token, "lwp_token");
177 TAILQ_INIT(&lwp0.lwp_lpmap_backing_list);
178 spin_init(&lwp0.lwp_spin, "iproc_lwp0");
179 varsymset_init(&proc0.p_varsymset, NULL);
180 thread0.td_flags |= TDF_RUNNING;
181 thread0.td_proc = &proc0;
182 thread0.td_lwp = &lwp0;
183 thread0.td_switch = cpu_lwkt_switch;
184 lwkt_schedule_self(curthread);
185 }
186
187 /*
188 * System startup; initialize the world, create process 0, mount root
189 * filesystem, and fork to create init and pagedaemon. Most of the
190 * hard work is done in the lower-level initialization routines including
191 * startup(), which does memory initialization and autoconfiguration.
192 *
193 * This allows simple addition of new kernel subsystems that require
194 * boot time initialization. It also allows substitution of subsystem
195 * (for instance, a scheduler, kernel profiler, or VM system) by object
196 * module. Finally, it allows for optional "kernel threads".
197 */
198 void
mi_startup(void)199 mi_startup(void)
200 {
201 struct sysinit *sip; /* system initialization*/
202 struct sysinit **sipp; /* system initialization*/
203 struct sysinit **xipp; /* interior loop of sort*/
204 struct sysinit *save; /* bubble*/
205
206 if (sysinit == NULL) {
207 sysinit = SET_BEGIN(sysinit_set);
208 #if defined(__x86_64__) && defined(_KERNEL_VIRTUAL)
209 /*
210 * XXX For whatever reason, on 64-bit vkernels
211 * the value of sysinit obtained from the
212 * linker set is wrong.
213 */
214 if ((long)sysinit % 8 != 0) {
215 kprintf("Fixing sysinit value...\n");
216 sysinit = (void *)((long)(intptr_t)sysinit + 4);
217 }
218 #endif
219 sysinit_end = SET_LIMIT(sysinit_set);
220 }
221 #if defined(__x86_64__) && defined(_KERNEL_VIRTUAL)
222 KKASSERT((long)sysinit % 8 == 0);
223 #endif
224
225 restart:
226 /*
227 * Perform a bubble sort of the system initialization objects by
228 * their subsystem (primary key) and order (secondary key).
229 */
230 for (sipp = sysinit; sipp < sysinit_end; sipp++) {
231 for (xipp = sipp + 1; xipp < sysinit_end; xipp++) {
232 if ((*sipp)->subsystem < (*xipp)->subsystem ||
233 ((*sipp)->subsystem == (*xipp)->subsystem &&
234 (*sipp)->order <= (*xipp)->order))
235 continue; /* skip*/
236 save = *sipp;
237 *sipp = *xipp;
238 *xipp = save;
239 }
240 }
241
242 /*
243 * Traverse the (now) ordered list of system initialization tasks.
244 * Perform each task, and continue on to the next task.
245 *
246 * The last item on the list is expected to be the scheduler,
247 * which will not return.
248 */
249 for (sipp = sysinit; sipp < sysinit_end; sipp++) {
250 sip = *sipp;
251 if (sip->subsystem == SI_SPECIAL_DUMMY)
252 continue; /* skip dummy task(s)*/
253
254 if (sip->subsystem == SI_SPECIAL_DONE)
255 continue;
256
257 #if 0
258 if (bootverbose)
259 kprintf("(%08x-%p)\n", sip->subsystem, sip->func);
260 #endif
261
262 /* Call function */
263 (*(sip->func))(sip->udata);
264
265 /* Check off the one we're just done */
266 sip->subsystem = SI_SPECIAL_DONE;
267
268 /* Check if we've installed more sysinit items via KLD */
269 if (newsysinit != NULL) {
270 if (sysinit != SET_BEGIN(sysinit_set))
271 kfree(sysinit, M_TEMP);
272 sysinit = newsysinit;
273 sysinit_end = newsysinit_end;
274 newsysinit = NULL;
275 newsysinit_end = NULL;
276 goto restart;
277 }
278 }
279
280 panic("Shouldn't get here!");
281 /* NOTREACHED*/
282 }
283
284
285 /*
286 ***************************************************************************
287 ****
288 **** The following SYSINIT's belong elsewhere, but have not yet
289 **** been moved.
290 ****
291 ***************************************************************************
292 */
293 static void
print_caddr_t(void * data)294 print_caddr_t(void *data)
295 {
296 kprintf("%s", (char *)data);
297 }
298 SYSINIT(announce, SI_BOOT1_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t, copyright);
299
300 /*
301 * Leave the critical section that protected us from spurious interrupts
302 * so device probes work.
303 */
304 static void
leavecrit(void * dummy __unused)305 leavecrit(void *dummy __unused)
306 {
307 MachIntrABI.stabilize();
308 cpu_enable_intr();
309 MachIntrABI.cleanup();
310 crit_exit();
311 KKASSERT(!IN_CRITICAL_SECT(curthread));
312
313 if (bootverbose)
314 kprintf("Leaving critical section, allowing interrupts\n");
315 }
316 SYSINIT(leavecrit, SI_BOOT2_LEAVE_CRIT, SI_ORDER_ANY, leavecrit, NULL);
317
318 /*
319 * This is called after the threading system is up and running,
320 * including the softclock, clock interrupts, and SMP.
321 */
322 static void
tsleepworks(void * dummy __unused)323 tsleepworks(void *dummy __unused)
324 {
325 tsleep_now_works = 1;
326 }
327 SYSINIT(tsleepworks, SI_BOOT2_FINISH_SMP, SI_ORDER_SECOND, tsleepworks, NULL);
328
329 /*
330 * This is called after devices have configured. Tell the kernel we are
331 * no longer in cold boot.
332 */
333 static void
endofcoldboot(void * dummy __unused)334 endofcoldboot(void *dummy __unused)
335 {
336 cold = 0;
337 }
338 SYSINIT(endofcoldboot, SI_SUB_ISWARM, SI_ORDER_ANY, endofcoldboot, NULL);
339
340 struct sysentvec null_sysvec = {
341 .sv_size = SYS_MAXSYSCALL,
342 .sv_table = sysent,
343 .sv_sigsize = 0,
344 .sv_sigtbl = NULL,
345 .sv_errsize = 0,
346 .sv_errtbl = NULL,
347 .sv_transtrap = NULL,
348 .sv_fixup = NULL,
349 .sv_sendsig = sendsig,
350 .sv_sigcode = sigcode,
351 .sv_szsigcode = &szsigcode,
352 .sv_name = "null",
353 .sv_coredump = NULL,
354 .sv_imgact_try = NULL,
355 .sv_minsigstksz = MINSIGSTKSZ
356 };
357
358 /*
359 ***************************************************************************
360 ****
361 **** The two following SYSINT's are proc0 specific glue code. I am not
362 **** convinced that they can not be safely combined, but their order of
363 **** operation has been maintained as the same as the original init_main.c
364 **** for right now.
365 ****
366 **** These probably belong in init_proc.c or kern_proc.c, since they
367 **** deal with proc0 (the fork template process).
368 ****
369 ***************************************************************************
370 */
371 /* ARGSUSED*/
372 static void
proc0_init(void * dummy __unused)373 proc0_init(void *dummy __unused)
374 {
375 struct proc *p;
376 struct lwp *lp;
377 struct uidinfo *uip;
378
379 p = &proc0;
380 lp = &lwp0;
381
382 /*
383 * Initialize osrel
384 */
385 p->p_osrel = osreldate;
386
387 /*
388 * Initialize process and pgrp structures.
389 */
390 procinit();
391
392 /*
393 * additional VM structures
394 */
395 vm_init2();
396
397 /*
398 * Create process 0 (the swapper).
399 */
400 procinsertinit(p);
401 pgrpinsertinit(&pgrp0);
402 LIST_INIT(&pgrp0.pg_members);
403 lwkt_token_init(&pgrp0.pg_token, "pgrp0");
404 refcount_init(&pgrp0.pg_refs, 1);
405 lockinit(&pgrp0.pg_lock, "pgwt0", 0, 0);
406 LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
407
408 pgrp0.pg_session = &session0;
409 session0.s_count = 1;
410 session0.s_leader = p;
411 sessinsertinit(&session0);
412
413 pgref(&pgrp0);
414 p->p_pgrp = &pgrp0;
415
416 p->p_sysent = &null_sysvec;
417
418 p->p_flags = P_SYSTEM;
419 p->p_stat = SACTIVE;
420 lp->lwp_stat = LSRUN;
421 p->p_nice = NZERO;
422 p->p_rtprio.type = RTP_PRIO_NORMAL;
423 p->p_rtprio.prio = 0;
424 lp->lwp_rtprio = p->p_rtprio;
425
426 p->p_peers = NULL;
427 p->p_leader = p;
428
429 bcopy("swapper", p->p_comm, sizeof ("swapper"));
430 bcopy("swapper", thread0.td_comm, sizeof ("swapper"));
431
432 /* Create credentials. */
433 uip = uicreate(0); /* for cr_ruidinfo */
434 uihold(uip); /* for cr_uidinfo */
435 p->p_ucred = crget();
436 p->p_ucred->cr_ruidinfo = uip;
437 p->p_ucred->cr_uidinfo = uip;
438 p->p_ucred->cr_ngroups = 1; /* group 0 */
439 thread0.td_ucred = crhold(p->p_ucred); /* bootstrap fork1() */
440
441 /* Don't jail it */
442 p->p_ucred->cr_prison = NULL;
443
444 /* Create sigacts. */
445 p->p_sigacts = &sigacts0;
446 refcount_init(&p->p_sigacts->ps_refcnt, 1);
447
448 /* Initialize signal state for process 0. */
449 siginit(p);
450
451 /* Create the file descriptor table. */
452 fdinit_bootstrap(p, &filedesc0, cmask);
453
454 /* Create the limits structures. */
455 plimit_init0(&limit0);
456 p->p_limit = &limit0;
457
458 /* Allocate a prototype map so we have something to fork. */
459 pmap_pinit0(vmspace_pmap(&vmspace0));
460 p->p_vmspace = &vmspace0;
461 lp->lwp_vmspace = p->p_vmspace;
462 vmspace_initrefs(&vmspace0);
463 vm_map_init(&vmspace0.vm_map,
464 round_page(VM_MIN_USER_ADDRESS),
465 trunc_page(VM_MAX_USER_ADDRESS),
466 vmspace_pmap(&vmspace0));
467
468 kqueue_init(&lwp0.lwp_kqueue, &filedesc0);
469
470 /*
471 * Charge root for one process.
472 */
473 (void)chgproccnt(p->p_ucred->cr_uidinfo, 1, 0);
474 vm_init_limits(p);
475 }
476 SYSINIT(p0init, SI_BOOT2_PROC0, SI_ORDER_FIRST, proc0_init, NULL);
477
478 static int proc0_post_callback(struct proc *p, void *data __unused);
479
480 /* ARGSUSED*/
481 static void
proc0_post(void * dummy __unused)482 proc0_post(void *dummy __unused)
483 {
484 struct timespec ts;
485
486 /*
487 * Now we can look at the time, having had a chance to verify the
488 * time from the file system. Pretend that proc0 started now.
489 */
490 allproc_scan(proc0_post_callback, NULL, 0);
491
492 /*
493 * Give the ``random'' number generator a thump.
494 * XXX: Does read_random() contain enough bits to be used here ?
495 */
496 nanotime(&ts);
497 skrandom(ts.tv_sec ^ ts.tv_nsec);
498 }
499
500 static int
proc0_post_callback(struct proc * p,void * data __unused)501 proc0_post_callback(struct proc *p, void *data __unused)
502 {
503 microtime(&p->p_start);
504 return(0);
505 }
506
507 SYSINIT(p0post, SI_SUB_PROC0_POST, SI_ORDER_FIRST, proc0_post, NULL);
508
509 /*
510 ***************************************************************************
511 ****
512 **** The following SYSINIT's and glue code should be moved to the
513 **** respective files on a per subsystem basis.
514 ****
515 ***************************************************************************
516 */
517
518
519 /*
520 ***************************************************************************
521 ****
522 **** The following code probably belongs in another file, like
523 **** kern/init_init.c.
524 ****
525 ***************************************************************************
526 */
527
528 /*
529 * List of paths to try when searching for "init".
530 */
531 static char init_path[MAXPATHLEN] =
532 #ifdef INIT_PATH
533 __XSTRING(INIT_PATH);
534 #else
535 "/sbin/init:/sbin/oinit:/sbin/init.bak";
536 #endif
537 SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0, "");
538
539 /*
540 * Shutdown timeout of init(8).
541 * Unused within kernel, but used to control init(8), hence do not remove.
542 */
543 #ifndef INIT_SHUTDOWN_TIMEOUT
544 #define INIT_SHUTDOWN_TIMEOUT 120
545 #endif
546 static int init_shutdown_timeout = INIT_SHUTDOWN_TIMEOUT;
547 SYSCTL_INT(_kern, OID_AUTO, init_shutdown_timeout,
548 CTLFLAG_RW, &init_shutdown_timeout, 0, "Shutdown timeout of init(8). "
549 "Unused within kernel, but used to control init(8)");
550
551 /*
552 * Start the initial user process; try exec'ing each pathname in init_path.
553 * The program is invoked with one argument containing the boot flags.
554 */
555 static void
start_init(void * dummy,struct trapframe * frame)556 start_init(void *dummy, struct trapframe *frame)
557 {
558 vm_offset_t addr;
559 struct sysmsg sysmsg;
560 struct execve_args args;
561 int options, error;
562 char *var, *path, *next, *s;
563 char *ucp, **uap, *arg0, *arg1;
564 struct proc *p;
565 struct lwp *lp;
566 struct mount *mp;
567 struct vnode *vp;
568 char *env;
569
570 /*
571 * This is passed in by the bootloader
572 */
573 env = kgetenv("kernelname");
574 if (env != NULL)
575 strlcpy(kernelname, env, sizeof(kernelname));
576
577 p = curproc;
578
579 lp = ONLY_LWP_IN_PROC(p);
580
581 /* Get the vnode for '/'. Set p->p_fd->fd_cdir to reference it. */
582 mp = mountlist_boot_getfirst();
583 if (VFS_ROOT(mp, &vp))
584 panic("cannot find root vnode");
585 if (mp->mnt_ncmountpt.ncp == NULL) {
586 cache_allocroot(&mp->mnt_ncmountpt, mp, vp);
587 cache_unlock(&mp->mnt_ncmountpt); /* leave ref intact */
588 }
589 p->p_fd->fd_cdir = vp;
590 vref(p->p_fd->fd_cdir);
591 p->p_fd->fd_rdir = vp;
592 vref(p->p_fd->fd_rdir);
593 vfs_cache_setroot(vp, cache_hold(&mp->mnt_ncmountpt));
594 vn_unlock(vp); /* leave ref intact */
595 cache_copy(&mp->mnt_ncmountpt, &p->p_fd->fd_ncdir);
596 cache_copy(&mp->mnt_ncmountpt, &p->p_fd->fd_nrdir);
597
598 kprintf("Mounting devfs\n");
599 vfs_mountroot_devfs();
600
601 /*
602 * Need just enough stack to hold the faked-up "execve()" arguments.
603 */
604 addr = trunc_page(USRSTACK - PAGE_SIZE);
605 error = vm_map_find(&p->p_vmspace->vm_map, NULL, NULL,
606 0, &addr, PAGE_SIZE,
607 PAGE_SIZE, FALSE,
608 VM_MAPTYPE_NORMAL, VM_SUBSYS_INIT,
609 VM_PROT_ALL, VM_PROT_ALL, 0);
610 if (error)
611 panic("init: couldn't allocate argument space");
612 p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
613 p->p_vmspace->vm_ssize = PAGE_SIZE;
614
615 if ((var = kgetenv("init_path")) != NULL) {
616 strncpy(init_path, var, sizeof init_path);
617 init_path[sizeof init_path - 1] = 0;
618 }
619
620 for (path = init_path; *path != '\0'; path = next) {
621 while (*path == ':')
622 path++;
623 if (*path == '\0')
624 break;
625 for (next = path; *next != '\0' && *next != ':'; next++)
626 /* nothing */ ;
627 if (bootverbose)
628 kprintf("start_init: trying %.*s\n", (int)(next - path),
629 path);
630
631 /*
632 * Move out the boot flag argument.
633 */
634 options = 0;
635 ucp = (char *)USRSTACK;
636 (void)subyte(--ucp, 0); /* trailing zero */
637 if (boothowto & RB_SINGLE) {
638 (void)subyte(--ucp, 's');
639 options = 1;
640 }
641 #ifdef notyet
642 if (boothowto & RB_FASTBOOT) {
643 (void)subyte(--ucp, 'f');
644 options = 1;
645 }
646 #endif
647
648 #ifdef BOOTCDROM
649 (void)subyte(--ucp, 'C');
650 options = 1;
651 #endif
652 if (options == 0)
653 (void)subyte(--ucp, '-');
654 (void)subyte(--ucp, '-'); /* leading hyphen */
655 arg1 = ucp;
656
657 /*
658 * Move out the file name (also arg 0).
659 */
660 (void)subyte(--ucp, 0);
661 for (s = next - 1; s >= path; s--)
662 (void)subyte(--ucp, *s);
663 arg0 = ucp;
664
665 /*
666 * Move out the arg pointers.
667 */
668 uap = (char **)(rounddown2((intptr_t)ucp, sizeof(intptr_t)));
669
670 /* terminator */
671 suword64((uint64_t *)(caddr_t)--uap, (uint64_t)0);
672
673 suword64((uint64_t *)(caddr_t)--uap, (uint64_t)(intptr_t)arg1);
674 suword64((uint64_t *)(caddr_t)--uap, (uint64_t)(intptr_t)arg0);
675
676 /*
677 * Point at the arguments.
678 */
679 bzero(&sysmsg, sizeof(sysmsg));
680 args.fname = arg0;
681 args.argv = uap;
682 args.envv = NULL;
683
684 /*
685 * Now try to exec the program. If can't for any reason
686 * other than it doesn't exist, complain.
687 *
688 * Otherwise, return via fork_trampoline() all the way
689 * to user mode as init!
690 *
691 * WARNING! We may have been moved to another cpu after
692 * acquiring the current user process designation. The
693 * MP lock will migrate with us though so we still have to
694 * release it.
695 */
696 if ((error = sys_execve(&sysmsg, &args)) == 0) {
697 lp->lwp_proc->p_usched->acquire_curproc(lp);
698 return;
699 }
700 if (error != ENOENT)
701 kprintf("exec %.*s: error %d\n", (int)(next - path),
702 path, error);
703 }
704 kprintf("init: not found in path %s\n", init_path);
705 panic("no init");
706 }
707
708 /*
709 * Like kthread_create(), but runs in it's own address space.
710 * We do this early to reserve pid 1.
711 *
712 * Note special case - do not make it runnable yet. Other work
713 * in progress will change this more.
714 */
715 static void
create_init(const void * udata __unused)716 create_init(const void *udata __unused)
717 {
718 int error;
719 struct lwp *lp;
720
721 crit_enter();
722 error = fork1(&lwp0, RFFDG | RFPROC, &initproc);
723 if (error)
724 panic("cannot fork init: %d", error);
725 initproc->p_flags |= P_SYSTEM;
726 reaper_init(initproc, &initreaper);
727 lp = ONLY_LWP_IN_PROC(initproc);
728 cpu_set_fork_handler(lp, start_init, NULL);
729 crit_exit();
730 }
731 SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL);
732
733 /*
734 * Make it runnable now.
735 */
736 static void
kick_init(const void * udata __unused)737 kick_init(const void *udata __unused)
738 {
739 start_forked_proc(&lwp0, initproc);
740 }
741 SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL);
742
743 static void
kpmap_init(const void * udata __unused)744 kpmap_init(const void *udata __unused)
745 {
746 kpmap = kmalloc(roundup2(sizeof(*kpmap), PAGE_SIZE),
747 M_TEMP, M_ZERO | M_WAITOK);
748
749 kpmap->header[0].type = UKPTYPE_VERSION;
750 kpmap->header[0].offset = offsetof(struct sys_kpmap, version);
751 kpmap->header[1].type = KPTYPE_UPTICKS;
752 kpmap->header[1].offset = offsetof(struct sys_kpmap, upticks);
753 kpmap->header[2].type = KPTYPE_TS_UPTIME;
754 kpmap->header[2].offset = offsetof(struct sys_kpmap, ts_uptime);
755 kpmap->header[3].type = KPTYPE_TS_REALTIME;
756 kpmap->header[3].offset = offsetof(struct sys_kpmap, ts_realtime);
757 kpmap->header[4].type = KPTYPE_TSC_FREQ;
758 kpmap->header[4].offset = offsetof(struct sys_kpmap, tsc_freq);
759 kpmap->header[5].type = KPTYPE_TICK_FREQ;
760 kpmap->header[5].offset = offsetof(struct sys_kpmap, tick_freq);
761 kpmap->header[6].type = KPTYPE_FAST_GTOD;
762 kpmap->header[6].offset = offsetof(struct sys_kpmap, fast_gtod);
763 kpmap->version = KPMAP_VERSION;
764 }
765 SYSINIT(kpmapinit, SI_BOOT1_POST, SI_ORDER_FIRST, kpmap_init, NULL);
766
767 /*
768 * Machine independant globaldata initialization
769 *
770 * WARNING! Called from early boot, 'mycpu' may not work yet.
771 */
772 void
mi_gdinit(struct globaldata * gd,int cpuid)773 mi_gdinit(struct globaldata *gd, int cpuid)
774 {
775 TAILQ_INIT(&gd->gd_systimerq);
776 gd->gd_sysid_alloc = cpuid; /* prime low bits for cpu lookup */
777 gd->gd_cpuid = cpuid;
778 CPUMASK_ASSBIT(gd->gd_cpumask, cpuid);
779 gd->gd_cpumask_simple = CPUMASK_SIMPLE(cpuid);
780 gd->gd_cpumask_offset = (uintptr_t)CPUMASK_ADDR(*(cpumask_t *)0, cpuid);
781 lwkt_gdinit(gd);
782 vm_map_entry_reserve_cpu_init(gd);
783 if (gd->gd_cpuid == 0)
784 sleep_early_gdinit(gd);
785 else
786 sleep_gdinit(gd);
787 slab_gdinit(gd);
788 ATOMIC_CPUMASK_ORBIT(usched_global_cpumask, cpuid);
789 gd->gd_vmstats = vmstats;
790 }
791
792