xnu-7195.101.1.tar.gz

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

diff --git a/bsd/kern/kpi_mbuf.c b/bsd/kern/kpi_mbuf.c
index 6cb79b10e8bcc66f8b7a159f709ea7e32f4b82a0..8e1d821ce3564e9fa5d0ec5a6e057412e1c0f732 100644 (file)
--- a/bsd/kern/kpi_mbuf.c
+++ b/bsd/kern/kpi_mbuf.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2004-2017 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2019 Apple Inc. All rights reserved.

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


@@ -26,7 +26,7 @@
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 

-#define        __KPI__
+#define __KPI__

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


@@ -34,7 +34,6 @@
 #include <sys/socket.h>
 #include <kern/debug.h>
 #include <libkern/OSAtomic.h>
 #include <sys/socket.h>
 #include <kern/debug.h>
 #include <libkern/OSAtomic.h>

-#include <kern/kalloc.h>

 #include <string.h>
 #include <net/dlil.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <net/dlil.h>
 #include <netinet/in.h>


@@ -50,10 +49,10 @@ static const mbuf_flags_t mbuf_flags_mask = (MBUF_EXT | MBUF_PKTHDR | MBUF_EOR |
 /* Unalterable mbuf flags */
 static const mbuf_flags_t mbuf_cflags_mask = (MBUF_EXT);
 
 /* Unalterable mbuf flags */
 static const mbuf_flags_t mbuf_cflags_mask = (MBUF_EXT);
 

-#define        MAX_MBUF_TX_COMPL_FUNC 32
+#define MAX_MBUF_TX_COMPL_FUNC 32

 mbuf_tx_compl_func
 mbuf_tx_compl_func

-mbuf_tx_compl_table[MAX_MBUF_TX_COMPL_FUNC];
-extern lck_rw_t *mbuf_tx_compl_tbl_lock;
+    mbuf_tx_compl_table[MAX_MBUF_TX_COMPL_FUNC];
+extern lck_rw_t mbuf_tx_compl_tbl_lock;

 u_int32_t mbuf_tx_compl_index = 0;
 
 #if (DEVELOPMENT || DEBUG)
 u_int32_t mbuf_tx_compl_index = 0;
 
 #if (DEVELOPMENT || DEBUG)


@@ -77,43 +76,47 @@ SYSCTL_QUAD(_kern_ipc_mbtxcf, OID_AUTO, aborted,
 void *
 mbuf_data(mbuf_t mbuf)
 {
 void *
 mbuf_data(mbuf_t mbuf)
 {

-       return (mbuf->m_data);
+       return mbuf->m_data;

 }
 
 void *
 mbuf_datastart(mbuf_t mbuf)
 {
 }
 
 void *
 mbuf_datastart(mbuf_t mbuf)
 {

-       if (mbuf->m_flags & M_EXT)
-               return (mbuf->m_ext.ext_buf);
-       if (mbuf->m_flags & M_PKTHDR)
-               return (mbuf->m_pktdat);
-       return (mbuf->m_dat);
+       if (mbuf->m_flags & M_EXT) {
+               return mbuf->m_ext.ext_buf;
+       }
+       if (mbuf->m_flags & M_PKTHDR) {
+               return mbuf->m_pktdat;
+       }
+       return mbuf->m_dat;

 }
 
 errno_t
 mbuf_setdata(mbuf_t mbuf, void *data, size_t len)
 {
 }
 
 errno_t
 mbuf_setdata(mbuf_t mbuf, void *data, size_t len)
 {

-       size_t  start = (size_t)((char *)mbuf_datastart(mbuf));
-       size_t  maxlen = mbuf_maxlen(mbuf);
+       size_t  start = (size_t)((char *)mbuf_datastart(mbuf));
+       size_t  maxlen = mbuf_maxlen(mbuf);

 
 

-       if ((size_t)data < start || ((size_t)data) + len > start + maxlen)
-               return (EINVAL);
+       if ((size_t)data < start || ((size_t)data) + len > start + maxlen) {
+               return EINVAL;
+       }

        mbuf->m_data = data;
        mbuf->m_len = len;
 
        mbuf->m_data = data;
        mbuf->m_len = len;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_align_32(mbuf_t mbuf, size_t len)
 {
 }
 
 errno_t
 mbuf_align_32(mbuf_t mbuf, size_t len)
 {

-       if ((mbuf->m_flags & M_EXT) != 0 && m_mclhasreference(mbuf))
-               return (ENOTSUP);
+       if ((mbuf->m_flags & M_EXT) != 0 && m_mclhasreference(mbuf)) {
+               return ENOTSUP;
+       }

        mbuf->m_data = mbuf_datastart(mbuf);
        mbuf->m_data +=
        mbuf->m_data = mbuf_datastart(mbuf);
        mbuf->m_data +=

-           ((mbuf_trailingspace(mbuf) - len) &~ (sizeof(u_int32_t) - 1));
+           ((mbuf_trailingspace(mbuf) - len) & ~(sizeof(u_int32_t) - 1));

 
 

-       return (0);
+       return 0;

 }
 
 /*
 }
 
 /*


@@ -124,7 +127,7 @@ mbuf_align_32(mbuf_t mbuf, size_t len)
 addr64_t
 mbuf_data_to_physical(void *ptr)
 {
 addr64_t
 mbuf_data_to_physical(void *ptr)
 {

-       return ((addr64_t)mcl_to_paddr(ptr));
+       return (addr64_t)mcl_to_paddr(ptr);

 }
 
 errno_t
 }
 
 errno_t


@@ -133,7 +136,7 @@ mbuf_get(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)
        /* Must set *mbuf to NULL in failure case */
        *mbuf = m_get(how, type);
 
        /* Must set *mbuf to NULL in failure case */
        *mbuf = m_get(how, type);
 

-       return (*mbuf == NULL ? ENOMEM : 0);
+       return *mbuf == NULL ? ENOMEM : 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -142,7 +145,7 @@ mbuf_gethdr(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)
        /* Must set *mbuf to NULL in failure case */
        *mbuf = m_gethdr(how, type);
 
        /* Must set *mbuf to NULL in failure case */
        *mbuf = m_gethdr(how, type);
 

-       return (*mbuf == NULL ? ENOMEM : 0);
+       return *mbuf == NULL ? ENOMEM : 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -150,14 +153,16 @@ mbuf_attachcluster(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf,
     caddr_t extbuf, void (*extfree)(caddr_t, u_int, caddr_t),
     size_t extsize, caddr_t extarg)
 {
     caddr_t extbuf, void (*extfree)(caddr_t, u_int, caddr_t),
     size_t extsize, caddr_t extarg)
 {

-       if (mbuf == NULL || extbuf == NULL || extfree == NULL || extsize == 0)
-               return (EINVAL);
+       if (mbuf == NULL || extbuf == NULL || extfree == NULL || extsize == 0) {
+               return EINVAL;
+       }

 
        if ((*mbuf = m_clattach(*mbuf, type, extbuf,
 
        if ((*mbuf = m_clattach(*mbuf, type, extbuf,

-           extfree, extsize, extarg, how, 0)) == NULL)
-               return (ENOMEM);
+           extfree, extsize, extarg, how, 0)) == NULL) {
+               return ENOMEM;
+       }

 
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -167,115 +172,128 @@ mbuf_ring_cluster_alloc(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf,
        caddr_t extbuf = NULL;
        errno_t err;
 
        caddr_t extbuf = NULL;
        errno_t err;
 

-       if (mbuf == NULL || extfree == NULL || size == NULL || *size == 0)
-               return (EINVAL);
+       if (mbuf == NULL || extfree == NULL || size == NULL || *size == 0) {
+               return EINVAL;
+       }

 
 

-       if ((err = mbuf_alloccluster(how, size, &extbuf)) != 0)
-               return (err);
+       if ((err = mbuf_alloccluster(how, size, &extbuf)) != 0) {
+               return err;
+       }

 
        if ((*mbuf = m_clattach(*mbuf, type, extbuf,
            extfree, *size, NULL, how, 1)) == NULL) {
                mbuf_freecluster(extbuf, *size);
 
        if ((*mbuf = m_clattach(*mbuf, type, extbuf,
            extfree, *size, NULL, how, 1)) == NULL) {
                mbuf_freecluster(extbuf, *size);

-               return (ENOMEM);
+               return ENOMEM;

        }
 
        }
 

-       return (0);
+       return 0;

 }
 
 int
 mbuf_ring_cluster_is_active(mbuf_t mbuf)
 {
 }
 
 int
 mbuf_ring_cluster_is_active(mbuf_t mbuf)
 {

-       return (m_ext_paired_is_active(mbuf));
+       return m_ext_paired_is_active(mbuf);

 }
 
 errno_t
 mbuf_ring_cluster_activate(mbuf_t mbuf)
 {
 }
 
 errno_t
 mbuf_ring_cluster_activate(mbuf_t mbuf)
 {

-       if (mbuf_ring_cluster_is_active(mbuf))
-               return (EBUSY);
+       if (mbuf_ring_cluster_is_active(mbuf)) {
+               return EBUSY;
+       }

 
        m_ext_paired_activate(mbuf);
 
        m_ext_paired_activate(mbuf);

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_cluster_set_prop(mbuf_t mbuf, u_int32_t oldprop, u_int32_t newprop)
 {
 }
 
 errno_t
 mbuf_cluster_set_prop(mbuf_t mbuf, u_int32_t oldprop, u_int32_t newprop)
 {

-       if (mbuf == NULL || !(mbuf->m_flags & M_EXT))
-               return (EINVAL);
+       if (mbuf == NULL || !(mbuf->m_flags & M_EXT)) {
+               return EINVAL;
+       }

 
 

-       return (m_ext_set_prop(mbuf, oldprop, newprop) ? 0 : EBUSY);
+       return m_ext_set_prop(mbuf, oldprop, newprop) ? 0 : EBUSY;

 }
 
 errno_t
 mbuf_cluster_get_prop(mbuf_t mbuf, u_int32_t *prop)
 {
 }
 
 errno_t
 mbuf_cluster_get_prop(mbuf_t mbuf, u_int32_t *prop)
 {

-       if (mbuf == NULL || prop == NULL || !(mbuf->m_flags & M_EXT))
-               return (EINVAL);
+       if (mbuf == NULL || prop == NULL || !(mbuf->m_flags & M_EXT)) {
+               return EINVAL;
+       }

 
        *prop = m_ext_get_prop(mbuf);
 
        *prop = m_ext_get_prop(mbuf);

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_alloccluster(mbuf_how_t how, size_t *size, caddr_t *addr)
 {
 }
 
 errno_t
 mbuf_alloccluster(mbuf_how_t how, size_t *size, caddr_t *addr)
 {

-       if (size == NULL || *size == 0 || addr == NULL)
-               return (EINVAL);
+       if (size == NULL || *size == 0 || addr == NULL) {
+               return EINVAL;
+       }

 
        *addr = NULL;
 
        /* Jumbo cluster pool not available? */
 
        *addr = NULL;
 
        /* Jumbo cluster pool not available? */

-       if (*size > MBIGCLBYTES && njcl == 0)
-               return (ENOTSUP);
+       if (*size > MBIGCLBYTES && njcl == 0) {
+               return ENOTSUP;
+       }

 
 

-       if (*size <= MCLBYTES && (*addr = m_mclalloc(how)) != NULL)
+       if (*size <= MCLBYTES && (*addr = m_mclalloc(how)) != NULL) {

                *size = MCLBYTES;
                *size = MCLBYTES;

-       else if (*size > MCLBYTES && *size <= MBIGCLBYTES &&
-           (*addr = m_bigalloc(how)) != NULL)
+       } else if (*size > MCLBYTES && *size <= MBIGCLBYTES &&
+           (*addr = m_bigalloc(how)) != NULL) {

                *size = MBIGCLBYTES;
                *size = MBIGCLBYTES;

-       else if (*size > MBIGCLBYTES && *size <= M16KCLBYTES &&
-           (*addr = m_16kalloc(how)) != NULL)
+       } else if (*size > MBIGCLBYTES && *size <= M16KCLBYTES &&
+           (*addr = m_16kalloc(how)) != NULL) {

                *size = M16KCLBYTES;
                *size = M16KCLBYTES;

-       else
+       } else {

                *size = 0;
                *size = 0;

+       }

 
 

-       if (*addr == NULL)
-               return (ENOMEM);
+       if (*addr == NULL) {
+               return ENOMEM;
+       }

 
 

-       return (0);
+       return 0;

 }
 
 void
 mbuf_freecluster(caddr_t addr, size_t size)
 {
 }
 
 void
 mbuf_freecluster(caddr_t addr, size_t size)
 {

-       if (size != MCLBYTES && size != MBIGCLBYTES && size != M16KCLBYTES)
+       if (size != MCLBYTES && size != MBIGCLBYTES && size != M16KCLBYTES) {

                panic("%s: invalid size (%ld) for cluster %p", __func__,
                    size, (void *)addr);
                panic("%s: invalid size (%ld) for cluster %p", __func__,
                    size, (void *)addr);

+       }

 
 

-       if (size == MCLBYTES)
+       if (size == MCLBYTES) {

                m_mclfree(addr);
                m_mclfree(addr);

-       else if (size == MBIGCLBYTES)
+       } else if (size == MBIGCLBYTES) {

                m_bigfree(addr, MBIGCLBYTES, NULL);
                m_bigfree(addr, MBIGCLBYTES, NULL);

-       else if (njcl > 0)
+       } else if (njcl > 0) {

                m_16kfree(addr, M16KCLBYTES, NULL);
                m_16kfree(addr, M16KCLBYTES, NULL);

-       else
+       } else {

                panic("%s: freeing jumbo cluster to an empty pool", __func__);
                panic("%s: freeing jumbo cluster to an empty pool", __func__);

+       }

 }
 
 errno_t
 mbuf_getcluster(mbuf_how_t how, mbuf_type_t type, size_t size, mbuf_t *mbuf)
 {
        /* Must set *mbuf to NULL in failure case */
 }
 
 errno_t
 mbuf_getcluster(mbuf_how_t how, mbuf_type_t type, size_t size, mbuf_t *mbuf)
 {
        /* Must set *mbuf to NULL in failure case */

-       errno_t error = 0;
-       int     created = 0;
+       errno_t error = 0;
+       int     created = 0;

 
 

-       if (mbuf == NULL)
-               return (EINVAL);
+       if (mbuf == NULL) {
+               return EINVAL;
+       }

        if (*mbuf == NULL) {
                *mbuf = m_get(how, type);
        if (*mbuf == NULL) {
                *mbuf = m_get(how, type);

-               if (*mbuf == NULL)
-                       return (ENOMEM);
+               if (*mbuf == NULL) {
+                       return ENOMEM;
+               }

                created = 1;
        }
        /*
                created = 1;
        }
        /*


@@ -298,28 +316,31 @@ mbuf_getcluster(mbuf_how_t how, mbuf_type_t type, size_t size, mbuf_t *mbuf)
                error = EINVAL;
                goto out;
        }
                error = EINVAL;
                goto out;
        }

-       if (*mbuf == NULL || ((*mbuf)->m_flags & M_EXT) == 0)
+       if (*mbuf == NULL || ((*mbuf)->m_flags & M_EXT) == 0) {

                error = ENOMEM;
                error = ENOMEM;

+       }

 out:
        if (created && error != 0) {
                mbuf_free(*mbuf);
                *mbuf = NULL;
        }
 out:
        if (created && error != 0) {
                mbuf_free(*mbuf);
                *mbuf = NULL;
        }

-       return (error);
+       return error;

 }
 
 errno_t
 mbuf_mclget(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)
 {
        /* Must set *mbuf to NULL in failure case */
 }
 
 errno_t
 mbuf_mclget(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)
 {
        /* Must set *mbuf to NULL in failure case */

-       errno_t error = 0;
-       int             created = 0;
-       if (mbuf == NULL)
-               return (EINVAL);
+       errno_t error = 0;
+       int             created = 0;
+       if (mbuf == NULL) {
+               return EINVAL;
+       }

        if (*mbuf == NULL) {
                error = mbuf_get(how, type, mbuf);
        if (*mbuf == NULL) {
                error = mbuf_get(how, type, mbuf);

-               if (error)
-                       return (error);
+               if (error) {
+                       return error;
+               }

                created = 1;
        }
 
                created = 1;
        }
 


@@ -333,9 +354,10 @@ mbuf_mclget(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)
                mbuf_free(*mbuf);
                *mbuf = NULL;
        }
                mbuf_free(*mbuf);
                *mbuf = NULL;
        }

-       if (*mbuf == NULL || ((*mbuf)->m_flags & M_EXT) == 0)
+       if (*mbuf == NULL || ((*mbuf)->m_flags & M_EXT) == 0) {

                error = ENOMEM;
                error = ENOMEM;

-       return (error);
+       }
+       return error;

 }
 
 
 }
 
 


@@ -343,18 +365,19 @@ errno_t
 mbuf_getpacket(mbuf_how_t how, mbuf_t *mbuf)
 {
        /* Must set *mbuf to NULL in failure case */
 mbuf_getpacket(mbuf_how_t how, mbuf_t *mbuf)
 {
        /* Must set *mbuf to NULL in failure case */

-       errno_t error = 0;
+       errno_t error = 0;

 
        *mbuf = m_getpacket_how(how);
 
        if (*mbuf == NULL) {
 
        *mbuf = m_getpacket_how(how);
 
        if (*mbuf == NULL) {

-               if (how == MBUF_WAITOK)
+               if (how == MBUF_WAITOK) {

                        error = ENOMEM;
                        error = ENOMEM;

-               else
+               } else {

                        error = EWOULDBLOCK;
                        error = EWOULDBLOCK;

+               }

        }
 
        }
 

-       return (error);
+       return error;

 }
 
 /*
 }
 
 /*


@@ -364,7 +387,7 @@ mbuf_getpacket(mbuf_how_t how, mbuf_t *mbuf)
 mbuf_t
 mbuf_free(mbuf_t mbuf)
 {
 mbuf_t
 mbuf_free(mbuf_t mbuf)
 {

-       return (m_free(mbuf));
+       return m_free(mbuf);

 }
 
 /*
 }
 
 /*


@@ -380,13 +403,13 @@ mbuf_freem(mbuf_t mbuf)
 int
 mbuf_freem_list(mbuf_t mbuf)
 {
 int
 mbuf_freem_list(mbuf_t mbuf)
 {

-       return (m_freem_list(mbuf));
+       return m_freem_list(mbuf);

 }
 
 size_t
 mbuf_leadingspace(const mbuf_t mbuf)
 {
 }
 
 size_t
 mbuf_leadingspace(const mbuf_t mbuf)
 {

-       return (m_leadingspace(mbuf));
+       return M_LEADINGSPACE(mbuf);

 }
 
 /*
 }
 
 /*


@@ -397,7 +420,7 @@ mbuf_leadingspace(const mbuf_t mbuf)
 size_t
 mbuf_trailingspace(const mbuf_t mbuf)
 {
 size_t
 mbuf_trailingspace(const mbuf_t mbuf)
 {

-       return (m_trailingspace(mbuf));
+       return M_TRAILINGSPACE(mbuf);

 }
 
 /* Manipulation */
 }
 
 /* Manipulation */


@@ -408,7 +431,7 @@ mbuf_copym(const mbuf_t src, size_t offset, size_t len,
        /* Must set *mbuf to NULL in failure case */
        *new_mbuf = m_copym(src, offset, len, how);
 
        /* Must set *mbuf to NULL in failure case */
        *new_mbuf = m_copym(src, offset, len, how);
 

-       return (*new_mbuf == NULL ? ENOMEM : 0);
+       return *new_mbuf == NULL ? ENOMEM : 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -417,7 +440,7 @@ mbuf_dup(const mbuf_t src, mbuf_how_t how, mbuf_t *new_mbuf)
        /* Must set *new_mbuf to NULL in failure case */
        *new_mbuf = m_dup(src, how);
 
        /* Must set *new_mbuf to NULL in failure case */
        *new_mbuf = m_dup(src, how);
 

-       return (*new_mbuf == NULL ? ENOMEM : 0);
+       return *new_mbuf == NULL ? ENOMEM : 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -426,17 +449,17 @@ mbuf_prepend(mbuf_t *orig, size_t len, mbuf_how_t how)
        /* Must set *orig to NULL in failure case */
        *orig = m_prepend_2(*orig, len, how, 0);
 
        /* Must set *orig to NULL in failure case */
        *orig = m_prepend_2(*orig, len, how, 0);
 

-       return (*orig == NULL ? ENOMEM : 0);
+       return *orig == NULL ? ENOMEM : 0;

 }
 
 errno_t
 mbuf_split(mbuf_t src, size_t offset,
 }
 
 errno_t
 mbuf_split(mbuf_t src, size_t offset,

-                                       mbuf_how_t how, mbuf_t *new_mbuf)
+    mbuf_how_t how, mbuf_t *new_mbuf)

 {
        /* Must set *new_mbuf to NULL in failure case */
        *new_mbuf = m_split(src, offset, how);
 
 {
        /* Must set *new_mbuf to NULL in failure case */
        *new_mbuf = m_split(src, offset, how);
 

-       return (*new_mbuf == NULL ? ENOMEM : 0);
+       return *new_mbuf == NULL ? ENOMEM : 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -445,7 +468,7 @@ mbuf_pullup(mbuf_t *mbuf, size_t len)
        /* Must set *mbuf to NULL in failure case */
        *mbuf = m_pullup(*mbuf, len);
 
        /* Must set *mbuf to NULL in failure case */
        *mbuf = m_pullup(*mbuf, len);
 

-       return (*mbuf == NULL ? ENOMEM : 0);
+       return *mbuf == NULL ? ENOMEM : 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -456,7 +479,7 @@ mbuf_pulldown(mbuf_t src, size_t *offset, size_t len, mbuf_t *location)
        *location = m_pulldown(src, *offset, len, &new_offset);
        *offset = new_offset;
 
        *location = m_pulldown(src, *offset, len, &new_offset);
        *offset = new_offset;
 

-       return (*location == NULL ? ENOMEM : 0);
+       return *location == NULL ? ENOMEM : 0;

 }
 
 /*
 }
 
 /*


@@ -477,45 +500,54 @@ mbuf_adjustlen(mbuf_t m, int amount)
                int used = (size_t)mbuf_data(m) - (size_t)mbuf_datastart(m) +
                    m->m_len;
 
                int used = (size_t)mbuf_data(m) - (size_t)mbuf_datastart(m) +
                    m->m_len;
 

-               if ((size_t)(amount + used) > mbuf_maxlen(m))
-                       return (EINVAL);
+               if ((size_t)(amount + used) > mbuf_maxlen(m)) {
+                       return EINVAL;
+               }

        } else if (-amount > m->m_len) {
        } else if (-amount > m->m_len) {

-               return (EINVAL);
+               return EINVAL;

        }
 
        m->m_len += amount;
        }
 
        m->m_len += amount;

-       return (0);
+       return 0;

 }
 
 mbuf_t
 mbuf_concatenate(mbuf_t dst, mbuf_t src)
 {
 }
 
 mbuf_t
 mbuf_concatenate(mbuf_t dst, mbuf_t src)
 {

-       if (dst == NULL)
-               return (NULL);
+       if (dst == NULL) {
+               return NULL;
+       }

 
        m_cat(dst, src);
 
        /* return dst as is in the current implementation */
 
        m_cat(dst, src);
 
        /* return dst as is in the current implementation */

-       return (dst);
+       return dst;

 }
 errno_t
 mbuf_copydata(const mbuf_t m0, size_t off, size_t len, void *out_data)
 {
        /* Copied m_copydata, added error handling (don't just panic) */
 }
 errno_t
 mbuf_copydata(const mbuf_t m0, size_t off, size_t len, void *out_data)
 {
        /* Copied m_copydata, added error handling (don't just panic) */

-       int count;
-       mbuf_t  m = m0;
+       size_t count;
+       mbuf_t  m = m0;
+
+       if (off >= INT_MAX || len >= INT_MAX) {
+               return EINVAL;
+       }

 
        while (off > 0) {
 
        while (off > 0) {

-               if (m == 0)
-                       return (EINVAL);
-               if (off < (size_t)m->m_len)
+               if (m == 0) {
+                       return EINVAL;
+               }
+               if (off < (size_t)m->m_len) {

                        break;
                        break;

+               }

                off -= m->m_len;
                m = m->m_next;
        }
        while (len > 0) {
                off -= m->m_len;
                m = m->m_next;
        }
        while (len > 0) {

-               if (m == 0)
-                       return (EINVAL);
+               if (m == 0) {
+                       return EINVAL;
+               }

                count = m->m_len - off > len ? len : m->m_len - off;
                bcopy(mtod(m, caddr_t) + off, out_data, count);
                len -= count;
                count = m->m_len - off > len ? len : m->m_len - off;
                bcopy(mtod(m, caddr_t) + off, out_data, count);
                len -= count;


@@ -524,16 +556,17 @@ mbuf_copydata(const mbuf_t m0, size_t off, size_t len, void *out_data)
                m = m->m_next;
        }
 
                m = m->m_next;
        }
 

-       return (0);
+       return 0;

 }
 
 int
 mbuf_mclhasreference(mbuf_t mbuf)
 {
 }
 
 int
 mbuf_mclhasreference(mbuf_t mbuf)
 {

-       if ((mbuf->m_flags & M_EXT))
-               return (m_mclhasreference(mbuf));
-       else
-               return (0);
+       if ((mbuf->m_flags & M_EXT)) {
+               return m_mclhasreference(mbuf);
+       } else {
+               return 0;
+       }

 }
 
 
 }
 
 


@@ -541,24 +574,25 @@ mbuf_mclhasreference(mbuf_t mbuf)
 mbuf_t
 mbuf_next(const mbuf_t mbuf)
 {
 mbuf_t
 mbuf_next(const mbuf_t mbuf)
 {

-       return (mbuf->m_next);
+       return mbuf->m_next;

 }
 
 errno_t
 mbuf_setnext(mbuf_t mbuf, mbuf_t next)
 {
        if (next && ((next)->m_nextpkt != NULL ||
 }
 
 errno_t
 mbuf_setnext(mbuf_t mbuf, mbuf_t next)
 {
        if (next && ((next)->m_nextpkt != NULL ||

-           (next)->m_type == MT_FREE))
-               return (EINVAL);
+           (next)->m_type == MT_FREE)) {
+               return EINVAL;
+       }

        mbuf->m_next = next;
 
        mbuf->m_next = next;
 

-       return (0);
+       return 0;

 }
 
 mbuf_t
 mbuf_nextpkt(const mbuf_t mbuf)
 {
 }
 
 mbuf_t
 mbuf_nextpkt(const mbuf_t mbuf)
 {

-       return (mbuf->m_nextpkt);
+       return mbuf->m_nextpkt;

 }
 
 void
 }
 
 void


@@ -570,7 +604,7 @@ mbuf_setnextpkt(mbuf_t mbuf, mbuf_t nextpkt)
 size_t
 mbuf_len(const mbuf_t mbuf)
 {
 size_t
 mbuf_len(const mbuf_t mbuf)
 {

-       return (mbuf->m_len);
+       return mbuf->m_len;

 }
 
 void
 }
 
 void


@@ -582,32 +616,34 @@ mbuf_setlen(mbuf_t mbuf, size_t len)
 size_t
 mbuf_maxlen(const mbuf_t mbuf)
 {
 size_t
 mbuf_maxlen(const mbuf_t mbuf)
 {

-       if (mbuf->m_flags & M_EXT)
-               return (mbuf->m_ext.ext_size);
-       return (&mbuf->m_dat[MLEN] - ((char *)mbuf_datastart(mbuf)));
+       if (mbuf->m_flags & M_EXT) {
+               return mbuf->m_ext.ext_size;
+       }
+       return &mbuf->m_dat[MLEN] - ((char *)mbuf_datastart(mbuf));

 }
 
 mbuf_type_t
 mbuf_type(const mbuf_t mbuf)
 {
 }
 
 mbuf_type_t
 mbuf_type(const mbuf_t mbuf)
 {

-       return (mbuf->m_type);
+       return mbuf->m_type;

 }
 
 errno_t
 mbuf_settype(mbuf_t mbuf, mbuf_type_t new_type)
 {
 }
 
 errno_t
 mbuf_settype(mbuf_t mbuf, mbuf_type_t new_type)
 {

-       if (new_type == MBUF_TYPE_FREE)
-               return (EINVAL);
+       if (new_type == MBUF_TYPE_FREE) {
+               return EINVAL;
+       }

 
        m_mchtype(mbuf, new_type);
 
 
        m_mchtype(mbuf, new_type);
 

-       return (0);
+       return 0;

 }
 
 mbuf_flags_t
 mbuf_flags(const mbuf_t mbuf)
 {
 }
 
 mbuf_flags_t
 mbuf_flags(const mbuf_t mbuf)
 {

-       return (mbuf->m_flags & mbuf_flags_mask);
+       return mbuf->m_flags & mbuf_flags_mask;

 }
 
 errno_t
 }
 
 errno_t


@@ -637,13 +673,13 @@ mbuf_setflags(mbuf_t mbuf, mbuf_flags_t flags)
                 * bit, as well as the rest of bookkeeping.
                 */
                if ((oflags ^ mbuf->m_flags) & M_PKTHDR) {
                 * bit, as well as the rest of bookkeeping.
                 */
                if ((oflags ^ mbuf->m_flags) & M_PKTHDR) {

-                       mbuf->m_flags ^= M_PKTHDR;      /* restore */
+                       mbuf->m_flags ^= M_PKTHDR;      /* restore */

                        ret = m_reinit(mbuf,
                            (mbuf->m_flags & M_PKTHDR) ? 0 : 1);
                }
        }
 
                        ret = m_reinit(mbuf,
                            (mbuf->m_flags & M_PKTHDR) ? 0 : 1);
                }
        }
 

-       return (ret);
+       return ret;

 }
 
 errno_t
 }
 
 errno_t


