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