xnu-1699.26.8.tar.gz

[apple/xnu.git] / bsd / kern / bsd_init.c

diff --git a/bsd/kern/bsd_init.c b/bsd/kern/bsd_init.c
index 50d955a3f7ac1729f9944d8da9f7cdc069a40e0c..dac2c94d899c0657f23ed7b5f2a30481568b2238 100644 (file)
--- a/bsd/kern/bsd_init.c
+++ b/bsd/kern/bsd_init.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2009 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -24,8 +24,8 @@
  * limitations under the License.
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  * limitations under the License.
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

- */
-/*
+ * 
+ *

  * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
  *     The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
  *     The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.


@@ -95,7 +95,7 @@
 #include <sys/systm.h>
 #include <sys/mman.h>
 
 #include <sys/systm.h>
 #include <sys/mman.h>
 

-#include <bsm/audit_kernel.h>
+#include <security/audit/audit.h>

 
 #include <sys/malloc.h>
 #include <sys/dkstat.h>
 
 #include <sys/malloc.h>
 #include <sys/dkstat.h>


@@ -105,6 +105,8 @@
 #include <kern/thread.h>
 #include <kern/task.h>
 #include <kern/ast.h>
 #include <kern/thread.h>
 #include <kern/task.h>
 #include <kern/ast.h>

+#include <kern/kalloc.h>
+#include <mach/mach_host.h>

 
 #include <mach/vm_param.h>
 
 
 #include <mach/vm_param.h>
 


@@ -131,6 +133,7 @@
 #include <sys/mcache.h>                        /* for mcache_init() */
 #include <sys/mbuf.h>                  /* for mbinit() */
 #include <sys/event.h>                 /* for knote_init() */
 #include <sys/mcache.h>                        /* for mcache_init() */
 #include <sys/mbuf.h>                  /* for mbinit() */
 #include <sys/event.h>                 /* for knote_init() */

+#include <sys/kern_memorystatus.h>     /* for kern_memorystatus_init() */

 #include <sys/aio_kern.h>              /* for aio_init() */
 #include <sys/semaphore.h>             /* for psem_cache_init() */
 #include <net/dlil.h>                  /* for dlil_init() */
 #include <sys/aio_kern.h>              /* for aio_init() */
 #include <sys/semaphore.h>             /* for psem_cache_init() */
 #include <net/dlil.h>                  /* for dlil_init() */


@@ -147,6 +150,11 @@
 #include <vm/vm_kern.h>                        /* for kmem_suballoc() */
 #include <sys/semaphore.h>             /* for psem_lock_init() */
 #include <sys/msgbuf.h>                        /* for log_setsize() */
 #include <vm/vm_kern.h>                        /* for kmem_suballoc() */
 #include <sys/semaphore.h>             /* for psem_lock_init() */
 #include <sys/msgbuf.h>                        /* for log_setsize() */

+#include <sys/tty.h>                   /* for tty_init() */
+#include <net/if_utun.h>               /* for utun_register_control() */
+#include <net/net_str_id.h>            /* for net_str_id_init() */
+#include <net/netsrc.h>                        /* for netsrc_init() */
+#include <kern/assert.h>               /* for assert() */

 
 #include <net/init.h>
 
 
 #include <net/init.h>
 


@@ -158,17 +166,28 @@
 
 #include <machine/exec.h>
 
 
 #include <machine/exec.h>
 

+#if NFSCLIENT
+#include <sys/netboot.h>
+#endif
+

 #if CONFIG_IMAGEBOOT
 #include <sys/imageboot.h>
 #endif
 
 #if CONFIG_IMAGEBOOT
 #include <sys/imageboot.h>
 #endif
 

+#if PFLOG
+#include <net/if_pflog.h>
+#endif
+

 #include <pexpert/pexpert.h>
 #include <pexpert/pexpert.h>

+#include <machine/pal_routines.h>

 
 void * get_user_regs(thread_t);                /* XXX kludge for <machine/thread.h> */
 void IOKitInitializeTime(void);                /* XXX */
 
 void * get_user_regs(thread_t);                /* XXX kludge for <machine/thread.h> */
 void IOKitInitializeTime(void);                /* XXX */

+void IOSleep(unsigned int);            /* XXX */

 void loopattach(void);                 /* XXX */
 void loopattach(void);                 /* XXX */

+void vc_progress_set(boolean_t, uint32_t); /* XXX */

 
 

-char    copyright[] =
+const char    copyright[] =

 "Copyright (c) 1982, 1986, 1989, 1991, 1993\n\t"
 "The Regents of the University of California. "
 "All rights reserved.\n\n";
 "Copyright (c) 1982, 1986, 1989, 1991, 1993\n\t"
 "The Regents of the University of California. "
 "All rights reserved.\n\n";


@@ -204,9 +223,9 @@ char        hostname[MAXHOSTNAMELEN];
 int            hostnamelen;
 char   domainname[MAXDOMNAMELEN];
 int            domainnamelen;
 int            hostnamelen;
 char   domainname[MAXDOMNAMELEN];
 int            domainnamelen;

-#if __i386__
+#if defined(__i386__) || defined(__x86_64__)

 struct exec_archhandler exec_archhandler_ppc = {
 struct exec_archhandler exec_archhandler_ppc = {

-       .path = "/usr/libexec/oah/translate",
+       .path = "/usr/libexec/oah/RosettaNonGrata",

 };
 #else /* __i386__ */
 struct exec_archhandler exec_archhandler_ppc;
 };
 #else /* __i386__ */
 struct exec_archhandler exec_archhandler_ppc;


@@ -232,21 +251,38 @@ extern void file_lock_init(void);
 extern void kmeminit(void);
 extern void bsd_bufferinit(void);
 
 extern void kmeminit(void);
 extern void bsd_bufferinit(void);
 

-extern int srv;
+extern int serverperfmode;

 extern int ncl;
 
 extern int ncl;
 

-#define BSD_SIMUL_EXECS       33 /* 32 , allow for rounding */
-#define        BSD_PAGABLE_MAP_SIZE    (BSD_SIMUL_EXECS * (NCARGS + PAGE_SIZE))

 vm_map_t       bsd_pageable_map;
 vm_map_t       mb_map;
 vm_map_t       bsd_pageable_map;
 vm_map_t       mb_map;

