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