@@ -662,30 +698,43 @@ mbuf_setflags_mask(mbuf_t mbuf, mbuf_flags_t flags, mbuf_flags_t mask)
                 * bit, as well as the rest of bookkeeping.
                 */
                if ((oflags ^ mbuf->m_flags) & M_PKTHDR) {
                 * bit, as well as the rest of bookkeeping.
                 */
                if ((oflags ^ mbuf->m_flags) & M_PKTHDR) {

-                       mbuf->m_flags ^= M_PKTHDR;      /* restore */
+                       mbuf->m_flags ^= M_PKTHDR;      /* restore */

                        ret = m_reinit(mbuf,
                            (mbuf->m_flags & M_PKTHDR) ? 0 : 1);
                }
        }
 
                        ret = m_reinit(mbuf,
                            (mbuf->m_flags & M_PKTHDR) ? 0 : 1);
                }
        }
 

-       return (ret);
+       return ret;

 }
 
 errno_t
 mbuf_copy_pkthdr(mbuf_t dest, const mbuf_t src)
 {
 }
 
 errno_t
 mbuf_copy_pkthdr(mbuf_t dest, const mbuf_t src)
 {

-       if (((src)->m_flags & M_PKTHDR) == 0)
-               return (EINVAL);
+       if (((src)->m_flags & M_PKTHDR) == 0) {
+               return EINVAL;
+       }

 
        m_copy_pkthdr(dest, src);
 
 
        m_copy_pkthdr(dest, src);
 

-       return (0);
+       return 0;

 }
 
 size_t
 mbuf_pkthdr_len(const mbuf_t mbuf)
 {
 }
 
 size_t
 mbuf_pkthdr_len(const mbuf_t mbuf)
 {

-       return (mbuf->m_pkthdr.len);
+       if (((mbuf)->m_flags & M_PKTHDR) == 0) {
+               return 0;
+       }
+       /*
+        * While we Assert for development or debug builds,
+        * also make sure we never return negative length
+        * for release build.
+        */
+       ASSERT(mbuf->m_pkthdr.len >= 0);
+       if (mbuf->m_pkthdr.len < 0) {
+               return 0;
+       }
+       return mbuf->m_pkthdr.len;

 }
 
 __private_extern__ size_t
 }
 
 __private_extern__ size_t