-semaphore_t execve_semaphore;
+
+static  int bsd_simul_execs;
+static int bsd_pageable_map_size;
+__private_extern__ int execargs_cache_size = 0;
+__private_extern__ int execargs_free_count = 0;
+__private_extern__ vm_offset_t * execargs_cache = NULL;
+
+void bsd_exec_setup(int);
+
+/*
+ * Set to disable grading 64 bit Mach-o binaries as executable, for testing;
+ * Intel only.
+ */
+__private_extern__ int bootarg_no64exec = 0;
+__private_extern__ int bootarg_vnode_cache_defeat = 0;
+
+/*
+ * Prevent kernel-based ASLR from being used, for testing.
+ */
+#if DEVELOPMENT || DEBUG
+__private_extern__ int bootarg_disable_aslr = 0;
+#endif

 
 int    cmask = CMASK;
 extern int customnbuf;
 
 void bsd_init(void) __attribute__((section("__TEXT, initcode")));
 
 int    cmask = CMASK;
 extern int customnbuf;
 
 void bsd_init(void) __attribute__((section("__TEXT, initcode")));

-__private_extern__ void ubc_init(void )  __attribute__((section("__TEXT, initcode")));
-void vfsinit(void) __attribute__((section("__TEXT, initcode")));

 kern_return_t bsd_autoconf(void) __attribute__((section("__TEXT, initcode")));
 void bsd_utaskbootstrap(void) __attribute__((section("__TEXT, initcode")));
 
 kern_return_t bsd_autoconf(void) __attribute__((section("__TEXT, initcode")));
 void bsd_utaskbootstrap(void) __attribute__((section("__TEXT, initcode")));
 


@@ -254,6 +290,7 @@ static void parse_bsd_args(void);
 extern task_t bsd_init_task;
 extern char    init_task_failure_data[];
 extern void time_zone_slock_init(void);
 extern task_t bsd_init_task;
 extern char    init_task_failure_data[];
 extern void time_zone_slock_init(void);

+extern void select_wait_queue_init(void);

 static void process_name(const char *, proc_t);
 
 static void setconf(void);
 static void process_name(const char *, proc_t);
 
 static void setconf(void);


@@ -269,20 +306,31 @@ extern void sysv_sem_lock_init(void);
 #if SYSV_MSG
 extern void sysv_msg_lock_init(void);
 #endif
 #if SYSV_MSG
 extern void sysv_msg_lock_init(void);
 #endif

-extern void pthread_init(void);

 
 

+#if !defined(SECURE_KERNEL)

 /* kmem access not enabled by default; can be changed with boot-args */
 /* kmem access not enabled by default; can be changed with boot-args */

+/* We don't need to keep this symbol around in RELEASE kernel */

 int setup_kmem = 0;
 int setup_kmem = 0;

+#endif

 
 

-/* size of kernel trace buffer, disabled by default */
-unsigned int new_nkdbufs = 0;
+#if CONFIG_MACF
+#if defined (__i386__) || defined (__x86_64__)
+/* MACF policy_check configuration flags; see policy_check.c for details */
+int policy_check_flags = 0;

 
 

-/* mach leak logging */
-int log_leaks = 0;
-int turn_on_log_leaks = 0;
+extern int check_policy_init(int);
+#endif
+#endif /* CONFIG_MACF */

 
 extern void stackshot_lock_init(void);
 
 
 extern void stackshot_lock_init(void);
 

+
+/* If we are using CONFIG_DTRACE */
+#if CONFIG_DTRACE
+       extern void dtrace_postinit(void);
+#endif
+
+

 /*
  * Initialization code.
  * Called from cold start routine as
 /*
  * Initialization code.
  * Called from cold start routine as


@@ -314,19 +362,23 @@ struct rlimit vm_initial_limit_stack = { DFLSSIZ, MAXSSIZ - PAGE_SIZE };
 struct rlimit vm_initial_limit_data = { DFLDSIZ, MAXDSIZ };
 struct rlimit vm_initial_limit_core = { DFLCSIZ, MAXCSIZ };
 
 struct rlimit vm_initial_limit_data = { DFLDSIZ, MAXDSIZ };
 struct rlimit vm_initial_limit_core = { DFLCSIZ, MAXCSIZ };
 

-extern thread_t        cloneproc(proc_t, int);
+extern thread_t        cloneproc(task_t, proc_t, int);

 extern int     (*mountroot)(void);
 extern int     (*mountroot)(void);

-extern int     netboot_mountroot(void);        /* netboot.c */
-extern int     netboot_setup(void);

 
 lck_grp_t * proc_lck_grp;
 
 lck_grp_t * proc_lck_grp;

+lck_grp_t * proc_slock_grp;
+lck_grp_t * proc_fdmlock_grp;
+lck_grp_t * proc_mlock_grp;

 lck_grp_attr_t * proc_lck_grp_attr;
 lck_attr_t * proc_lck_attr;
 lck_mtx_t * proc_list_mlock;
 lck_mtx_t * proc_klist_mlock;
 
 lck_grp_attr_t * proc_lck_grp_attr;
 lck_attr_t * proc_lck_attr;
 lck_mtx_t * proc_list_mlock;
 lck_mtx_t * proc_klist_mlock;
 

+extern lck_mtx_t * execargs_cache_lock;
+

 /* hook called after root is mounted XXX temporary hack */
 void (*mountroot_post_hook)(void);
 /* hook called after root is mounted XXX temporary hack */
 void (*mountroot_post_hook)(void);

