xnu-1699.32.7.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 ea47e2f6cd8b2120a4a3d17cf40245ecb0a6c013..70ab53b3123ef63686972a3f93acc3f1227eb27c 100644 (file)
--- a/bsd/kern/kpi_mbuf.c
+++ b/bsd/kern/kpi_mbuf.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2004-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2011 Apple Inc. All rights reserved.

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


@@ -37,11 +37,12 @@
 #include <kern/kalloc.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <kern/kalloc.h>
 #include <string.h>
 #include <netinet/in.h>

-#include "kpi_mbuf_internal.h"

 
 

-static const mbuf_flags_t mbuf_flags_mask = MBUF_EXT | MBUF_PKTHDR | MBUF_EOR |
-                               MBUF_BCAST | MBUF_MCAST | MBUF_FRAG | MBUF_FIRSTFRAG |
-                               MBUF_LASTFRAG | MBUF_PROMISC;
+#include "net/net_str_id.h"
+
+static const mbuf_flags_t mbuf_flags_mask = (MBUF_EXT | MBUF_PKTHDR | MBUF_EOR |
+    MBUF_LOOP | MBUF_BCAST | MBUF_MCAST | MBUF_FRAG | MBUF_FIRSTFRAG |
+    MBUF_LASTFRAG | MBUF_PROMISC | MBUF_HASFCS);

 
 void* mbuf_data(mbuf_t mbuf)
 {
 
 void* mbuf_data(mbuf_t mbuf)
 {


@@ -80,9 +81,13 @@ errno_t mbuf_align_32(mbuf_t mbuf, size_t len)
        return 0;
 }
 
        return 0;
 }
 

+/* This function is used to provide mcl_to_paddr via symbol indirection,
+ * please avoid any change in behavior or remove the indirection in 
+ * config/Unsupported*
+ */

 addr64_t mbuf_data_to_physical(void* ptr)
 {
 addr64_t mbuf_data_to_physical(void* ptr)
 {

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

 }
 
 errno_t mbuf_get(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)
 }
 
 errno_t mbuf_get(mbuf_how_t how, mbuf_type_t type, mbuf_t *mbuf)


@@ -106,10 +111,10 @@ 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 (extbuf == NULL || extfree == NULL || extsize == 0)
+       if (mbuf == NULL || extbuf == NULL || extfree == NULL || extsize == 0)

                return (EINVAL);
 
                return (EINVAL);
 

-       if ((*mbuf = m_clattach(mbuf != NULL ? *mbuf : NULL, type, extbuf,
+       if ((*mbuf = m_clattach(*mbuf, type, extbuf,

            extfree, extsize, extarg, how)) == NULL)
                return (ENOMEM);
 
            extfree, extsize, extarg, how)) == NULL)
                return (ENOMEM);
 


@@ -125,15 +130,15 @@ mbuf_alloccluster(mbuf_how_t how, size_t *size, caddr_t *addr)
        *addr = NULL;
 
        /* Jumbo cluster pool not available? */
        *addr = NULL;
 
        /* Jumbo cluster pool not available? */

-       if (*size > NBPG && njcl == 0)
+       if (*size > MBIGCLBYTES && njcl == 0)

                return (ENOTSUP);
 
        if (*size <= MCLBYTES && (*addr = m_mclalloc(how)) != NULL)
                *size = MCLBYTES;
                return (ENOTSUP);
 
        if (*size <= MCLBYTES && (*addr = m_mclalloc(how)) != NULL)
                *size = MCLBYTES;

-       else if (*size > MCLBYTES && *size <= NBPG &&
+       else if (*size > MCLBYTES && *size <= MBIGCLBYTES &&

            (*addr = m_bigalloc(how)) != NULL)
            (*addr = m_bigalloc(how)) != NULL)

-               *size = NBPG;
-       else if (*size > NBPG && *size <= M16KCLBYTES &&
+               *size = MBIGCLBYTES;
+       else if (*size > MBIGCLBYTES && *size <= M16KCLBYTES &&

            (*addr = m_16kalloc(how)) != NULL)
                *size = M16KCLBYTES;
        else
            (*addr = m_16kalloc(how)) != NULL)
                *size = M16KCLBYTES;
        else