@@ -698,12 +747,16 @@ mbuf_pkthdr_maxlen(mbuf_t m)
                maxlen += mbuf_maxlen(n);
                n = mbuf_next(n);
        }
                maxlen += mbuf_maxlen(n);
                n = mbuf_next(n);
        }

-       return (maxlen);
+       return maxlen;

 }
 
 void
 mbuf_pkthdr_setlen(mbuf_t mbuf, size_t len)
 {
 }
 
 void
 mbuf_pkthdr_setlen(mbuf_t mbuf, size_t len)
 {

+       if (len > INT32_MAX) {
+               len = INT32_MAX;
+       }
+

        mbuf->m_pkthdr.len = len;
 }
 
        mbuf->m_pkthdr.len = len;
 }
 


@@ -720,7 +773,7 @@ mbuf_pkthdr_rcvif(const mbuf_t mbuf)
         * If we reference count ifnets, we should take a reference here
         * before returning
         */
         * If we reference count ifnets, we should take a reference here
         * before returning
         */

-       return (mbuf->m_pkthdr.rcvif);
+       return mbuf->m_pkthdr.rcvif;

 }
 
 errno_t
 }
 
 errno_t


@@ -728,13 +781,13 @@ mbuf_pkthdr_setrcvif(mbuf_t mbuf, ifnet_t ifnet)
 {
        /* May want to walk ifnet list to determine if interface is valid */
        mbuf->m_pkthdr.rcvif = (struct ifnet *)ifnet;
 {
        /* May want to walk ifnet list to determine if interface is valid */
        mbuf->m_pkthdr.rcvif = (struct ifnet *)ifnet;

-       return (0);
+       return 0;

 }
 
 void*
 mbuf_pkthdr_header(const mbuf_t mbuf)
 {
 }
 
 void*
 mbuf_pkthdr_header(const mbuf_t mbuf)
 {

-       return (mbuf->m_pkthdr.pkt_hdr);
+       return mbuf->m_pkthdr.pkt_hdr;

 }
 
 void
 }
 
 void


