![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bsd_init.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to bsd_init.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
24: * The Regents of the University of California. All rights reserved.
25: * (c) UNIX System Laboratories, Inc.
26: * All or some portions of this file are derived from material licensed
27: * to the University of California by American Telephone and Telegraph
28: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
29: * the permission of UNIX System Laboratories, Inc.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. All advertising materials mentioning features or use of this software
40: * must display the following acknowledgement:
41: * This product includes software developed by the University of
42: * California, Berkeley and its contributors.
43: * 4. Neither the name of the University nor the names of its contributors
44: * may be used to endorse or promote products derived from this software
45: * without specific prior written permission.
46: *
47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57: * SUCH DAMAGE.
58: *
59: * @(#)init_main.c 8.16 (Berkeley) 5/14/95
60: */
61:
62: /*
63: *
64: * Mach Operating System
65: * Copyright (c) 1987 Carnegie-Mellon University
66: * All rights reserved. The CMU software License Agreement specifies
67: * the terms and conditions for use and redistribution.
68: */
69: /*
70: * HISTORY
71: * 16-Apr-98 A. Ramesh at Apple
72: * Created for Apple Core from DR2 init_main.c.
73: */
74:
75: #include <quota.h>
76:
77: #include <sys/param.h>
78: #include <sys/filedesc.h>
79: #include <sys/kernel.h>
80: #include <sys/mount.h>
81: #include <sys/proc.h>
82: #include <sys/systm.h>
83: #include <sys/vnode.h>
84: #include <sys/conf.h>
85: #include <sys/buf.h>
86: #include <sys/clist.h>
87: #include <sys/user.h>
88: #include <ufs/ufs/quota.h>
89:
90: #include <sys/malloc.h>
91: #include <sys/dkstat.h>
92:
93: #include <machine/spl.h>
94: #include <kern/thread.h>
95: #include <kern/task.h>
96: #include <kern/ast.h>
97:
98: #include <mach/vm_param.h>
99:
100: #include <vm/vm_map.h>
101: #include <vm/vm_kern.h>
102:
103: #include <sys/ux_exception.h>
104:
105: #include <sys/reboot.h>
106: #include <mach/exception_types.h>
107: #include <dev/busvar.h>
108:
109: char copyright[] =
110: "Copyright (c) 1982, 1986, 1989, 1991, 1993\n\tThe Regents of the University of California. All rights reserved.\n\n";
111:
112: extern void ux_handler();
113:
114: /* Components of the first process -- never freed. */
115: struct proc proc0;
116: struct session session0;
117: struct pgrp pgrp0;
118: struct pcred cred0;
119: struct filedesc filedesc0;
120: struct plimit limit0;
121: struct pstats pstats0;
122: struct sigacts sigacts0;
123: struct proc *kernproc, *initproc;
124:
125:
126: long cp_time[CPUSTATES];
127: long dk_seek[DK_NDRIVE];
128: long dk_time[DK_NDRIVE];
129: long dk_wds[DK_NDRIVE];
130: long dk_wpms[DK_NDRIVE];
131: long dk_xfer[DK_NDRIVE];
132: long dk_bps[DK_NDRIVE];
133:
134: int dk_busy;
135: int dk_ndrive;
136:
137: long tk_cancc;
138: long tk_nin;
139: long tk_nout;
140: long tk_rawcc;
141:
142: /* Global variables to make pstat happy. We do swapping differently */
143: int nswdev, nswap;
144: int nswapmap;
145: void *swapmap;
146: struct swdevt swdevt[1];
147:
148: dev_t rootdev; /* device of the root */
149: dev_t dumpdev; /* device to take dumps on */
150: long dumplo; /* offset into dumpdev */
151: long hostid;
152: char hostname[MAXHOSTNAMELEN];
153: int hostnamelen;
154: char domainname[MAXDOMNAMELEN];
155: int domainnamelen;
156:
157: char rootdevice[16]; /* hfs device names have at least 9 chars */
158: struct timeval boottime; /* GRODY! This has to go... */
159: #if FIXME /* [ */
160: struct timeval time;
161: #endif /* FIXME ] */
162:
163: #ifdef KMEMSTATS
164: struct kmemstats kmemstats[M_LAST];
165: #endif
166:
167: int lbolt; /* awoken once a second */
168: struct vnode *rootvp;
169: int boothowto = RB_DEBUG;
170:
171: vm_map_t bsd_pageable_map;
172: vm_map_t mb_map;
173:
174: int cmask = CMASK;
175:
176: int parse_bsd_args(void);
177: extern int bsd_hardclockinit;
178:
179: /*
180: * Initialization code.
181: * Called from cold start routine as
182: * soon as a stack and segmentation
183: * have been established.
184: * Functions:
185: * clear and free user core
186: * turn on clock
187: * hand craft 0th process
188: * call all initialization routines
189: * fork - process 0 to schedule
190: * - process 1 execute bootstrap
191: * - process 2 to page out
192: */
193:
194: /*
195: * Sets the name for the given task.
196: */
197: void proc_name(s, p)
198: char *s;
199: struct proc *p;
200: {
201: int length = strlen(s);
202:
203: bcopy(s, p->p_comm,
204: length >= sizeof(p->p_comm) ? sizeof(p->p_comm) :
205: length + 1);
206: }
207:
208:
209: /* To allow these values to be patched, they're globals here */
210: #include <machine/vmparam.h>
211: struct rlimit vm_initial_limit_stack = { DFLSSIZ, MAXSSIZ };
212: struct rlimit vm_initial_limit_data = { DFLDSIZ, MAXDSIZ };
213: struct rlimit vm_initial_limit_core = { DFLCSIZ, MAXCSIZ };
214:
215: extern thread_t first_thread;
216:
217: #define SPL_DEBUG 0
218: #if SPL_DEBUG
219: #define dprintf(x) printf x
220: #else SPL_DEBUG
221: #define dprintf(x)
222: #endif /* SPL_DEBUG */
223:
224: void
225: bsd_init()
226: {
227: register struct proc *p;
228: extern struct ucred *rootcred;
229: register int i;
230: int s;
231: thread_t th;
232: extern void bsdinit_task();
233: extern void netisr_thread();
234: void lightning_bolt(void );
235: kern_return_t ret;
236: boolean_t funnel_state;
237: extern thread_t cloneproc();
238:
239: extern int (*mountroot) __P((void));
240:
241: funnel_state = thread_set_funneled(TRUE);
242:
243: printf(copyright);
244:
245: kmeminit();
246:
247: parse_bsd_args();
248:
249: bsd_bufferinit();
250:
251: /*
252: * Initialize process and pgrp structures.
253: */
254: procinit();
255:
256: kernproc = &proc0;
257:
258: p = kernproc;
259:
260: /* kernel_task->proc = kernproc; */
261: set_bsdtask_info(kernel_task,(void *)kernproc);
262: p->p_pid = 0;
263:
264: /* give kernproc a name */
265: proc_name("kernel_task", p);
266:
267: if (current_task() != kernel_task)
268: printf("We are in for problem, current task in not kernel task\n");
269:
270: /*
271: * Create process 0.
272: */
273: LIST_INSERT_HEAD(&allproc, p, p_list);
274: p->p_pgrp = &pgrp0;
275: LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
276: LIST_INIT(&pgrp0.pg_members);
277: LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
278:
279: pgrp0.pg_session = &session0;
280: session0.s_count = 1;
281: session0.s_leader = p;
282:
283: p->task = kernel_task;
284:
285: p->p_stat = SRUN;
286: p->p_flag = P_INMEM|P_SYSTEM;
287: p->p_nice = NZERO;
288: p->p_pptr = p;
289: simple_lock_init(&p->siglock);
290: p->sigwait = FALSE;
291: p->sigwait_thread = THREAD_NULL;
292: p->exit_thread = THREAD_NULL;
293:
294: /* Create credentials. */
295: lockinit(&cred0.pc_lock, PLOCK, "proc0 cred", 0, 0);
296: cred0.p_refcnt = 1;
297: p->p_cred = &cred0;
298: p->p_ucred = crget();
299: p->p_ucred->cr_ngroups = 1; /* group 0 */
300:
301: /* Create the file descriptor table. */
302: filedesc0.fd_refcnt = 1+1; /* +1 so shutdown will not _FREE_ZONE */
303: p->p_fd = &filedesc0;
304: filedesc0.fd_cmask = cmask;
305:
306: /* Create the limits structures. */
307: p->p_limit = &limit0;
308: for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
309: limit0.pl_rlimit[i].rlim_cur =
310: limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
311: limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;
312: limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = MAXUPRC;
313: limit0.pl_rlimit[RLIMIT_STACK] = vm_initial_limit_stack;
314: limit0.pl_rlimit[RLIMIT_DATA] = vm_initial_limit_data;
315: limit0.pl_rlimit[RLIMIT_CORE] = vm_initial_limit_core;
316: limit0.p_refcnt = 1;
317:
318: p->p_stats = &pstats0;
319: p->p_sigacts = &sigacts0;
320:
321: /*
322: * Charge root for one process.
323: */
324: (void)chgproccnt(0, 1);
325:
326:
327: /*
328: * Allocate a kernel submap for pageable memory
329: * for temporary copying (table(), execve()).
330: */
331: {
332: vm_offset_t min, max;
333:
334: ret = kmem_suballoc(kernel_map,
335: &min,
336: (vm_size_t)512*1024,
337: TRUE,
338: TRUE,
339: &bsd_pageable_map);
340: if (ret != KERN_SUCCESS)
341: panic("Failed to allocare bsd pageable map\n");
342: }
343:
344: /*
345: * Initialize the calendar by
346: * reading the BBC, if not already set.
347: */
348: IOKitResetTime();
349:
350: mapfs_init();
351:
352: /* Initialize the file systems. */
353: vfsinit();
354:
355: /* Initialize mbuf's. */
356: mbinit();
357:
358: /* Initialize syslog */
359: log_init();
360:
361: /* Initialize SysV shm */
362: shminit();
363:
364: /*
365: * Initialize protocols. Block reception of incoming packets
366: * until everything is ready.
367: */
368: s = splimp();
369: sysctl_register_fixed();
370: dlil_init();
371: socketinit();
372: domaininit();
373: splx(s);
374:
375: /*
376: * Create kernel idle cpu processes. This must be done
377: * before a context switch can occur (and hence I/O can
378: * happen in the binit() call).
379: */
380: p->p_fd->fd_cdir = NULL;
381: p->p_fd->fd_rdir = NULL;
382:
383:
384: #ifdef GPROF
385: /* Initialize kernel profiling. */
386: kmstartup();
387: #endif
388:
389: /* kick off timeout driven events by calling first time */
390: lightning_bolt();
391:
392: /*
393: * Start up netisr thread now in case we are doing an nfs_mountroot.
394: */
395: (void) kernel_thread(kernel_task, netisr_thread);
396:
397: bsd_autoconf();
398:
399: /*
400: * We attach the loopback interface *way* down here to ensure
401: * it happens after autoconf(), otherwise it becomes the
402: * "primary" interface.
403: */
404: #include <loop.h>
405: #if NLOOP > 0
406: loopattach(); /* XXX */
407: #endif
408:
409:
410: /* Mount the root file system. */
411: while( TRUE) {
412: int err;
413:
414: setconf();
415: /* read the time after clock_initialize_calendar()
416: * and before nfs mount */
417: microtime(&time);
418:
419: if (0 == (err = vfs_mountroot()))
420: break;
421: printf("cannot mount root, errno = %d\n", err);
422: boothowto |= RB_ASKNAME;
423: }
424:
425: mountlist.cqh_first->mnt_flag |= MNT_ROOTFS;
426:
427: /* Get the vnode for '/'. Set fdp->fd_fd.fd_cdir to reference it. */
428: if (VFS_ROOT(mountlist.cqh_first, &rootvnode))
429: panic("cannot find root vnode");
430: filedesc0.fd_cdir = rootvnode;
431: VREF(rootvnode);
432: VOP_UNLOCK(rootvnode, 0, p);
433:
434:
435: /*
436: * Now can look at time, having had a chance to verify the time
437: * from the file system. Reset p->p_rtime as it may have been
438: * munched in mi_switch() after the time got set.
439: */
440: p->p_stats->p_start = boottime = time;
441: p->p_rtime.tv_sec = p->p_rtime.tv_usec = 0;
442:
443: #ifdef DEVFS
444: {
445: extern void devfs_kernel_mount(char * str);
446:
447: devfs_kernel_mount("/dev");
448: }
449: #endif DEVFS
450:
451: /* Initialize signal state for process 0. */
452: siginit(p);
453:
454: vnode_pager_bootstrap();
455: /* printf("vnode pager initialized\n"); */
456:
457: /* printf("Launching user process\n"); */
458:
459: bsd_utaskbootstrap();
460:
461: (void) thread_set_funneled(funnel_state);
462: }
463:
464: void
465: bsdinit_task()
466: {
467: struct proc *p = current_proc();
468: struct uthread *ut;
469: kern_return_t kr;
470: thread_act_t th_act;
471: boolean_t funnel_state;
472:
473: funnel_state = thread_set_funneled(TRUE);
474:
475: #if FIXME /* [ */
476:
477: ipc_port_t master_bootstrap_port;
478: task_t bootstrap_task;
479: thread_act_t bootstrap_thr_act;
480: ipc_port_t root_device_port;
481:
482: master_bootstrap_port = ipc_port_alloc_kernel();
483: if (master_bootstrap_port == IP_NULL)
484: panic("can't allocate master bootstrap port");
485: task_set_special_port(bootstrap_task,
486: TASK_BOOTSTRAP_PORT,
487: ipc_port_make_send(master_bootstrap_port));
488: printf("setting bootstrap port \n");
489: printf("Setting exception port for the init task\n");
490: (void) task_set_exception_ports(get_threadtask(th),
491: EXC_MASK_ALL &
492: ~(EXC_MASK_SYSCALL |
493: EXC_MASK_MACH_SYSCALL | EXC_MASK_RPC_ALERT),
494: ux_exception_port,
495: EXCEPTION_DEFAULT, 0);
496:
497: #endif /* FIXME ] */
498: proc_name("init", p);
499:
500: ux_handler_init();
501: /* port_reference(ux_exception_port);*/
502:
503: th_act = current_act();
504: (void) task_set_exception_ports(get_threadtask(th_act),
505: EXC_MASK_ALL &
506: ~(EXC_MASK_SYSCALL |
507: EXC_MASK_MACH_SYSCALL | EXC_MASK_RPC_ALERT),
508: ux_exception_port,
509: EXCEPTION_DEFAULT, 0);
510:
511:
512:
513:
514: ut = (uthread_t)get_bsdthread_info(th_act);
515: ut->uu_ar0 = (void *)get_user_regs(th_act);
516:
517: bsd_hardclockinit = 1; /* Start bsd hardclock */
518: load_init_program(p);
519:
520: (void) thread_set_funneled(funnel_state);
521:
522: }
523:
524: void
525: lightning_bolt()
526: {
527: thread_wakeup(&lbolt);
528: timeout(lightning_bolt,0,hz);
529: }
530:
531: bsd_autoconf(){
532: extern kern_return_t IOKitBSDInit( void );
533:
534: kminit();
535:
536: /*
537: * Early startup for bsd pseudodevices.
538: */
539: {
540: struct pseudo_init *pi;
541:
542: for (pi = pseudo_inits; pi->ps_func; pi++)
543: (*pi->ps_func) (pi->ps_count);
544: }
545:
546: return( IOKitBSDInit());
547: }
548:
549:
550: #include <sys/disklabel.h> // for MAXPARTITIONS
551:
552: setconf()
553: {
554: extern kern_return_t IOFindBSDRoot( char * rootName,
555: dev_t * root, u_int32_t * flags );
556:
557: extern int (*mountroot) __P((void));
558: extern int nfs_mountroot(); /* nfs_vfsops.c */
559:
560: u_int32_t flags;
561: kern_return_t err;
562:
563: err = IOFindBSDRoot( rootdevice, &rootdev, &flags );
564: if( err) {
565: printf("setconf: IOFindBSDRoot returned an error (%d); setting rootdevice to 'sd0a'.\n", err); /* XXX DEBUG TEMP */
566: rootdev = makedev( 6, 0 );
567: strcpy( rootdevice, "sd0a" );
568: flags = 0;
569: }
570:
571: /* if network device then force nfs root */
572: if( flags & 1 ) {
573: printf("mounting nfs root\n");
574: mountroot = nfs_mountroot;
575: } else {
576: /* otherwise have vfs determine root filesystem */
577: printf("probing for root file system\n");
578: mountroot = NULL;
579: }
580:
581: }
582:
583: bsd_utaskbootstrap()
584: {
585: thread_act_t th_act;
586:
587: th_act = cloneproc(kernproc);
588: initproc = pfind(1);
589: thread_hold(th_act);
590: (void) thread_stop_wait(getshuttle_thread(th_act));
591: thread_ast_set(th_act,AST_BSD_INIT);
592: thread_release(th_act);
593: thread_unstop(getshuttle_thread(th_act));
594: (void) thread_resume(th_act);
595: }
596:
597: parse_bsd_args()
598: {
599: extern char init_args[];
600: char namep[16];
601: extern int boothowto;
602: extern int srv;
603: extern int ncl;
604: extern int bufpages;
605: extern int nbuf;
606:
607: int len;
608:
609: if (PE_parse_boot_arg("-s", namep)) {
610: boothowto |= RB_SINGLE;
611: len = strlen(init_args);
612: if(len != 0)
613: strcat(init_args," -s");
614: else
615: strcat(init_args,"-s");
616: }
617: if (PE_parse_boot_arg("-b", namep)) {
618: boothowto |= RB_NOBOOTRC;
619: len = strlen(init_args);
620: if(len != 0)
621: strcat(init_args," -b");
622: else
623: strcat(init_args,"-b");
624: }
625:
626: if (PE_parse_boot_arg("-F", namep)) {
627: len = strlen(init_args);
628: if(len != 0)
629: strcat(init_args," -F");
630: else
631: strcat(init_args,"-F");
632: }
633:
634: if (PE_parse_boot_arg("-v", namep)) {
635: len = strlen(init_args);
636: if(len != 0)
637: strcat(init_args," -v");
638: else
639: strcat(init_args,"-v");
640: }
641:
642: PE_parse_boot_arg("srv", &srv);
643: PE_parse_boot_arg("ncl", &ncl);
644: PE_parse_boot_arg("nbuf", &nbuf);
645: PE_parse_boot_arg("bufpages", &bufpages);
646:
647: return 0;
648: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.