@@ -148,14 +153,14 @@ mbuf_alloccluster(mbuf_how_t how, size_t *size, caddr_t *addr)
 void
 mbuf_freecluster(caddr_t addr, size_t size)
 {
 void
 mbuf_freecluster(caddr_t addr, size_t size)
 {

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

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

-       else if (size == NBPG)
-               m_bigfree(addr, NBPG, NULL);
+       else if (size == MBIGCLBYTES)
+               m_bigfree(addr, MBIGCLBYTES, NULL);

        else if (njcl > 0)
                m_16kfree(addr, M16KCLBYTES, NULL);
        else
        else if (njcl > 0)
                m_16kfree(addr, M16KCLBYTES, NULL);
        else


@@ -183,7 +188,7 @@ mbuf_getcluster(mbuf_how_t how, mbuf_type_t type, size_t size, mbuf_t* mbuf)
         */
        if (size == MCLBYTES) {
                *mbuf = m_mclget(*mbuf, how);
         */
        if (size == MCLBYTES) {
                *mbuf = m_mclget(*mbuf, how);

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

                *mbuf = m_mbigget(*mbuf, how);
        } else if (size == M16KCLBYTES) {
                if (njcl > 0) {
                *mbuf = m_mbigget(*mbuf, how);
        } else if (size == M16KCLBYTES) {
                if (njcl > 0) {


@@ -253,11 +258,17 @@ errno_t mbuf_getpacket(mbuf_how_t how, mbuf_t *mbuf)
        return error;
 }
 
        return error;
 }
 

+/* This function is used to provide m_free via symbol indirection, please avoid
+ * any change in behavior or remove the indirection in config/Unsupported*
+ */

 mbuf_t mbuf_free(mbuf_t mbuf)
 {
        return m_free(mbuf);
 }
 
 mbuf_t mbuf_free(mbuf_t mbuf)
 {
        return m_free(mbuf);
 }
 

+/* This function is used to provide m_freem via symbol indirection, please avoid
+ * any change in behavior or remove the indirection in config/Unsupported*
+ */

 void mbuf_freem(mbuf_t mbuf)
 {
        m_freem(mbuf);
 void mbuf_freem(mbuf_t mbuf)
 {
        m_freem(mbuf);


@@ -273,6 +284,10 @@ size_t mbuf_leadingspace(const mbuf_t mbuf)
        return m_leadingspace(mbuf);
 }
 
        return m_leadingspace(mbuf);
 }
 

+/* This function is used to provide m_trailingspace via symbol indirection,
+ * please avoid any change in behavior or remove the indirection in 
+ * config/Unsupported*
+ */

 size_t mbuf_trailingspace(const mbuf_t mbuf)
 {
        return m_trailingspace(mbuf);
 size_t mbuf_trailingspace(const mbuf_t mbuf)
 {
        return m_trailingspace(mbuf);


@@ -331,6 +346,9 @@ errno_t mbuf_pulldown(mbuf_t src, size_t *offset, size_t len, mbuf_t *location)
        return (*location == NULL) ? ENOMEM : 0;
 }
 
        return (*location == NULL) ? ENOMEM : 0;
 }
 

+/* This function is used to provide m_adj via symbol indirection, please avoid
+ * any change in behavior or remove the indirection in config/Unsupported*
+ */

 void mbuf_adj(mbuf_t mbuf, int len)
 {
        m_adj(mbuf, len);
 void mbuf_adj(mbuf_t mbuf, int len)
 {
        m_adj(mbuf, len);


@@ -354,6 +372,17 @@ errno_t mbuf_adjustlen(mbuf_t m, int amount)
        return 0;
 }
 
        return 0;
 }
 

+mbuf_t
+mbuf_concatenate(mbuf_t dst, mbuf_t src)
+{
+       if (dst == NULL)
+               return (NULL);
+
+       m_cat(dst, src);
+
+       /* return dst as is in the current implementation */
+       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) */


@@ -529,10 +558,10 @@ extern void in_cksum_offset(struct mbuf* m, size_t ip_offset);
 extern void in_delayed_cksum_offset(struct mbuf *m, int ip_offset);
 
 void
 extern void in_delayed_cksum_offset(struct mbuf *m, int ip_offset);
 
 void

-mbuf_outbound_finalize(mbuf_t mbuf, u_long protocol_family, size_t protocol_offset)
+mbuf_outbound_finalize(mbuf_t mbuf, u_int32_t protocol_family, size_t protocol_offset)

 {
        if ((mbuf->m_pkthdr.csum_flags &
 {
        if ((mbuf->m_pkthdr.csum_flags &

-                (CSUM_DELAY_DATA | CSUM_DELAY_IP | CSUM_TCP_SUM16)) == 0)
+                (CSUM_DELAY_DATA | CSUM_DELAY_IP | CSUM_TCP_SUM16 | CSUM_DELAY_IPV6_DATA)) == 0)

                return;
        
        /* Generate the packet in software, client needs it */
                return;
        
        /* Generate the packet in software, client needs it */


@@ -561,14 +590,23 @@ mbuf_outbound_finalize(mbuf_t mbuf, u_long protocol_family, size_t protocol_offs
                        
                        mbuf->m_pkthdr.csum_flags &= ~(CSUM_DELAY_DATA | CSUM_DELAY_IP);
                        break;
                        
                        mbuf->m_pkthdr.csum_flags &= ~(CSUM_DELAY_DATA | CSUM_DELAY_IP);
                        break;

+
+               case PF_INET6:
+
+                       if (mbuf->m_pkthdr.csum_flags & CSUM_DELAY_IPV6_DATA) {
+                               in_delayed_cksum_offset(mbuf, protocol_offset);
+                       }
+                       mbuf->m_pkthdr.csum_flags &= ~CSUM_DELAY_IPV6_DATA;
+                       break;
+                       

        
                default:
                        /*
                         * Not sure what to do here if anything.
        
                default:
                        /*
                         * Not sure what to do here if anything.

-                        * Hardware checksum code looked pretty IPv4 specific.
+                        * Hardware checksum code looked pretty IPv4/IPv6 specific.

                         */
                         */

-                       if ((mbuf->m_pkthdr.csum_flags & (CSUM_DELAY_DATA | CSUM_DELAY_IP)) != 0)
-                               panic("mbuf_outbound_finalize - CSUM flags set for non-IPv4 packet (%lu)!\n", protocol_family);
+                       if ((mbuf->m_pkthdr.csum_flags & (CSUM_DELAY_DATA | CSUM_DELAY_IP | CSUM_DELAY_IPV6_DATA)) != 0)
+                               panic("mbuf_outbound_finalize - CSUM flags set for non-IPv4 or IPv6 packet (%u)!\n", protocol_family);

        }
 }
 
        }
 }
 


@@ -607,7 +645,8 @@ mbuf_clear_vlan_tag(
 }
 
 static const mbuf_csum_request_flags_t mbuf_valid_csum_request_flags = 
 }
 
 static const mbuf_csum_request_flags_t mbuf_valid_csum_request_flags = 

-       MBUF_CSUM_REQ_IP | MBUF_CSUM_REQ_TCP | MBUF_CSUM_REQ_UDP | MBUF_CSUM_REQ_SUM16;
+       MBUF_CSUM_REQ_IP | MBUF_CSUM_REQ_TCP | MBUF_CSUM_REQ_UDP |
+               MBUF_CSUM_REQ_SUM16 | MBUF_CSUM_REQ_TCPIPV6 | MBUF_CSUM_REQ_UDPIPV6;

 
 errno_t
 mbuf_set_csum_requested(
 
 errno_t
 mbuf_set_csum_requested(


@@ -622,6 +661,27 @@ mbuf_set_csum_requested(
        return 0;
 }
 
        return 0;
 }
 

+static const mbuf_tso_request_flags_t mbuf_valid_tso_request_flags = 
+       MBUF_TSO_IPV4 | MBUF_TSO_IPV6;
+
+errno_t
+mbuf_get_tso_requested(
+       mbuf_t mbuf,
+       mbuf_tso_request_flags_t *request,
+       u_int32_t *value)
+{
+       if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 ||
+                       request == NULL || value == NULL)
+               return EINVAL;
+
+       *request = mbuf->m_pkthdr.csum_flags;
+       *request &= mbuf_valid_tso_request_flags;
+       if (*request && value != NULL) 
+               *value = mbuf->m_pkthdr.tso_segsz;
+       
+       return 0;
+}
+

 errno_t
 mbuf_get_csum_requested(
        mbuf_t mbuf,
 errno_t
 mbuf_get_csum_requested(
        mbuf_t mbuf,


@@ -754,111 +814,14 @@ nd6_storelladdr(void)
  * Mbuf tag KPIs
  */
 
  * Mbuf tag KPIs
  */
 

-struct mbuf_tag_id_entry {
-       SLIST_ENTRY(mbuf_tag_id_entry)  next;
-       mbuf_tag_id_t                                   id;
-       char                                                    string[];
-};
-
-#define        MBUF_TAG_ID_ENTRY_SIZE(__str) \
-       ((size_t)&(((struct mbuf_tag_id_entry*)0)->string[0]) + \
-        strlen(__str) + 1)
-
-#define        MTAG_FIRST_ID                                   1000
-static mbuf_tag_id_t                                   mtag_id_next = MTAG_FIRST_ID;
-static SLIST_HEAD(,mbuf_tag_id_entry)  mtag_id_list = {NULL};
-static lck_mtx_t                                               *mtag_id_lock = NULL;
-
-__private_extern__ void
-mbuf_tag_id_first_last(
-       mbuf_tag_id_t * first,
-       mbuf_tag_id_t * last)
-{
-       *first = MTAG_FIRST_ID;
-       *last = mtag_id_next - 1;
-}
-
-__private_extern__ errno_t
-mbuf_tag_id_find_internal(
-       const char              *string,
-       mbuf_tag_id_t   *out_id,
-       int                             create)
-{
-       struct mbuf_tag_id_entry                        *entry = NULL;
-       
-       
-       *out_id = 0;
-       
-       if (string == NULL || out_id == NULL) {
-               return EINVAL;
-       }
-       
-       /* Don't bother allocating the lock if we're only doing a lookup */
-       if (create == 0 && mtag_id_lock == NULL)
-               return ENOENT;
-       
-       /* Allocate lock if necessary */
-       if (mtag_id_lock == NULL) {
-               lck_grp_attr_t  *grp_attrib = NULL;
-               lck_attr_t              *lck_attrb = NULL;
-               lck_grp_t               *lck_group = NULL;
-               lck_mtx_t               *new_lock = NULL;
-               
-               grp_attrib = lck_grp_attr_alloc_init();
-               lck_group = lck_grp_alloc_init("mbuf_tag_allocate_id", grp_attrib);
-               lck_grp_attr_free(grp_attrib);
-               lck_attrb = lck_attr_alloc_init();
-
-               new_lock = lck_mtx_alloc_init(lck_group, lck_attrb);
-               if (!OSCompareAndSwap((UInt32)0, (UInt32)new_lock, (UInt32*)&mtag_id_lock)) {
-                       /*
-                        * If the atomic swap fails, someone else has already
-                        * done this work. We can free the stuff we allocated.
-                        */
-                       lck_mtx_free(new_lock, lck_group);
-                       lck_grp_free(lck_group);
-               }
-               lck_attr_free(lck_attrb);
-       }
-       
-       /* Look for an existing entry */
-       lck_mtx_lock(mtag_id_lock);
-       SLIST_FOREACH(entry, &mtag_id_list, next) {
-               if (strncmp(string, entry->string, strlen(string) + 1) == 0) {
-                       break;
-               }
-       }
-       
-       if (entry == NULL) {
-               if (create == 0) {
-                       lck_mtx_unlock(mtag_id_lock);
-                       return ENOENT;
-               }
-               
-               entry = kalloc(MBUF_TAG_ID_ENTRY_SIZE(string));
-               if (entry == NULL) {
-                       lck_mtx_unlock(mtag_id_lock);
-                       return ENOMEM;
-               }
-               
-               strlcpy(entry->string, string, strlen(string)+1);
-               entry->id = mtag_id_next;
-               mtag_id_next++;
-               SLIST_INSERT_HEAD(&mtag_id_list, entry, next);
-       }
-       lck_mtx_unlock(mtag_id_lock);
-       
-       *out_id = entry->id;
-       
-       return 0;
-}
+#define MTAG_FIRST_ID FIRST_KPI_STR_ID

 
 errno_t
 mbuf_tag_id_find(
        const char              *string,
        mbuf_tag_id_t   *out_id)
 {
 
 errno_t
 mbuf_tag_id_find(
        const char              *string,
        mbuf_tag_id_t   *out_id)
 {

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

 }
 
 errno_t
 }
 
 errno_t


@@ -871,13 +834,15 @@ mbuf_tag_allocate(
        void**                  data_p)
 {
        struct m_tag *tag;
        void**                  data_p)
 {
        struct m_tag *tag;

+       u_int32_t mtag_id_first, mtag_id_last;

        
        if (data_p != NULL)
                *data_p = NULL;
        
        /* Sanity check parameters */
        
        if (data_p != NULL)
                *data_p = NULL;
        
        /* Sanity check parameters */

-       if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 || id < MTAG_FIRST_ID ||
-               id >= mtag_id_next || length < 1 || (length & 0xffff0000) != 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 || length < 1 || (length & 0xffff0000) != 0 ||

                data_p == NULL) {
                return EINVAL;
        }
                data_p == NULL) {
                return EINVAL;
        }


@@ -889,7 +854,7 @@ mbuf_tag_allocate(
        }
        
        /* Allocate an mtag */
        }
        
        /* Allocate an mtag */

-       tag = m_tag_alloc(id, type, length, how);
+       tag = m_tag_create(id, type, length, how, mbuf);

        if (tag == NULL) {
                return how == M_WAITOK ? ENOMEM : EWOULDBLOCK;
        }
        if (tag == NULL) {
                return how == M_WAITOK ? ENOMEM : EWOULDBLOCK;
        }


@@ -910,6 +875,7 @@ mbuf_tag_find(
        void**                  data_p)
 {
        struct m_tag *tag;
        void**                  data_p)
 {
        struct m_tag *tag;

+       u_int32_t mtag_id_first, mtag_id_last;

        
        if (length != NULL)
                *length = 0;
        
        if (length != NULL)
                *length = 0;


@@ -917,8 +883,9 @@ mbuf_tag_find(
                *data_p = NULL;
        
        /* Sanity check parameters */
                *data_p = NULL;
        
        /* Sanity check parameters */

-       if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 || id < MTAG_FIRST_ID ||
-               id >= mtag_id_next || length == NULL || data_p == NULL) {
+       (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 || length == NULL || data_p == NULL) {

                return EINVAL;
        }
        
                return EINVAL;
        }
        


@@ -942,9 +909,12 @@ mbuf_tag_free(
        mbuf_tag_type_t type)
 {
        struct m_tag *tag;
        mbuf_tag_type_t type)
 {
        struct m_tag *tag;

+       u_int32_t mtag_id_first, mtag_id_last;

        
        

-       if (mbuf == NULL || (mbuf->m_flags & M_PKTHDR) == 0 || id < MTAG_FIRST_ID ||
-               id >= mtag_id_next)
+       /* Sanity check parameters */
+       (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)

                return;
        
        tag = m_tag_locate(mbuf, id, type, NULL);
                return;
        
        tag = m_tag_locate(mbuf, id, type, NULL);


@@ -1117,11 +1087,56 @@ out:
        return result;
 }
 
        return result;
 }
 

-#if !INET6
-void inet6_unsupported(void);
+u_int32_t
+mbuf_get_mlen(void)
+{
+       return (_MLEN);
+}
+
+u_int32_t
+mbuf_get_mhlen(void)
+{
+       return (_MHLEN);
+}
+
+u_int32_t
+mbuf_get_minclsize(void)
+{
+       return (MHLEN + MLEN);
+}
+
+mbuf_traffic_class_t 
+mbuf_get_traffic_class(mbuf_t m)
+{
+       mbuf_traffic_class_t prio = MBUF_TC_BE;
+
+       if (m == NULL || !(m->m_flags & M_PKTHDR))
+               return (prio);

 
 

-void inet6_unsupported(void)
+       if (m->m_pkthdr.prio <= MBUF_TC_VO)
+               prio = m->m_pkthdr.prio;
+
+       return (prio);
+}
+
+errno_t 
+mbuf_set_traffic_class(mbuf_t m, mbuf_traffic_class_t tc)

 {
 {

-       *((int *)0) = 0x1;
+       errno_t error = 0;
+       
+       if (m == NULL || !(m->m_flags & M_PKTHDR))
+               return EINVAL;
+
+       switch (tc) {
+               case MBUF_TC_BE:
+               case MBUF_TC_BK:
+               case MBUF_TC_VI:
+               case MBUF_TC_VO:
+                       m->m_pkthdr.prio = tc;
+                       break;
+               default:
+                       error = EINVAL;
+                       break;
+       }
+       return error;

 }
 }

-#endif /* !INET6 */