@@ -760,14 +813,12 @@ mbuf_outbound_finalize(struct mbuf *m, u_int32_t pf, size_t o)
                break;
 
        case PF_INET6:
                break;
 
        case PF_INET6:

-#if INET6

                /*
                 * Checksum offload should not have been enabled when
                 * extension headers exist; indicate that the callee
                 * should skip such case by setting optlen to -1.
                 */
                (void) in6_finalize_cksum(m, o, -1, -1, m->m_pkthdr.csum_flags);
                /*
                 * Checksum offload should not have been enabled when
                 * extension headers exist; indicate that the callee
                 * should skip such case by setting optlen to -1.
                 */
                (void) in6_finalize_cksum(m, o, -1, -1, m->m_pkthdr.csum_flags);

-#endif /* INET6 */

                break;
 
        default:
                break;
 
        default:


@@ -783,7 +834,7 @@ mbuf_set_vlan_tag(
        mbuf->m_pkthdr.csum_flags |= CSUM_VLAN_TAG_VALID;
        mbuf->m_pkthdr.vlan_tag = vlan;
 
        mbuf->m_pkthdr.csum_flags |= CSUM_VLAN_TAG_VALID;
        mbuf->m_pkthdr.vlan_tag = vlan;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -791,12 +842,12 @@ mbuf_get_vlan_tag(
        mbuf_t mbuf,
        u_int16_t *vlan)
 {
        mbuf_t mbuf,
        u_int16_t *vlan)
 {

-       if ((mbuf->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) == 0)
-               return (ENXIO); // No vlan tag set
-
+       if ((mbuf->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) == 0) {
+               return ENXIO; // No vlan tag set
+       }

        *vlan = mbuf->m_pkthdr.vlan_tag;
 
        *vlan = mbuf->m_pkthdr.vlan_tag;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -806,7 +857,7 @@ mbuf_clear_vlan_tag(
        mbuf->m_pkthdr.csum_flags &= ~CSUM_VLAN_TAG_VALID;
        mbuf->m_pkthdr.vlan_tag = 0;
 
        mbuf->m_pkthdr.csum_flags &= ~CSUM_VLAN_TAG_VALID;
        mbuf->m_pkthdr.vlan_tag = 0;
 

-       return (0);
+       return 0;

 }
 
 static const mbuf_csum_request_flags_t mbuf_valid_csum_request_flags =
 }
 
 static const mbuf_csum_request_flags_t mbuf_valid_csum_request_flags =


@@ -824,11 +875,11 @@ mbuf_set_csum_requested(
            (mbuf->m_pkthdr.csum_flags & 0xffff0000) | request;
        mbuf->m_pkthdr.csum_data = value;
 
            (mbuf->m_pkthdr.csum_flags & 0xffff0000) | request;
        mbuf->m_pkthdr.csum_data = value;
 

-       return (0);
+       return 0;

 }
 
 static const mbuf_tso_request_flags_t mbuf_valid_tso_request_flags =
 }
 
 static const mbuf_tso_request_flags_t mbuf_valid_tso_request_flags =

-       MBUF_TSO_IPV4 | MBUF_TSO_IPV6;
+    MBUF_TSO_IPV4 | MBUF_TSO_IPV6;

 
 errno_t
 mbuf_get_tso_requested(
 
 errno_t
 mbuf_get_tso_requested(


@@ -837,15 +888,17 @@ mbuf_get_tso_requested(
        u_int32_t *value)
 {
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
        u_int32_t *value)
 {
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||

-                       request == NULL || value == NULL)
-               return (EINVAL);
+           request == NULL || value == NULL) {
+               return EINVAL;
+       }

 
        *request = mbuf->m_pkthdr.csum_flags;
        *request &= mbuf_valid_tso_request_flags;
 
        *request = mbuf->m_pkthdr.csum_flags;
        *request &= mbuf_valid_tso_request_flags;

-       if (*request && value != NULL)
+       if (*request && value != NULL) {

                *value = mbuf->m_pkthdr.tso_segsz;
                *value = mbuf->m_pkthdr.tso_segsz;

+       }

 
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -860,7 +913,7 @@ mbuf_get_csum_requested(
                *value = mbuf->m_pkthdr.csum_data;
        }
 
                *value = mbuf->m_pkthdr.csum_data;
        }
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -870,12 +923,12 @@ mbuf_clear_csum_requested(
        mbuf->m_pkthdr.csum_flags &= 0xffff0000;
        mbuf->m_pkthdr.csum_data = 0;
 
        mbuf->m_pkthdr.csum_flags &= 0xffff0000;
        mbuf->m_pkthdr.csum_data = 0;
 

-       return (0);
+       return 0;

 }
 
 static const mbuf_csum_performed_flags_t mbuf_valid_csum_performed_flags =
 }
 
 static const mbuf_csum_performed_flags_t mbuf_valid_csum_performed_flags =

