X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/0b4e3aa066abc0728aacb4bbeb86f53f9737156e..3a60a9f5b85abb8c2cf24e1926c5c7b3f608a5e2:/bsd/sys/mbuf.h diff --git a/bsd/sys/mbuf.h b/bsd/sys/mbuf.h index 9638bc398..d7a417160 100644 --- a/bsd/sys/mbuf.h +++ b/bsd/sys/mbuf.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * @@ -72,7 +72,13 @@ #ifndef _SYS_MBUF_H_ #define _SYS_MBUF_H_ +#include +#include + +#ifdef KERNEL_PRIVATE + #include +#include /* * Mbufs are of a single size, MSIZE (machine/param.h), which @@ -90,7 +96,6 @@ #define NMBPCL (sizeof(union mcluster) / sizeof(struct mbuf)) - /* * Macros for type conversion * mtod(m,t) - convert mbuf pointer to data pointer of correct type @@ -98,13 +103,13 @@ * mtocl(x) - convert pointer within cluster to cluster index # * cltom(x) - convert cluster # to ptr to beginning of cluster */ -#define mtod(m,t) ((t)((m)->m_data)) -#define dtom(x) ((struct mbuf *)((u_long)(x) & ~(MSIZE-1))) -#define mtocl(x) ((union mcluster *)(x) - (union mcluster *)mbutl) -#define cltom(x) ((union mcluster *)(mbutl + (x))) +#define mtod(m,t) ((t)m_mtod(m)) +#define dtom(x) m_dtom(x) +#define mtocl(x) m_mtocl(x) +#define cltom(x) m_cltom(x) -#define MCLREF(p) (++mclrefcnt[mtocl(p)]) -#define MCLUNREF(p) (--mclrefcnt[mtocl(p)] == 0) +#define MCLREF(p) m_mclref(p) +#define MCLUNREF(p) m_mclunref(p) /* header at beginning of each mbuf: */ struct m_hdr { @@ -116,6 +121,16 @@ struct m_hdr { short mh_flags; /* flags; see below */ }; +/* + * Packet tag structure (see below for details). + */ +struct m_tag { + SLIST_ENTRY(m_tag) m_tag_link; /* List of packet tags */ + u_int16_t m_tag_type; /* Module specific type */ + u_int16_t m_tag_len; /* Length of data */ + u_int32_t m_tag_id; /* Module ID */ +}; + /* record/packet header in first mbuf of chain; valid if M_PKTHDR set */ struct pkthdr { int len; /* total packet length */ @@ -124,18 +139,26 @@ struct pkthdr { /* variables for ip and tcp reassembly */ void *header; /* pointer to packet header */ /* variables for hardware checksum */ +#ifdef KERNEL_PRIVATE + /* Note: csum_flags is used for hardware checksum and VLAN */ +#endif KERNEL_PRIVATE int csum_flags; /* flags regarding checksum */ int csum_data; /* data field used by csum routines */ struct mbuf *aux; /* extra data buffer; ipsec/others */ - void *reserved1; /* for future use */ - void *reserved2; /* for future use */ +#ifdef KERNEL_PRIVATE + u_short vlan_tag; /* VLAN tag, host byte order */ + u_short socket_id; /* socket id */ +#else KERNEL_PRIVATE + u_int reserved1; /* for future use */ +#endif KERNEL_PRIVATE + SLIST_HEAD(packet_tags, m_tag) tags; /* list of packet tags */ }; /* description of external storage mapped into mbuf, valid if M_EXT set */ struct m_ext { caddr_t ext_buf; /* start of buffer */ - void (*ext_free)(); /* free routine if not the usual */ + void (*ext_free)(caddr_t , u_int, caddr_t); /* free routine if not the usual */ u_int ext_size; /* size of buffer, for ext_free */ caddr_t ext_arg; /* additional ext_free argument */ struct ext_refsq { /* references held */ @@ -174,23 +197,23 @@ struct mbuf { #define M_PKTHDR 0x0002 /* start of record */ #define M_EOR 0x0004 /* end of record */ #define M_PROTO1 0x0008 /* protocol-specific */ - -#define M_MIP6TUNNEL 0x0010 /* MIP6 temporary use */ +#define M_PROTO2 0x0010 /* protocol-specific */ +#define M_PROTO3 0x0020 /* protocol-specific */ +#define M_PROTO4 0x0040 /* protocol-specific */ +#define M_PROTO5 0x0080 /* protocol-specific */ /* mbuf pkthdr flags, also in m_flags */ #define M_BCAST 0x0100 /* send/received as link-level broadcast */ #define M_MCAST 0x0200 /* send/received as link-level multicast */ -#define M_FRAG 0x0400 /* packet is a fragment of a larger packet */ -#define M_ANYCAST6 0x0800 /* received as IPv6 anycast */ - -/* mbuf pkthdr flags, also in m_flags */ -#define M_AUTHIPHDR 0x1000 /* data origin authentication for IP header */ -#define M_DECRYPTED 0x2000 /* confidentiality */ -#define M_LOOP 0x4000 /* for Mbuf statistics */ -#define M_AUTHIPDGM 0x8000 /* data origin authentication */ +#define M_FRAG 0x0400 /* packet is a fragment of a larger packet */ +#define M_FIRSTFRAG 0x0800 /* packet is first fragment */ +#define M_LASTFRAG 0x1000 /* packet is last fragment */ +#define M_PROMISC 0x2000 /* packet is promiscuous (shouldn't go to stack) */ /* flags copied when copying m_pkthdr */ -#define M_COPYFLAGS (M_PKTHDR|M_EOR|M_BCAST|M_MCAST|M_FRAG|M_ANYCAST6|M_AUTHIPHDR|M_DECRYPTED|M_LOOP|M_AUTHIPDGM) +#define M_COPYFLAGS (M_PKTHDR|M_EOR|M_PROTO1|M_PROTO2|M_PROTO3 | \ + M_PROTO4|M_PROTO5|M_BCAST|M_MCAST|M_FRAG | \ + M_FIRSTFRAG|M_LASTFRAG|M_PROMISC) /* flags indicating hw checksum support and sw checksum requirements [freebsd4.1]*/ #define CSUM_IP 0x0001 /* will csum IP */ @@ -207,6 +230,15 @@ struct mbuf { #define CSUM_DELAY_DATA (CSUM_TCP | CSUM_UDP) #define CSUM_DELAY_IP (CSUM_IP) /* XXX add ipv6 here too? */ +/* + * Note: see also IF_HWASSIST_CSUM defined in + */ +/* bottom 16 bits reserved for hardware checksum */ +#define CSUM_CHECKSUM_MASK 0xffff + +/* VLAN tag present */ +#define CSUM_VLAN_TAG_VALID 0x10000 /* vlan_tag field is valid */ +#endif KERNEL_PRIVATE /* mbuf types */ @@ -225,8 +257,11 @@ struct mbuf { #define MT_IFADDR 13 /* interface address */ #define MT_CONTROL 14 /* extra-data protocol message */ #define MT_OOBDATA 15 /* expedited data */ +#define MT_TAG 16 /* volatile metadata associated to pkts */ #define MT_MAX 32 /* enough? */ +#ifdef KERNEL_PRIVATE + /* flags to m_get/MGET */ /* Need to include malloc.h to get right options for malloc */ #include @@ -242,13 +277,14 @@ struct mbuf { * drivers. */ +#ifdef _KERN_LOCKS_H_ +extern lck_mtx_t * mbuf_mlock; +#else +extern void * mbuf_mlock; +#endif -extern -decl_simple_lock_data(, mbuf_slock); -#define MBUF_LOCK() usimple_lock(&mbuf_slock); -#define MBUF_UNLOCK() usimple_unlock(&mbuf_slock); -#define MBUF_LOCKINIT() simple_lock_init(&mbuf_slock); - +#define MBUF_LOCK() lck_mtx_lock(mbuf_mlock); +#define MBUF_UNLOCK() lck_mtx_unlock(mbuf_mlock); /* * mbuf allocation/deallocation macros: @@ -262,54 +298,16 @@ decl_simple_lock_data(, mbuf_slock); */ #if 1 -#define MCHECK(m) if ((m)->m_type != MT_FREE) panic("mget MCHECK: m_type=%x m=%x", m->m_type, m) +#define MCHECK(m) m_mcheck(m) #else #define MCHECK(m) #endif extern struct mbuf *mfree; /* mbuf free list */ -extern simple_lock_data_t mbuf_slock; - -#define _MINTGET(m, type) { \ - MBUF_LOCK(); \ - if (((m) = mfree) != 0) { \ - MCHECK(m); \ - ++mclrefcnt[mtocl(m)]; \ - mbstat.m_mtypes[MT_FREE]--; \ - mbstat.m_mtypes[type]++; \ - mfree = (m)->m_next; \ - } \ - MBUF_UNLOCK(); \ -} - -#define MGET(m, how, type) { \ - _MINTGET(m, type); \ - if (m) { \ - (m)->m_next = (m)->m_nextpkt = 0; \ - (m)->m_type = (type); \ - (m)->m_data = (m)->m_dat; \ - (m)->m_flags = 0; \ - } else \ - (m) = m_retry((how), (type)); \ -} - -#define MGETHDR(m, how, type) { \ - _MINTGET(m, type); \ - if (m) { \ - (m)->m_next = (m)->m_nextpkt = 0; \ - (m)->m_type = (type); \ - (m)->m_data = (m)->m_pktdat; \ - (m)->m_flags = M_PKTHDR; \ - (m)->m_pkthdr.rcvif = NULL; \ - (m)->m_pkthdr.header = NULL; \ - (m)->m_pkthdr.csum_flags = 0; \ - (m)->m_pkthdr.csum_data = 0; \ - (m)->m_pkthdr.aux = (struct mbuf *)NULL; \ - (m)->m_pkthdr.reserved1 = NULL; \ - (m)->m_pkthdr.reserved2 = NULL; \ - } else \ - (m) = m_retryhdr((how), (type)); \ -} + +#define MGET(m, how, type) ((m) = m_get((how), (type))) + +#define MGETHDR(m, how, type) ((m) = m_gethdr((how), (type))) /* * Mbuf cluster macros. @@ -328,40 +326,23 @@ union mcluster { char mcl_buf[MCLBYTES]; }; -#define MCLALLOC(p, how) { \ - (void)m_clalloc(1, (how)); \ - if (((p) = (caddr_t)mclfree)) { \ - ++mclrefcnt[mtocl(p)]; \ - mbstat.m_clfree--; \ - mclfree = ((union mcluster *)(p))->mcl_next; \ - } \ - MBUF_UNLOCK(); \ -} - -#define MCLGET(m, how) { \ - MCLALLOC((m)->m_ext.ext_buf, (how)); \ - if ((m)->m_ext.ext_buf) { \ - (m)->m_data = (m)->m_ext.ext_buf; \ - (m)->m_flags |= M_EXT; \ - (m)->m_ext.ext_size = MCLBYTES; \ - (m)->m_ext.ext_free = 0; \ - (m)->m_ext.ext_refs.forward = (m)->m_ext.ext_refs.backward = \ - &(m)->m_ext.ext_refs; \ - } \ -} - -#define MCLFREE(p) { \ - MBUF_LOCK(); \ - if (--mclrefcnt[mtocl(p)] == 0) { \ - ((union mcluster *)(p))->mcl_next = mclfree; \ - mclfree = (union mcluster *)(p); \ - mbstat.m_clfree++; \ - } \ - MBUF_UNLOCK(); \ -} - -#define MCLHASREFERENCE(m) \ - ((m)->m_ext.ext_refs.forward != &((m)->m_ext.ext_refs)) +#define MCLALLOC(p, how) ((p) = m_mclalloc(how)) + +#define MCLFREE(p) m_mclfree(p) + +#define MCLGET(m, how) ((m) = m_mclget(m, how)) + +/* + * Mbuf big cluster + */ + +union mbigcluster { + union mbigcluster *mbc_next; + char mbc_buf[NBPG]; +}; + + +#define MCLHASREFERENCE(m) m_mclhasreference(m) /* * MFREE(struct mbuf *m, struct mbuf *n) @@ -369,25 +350,20 @@ union mcluster { * Place the successor, if any, in n. */ -#define MFREE(m, n) (n) = m_free(m) +#define MFREE(m, n) ((n) = m_free(m)) /* * Copy mbuf pkthdr from from to to. * from must have M_PKTHDR set, and to must be empty. * aux pointer will be moved to `to'. */ -#define M_COPY_PKTHDR(to, from) { \ - (to)->m_pkthdr = (from)->m_pkthdr; \ - (from)->m_pkthdr.aux = (struct mbuf *)NULL; \ - (to)->m_flags = (from)->m_flags & M_COPYFLAGS; \ - (to)->m_data = (to)->m_pktdat; \ -} +#define M_COPY_PKTHDR(to, from) m_copy_pkthdr(to, from) /* * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place * an object of the specified size at the end of the mbuf, longword aligned. */ -#define M_ALIGN(m, len) \ +#define M_ALIGN(m, len) \ { (m)->m_data += (MLEN - (len)) &~ (sizeof(long) - 1); } /* * As above, for mbufs allocated with m_gethdr/MGETHDR @@ -401,7 +377,6 @@ union mcluster { * before the current start of data in an mbuf. * Subroutine - data not available if certain references. */ -int m_leadingspace(struct mbuf *); #define M_LEADINGSPACE(m) m_leadingspace(m) /* @@ -409,7 +384,6 @@ int m_leadingspace(struct mbuf *); * after the end of data in an mbuf. * Subroutine - data not available if certain references. */ -int m_trailingspace(struct mbuf *); #define M_TRAILINGSPACE(m) m_trailingspace(m) /* @@ -418,24 +392,10 @@ int m_trailingspace(struct mbuf *); * If how is M_DONTWAIT and allocation fails, the original mbuf chain * is freed and m is set to NULL. */ -#define M_PREPEND(m, plen, how) { \ - if (M_LEADINGSPACE(m) >= (plen)) { \ - (m)->m_data -= (plen); \ - (m)->m_len += (plen); \ - } else \ - (m) = m_prepend((m), (plen), (how)); \ - if ((m) && (m)->m_flags & M_PKTHDR) \ - (m)->m_pkthdr.len += (plen); \ -} +#define M_PREPEND(m, plen, how) ((m) = m_prepend_2((m), (plen), (how))) /* change mbuf to new type */ -#define MCHTYPE(m, t) { \ - MBUF_LOCK(); \ - mbstat.m_mtypes[(m)->m_type]--; \ - mbstat.m_mtypes[t]++; \ - (m)->m_type = t; \ - MBUF_UNLOCK(); \ -} +#define MCHTYPE(m, t) m_mchtype(m, t) /* length to m_copy to copy all */ #define M_COPYALL 1000000000 @@ -443,10 +403,35 @@ int m_trailingspace(struct mbuf *); /* compatiblity with 4.3 */ #define m_copy(m, o, l) m_copym((m), (o), (l), M_DONTWAIT) +#endif /* KERNEL_PRIVATE */ + /* * Mbuf statistics. */ +/* LP64todo - not 64-bit safe */ struct mbstat { + u_long m_mbufs; /* mbufs obtained from page pool */ + u_long m_clusters; /* clusters obtained from page pool */ + u_long m_spare; /* spare field */ + u_long m_clfree; /* free clusters */ + u_long m_drops; /* times failed to find space */ + u_long m_wait; /* times waited for space */ + u_long m_drain; /* times drained protocols for space */ + u_short m_mtypes[256]; /* type specific mbuf allocations */ + u_long m_mcfail; /* times m_copym failed */ + u_long m_mpfail; /* times m_pullup failed */ + u_long m_msize; /* length of an mbuf */ + u_long m_mclbytes; /* length of an mbuf cluster */ + u_long m_minclsize; /* min length of data to allocate a cluster */ + u_long m_mlen; /* length of data in an mbuf */ + u_long m_mhlen; /* length of data in a header mbuf */ + u_long m_bigclusters; /* clusters obtained from page pool */ + u_long m_bigclfree; /* free clusters */ + u_long m_bigmclbytes; /* length of an mbuf cluster */ +}; + +/* Compatibillity with 10.3 */ +struct ombstat { u_long m_mbufs; /* mbufs obtained from page pool */ u_long m_clusters; /* clusters obtained from page pool */ u_long m_spare; /* spare field */ @@ -463,6 +448,7 @@ struct mbstat { u_long m_mlen; /* length of data in an mbuf */ u_long m_mhlen; /* length of data in a header mbuf */ }; +#ifdef KERNEL_PRIVATE /* * pkthdr.aux type tags. @@ -485,24 +471,136 @@ extern int max_protohdr; /* largest protocol header */ extern int max_hdr; /* largest link+protocol header */ extern int max_datalen; /* MHLEN - max_hdr */ -struct mbuf *m_copym __P((struct mbuf *, int, int, int)); -struct mbuf *m_free __P((struct mbuf *)); -struct mbuf *m_get __P((int, int)); -struct mbuf *m_getpacket __P((void)); -struct mbuf *m_getclr __P((int, int)); -struct mbuf *m_gethdr __P((int, int)); -struct mbuf *m_prepend __P((struct mbuf *, int, int)); -struct mbuf *m_pullup __P((struct mbuf *, int)); -struct mbuf *m_retry __P((int, int)); -struct mbuf *m_retryhdr __P((int, int)); -void m_adj __P((struct mbuf *, int)); -int m_clalloc __P((int, int)); -void m_freem __P((struct mbuf *)); -int m_freem_list __P((struct mbuf *)); -struct mbuf *m_devget __P((char *, int, int, struct ifnet *, void (*)())); -char *mcl_to_paddr __P((char *)); -struct mbuf *m_aux_add __P((struct mbuf *, int, int)); -struct mbuf *m_aux_find __P((struct mbuf *, int, int)); -void m_aux_delete __P((struct mbuf *, struct mbuf *)); +__BEGIN_DECLS +struct mbuf *m_copym(struct mbuf *, int, int, int); +struct mbuf *m_split(struct mbuf *, int, int); +struct mbuf *m_free(struct mbuf *); +struct mbuf *m_get(int, int); +struct mbuf *m_getpacket(void); +struct mbuf *m_getclr(int, int); +struct mbuf *m_gethdr(int, int); +struct mbuf *m_prepend(struct mbuf *, int, int); +struct mbuf *m_prepend_2(struct mbuf *, int, int); +struct mbuf *m_pullup(struct mbuf *, int); +struct mbuf *m_retry(int, int); +struct mbuf *m_retryhdr(int, int); +void m_adj(struct mbuf *, int); +void m_freem(struct mbuf *); +int m_freem_list(struct mbuf *); +struct mbuf *m_devget(char *, int, int, struct ifnet *, void (*)(const void *, void *, size_t)); +char *mcl_to_paddr(char *); +struct mbuf *m_pulldown(struct mbuf*, int, int, int*); +struct mbuf *m_aux_add(struct mbuf *, int, int); +struct mbuf *m_aux_find(struct mbuf *, int, int); +void m_aux_delete(struct mbuf *, struct mbuf *); + +struct mbuf *m_mclget(struct mbuf *, int); +caddr_t m_mclalloc(int); +void m_mclfree(caddr_t p); +int m_mclhasreference(struct mbuf *); +void m_copy_pkthdr(struct mbuf *, struct mbuf*); + +int m_mclref(struct mbuf *); +int m_mclunref(struct mbuf *); + +void * m_mtod(struct mbuf *); +struct mbuf * m_dtom(void *); +int m_mtocl(void *); +union mcluster *m_cltom(int ); + +int m_trailingspace(struct mbuf *); +int m_leadingspace(struct mbuf *); + +void m_mchtype(struct mbuf *m, int t); +void m_mcheck(struct mbuf*); + +void m_copyback(struct mbuf *, int , int , caddr_t); +void m_copydata(struct mbuf *, int , int , caddr_t); +struct mbuf* m_dup(struct mbuf *m, int how); +void m_cat(struct mbuf *, struct mbuf *); +struct mbuf *m_copym_with_hdrs(struct mbuf*, int, int, int, struct mbuf**, int*); +struct mbuf *m_getpackets(int, int, int); +struct mbuf * m_getpackethdrs(int , int ); +struct mbuf* m_getpacket_how(int ); +struct mbuf * m_getpackets_internal(unsigned int *, int , int , int , size_t); +struct mbuf * m_allocpacket_internal(unsigned int * , size_t , unsigned int *, int , int , size_t ); + +__END_DECLS + +/* + Packets may have annotations attached by affixing a list of "packet + tags" to the pkthdr structure. Packet tags are dynamically allocated + semi-opaque data structures that have a fixed header (struct m_tag) + that specifies the size of the memory block and an pair that + identifies it. The id identifies the module and the type identifies the + type of data for that module. The id of zero is reserved for the kernel. + + Note that the packet tag returned by m_tag_allocate has the default + memory alignment implemented by malloc. To reference private data one + can use a construct like: + + struct m_tag *mtag = m_tag_allocate(...); + struct foo *p = (struct foo *)(mtag+1); + + if the alignment of struct m_tag is sufficient for referencing members + of struct foo. Otherwise it is necessary to embed struct m_tag within + the private data structure to insure proper alignment; e.g. + + struct foo { + struct m_tag tag; + ... + }; + struct foo *p = (struct foo *) m_tag_allocate(...); + struct m_tag *mtag = &p->tag; + */ + +#define KERNEL_MODULE_TAG_ID 0 + +enum { + KERNEL_TAG_TYPE_NONE = 0, + KERNEL_TAG_TYPE_DUMMYNET = 1, + KERNEL_TAG_TYPE_DIVERT = 2, + KERNEL_TAG_TYPE_IPFORWARD = 3, + KERNEL_TAG_TYPE_IPFILT = 4 +}; + +/* + * As a temporary and low impact solution to replace the even uglier + * approach used so far in some parts of the network stack (which relies + * on global variables), packet tag-like annotations are stored in MT_TAG + * mbufs (or lookalikes) prepended to the actual mbuf chain. + * + * m_type = MT_TAG + * m_flags = m_tag_id + * m_next = next buffer in chain. + * + * BE VERY CAREFUL not to pass these blocks to the mbuf handling routines. + */ +#define _m_tag_id m_hdr.mh_flags + +__BEGIN_DECLS + +/* Packet tag routines */ +struct m_tag *m_tag_alloc(u_int32_t id, u_int16_t type, int len, int wait); +void m_tag_free(struct m_tag *); +void m_tag_prepend(struct mbuf *, struct m_tag *); +void m_tag_unlink(struct mbuf *, struct m_tag *); +void m_tag_delete(struct mbuf *, struct m_tag *); +void m_tag_delete_chain(struct mbuf *, struct m_tag *); +struct m_tag *m_tag_locate(struct mbuf *,u_int32_t id, u_int16_t type, + struct m_tag *); +struct m_tag *m_tag_copy(struct m_tag *, int wait); +int m_tag_copy_chain(struct mbuf *to, struct mbuf *from, int wait); +void m_tag_init(struct mbuf *); +struct m_tag *m_tag_first(struct mbuf *); +struct m_tag *m_tag_next(struct mbuf *, struct m_tag *); + +__END_DECLS + +#endif /* KERNEL */ + +#endif /* KERNEL_PRIVATE */ +#ifdef KERNEL +#include #endif #endif /* !_SYS_MBUF_H_ */