+void (*unmountroot_pre_hook)(void);

 
 /*
  * This function is called very early on in the Mach startup, from the
 
 /*
  * This function is called very early on in the Mach startup, from the


@@ -345,15 +397,18 @@ void (*mountroot_post_hook)(void);
 void
 bsd_init(void)
 {
 void
 bsd_init(void)
 {

-       proc_t p;

        struct uthread *ut;
        unsigned int i;
        struct uthread *ut;
        unsigned int i;

-#if __i386__
+#if __i386__ || __x86_64__

        int error;
 #endif 
        struct vfs_context context;
        kern_return_t   ret;
        struct ucred temp_cred;
        int error;
 #endif 
        struct vfs_context context;
        kern_return_t   ret;
        struct ucred temp_cred;

+       struct posix_cred temp_pcred;
+#if NFSCLIENT || CONFIG_IMAGEBOOT
+       boolean_t       netboot = FALSE;
+#endif

 
 #define bsd_init_kprintf(x...) /* kprintf("bsd_init: " x) */
 
 
 #define bsd_init_kprintf(x...) /* kprintf("bsd_init: " x) */
 


@@ -378,25 +433,28 @@ bsd_init(void)
        bsd_init_kprintf("calling procinit\n");
        procinit();
 
        bsd_init_kprintf("calling procinit\n");
        procinit();
 

-       kernproc = &proc0;
+       /* Initialize the ttys (MUST be before kminit()/bsd_autoconf()!)*/
+       tty_init();

 
 

-       p = kernproc;
+       kernproc = &proc0;      /* implicitly bzero'ed */

 
        /* kernel_task->proc = kernproc; */
 
        /* kernel_task->proc = kernproc; */

-       set_bsdtask_info(kernel_task,(void *)p);
-       p->p_pid = 0;
-       p->p_ppid = 0;
+       set_bsdtask_info(kernel_task,(void *)kernproc);

 
        /* give kernproc a name */
        bsd_init_kprintf("calling process_name\n");
 
        /* give kernproc a name */
        bsd_init_kprintf("calling process_name\n");

-       process_name("kernel_task", p);
+       process_name("kernel_task", kernproc);

 
        /* allocate proc lock group attribute and group */
        bsd_init_kprintf("calling lck_grp_attr_alloc_init\n");
        proc_lck_grp_attr= lck_grp_attr_alloc_init();
 
        /* allocate proc lock group attribute and group */
        bsd_init_kprintf("calling lck_grp_attr_alloc_init\n");
        proc_lck_grp_attr= lck_grp_attr_alloc_init();

-       
-       proc_lck_grp = lck_grp_alloc_init("proc",  proc_lck_grp_attr);

 
 

+       proc_lck_grp = lck_grp_alloc_init("proc",  proc_lck_grp_attr);
+#if CONFIG_FINE_LOCK_GROUPS
+       proc_slock_grp = lck_grp_alloc_init("proc-slock",  proc_lck_grp_attr);
+       proc_fdmlock_grp = lck_grp_alloc_init("proc-fdmlock",  proc_lck_grp_attr);
+       proc_mlock_grp = lck_grp_alloc_init("proc-mlock",  proc_lck_grp_attr);
+#endif

        /* Allocate proc lock attribute */
        proc_lck_attr = lck_attr_alloc_init();
 #if 0
        /* Allocate proc lock attribute */
        proc_lck_attr = lck_attr_alloc_init();
 #if 0


@@ -405,12 +463,27 @@ bsd_init(void)
 #endif
 #endif
 
 #endif
 #endif
 

+#if CONFIG_FINE_LOCK_GROUPS
+       proc_list_mlock = lck_mtx_alloc_init(proc_mlock_grp, proc_lck_attr);
+       proc_klist_mlock = lck_mtx_alloc_init(proc_mlock_grp, proc_lck_attr);
+       lck_mtx_init(&kernproc->p_mlock, proc_mlock_grp, proc_lck_attr);
+       lck_mtx_init(&kernproc->p_fdmlock, proc_fdmlock_grp, proc_lck_attr);
+       lck_spin_init(&kernproc->p_slock, proc_slock_grp, proc_lck_attr);
+#else

        proc_list_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
        proc_klist_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
        proc_list_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
        proc_klist_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);

-       lck_mtx_init(&p->p_mlock, proc_lck_grp, proc_lck_attr);
-       lck_mtx_init(&p->p_fdmlock, proc_lck_grp, proc_lck_attr);
-       lck_spin_init(&p->p_slock, proc_lck_grp, proc_lck_attr);
+       lck_mtx_init(&kernproc->p_mlock, proc_lck_grp, proc_lck_attr);
+       lck_mtx_init(&kernproc->p_fdmlock, proc_lck_grp, proc_lck_attr);
+       lck_spin_init(&kernproc->p_slock, proc_lck_grp, proc_lck_attr);
+#endif

 
 

+       assert(bsd_simul_execs != 0);
+       execargs_cache_lock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
+       execargs_cache_size = bsd_simul_execs;
+       execargs_free_count = bsd_simul_execs;
+       execargs_cache = (vm_offset_t *)kalloc(bsd_simul_execs * sizeof(vm_offset_t));
+       bzero(execargs_cache, bsd_simul_execs * sizeof(vm_offset_t));
+       

        if (current_task() != kernel_task)
                printf("bsd_init: We have a problem, "
                                "current task is not kernel task\n");
        if (current_task() != kernel_task)
                printf("bsd_init: We have a problem, "
                                "current task is not kernel task\n");


@@ -423,86 +496,120 @@ bsd_init(void)
         * Initialize the MAC Framework
         */
        mac_policy_initbsd();
         * Initialize the MAC Framework
         */
        mac_policy_initbsd();

-       p->p_mac_enforce = 0;
+       kernproc->p_mac_enforce = 0;
+
+#if defined (__i386__) || defined (__x86_64__)
+       /*
+        * We currently only support this on i386/x86_64, as that is the
+        * only lock code we have instrumented so far.
+        */
+       check_policy_init(policy_check_flags);
+#endif

 #endif /* MAC */
 
        /*
         * Create process 0.
         */
        proc_list_lock();
 #endif /* MAC */
 
        /*
         * Create process 0.
         */
        proc_list_lock();

-       LIST_INSERT_HEAD(&allproc, p, p_list);
-       p->p_pgrp = &pgrp0;
+       LIST_INSERT_HEAD(&allproc, kernproc, p_list);
+       kernproc->p_pgrp = &pgrp0;

        LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
        LIST_INIT(&pgrp0.pg_members);
        LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
        LIST_INIT(&pgrp0.pg_members);

+#ifdef CONFIG_FINE_LOCK_GROUPS
+       lck_mtx_init(&pgrp0.pg_mlock, proc_mlock_grp, proc_lck_attr);
+#else

        lck_mtx_init(&pgrp0.pg_mlock, proc_lck_grp, proc_lck_attr);
        lck_mtx_init(&pgrp0.pg_mlock, proc_lck_grp, proc_lck_attr);

+#endif

        /* There is no other bsd thread this point and is safe without pgrp lock */
        /* There is no other bsd thread this point and is safe without pgrp lock */

-       LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
-       p->p_listflag |= P_LIST_INPGRP;
-       p->p_pgrpid = 0;
+       LIST_INSERT_HEAD(&pgrp0.pg_members, kernproc, p_pglist);
+       kernproc->p_listflag |= P_LIST_INPGRP;
+       kernproc->p_pgrpid = 0;
+       kernproc->p_uniqueid = 0;

 
        pgrp0.pg_session = &session0;
        pgrp0.pg_membercnt = 1;
 
        session0.s_count = 1;
 
        pgrp0.pg_session = &session0;
        pgrp0.pg_membercnt = 1;
 
        session0.s_count = 1;

-       session0.s_leader = p;
+       session0.s_leader = kernproc;

        session0.s_listflags = 0;
        session0.s_listflags = 0;

+#ifdef CONFIG_FINE_LOCK_GROUPS
+       lck_mtx_init(&session0.s_mlock, proc_mlock_grp, proc_lck_attr);
+#else

        lck_mtx_init(&session0.s_mlock, proc_lck_grp, proc_lck_attr);
        lck_mtx_init(&session0.s_mlock, proc_lck_grp, proc_lck_attr);

+#endif

        LIST_INSERT_HEAD(SESSHASH(0), &session0, s_hash);
        proc_list_unlock();
 
 #if CONFIG_LCTX
        LIST_INSERT_HEAD(SESSHASH(0), &session0, s_hash);
        proc_list_unlock();
 
 #if CONFIG_LCTX

-       p->p_lctx = NULL;
+       kernproc->p_lctx = NULL;

 #endif
 
 #endif
 

-       p->task = kernel_task;
+       kernproc->task = kernel_task;

        
        

-       p->p_stat = SRUN;
-       p->p_flag = P_SYSTEM;
-       p->p_nice = NZERO;
-       p->p_pptr = p;
+       kernproc->p_stat = SRUN;
+       kernproc->p_flag = P_SYSTEM;
+       kernproc->p_lflag = 0;
+       kernproc->p_ladvflag = 0;
+       
+#if DEVELOPMENT || DEBUG
+       if (bootarg_disable_aslr)
+               kernproc->p_flag |= P_DISABLE_ASLR;
+#endif
+
+       kernproc->p_nice = NZERO;
+       kernproc->p_pptr = kernproc;

 
 

-       TAILQ_INIT(&p->p_uthlist);
-       TAILQ_INSERT_TAIL(&p->p_uthlist, ut, uu_list);
+       TAILQ_INIT(&kernproc->p_uthlist);
+       TAILQ_INSERT_TAIL(&kernproc->p_uthlist, ut, uu_list);

        
        

-       p->sigwait = FALSE;
-       p->sigwait_thread = THREAD_NULL;
-       p->exit_thread = THREAD_NULL;
-       p->p_csflags = CS_VALID;
+       kernproc->sigwait = FALSE;
+       kernproc->sigwait_thread = THREAD_NULL;
+       kernproc->exit_thread = THREAD_NULL;
+       kernproc->p_csflags = CS_VALID;

 
        /*
         * Create credential.  This also Initializes the audit information.
 
        /*
         * Create credential.  This also Initializes the audit information.

-        * XXX It is not clear what the initial values should be for audit ID,
-        * XXX session ID, etc..

         */
        bsd_init_kprintf("calling bzero\n");
        bzero(&temp_cred, sizeof(temp_cred));
         */
        bsd_init_kprintf("calling bzero\n");
        bzero(&temp_cred, sizeof(temp_cred));

-       temp_cred.cr_ngroups = 1;
+       bzero(&temp_pcred, sizeof(temp_pcred));
+       temp_pcred.cr_ngroups = 1;
+
+       temp_cred.cr_audit.as_aia_p = audit_default_aia_p;

 
        bsd_init_kprintf("calling kauth_cred_create\n");
 
        bsd_init_kprintf("calling kauth_cred_create\n");

-       p->p_ucred = kauth_cred_create(&temp_cred); 
+       /*
+        * We have to label the temp cred before we create from it to
+        * properly set cr_ngroups, or the create will fail.
+        */
+       posix_cred_label(&temp_cred, &temp_pcred);
+       kernproc->p_ucred = kauth_cred_create(&temp_cred); 
+
+       /* update cred on proc */
+       PROC_UPDATE_CREDS_ONPROC(kernproc);

 
        /* give the (already exisiting) initial thread a reference on it */
        bsd_init_kprintf("calling kauth_cred_ref\n");
 
        /* give the (already exisiting) initial thread a reference on it */
        bsd_init_kprintf("calling kauth_cred_ref\n");

-       kauth_cred_ref(p->p_ucred);
-       ut->uu_context.vc_ucred = p->p_ucred;
+       kauth_cred_ref(kernproc->p_ucred);
+       ut->uu_context.vc_ucred = kernproc->p_ucred;

        ut->uu_context.vc_thread = current_thread();
 
        ut->uu_context.vc_thread = current_thread();
 

-       TAILQ_INIT(&p->aio_activeq);
-       TAILQ_INIT(&p->aio_doneq);
-       p->aio_active_count = 0;
-       p->aio_done_count = 0;
+       TAILQ_INIT(&kernproc->p_aio_activeq);
+       TAILQ_INIT(&kernproc->p_aio_doneq);
+       kernproc->p_aio_total_count = 0;
+       kernproc->p_aio_active_count = 0;

 
        bsd_init_kprintf("calling file_lock_init\n");
        file_lock_init();
 
 #if CONFIG_MACF
 
        bsd_init_kprintf("calling file_lock_init\n");
        file_lock_init();
 
 #if CONFIG_MACF

-       mac_cred_label_associate_kernel(p->p_ucred);
-       mac_task_label_update_cred (p->p_ucred, (struct task *) p->task);
+       mac_cred_label_associate_kernel(kernproc->p_ucred);
+       mac_task_label_update_cred (kernproc->p_ucred, (struct task *) kernproc->task);

 #endif
 
        /* Create the file descriptor table. */
        filedesc0.fd_refcnt = 1+1;      /* +1 so shutdown will not _FREE_ZONE */
 #endif
 
        /* Create the file descriptor table. */
        filedesc0.fd_refcnt = 1+1;      /* +1 so shutdown will not _FREE_ZONE */

-       p->p_fd = &filedesc0;
+       kernproc->p_fd = &filedesc0;

        filedesc0.fd_cmask = cmask;
        filedesc0.fd_knlistsize = -1;
        filedesc0.fd_knlist = NULL;
        filedesc0.fd_cmask = cmask;
        filedesc0.fd_knlistsize = -1;
        filedesc0.fd_knlist = NULL;


@@ -510,8 +617,8 @@ bsd_init(void)
        filedesc0.fd_knhashmask = 0;
 
        /* Create the limits structures. */
        filedesc0.fd_knhashmask = 0;
 
        /* Create the limits structures. */

-       p->p_limit = &limit0;
-       for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
+       kernproc->p_limit = &limit0;
+       for (i = 0; i < sizeof(kernproc->p_rlimit)/sizeof(kernproc->p_rlimit[0]); i++)

                limit0.pl_rlimit[i].rlim_cur = 
                        limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
        limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;
                limit0.pl_rlimit[i].rlim_cur = 
                        limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
        limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;


@@ -522,8 +629,8 @@ bsd_init(void)
        limit0.pl_rlimit[RLIMIT_CORE] = vm_initial_limit_core;
        limit0.pl_refcnt = 1;
 
        limit0.pl_rlimit[RLIMIT_CORE] = vm_initial_limit_core;
        limit0.pl_refcnt = 1;
 

-       p->p_stats = &pstats0;
-       p->p_sigacts = &sigacts0;
+       kernproc->p_stats = &pstats0;
+       kernproc->p_sigacts = &sigacts0;

 
        /*
         * Charge root for two  processes: init and mach_init.
 
        /*
         * Charge root for two  processes: init and mach_init.


@@ -539,9 +646,10 @@ bsd_init(void)
                vm_offset_t     minimum;
 
                bsd_init_kprintf("calling kmem_suballoc\n");
                vm_offset_t     minimum;
 
                bsd_init_kprintf("calling kmem_suballoc\n");

+               assert(bsd_pageable_map_size != 0);

                ret = kmem_suballoc(kernel_map,
                                &minimum,
                ret = kmem_suballoc(kernel_map,
                                &minimum,

-                               (vm_size_t)BSD_PAGABLE_MAP_SIZE,
+                               (vm_size_t)bsd_pageable_map_size,

                                TRUE,
                                VM_FLAGS_ANYWHERE,
                                &bsd_pageable_map);
                                TRUE,
                                VM_FLAGS_ANYWHERE,
                                &bsd_pageable_map);


@@ -561,8 +669,7 @@ bsd_init(void)
 
        /* Initialize the execve() semaphore */
        bsd_init_kprintf("calling semaphore_create\n");
 
        /* Initialize the execve() semaphore */
        bsd_init_kprintf("calling semaphore_create\n");

-       ret = semaphore_create(kernel_task, &execve_semaphore,
-                              SYNC_POLICY_FIFO, BSD_SIMUL_EXECS -1);
+

        if (ret != KERN_SUCCESS)
                panic("bsd_init: Failed to create execve semaphore");
 
        if (ret != KERN_SUCCESS)
                panic("bsd_init: Failed to create execve semaphore");
 


@@ -572,15 +679,15 @@ bsd_init(void)
        bsd_init_kprintf("calling IOKitInitializeTime\n");
        IOKitInitializeTime();
 
        bsd_init_kprintf("calling IOKitInitializeTime\n");
        IOKitInitializeTime();
 

-       if (turn_on_log_leaks && !new_nkdbufs)
-               new_nkdbufs = 200000;
-       start_kern_tracing(new_nkdbufs);
-       if (turn_on_log_leaks)
-               log_leaks = 1;
-

        bsd_init_kprintf("calling ubc_init\n");
        ubc_init();
 
        bsd_init_kprintf("calling ubc_init\n");
        ubc_init();
 

+       /*
+        * Initialize device-switches.
+        */
+       bsd_init_kprintf("calling devsw_init() \n");
+       devsw_init();
+

        /* Initialize the file systems. */
        bsd_init_kprintf("calling vfsinit\n");
        vfsinit();
        /* Initialize the file systems. */
        bsd_init_kprintf("calling vfsinit\n");
        vfsinit();


@@ -592,13 +699,14 @@ bsd_init(void)
        /* Initialize mbuf's. */
        bsd_init_kprintf("calling mbinit\n");
        mbinit();
        /* Initialize mbuf's. */
        bsd_init_kprintf("calling mbinit\n");
        mbinit();

+       net_str_id_init(); /* for mbuf tags */

 #endif /* SOCKETS */
 
        /*
         * Initializes security event auditing.
         * XXX: Should/could this occur later?
         */
 #endif /* SOCKETS */
 
        /*
         * Initializes security event auditing.
         * XXX: Should/could this occur later?
         */

-#if AUDIT
+#if CONFIG_AUDIT

        bsd_init_kprintf("calling audit_init\n");
        audit_init();  
 #endif
        bsd_init_kprintf("calling audit_init\n");
        audit_init();  
 #endif


@@ -607,12 +715,6 @@ bsd_init(void)
        bsd_init_kprintf("calling knote_init\n");
        knote_init();
 
        bsd_init_kprintf("calling knote_init\n");
        knote_init();
 

-#if CONFIG_EMBEDDED
-       /* Initialize kernel memory status notifications */
-       bsd_init_kprintf("calling kern_memorystatus_init\n");
-       kern_memorystatus_init();
-#endif
-

        /* Initialize for async IO */
        bsd_init_kprintf("calling aio_init\n");
        aio_init();
        /* Initialize for async IO */
        bsd_init_kprintf("calling aio_init\n");
        aio_init();


@@ -649,6 +751,8 @@ bsd_init(void)
        psem_cache_init();
        bsd_init_kprintf("calling time_zone_slock_init\n");
        time_zone_slock_init();
        psem_cache_init();
        bsd_init_kprintf("calling time_zone_slock_init\n");
        time_zone_slock_init();

+       bsd_init_kprintf("calling select_wait_queue_init\n");
+       select_wait_queue_init();

 
        /* Stack snapshot facility lock */
        stackshot_lock_init();
 
        /* Stack snapshot facility lock */
        stackshot_lock_init();


@@ -673,8 +777,20 @@ bsd_init(void)
        domaininit();
 #endif /* SOCKETS */
 
        domaininit();
 #endif /* SOCKETS */
 

-       p->p_fd->fd_cdir = NULL;
-       p->p_fd->fd_rdir = NULL;
+       kernproc->p_fd->fd_cdir = NULL;
+       kernproc->p_fd->fd_rdir = NULL;
+
+#if CONFIG_FREEZE
+       /* Initialise background hibernation */
+       bsd_init_kprintf("calling kern_hibernation_init\n");
+       kern_hibernation_init();
+#endif
+
+#if CONFIG_EMBEDDED
+       /* Initialize kernel memory status notifications */
+       bsd_init_kprintf("calling kern_memorystatus_init\n");
+       kern_memorystatus_init();
+#endif

 
 #ifdef GPROF
        /* Initialize kernel profiling. */
 
 #ifdef GPROF
        /* Initialize kernel profiling. */


@@ -689,7 +805,6 @@ bsd_init(void)
        bsd_autoconf();
 
 #if CONFIG_DTRACE
        bsd_autoconf();
 
 #if CONFIG_DTRACE

-       extern void dtrace_postinit(void);

        dtrace_postinit();
 #endif
 
        dtrace_postinit();
 #endif
 


@@ -703,7 +818,12 @@ bsd_init(void)
        bsd_init_kprintf("calling loopattach\n");
        loopattach();                   /* XXX */
 #endif
        bsd_init_kprintf("calling loopattach\n");
        loopattach();                   /* XXX */
 #endif

-        
+
+#if PFLOG
+       /* Initialize packet filter log interface */
+       pfloginit();
+#endif /* PFLOG */
+

 #if NETHER > 0
        /* Register the built-in dlil ethernet interface family */
        bsd_init_kprintf("calling ether_family_init\n");
 #if NETHER > 0
        /* Register the built-in dlil ethernet interface family */
        bsd_init_kprintf("calling ether_family_init\n");


@@ -714,6 +834,13 @@ bsd_init(void)
        /* Call any kext code that wants to run just after network init */
        bsd_init_kprintf("calling net_init_run\n");
        net_init_run();
        /* Call any kext code that wants to run just after network init */
        bsd_init_kprintf("calling net_init_run\n");
        net_init_run();

+       
+       /* register user tunnel kernel control handler */
+       utun_register_control();
+    netsrc_init();
+       
+       /* wait for network domain to finish */
+       domainfin();

 #endif /* NETWORKING */
 
        bsd_init_kprintf("calling vnode_pager_bootstrap\n");
 #endif /* NETWORKING */
 
        bsd_init_kprintf("calling vnode_pager_bootstrap\n");


@@ -728,64 +855,31 @@ bsd_init(void)
        bsd_init_kprintf("calling inittodr\n");
        inittodr(0);
 
        bsd_init_kprintf("calling inittodr\n");
        inittodr(0);
 

-#if CONFIG_EMBEDDED
-       {
-               /* print out early VM statistics */
-               kern_return_t kr1;
-               vm_statistics_data_t stat;
-               mach_msg_type_number_t count;
-
-               count = HOST_VM_INFO_COUNT;
-               kr1 = host_statistics(host_self(),
-                                     HOST_VM_INFO,
-                                     (host_info_t)&stat,
-                                     &count);
-               kprintf("Mach Virtual Memory Statistics (page size of 4096) bytes\n"
-                       "Pages free:\t\t\t%u.\n"
-                       "Pages active:\t\t\t%u.\n"
-                       "Pages inactive:\t\t\t%u.\n"
-                       "Pages wired down:\t\t%u.\n"
-                       "\"Translation faults\":\t\t%u.\n"
-                       "Pages copy-on-write:\t\t%u.\n"
-                       "Pages zero filled:\t\t%u.\n"
-                       "Pages reactivated:\t\t%u.\n"
-                       "Pageins:\t\t\t%u.\n"
-                       "Pageouts:\t\t\t\%u.\n"
-                       "Object cache: %u hits of %u lookups (%d%% hit rate)\n",
-
-                       stat.free_count,
-                       stat.active_count,
-                       stat.inactive_count,
-                       stat.wire_count,
-                       stat.faults,
-                       stat.cow_faults,
-                       stat.zero_fill_count,
-                       stat.reactivations,
-                       stat.pageins,
-                       stat.pageouts,
-                       stat.hits,
-                       stat.lookups,
-                       (stat.hits == 0) ? 100 :
-                                          ((stat.lookups * 100) / stat.hits));
-       }
-#endif /* CONFIG_EMBEDDED */
-       

        /* Mount the root file system. */
        while( TRUE) {
                int err;
 
                bsd_init_kprintf("calling setconf\n");
                setconf();
        /* Mount the root file system. */
        while( TRUE) {
                int err;
 
                bsd_init_kprintf("calling setconf\n");
                setconf();

+#if NFSCLIENT
+               netboot = (mountroot == netboot_mountroot);
+#endif

 
                bsd_init_kprintf("vfs_mountroot\n");
                if (0 == (err = vfs_mountroot()))
                        break;
                rootdevice[0] = '\0';
 #if NFSCLIENT
 
                bsd_init_kprintf("vfs_mountroot\n");
                if (0 == (err = vfs_mountroot()))
                        break;
                rootdevice[0] = '\0';
 #if NFSCLIENT

-               if (mountroot == netboot_mountroot) {
-                       printf("bsd_init: netboot_mountroot failed,"
-                              " errno = %d\n", err);
-                       panic("bsd_init: failed to mount network root: %s", PE_boot_args());
+               if (netboot) {
+                       PE_display_icon( 0, "noroot");  /* XXX a netboot-specific icon would be nicer */
+                       vc_progress_set(FALSE, 0);
+                       for (i=1; 1; i*=2) {
+                               printf("bsd_init: failed to mount network root, error %d, %s\n",
+                                       err, PE_boot_args());
+                               printf("We are hanging here...\n");
+                               IOSleep(i*60*1000);
+                       }
+                       /*NOTREACHED*/

                }
 #endif
                printf("cannot mount root, errno = %d\n", err);
                }
 #endif
                printf("cannot mount root, errno = %d\n", err);


@@ -795,7 +889,7 @@ bsd_init(void)
        IOSecureBSDRoot(rootdevice);
 
        context.vc_thread = current_thread();
        IOSecureBSDRoot(rootdevice);
 
        context.vc_thread = current_thread();

-       context.vc_ucred = p->p_ucred;
+       context.vc_ucred = kernproc->p_ucred;

        mountlist.tqh_first->mnt_flag |= MNT_ROOTFS;
 
        bsd_init_kprintf("calling VFS_ROOT\n");
        mountlist.tqh_first->mnt_flag |= MNT_ROOTFS;
 
        bsd_init_kprintf("calling VFS_ROOT\n");


@@ -808,11 +902,21 @@ bsd_init(void)
        filedesc0.fd_cdir = rootvnode;
 
 #if NFSCLIENT
        filedesc0.fd_cdir = rootvnode;
 
 #if NFSCLIENT

-       if (mountroot == netboot_mountroot) {
+       if (netboot) {

                int err;
                int err;

+
+               netboot = TRUE;

                /* post mount setup */
                if ((err = netboot_setup()) != 0) {
                /* post mount setup */
                if ((err = netboot_setup()) != 0) {

-                       panic("bsd_init: NetBoot could not find root, %d: %s", err, PE_boot_args());
+                       PE_display_icon( 0, "noroot");  /* XXX a netboot-specific icon would be nicer */
+                       vc_progress_set(FALSE, 0);
+                       for (i=1; 1; i*=2) {
+                               printf("bsd_init: NetBoot could not find root, error %d: %s\n",
+                                       err, PE_boot_args());
+                               printf("We are hanging here...\n");
+                               IOSleep(i*60*1000);
+                       }
+                       /*NOTREACHED*/

                }
        }
 #endif
                }
        }
 #endif


@@ -823,25 +927,18 @@ bsd_init(void)
         * See if a system disk image is present. If so, mount it and
         * switch the root vnode to point to it
         */ 
         * See if a system disk image is present. If so, mount it and
         * switch the root vnode to point to it
         */ 

-  
-       if(imageboot_needed()) {
-               int err;
-
-               /* An image was found */
-               if((err = imageboot_setup())) {
-                       /*
-                        * this is not fatal. Keep trying to root
-                        * off the original media
-                        */
-                       printf("%s: imageboot could not find root, %d\n",
-                               __FUNCTION__, err);
-               }
+       if (netboot == FALSE && imageboot_needed()) {
+               /* 
+                * An image was found.  No turning back: we're booted
+                * with a kernel from the disk image.
+                */
+               imageboot_setup(); 

        }
 #endif /* CONFIG_IMAGEBOOT */
   
        }
 #endif /* CONFIG_IMAGEBOOT */
   

-       microtime(&p->p_stats->p_start);        /* for compat sake */
-       microtime(&p->p_start);
-       p->p_rtime.tv_sec = p->p_rtime.tv_usec = 0;
+       /* set initial time; all other resource data is  already zero'ed */
+       microtime(&kernproc->p_start);
+       kernproc->p_stats->p_start = kernproc->p_start; /* for compat */

 
 #if DEVFS
        {
 
 #if DEVFS
        {


@@ -854,14 +951,21 @@ bsd_init(void)
        
        /* Initialize signal state for process 0. */
        bsd_init_kprintf("calling siginit\n");
        
        /* Initialize signal state for process 0. */
        bsd_init_kprintf("calling siginit\n");

-       siginit(p);
+       siginit(kernproc);

 
        bsd_init_kprintf("calling bsd_utaskbootstrap\n");
        bsd_utaskbootstrap();
 
 
        bsd_init_kprintf("calling bsd_utaskbootstrap\n");
        bsd_utaskbootstrap();
 

-#if __i386__
+#if defined(__LP64__)
+       kernproc->p_flag |= P_LP64;
+       printf("Kernel is LP64\n");
+#endif
+
+       pal_kernel_announce();
+
+#if __i386__ || __x86_64__

        /* this should be done after the root filesystem is mounted */
        /* this should be done after the root filesystem is mounted */

-       error = set_archhandler(p, CPU_TYPE_POWERPC);
+       error = set_archhandler(kernproc, CPU_TYPE_POWERPC);

        if (error) /* XXX make more generic */
                exec_archhandler_ppc.path[0] = 0;
 #endif 
        if (error) /* XXX make more generic */
                exec_archhandler_ppc.path[0] = 0;
 #endif 


@@ -873,10 +977,9 @@ bsd_init(void)
                mountroot_post_hook();
 
 #if 0 /* not yet */
                mountroot_post_hook();
 
 #if 0 /* not yet */

-       IOKitJettisonKLD();
-       consider_zone_gc();
+       consider_zone_gc(FALSE);

 #endif
 #endif

-       
+

        bsd_init_kprintf("done\n");
 }
 
        bsd_init_kprintf("done\n");
 }
 


@@ -894,11 +997,8 @@ bsdinit_task(void)
 
        thread = current_thread();
        (void) host_set_exception_ports(host_priv_self(),
 
        thread = current_thread();
        (void) host_set_exception_ports(host_priv_self(),

-                                       EXC_MASK_ALL & ~(EXC_MASK_SYSCALL |
-                                                        EXC_MASK_MACH_SYSCALL |
-                                                        EXC_MASK_RPC_ALERT |
-                                                        EXC_MASK_CRASH),
-                                       (mach_port_t)ux_exception_port,
+                                       EXC_MASK_ALL & ~(EXC_MASK_RPC_ALERT),//pilotfish (shark) needs this port
+                                       (mach_port_t) ux_exception_port,

                                        EXCEPTION_DEFAULT| MACH_EXCEPTION_CODES,
                                        0);
 
                                        EXCEPTION_DEFAULT| MACH_EXCEPTION_CODES,
                                        0);
 


@@ -991,17 +1091,24 @@ bsd_utaskbootstrap(void)
        thread_t thread;
        struct uthread *ut;
 
        thread_t thread;
        struct uthread *ut;
 

-       thread = cloneproc(kernproc, 0);
+       /*
+        * Clone the bootstrap process from the kernel process, without
+        * inheriting either task characteristics or memory from the kernel;
+        */
+       thread = cloneproc(TASK_NULL, kernproc, FALSE);
+

        /* Hold the reference as it will be dropped during shutdown */
        initproc = proc_find(1);                                
 #if __PROC_INTERNAL_DEBUG
        if (initproc == PROC_NULL)
                panic("bsd_utaskbootstrap: initproc not set\n");
 #endif
        /* Hold the reference as it will be dropped during shutdown */
        initproc = proc_find(1);                                
 #if __PROC_INTERNAL_DEBUG
        if (initproc == PROC_NULL)
                panic("bsd_utaskbootstrap: initproc not set\n");
 #endif

-       /* Set the launch time for init */
-       microtime(&initproc->p_start);
-       microtime(&initproc->p_stats->p_start); /* for compat sake */
-       
+       /*
+        * Since we aren't going back out the normal way to our parent,
+        * we have to drop the transition locks explicitly.
+        */
+       proc_signalend(initproc, 0);
+       proc_transend(initproc, 0);

 
        ut = (struct uthread *)get_bsdthread_info(thread);
        ut->uu_sigmask = 0;
 
        ut = (struct uthread *)get_bsdthread_info(thread);
        ut->uu_sigmask = 0;


@@ -1015,34 +1122,85 @@ parse_bsd_args(void)
        char namep[16];
        int msgbuf;
 
        char namep[16];
        int msgbuf;
 

-       if (PE_parse_boot_arg("-s", namep))
+       if (PE_parse_boot_argn("-s", namep, sizeof (namep)))

                boothowto |= RB_SINGLE;
 
                boothowto |= RB_SINGLE;
 

-       if (PE_parse_boot_arg("-b", namep))
+       if (PE_parse_boot_argn("-b", namep, sizeof (namep)))

                boothowto |= RB_NOBOOTRC;
 
                boothowto |= RB_NOBOOTRC;
 

-       if (PE_parse_boot_arg("-x", namep)) /* safe boot */
+       if (PE_parse_boot_argn("-x", namep, sizeof (namep))) /* safe boot */

                boothowto |= RB_SAFEBOOT;
 
                boothowto |= RB_SAFEBOOT;
 

-       if (PE_parse_boot_arg("-l", namep)) /* leaks logging */
-               turn_on_log_leaks = 1;
+       /* disable 64 bit grading */
+       if (PE_parse_boot_argn("-no64exec", namep, sizeof (namep)))
+               bootarg_no64exec = 1;

 
 

-       PE_parse_boot_arg("srv", &srv);
-       PE_parse_boot_arg("ncl", &ncl);
-       if (PE_parse_boot_arg("nbuf", &max_nbuf_headers)) {
+       /* disable vnode_cache_is_authorized() by setting vnode_cache_defeat */
+       if (PE_parse_boot_argn("-vnode_cache_defeat", namep, sizeof (namep)))
+               bootarg_vnode_cache_defeat = 1;
+
+#if DEVELOPMENT || DEBUG
+       if (PE_parse_boot_argn("-disable_aslr", namep, sizeof (namep)))
+               bootarg_disable_aslr = 1;
+#endif
+
+       PE_parse_boot_argn("ncl", &ncl, sizeof (ncl));
+       if (PE_parse_boot_argn("nbuf", &max_nbuf_headers,
+                               sizeof (max_nbuf_headers))) {

                customnbuf = 1;
        }
 #if !defined(SECURE_KERNEL)
                customnbuf = 1;
        }
 #if !defined(SECURE_KERNEL)

-       PE_parse_boot_arg("kmem", &setup_kmem);
+       PE_parse_boot_argn("kmem", &setup_kmem, sizeof (setup_kmem));

 #endif
 #endif

-       PE_parse_boot_arg("trace", &new_nkdbufs);

 
 

-       if (PE_parse_boot_arg("msgbuf", &msgbuf)) {
+#if CONFIG_MACF
+#if defined (__i386__) || defined (__x86_64__)
+       PE_parse_boot_argn("policy_check", &policy_check_flags, sizeof (policy_check_flags));
+#endif
+#endif /* CONFIG_MACF */
+
+       if (PE_parse_boot_argn("msgbuf", &msgbuf, sizeof (msgbuf))) {

                log_setsize(msgbuf);
        }
                log_setsize(msgbuf);
        }

+
+       if (PE_parse_boot_argn("-novfscache", namep, sizeof(namep))) {
+               nc_disabled = 1;
+       }
+}
+
+void
+bsd_exec_setup(int scale)
+{
+
+       switch (scale) {
+               case 0:
+               case 1:
+                       bsd_simul_execs = BSD_SIMUL_EXECS;
+                       break;
+               case 2:
+               case 3:
+                       bsd_simul_execs = 65;
+                       break;
+               case 4:
+               case 5:
+                       bsd_simul_execs = 129;
+                       break;
+               case 6:
+               case 7:
+                       bsd_simul_execs = 257;
+                       break;
+               default:
+                       bsd_simul_execs = 513;
+                       break;
+                       
+       }
+       bsd_pageable_map_size = (bsd_simul_execs * BSD_PAGEABLE_SIZE_PER_EXEC);

 }
 
 #if !NFSCLIENT
 }
 
 #if !NFSCLIENT

+int 
+netboot_root(void);
+

 int 
 netboot_root(void)
 {
 int 
 netboot_root(void)
 {