apps: fix default mbuf size
[dpdk.git] / lib / librte_mbuf / rte_mbuf.h
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   Copyright 2014 6WIND S.A.
6  *   All rights reserved.
7  *
8  *   Redistribution and use in source and binary forms, with or without
9  *   modification, are permitted provided that the following conditions
10  *   are met:
11  *
12  *     * Redistributions of source code must retain the above copyright
13  *       notice, this list of conditions and the following disclaimer.
14  *     * Redistributions in binary form must reproduce the above copyright
15  *       notice, this list of conditions and the following disclaimer in
16  *       the documentation and/or other materials provided with the
17  *       distribution.
18  *     * Neither the name of Intel Corporation nor the names of its
19  *       contributors may be used to endorse or promote products derived
20  *       from this software without specific prior written permission.
21  *
22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 #ifndef _RTE_MBUF_H_
36 #define _RTE_MBUF_H_
37
38 /**
39  * @file
40  * RTE Mbuf
41  *
42  * The mbuf library provides the ability to create and destroy buffers
43  * that may be used by the RTE application to store message
44  * buffers. The message buffers are stored in a mempool, using the
45  * RTE mempool library.
46  *
47  * This library provide an API to allocate/free packet mbufs, which are
48  * used to carry network packets.
49  *
50  * To understand the concepts of packet buffers or mbufs, you
51  * should read "TCP/IP Illustrated, Volume 2: The Implementation,
52  * Addison-Wesley, 1995, ISBN 0-201-63354-X from Richard Stevens"
53  * http://www.kohala.com/start/tcpipiv2.html
54  */
55
56 #include <stdint.h>
57 #include <rte_mempool.h>
58 #include <rte_memory.h>
59 #include <rte_atomic.h>
60 #include <rte_prefetch.h>
61 #include <rte_branch_prediction.h>
62
63 #ifdef __cplusplus
64 extern "C" {
65 #endif
66
67 /* deprecated options */
68 #pragma GCC poison RTE_MBUF_SCATTER_GATHER
69 #pragma GCC poison RTE_MBUF_REFCNT
70
71 /*
72  * Packet Offload Features Flags. It also carry packet type information.
73  * Critical resources. Both rx/tx shared these bits. Be cautious on any change
74  *
75  * - RX flags start at bit position zero, and get added to the left of previous
76  *   flags.
77  * - The most-significant 8 bits are reserved for generic mbuf flags
78  * - TX flags therefore start at bit position 55 (i.e. 63-8), and new flags get
79  *   added to the right of the previously defined flags
80  *
81  * Keep these flags synchronized with rte_get_rx_ol_flag_name() and
82  * rte_get_tx_ol_flag_name().
83  */
84 #define PKT_RX_VLAN_PKT      (1ULL << 0)  /**< RX packet is a 802.1q VLAN packet. */
85 #define PKT_RX_RSS_HASH      (1ULL << 1)  /**< RX packet with RSS hash result. */
86 #define PKT_RX_FDIR          (1ULL << 2)  /**< RX packet with FDIR match indicate. */
87 #define PKT_RX_L4_CKSUM_BAD  (1ULL << 3)  /**< L4 cksum of RX pkt. is not OK. */
88 #define PKT_RX_IP_CKSUM_BAD  (1ULL << 4)  /**< IP cksum of RX pkt. is not OK. */
89 #define PKT_RX_EIP_CKSUM_BAD (0ULL << 0)  /**< External IP header checksum error. */
90 #define PKT_RX_OVERSIZE      (0ULL << 0)  /**< Num of desc of an RX pkt oversize. */
91 #define PKT_RX_HBUF_OVERFLOW (0ULL << 0)  /**< Header buffer overflow. */
92 #define PKT_RX_RECIP_ERR     (0ULL << 0)  /**< Hardware processing error. */
93 #define PKT_RX_MAC_ERR       (0ULL << 0)  /**< MAC error. */
94 #define PKT_RX_IPV4_HDR      (1ULL << 5)  /**< RX packet with IPv4 header. */
95 #define PKT_RX_IPV4_HDR_EXT  (1ULL << 6)  /**< RX packet with extended IPv4 header. */
96 #define PKT_RX_IPV6_HDR      (1ULL << 7)  /**< RX packet with IPv6 header. */
97 #define PKT_RX_IPV6_HDR_EXT  (1ULL << 8)  /**< RX packet with extended IPv6 header. */
98 #define PKT_RX_IEEE1588_PTP  (1ULL << 9)  /**< RX IEEE1588 L2 Ethernet PT Packet. */
99 #define PKT_RX_IEEE1588_TMST (1ULL << 10) /**< RX IEEE1588 L2/L4 timestamped packet.*/
100 #define PKT_RX_TUNNEL_IPV4_HDR (1ULL << 11) /**< RX tunnel packet with IPv4 header.*/
101 #define PKT_RX_TUNNEL_IPV6_HDR (1ULL << 12) /**< RX tunnel packet with IPv6 header. */
102 #define PKT_RX_FDIR_ID       (1ULL << 13) /**< FD id reported if FDIR match. */
103 #define PKT_RX_FDIR_FLX      (1ULL << 14) /**< Flexible bytes reported if FDIR match. */
104 /* add new RX flags here */
105
106 /* add new TX flags here */
107
108 /**
109  * TCP segmentation offload. To enable this offload feature for a
110  * packet to be transmitted on hardware supporting TSO:
111  *  - set the PKT_TX_TCP_SEG flag in mbuf->ol_flags (this flag implies
112  *    PKT_TX_TCP_CKSUM)
113  *  - set the flag PKT_TX_IPV4 or PKT_TX_IPV6
114  *  - if it's IPv4, set the PKT_TX_IP_CKSUM flag and write the IP checksum
115  *    to 0 in the packet
116  *  - fill the mbuf offload information: l2_len, l3_len, l4_len, tso_segsz
117  *  - calculate the pseudo header checksum without taking ip_len in account,
118  *    and set it in the TCP header. Refer to rte_ipv4_phdr_cksum() and
119  *    rte_ipv6_phdr_cksum() that can be used as helpers.
120  */
121 #define PKT_TX_TCP_SEG       (1ULL << 50)
122
123 #define PKT_TX_IEEE1588_TMST (1ULL << 51) /**< TX IEEE1588 packet to timestamp. */
124
125 /**
126  * Bits 52+53 used for L4 packet type with checksum enabled: 00: Reserved,
127  * 01: TCP checksum, 10: SCTP checksum, 11: UDP checksum. To use hardware
128  * L4 checksum offload, the user needs to:
129  *  - fill l2_len and l3_len in mbuf
130  *  - set the flags PKT_TX_TCP_CKSUM, PKT_TX_SCTP_CKSUM or PKT_TX_UDP_CKSUM
131  *  - set the flag PKT_TX_IPV4 or PKT_TX_IPV6
132  *  - calculate the pseudo header checksum and set it in the L4 header (only
133  *    for TCP or UDP). See rte_ipv4_phdr_cksum() and rte_ipv6_phdr_cksum().
134  *    For SCTP, set the crc field to 0.
135  */
136 #define PKT_TX_L4_NO_CKSUM   (0ULL << 52) /**< Disable L4 cksum of TX pkt. */
137 #define PKT_TX_TCP_CKSUM     (1ULL << 52) /**< TCP cksum of TX pkt. computed by NIC. */
138 #define PKT_TX_SCTP_CKSUM    (2ULL << 52) /**< SCTP cksum of TX pkt. computed by NIC. */
139 #define PKT_TX_UDP_CKSUM     (3ULL << 52) /**< UDP cksum of TX pkt. computed by NIC. */
140 #define PKT_TX_L4_MASK       (3ULL << 52) /**< Mask for L4 cksum offload request. */
141
142 /**
143  * Offload the IP checksum in the hardware. The flag PKT_TX_IPV4 should
144  * also be set by the application, although a PMD will only check
145  * PKT_TX_IP_CKSUM.
146  *  - set the IP checksum field in the packet to 0
147  *  - fill the mbuf offload information: l2_len, l3_len
148  */
149 #define PKT_TX_IP_CKSUM      (1ULL << 54)
150
151 /**
152  * Packet is IPv4. This flag must be set when using any offload feature
153  * (TSO, L3 or L4 checksum) to tell the NIC that the packet is an IPv4
154  * packet. If the packet is a tunneled packet, this flag is related to
155  * the inner headers.
156  */
157 #define PKT_TX_IPV4          (1ULL << 55)
158
159 /**
160  * Packet is IPv6. This flag must be set when using an offload feature
161  * (TSO or L4 checksum) to tell the NIC that the packet is an IPv6
162  * packet. If the packet is a tunneled packet, this flag is related to
163  * the inner headers.
164  */
165 #define PKT_TX_IPV6          (1ULL << 56)
166
167 #define PKT_TX_VLAN_PKT      (1ULL << 57) /**< TX packet is a 802.1q VLAN packet. */
168
169 /**
170  * Offload the IP checksum of an external header in the hardware. The
171  * flag PKT_TX_OUTER_IPV4 should also be set by the application, alto ugh
172  * a PMD will only check PKT_TX_IP_CKSUM.  The IP checksum field in the
173  * packet must be set to 0.
174  *  - set the outer IP checksum field in the packet to 0
175  *  - fill the mbuf offload information: outer_l2_len, outer_l3_len
176  */
177 #define PKT_TX_OUTER_IP_CKSUM   (1ULL << 58)
178
179 /**
180  * Packet outer header is IPv4. This flag must be set when using any
181  * outer offload feature (L3 or L4 checksum) to tell the NIC that the
182  * outer header of the tunneled packet is an IPv4 packet.
183  */
184 #define PKT_TX_OUTER_IPV4   (1ULL << 59)
185
186 /**
187  * Packet outer header is IPv6. This flag must be set when using any
188  * outer offload feature (L4 checksum) to tell the NIC that the outer
189  * header of the tunneled packet is an IPv6 packet.
190  */
191 #define PKT_TX_OUTER_IPV6    (1ULL << 60)
192
193 #define IND_ATTACHED_MBUF    (1ULL << 62) /**< Indirect attached mbuf */
194
195 /* Use final bit of flags to indicate a control mbuf */
196 #define CTRL_MBUF_FLAG       (1ULL << 63) /**< Mbuf contains control data */
197
198 /**
199  * Get the name of a RX offload flag
200  *
201  * @param mask
202  *   The mask describing the flag.
203  * @return
204  *   The name of this flag, or NULL if it's not a valid RX flag.
205  */
206 const char *rte_get_rx_ol_flag_name(uint64_t mask);
207
208 /**
209  * Get the name of a TX offload flag
210  *
211  * @param mask
212  *   The mask describing the flag. Usually only one bit must be set.
213  *   Several bits can be given if they belong to the same mask.
214  *   Ex: PKT_TX_L4_MASK.
215  * @return
216  *   The name of this flag, or NULL if it's not a valid TX flag.
217  */
218 const char *rte_get_tx_ol_flag_name(uint64_t mask);
219
220 /**
221  * Some NICs need at least 2KB buffer to RX standard Ethernet frame without
222  * splitting it into multiple segments.
223  * So, for mbufs that planned to be involved into RX/TX, the recommended
224  * minimal buffer length is 2KB + RTE_PKTMBUF_HEADROOM.
225  */
226 #define RTE_MBUF_DEFAULT_DATAROOM       2048
227 #define RTE_MBUF_DEFAULT_BUF_SIZE       \
228         (RTE_MBUF_DEFAULT_DATAROOM + RTE_PKTMBUF_HEADROOM)
229
230 /* define a set of marker types that can be used to refer to set points in the
231  * mbuf */
232 typedef void    *MARKER[0];   /**< generic marker for a point in a structure */
233 typedef uint8_t  MARKER8[0];  /**< generic marker with 1B alignment */
234 typedef uint64_t MARKER64[0]; /**< marker that allows us to overwrite 8 bytes
235                                * with a single assignment */
236
237 /**
238  * The generic rte_mbuf, containing a packet mbuf.
239  */
240 struct rte_mbuf {
241         MARKER cacheline0;
242
243         void *buf_addr;           /**< Virtual address of segment buffer. */
244         phys_addr_t buf_physaddr; /**< Physical address of segment buffer. */
245
246         uint16_t buf_len;         /**< Length of segment buffer. */
247
248         /* next 6 bytes are initialised on RX descriptor rearm */
249         MARKER8 rearm_data;
250         uint16_t data_off;
251
252         /**
253          * 16-bit Reference counter.
254          * It should only be accessed using the following functions:
255          * rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
256          * rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
257          * or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
258          * config option.
259          */
260         union {
261                 rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */
262                 uint16_t refcnt;              /**< Non-atomically accessed refcnt */
263         };
264         uint8_t nb_segs;          /**< Number of segments. */
265         uint8_t port;             /**< Input port. */
266
267         uint64_t ol_flags;        /**< Offload features. */
268
269         /* remaining bytes are set on RX when pulling packet from descriptor */
270         MARKER rx_descriptor_fields1;
271
272         /**
273          * The packet type, which is used to indicate ordinary packet and also
274          * tunneled packet format, i.e. each number is represented a type of
275          * packet.
276          */
277         uint16_t packet_type;
278
279         uint16_t data_len;        /**< Amount of data in segment buffer. */
280         uint32_t pkt_len;         /**< Total pkt len: sum of all segments. */
281         uint16_t vlan_tci;        /**< VLAN Tag Control Identifier (CPU order) */
282         uint16_t reserved;
283         union {
284                 uint32_t rss;     /**< RSS hash result if RSS enabled */
285                 struct {
286                         union {
287                                 struct {
288                                         uint16_t hash;
289                                         uint16_t id;
290                                 };
291                                 uint32_t lo;
292                                 /**< Second 4 flexible bytes */
293                         };
294                         uint32_t hi;
295                         /**< First 4 flexible bytes or FD ID, dependent on
296                              PKT_RX_FDIR_* flag in ol_flags. */
297                 } fdir;           /**< Filter identifier if FDIR enabled */
298                 uint32_t sched;   /**< Hierarchical scheduler */
299                 uint32_t usr;     /**< User defined tags. See rte_distributor_process() */
300         } hash;                   /**< hash information */
301
302         uint32_t seqn; /**< Sequence number. See also rte_reorder_insert() */
303
304         /* second cache line - fields only used in slow path or on TX */
305         MARKER cacheline1 __rte_cache_aligned;
306
307         union {
308                 void *userdata;   /**< Can be used for external metadata */
309                 uint64_t udata64; /**< Allow 8-byte userdata on 32-bit */
310         };
311
312         struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */
313         struct rte_mbuf *next;    /**< Next segment of scattered packet. */
314
315         /* fields to support TX offloads */
316         union {
317                 uint64_t tx_offload;       /**< combined for easy fetch */
318                 struct {
319                         uint64_t l2_len:7; /**< L2 (MAC) Header Length. */
320                         uint64_t l3_len:9; /**< L3 (IP) Header Length. */
321                         uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */
322                         uint64_t tso_segsz:16; /**< TCP TSO segment size */
323
324                         /* fields for TX offloading of tunnels */
325                         uint64_t outer_l3_len:9; /**< Outer L3 (IP) Hdr Length. */
326                         uint64_t outer_l2_len:7; /**< Outer L2 (MAC) Hdr Length. */
327
328                         /* uint64_t unused:8; */
329                 };
330         };
331
332         /** Size of the application private data. In case of an indirect
333          * mbuf, it stores the direct mbuf private data size. */
334         uint16_t priv_size;
335 } __rte_cache_aligned;
336
337 static inline uint16_t rte_pktmbuf_priv_size(struct rte_mempool *mp);
338
339 /**
340  * Return the mbuf owning the data buffer address of an indirect mbuf.
341  *
342  * @param mi
343  *   The pointer to the indirect mbuf.
344  * @return
345  *   The address of the direct mbuf corresponding to buffer_addr.
346  */
347 static inline struct rte_mbuf *
348 rte_mbuf_from_indirect(struct rte_mbuf *mi)
349 {
350         struct rte_mbuf *md;
351
352         /* mi->buf_addr and mi->priv_size correspond to buffer and
353          * private size of the direct mbuf */
354         md = (struct rte_mbuf *)((char *)mi->buf_addr - sizeof(*mi) -
355                 mi->priv_size);
356         return md;
357 }
358
359 /**
360  * Return the buffer address embedded in the given mbuf.
361  *
362  * @param md
363  *   The pointer to the mbuf.
364  * @return
365  *   The address of the data buffer owned by the mbuf.
366  */
367 static inline char *
368 rte_mbuf_to_baddr(struct rte_mbuf *md)
369 {
370         char *buffer_addr;
371         buffer_addr = (char *)md + sizeof(*md) + rte_pktmbuf_priv_size(md->pool);
372         return buffer_addr;
373 }
374
375 /**
376  * Returns TRUE if given mbuf is indirect, or FALSE otherwise.
377  */
378 #define RTE_MBUF_INDIRECT(mb)   ((mb)->ol_flags & IND_ATTACHED_MBUF)
379
380 /**
381  * Returns TRUE if given mbuf is direct, or FALSE otherwise.
382  */
383 #define RTE_MBUF_DIRECT(mb)     (!RTE_MBUF_INDIRECT(mb))
384
385 /**
386  * Private data in case of pktmbuf pool.
387  *
388  * A structure that contains some pktmbuf_pool-specific data that are
389  * appended after the mempool structure (in private data).
390  */
391 struct rte_pktmbuf_pool_private {
392         uint16_t mbuf_data_room_size; /**< Size of data space in each mbuf. */
393         uint16_t mbuf_priv_size;      /**< Size of private area in each mbuf. */
394 };
395
396 #ifdef RTE_LIBRTE_MBUF_DEBUG
397
398 /**  check mbuf type in debug mode */
399 #define __rte_mbuf_sanity_check(m, is_h) rte_mbuf_sanity_check(m, is_h)
400
401 /**  check mbuf type in debug mode if mbuf pointer is not null */
402 #define __rte_mbuf_sanity_check_raw(m, is_h)    do {       \
403         if ((m) != NULL)                                   \
404                 rte_mbuf_sanity_check(m, is_h);          \
405 } while (0)
406
407 /**  MBUF asserts in debug mode */
408 #define RTE_MBUF_ASSERT(exp)                                         \
409 if (!(exp)) {                                                        \
410         rte_panic("line%d\tassert \"" #exp "\" failed\n", __LINE__); \
411 }
412
413 #else /*  RTE_LIBRTE_MBUF_DEBUG */
414
415 /**  check mbuf type in debug mode */
416 #define __rte_mbuf_sanity_check(m, is_h) do { } while (0)
417
418 /**  check mbuf type in debug mode if mbuf pointer is not null */
419 #define __rte_mbuf_sanity_check_raw(m, is_h) do { } while (0)
420
421 /**  MBUF asserts in debug mode */
422 #define RTE_MBUF_ASSERT(exp)                do { } while (0)
423
424 #endif /*  RTE_LIBRTE_MBUF_DEBUG */
425
426 #ifdef RTE_MBUF_REFCNT_ATOMIC
427
428 /**
429  * Adds given value to an mbuf's refcnt and returns its new value.
430  * @param m
431  *   Mbuf to update
432  * @param value
433  *   Value to add/subtract
434  * @return
435  *   Updated value
436  */
437 static inline uint16_t
438 rte_mbuf_refcnt_update(struct rte_mbuf *m, int16_t value)
439 {
440         return (uint16_t)(rte_atomic16_add_return(&m->refcnt_atomic, value));
441 }
442
443 /**
444  * Reads the value of an mbuf's refcnt.
445  * @param m
446  *   Mbuf to read
447  * @return
448  *   Reference count number.
449  */
450 static inline uint16_t
451 rte_mbuf_refcnt_read(const struct rte_mbuf *m)
452 {
453         return (uint16_t)(rte_atomic16_read(&m->refcnt_atomic));
454 }
455
456 /**
457  * Sets an mbuf's refcnt to a defined value.
458  * @param m
459  *   Mbuf to update
460  * @param new_value
461  *   Value set
462  */
463 static inline void
464 rte_mbuf_refcnt_set(struct rte_mbuf *m, uint16_t new_value)
465 {
466         rte_atomic16_set(&m->refcnt_atomic, new_value);
467 }
468
469 #else /* ! RTE_MBUF_REFCNT_ATOMIC */
470
471 /**
472  * Adds given value to an mbuf's refcnt and returns its new value.
473  */
474 static inline uint16_t
475 rte_mbuf_refcnt_update(struct rte_mbuf *m, int16_t value)
476 {
477         m->refcnt = (uint16_t)(m->refcnt + value);
478         return m->refcnt;
479 }
480
481 /**
482  * Reads the value of an mbuf's refcnt.
483  */
484 static inline uint16_t
485 rte_mbuf_refcnt_read(const struct rte_mbuf *m)
486 {
487         return m->refcnt;
488 }
489
490 /**
491  * Sets an mbuf's refcnt to the defined value.
492  */
493 static inline void
494 rte_mbuf_refcnt_set(struct rte_mbuf *m, uint16_t new_value)
495 {
496         m->refcnt = new_value;
497 }
498
499 #endif /* RTE_MBUF_REFCNT_ATOMIC */
500
501 /** Mbuf prefetch */
502 #define RTE_MBUF_PREFETCH_TO_FREE(m) do {       \
503         if ((m) != NULL)                        \
504                 rte_prefetch0(m);               \
505 } while (0)
506
507
508 /**
509  * Sanity checks on an mbuf.
510  *
511  * Check the consistency of the given mbuf. The function will cause a
512  * panic if corruption is detected.
513  *
514  * @param m
515  *   The mbuf to be checked.
516  * @param is_header
517  *   True if the mbuf is a packet header, false if it is a sub-segment
518  *   of a packet (in this case, some fields like nb_segs are not checked)
519  */
520 void
521 rte_mbuf_sanity_check(const struct rte_mbuf *m, int is_header);
522
523 /**
524  * @internal Allocate a new mbuf from mempool *mp*.
525  * The use of that function is reserved for RTE internal needs.
526  * Please use rte_pktmbuf_alloc().
527  *
528  * @param mp
529  *   The mempool from which mbuf is allocated.
530  * @return
531  *   - The pointer to the new mbuf on success.
532  *   - NULL if allocation failed.
533  */
534 static inline struct rte_mbuf *__rte_mbuf_raw_alloc(struct rte_mempool *mp)
535 {
536         struct rte_mbuf *m;
537         void *mb = NULL;
538         if (rte_mempool_get(mp, &mb) < 0)
539                 return NULL;
540         m = (struct rte_mbuf *)mb;
541         RTE_MBUF_ASSERT(rte_mbuf_refcnt_read(m) == 0);
542         rte_mbuf_refcnt_set(m, 1);
543         return (m);
544 }
545
546 /**
547  * @internal Put mbuf back into its original mempool.
548  * The use of that function is reserved for RTE internal needs.
549  * Please use rte_pktmbuf_free().
550  *
551  * @param m
552  *   The mbuf to be freed.
553  */
554 static inline void __attribute__((always_inline))
555 __rte_mbuf_raw_free(struct rte_mbuf *m)
556 {
557         RTE_MBUF_ASSERT(rte_mbuf_refcnt_read(m) == 0);
558         rte_mempool_put(m->pool, m);
559 }
560
561 /* Operations on ctrl mbuf */
562
563 /**
564  * The control mbuf constructor.
565  *
566  * This function initializes some fields in an mbuf structure that are
567  * not modified by the user once created (mbuf type, origin pool, buffer
568  * start address, and so on). This function is given as a callback function
569  * to rte_mempool_create() at pool creation time.
570  *
571  * @param mp
572  *   The mempool from which the mbuf is allocated.
573  * @param opaque_arg
574  *   A pointer that can be used by the user to retrieve useful information
575  *   for mbuf initialization. This pointer comes from the ``init_arg``
576  *   parameter of rte_mempool_create().
577  * @param m
578  *   The mbuf to initialize.
579  * @param i
580  *   The index of the mbuf in the pool table.
581  */
582 void rte_ctrlmbuf_init(struct rte_mempool *mp, void *opaque_arg,
583                 void *m, unsigned i);
584
585 /**
586  * Allocate a new mbuf (type is ctrl) from mempool *mp*.
587  *
588  * This new mbuf is initialized with data pointing to the beginning of
589  * buffer, and with a length of zero.
590  *
591  * @param mp
592  *   The mempool from which the mbuf is allocated.
593  * @return
594  *   - The pointer to the new mbuf on success.
595  *   - NULL if allocation failed.
596  */
597 #define rte_ctrlmbuf_alloc(mp) rte_pktmbuf_alloc(mp)
598
599 /**
600  * Free a control mbuf back into its original mempool.
601  *
602  * @param m
603  *   The control mbuf to be freed.
604  */
605 #define rte_ctrlmbuf_free(m) rte_pktmbuf_free(m)
606
607 /**
608  * A macro that returns the pointer to the carried data.
609  *
610  * The value that can be read or assigned.
611  *
612  * @param m
613  *   The control mbuf.
614  */
615 #define rte_ctrlmbuf_data(m) ((char *)((m)->buf_addr) + (m)->data_off)
616
617 /**
618  * A macro that returns the length of the carried data.
619  *
620  * The value that can be read or assigned.
621  *
622  * @param m
623  *   The control mbuf.
624  */
625 #define rte_ctrlmbuf_len(m) rte_pktmbuf_data_len(m)
626
627 /**
628  * Tests if an mbuf is a control mbuf
629  *
630  * @param m
631  *   The mbuf to be tested
632  * @return
633  *   - True (1) if the mbuf is a control mbuf
634  *   - False(0) otherwise
635  */
636 static inline int
637 rte_is_ctrlmbuf(struct rte_mbuf *m)
638 {
639         return (!!(m->ol_flags & CTRL_MBUF_FLAG));
640 }
641
642 /* Operations on pkt mbuf */
643
644 /**
645  * The packet mbuf constructor.
646  *
647  * This function initializes some fields in the mbuf structure that are
648  * not modified by the user once created (origin pool, buffer start
649  * address, and so on). This function is given as a callback function to
650  * rte_mempool_create() at pool creation time.
651  *
652  * @param mp
653  *   The mempool from which mbufs originate.
654  * @param opaque_arg
655  *   A pointer that can be used by the user to retrieve useful information
656  *   for mbuf initialization. This pointer comes from the ``init_arg``
657  *   parameter of rte_mempool_create().
658  * @param m
659  *   The mbuf to initialize.
660  * @param i
661  *   The index of the mbuf in the pool table.
662  */
663 void rte_pktmbuf_init(struct rte_mempool *mp, void *opaque_arg,
664                       void *m, unsigned i);
665
666
667 /**
668  * A  packet mbuf pool constructor.
669  *
670  * This function initializes the mempool private data in the case of a
671  * pktmbuf pool. This private data is needed by the driver. The
672  * function is given as a callback function to rte_mempool_create() at
673  * pool creation. It can be extended by the user, for example, to
674  * provide another packet size.
675  *
676  * @param mp
677  *   The mempool from which mbufs originate.
678  * @param opaque_arg
679  *   A pointer that can be used by the user to retrieve useful information
680  *   for mbuf initialization. This pointer comes from the ``init_arg``
681  *   parameter of rte_mempool_create().
682  */
683 void rte_pktmbuf_pool_init(struct rte_mempool *mp, void *opaque_arg);
684
685 /**
686  * Create a mbuf pool.
687  *
688  * This function creates and initializes a packet mbuf pool. It is
689  * a wrapper to rte_mempool_create() with the proper packet constructor
690  * and mempool constructor.
691  *
692  * @param name
693  *   The name of the mbuf pool.
694  * @param n
695  *   The number of elements in the mbuf pool. The optimum size (in terms
696  *   of memory usage) for a mempool is when n is a power of two minus one:
697  *   n = (2^q - 1).
698  * @param cache_size
699  *   Size of the per-core object cache. See rte_mempool_create() for
700  *   details.
701  * @param priv_size
702  *   Size of application private are between the rte_mbuf structure
703  *   and the data buffer.
704  * @param data_room_size
705  *   Size of data buffer in each mbuf, including RTE_PKTMBUF_HEADROOM.
706  * @param socket_id
707  *   The socket identifier where the memory should be allocated. The
708  *   value can be *SOCKET_ID_ANY* if there is no NUMA constraint for the
709  *   reserved zone.
710  * @return
711  *   The pointer to the new allocated mempool, on success. NULL on error
712  *   with rte_errno set appropriately. Possible rte_errno values include:
713  *    - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
714  *    - E_RTE_SECONDARY - function was called from a secondary process instance
715  *    - EINVAL - cache size provided is too large
716  *    - ENOSPC - the maximum number of memzones has already been allocated
717  *    - EEXIST - a memzone with the same name already exists
718  *    - ENOMEM - no appropriate memory area found in which to create memzone
719  */
720 struct rte_mempool *
721 rte_pktmbuf_pool_create(const char *name, unsigned n,
722         unsigned cache_size, uint16_t priv_size, uint16_t data_room_size,
723         int socket_id);
724
725 /**
726  * Get the data room size of mbufs stored in a pktmbuf_pool
727  *
728  * The data room size is the amount of data that can be stored in a
729  * mbuf including the headroom (RTE_PKTMBUF_HEADROOM).
730  *
731  * @param mp
732  *   The packet mbuf pool.
733  * @return
734  *   The data room size of mbufs stored in this mempool.
735  */
736 static inline uint16_t
737 rte_pktmbuf_data_room_size(struct rte_mempool *mp)
738 {
739         struct rte_pktmbuf_pool_private *mbp_priv;
740
741         mbp_priv = (struct rte_pktmbuf_pool_private *)rte_mempool_get_priv(mp);
742         return mbp_priv->mbuf_data_room_size;
743 }
744
745 /**
746  * Get the application private size of mbufs stored in a pktmbuf_pool
747  *
748  * The private size of mbuf is a zone located between the rte_mbuf
749  * structure and the data buffer where an application can store data
750  * associated to a packet.
751  *
752  * @param mp
753  *   The packet mbuf pool.
754  * @return
755  *   The private size of mbufs stored in this mempool.
756  */
757 static inline uint16_t
758 rte_pktmbuf_priv_size(struct rte_mempool *mp)
759 {
760         struct rte_pktmbuf_pool_private *mbp_priv;
761
762         mbp_priv = (struct rte_pktmbuf_pool_private *)rte_mempool_get_priv(mp);
763         return mbp_priv->mbuf_priv_size;
764 }
765
766 /**
767  * Reset the fields of a packet mbuf to their default values.
768  *
769  * The given mbuf must have only one segment.
770  *
771  * @param m
772  *   The packet mbuf to be resetted.
773  */
774 static inline void rte_pktmbuf_reset(struct rte_mbuf *m)
775 {
776         m->next = NULL;
777         m->pkt_len = 0;
778         m->tx_offload = 0;
779         m->vlan_tci = 0;
780         m->nb_segs = 1;
781         m->port = 0xff;
782
783         m->ol_flags = 0;
784         m->packet_type = 0;
785         m->data_off = (RTE_PKTMBUF_HEADROOM <= m->buf_len) ?
786                         RTE_PKTMBUF_HEADROOM : m->buf_len;
787
788         m->data_len = 0;
789         __rte_mbuf_sanity_check(m, 1);
790 }
791
792 /**
793  * Allocate a new mbuf from a mempool.
794  *
795  * This new mbuf contains one segment, which has a length of 0. The pointer
796  * to data is initialized to have some bytes of headroom in the buffer
797  * (if buffer size allows).
798  *
799  * @param mp
800  *   The mempool from which the mbuf is allocated.
801  * @return
802  *   - The pointer to the new mbuf on success.
803  *   - NULL if allocation failed.
804  */
805 static inline struct rte_mbuf *rte_pktmbuf_alloc(struct rte_mempool *mp)
806 {
807         struct rte_mbuf *m;
808         if ((m = __rte_mbuf_raw_alloc(mp)) != NULL)
809                 rte_pktmbuf_reset(m);
810         return (m);
811 }
812
813 /**
814  * Attach packet mbuf to another packet mbuf.
815  *
816  * After attachment we refer the mbuf we attached as 'indirect',
817  * while mbuf we attached to as 'direct'.
818  * Right now, not supported:
819  *  - attachment for already indirect mbuf (e.g. - mi has to be direct).
820  *  - mbuf we trying to attach (mi) is used by someone else
821  *    e.g. it's reference counter is greater then 1.
822  *
823  * @param mi
824  *   The indirect packet mbuf.
825  * @param m
826  *   The packet mbuf we're attaching to.
827  */
828 static inline void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *m)
829 {
830         struct rte_mbuf *md;
831
832         RTE_MBUF_ASSERT(RTE_MBUF_DIRECT(mi) &&
833             rte_mbuf_refcnt_read(mi) == 1);
834
835         /* if m is not direct, get the mbuf that embeds the data */
836         if (RTE_MBUF_DIRECT(m))
837                 md = m;
838         else
839                 md = rte_mbuf_from_indirect(m);
840
841         rte_mbuf_refcnt_update(md, 1);
842         mi->priv_size = m->priv_size;
843         mi->buf_physaddr = m->buf_physaddr;
844         mi->buf_addr = m->buf_addr;
845         mi->buf_len = m->buf_len;
846
847         mi->next = m->next;
848         mi->data_off = m->data_off;
849         mi->data_len = m->data_len;
850         mi->port = m->port;
851         mi->vlan_tci = m->vlan_tci;
852         mi->tx_offload = m->tx_offload;
853         mi->hash = m->hash;
854
855         mi->next = NULL;
856         mi->pkt_len = mi->data_len;
857         mi->nb_segs = 1;
858         mi->ol_flags = m->ol_flags | IND_ATTACHED_MBUF;
859         mi->packet_type = m->packet_type;
860
861         __rte_mbuf_sanity_check(mi, 1);
862         __rte_mbuf_sanity_check(m, 0);
863 }
864
865 /**
866  * Detach an indirect packet mbuf.
867  *
868  *  - restore original mbuf address and length values.
869  *  - reset pktmbuf data and data_len to their default values.
870  *  All other fields of the given packet mbuf will be left intact.
871  *
872  * @param m
873  *   The indirect attached packet mbuf.
874  */
875 static inline void rte_pktmbuf_detach(struct rte_mbuf *m)
876 {
877         struct rte_mempool *mp = m->pool;
878         uint32_t mbuf_size, buf_len, priv_size;
879
880         priv_size = rte_pktmbuf_priv_size(mp);
881         mbuf_size = sizeof(struct rte_mbuf) + priv_size;
882         buf_len = rte_pktmbuf_data_room_size(mp);
883
884         m->priv_size = priv_size;
885         m->buf_addr = (char *)m + mbuf_size;
886         m->buf_physaddr = rte_mempool_virt2phy(mp, m) + mbuf_size;
887         m->buf_len = (uint16_t)buf_len;
888         m->data_off = RTE_MIN(RTE_PKTMBUF_HEADROOM, (uint16_t)m->buf_len);
889         m->data_len = 0;
890         m->ol_flags = 0;
891 }
892
893 static inline struct rte_mbuf* __attribute__((always_inline))
894 __rte_pktmbuf_prefree_seg(struct rte_mbuf *m)
895 {
896         __rte_mbuf_sanity_check(m, 0);
897
898         /*
899          * Check to see if this is the last reference to the mbuf.
900          * Note: the double check here is deliberate. If the ref_cnt is "atomic"
901          * the call to "refcnt_update" is a very expensive operation, so we
902          * don't want to call it in the case where we know we are the holder
903          * of the last reference to this mbuf i.e. ref_cnt == 1.
904          * If however, ref_cnt != 1, it's still possible that we may still be
905          * the final decrementer of the count, so we need to check that
906          * result also, to make sure the mbuf is freed properly.
907          */
908         if (likely (rte_mbuf_refcnt_read(m) == 1) ||
909                         likely (rte_mbuf_refcnt_update(m, -1) == 0)) {
910
911                 rte_mbuf_refcnt_set(m, 0);
912
913                 /* if this is an indirect mbuf, then
914                  *  - detach mbuf
915                  *  - free attached mbuf segment
916                  */
917                 if (RTE_MBUF_INDIRECT(m)) {
918                         struct rte_mbuf *md = rte_mbuf_from_indirect(m);
919                         rte_pktmbuf_detach(m);
920                         if (rte_mbuf_refcnt_update(md, -1) == 0)
921                                 __rte_mbuf_raw_free(md);
922                 }
923                 return(m);
924         }
925         return (NULL);
926 }
927
928 /**
929  * Free a segment of a packet mbuf into its original mempool.
930  *
931  * Free an mbuf, without parsing other segments in case of chained
932  * buffers.
933  *
934  * @param m
935  *   The packet mbuf segment to be freed.
936  */
937 static inline void __attribute__((always_inline))
938 rte_pktmbuf_free_seg(struct rte_mbuf *m)
939 {
940         if (likely(NULL != (m = __rte_pktmbuf_prefree_seg(m)))) {
941                 m->next = NULL;
942                 __rte_mbuf_raw_free(m);
943         }
944 }
945
946 /**
947  * Free a packet mbuf back into its original mempool.
948  *
949  * Free an mbuf, and all its segments in case of chained buffers. Each
950  * segment is added back into its original mempool.
951  *
952  * @param m
953  *   The packet mbuf to be freed.
954  */
955 static inline void rte_pktmbuf_free(struct rte_mbuf *m)
956 {
957         struct rte_mbuf *m_next;
958
959         __rte_mbuf_sanity_check(m, 1);
960
961         while (m != NULL) {
962                 m_next = m->next;
963                 rte_pktmbuf_free_seg(m);
964                 m = m_next;
965         }
966 }
967
968 /**
969  * Creates a "clone" of the given packet mbuf.
970  *
971  * Walks through all segments of the given packet mbuf, and for each of them:
972  *  - Creates a new packet mbuf from the given pool.
973  *  - Attaches newly created mbuf to the segment.
974  * Then updates pkt_len and nb_segs of the "clone" packet mbuf to match values
975  * from the original packet mbuf.
976  *
977  * @param md
978  *   The packet mbuf to be cloned.
979  * @param mp
980  *   The mempool from which the "clone" mbufs are allocated.
981  * @return
982  *   - The pointer to the new "clone" mbuf on success.
983  *   - NULL if allocation fails.
984  */
985 static inline struct rte_mbuf *rte_pktmbuf_clone(struct rte_mbuf *md,
986                 struct rte_mempool *mp)
987 {
988         struct rte_mbuf *mc, *mi, **prev;
989         uint32_t pktlen;
990         uint8_t nseg;
991
992         if (unlikely ((mc = rte_pktmbuf_alloc(mp)) == NULL))
993                 return (NULL);
994
995         mi = mc;
996         prev = &mi->next;
997         pktlen = md->pkt_len;
998         nseg = 0;
999
1000         do {
1001                 nseg++;
1002                 rte_pktmbuf_attach(mi, md);
1003                 *prev = mi;
1004                 prev = &mi->next;
1005         } while ((md = md->next) != NULL &&
1006             (mi = rte_pktmbuf_alloc(mp)) != NULL);
1007
1008         *prev = NULL;
1009         mc->nb_segs = nseg;
1010         mc->pkt_len = pktlen;
1011
1012         /* Allocation of new indirect segment failed */
1013         if (unlikely (mi == NULL)) {
1014                 rte_pktmbuf_free(mc);
1015                 return (NULL);
1016         }
1017
1018         __rte_mbuf_sanity_check(mc, 1);
1019         return (mc);
1020 }
1021
1022 /**
1023  * Adds given value to the refcnt of all packet mbuf segments.
1024  *
1025  * Walks through all segments of given packet mbuf and for each of them
1026  * invokes rte_mbuf_refcnt_update().
1027  *
1028  * @param m
1029  *   The packet mbuf whose refcnt to be updated.
1030  * @param v
1031  *   The value to add to the mbuf's segments refcnt.
1032  */
1033 static inline void rte_pktmbuf_refcnt_update(struct rte_mbuf *m, int16_t v)
1034 {
1035         __rte_mbuf_sanity_check(m, 1);
1036
1037         do {
1038                 rte_mbuf_refcnt_update(m, v);
1039         } while ((m = m->next) != NULL);
1040 }
1041
1042 /**
1043  * Get the headroom in a packet mbuf.
1044  *
1045  * @param m
1046  *   The packet mbuf.
1047  * @return
1048  *   The length of the headroom.
1049  */
1050 static inline uint16_t rte_pktmbuf_headroom(const struct rte_mbuf *m)
1051 {
1052         __rte_mbuf_sanity_check(m, 1);
1053         return m->data_off;
1054 }
1055
1056 /**
1057  * Get the tailroom of a packet mbuf.
1058  *
1059  * @param m
1060  *   The packet mbuf.
1061  * @return
1062  *   The length of the tailroom.
1063  */
1064 static inline uint16_t rte_pktmbuf_tailroom(const struct rte_mbuf *m)
1065 {
1066         __rte_mbuf_sanity_check(m, 1);
1067         return (uint16_t)(m->buf_len - rte_pktmbuf_headroom(m) -
1068                           m->data_len);
1069 }
1070
1071 /**
1072  * Get the last segment of the packet.
1073  *
1074  * @param m
1075  *   The packet mbuf.
1076  * @return
1077  *   The last segment of the given mbuf.
1078  */
1079 static inline struct rte_mbuf *rte_pktmbuf_lastseg(struct rte_mbuf *m)
1080 {
1081         struct rte_mbuf *m2 = (struct rte_mbuf *)m;
1082
1083         __rte_mbuf_sanity_check(m, 1);
1084         while (m2->next != NULL)
1085                 m2 = m2->next;
1086         return m2;
1087 }
1088
1089 /**
1090  * A macro that points to the start of the data in the mbuf.
1091  *
1092  * The returned pointer is cast to type t. Before using this
1093  * function, the user must ensure that m_headlen(m) is large enough to
1094  * read its data.
1095  *
1096  * @param m
1097  *   The packet mbuf.
1098  * @param t
1099  *   The type to cast the result into.
1100  */
1101 #define rte_pktmbuf_mtod(m, t) ((t)((char *)(m)->buf_addr + (m)->data_off))
1102
1103 /**
1104  * A macro that returns the length of the packet.
1105  *
1106  * The value can be read or assigned.
1107  *
1108  * @param m
1109  *   The packet mbuf.
1110  */
1111 #define rte_pktmbuf_pkt_len(m) ((m)->pkt_len)
1112
1113 /**
1114  * A macro that returns the length of the segment.
1115  *
1116  * The value can be read or assigned.
1117  *
1118  * @param m
1119  *   The packet mbuf.
1120  */
1121 #define rte_pktmbuf_data_len(m) ((m)->data_len)
1122
1123 /**
1124  * Prepend len bytes to an mbuf data area.
1125  *
1126  * Returns a pointer to the new
1127  * data start address. If there is not enough headroom in the first
1128  * segment, the function will return NULL, without modifying the mbuf.
1129  *
1130  * @param m
1131  *   The pkt mbuf.
1132  * @param len
1133  *   The amount of data to prepend (in bytes).
1134  * @return
1135  *   A pointer to the start of the newly prepended data, or
1136  *   NULL if there is not enough headroom space in the first segment
1137  */
1138 static inline char *rte_pktmbuf_prepend(struct rte_mbuf *m,
1139                                         uint16_t len)
1140 {
1141         __rte_mbuf_sanity_check(m, 1);
1142
1143         if (unlikely(len > rte_pktmbuf_headroom(m)))
1144                 return NULL;
1145
1146         m->data_off -= len;
1147         m->data_len = (uint16_t)(m->data_len + len);
1148         m->pkt_len  = (m->pkt_len + len);
1149
1150         return (char *)m->buf_addr + m->data_off;
1151 }
1152
1153 /**
1154  * Append len bytes to an mbuf.
1155  *
1156  * Append len bytes to an mbuf and return a pointer to the start address
1157  * of the added data. If there is not enough tailroom in the last
1158  * segment, the function will return NULL, without modifying the mbuf.
1159  *
1160  * @param m
1161  *   The packet mbuf.
1162  * @param len
1163  *   The amount of data to append (in bytes).
1164  * @return
1165  *   A pointer to the start of the newly appended data, or
1166  *   NULL if there is not enough tailroom space in the last segment
1167  */
1168 static inline char *rte_pktmbuf_append(struct rte_mbuf *m, uint16_t len)
1169 {
1170         void *tail;
1171         struct rte_mbuf *m_last;
1172
1173         __rte_mbuf_sanity_check(m, 1);
1174
1175         m_last = rte_pktmbuf_lastseg(m);
1176         if (unlikely(len > rte_pktmbuf_tailroom(m_last)))
1177                 return NULL;
1178
1179         tail = (char *)m_last->buf_addr + m_last->data_off + m_last->data_len;
1180         m_last->data_len = (uint16_t)(m_last->data_len + len);
1181         m->pkt_len  = (m->pkt_len + len);
1182         return (char*) tail;
1183 }
1184
1185 /**
1186  * Remove len bytes at the beginning of an mbuf.
1187  *
1188  * Returns a pointer to the start address of the new data area. If the
1189  * length is greater than the length of the first segment, then the
1190  * function will fail and return NULL, without modifying the mbuf.
1191  *
1192  * @param m
1193  *   The packet mbuf.
1194  * @param len
1195  *   The amount of data to remove (in bytes).
1196  * @return
1197  *   A pointer to the new start of the data.
1198  */
1199 static inline char *rte_pktmbuf_adj(struct rte_mbuf *m, uint16_t len)
1200 {
1201         __rte_mbuf_sanity_check(m, 1);
1202
1203         if (unlikely(len > m->data_len))
1204                 return NULL;
1205
1206         m->data_len = (uint16_t)(m->data_len - len);
1207         m->data_off += len;
1208         m->pkt_len  = (m->pkt_len - len);
1209         return (char *)m->buf_addr + m->data_off;
1210 }
1211
1212 /**
1213  * Remove len bytes of data at the end of the mbuf.
1214  *
1215  * If the length is greater than the length of the last segment, the
1216  * function will fail and return -1 without modifying the mbuf.
1217  *
1218  * @param m
1219  *   The packet mbuf.
1220  * @param len
1221  *   The amount of data to remove (in bytes).
1222  * @return
1223  *   - 0: On success.
1224  *   - -1: On error.
1225  */
1226 static inline int rte_pktmbuf_trim(struct rte_mbuf *m, uint16_t len)
1227 {
1228         struct rte_mbuf *m_last;
1229
1230         __rte_mbuf_sanity_check(m, 1);
1231
1232         m_last = rte_pktmbuf_lastseg(m);
1233         if (unlikely(len > m_last->data_len))
1234                 return -1;
1235
1236         m_last->data_len = (uint16_t)(m_last->data_len - len);
1237         m->pkt_len  = (m->pkt_len - len);
1238         return 0;
1239 }
1240
1241 /**
1242  * Test if mbuf data is contiguous.
1243  *
1244  * @param m
1245  *   The packet mbuf.
1246  * @return
1247  *   - 1, if all data is contiguous (one segment).
1248  *   - 0, if there is several segments.
1249  */
1250 static inline int rte_pktmbuf_is_contiguous(const struct rte_mbuf *m)
1251 {
1252         __rte_mbuf_sanity_check(m, 1);
1253         return !!(m->nb_segs == 1);
1254 }
1255
1256 /**
1257  * Dump an mbuf structure to the console.
1258  *
1259  * Dump all fields for the given packet mbuf and all its associated
1260  * segments (in the case of a chained buffer).
1261  *
1262  * @param f
1263  *   A pointer to a file for output
1264  * @param m
1265  *   The packet mbuf.
1266  * @param dump_len
1267  *   If dump_len != 0, also dump the "dump_len" first data bytes of
1268  *   the packet.
1269  */
1270 void rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len);
1271
1272 #ifdef __cplusplus
1273 }
1274 #endif
1275
1276 #endif /* _RTE_MBUF_H_ */