-       MBUF_CSUM_DID_IP | MBUF_CSUM_IP_GOOD | MBUF_CSUM_DID_DATA |
-       MBUF_CSUM_PSEUDO_HDR | MBUF_CSUM_PARTIAL;
+    MBUF_CSUM_DID_IP | MBUF_CSUM_IP_GOOD | MBUF_CSUM_DID_DATA |
+    MBUF_CSUM_PSEUDO_HDR | MBUF_CSUM_PARTIAL;

 
 errno_t
 mbuf_set_csum_performed(
 
 errno_t
 mbuf_set_csum_performed(


@@ -888,7 +941,7 @@ mbuf_set_csum_performed(
            (mbuf->m_pkthdr.csum_flags & 0xffff0000) | performed;
        mbuf->m_pkthdr.csum_data = value;
 
            (mbuf->m_pkthdr.csum_flags & 0xffff0000) | performed;
        mbuf->m_pkthdr.csum_data = value;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -901,7 +954,7 @@ mbuf_get_csum_performed(
            mbuf->m_pkthdr.csum_flags & mbuf_valid_csum_performed_flags;
        *value = mbuf->m_pkthdr.csum_data;
 
            mbuf->m_pkthdr.csum_flags & mbuf_valid_csum_performed_flags;
        *value = mbuf->m_pkthdr.csum_data;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -911,7 +964,7 @@ mbuf_clear_csum_performed(
        mbuf->m_pkthdr.csum_flags &= 0xffff0000;
        mbuf->m_pkthdr.csum_data = 0;
 
        mbuf->m_pkthdr.csum_flags &= 0xffff0000;
        mbuf->m_pkthdr.csum_data = 0;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -919,93 +972,56 @@ mbuf_inet_cksum(mbuf_t mbuf, int protocol, u_int32_t offset, u_int32_t length,
     u_int16_t *csum)
 {
        if (mbuf == NULL || length == 0 || csum == NULL ||
     u_int16_t *csum)
 {
        if (mbuf == NULL || length == 0 || csum == NULL ||

-           (u_int32_t)mbuf->m_pkthdr.len < (offset + length))
-               return (EINVAL);
+           (u_int32_t)mbuf->m_pkthdr.len < (offset + length)) {
+               return EINVAL;
+       }

 
        *csum = inet_cksum(mbuf, protocol, offset, length);
 
        *csum = inet_cksum(mbuf, protocol, offset, length);

-       return (0);
+       return 0;

 }
 
 }
 

-#if INET6

 errno_t
 mbuf_inet6_cksum(mbuf_t mbuf, int protocol, u_int32_t offset, u_int32_t length,
     u_int16_t *csum)
 {
        if (mbuf == NULL || length == 0 || csum == NULL ||
 errno_t
 mbuf_inet6_cksum(mbuf_t mbuf, int protocol, u_int32_t offset, u_int32_t length,
     u_int16_t *csum)
 {
        if (mbuf == NULL || length == 0 || csum == NULL ||

-           (u_int32_t)mbuf->m_pkthdr.len < (offset + length))
-               return (EINVAL);
+           (u_int32_t)mbuf->m_pkthdr.len < (offset + length)) {
+               return EINVAL;
+       }

 
        *csum = inet6_cksum(mbuf, protocol, offset, length);
 
        *csum = inet6_cksum(mbuf, protocol, offset, length);

-       return (0);
-}
-#else /* INET6 */
-errno_t
-mbuf_inet6_cksum(__unused mbuf_t mbuf, __unused int protocol,
-               __unused u_int32_t offset, __unused u_int32_t length,
-               __unused u_int16_t *csum)
-{
-       panic("mbuf_inet6_cksum() doesn't exist on this platform\n");
-       return (0);
-}
-
-u_int16_t
-inet6_cksum(__unused struct mbuf *m, __unused unsigned int nxt,
-               __unused unsigned int off, __unused unsigned int len)
-{
-       panic("inet6_cksum() doesn't exist on this platform\n");
-       return (0);
+       return 0;

 }
 
 }
 

-void nd6_lookup_ipv6(void);
-void
-nd6_lookup_ipv6(void)
-{
-       panic("nd6_lookup_ipv6() doesn't exist on this platform\n");
-}
-
-int
-in6addr_local(__unused struct in6_addr *a)
-{
-       panic("in6addr_local() doesn't exist on this platform\n");
-       return (0);
-}
-
-void nd6_storelladdr(void);
-void
-nd6_storelladdr(void)
-{
-       panic("nd6_storelladdr() doesn't exist on this platform\n");
-}
-#endif /* INET6 */
-

 /*
  * Mbuf tag KPIs
  */
 
 /*
  * Mbuf tag KPIs
  */
 

-#define        MTAG_FIRST_ID FIRST_KPI_STR_ID
+#define MTAG_FIRST_ID FIRST_KPI_STR_ID

 
 errno_t
 mbuf_tag_id_find(
 
 errno_t
 mbuf_tag_id_find(

-       const char              *string,
-       mbuf_tag_id_t   *out_id)
+       const char              *string,
+       mbuf_tag_id_t   *out_id)

 {
 {

-       return (net_str_id_find_internal(string, out_id, NSI_MBUF_TAG, 1));
+       return net_str_id_find_internal(string, out_id, NSI_MBUF_TAG, 1);

 }
 
 errno_t
 mbuf_tag_allocate(
 }
 
 errno_t
 mbuf_tag_allocate(

-       mbuf_t                  mbuf,
-       mbuf_tag_id_t   id,
-       mbuf_tag_type_t type,
-       size_t                  length,
-       mbuf_how_t              how,
-       void**                  data_p)
+       mbuf_t                  mbuf,
+       mbuf_tag_id_t   id,
+       mbuf_tag_type_t type,
+       size_t                  length,
+       mbuf_how_t              how,
+       void**                  data_p)

 {
        struct m_tag *tag;
        u_int32_t mtag_id_first, mtag_id_last;
 
 {
        struct m_tag *tag;
        u_int32_t mtag_id_first, mtag_id_last;
 

-       if (data_p != NULL)
+       if (data_p != NULL) {

                *data_p = NULL;
                *data_p = NULL;

+       }

 
        /* Sanity check parameters */
        (void) net_str_id_first_last(&mtag_id_first, &mtag_id_last,
 
        /* Sanity check parameters */
        (void) net_str_id_first_last(&mtag_id_first, &mtag_id_last,


@@ -1013,26 +1029,26 @@ mbuf_tag_allocate(
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
            id < mtag_id_first || id > mtag_id_last || length < 1 ||
            (length & 0xffff0000) != 0 || data_p == NULL) {
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
            id < mtag_id_first || id > mtag_id_last || length < 1 ||
            (length & 0xffff0000) != 0 || data_p == NULL) {

-               return (EINVAL);
+               return EINVAL;

        }
 
        /* Make sure this mtag hasn't already been allocated */
        tag = m_tag_locate(mbuf, id, type, NULL);
        if (tag != NULL) {
        }
 
        /* Make sure this mtag hasn't already been allocated */
        tag = m_tag_locate(mbuf, id, type, NULL);
        if (tag != NULL) {

-               return (EEXIST);
+               return EEXIST;

        }
 
        /* Allocate an mtag */
        tag = m_tag_create(id, type, length, how, mbuf);
        if (tag == NULL) {
        }
 
        /* Allocate an mtag */
        tag = m_tag_create(id, type, length, how, mbuf);
        if (tag == NULL) {

-               return (how == M_WAITOK ? ENOMEM : EWOULDBLOCK);
+               return how == M_WAITOK ? ENOMEM : EWOULDBLOCK;

        }
 
        /* Attach the mtag and set *data_p */
        m_tag_prepend(mbuf, tag);
        *data_p = tag + 1;
 
        }
 
        /* Attach the mtag and set *data_p */
        m_tag_prepend(mbuf, tag);
        *data_p = tag + 1;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -1046,10 +1062,12 @@ mbuf_tag_find(
        struct m_tag *tag;
        u_int32_t mtag_id_first, mtag_id_last;
 
        struct m_tag *tag;
        u_int32_t mtag_id_first, mtag_id_last;
 

-       if (length != NULL)
+       if (length != NULL) {

                *length = 0;
                *length = 0;

-       if (data_p != NULL)
+       }
+       if (data_p != NULL) {

                *data_p = NULL;
                *data_p = NULL;

+       }

 
        /* Sanity check parameters */
        (void) net_str_id_first_last(&mtag_id_first, &mtag_id_last,
 
        /* Sanity check parameters */
        (void) net_str_id_first_last(&mtag_id_first, &mtag_id_last,


@@ -1057,27 +1075,27 @@ mbuf_tag_find(
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
            id < mtag_id_first || id > mtag_id_last || length == NULL ||
            data_p == NULL) {
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
            id < mtag_id_first || id > mtag_id_last || length == NULL ||
            data_p == NULL) {

-               return (EINVAL);
+               return EINVAL;

        }
 
        /* Locate an mtag */
        tag = m_tag_locate(mbuf, id, type, NULL);
        if (tag == NULL) {
        }
 
        /* Locate an mtag */
        tag = m_tag_locate(mbuf, id, type, NULL);
        if (tag == NULL) {

-               return (ENOENT);
+               return ENOENT;

        }
 
        /* Copy out the pointer to the data and the lenght value */
        *length = tag->m_tag_len;
        *data_p = tag + 1;
 
        }
 
        /* Copy out the pointer to the data and the lenght value */
        *length = tag->m_tag_len;
        *data_p = tag + 1;
 

-       return (0);
+       return 0;

 }
 
 void
 mbuf_tag_free(
 }
 
 void
 mbuf_tag_free(

-       mbuf_t                  mbuf,
-       mbuf_tag_id_t   id,
-       mbuf_tag_type_t type)
+       mbuf_t                  mbuf,
+       mbuf_tag_id_t   id,
+       mbuf_tag_type_t type)

 {
        struct m_tag *tag;
        u_int32_t mtag_id_first, mtag_id_last;
 {
        struct m_tag *tag;
        u_int32_t mtag_id_first, mtag_id_last;


@@ -1086,8 +1104,9 @@ mbuf_tag_free(
        (void) net_str_id_first_last(&mtag_id_first, &mtag_id_last,
            NSI_MBUF_TAG);
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
        (void) net_str_id_first_last(&mtag_id_first, &mtag_id_last,
            NSI_MBUF_TAG);
        if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||

-           id < mtag_id_first || id > mtag_id_last)
+           id < mtag_id_first || id > mtag_id_last) {

                return;
                return;

+       }

 
        tag = m_tag_locate(mbuf, id, type, NULL);
        if (tag == NULL) {
 
        tag = m_tag_locate(mbuf, id, type, NULL);
        if (tag == NULL) {


@@ -1103,8 +1122,8 @@ mbuf_tag_free(
  * the nearest 64-bit boundary.  This takes into account mbuf
  * tag-related (m_taghdr + m_tag) as well m_drvaux_tag structs.
  */
  * the nearest 64-bit boundary.  This takes into account mbuf
  * tag-related (m_taghdr + m_tag) as well m_drvaux_tag structs.
  */

-#define        MBUF_DRVAUX_MAXLEN                                              \
-       P2ROUNDDOWN(MLEN - sizeof (struct m_taghdr) -                   \
+#define MBUF_DRVAUX_MAXLEN                                              \
+       P2ROUNDDOWN(MLEN - sizeof (struct m_taghdr) -                   \

        M_TAG_ALIGN(sizeof (struct m_drvaux_tag)), sizeof (uint64_t))
 
 errno_t
        M_TAG_ALIGN(sizeof (struct m_drvaux_tag)), sizeof (uint64_t))
 
 errno_t


@@ -1115,21 +1134,25 @@ mbuf_add_drvaux(mbuf_t mbuf, mbuf_how_t how, u_int32_t family,
        struct m_tag *tag;
 
        if (mbuf == NULL || !(mbuf->m_flags & M_PKTHDR) ||
        struct m_tag *tag;
 
        if (mbuf == NULL || !(mbuf->m_flags & M_PKTHDR) ||

-           length == 0 || length > MBUF_DRVAUX_MAXLEN)
-               return (EINVAL);
+           length == 0 || length > MBUF_DRVAUX_MAXLEN) {
+               return EINVAL;
+       }

 
 

-       if (data_p != NULL)
+       if (data_p != NULL) {

                *data_p = NULL;
                *data_p = NULL;

+       }

 
        /* Check if one is already associated */
        if ((tag = m_tag_locate(mbuf, KERNEL_MODULE_TAG_ID,
 
        /* Check if one is already associated */
        if ((tag = m_tag_locate(mbuf, KERNEL_MODULE_TAG_ID,

-           KERNEL_TAG_TYPE_DRVAUX, NULL)) != NULL)
-               return (EEXIST);
+           KERNEL_TAG_TYPE_DRVAUX, NULL)) != NULL) {
+               return EEXIST;
+       }

 
        /* Tag is (m_drvaux_tag + module specific data) */
        if ((tag = m_tag_create(KERNEL_MODULE_TAG_ID, KERNEL_TAG_TYPE_DRVAUX,
 
        /* Tag is (m_drvaux_tag + module specific data) */
        if ((tag = m_tag_create(KERNEL_MODULE_TAG_ID, KERNEL_TAG_TYPE_DRVAUX,

-           sizeof (*p) + length, how, mbuf)) == NULL)
-               return ((how == MBUF_WAITOK) ? ENOMEM : EWOULDBLOCK);
+           sizeof(*p) + length, how, mbuf)) == NULL) {
+               return (how == MBUF_WAITOK) ? ENOMEM : EWOULDBLOCK;
+       }

 
        p = (struct m_drvaux_tag *)(tag + 1);
        p->da_family = family;
 
        p = (struct m_drvaux_tag *)(tag + 1);
        p->da_family = family;


@@ -1139,10 +1162,11 @@ mbuf_add_drvaux(mbuf_t mbuf, mbuf_how_t how, u_int32_t family,
        /* Associate the tag */
        m_tag_prepend(mbuf, tag);
 
        /* Associate the tag */
        m_tag_prepend(mbuf, tag);
 

-       if (data_p != NULL)
+       if (data_p != NULL) {

                *data_p = (p + 1);
                *data_p = (p + 1);

+       }

 
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -1152,31 +1176,36 @@ mbuf_find_drvaux(mbuf_t mbuf, u_int32_t *family_p, u_int32_t *subfamily_p,
        struct m_drvaux_tag *p;
        struct m_tag *tag;
 
        struct m_drvaux_tag *p;
        struct m_tag *tag;
 

-       if (mbuf == NULL || !(mbuf->m_flags & M_PKTHDR) || data_p == NULL)
-               return (EINVAL);
+       if (mbuf == NULL || !(mbuf->m_flags & M_PKTHDR) || data_p == NULL) {
+               return EINVAL;
+       }

 
        *data_p = NULL;
 
        if ((tag = m_tag_locate(mbuf, KERNEL_MODULE_TAG_ID,
 
        *data_p = NULL;
 
        if ((tag = m_tag_locate(mbuf, KERNEL_MODULE_TAG_ID,

-           KERNEL_TAG_TYPE_DRVAUX, NULL)) == NULL)
-               return (ENOENT);
+           KERNEL_TAG_TYPE_DRVAUX, NULL)) == NULL) {
+               return ENOENT;
+       }

 
        /* Must be at least size of m_drvaux_tag */
 
        /* Must be at least size of m_drvaux_tag */

-       VERIFY(tag->m_tag_len >= sizeof (*p));
+       VERIFY(tag->m_tag_len >= sizeof(*p));

 
        p = (struct m_drvaux_tag *)(tag + 1);
        VERIFY(p->da_length > 0 && p->da_length <= MBUF_DRVAUX_MAXLEN);
 
 
        p = (struct m_drvaux_tag *)(tag + 1);
        VERIFY(p->da_length > 0 && p->da_length <= MBUF_DRVAUX_MAXLEN);
 

-       if (family_p != NULL)
+       if (family_p != NULL) {

                *family_p = p->da_family;
                *family_p = p->da_family;

-       if (subfamily_p != NULL)
+       }
+       if (subfamily_p != NULL) {

                *subfamily_p = p->da_subfamily;
                *subfamily_p = p->da_subfamily;

-       if (length_p != NULL)
+       }
+       if (length_p != NULL) {

                *length_p = p->da_length;
                *length_p = p->da_length;

+       }

 
        *data_p = (p + 1);
 
 
        *data_p = (p + 1);
 

-       return (0);
+       return 0;

 }
 
 void
 }
 
 void


@@ -1184,12 +1213,14 @@ mbuf_del_drvaux(mbuf_t mbuf)
 {
        struct m_tag *tag;
 
 {
        struct m_tag *tag;
 

-       if (mbuf == NULL || !(mbuf->m_flags & M_PKTHDR))
+       if (mbuf == NULL || !(mbuf->m_flags & M_PKTHDR)) {

                return;
                return;

+       }

 
        if ((tag = m_tag_locate(mbuf, KERNEL_MODULE_TAG_ID,
 
        if ((tag = m_tag_locate(mbuf, KERNEL_MODULE_TAG_ID,

-           KERNEL_TAG_TYPE_DRVAUX, NULL)) != NULL)
+           KERNEL_TAG_TYPE_DRVAUX, NULL)) != NULL) {

                m_tag_delete(mbuf, tag);
                m_tag_delete(mbuf, tag);

+       }

 }
 
 /* mbuf stats */
 }
 
 /* mbuf stats */


@@ -1231,18 +1262,20 @@ mbuf_allocpacket(mbuf_how_t how, size_t packetlen, unsigned int *maxchunks,
        m = m_allocpacket_internal(&numpkts, packetlen,
            maxchunks ? &numchunks : NULL, how, 1, 0);
        if (m == 0) {
        m = m_allocpacket_internal(&numpkts, packetlen,
            maxchunks ? &numchunks : NULL, how, 1, 0);
        if (m == 0) {

-               if (maxchunks && *maxchunks && numchunks > *maxchunks)
+               if (maxchunks && *maxchunks && numchunks > *maxchunks) {

                        error = ENOBUFS;
                        error = ENOBUFS;

-               else
+               } else {

                        error = ENOMEM;
                        error = ENOMEM;

+               }

        } else {
        } else {

-               if (maxchunks)
+               if (maxchunks) {

                        *maxchunks = numchunks;
                        *maxchunks = numchunks;

+               }

                error = 0;
                *mbuf = m;
        }
 out:
                error = 0;
                *mbuf = m;
        }
 out:

-       return (error);
+       return error;

 }
 
 errno_t
 }
 
 errno_t


@@ -1264,18 +1297,20 @@ mbuf_allocpacket_list(unsigned int numpkts, mbuf_how_t how, size_t packetlen,
        m = m_allocpacket_internal(&numpkts, packetlen,
            maxchunks ? &numchunks : NULL, how, 1, 0);
        if (m == 0) {
        m = m_allocpacket_internal(&numpkts, packetlen,
            maxchunks ? &numchunks : NULL, how, 1, 0);
        if (m == 0) {

-               if (maxchunks && *maxchunks && numchunks > *maxchunks)
+               if (maxchunks && *maxchunks && numchunks > *maxchunks) {

                        error = ENOBUFS;
                        error = ENOBUFS;

-               else
+               } else {

                        error = ENOMEM;
                        error = ENOMEM;

+               }

        } else {
        } else {

-               if (maxchunks)
+               if (maxchunks) {

                        *maxchunks = numchunks;
                        *maxchunks = numchunks;

+               }

                error = 0;
                *mbuf = m;
        }
 out:
                error = 0;
                *mbuf = m;
        }
 out:

-       return (error);
+       return error;

 }
 
 __private_extern__ size_t
 }
 
 __private_extern__ size_t


@@ -1288,7 +1323,7 @@ mbuf_pkt_list_len(mbuf_t m)
                len += mbuf_pkthdr_len(n);
                n = mbuf_nextpkt(n);
        }
                len += mbuf_pkthdr_len(n);
                n = mbuf_nextpkt(n);
        }

-       return (len);
+       return len;

 }
 
 __private_extern__ size_t
 }
 
 __private_extern__ size_t


@@ -1301,7 +1336,7 @@ mbuf_pkt_list_maxlen(mbuf_t m)
                maxlen += mbuf_pkthdr_maxlen(n);
                n = mbuf_nextpkt(n);
        }
                maxlen += mbuf_pkthdr_maxlen(n);
                n = mbuf_nextpkt(n);
        }

-       return (maxlen);
+       return maxlen;

 }
 
 /*
 }
 
 /*


@@ -1313,21 +1348,22 @@ mbuf_pkt_list_maxlen(mbuf_t m)
  */
 errno_t
 mbuf_copyback(
  */
 errno_t
 mbuf_copyback(

-       mbuf_t          m,
-       size_t          off,
-       size_t          len,
-       const void      *data,
-       mbuf_how_t      how)
-{
-       size_t  mlen;
-       mbuf_t  m_start = m;
-       mbuf_t  n;
-       int             totlen = 0;
-       errno_t         result = 0;
-       const char      *cp = data;
-
-       if (m == NULL || len == 0 || data == NULL)
-               return (EINVAL);
+       mbuf_t          m,
+       size_t          off,
+       size_t          len,
+       const void      *data,
+       mbuf_how_t      how)
+{
+       size_t  mlen;
+       mbuf_t  m_start = m;
+       mbuf_t  n;
+       int             totlen = 0;
+       errno_t         result = 0;
+       const char      *cp = data;
+
+       if (m == NULL || len == 0 || data == NULL) {
+               return EINVAL;
+       }

 
        while (off > (mlen = m->m_len)) {
                off -= mlen;
 
        while (off > (mlen = m->m_len)) {
                off -= mlen;


@@ -1348,7 +1384,7 @@ mbuf_copyback(
                mlen = MIN(m->m_len - off, len);
                if (mlen < len && m->m_next == NULL &&
                    mbuf_trailingspace(m) > 0) {
                mlen = MIN(m->m_len - off, len);
                if (mlen < len && m->m_next == NULL &&
                    mbuf_trailingspace(m) > 0) {

-                       size_t  grow = MIN(mbuf_trailingspace(m), len - mlen);
+                       size_t  grow = MIN(mbuf_trailingspace(m), len - mlen);

                        mlen += grow;
                        m->m_len += grow;
                }
                        mlen += grow;
                        m->m_len += grow;
                }


@@ -1358,8 +1394,9 @@ mbuf_copyback(
                mlen += off;
                off = 0;
                totlen += mlen;
                mlen += off;
                off = 0;
                totlen += mlen;

-               if (len == 0)
+               if (len == 0) {

                        break;
                        break;

+               }

                if (m->m_next == 0) {
                        n = m_get(how, m->m_type);
                        if (n == NULL) {
                if (m->m_next == 0) {
                        n = m_get(how, m->m_type);
                        if (n == NULL) {


@@ -1380,107 +1417,115 @@ mbuf_copyback(
        }
 
 out:
        }
 
 out:

-       if ((m_start->m_flags & M_PKTHDR) && (m_start->m_pkthdr.len < totlen))
+       if ((m_start->m_flags & M_PKTHDR) && (m_start->m_pkthdr.len < totlen)) {

                m_start->m_pkthdr.len = totlen;
                m_start->m_pkthdr.len = totlen;

+       }

 
 

-       return (result);
+       return result;

 }
 
 u_int32_t
 mbuf_get_mlen(void)
 {
 }
 
 u_int32_t
 mbuf_get_mlen(void)
 {

-       return (_MLEN);
+       return _MLEN;

 }
 
 u_int32_t
 mbuf_get_mhlen(void)
 {
 }
 
 u_int32_t
 mbuf_get_mhlen(void)
 {

-       return (_MHLEN);
+       return _MHLEN;

 }
 
 u_int32_t
 mbuf_get_minclsize(void)
 {
 }
 
 u_int32_t
 mbuf_get_minclsize(void)
 {

-       return (MHLEN + MLEN);
+       return MHLEN + MLEN;

 }
 
 u_int32_t
 mbuf_get_traffic_class_max_count(void)
 {
 }
 
 u_int32_t
 mbuf_get_traffic_class_max_count(void)
 {

-       return (MBUF_TC_MAX);
+       return MBUF_TC_MAX;

 }
 
 errno_t
 mbuf_get_traffic_class_index(mbuf_traffic_class_t tc, u_int32_t *index)
 {
 }
 
 errno_t
 mbuf_get_traffic_class_index(mbuf_traffic_class_t tc, u_int32_t *index)
 {

-       if (index == NULL || (u_int32_t)tc >= MBUF_TC_MAX)
-               return (EINVAL);
+       if (index == NULL || (u_int32_t)tc >= MBUF_TC_MAX) {
+               return EINVAL;
+       }

 
        *index = MBUF_SCIDX(m_service_class_from_val(MBUF_TC2SCVAL(tc)));
 
        *index = MBUF_SCIDX(m_service_class_from_val(MBUF_TC2SCVAL(tc)));

-       return (0);
+       return 0;

 }
 
 mbuf_traffic_class_t
 mbuf_get_traffic_class(mbuf_t m)
 {
 }
 
 mbuf_traffic_class_t
 mbuf_get_traffic_class(mbuf_t m)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (MBUF_TC_BE);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return MBUF_TC_BE;
+       }

 
 

-       return (m_get_traffic_class(m));
+       return m_get_traffic_class(m);

 }
 
 errno_t
 mbuf_set_traffic_class(mbuf_t m, mbuf_traffic_class_t tc)
 {
        if (m == NULL || !(m->m_flags & M_PKTHDR) ||
 }
 
 errno_t
 mbuf_set_traffic_class(mbuf_t m, mbuf_traffic_class_t tc)
 {
        if (m == NULL || !(m->m_flags & M_PKTHDR) ||

-           ((u_int32_t)tc >= MBUF_TC_MAX))
-               return (EINVAL);
+           ((u_int32_t)tc >= MBUF_TC_MAX)) {
+               return EINVAL;
+       }

 
 

-       return (m_set_traffic_class(m, tc));
+       return m_set_traffic_class(m, tc);

 }
 
 int
 mbuf_is_traffic_class_privileged(mbuf_t m)
 {
        if (m == NULL || !(m->m_flags & M_PKTHDR) ||
 }
 
 int
 mbuf_is_traffic_class_privileged(mbuf_t m)
 {
        if (m == NULL || !(m->m_flags & M_PKTHDR) ||

-           !MBUF_VALID_SC(m->m_pkthdr.pkt_svc))
-               return (0);
+           !MBUF_VALID_SC(m->m_pkthdr.pkt_svc)) {
+               return 0;
+       }

 
 

-       return ((m->m_pkthdr.pkt_flags & PKTF_PRIO_PRIVILEGED) ? 1 : 0);
+       return (m->m_pkthdr.pkt_flags & PKTF_PRIO_PRIVILEGED) ? 1 : 0;

 }
 
 u_int32_t
 mbuf_get_service_class_max_count(void)
 {
 }
 
 u_int32_t
 mbuf_get_service_class_max_count(void)
 {

-       return (MBUF_SC_MAX_CLASSES);
+       return MBUF_SC_MAX_CLASSES;

 }
 
 errno_t
 mbuf_get_service_class_index(mbuf_svc_class_t sc, u_int32_t *index)
 {
 }
 
 errno_t
 mbuf_get_service_class_index(mbuf_svc_class_t sc, u_int32_t *index)
 {

-       if (index == NULL || !MBUF_VALID_SC(sc))
-               return (EINVAL);
+       if (index == NULL || !MBUF_VALID_SC(sc)) {
+               return EINVAL;
+       }

 
        *index = MBUF_SCIDX(sc);
 
        *index = MBUF_SCIDX(sc);

-       return (0);
+       return 0;

 }
 
 mbuf_svc_class_t
 mbuf_get_service_class(mbuf_t m)
 {
 }
 
 mbuf_svc_class_t
 mbuf_get_service_class(mbuf_t m)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (MBUF_SC_BE);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return MBUF_SC_BE;
+       }

 
 

-       return (m_get_service_class(m));
+       return m_get_service_class(m);

 }
 
 errno_t
 mbuf_set_service_class(mbuf_t m, mbuf_svc_class_t sc)
 {
 }
 
 errno_t
 mbuf_set_service_class(mbuf_t m, mbuf_svc_class_t sc)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
 

-       return (m_set_service_class(m, sc));
+       return m_set_service_class(m, sc);

 }
 
 errno_t
 }
 
 errno_t


@@ -1488,110 +1533,125 @@ mbuf_pkthdr_aux_flags(mbuf_t m, mbuf_pkthdr_aux_flags_t *flagsp)
 {
        u_int32_t flags;
 
 {
        u_int32_t flags;
 

-       if (m == NULL || !(m->m_flags & M_PKTHDR) || flagsp == NULL)
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR) || flagsp == NULL) {
+               return EINVAL;
+       }

 
        *flagsp = 0;
        flags = m->m_pkthdr.pkt_flags;
 
        *flagsp = 0;
        flags = m->m_pkthdr.pkt_flags;

-       if ((flags & (PKTF_INET_RESOLVE|PKTF_RESOLVE_RTR)) ==
-           (PKTF_INET_RESOLVE|PKTF_RESOLVE_RTR))
+       if ((flags & (PKTF_INET_RESOLVE | PKTF_RESOLVE_RTR)) ==
+           (PKTF_INET_RESOLVE | PKTF_RESOLVE_RTR)) {

                *flagsp |= MBUF_PKTAUXF_INET_RESOLVE_RTR;
                *flagsp |= MBUF_PKTAUXF_INET_RESOLVE_RTR;

-       if ((flags & (PKTF_INET6_RESOLVE|PKTF_RESOLVE_RTR)) ==
-           (PKTF_INET6_RESOLVE|PKTF_RESOLVE_RTR))
+       }
+       if ((flags & (PKTF_INET6_RESOLVE | PKTF_RESOLVE_RTR)) ==
+           (PKTF_INET6_RESOLVE | PKTF_RESOLVE_RTR)) {

                *flagsp |= MBUF_PKTAUXF_INET6_RESOLVE_RTR;
                *flagsp |= MBUF_PKTAUXF_INET6_RESOLVE_RTR;

+       }

 
        /* These 2 flags are mutually exclusive */
        VERIFY((*flagsp &
            (MBUF_PKTAUXF_INET_RESOLVE_RTR | MBUF_PKTAUXF_INET6_RESOLVE_RTR)) !=
            (MBUF_PKTAUXF_INET_RESOLVE_RTR | MBUF_PKTAUXF_INET6_RESOLVE_RTR));
 
 
        /* These 2 flags are mutually exclusive */
        VERIFY((*flagsp &
            (MBUF_PKTAUXF_INET_RESOLVE_RTR | MBUF_PKTAUXF_INET6_RESOLVE_RTR)) !=
            (MBUF_PKTAUXF_INET_RESOLVE_RTR | MBUF_PKTAUXF_INET6_RESOLVE_RTR));
 

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_get_driver_scratch(mbuf_t m, u_int8_t **area, size_t *area_len)
 {
        if (m == NULL || area == NULL || area_len == NULL ||
 }
 
 errno_t
 mbuf_get_driver_scratch(mbuf_t m, u_int8_t **area, size_t *area_len)
 {
        if (m == NULL || area == NULL || area_len == NULL ||

-           !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+           !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
        *area_len = m_scratch_get(m, area);
 
        *area_len = m_scratch_get(m, area);

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_get_unsent_data_bytes(const mbuf_t m, u_int32_t *unsent_data)
 {
 }
 
 errno_t
 mbuf_get_unsent_data_bytes(const mbuf_t m, u_int32_t *unsent_data)
 {

-       if (m == NULL || unsent_data == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || unsent_data == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
 

-       if (!(m->m_pkthdr.pkt_flags & PKTF_VALID_UNSENT_DATA))
-               return (EINVAL);
+       if (!(m->m_pkthdr.pkt_flags & PKTF_VALID_UNSENT_DATA)) {
+               return EINVAL;
+       }

 
        *unsent_data = m->m_pkthdr.bufstatus_if +
            m->m_pkthdr.bufstatus_sndbuf;
 
        *unsent_data = m->m_pkthdr.bufstatus_if +
            m->m_pkthdr.bufstatus_sndbuf;

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_get_buffer_status(const mbuf_t m, mbuf_buffer_status_t *buf_status)
 {
        if (m == NULL || buf_status == NULL || !(m->m_flags & M_PKTHDR) ||
 }
 
 errno_t
 mbuf_get_buffer_status(const mbuf_t m, mbuf_buffer_status_t *buf_status)
 {
        if (m == NULL || buf_status == NULL || !(m->m_flags & M_PKTHDR) ||

-           !(m->m_pkthdr.pkt_flags & PKTF_VALID_UNSENT_DATA))
-               return (EINVAL);
+           !(m->m_pkthdr.pkt_flags & PKTF_VALID_UNSENT_DATA)) {
+               return EINVAL;
+       }

 
        buf_status->buf_interface = m->m_pkthdr.bufstatus_if;
        buf_status->buf_sndbuf = m->m_pkthdr.bufstatus_sndbuf;
 
        buf_status->buf_interface = m->m_pkthdr.bufstatus_if;
        buf_status->buf_sndbuf = m->m_pkthdr.bufstatus_sndbuf;

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_pkt_new_flow(const mbuf_t m, u_int32_t *retval)
 {
 }
 
 errno_t
 mbuf_pkt_new_flow(const mbuf_t m, u_int32_t *retval)
 {

-       if (m == NULL || retval == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
-       if (m->m_pkthdr.pkt_flags & PKTF_NEW_FLOW)
+       if (m == NULL || retval == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }
+       if (m->m_pkthdr.pkt_flags & PKTF_NEW_FLOW) {

                *retval = 1;
                *retval = 1;

-       else
+       } else {

                *retval = 0;
                *retval = 0;

-       return (0);
+       }
+       return 0;

 }
 
 errno_t
 mbuf_last_pkt(const mbuf_t m, u_int32_t *retval)
 {
 }
 
 errno_t
 mbuf_last_pkt(const mbuf_t m, u_int32_t *retval)
 {

-       if (m == NULL || retval == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
-       if (m->m_pkthdr.pkt_flags & PKTF_LAST_PKT)
+       if (m == NULL || retval == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }
+       if (m->m_pkthdr.pkt_flags & PKTF_LAST_PKT) {

                *retval = 1;
                *retval = 1;

-       else
+       } else {

                *retval = 0;
                *retval = 0;

-       return (0);
+       }
+       return 0;

 }
 
 errno_t
 mbuf_get_timestamp(mbuf_t m, u_int64_t *ts, boolean_t *valid)
 {
 }
 
 errno_t
 mbuf_get_timestamp(mbuf_t m, u_int64_t *ts, boolean_t *valid)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR) || ts == NULL)
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR) || ts == NULL) {
+               return EINVAL;
+       }

 
        if ((m->m_pkthdr.pkt_flags & PKTF_TS_VALID) == 0) {
 
        if ((m->m_pkthdr.pkt_flags & PKTF_TS_VALID) == 0) {

-               if (valid != NULL)
+               if (valid != NULL) {

                        *valid = FALSE;
                        *valid = FALSE;

+               }

                *ts = 0;
        } else {
                *ts = 0;
        } else {

-               if (valid != NULL)
+               if (valid != NULL) {

                        *valid = TRUE;
                        *valid = TRUE;

+               }

                *ts = m->m_pkthdr.pkt_timestamp;
        }
                *ts = m->m_pkthdr.pkt_timestamp;
        }

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_set_timestamp(mbuf_t m, u_int64_t ts, boolean_t valid)
 {
 }
 
 errno_t
 mbuf_set_timestamp(mbuf_t m, u_int64_t ts, boolean_t valid)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
        if (valid == FALSE) {
                m->m_pkthdr.pkt_flags &= ~PKTF_TS_VALID;
 
        if (valid == FALSE) {
                m->m_pkthdr.pkt_flags &= ~PKTF_TS_VALID;


@@ -1600,21 +1660,22 @@ mbuf_set_timestamp(mbuf_t m, u_int64_t ts, boolean_t valid)
                m->m_pkthdr.pkt_flags |= PKTF_TS_VALID;
                m->m_pkthdr.pkt_timestamp = ts;
        }
                m->m_pkthdr.pkt_flags |= PKTF_TS_VALID;
                m->m_pkthdr.pkt_timestamp = ts;
        }

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_get_status(mbuf_t m, kern_return_t *status)
 {
 }
 
 errno_t
 mbuf_get_status(mbuf_t m, kern_return_t *status)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR) || status == NULL)
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR) || status == NULL) {
+               return EINVAL;
+       }

 
        if ((m->m_pkthdr.pkt_flags & PKTF_DRIVER_MTAG) == 0) {
                *status = 0;
        } else {
                *status = m->m_pkthdr.drv_tx_status;
        }
 
        if ((m->m_pkthdr.pkt_flags & PKTF_DRIVER_MTAG) == 0) {
                *status = 0;
        } else {
                *status = m->m_pkthdr.drv_tx_status;
        }

-       return (0);
+       return 0;

 }
 
 static void
 }
 
 static void


@@ -1630,49 +1691,53 @@ driver_mtag_init(mbuf_t m)
 errno_t
 mbuf_set_status(mbuf_t m, kern_return_t status)
 {
 errno_t
 mbuf_set_status(mbuf_t m, kern_return_t status)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
        driver_mtag_init(m);
 
        m->m_pkthdr.drv_tx_status = status;
 
 
        driver_mtag_init(m);
 
        m->m_pkthdr.drv_tx_status = status;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_get_flowid(mbuf_t m, u_int16_t *flowid)
 {
 }
 
 errno_t
 mbuf_get_flowid(mbuf_t m, u_int16_t *flowid)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR) || flowid == NULL)
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR) || flowid == NULL) {
+               return EINVAL;
+       }

 
        if ((m->m_pkthdr.pkt_flags & PKTF_DRIVER_MTAG) == 0) {
                *flowid = 0;
        } else {
                *flowid = m->m_pkthdr.drv_flowid;
        }
 
        if ((m->m_pkthdr.pkt_flags & PKTF_DRIVER_MTAG) == 0) {
                *flowid = 0;
        } else {
                *flowid = m->m_pkthdr.drv_flowid;
        }

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_set_flowid(mbuf_t m, u_int16_t flowid)
 {
 }
 
 errno_t
 mbuf_set_flowid(mbuf_t m, u_int16_t flowid)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
        driver_mtag_init(m);
 
        m->m_pkthdr.drv_flowid = flowid;
 
 
        driver_mtag_init(m);
 
        m->m_pkthdr.drv_flowid = flowid;
 

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_get_tx_compl_data(mbuf_t m, uintptr_t *arg, uintptr_t *data)
 {
        if (m == NULL || !(m->m_flags & M_PKTHDR) || arg == NULL ||
 }
 
 errno_t
 mbuf_get_tx_compl_data(mbuf_t m, uintptr_t *arg, uintptr_t *data)
 {
        if (m == NULL || !(m->m_flags & M_PKTHDR) || arg == NULL ||

-           data == NULL)
-               return (EINVAL);
+           data == NULL) {
+               return EINVAL;
+       }

 
        if ((m->m_pkthdr.pkt_flags & PKTF_DRIVER_MTAG) == 0) {
                *arg = 0;
 
        if ((m->m_pkthdr.pkt_flags & PKTF_DRIVER_MTAG) == 0) {
                *arg = 0;


@@ -1681,21 +1746,22 @@ mbuf_get_tx_compl_data(mbuf_t m, uintptr_t *arg, uintptr_t *data)
                *arg = m->m_pkthdr.drv_tx_compl_arg;
                *data = m->m_pkthdr.drv_tx_compl_data;
        }
                *arg = m->m_pkthdr.drv_tx_compl_arg;
                *data = m->m_pkthdr.drv_tx_compl_data;
        }

-       return (0);
+       return 0;

 }
 
 errno_t
 mbuf_set_tx_compl_data(mbuf_t m, uintptr_t arg, uintptr_t data)
 {
 }
 
 errno_t
 mbuf_set_tx_compl_data(mbuf_t m, uintptr_t arg, uintptr_t data)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
        driver_mtag_init(m);
 
        m->m_pkthdr.drv_tx_compl_arg = arg;
        m->m_pkthdr.drv_tx_compl_data = data;
 
 
        driver_mtag_init(m);
 
        m->m_pkthdr.drv_tx_compl_arg = arg;
        m->m_pkthdr.drv_tx_compl_data = data;
 

