Annotation of sys/kern/init_main.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: init_main.c,v 1.143 2007/07/25 23:11:52 art Exp $ */
2: /* $NetBSD: init_main.c,v 1.84.4.1 1996/06/02 09:08:06 mrg Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Christopher G. Demetriou. All rights reserved.
6: * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
7: * The Regents of the University of California. All rights reserved.
8: * (c) UNIX System Laboratories, Inc.
9: * All or some portions of this file are derived from material licensed
10: * to the University of California by American Telephone and Telegraph
11: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
12: * the permission of UNIX System Laboratories, Inc.
13: *
14: * Redistribution and use in source and binary forms, with or without
15: * modification, are permitted provided that the following conditions
16: * are met:
17: * 1. Redistributions of source code must retain the above copyright
18: * notice, this list of conditions and the following disclaimer.
19: * 2. Redistributions in binary form must reproduce the above copyright
20: * notice, this list of conditions and the following disclaimer in the
21: * documentation and/or other materials provided with the distribution.
22: * 3. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * @(#)init_main.c 8.9 (Berkeley) 1/21/94
39: */
40:
41: #include <sys/param.h>
42: #include <sys/filedesc.h>
43: #include <sys/file.h>
44: #include <sys/errno.h>
45: #include <sys/exec.h>
46: #include <sys/kernel.h>
47: #include <sys/kthread.h>
48: #include <sys/mount.h>
49: #include <sys/proc.h>
50: #include <sys/resourcevar.h>
51: #include <sys/signalvar.h>
52: #include <sys/systm.h>
53: #include <sys/namei.h>
54: #include <sys/vnode.h>
55: #include <sys/tty.h>
56: #include <sys/conf.h>
57: #include <sys/buf.h>
58: #include <sys/device.h>
59: #include <sys/socketvar.h>
60: #include <sys/lockf.h>
61: #include <sys/protosw.h>
62: #include <sys/reboot.h>
63: #include <sys/user.h>
64: #ifdef SYSVSHM
65: #include <sys/shm.h>
66: #endif
67: #ifdef SYSVSEM
68: #include <sys/sem.h>
69: #endif
70: #ifdef SYSVMSG
71: #include <sys/msg.h>
72: #endif
73: #include <sys/domain.h>
74: #include <sys/mbuf.h>
75: #include <sys/pipe.h>
76: #include <sys/workq.h>
77:
78: #include <sys/syscall.h>
79: #include <sys/syscallargs.h>
80:
81: #include <dev/rndvar.h>
82:
83: #include <ufs/ufs/quota.h>
84:
85: #include <machine/cpu.h>
86:
87: #include <uvm/uvm.h>
88:
89: #include <net/if.h>
90: #include <net/raw_cb.h>
91:
92: #if defined(CRYPTO)
93: #include <crypto/cryptodev.h>
94: #include <crypto/cryptosoft.h>
95: #endif
96:
97: #if defined(NFSSERVER) || defined(NFSCLIENT)
98: extern void nfs_init(void);
99: #endif
100:
101: #include "softraid.h"
102:
103: const char copyright[] =
104: "Copyright (c) 1982, 1986, 1989, 1991, 1993\n"
105: "\tThe Regents of the University of California. All rights reserved.\n"
106: "Copyright (c) 1995-2007 OpenBSD. All rights reserved. http://www.OpenBSD.org\n";
107:
108: /* Components of the first process -- never freed. */
109: struct session session0;
110: struct pgrp pgrp0;
111: struct proc proc0;
112: struct process process0;
113: struct pcred cred0;
114: struct plimit limit0;
115: struct vmspace vmspace0;
116: struct sigacts sigacts0;
117: struct proc *initproc;
118:
119: int cmask = CMASK;
120: extern struct user *proc0paddr;
121:
122: struct vnode *rootvp, *swapdev_vp;
123: int boothowto;
124: struct timeval boottime;
125: int ncpus = 1;
126: __volatile int start_init_exec; /* semaphore for start_init() */
127:
128: #if !defined(NO_PROPOLICE)
129: long __guard[8];
130: #endif
131:
132: /* XXX return int so gcc -Werror won't complain */
133: int main(void *);
134: void check_console(struct proc *);
135: void start_init(void *);
136: void start_cleaner(void *);
137: void start_update(void *);
138: void start_reaper(void *);
139: void start_crypto(void *);
140: void init_exec(void);
141: void kqueue_init(void);
142: void workq_init(void);
143:
144: extern char sigcode[], esigcode[];
145: #ifdef SYSCALL_DEBUG
146: extern char *syscallnames[];
147: #endif
148:
149: struct emul emul_native = {
150: "native",
151: NULL,
152: sendsig,
153: SYS_syscall,
154: SYS_MAXSYSCALL,
155: sysent,
156: #ifdef SYSCALL_DEBUG
157: syscallnames,
158: #else
159: NULL,
160: #endif
161: 0,
162: copyargs,
163: setregs,
164: NULL,
165: sigcode,
166: esigcode,
167: EMUL_ENABLED | EMUL_NATIVE,
168: };
169:
170: /*
171: * System startup; initialize the world, create process 0, mount root
172: * filesystem, and fork to create init and pagedaemon. Most of the
173: * hard work is done in the lower-level initialization routines including
174: * startup(), which does memory initialization and autoconfiguration.
175: */
176: /* XXX return int, so gcc -Werror won't complain */
177: int
178: main(void *framep)
179: {
180: struct proc *p;
181: struct pdevinit *pdev;
182: struct timeval rtv;
183: quad_t lim;
184: int s, i;
185: extern struct pdevinit pdevinit[];
186: extern void scheduler_start(void);
187: extern void disk_init(void);
188: extern void endtsleep(void *);
189: extern void realitexpire(void *);
190:
191: /*
192: * Initialize the current process pointer (curproc) before
193: * any possible traps/probes to simplify trap processing.
194: */
195: curproc = p = &proc0;
196: p->p_cpu = curcpu();
197:
198: /*
199: * Initialize timeouts.
200: */
201: timeout_startup();
202:
203: /*
204: * Attempt to find console and initialize
205: * in case of early panic or other messages.
206: */
207: config_init(); /* init autoconfiguration data structures */
208: consinit();
209:
210: printf("%s\n", copyright);
211:
212: KERNEL_LOCK_INIT();
213:
214: uvm_init();
215: disk_init(); /* must come before autoconfiguration */
216: tty_init(); /* initialise tty's */
217: cpu_startup();
218:
219: /*
220: * Initialize mbuf's. Do this now because we might attempt to
221: * allocate mbufs or mbuf clusters during autoconfiguration.
222: */
223: mbinit();
224:
225: /* Initialize sockets. */
226: soinit();
227:
228: /*
229: * Initialize process and pgrp structures.
230: */
231: procinit();
232:
233: /* Initialize file locking. */
234: lf_init();
235:
236: /*
237: * Initialize filedescriptors.
238: */
239: filedesc_init();
240:
241: /*
242: * Initialize pipes.
243: */
244: pipe_init();
245:
246: /*
247: * Initialize kqueues.
248: */
249: kqueue_init();
250:
251: /*
252: * Create process 0 (the swapper).
253: */
254:
255: process0.ps_mainproc = p;
256: TAILQ_INIT(&process0.ps_threads);
257: TAILQ_INSERT_TAIL(&process0.ps_threads, p, p_thr_link);
258: p->p_p = &process0;
259:
260: LIST_INSERT_HEAD(&allproc, p, p_list);
261: p->p_pgrp = &pgrp0;
262: LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
263: LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
264: LIST_INIT(&pgrp0.pg_members);
265: LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
266:
267: pgrp0.pg_session = &session0;
268: session0.s_count = 1;
269: session0.s_leader = p;
270:
271: atomic_setbits_int(&p->p_flag, P_SYSTEM | P_NOCLDWAIT);
272: p->p_stat = SONPROC;
273: p->p_nice = NZERO;
274: p->p_emul = &emul_native;
275: bcopy("swapper", p->p_comm, sizeof ("swapper"));
276:
277: /* Init timeouts. */
278: timeout_set(&p->p_sleep_to, endtsleep, p);
279: timeout_set(&p->p_realit_to, realitexpire, p);
280:
281: /* Create credentials. */
282: cred0.p_refcnt = 1;
283: p->p_cred = &cred0;
284: p->p_ucred = crget();
285: p->p_ucred->cr_ngroups = 1; /* group 0 */
286:
287: /* Initialize signal state for process 0. */
288: signal_init();
289: p->p_sigacts = &sigacts0;
290: siginit(p);
291:
292: /* Create the file descriptor table. */
293: p->p_fd = fdinit(NULL);
294:
295: /* Create the limits structures. */
296: p->p_p->ps_limit = &limit0;
297: for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
298: limit0.pl_rlimit[i].rlim_cur =
299: limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
300: limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;
301: limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = MIN(NOFILE_MAX,
302: (maxfiles - NOFILE > NOFILE) ? maxfiles - NOFILE : NOFILE);
303: limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = MAXUPRC;
304: lim = ptoa(uvmexp.free);
305: limit0.pl_rlimit[RLIMIT_RSS].rlim_max = lim;
306: limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim;
307: limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
308: limit0.p_refcnt = 1;
309:
310: /* Allocate a prototype map so we have something to fork. */
311: uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS),
312: trunc_page(VM_MAX_ADDRESS), TRUE);
313: p->p_vmspace = &vmspace0;
314:
315: p->p_addr = proc0paddr; /* XXX */
316:
317: /*
318: * We continue to place resource usage info in the
319: * user struct so they're pageable.
320: */
321: p->p_stats = &p->p_addr->u_stats;
322:
323: /*
324: * Charge root for one process.
325: */
326: (void)chgproccnt(0, 1);
327:
328: /* Initialize run queues */
329: rqinit();
330:
331: /* Initialize work queues */
332: workq_init();
333:
334: /* Configure the devices */
335: cpu_configure();
336:
337: /* Configure virtual memory system, set vm rlimits. */
338: uvm_init_limits(p);
339:
340: /* Initialize the file systems. */
341: #if defined(NFSSERVER) || defined(NFSCLIENT)
342: nfs_init(); /* initialize server/shared data */
343: #endif
344: vfsinit();
345:
346: /* Start real time and statistics clocks. */
347: initclocks();
348:
349: /* Lock the kernel on behalf of proc0. */
350: KERNEL_PROC_LOCK(p);
351:
352: #ifdef SYSVSHM
353: /* Initialize System V style shared memory. */
354: shminit();
355: #endif
356:
357: #ifdef SYSVSEM
358: /* Initialize System V style semaphores. */
359: seminit();
360: #endif
361:
362: #ifdef SYSVMSG
363: /* Initialize System V style message queues. */
364: msginit();
365: #endif
366:
367: /* Attach pseudo-devices. */
368: randomattach();
369: for (pdev = pdevinit; pdev->pdev_attach != NULL; pdev++)
370: if (pdev->pdev_count > 0)
371: (*pdev->pdev_attach)(pdev->pdev_count);
372:
373: #ifdef CRYPTO
374: swcr_init();
375: #endif /* CRYPTO */
376:
377: /*
378: * Initialize protocols. Block reception of incoming packets
379: * until everything is ready.
380: */
381: s = splnet();
382: ifinit();
383: domaininit();
384: if_attachdomain();
385: splx(s);
386:
387: #ifdef GPROF
388: /* Initialize kernel profiling. */
389: kmstartup();
390: #endif
391:
392: #if !defined(NO_PROPOLICE)
393: {
394: volatile long newguard[8];
395: int i;
396:
397: arc4random_bytes((long *)newguard, sizeof(newguard));
398:
399: for (i = sizeof(__guard)/sizeof(__guard[0]) - 1; i; i--)
400: __guard[i] = newguard[i];
401: }
402: #endif
403:
404: /* init exec and emul */
405: init_exec();
406:
407: /* Start the scheduler */
408: scheduler_start();
409:
410: /*
411: * Create process 1 (init(8)). We do this now, as Unix has
412: * historically had init be process 1, and changing this would
413: * probably upset a lot of people.
414: *
415: * Note that process 1 won't immediately exec init(8), but will
416: * wait for us to inform it that the root file system has been
417: * mounted.
418: */
419: if (fork1(p, SIGCHLD, FORK_FORK, NULL, 0, start_init, NULL, NULL,
420: &initproc))
421: panic("fork init");
422:
423: /*
424: * Create any kernel threads whose creation was deferred because
425: * initproc had not yet been created.
426: */
427: kthread_run_deferred_queue();
428:
429: /*
430: * Now that device driver threads have been created, wait for
431: * them to finish any deferred autoconfiguration. Note we don't
432: * need to lock this semaphore, since we haven't booted any
433: * secondary processors, yet.
434: */
435: while (config_pending)
436: (void) tsleep((void *)&config_pending, PWAIT, "cfpend", 0);
437:
438: dostartuphooks();
439:
440: #if NSOFTRAID > 0
441: config_rootfound("softraid", NULL);
442: #endif
443:
444: /* Configure root/swap devices */
445: diskconf();
446:
447: /* Mount the root file system. */
448: if (vfs_mountroot())
449: panic("cannot mount root");
450: CIRCLEQ_FIRST(&mountlist)->mnt_flag |= MNT_ROOTFS;
451:
452: /* Get the vnode for '/'. Set p->p_fd->fd_cdir to reference it. */
453: if (VFS_ROOT(CIRCLEQ_FIRST(&mountlist), &rootvnode))
454: panic("cannot find root vnode");
455: p->p_fd->fd_cdir = rootvnode;
456: VREF(p->p_fd->fd_cdir);
457: VOP_UNLOCK(rootvnode, 0, p);
458: p->p_fd->fd_rdir = NULL;
459:
460: /*
461: * Now that root is mounted, we can fixup initproc's CWD
462: * info. All other processes are kthreads, which merely
463: * share proc0's CWD info.
464: */
465: initproc->p_fd->fd_cdir = rootvnode;
466: VREF(initproc->p_fd->fd_cdir);
467: initproc->p_fd->fd_rdir = NULL;
468:
469: /*
470: * Now can look at time, having had a chance to verify the time
471: * from the file system. Reset p->p_rtime as it may have been
472: * munched in mi_switch() after the time got set.
473: */
474: #ifdef __HAVE_TIMECOUNTER
475: microtime(&boottime);
476: #else
477: boottime = mono_time = time;
478: #endif
479: LIST_FOREACH(p, &allproc, p_list) {
480: p->p_stats->p_start = boottime;
481: microuptime(&p->p_cpu->ci_schedstate.spc_runtime);
482: p->p_rtime.tv_sec = p->p_rtime.tv_usec = 0;
483: }
484:
485: uvm_swap_init();
486:
487: /* Create the pageout daemon kernel thread. */
488: if (kthread_create(uvm_pageout, NULL, NULL, "pagedaemon"))
489: panic("fork pagedaemon");
490:
491: /* Create the reaper daemon kernel thread. */
492: if (kthread_create(start_reaper, NULL, NULL, "reaper"))
493: panic("fork reaper");
494:
495: /* Create the cleaner daemon kernel thread. */
496: if (kthread_create(start_cleaner, NULL, NULL, "cleaner"))
497: panic("fork cleaner");
498:
499: /* Create the update daemon kernel thread. */
500: if (kthread_create(start_update, NULL, NULL, "update"))
501: panic("fork update");
502:
503: /* Create the aiodone daemon kernel thread. */
504: if (kthread_create(uvm_aiodone_daemon, NULL, NULL, "aiodoned"))
505: panic("fork aiodoned");
506:
507: #ifdef CRYPTO
508: /* Create the crypto kernel thread. */
509: if (kthread_create(start_crypto, NULL, NULL, "crypto"))
510: panic("crypto thread");
511: #endif /* CRYPTO */
512:
513: microtime(&rtv);
514: srandom((u_long)(rtv.tv_sec ^ rtv.tv_usec));
515:
516: randompid = 1;
517:
518: #if defined(MULTIPROCESSOR)
519: /* Boot the secondary processors. */
520: cpu_boot_secondary_processors();
521: #endif
522:
523: domountroothooks();
524:
525: /*
526: * Okay, now we can let init(8) exec! It's off to userland!
527: */
528: start_init_exec = 1;
529: wakeup((void *)&start_init_exec);
530:
531: /* The scheduler is an infinite loop. */
532: uvm_scheduler();
533: /* NOTREACHED */
534: }
535:
536: /*
537: * List of paths to try when searching for "init".
538: */
539: static char *initpaths[] = {
540: "/sbin/init",
541: "/sbin/oinit",
542: "/sbin/init.bak",
543: NULL,
544: };
545:
546: void
547: check_console(struct proc *p)
548: {
549: struct nameidata nd;
550: int error;
551:
552: NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/dev/console", p);
553: error = namei(&nd);
554: if (error) {
555: if (error == ENOENT)
556: printf("warning: /dev/console does not exist\n");
557: else
558: printf("warning: /dev/console error %d\n", error);
559: } else
560: vrele(nd.ni_vp);
561: }
562:
563: /*
564: * Start the initial user process; try exec'ing each pathname in "initpaths".
565: * The program is invoked with one argument containing the boot flags.
566: */
567: void
568: start_init(void *arg)
569: {
570: struct proc *p = arg;
571: vaddr_t addr;
572: struct sys_execve_args /* {
573: syscallarg(const char *) path;
574: syscallarg(char *const *) argp;
575: syscallarg(char *const *) envp;
576: } */ args;
577: int options, error;
578: long i;
579: register_t retval[2];
580: char flags[4], *flagsp;
581: char **pathp, *path, *ucp, **uap, *arg0, *arg1 = NULL;
582:
583: /*
584: * Now in process 1.
585: */
586:
587: /*
588: * Wait for main() to tell us that it's safe to exec.
589: */
590: while (start_init_exec == 0)
591: (void) tsleep((void *)&start_init_exec, PWAIT, "initexec", 0);
592:
593: check_console(p);
594:
595: /*
596: * Need just enough stack to hold the faked-up "execve()" arguments.
597: */
598: #ifdef MACHINE_STACK_GROWS_UP
599: addr = USRSTACK;
600: #else
601: addr = USRSTACK - PAGE_SIZE;
602: #endif
603: if (uvm_map(&p->p_vmspace->vm_map, &addr, PAGE_SIZE,
604: NULL, UVM_UNKNOWN_OFFSET, 0,
605: UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_ALL, UVM_INH_COPY,
606: UVM_ADV_NORMAL, UVM_FLAG_FIXED|UVM_FLAG_OVERLAY|UVM_FLAG_COPYONW)))
607: panic("init: couldn't allocate argument space");
608: p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
609:
610: for (pathp = &initpaths[0]; (path = *pathp) != NULL; pathp++) {
611: #ifdef MACHINE_STACK_GROWS_UP
612: ucp = (char *)addr;
613: #else
614: ucp = (char *)(addr + PAGE_SIZE);
615: #endif
616: /*
617: * Construct the boot flag argument.
618: */
619: flagsp = flags;
620: *flagsp++ = '-';
621: options = 0;
622:
623: if (boothowto & RB_SINGLE) {
624: *flagsp++ = 's';
625: options = 1;
626: }
627: #ifdef notyet
628: if (boothowto & RB_FASTBOOT) {
629: *flagsp++ = 'f';
630: options = 1;
631: }
632: #endif
633:
634: /*
635: * Move out the flags (arg 1), if necessary.
636: */
637: if (options != 0) {
638: *flagsp++ = '\0';
639: i = flagsp - flags;
640: #ifdef DEBUG
641: printf("init: copying out flags `%s' %d\n", flags, i);
642: #endif
643: #ifdef MACHINE_STACK_GROWS_UP
644: arg1 = ucp;
645: (void)copyout((caddr_t)flags, (caddr_t)ucp, i);
646: ucp += i;
647: #else
648: (void)copyout((caddr_t)flags, (caddr_t)(ucp -= i), i);
649: arg1 = ucp;
650: #endif
651: }
652:
653: /*
654: * Move out the file name (also arg 0).
655: */
656: i = strlen(path) + 1;
657: #ifdef DEBUG
658: printf("init: copying out path `%s' %d\n", path, i);
659: #endif
660: #ifdef MACHINE_STACK_GROWS_UP
661: arg0 = ucp;
662: (void)copyout((caddr_t)path, (caddr_t)ucp, i);
663: ucp += i;
664: ucp = (caddr_t)ALIGN((u_long)ucp);
665: uap = (char **)ucp + 3;
666: #else
667: (void)copyout((caddr_t)path, (caddr_t)(ucp -= i), i);
668: arg0 = ucp;
669: uap = (char **)((u_long)ucp & ~ALIGNBYTES);
670: #endif
671:
672: /*
673: * Move out the arg pointers.
674: */
675: i = 0;
676: copyout(&i, (caddr_t)--uap, sizeof(register_t)); /* terminator */
677: if (options != 0)
678: copyout(&arg1, (caddr_t)--uap, sizeof(register_t));
679: copyout(&arg0, (caddr_t)--uap, sizeof(register_t));
680:
681: /*
682: * Point at the arguments.
683: */
684: SCARG(&args, path) = arg0;
685: SCARG(&args, argp) = uap;
686: SCARG(&args, envp) = NULL;
687:
688: /*
689: * Now try to exec the program. If can't for any reason
690: * other than it doesn't exist, complain.
691: */
692: if ((error = sys_execve(p, &args, retval)) == 0) {
693: KERNEL_PROC_UNLOCK(p);
694: return;
695: }
696: if (error != ENOENT)
697: printf("exec %s: error %d\n", path, error);
698: }
699: printf("init: not found\n");
700: panic("no init");
701: }
702:
703: void
704: start_update(void *arg)
705: {
706: sched_sync(curproc);
707: /* NOTREACHED */
708: }
709:
710: void
711: start_cleaner(void *arg)
712: {
713: buf_daemon(curproc);
714: /* NOTREACHED */
715: }
716:
717: void
718: start_reaper(void *arg)
719: {
720: reaper();
721: /* NOTREACHED */
722: }
723:
724: #ifdef CRYPTO
725: void
726: start_crypto(void *arg)
727: {
728: crypto_thread();
729: /* NOTREACHED */
730: }
731: #endif /* CRYPTO */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to init_main.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern