xnu-792.21.3.tar.gz

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

diff --git a/bsd/kern/netboot.c b/bsd/kern/netboot.c
index 4043bc9d31d66bbb513213291d5382a8e005a8a8..97ca556cfcc8a7ac0fbfc807ff375901089f46a6 100644 (file)
--- a/bsd/kern/netboot.c
+++ b/bsd/kern/netboot.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2001 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2001-2004 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 
 /*
  */
 
 /*


@@ -30,13 +36,14 @@
 #include <sys/kernel.h>
 #include <sys/conf.h>
 #include <sys/ioctl.h>
 #include <sys/kernel.h>
 #include <sys/conf.h>
 #include <sys/ioctl.h>

-#include <sys/proc.h>
-#include <sys/mount.h>
+#include <sys/proc_internal.h>
+#include <sys/mount_internal.h>

 #include <sys/mbuf.h>
 #include <sys/filedesc.h>
 #include <sys/mbuf.h>
 #include <sys/filedesc.h>

-#include <sys/vnode.h>
+#include <sys/vnode_internal.h>

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

+#include <sys/socketvar.h>

 #include <sys/reboot.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/reboot.h>
 #include <net/if.h>
 #include <net/if_dl.h>


@@ -45,16 +52,19 @@
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 #include <netinet/dhcp_options.h>
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 #include <netinet/dhcp_options.h>

+#include <pexpert/pexpert.h>

 
 

+#include <kern/kern_types.h>
+#include <kern/kalloc.h>

 
 //#include <libkern/libkern.h>
 
 //#include <libkern/libkern.h>

-
-extern dev_t           rootdev;                /* device of the root */

 extern struct filedesc         filedesc0;
 
 extern struct filedesc         filedesc0;
 

+extern int     strncmp(const char *,const char *, size_t);
+extern unsigned long strtoul(const char *, char **, int);

 extern char *  strchr(const char *str, int ch);
 
 extern char *  strchr(const char *str, int ch);
 

-extern int     nfs_mountroot();        /* nfs_vfsops.c */
+extern int     nfs_mountroot(void);    /* nfs_vfsops.c */

 extern int (*mountroot)(void);
 
 extern unsigned char   rootdevice[];
 extern int (*mountroot)(void);
 
 extern unsigned char   rootdevice[];


@@ -63,24 +73,19 @@ static int                  S_netboot = 0;
 static struct netboot_info *   S_netboot_info_p;
 
 void *
 static struct netboot_info *   S_netboot_info_p;
 
 void *

-IOBSDRegistryEntryForDeviceTree(char * path);
+IOBSDRegistryEntryForDeviceTree(const char * path);

 
 void
 IOBSDRegistryEntryRelease(void * entry);
 
 const void *
 
 void
 IOBSDRegistryEntryRelease(void * entry);
 
 const void *

-IOBSDRegistryEntryGetData(void * entry, char * property_name, 
+IOBSDRegistryEntryGetData(void * entry, const char * property_name, 

                          int * packet_length);
 
 extern int vndevice_root_image(const char * path, char devname[], 
                               dev_t * dev_p);
 extern int di_root_image(const char *path, char devname[], dev_t *dev_p);
 
                          int * packet_length);
 
 extern int vndevice_root_image(const char * path, char devname[], 
                               dev_t * dev_p);
 extern int di_root_image(const char *path, char devname[], dev_t *dev_p);
 

-
-static boolean_t path_getfile __P((char * image_path, 
-                                  struct sockaddr_in * sin_p, 
-                                  char * serv_name, char * pathname));
-

 #define BOOTP_RESPONSE "bootp-response"
 #define BSDP_RESPONSE  "bsdp-response"
 #define DHCP_RESPONSE  "dhcp-response"
 #define BOOTP_RESPONSE "bootp-response"
 #define BSDP_RESPONSE  "bsdp-response"
 #define DHCP_RESPONSE  "dhcp-response"


@@ -90,6 +95,20 @@ bootp(struct ifnet * ifp, struct in_addr * iaddr_p, int max_retry,
       struct in_addr * netmask_p, struct in_addr * router_p,
       struct proc * procp);
 
       struct in_addr * netmask_p, struct in_addr * router_p,
       struct proc * procp);
 

+
+/* forward declarations */
+int    inet_aton(char * cp, struct in_addr * pin);
+
+boolean_t      netboot_iaddr(struct in_addr * iaddr_p);
+boolean_t      netboot_rootpath(struct in_addr * server_ip,
+                                char * name, int name_len, 
+                                char * path, int path_len);
+int    netboot_setup(struct proc * p);
+int    netboot_mountroot(void);
+int    netboot_root(void);
+
+
+

 #define IP_FORMAT      "%d.%d.%d.%d"
 #define IP_CH(ip)      ((u_char *)ip)
 #define IP_LIST(ip)    IP_CH(ip)[0],IP_CH(ip)[1],IP_CH(ip)[2],IP_CH(ip)[3]
 #define IP_FORMAT      "%d.%d.%d.%d"
 #define IP_CH(ip)      ((u_char *)ip)
 #define IP_LIST(ip)    IP_CH(ip)[0],IP_CH(ip)[1],IP_CH(ip)[2],IP_CH(ip)[3]


@@ -239,6 +258,7 @@ static __inline__ boolean_t
 parse_netboot_path(char * path, struct in_addr * iaddr_p, char * * host,
                   char * * mount_dir, char * * image_path)
 {
 parse_netboot_path(char * path, struct in_addr * iaddr_p, char * * host,
                   char * * mount_dir, char * * image_path)
 {

+       static char     tmp[MAX_IPv4_STR_LEN];  /* Danger - not thread safe */

     char *     start;
     char *     colon;
 
     char *     start;
     char *     colon;
 


@@ -272,7 +292,7 @@ parse_netboot_path(char * path, struct in_addr * iaddr_p, char * * host,
        (void)find_colon(start);
        *image_path = start;
     }
        (void)find_colon(start);
        *image_path = start;
     }

-    *host = inet_ntoa(*iaddr_p);
+    *host = inet_ntop(AF_INET, iaddr_p, tmp, sizeof(tmp));

     return (TRUE);
 }
 
     return (TRUE);
 }
 


@@ -301,13 +321,13 @@ get_root_path(char * root_path)
        return (FALSE);
     }
     pkt = IOBSDRegistryEntryGetData(entry, BSDP_RESPONSE, &pkt_len);
        return (FALSE);
     }
     pkt = IOBSDRegistryEntryGetData(entry, BSDP_RESPONSE, &pkt_len);

-    if (pkt != NULL && pkt_len >= sizeof(struct dhcp)) {
+    if (pkt != NULL && pkt_len >= (int)sizeof(struct dhcp)) {

        printf("netboot: retrieving root path from BSDP response\n");
     }
     else {
        pkt = IOBSDRegistryEntryGetData(entry, BOOTP_RESPONSE, 
                                        &pkt_len);
        printf("netboot: retrieving root path from BSDP response\n");
     }
     else {
        pkt = IOBSDRegistryEntryGetData(entry, BOOTP_RESPONSE, 
                                        &pkt_len);

-       if (pkt != NULL && pkt_len >= sizeof(struct dhcp)) {
+       if (pkt != NULL && pkt_len >= (int)sizeof(struct dhcp)) {

            printf("netboot: retrieving root path from BOOTP response\n");
        }
     }
            printf("netboot: retrieving root path from BOOTP response\n");
        }
     }


@@ -342,10 +362,12 @@ netboot_info_init(struct in_addr iaddr)
     char *                     vndevice = NULL;
 
     MALLOC_ZONE(vndevice, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
     char *                     vndevice = NULL;
 
     MALLOC_ZONE(vndevice, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);

+    if (vndevice == NULL)
+       panic("netboot_info_init: M_NAMEI zone exhausted");

     if (PE_parse_boot_arg("vndevice", vndevice) == TRUE) {
        use_hdix = FALSE;
     }
     if (PE_parse_boot_arg("vndevice", vndevice) == TRUE) {
        use_hdix = FALSE;
     }

-    _FREE_ZONE(vndevice, MAXPATHLEN, M_NAMEI);
+    FREE_ZONE(vndevice, MAXPATHLEN, M_NAMEI);

 
     info = (struct netboot_info *)kalloc(sizeof(*info));
     bzero(info, sizeof(*info));
 
     info = (struct netboot_info *)kalloc(sizeof(*info));
     bzero(info, sizeof(*info));


@@ -355,6 +377,8 @@ netboot_info_init(struct in_addr iaddr)
 
     /* check for a booter-specified path then a NetBoot path */
     MALLOC_ZONE(root_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
 
     /* check for a booter-specified path then a NetBoot path */
     MALLOC_ZONE(root_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);

+    if (root_path  == NULL)
+       panic("netboot_info_init: M_NAMEI zone exhausted");

     if (PE_parse_boot_arg("rp", root_path) == TRUE
        || PE_parse_boot_arg("rootpath", root_path) == TRUE
        || get_root_path(root_path) == TRUE) {
     if (PE_parse_boot_arg("rp", root_path) == TRUE
        || PE_parse_boot_arg("rootpath", root_path) == TRUE
        || get_root_path(root_path) == TRUE) {


@@ -377,7 +401,7 @@ netboot_info_init(struct in_addr iaddr)
            printf("Server %s Mount %s", 
                   server_name, info->mount_point);
            if (image_path != NULL) {
            printf("Server %s Mount %s", 
                   server_name, info->mount_point);
            if (image_path != NULL) {

-               boolean_t       needs_slash;
+               boolean_t       needs_slash = FALSE;

 
                info->image_path_length = strlen(image_path) + 1;
                if (image_path[0] != '/') {
 
                info->image_path_length = strlen(image_path) + 1;
                if (image_path[0] != '/') {


@@ -409,7 +433,7 @@ netboot_info_init(struct in_addr iaddr)
            printf("netboot: root path uses unrecognized format\n");
        }
     }
            printf("netboot: root path uses unrecognized format\n");
        }
     }

-    _FREE_ZONE(root_path, MAXPATHLEN, M_NAMEI);
+    FREE_ZONE(root_path, MAXPATHLEN, M_NAMEI);

     return (info);
 }
 
     return (info);
 }
 


@@ -484,12 +508,12 @@ get_ip_parameters(struct in_addr * iaddr_p, struct in_addr * netmask_p,
        return (FALSE);
     }
     pkt = IOBSDRegistryEntryGetData(entry, DHCP_RESPONSE, &pkt_len);
        return (FALSE);
     }
     pkt = IOBSDRegistryEntryGetData(entry, DHCP_RESPONSE, &pkt_len);

-    if (pkt != NULL && pkt_len >= sizeof(struct dhcp)) {
+    if (pkt != NULL && pkt_len >= (int)sizeof(struct dhcp)) {

        printf("netboot: retrieving IP information from DHCP response\n");
     }
     else {
        pkt = IOBSDRegistryEntryGetData(entry, BOOTP_RESPONSE, &pkt_len);
        printf("netboot: retrieving IP information from DHCP response\n");
     }
     else {
        pkt = IOBSDRegistryEntryGetData(entry, BOOTP_RESPONSE, &pkt_len);

-       if (pkt != NULL && pkt_len >= sizeof(struct dhcp)) {
+       if (pkt != NULL && pkt_len >= (int)sizeof(struct dhcp)) {

            printf("netboot: retrieving IP information from BOOTP response\n");
        }
     }
            printf("netboot: retrieving IP information from BOOTP response\n");
        }
     }


@@ -523,9 +547,13 @@ inet_aifaddr(struct socket * so, char * name, const struct in_addr * addr,
             const struct in_addr * mask,
             const struct in_addr * broadcast)
 {
             const struct in_addr * mask,
             const struct in_addr * broadcast)
 {

-    struct sockaddr    blank_sin = { sizeof(blank_sin), AF_INET };
+    struct sockaddr    blank_sin;

     struct ifaliasreq  ifra;
 
     struct ifaliasreq  ifra;
 

+    bzero(&blank_sin, sizeof(blank_sin));
+    blank_sin.sa_len = sizeof(blank_sin);
+    blank_sin.sa_family = AF_INET;
+

     bzero(&ifra, sizeof(ifra));
     strncpy(ifra.ifra_name, name, sizeof(ifra.ifra_name));
     if (addr) {
     bzero(&ifra, sizeof(ifra));
     strncpy(ifra.ifra_name, name, sizeof(ifra.ifra_name));
     if (addr) {


@@ -544,59 +572,78 @@ inet_aifaddr(struct socket * so, char * name, const struct in_addr * addr,
 }
 
 static int
 }
 
 static int

-default_route_add(struct in_addr router, boolean_t proxy_arp)
+route_cmd(int cmd, struct in_addr d, struct in_addr g, 
+         struct in_addr m, u_long more_flags)

 {
     struct sockaddr_in                 dst;
     u_long                     flags = RTF_UP | RTF_STATIC;
     struct sockaddr_in         gw;
     struct sockaddr_in         mask;
     
 {
     struct sockaddr_in                 dst;
     u_long                     flags = RTF_UP | RTF_STATIC;
     struct sockaddr_in         gw;
     struct sockaddr_in         mask;
     

-    if (proxy_arp == FALSE) {
-       flags |= RTF_GATEWAY;
-    }
+    flags |= more_flags;

 
 

-    /* dest 0.0.0.0 */
+    /* destination */

     bzero((caddr_t)&dst, sizeof(dst));
     dst.sin_len = sizeof(dst);
     dst.sin_family = AF_INET;
     bzero((caddr_t)&dst, sizeof(dst));
     dst.sin_len = sizeof(dst);
     dst.sin_family = AF_INET;

+    dst.sin_addr = d;

 
     /* gateway */
     bzero((caddr_t)&gw, sizeof(gw));
     gw.sin_len = sizeof(gw);
     gw.sin_family = AF_INET;
 
     /* gateway */
     bzero((caddr_t)&gw, sizeof(gw));
     gw.sin_len = sizeof(gw);
     gw.sin_family = AF_INET;

-    gw.sin_addr = router;
+    gw.sin_addr = g;

 
 

-    /* mask 0.0.0.0 */
+    /* mask */

     bzero(&mask, sizeof(mask));
     mask.sin_len = sizeof(mask);
     mask.sin_family = AF_INET;
     bzero(&mask, sizeof(mask));
     mask.sin_len = sizeof(mask);
     mask.sin_family = AF_INET;

+    mask.sin_addr = m;

 
 

-    printf("netboot: adding default route " IP_FORMAT "\n", 
-          IP_LIST(&router));
-
-    return (rtrequest(RTM_ADD, (struct sockaddr *)&dst, (struct sockaddr *)&gw,
+    return (rtrequest(cmd, (struct sockaddr *)&dst, (struct sockaddr *)&gw,

                      (struct sockaddr *)&mask, flags, NULL));
 }
 
                      (struct sockaddr *)&mask, flags, NULL));
 }
 

+static int
+default_route_add(struct in_addr router, boolean_t proxy_arp)
+{
+    u_long                     flags = 0;
+    struct in_addr             zeroes = { 0 };
+    
+    if (proxy_arp == FALSE) {
+       flags |= RTF_GATEWAY;
+    }
+    return (route_cmd(RTM_ADD, zeroes, router, zeroes, flags));
+}
+
+static int
+host_route_delete(struct in_addr host)
+{
+    struct in_addr             zeroes = { 0 };
+    
+    return (route_cmd(RTM_DELETE, host, zeroes, zeroes, RTF_HOST));
+}
+

 static struct ifnet *
 static struct ifnet *

-find_interface()
+find_interface(void)

 {
     struct ifnet *             ifp = NULL;
 
     if (rootdevice[0]) {
 {
     struct ifnet *             ifp = NULL;
 
     if (rootdevice[0]) {

-       ifp = ifunit(rootdevice);
+               ifp = ifunit(rootdevice);

     }
     if (ifp == NULL) {
     }
     if (ifp == NULL) {

-       TAILQ_FOREACH(ifp, &ifnet, if_link)
-           if ((ifp->if_flags &
-                (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
-               break;
+               ifnet_head_lock_shared();
+               TAILQ_FOREACH(ifp, &ifnet_head, if_link)
+                       if ((ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
+                               break;
+               ifnet_head_done();

     }
     return (ifp);
 }
 
 int
     }
     return (ifp);
 }
 
 int

-netboot_mountroot()
+netboot_mountroot(void)

 {
     int                        error = 0;
     struct in_addr             iaddr = { 0 };
 {
     int                        error = 0;
     struct in_addr             iaddr = { 0 };


@@ -606,10 +653,10 @@ netboot_mountroot()
     struct proc *              procp = current_proc();
     struct in_addr             router = { 0 };
     struct socket *            so = NULL;
     struct proc *              procp = current_proc();
     struct in_addr             router = { 0 };
     struct socket *            so = NULL;

+    unsigned int               try;

 
     bzero(&ifr, sizeof(ifr));
 
 
     bzero(&ifr, sizeof(ifr));
 

-    thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);

 
     /* find the interface */
     ifp = find_interface();
 
     /* find the interface */
     ifp = find_interface();


@@ -659,19 +706,56 @@ netboot_mountroot()
        /* enable proxy arp if we don't have a router */
        router.s_addr = iaddr.s_addr;
     }
        /* enable proxy arp if we don't have a router */
        router.s_addr = iaddr.s_addr;
     }

+    printf("netboot: adding default route " IP_FORMAT "\n", 
+          IP_LIST(&router));

     error = default_route_add(router, router.s_addr == iaddr.s_addr);
     if (error) {
        printf("netboot: default_route_add failed %d\n", error);
     }
 
     soclose(so);
     error = default_route_add(router, router.s_addr == iaddr.s_addr);
     if (error) {
        printf("netboot: default_route_add failed %d\n", error);
     }
 
     soclose(so);

-    thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);

 
     S_netboot_info_p = netboot_info_init(iaddr);
     switch (S_netboot_info_p->image_type) {
     default:
     case kNetBootImageTypeNFS:
 
     S_netboot_info_p = netboot_info_init(iaddr);
     switch (S_netboot_info_p->image_type) {
     default:
     case kNetBootImageTypeNFS:

-       error = nfs_mountroot();
+       for (try = 1; TRUE; try++) {
+           error = nfs_mountroot();
+           if (error == 0) {
+               break;
+           }
+           printf("netboot: nfs_mountroot() attempt %u failed; "
+                  "clearing ARP entry and trying again\n", try);
+           /* 
+            * error is either EHOSTDOWN or EHOSTUNREACH, which likely means
+            * that the port we're plugged into has spanning tree enabled,
+            * and either the router or the server can't answer our ARP
+            * requests.  Clear the incomplete ARP entry by removing the
+            * appropriate route, depending on the error code:
+            *     EHOSTDOWN            NFS server's route
+            *     EHOSTUNREACH         router's route
+            */
+           switch (error) {
+           default:
+               /* NOT REACHED */
+           case EHOSTDOWN:
+               /* remove the server's arp entry */
+               error = host_route_delete(S_netboot_info_p->server_ip);
+               if (error) {
+                   printf("netboot: host_route_delete(" IP_FORMAT
+                          ") failed %d\n", 
+                          IP_LIST(&S_netboot_info_p->server_ip), error);
+               }
+               break;
+           case EHOSTUNREACH:
+               error = host_route_delete(router);
+               if (error) {
+                   printf("netboot: host_route_delete(" IP_FORMAT
+                          ") failed %d\n", IP_LIST(&router), error);
+               }
+               break;
+           }
+       }

        break;
     case kNetBootImageTypeHTTP:
        error = netboot_setup(procp);
        break;
     case kNetBootImageTypeHTTP:
        error = netboot_setup(procp);


@@ -688,7 +772,6 @@ failed:
     if (so != NULL) {
        soclose(so);
     }
     if (so != NULL) {
        soclose(so);
     }

-    thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);

     return (error);
 }
 
     return (error);
 }
 


@@ -727,20 +810,24 @@ netboot_setup(struct proc * p)
     if (error == 0 && rootvnode != NULL) {
         struct vnode *tvp;
         struct vnode *newdp;
     if (error == 0 && rootvnode != NULL) {
         struct vnode *tvp;
         struct vnode *newdp;

+       struct vfs_context context;
+
+       context.vc_proc = p;
+       context.vc_ucred = proc_ucred(p);       /* XXX kauth_cred_get() ??? proxy */

 
        /* Get the vnode for '/'.  Set fdp->fd_fd.fd_cdir to reference it. */
 
        /* Get the vnode for '/'.  Set fdp->fd_fd.fd_cdir to reference it. */

-       if (VFS_ROOT(mountlist.cqh_last, &newdp))
+       if (VFS_ROOT(mountlist.tqh_last, &newdp, &context))

                panic("netboot_setup: cannot find root vnode");
                panic("netboot_setup: cannot find root vnode");

-       VREF(newdp);
+       vnode_ref(newdp);
+       vnode_put(newdp);

        tvp = rootvnode;
        tvp = rootvnode;

-       vrele(tvp);
+       vnode_rele(tvp);

        filedesc0.fd_cdir = newdp;
        rootvnode = newdp;
        filedesc0.fd_cdir = newdp;
        rootvnode = newdp;

-       simple_lock(&mountlist_slock);
-       CIRCLEQ_REMOVE(&mountlist, CIRCLEQ_FIRST(&mountlist), mnt_list);
-       simple_unlock(&mountlist_slock);
-       VOP_UNLOCK(rootvnode, 0, p);
-       mountlist.cqh_first->mnt_flag |= MNT_ROOTFS;
+       mount_list_lock();
+       TAILQ_REMOVE(&mountlist, TAILQ_FIRST(&mountlist), mnt_list);
+       mount_list_unlock();
+       mountlist.tqh_first->mnt_flag |= MNT_ROOTFS;

     }
  done:
     netboot_info_free(&S_netboot_info_p);
     }
  done:
     netboot_info_free(&S_netboot_info_p);


@@ -748,7 +835,7 @@ netboot_setup(struct proc * p)
 }
 
 int
 }
 
 int

-netboot_root()
+netboot_root(void)

 {
     return (S_netboot);
 }
 {
     return (S_netboot);
 }