-       return (0);
+       return 0;

 }
 
 static u_int32_t
 }
 
 static u_int32_t


@@ -1705,10 +1771,10 @@ get_tx_compl_callback_index_locked(mbuf_tx_compl_func callback)
 
        for (i = 0; i < MAX_MBUF_TX_COMPL_FUNC; i++) {
                if (mbuf_tx_compl_table[i] == callback) {
 
        for (i = 0; i < MAX_MBUF_TX_COMPL_FUNC; i++) {
                if (mbuf_tx_compl_table[i] == callback) {

-                       return (i);
+                       return i;

                }
        }
                }
        }

-       return (UINT32_MAX);
+       return UINT32_MAX;

 }
 
 static u_int32_t
 }
 
 static u_int32_t


@@ -1716,13 +1782,28 @@ get_tx_compl_callback_index(mbuf_tx_compl_func callback)
 {
        u_int32_t i;
 
 {
        u_int32_t i;
 

-       lck_rw_lock_shared(mbuf_tx_compl_tbl_lock);
+       lck_rw_lock_shared(&mbuf_tx_compl_tbl_lock);

 
        i = get_tx_compl_callback_index_locked(callback);
 
 
        i = get_tx_compl_callback_index_locked(callback);
 

-       lck_rw_unlock_shared(mbuf_tx_compl_tbl_lock);
+       lck_rw_unlock_shared(&mbuf_tx_compl_tbl_lock);
+
+       return i;
+}
+
+mbuf_tx_compl_func
+m_get_tx_compl_callback(u_int32_t idx)
+{
+       mbuf_tx_compl_func cb;

 
 

-       return (i);
+       if (idx >= MAX_MBUF_TX_COMPL_FUNC) {
+               ASSERT(0);
+               return NULL;
+       }
+       lck_rw_lock_shared(&mbuf_tx_compl_tbl_lock);
+       cb = mbuf_tx_compl_table[idx];
+       lck_rw_unlock_shared(&mbuf_tx_compl_tbl_lock);
+       return cb;

 }
 
 errno_t
 }
 
 errno_t


