|
ADC Home > Reference Library > Reference > Darwin > KPI Reference
|
kpi_mbuf.h |
| Includes: | <sys/kernel_types.h> <mach/vm_types.h> |
This header defines an API for interacting with mbufs. mbufs are the
primary method of storing packets in the networking stack.
mbufs are used to store various items in the networking stack. The
most common usage of an mbuf is to store a packet or data on a
socket waiting to be sent or received. The mbuf is a contiguous
structure with some header followed by some data. To store more data
than would fit in an mbuf, external data is used. Most mbufs with
external data use clusters to store the external data.
mbufs can be chained, contiguous data in a packet can be found by
following the m_next chain. Packets may be bundled together using
m_nextpacket. Many parts of the stack do not properly handle chains
of packets. When in doubt, don't chain packets.
mbuf_adj |
void mbuf_adj( mbuf_t mbuf, int len);
mbuflenTrims len bytes from the mbuf. If the length is greater than zero, the bytes are trimmed from the front of the mbuf. If the length is less than zero, the bytes are trimmed from the end of the mbuf chain.
mbuf_adjustlen |
errno_t mbuf_adjustlen( mbuf_t mbuf, int amount);
mbufamount0 upon success otherwise the errno error.
Adds amount to the mbuf len. Verifies that the new length is valid (greater than or equal to zero and less than maximum amount of data that may be stored in the mbuf). This function will not adjust the packet header length field or affect any other mbufs in a chain.
mbuf_align_32 |
errno_t mbuf_align_32( mbuf_t mbuf, size_t len);
mbuflen0 on success, errno error on failure.
mbuf_align_32 is a replacement for M_ALIGN and MH_ALIGN. mbuf_align_32 will set the data pointer to a location aligned on a four byte boundry with at least 'len' bytes between the data pointer and the end of the data block.
mbuf_allocpacket |
errno_t mbuf_allocpacket( mbuf_how_t how, size_t packetlen, unsigned int *maxchunks, mbuf_t *mbuf);
howpacketlenmaxchunksUponReturns 0 upon success or the following error code: EINVAL - Invalid parameter ENOMEM - Not enough memory available ENOBUFS - Buffers not big enough for the maximum number of chunks requested
Allocate an mbuf chain to store a single packet of the requested length. According to the requested length, a chain of mbufs will be created. The mbuf type will be set to MBUF_TYPE_DATA. The caller may specify the maximum number of buffer
mbuf_allocpacket_list |
errno_t mbuf_allocpacket_list( unsigned int numpkts, mbuf_how_t how, size_t packetlen, unsigned int *maxchunks, mbuf_t *mbuf);
numpktshowpacketlenmaxchunksUponReturns 0 upon success or the following error code: EINVAL - Invalid parameter ENOMEM - Not enough memory available ENOBUFS - Buffers not big enough for the maximum number of chunks requested
Allocate a linked list of packets. According to the requested length, each packet will made of a chain of one or more mbufs. The mbuf type will be set to MBUF_TYPE_DATA. The caller may specify the maximum number of element for each mbuf chain making up a packet.
mbuf_clear_csum_performed |
errno_t mbuf_clear_csum_performed( mbuf_t mbuf);
mbuf0 upon success otherwise the errno error.
Clears the hardware checksum flags and values.
mbuf_clear_csum_requested |
errno_t mbuf_clear_csum_requested( mbuf_t mbuf);
mbuf0 upon success otherwise the errno error.
This function clears the checksum request flags.
mbuf_clear_vlan_tag |
errno_t mbuf_clear_vlan_tag( mbuf_t mbuf);
mbuf0 upon success otherwise the errno error.
This function will clear any vlan tag associated with the mbuf.
mbuf_copy_pkthdr |
errno_t mbuf_copy_pkthdr( mbuf_t dest, const mbuf_t src);
srcmbuf0 upon success otherwise the errno error.
Copies the packet header from src to dest.
mbuf_copyback |
errno_t mbuf_copyback( mbuf_t mbuf, size_t offset, size_t length, const void *data, mbuf_how_t how);
mbufoffsetlengthdatahow0 upon success, EINVAL or ENOBUFS upon failure.
Copies data from a buffer to an mbuf chain.
mbuf_copyback will grow the chain to fit the specified buffer.
If mbuf_copydata is unable to allocate enough mbufs to grow the
chain, ENOBUFS will be returned. The mbuf chain will be shorter
than expected but all of the data up to the end of the mbuf
chain will be valid.
If an offset is specified, mbuf_copyback will skip that many
bytes in the mbuf chain before starting to write the buffer in
to the chain. If the mbuf chain does not contain this many
bytes, mbufs will be allocated to create the space.
mbuf_copydata |
errno_t mbuf_copydata( const mbuf_t mbuf, size_t offset, size_t length, void*out_data);
mbufoffsetlengthout_data0 upon success otherwise the errno error.
Copies data out of an mbuf in to a specified buffer. If the data is stored in a chain of mbufs, the data will be copied from each mbuf in the chain until length bytes have been copied.
mbuf_copym |
errno_t mbuf_copym( const mbuf_t src, size_t offset, size_t len, mbuf_how_t how, mbuf_t*new_mbuf);
srcoffsetlenhownew_mbuf0 upon success otherwise the errno error.
Copies len bytes from offset from src to a new mbuf.
mbuf_data |
void* mbuf_data( mbuf_t mbuf);
mbufA pointer to the data in the mbuf.
Returns a pointer to the start of data in this mbuf. There may be additional data on chained mbufs. The data you're looking for may not be contiguous if it spans more than one mbuf. Use mbuf_len to determine the lenght of data available in this mbuf. If a data structure you want to access stradles two mbufs in a chain, either use mbuf_pullup to get the data contiguous in one mbuf or copy the pieces of data from each mbuf in to a contiguous buffer. Using mbuf_pullup has the advantage of not having to copy the data. On the other hand, if you don't make sure there is space in the mbuf, mbuf_pullup may fail and free the mbuf.
mbuf_data_to_physical |
addr64_t mbuf_data_to_physical( void*ptr);
ptrThe 64 bit physical address of the mbuf data or NULL if ptr does not point to data stored in an mbuf.
mbuf_data_to_physical is a replacement for mcl_to_paddr. Given a pointer returned from mbuf_data of mbuf_datastart, mbuf_data_to_physical will return the phyical address for that block of data.
mbuf_datastart |
void* mbuf_datastart( mbuf_t mbuf);
mbufA pointer to smallest possible value for data.
Returns the start of the space set aside for storing data in an mbuf. An mbuf's data may come from a cluster or be embedded in the mbuf structure itself. The data pointer retrieved by mbuf_data may not be at the start of the data (mbuf_leadingspace will be non-zero). This function will return to you a pointer that matches mbuf_data() - mbuf_leadingspace().
mbuf_dup |
errno_t mbuf_dup( const mbuf_t src, mbuf_how_t how, mbuf_t*new_mbuf);
srchownew_mbuf0 upon success otherwise the errno error.
Exactly duplicates an mbuf chain.
mbuf_flags |
mbuf_flags_t mbuf_flags( const mbuf_t mbuf);
mbufThe flags.
Returns the set flags.
mbuf_free |
mbuf_t mbuf_free( mbuf_t mbuf);
mbufThe next mbuf in the chain.
Frees a single mbuf. Not commonly used because it doesn't touch the rest of the mbufs on the chain.
mbuf_freem |
void mbuf_freem( mbuf_t mbuf);
mbufFrees a chain of mbufs link through mnext.
mbuf_freem_list |
int mbuf_freem_list( mbuf_t mbuf);
mbufThe number of mbufs freed.
Frees linked list of mbuf chains. Walks through mnextpackt and does the equivalent of mbuf_mfreem to each.
mbuf_get |
errno_t mbuf_get( mbuf_how_t how, mbuf_type_t type, mbuf_t*mbuf);
howtypembuf0 on success, errno error on failure.
Allocates an mbuf without a cluster for external data.
mbuf_get_csum_requested |
errno_t mbuf_get_csum_requested( mbuf_t mbuf, mbuf_csum_request_flags_t *request, u_int32_t *value);
mbufrequestvalue0 upon success otherwise the errno error.
This function is used by the driver to determine which checksum operations should be performed in hardware.
mbuf_get_vlan_tag |
errno_t mbuf_get_vlan_tag( mbuf_t mbuf, u_int16_t *vlan);
mbufvlan0 upon success otherwise the errno error. ENXIO indicates that the vlan tag is not set.
This function is used by drivers that support hardware vlan tagging to determine which vlan this packet belongs to. To differentiate between the case where the vlan tag is zero and the case where there is no vlan tag, this function will return ENXIO when there is no vlan.
mbuf_getcluster |
errno_t mbuf_getcluster( mbuf_how_t how, mbuf_type_t type, size_t size, mbuf_t*mbuf);
howtypesizembuf0 on success, errno error on failure. If you specified NULL for the mbuf, any intermediate mbuf that may have been allocated will be freed. If you specify an mbuf value in *mbuf, mbuf_mclget will not free it. EINVAL - Invalid parameter ENOMEM - Not enough memory available
Allocate a cluster of the requested size and attach it to an mbuf for use as external data. If mbuf points to a NULL mbuf_t, an mbuf will be allocated for you. If mbuf points to a non-NULL mbuf_t, mbuf_getcluster may return a different mbuf_t than the one you passed in.
mbuf_gethdr |
errno_t mbuf_gethdr( mbuf_how_t how, mbuf_type_t type, mbuf_t*mbuf);
howtypembuf0 on success, errno error on failure.
Allocates an mbuf without a cluster for external data. Sets a flag to indicate there is a packet header and initializes the packet header.
mbuf_getpacket |
errno_t mbuf_getpacket( mbuf_how_t how, mbuf_t*mbuf);
howmbuf0 on success, errno error on failure.
Allocate an mbuf, allocate and attach a cluster, and set the packet header flag.
mbuf_inbound_modified |
void mbuf_inbound_modified( mbuf_t mbuf);
mbufThis function will clear the checksum flags to indicate that a hardware checksum should not be used. Any filter modifying data should call this function on an mbuf before passing the packet up the stack. If a filter modifies a packet in a way that affects any checksum, the filter is responsible for either modifying the checksum to compensate for the changes or verifying the checksum before making the changes and then modifying the data and calculating a new checksum only if the original checksum was valid.
mbuf_leadingspace |
size_t mbuf_leadingspace( const mbuf_t mbuf);
mbufThe number of unused bytes at the start of the mbuf.
Determines the space available in the mbuf proceeding the current data.
mbuf_len |
size_t mbuf_len( const mbuf_t mbuf);
mbufThe length.
Gets the length of data in this mbuf.
mbuf_maxlen |
size_t mbuf_maxlen( const mbuf_t mbuf);
mbufThe maximum lenght of data for this mbuf.
Retrieves the maximum length of data that may be stored in this mbuf. This value assumes that the data pointer was set to the start of the possible range for that pointer (mbuf_data_start).
mbuf_mclget |
errno_t mbuf_mclget( mbuf_how_t how, mbuf_type_t type, mbuf_t*mbuf);
howtypembuf0 on success, errno error on failure. If you specified NULL for the mbuf, any intermediate mbuf that may have been allocated will be freed. If you specify an mbuf value in *mbuf, mbuf_mclget will not free it.
Allocate a cluster and attach it to an mbuf for use as external data. If mbuf points to a NULL mbuf_t, an mbuf will be allocated for you. If mbuf points to a non-NULL mbuf_t, mbuf_mclget may return a different mbuf_t than the one you passed in.
mbuf_mclhasreference |
int mbuf_mclhasreference( mbuf_t mbuf);
mbuf0 if there is no reference by another mbuf, 1 otherwise.
Check if a cluster of an mbuf is referenced by another mbuf. References may be taken, for example, as a result of a call to mbuf_split or mbuf_copym
mbuf_next |
mbuf_t mbuf_next( const mbuf_t mbuf);
mbufThe next mbuf in the chain.
Returns the next mbuf in the chain.
mbuf_nextpkt |
mbuf_t mbuf_nextpkt( const mbuf_t mbuf);
mbufThe nextpkt.
Gets the next packet from the mbuf.
mbuf_outbound_finalize |
void mbuf_outbound_finalize( mbuf_t mbuf, u_long protocol_family, size_t protocol_offset);
mbufprotocol_familyprotocol_offsetThis function will "finalize" the packet allowing your
code to inspect the final packet.
There are a number of operations that are performed in hardware,
such as calculating checksums. This function will perform in
software the various opterations that were scheduled to be done
in hardware. Future operations may include IPSec processing or
vlan support. If you are redirecting a packet to a new interface
which may not have the same hardware support or encapsulating
the packet, you should call this function to force the stack to
calculate and fill out the checksums. This will bypass hardware
checksums but give you a complete packet to work with. If you
need to inspect aspects of the packet which may be generated by
hardware, you must call this function to get an aproximate final
packet. If you plan to modify the packet in any way, you should
call this function.
This function should be called before modifying any outbound
packets.
This function may be called at various levels, in some cases
additional headers may have already been prepended, such as the
case of a packet seen by an interface filter. To handle this,
the caller must pass the protocol family of the packet as well
as the offset from the start of the packet to the protocol
header.
mbuf_pkthdr_adjustlen |
void mbuf_pkthdr_adjustlen( mbuf_t mbuf, int amount);
mbufamountAdjusts the length of the packet in the packet header.
mbuf_pkthdr_header |
void* mbuf_pkthdr_header( const mbuf_t mbuf);
mbufA pointer to the packet header.
Returns a pointer to the packet header.
mbuf_pkthdr_len |
size_t mbuf_pkthdr_len( const mbuf_t mbuf);
mbufThe length, in bytes, of the packet.
Returns the length as reported by the packet header.
mbuf_pkthdr_rcvif |
ifnet_t mbuf_pkthdr_rcvif( const mbuf_t mbuf);
mbufA reference to the interface.
Returns the interface the packet was received on. This funciton does not modify the reference count of the interface. The interface is only valid for as long as the mbuf is not freed and the rcvif for the mbuf is not changed. Take a reference on the interface that you will release later before doing any of the following: free the mbuf, change the rcvif, pass the mbuf to any function that may free the mbuf or change the rcvif.
mbuf_pkthdr_setheader |
void mbuf_pkthdr_setheader( mbuf_t mbuf, void*header);
mbufifnet0 upon success otherwise the errno error.
Sets the pointer to the packet header.
mbuf_pkthdr_setlen |
void mbuf_pkthdr_setlen( mbuf_t mbuf, size_t len);
mbuflenSets the length of the packet in the packet header.
mbuf_pkthdr_setrcvif |
errno_t mbuf_pkthdr_setrcvif( mbuf_t mbuf, ifnet_t ifnet);
mbufifnet0 upon success otherwise the errno error.
Sets the interface the packet was received on.
mbuf_prepend |
errno_t mbuf_prepend( mbuf_t*mbuf, size_t len, mbuf_how_t how);
mbuflenhow0 upon success otherwise the errno error.
Prepend len bytes to an mbuf. If there is space (mbuf_leadingspace >= len), the mbuf's data ptr is changed and the same mbuf is returned. If there is no space, a new mbuf may be allocated and prepended to the mbuf chain. If the operation fails, the mbuf may be freed (*mbuf will be NULL).
mbuf_pulldown |
errno_t mbuf_pulldown( mbuf_t src, size_t *offset, size_t length, mbuf_t *location);
srcoffsetlengthlocation0 upon success otherwise the errno error.
Make length bytes at offset in the mbuf chain contiguous. Nothing before offset bytes in the chain will be modified. Upon return, location will be the mbuf the data is contiguous in and offset will be the offset in that mbuf at which the data is located. In the case of a failure, the mbuf chain will be freed.
mbuf_pullup |
errno_t mbuf_pullup( mbuf_t*mbuf, size_t len);
mbuflen0 upon success otherwise the errno error. In the case of an error, the mbuf chain has been freed.
Move the next len bytes in to mbuf from other mbufs in the chain. This is commonly used to get the IP and TCP or UDP header contiguous in the first mbuf. If mbuf_pullup fails, the entire mbuf chain will be freed.
mbuf_set_csum_performed |
errno_t mbuf_set_csum_performed( mbuf_t mbuf, mbuf_csum_performed_flags_t flags, u_int32_t value);
mbufflagsvalue0 upon success otherwise the errno error.
This is used by the driver to indicate to the stack which checksum operations were performed in hardware.
mbuf_set_vlan_tag |
errno_t mbuf_set_vlan_tag( mbuf_t mbuf, u_int16_t vlan);
mbufvlan0 upon success otherwise the errno error.
This function is used by interfaces that support vlan tagging in hardware. This function will set properties in the mbuf to indicate which vlan the packet was received for.
mbuf_setdata |
errno_t mbuf_setdata( mbuf_t mbuf, void *data, size_t len);
mbufdatalen0 on success, errno error on failure.
Sets the data and length values for an mbuf. The data value must be in a valid range. In the case of an mbuf with a cluster, the data value must point to a location in the cluster and the data value plus the length, must be less than the end of the cluster. For data embedded directly in an mbuf (no cluster), the data value must fall somewhere between the start and end of the data area in the mbuf and the data + length must also be in the same range.
mbuf_setflags |
errno_t mbuf_setflags( mbuf_t mbuf, mbuf_flags_t flags);
mbufflags0 upon success otherwise the errno error.
Sets the set of set flags.
mbuf_setflags_mask |
errno_t mbuf_setflags_mask( mbuf_t mbuf, mbuf_flags_t flags, mbuf_flags_t mask);
mbufflagsmask0 upon success otherwise the errno error.
Useful for setting or clearing individual flags. Easier than calling mbuf_setflags(m, mbuf_flags(m) | M_FLAG).
mbuf_setlen |
void mbuf_setlen( mbuf_t mbuf, size_t len);
mbuflen0 upon success otherwise the errno error.
Sets the length of data in this packet. Be careful to not set the length over the space available in the mbuf.
mbuf_setnext |
errno_t mbuf_setnext( mbuf_t mbuf, mbuf_t next);
mbufnext0 upon success otherwise the errno error.
Sets the next mbuf in the chain.
mbuf_setnextpkt |
void mbuf_setnextpkt( mbuf_t mbuf, mbuf_t nextpkt);
mbufnextpktSets the next packet attached to this mbuf.
mbuf_settype |
errno_t mbuf_settype( mbuf_t mbuf, mbuf_type_t new_type);
mbufnew_type0 upon success otherwise the errno error.
Sets the type of mbuf.
mbuf_split |
errno_t mbuf_split( mbuf_t src, size_t offset, mbuf_how_t how, mbuf_t*new_mbuf);
srcoffsethownew_mbuf0 upon success otherwise the errno error. In the case of failure, the original mbuf chain passed in to src will be preserved.
Split an mbuf chain at a specific offset.
mbuf_stats |
void mbuf_stats( struct mbuf_stat*stats);
statsGet the mbuf statistics.
mbuf_tag_allocate |
errno_t mbuf_tag_allocate( mbuf_t mbuf, mbuf_tag_id_t module_id, mbuf_tag_type_t type, size_t length, mbuf_how_t how, void** data_p);
mbufmodule_idtypelengthhowdata_p0 upon success otherwise the errno error.
Allocate an mbuf tag. Mbuf tags allow various portions
of the stack to tag mbufs with data that will travel with the
mbuf through the stack.
Tags may only be added to mbufs with packet headers
(MBUF_PKTHDR flag is set). Mbuf tags are freed when the mbuf is
freed or when mbuf_tag_free is called.
mbuf_tag_find |
errno_t mbuf_tag_find( mbuf_t mbuf, mbuf_tag_id_t module_id, mbuf_tag_type_t type, size_t *length, void** data_p);
mbufmodule_idtypelengthdata_p0 upon success otherwise the errno error.
Find the data associated with an mbuf tag.
mbuf_tag_free |
void mbuf_tag_free( mbuf_t mbuf, mbuf_tag_id_t module_id, mbuf_tag_type_t type);
mbufmodule_idtypeFrees a previously allocated mbuf tag.
mbuf_tag_id_find |
errno_t mbuf_tag_id_find( const char *module_string, mbuf_tag_id_t *module_id);
module_stringmodule_id0 upon success otherwise the errno error.
Lookup the module id for a string. If there is no module
id assigned to this string, a new module id will be assigned.
The string should be the bundle id of the kext. In the case of a
tag that will be shared across multiple kexts, a common bundle id
style string should be used.
The lookup operation is not optimized. A module should call this
function once during startup and chache the module id. The module id
will not be resassigned until the machine reboots.
mbuf_trailingspace |
size_t mbuf_trailingspace( const mbuf_t mbuf);
mbufThe number of unused bytes following the current data.
Determines the space available in the mbuf following the current data.
mbuf_type |
mbuf_type_t mbuf_type( const mbuf_t mbuf);
mbufThe type.
Gets the type of mbuf.
mbuf_stat |
struct mbuf_stat { u_long mbufs; /* mbufs obtained from page pool */ u_long clusters; /* clusters obtained from page pool */ u_long clfree; /* free clusters */ u_long drops; /* times failed to find space */ u_long wait; /* times waited for space */ u_long drain; /* times drained protocols for space */ u_short mtypes[256]; /* type specific mbuf allocations */ u_long mcfail; /* times m_copym failed */ u_long mpfail; /* times m_pullup failed */ u_long msize; /* length of an mbuf */ u_long mclbytes; /* length of an mbuf cluster */ u_long minclsize; /* min length of data to allocate a cluster */ u_long mlen; /* length of data in an mbuf */ u_long mhlen; /* length of data in a header mbuf */ u_long bigclusters; /* number of big clusters */ u_long bigclfree; /* number of big clustser free */ u_long bigmclbytes; /* length of data in a big cluster */ };
mbufs- Number of mbufs (free or otherwise).
clusters- Number of clusters (free or otherwise).
clfree- Number of free clusters.
drops- Number of times allocation failed.
wait- Number of times allocation blocked.
drain- Number of times protocol drain functions were called.
mtypes- An array of counts of each type of mbuf allocated.
mcfail- Number of times m_copym failed.
mpfail- Number of times m_pullup failed.
msize- Length of an mbuf.
mclbytes- Length of an mbuf cluster.
minclsize- Minimum length of data to allocate a cluster. Anything smaller than this should be placed in chained mbufs.
mlen- Length of data in an mbuf.
mhlen- Length of data in an mbuf with a packet header.
bigclusters- Number of big clusters.
bigclfree- Number of unused big clusters.
bigmclbytes- Length of a big mbuf cluster.
The mbuf_stat contains mbuf statistics.
mbuf_csum_performed_flags_t |
Checksum performed/requested flags.
enum { MBUF_CSUM_DID_IP = 0x0100, MBUF_CSUM_IP_GOOD = 0x0200, MBUF_CSUM_DID_DATA = 0x0400, MBUF_CSUM_PSEUDO_HDR = 0x0800 };
MBUF_CSUM_DID_IP- Indicates that the driver/hardware verified the IP checksum in hardware.
MBUF_CSUM_IP_GOOD- Indicates whether or not the IP checksum was good or bad. Only valid when MBUF_CSUM_DID_IP is set.
MBUF_CSUM_DID_DATA- Indicates that the TCP or UDP checksum was calculated. The value for the checksum calculated in hardware should be passed as the second parameter of mbuf_set_csum_performed. The hardware calculated checksum value can be retrieved using the second parameter passed to mbuf_get_csum_performed.
MBUF_CSUM_PSEUDO_HDR- If set, this indicates that the checksum value for MBUF_CSUM_DID_DATA includes the pseudo header value. If this is not set, the stack will calculate the pseudo header value and add that to the checksum. The value of this bit is only valid when MBUF_CSUM_DID_DATA is set.
Mbufs often contain packets. Some hardware supports performing checksums in hardware. The driver uses these flags to communicate to the stack the checksums that were calculated in hardware.
mbuf_csum_request_flags_t |
Checksum performed/requested flags.
enum { MBUF_CSUM_REQ_IP = 0x0001, MBUF_CSUM_REQ_TCP = 0x0002, MBUF_CSUM_REQ_UDP = 0x0004 };
MBUF_CSUM_REQ_IP- Indicates the IP checksum has not been calculated yet.
MBUF_CSUM_REQ_TCP- Indicates the TCP checksum has not been calculated yet.
MBUF_CSUM_REQ_UDP- Indicates the UDP checksum has not been calculated yet.
Mbufs often contain packets. Some hardware supports performing checksums in hardware. The stack uses these flags to indicate to the driver what sort of checksumming should be handled in by the driver/hardware. These flags will only be set if the driver indicates that it supports the corresponding checksums using ifnet_set_offload.
mbuf_flags_t |
Constants defining mbuf flags. Only the flags listed below can be set or retreieved.
enum { MBUF_EXT = 0x0001, /* has associated external storage */ MBUF_PKTHDR = 0x0002, /* start of record */ MBUF_EOR = 0x0004, /* end of record */ MBUF_BCAST = 0x0100, /* send/received as link-level broadcast */ MBUF_MCAST = 0x0200, /* send/received as link-level multicast */ MBUF_FRAG = 0x0400, /* packet is a fragment of a larger packet */ MBUF_FIRSTFRAG = 0x0800, /* packet is first fragment */ MBUF_LASTFRAG = 0x1000, /* packet is last fragment */ MBUF_PROMISC = 0x2000 /* packet is promiscuous */ };
MBUF_EXT- Indicates this mbuf has external data.
MBUF_PKTHDR- Indicates this mbuf has a packet header.
MBUF_EOR- Indicates this mbuf is the end of a record.
MBUF_BCAST- Indicates this packet will be sent or was received as a brodcast.
MBUF_MCAST- Indicates this packet will be sent or was received as a multicast.
MBUF_FRAG- Indicates this packet is a fragment of a larger packet.
MBUF_FIRSTFRAG- Indicates this packet is the first fragment.
MBUF_LASTFRAG- Indicates this packet is the last fragment.
MBUF_PROMISC- Indicates this packet was only received because the interface is in promiscuous mode. This should be set by the demux function. These packets will be discarded after being passed to any interface filters.
mbuf_how_t |
Method of allocating an mbuf.
enum { MBUF_WAITOK = 0, /* Ok to block to get memory */ MBUF_DONTWAIT = 1 /* Don't block, fail if blocking would be required */ };
MBUF_WAITOK- Allow a call to allocate an mbuf to block.
MBUF_DONTWAIT- Don't allow the mbuf allocation call to block, if blocking is necessary fail and return immediately.
Blocking will cause the funnel to be dropped. If the funnel is dropped, other threads may make changes to networking data structures. This can lead to very bad things happening. Blocking on the input our output path can also impact performance. There are some cases where making a blocking call is acceptable. When in doubt, use MBUF_DONTWAIT.
mbuf_type_t |
Types of mbufs.
enum { MBUF_TYPE_FREE = 0, /* should be on free list */ MBUF_TYPE_DATA = 1, /* dynamic (data) allocation */ MBUF_TYPE_HEADER = 2, /* packet header */ MBUF_TYPE_SOCKET = 3, /* socket structure */ MBUF_TYPE_PCB = 4, /* protocol control block */ MBUF_TYPE_RTABLE = 5, /* routing tables */ MBUF_TYPE_HTABLE = 6, /* IMP host tables */ MBUF_TYPE_ATABLE = 7, /* address resolution tables */ MBUF_TYPE_SONAME = 8, /* socket name */ MBUF_TYPE_SOOPTS = 10, /* socket options */ MBUF_TYPE_FTABLE = 11, /* fragment reassembly header */ MBUF_TYPE_RIGHTS = 12, /* access rights */ MBUF_TYPE_IFADDR = 13, /* interface address */ MBUF_TYPE_CONTROL = 14, /* extra-data protocol message */ MBUF_TYPE_OOBDATA = 15 /* expedited data */ };
MBUF_MT_FREE- Indicates the mbuf is free and is sitting on the queue of free mbufs. If you find that an mbuf you have a reference to has this type, something has gone terribly wrong.
MBUF_MT_DATA- Indicates this mbuf is being used to store data.
MBUF_MT_HEADER- Indicates this mbuf has a packet header, this is probably a packet.
MBUF_MT_SOCKET- Socket structure.
MBUF_MT_PCB- Protocol control block.
MBUF_MT_RTABLE- Routing table entry.
MBUF_MT_HTABLE- IMP host tables???.
MBUF_MT_ATABLE- Address resolution table data.
MBUF_MT_SONAME- Socket name, usually a sockaddr of some sort.
MBUF_MT_FTABLE- Fragment reassembly header.
MBUF_MT_RIGHTS- Access rights.
MBUF_MT_IFADDR- Interface address.
MBUF_MT_CONTROL- Extra-data protocol message (control message).
MBUF_MT_OOBDATA- Out of band data.
Some mbufs represent packets, some represnt data waiting on sockets. Other mbufs store control data or other various structures. The mbuf type is used to store what sort of data the mbuf contains.
|