@@ -1731,10 +1812,11 @@ mbuf_register_tx_compl_callback(mbuf_tx_compl_func callback)
        int i;
        errno_t error;
 
        int i;
        errno_t error;
 

-       if (callback == NULL)
-               return (EINVAL);
+       if (callback == NULL) {
+               return EINVAL;
+       }

 
 

-       lck_rw_lock_exclusive(mbuf_tx_compl_tbl_lock);
+       lck_rw_lock_exclusive(&mbuf_tx_compl_tbl_lock);

 
        i = get_tx_compl_callback_index_locked(callback);
        if (i != -1) {
 
        i = get_tx_compl_callback_index_locked(callback);
        if (i != -1) {


@@ -1752,9 +1834,9 @@ mbuf_register_tx_compl_callback(mbuf_tx_compl_func callback)
                }
        }
 unlock:
                }
        }
 unlock:

-       lck_rw_unlock_exclusive(mbuf_tx_compl_tbl_lock);
+       lck_rw_unlock_exclusive(&mbuf_tx_compl_tbl_lock);

 
 

-       return (error);
+       return error;

 }
 
 errno_t
 }
 
 errno_t


@@ -1763,10 +1845,11 @@ mbuf_unregister_tx_compl_callback(mbuf_tx_compl_func callback)
        int i;
        errno_t error;
 
        int i;
        errno_t error;
 

-       if (callback == NULL)
-               return (EINVAL);
+       if (callback == NULL) {
+               return EINVAL;
+       }

 
 

-       lck_rw_lock_exclusive(mbuf_tx_compl_tbl_lock);
+       lck_rw_lock_exclusive(&mbuf_tx_compl_tbl_lock);

 
        /* assume the worst */
        error = ENOENT;
 
        /* assume the worst */
        error = ENOENT;


@@ -1778,23 +1861,24 @@ mbuf_unregister_tx_compl_callback(mbuf_tx_compl_func callback)
                }
        }
 unlock:
                }
        }
 unlock:

-       lck_rw_unlock_exclusive(mbuf_tx_compl_tbl_lock);
+       lck_rw_unlock_exclusive(&mbuf_tx_compl_tbl_lock);

 
 

-       return (error);
+       return error;

 }
 
 errno_t
 mbuf_get_timestamp_requested(mbuf_t m, boolean_t *requested)
 {
 }
 
 errno_t
 mbuf_get_timestamp_requested(mbuf_t m, boolean_t *requested)
 {

-       if (m == NULL || !(m->m_flags & M_PKTHDR))
-               return (EINVAL);
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }

 
        if ((m->m_pkthdr.pkt_flags & PKTF_TX_COMPL_TS_REQ) == 0) {
                *requested = FALSE;
        } else {
                *requested = TRUE;
        }
 
        if ((m->m_pkthdr.pkt_flags & PKTF_TX_COMPL_TS_REQ) == 0) {
                *requested = FALSE;
        } else {
                *requested = TRUE;
        }

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -1804,12 +1888,14 @@ mbuf_set_timestamp_requested(mbuf_t m, uintptr_t *pktid,
        size_t i;
 
        if (m == NULL || !(m->m_flags & M_PKTHDR) || callback == NULL ||
        size_t i;
 
        if (m == NULL || !(m->m_flags & M_PKTHDR) || callback == NULL ||

-           pktid == NULL)
-               return (EINVAL);
+           pktid == NULL) {
+               return EINVAL;
+       }

 
        i = get_tx_compl_callback_index(callback);
 
        i = get_tx_compl_callback_index(callback);

-       if (i == UINT32_MAX)
-               return (ENOENT);
+       if (i == UINT32_MAX) {
+               return ENOENT;
+       }

 
 #if (DEBUG || DEVELOPMENT)
        VERIFY(i < sizeof(m->m_pkthdr.pkt_compl_callbacks));
 
 #if (DEBUG || DEVELOPMENT)
        VERIFY(i < sizeof(m->m_pkthdr.pkt_compl_callbacks));


@@ -1830,7 +1916,7 @@ mbuf_set_timestamp_requested(mbuf_t m, uintptr_t *pktid,
        m->m_pkthdr.pkt_compl_callbacks |= (1 << i);
        *pktid = m->m_pkthdr.pkt_compl_context;
 
        m->m_pkthdr.pkt_compl_callbacks |= (1 << i);
        *pktid = m->m_pkthdr.pkt_compl_context;
 

-       return (0);
+       return 0;

 }
 
 void
 }
 
 void


@@ -1838,11 +1924,13 @@ m_do_tx_compl_callback(struct mbuf *m, struct ifnet *ifp)
 {
        int i;
 
 {
        int i;
 

-       if (m == NULL)
+       if (m == NULL) {

                return;
                return;

+       }

 
 

-       if ((m->m_pkthdr.pkt_flags & PKTF_TX_COMPL_TS_REQ) == 0)
+       if ((m->m_pkthdr.pkt_flags & PKTF_TX_COMPL_TS_REQ) == 0) {

                return;
                return;

+       }

 
 #if (DEBUG || DEVELOPMENT)
        if (mbuf_tx_compl_debug != 0 && ifp != NULL &&
 
 #if (DEBUG || DEVELOPMENT)
        if (mbuf_tx_compl_debug != 0 && ifp != NULL &&


@@ -1858,12 +1946,13 @@ m_do_tx_compl_callback(struct mbuf *m, struct ifnet *ifp)
        for (i = 0; i < MAX_MBUF_TX_COMPL_FUNC; i++) {
                mbuf_tx_compl_func callback;
 
        for (i = 0; i < MAX_MBUF_TX_COMPL_FUNC; i++) {
                mbuf_tx_compl_func callback;
 

-               if ((m->m_pkthdr.pkt_compl_callbacks & (1 << i)) == 0)
+               if ((m->m_pkthdr.pkt_compl_callbacks & (1 << i)) == 0) {

                        continue;
                        continue;

+               }

 
 

-               lck_rw_lock_shared(mbuf_tx_compl_tbl_lock);
+               lck_rw_lock_shared(&mbuf_tx_compl_tbl_lock);

                callback = mbuf_tx_compl_table[i];
                callback = mbuf_tx_compl_table[i];

-               lck_rw_unlock_shared(mbuf_tx_compl_tbl_lock);
+               lck_rw_unlock_shared(&mbuf_tx_compl_tbl_lock);

 
                if (callback != NULL) {
                        callback(m->m_pkthdr.pkt_compl_context,
 
                if (callback != NULL) {
                        callback(m->m_pkthdr.pkt_compl_context,


@@ -1880,8 +1969,37 @@ m_do_tx_compl_callback(struct mbuf *m, struct ifnet *ifp)
 #if (DEBUG || DEVELOPMENT)
        if (mbuf_tx_compl_debug != 0) {
                OSDecrementAtomic64(&mbuf_tx_compl_outstanding);
 #if (DEBUG || DEVELOPMENT)
        if (mbuf_tx_compl_debug != 0) {
                OSDecrementAtomic64(&mbuf_tx_compl_outstanding);

-               if (ifp == NULL)
+               if (ifp == NULL) {

                        atomic_add_64(&mbuf_tx_compl_aborted, 1);
                        atomic_add_64(&mbuf_tx_compl_aborted, 1);

+               }

        }
 #endif /* (DEBUG || DEVELOPMENT) */
 }
        }
 #endif /* (DEBUG || DEVELOPMENT) */
 }

+
+errno_t
+mbuf_get_keepalive_flag(mbuf_t m, boolean_t *is_keepalive)
+{
+       if (m == NULL || is_keepalive == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }
+
+       *is_keepalive = (m->m_pkthdr.pkt_flags & PKTF_KEEPALIVE);
+
+       return 0;
+}
+
+errno_t
+mbuf_set_keepalive_flag(mbuf_t m, boolean_t is_keepalive)
+{
+       if (m == NULL || !(m->m_flags & M_PKTHDR)) {
+               return EINVAL;
+       }
+
+       if (is_keepalive) {
+               m->m_pkthdr.pkt_flags |= PKTF_KEEPALIVE;
+       } else {
+               m->m_pkthdr.pkt_flags &= ~PKTF_KEEPALIVE;
+       }
+
+       return 0;
+}