lib/librte_mbuf/rte_mbuf.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright 2014 6WIND S.A.
   4  */
   5
   6 #include <string.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <stdint.h>
  10 #include <stdarg.h>
  11 #include <inttypes.h>
  12 #include <errno.h>
  13 #include <ctype.h>
  14 #include <sys/queue.h>
  15
  16 #include <rte_compat.h>
  17 #include <rte_debug.h>
  18 #include <rte_common.h>
  19 #include <rte_log.h>
  20 #include <rte_memory.h>
  21 #include <rte_launch.h>
  22 #include <rte_eal.h>
  23 #include <rte_per_lcore.h>
  24 #include <rte_lcore.h>
  25 #include <rte_atomic.h>
  26 #include <rte_branch_prediction.h>
  27 #include <rte_mempool.h>
  28 #include <rte_mbuf.h>
  29 #include <rte_mbuf_pool_ops.h>
  30 #include <rte_string_fns.h>
  31 #include <rte_hexdump.h>
  32 #include <rte_errno.h>
  33 #include <rte_memcpy.h>
  34
  35 /*
  36  * pktmbuf pool constructor, given as a callback function to
  37  * rte_mempool_create(), or called directly if using
  38  * rte_mempool_create_empty()/rte_mempool_populate()
  39  */
  40 void
  41 rte_pktmbuf_pool_init(struct rte_mempool *mp, void *opaque_arg)
  42 {
  43         struct rte_pktmbuf_pool_private *user_mbp_priv, *mbp_priv;
  44         struct rte_pktmbuf_pool_private default_mbp_priv;
  45         uint16_t roomsz;
  46
  47         RTE_ASSERT(mp->elt_size >= sizeof(struct rte_mbuf));
  48
  49         /* if no structure is provided, assume no mbuf private area */
  50         user_mbp_priv = opaque_arg;
  51         if (user_mbp_priv == NULL) {
  52                 memset(&default_mbp_priv, 0, sizeof(default_mbp_priv));
  53                 if (mp->elt_size > sizeof(struct rte_mbuf))
  54                         roomsz = mp->elt_size - sizeof(struct rte_mbuf);
  55                 else
  56                         roomsz = 0;
  57                 default_mbp_priv.mbuf_data_room_size = roomsz;
  58                 user_mbp_priv = &default_mbp_priv;
  59         }
  60
  61         RTE_ASSERT(mp->elt_size >= sizeof(struct rte_mbuf) +
  62                 user_mbp_priv->mbuf_data_room_size +
  63                 user_mbp_priv->mbuf_priv_size);
  64         RTE_ASSERT(user_mbp_priv->flags == 0);
  65
  66         mbp_priv = rte_mempool_get_priv(mp);
  67         memcpy(mbp_priv, user_mbp_priv, sizeof(*mbp_priv));
  68 }
  69
  70 /*
  71  * pktmbuf constructor, given as a callback function to
  72  * rte_mempool_obj_iter() or rte_mempool_create().
  73  * Set the fields of a packet mbuf to their default values.
  74  */
  75 void
  76 rte_pktmbuf_init(struct rte_mempool *mp,
  77                  __attribute__((unused)) void *opaque_arg,
  78                  void *_m,
  79                  __attribute__((unused)) unsigned i)
  80 {
  81         struct rte_mbuf *m = _m;
  82         uint32_t mbuf_size, buf_len, priv_size;
  83
  84         priv_size = rte_pktmbuf_priv_size(mp);
  85         mbuf_size = sizeof(struct rte_mbuf) + priv_size;
  86         buf_len = rte_pktmbuf_data_room_size(mp);
  87
  88         RTE_ASSERT(RTE_ALIGN(priv_size, RTE_MBUF_PRIV_ALIGN) == priv_size);
  89         RTE_ASSERT(mp->elt_size >= mbuf_size);
  90         RTE_ASSERT(buf_len <= UINT16_MAX);
  91
  92         memset(m, 0, mbuf_size);
  93         /* start of buffer is after mbuf structure and priv data */
  94         m->priv_size = priv_size;
  95         m->buf_addr = (char *)m + mbuf_size;
  96         m->buf_iova = rte_mempool_virt2iova(m) + mbuf_size;
  97         m->buf_len = (uint16_t)buf_len;
  98
  99         /* keep some headroom between start of buffer and data */
 100         m->data_off = RTE_MIN(RTE_PKTMBUF_HEADROOM, (uint16_t)m->buf_len);
 101
 102         /* init some constant fields */
 103         m->pool = mp;
 104         m->nb_segs = 1;
 105         m->port = MBUF_INVALID_PORT;
 106         rte_mbuf_refcnt_set(m, 1);
 107         m->next = NULL;
 108 }
 109
 110 /* Helper to create a mbuf pool with given mempool ops name*/
 111 struct rte_mempool *
 112 rte_pktmbuf_pool_create_by_ops(const char *name, unsigned int n,
 113         unsigned int cache_size, uint16_t priv_size, uint16_t data_room_size,
 114         int socket_id, const char *ops_name)
 115 {
 116         struct rte_mempool *mp;
 117         struct rte_pktmbuf_pool_private mbp_priv;
 118         const char *mp_ops_name = ops_name;
 119         unsigned elt_size;
 120         int ret;
 121
 122         if (RTE_ALIGN(priv_size, RTE_MBUF_PRIV_ALIGN) != priv_size) {
 123                 RTE_LOG(ERR, MBUF, "mbuf priv_size=%u is not aligned\n",
 124                         priv_size);
 125                 rte_errno = EINVAL;
 126                 return NULL;
 127         }
 128         elt_size = sizeof(struct rte_mbuf) + (unsigned)priv_size +
 129                 (unsigned)data_room_size;
 130         memset(&mbp_priv, 0, sizeof(mbp_priv));
 131         mbp_priv.mbuf_data_room_size = data_room_size;
 132         mbp_priv.mbuf_priv_size = priv_size;
 133
 134         mp = rte_mempool_create_empty(name, n, elt_size, cache_size,
 135                  sizeof(struct rte_pktmbuf_pool_private), socket_id, 0);
 136         if (mp == NULL)
 137                 return NULL;
 138
 139         if (mp_ops_name == NULL)
 140                 mp_ops_name = rte_mbuf_best_mempool_ops();
 141         ret = rte_mempool_set_ops_byname(mp, mp_ops_name, NULL);
 142         if (ret != 0) {
 143                 RTE_LOG(ERR, MBUF, "error setting mempool handler\n");
 144                 rte_mempool_free(mp);
 145                 rte_errno = -ret;
 146                 return NULL;
 147         }
 148         rte_pktmbuf_pool_init(mp, &mbp_priv);
 149
 150         ret = rte_mempool_populate_default(mp);
 151         if (ret < 0) {
 152                 rte_mempool_free(mp);
 153                 rte_errno = -ret;
 154                 return NULL;
 155         }
 156
 157         rte_mempool_obj_iter(mp, rte_pktmbuf_init, NULL);
 158
 159         return mp;
 160 }
 161
 162 /* helper to create a mbuf pool */
 163 struct rte_mempool *
 164 rte_pktmbuf_pool_create(const char *name, unsigned int n,
 165         unsigned int cache_size, uint16_t priv_size, uint16_t data_room_size,
 166         int socket_id)
 167 {
 168         return rte_pktmbuf_pool_create_by_ops(name, n, cache_size, priv_size,
 169                         data_room_size, socket_id, NULL);
 170 }
 171
 172 /* do some sanity checks on a mbuf: panic if it fails */
 173 void
 174 rte_mbuf_sanity_check(const struct rte_mbuf *m, int is_header)
 175 {
 176         const char *reason;
 177
 178         if (rte_mbuf_check(m, is_header, &reason))
 179                 rte_panic("%s\n", reason);
 180 }
 181
 182 int rte_mbuf_check(const struct rte_mbuf *m, int is_header,
 183                    const char **reason)
 184 {
 185         unsigned int nb_segs, pkt_len;
 186
 187         if (m == NULL) {
 188                 *reason = "mbuf is NULL";
 189                 return -1;
 190         }
 191
 192         /* generic checks */
 193         if (m->pool == NULL) {
 194                 *reason = "bad mbuf pool";
 195                 return -1;
 196         }
 197         if (m->buf_iova == 0) {
 198                 *reason = "bad IO addr";
 199                 return -1;
 200         }
 201         if (m->buf_addr == NULL) {
 202                 *reason = "bad virt addr";
 203                 return -1;
 204         }
 205
 206         uint16_t cnt = rte_mbuf_refcnt_read(m);
 207         if ((cnt == 0) || (cnt == UINT16_MAX)) {
 208                 *reason = "bad ref cnt";
 209                 return -1;
 210         }
 211
 212         /* nothing to check for sub-segments */
 213         if (is_header == 0)
 214                 return 0;
 215
 216         /* data_len is supposed to be not more than pkt_len */
 217         if (m->data_len > m->pkt_len) {
 218                 *reason = "bad data_len";
 219                 return -1;
 220         }
 221
 222         nb_segs = m->nb_segs;
 223         pkt_len = m->pkt_len;
 224
 225         do {
 226                 if (m->data_off > m->buf_len) {
 227                         *reason = "data offset too big in mbuf segment";
 228                         return -1;
 229                 }
 230                 if (m->data_off + m->data_len > m->buf_len) {
 231                         *reason = "data length too big in mbuf segment";
 232                         return -1;
 233                 }
 234                 nb_segs -= 1;
 235                 pkt_len -= m->data_len;
 236         } while ((m = m->next) != NULL);
 237
 238         if (nb_segs) {
 239                 *reason = "bad nb_segs";
 240                 return -1;
 241         }
 242         if (pkt_len) {
 243                 *reason = "bad pkt_len";
 244                 return -1;
 245         }
 246
 247         return 0;
 248 }
 249
 250 /**
 251  * @internal helper function for freeing a bulk of packet mbuf segments
 252  * via an array holding the packet mbuf segments from the same mempool
 253  * pending to be freed.
 254  *
 255  * @param m
 256  *  The packet mbuf segment to be freed.
 257  * @param pending
 258  *  Pointer to the array of packet mbuf segments pending to be freed.
 259  * @param nb_pending
 260  *  Pointer to the number of elements held in the array.
 261  * @param pending_sz
 262  *  Number of elements the array can hold.
 263  *  Note: The compiler should optimize this parameter away when using a
 264  *  constant value, such as RTE_PKTMBUF_FREE_PENDING_SZ.
 265  */
 266 static void
 267 __rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,
 268         struct rte_mbuf ** const pending, unsigned int * const nb_pending,
 269         const unsigned int pending_sz)
 270 {
 271         m = rte_pktmbuf_prefree_seg(m);
 272         if (likely(m != NULL)) {
 273                 if (*nb_pending == pending_sz ||
 274                     (*nb_pending > 0 && m->pool != pending[0]->pool)) {
 275                         rte_mempool_put_bulk(pending[0]->pool,
 276                                         (void **)pending, *nb_pending);
 277                         *nb_pending = 0;
 278                 }
 279
 280                 pending[(*nb_pending)++] = m;
 281         }
 282 }
 283
 284 /**
 285  * Size of the array holding mbufs from the same mempool pending to be freed
 286  * in bulk.
 287  */
 288 #define RTE_PKTMBUF_FREE_PENDING_SZ 64
 289
 290 /* Free a bulk of packet mbufs back into their original mempools. */
 291 void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count)
 292 {
 293         struct rte_mbuf *m, *m_next, *pending[RTE_PKTMBUF_FREE_PENDING_SZ];
 294         unsigned int idx, nb_pending = 0;
 295
 296         for (idx = 0; idx < count; idx++) {
 297                 m = mbufs[idx];
 298                 if (unlikely(m == NULL))
 299                         continue;
 300
 301                 __rte_mbuf_sanity_check(m, 1);
 302
 303                 do {
 304                         m_next = m->next;
 305                         __rte_pktmbuf_free_seg_via_array(m,
 306                                         pending, &nb_pending,
 307                                         RTE_PKTMBUF_FREE_PENDING_SZ);
 308                         m = m_next;
 309                 } while (m != NULL);
 310         }
 311
 312         if (nb_pending > 0)
 313                 rte_mempool_put_bulk(pending[0]->pool, (void **)pending, nb_pending);
 314 }
 315
 316 /* Creates a shallow copy of mbuf */
 317 struct rte_mbuf *
 318 rte_pktmbuf_clone(struct rte_mbuf *md, struct rte_mempool *mp)
 319 {
 320         struct rte_mbuf *mc, *mi, **prev;
 321         uint32_t pktlen;
 322         uint16_t nseg;
 323
 324         mc = rte_pktmbuf_alloc(mp);
 325         if (unlikely(mc == NULL))
 326                 return NULL;
 327
 328         mi = mc;
 329         prev = &mi->next;
 330         pktlen = md->pkt_len;
 331         nseg = 0;
 332
 333         do {
 334                 nseg++;
 335                 rte_pktmbuf_attach(mi, md);
 336                 *prev = mi;
 337                 prev = &mi->next;
 338         } while ((md = md->next) != NULL &&
 339             (mi = rte_pktmbuf_alloc(mp)) != NULL);
 340
 341         *prev = NULL;
 342         mc->nb_segs = nseg;
 343         mc->pkt_len = pktlen;
 344
 345         /* Allocation of new indirect segment failed */
 346         if (unlikely(mi == NULL)) {
 347                 rte_pktmbuf_free(mc);
 348                 return NULL;
 349         }
 350
 351         __rte_mbuf_sanity_check(mc, 1);
 352         return mc;
 353 }
 354
 355 /* convert multi-segment mbuf to single mbuf */
 356 int
 357 __rte_pktmbuf_linearize(struct rte_mbuf *mbuf)
 358 {
 359         size_t seg_len, copy_len;
 360         struct rte_mbuf *m;
 361         struct rte_mbuf *m_next;
 362         char *buffer;
 363
 364         /* Extend first segment to the total packet length */
 365         copy_len = rte_pktmbuf_pkt_len(mbuf) - rte_pktmbuf_data_len(mbuf);
 366
 367         if (unlikely(copy_len > rte_pktmbuf_tailroom(mbuf)))
 368                 return -1;
 369
 370         buffer = rte_pktmbuf_mtod_offset(mbuf, char *, mbuf->data_len);
 371         mbuf->data_len = (uint16_t)(mbuf->pkt_len);
 372
 373         /* Append data from next segments to the first one */
 374         m = mbuf->next;
 375         while (m != NULL) {
 376                 m_next = m->next;
 377
 378                 seg_len = rte_pktmbuf_data_len(m);
 379                 rte_memcpy(buffer, rte_pktmbuf_mtod(m, char *), seg_len);
 380                 buffer += seg_len;
 381
 382                 rte_pktmbuf_free_seg(m);
 383                 m = m_next;
 384         }
 385
 386         mbuf->next = NULL;
 387         mbuf->nb_segs = 1;
 388
 389         return 0;
 390 }
 391
 392 /* Create a deep copy of mbuf */
 393 struct rte_mbuf *
 394 rte_pktmbuf_copy(const struct rte_mbuf *m, struct rte_mempool *mp,
 395                  uint32_t off, uint32_t len)
 396 {
 397         const struct rte_mbuf *seg = m;
 398         struct rte_mbuf *mc, *m_last, **prev;
 399
 400         /* garbage in check */
 401         __rte_mbuf_sanity_check(m, 1);
 402
 403         /* check for request to copy at offset past end of mbuf */
 404         if (unlikely(off >= m->pkt_len))
 405                 return NULL;
 406
 407         mc = rte_pktmbuf_alloc(mp);
 408         if (unlikely(mc == NULL))
 409                 return NULL;
 410
 411         /* truncate requested length to available data */
 412         if (len > m->pkt_len - off)
 413                 len = m->pkt_len - off;
 414
 415         __rte_pktmbuf_copy_hdr(mc, m);
 416
 417         /* copied mbuf is not indirect or external */
 418         mc->ol_flags = m->ol_flags & ~(IND_ATTACHED_MBUF|EXT_ATTACHED_MBUF);
 419
 420         prev = &mc->next;
 421         m_last = mc;
 422         while (len > 0) {
 423                 uint32_t copy_len;
 424
 425                 /* skip leading mbuf segments */
 426                 while (off >= seg->data_len) {
 427                         off -= seg->data_len;
 428                         seg = seg->next;
 429                 }
 430
 431                 /* current buffer is full, chain a new one */
 432                 if (rte_pktmbuf_tailroom(m_last) == 0) {
 433                         m_last = rte_pktmbuf_alloc(mp);
 434                         if (unlikely(m_last == NULL)) {
 435                                 rte_pktmbuf_free(mc);
 436                                 return NULL;
 437                         }
 438                         ++mc->nb_segs;
 439                         *prev = m_last;
 440                         prev = &m_last->next;
 441                 }
 442
 443                 /*
 444                  * copy the min of data in input segment (seg)
 445                  * vs space available in output (m_last)
 446                  */
 447                 copy_len = RTE_MIN(seg->data_len - off, len);
 448                 if (copy_len > rte_pktmbuf_tailroom(m_last))
 449                         copy_len = rte_pktmbuf_tailroom(m_last);
 450
 451                 /* append from seg to m_last */
 452                 rte_memcpy(rte_pktmbuf_mtod_offset(m_last, char *,
 453                                                    m_last->data_len),
 454                            rte_pktmbuf_mtod_offset(seg, char *, off),
 455                            copy_len);
 456
 457                 /* update offsets and lengths */
 458                 m_last->data_len += copy_len;
 459                 mc->pkt_len += copy_len;
 460                 off += copy_len;
 461                 len -= copy_len;
 462         }
 463
 464         /* garbage out check */
 465         __rte_mbuf_sanity_check(mc, 1);
 466         return mc;
 467 }
 468
 469 /* dump a mbuf on console */
 470 void
 471 rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len)
 472 {
 473         unsigned int len;
 474         unsigned int nb_segs;
 475
 476         __rte_mbuf_sanity_check(m, 1);
 477
 478         fprintf(f, "dump mbuf at %p, iova=%"PRIx64", buf_len=%u\n",
 479                m, (uint64_t)m->buf_iova, (unsigned)m->buf_len);
 480         fprintf(f, "  pkt_len=%"PRIu32", ol_flags=%"PRIx64", nb_segs=%u, "
 481                "in_port=%u\n", m->pkt_len, m->ol_flags,
 482                (unsigned)m->nb_segs, (unsigned)m->port);
 483         nb_segs = m->nb_segs;
 484
 485         while (m && nb_segs != 0) {
 486                 __rte_mbuf_sanity_check(m, 0);
 487
 488                 fprintf(f, "  segment at %p, data=%p, data_len=%u\n",
 489                         m, rte_pktmbuf_mtod(m, void *), (unsigned)m->data_len);
 490                 len = dump_len;
 491                 if (len > m->data_len)
 492                         len = m->data_len;
 493                 if (len != 0)
 494                         rte_hexdump(f, NULL, rte_pktmbuf_mtod(m, void *), len);
 495                 dump_len -= len;
 496                 m = m->next;
 497                 nb_segs --;
 498         }
 499 }
 500
 501 /* read len data bytes in a mbuf at specified offset (internal) */
 502 const void *__rte_pktmbuf_read(const struct rte_mbuf *m, uint32_t off,
 503         uint32_t len, void *buf)
 504 {
 505         const struct rte_mbuf *seg = m;
 506         uint32_t buf_off = 0, copy_len;
 507
 508         if (off + len > rte_pktmbuf_pkt_len(m))
 509                 return NULL;
 510
 511         while (off >= rte_pktmbuf_data_len(seg)) {
 512                 off -= rte_pktmbuf_data_len(seg);
 513                 seg = seg->next;
 514         }
 515
 516         if (off + len <= rte_pktmbuf_data_len(seg))
 517                 return rte_pktmbuf_mtod_offset(seg, char *, off);
 518
 519         /* rare case: header is split among several segments */
 520         while (len > 0) {
 521                 copy_len = rte_pktmbuf_data_len(seg) - off;
 522                 if (copy_len > len)
 523                         copy_len = len;
 524                 rte_memcpy((char *)buf + buf_off,
 525                         rte_pktmbuf_mtod_offset(seg, char *, off), copy_len);
 526                 off = 0;
 527                 buf_off += copy_len;
 528                 len -= copy_len;
 529                 seg = seg->next;
 530         }
 531
 532         return buf;
 533 }
 534
 535 /*
 536  * Get the name of a RX offload flag. Must be kept synchronized with flag
 537  * definitions in rte_mbuf.h.
 538  */
 539 const char *rte_get_rx_ol_flag_name(uint64_t mask)
 540 {
 541         switch (mask) {
 542         case PKT_RX_VLAN: return "PKT_RX_VLAN";
 543         case PKT_RX_RSS_HASH: return "PKT_RX_RSS_HASH";
 544         case PKT_RX_FDIR: return "PKT_RX_FDIR";
 545         case PKT_RX_L4_CKSUM_BAD: return "PKT_RX_L4_CKSUM_BAD";
 546         case PKT_RX_L4_CKSUM_GOOD: return "PKT_RX_L4_CKSUM_GOOD";
 547         case PKT_RX_L4_CKSUM_NONE: return "PKT_RX_L4_CKSUM_NONE";
 548         case PKT_RX_IP_CKSUM_BAD: return "PKT_RX_IP_CKSUM_BAD";
 549         case PKT_RX_IP_CKSUM_GOOD: return "PKT_RX_IP_CKSUM_GOOD";
 550         case PKT_RX_IP_CKSUM_NONE: return "PKT_RX_IP_CKSUM_NONE";
 551         case PKT_RX_EIP_CKSUM_BAD: return "PKT_RX_EIP_CKSUM_BAD";
 552         case PKT_RX_VLAN_STRIPPED: return "PKT_RX_VLAN_STRIPPED";
 553         case PKT_RX_IEEE1588_PTP: return "PKT_RX_IEEE1588_PTP";
 554         case PKT_RX_IEEE1588_TMST: return "PKT_RX_IEEE1588_TMST";
 555         case PKT_RX_FDIR_ID: return "PKT_RX_FDIR_ID";
 556         case PKT_RX_FDIR_FLX: return "PKT_RX_FDIR_FLX";
 557         case PKT_RX_QINQ_STRIPPED: return "PKT_RX_QINQ_STRIPPED";
 558         case PKT_RX_QINQ: return "PKT_RX_QINQ";
 559         case PKT_RX_LRO: return "PKT_RX_LRO";
 560         case PKT_RX_TIMESTAMP: return "PKT_RX_TIMESTAMP";
 561         case PKT_RX_SEC_OFFLOAD: return "PKT_RX_SEC_OFFLOAD";
 562         case PKT_RX_SEC_OFFLOAD_FAILED: return "PKT_RX_SEC_OFFLOAD_FAILED";
 563         case PKT_RX_OUTER_L4_CKSUM_BAD: return "PKT_RX_OUTER_L4_CKSUM_BAD";
 564         case PKT_RX_OUTER_L4_CKSUM_GOOD: return "PKT_RX_OUTER_L4_CKSUM_GOOD";
 565         case PKT_RX_OUTER_L4_CKSUM_INVALID:
 566                 return "PKT_RX_OUTER_L4_CKSUM_INVALID";
 567
 568         default: return NULL;
 569         }
 570 }
 571
 572 struct flag_mask {
 573         uint64_t flag;
 574         uint64_t mask;
 575         const char *default_name;
 576 };
 577
 578 /* write the list of rx ol flags in buffer buf */
 579 int
 580 rte_get_rx_ol_flag_list(uint64_t mask, char *buf, size_t buflen)
 581 {
 582         const struct flag_mask rx_flags[] = {
 583                 { PKT_RX_VLAN, PKT_RX_VLAN, NULL },
 584                 { PKT_RX_RSS_HASH, PKT_RX_RSS_HASH, NULL },
 585                 { PKT_RX_FDIR, PKT_RX_FDIR, NULL },
 586                 { PKT_RX_L4_CKSUM_BAD, PKT_RX_L4_CKSUM_MASK, NULL },
 587                 { PKT_RX_L4_CKSUM_GOOD, PKT_RX_L4_CKSUM_MASK, NULL },
 588                 { PKT_RX_L4_CKSUM_NONE, PKT_RX_L4_CKSUM_MASK, NULL },
 589                 { PKT_RX_L4_CKSUM_UNKNOWN, PKT_RX_L4_CKSUM_MASK,
 590                   "PKT_RX_L4_CKSUM_UNKNOWN" },
 591                 { PKT_RX_IP_CKSUM_BAD, PKT_RX_IP_CKSUM_MASK, NULL },
 592                 { PKT_RX_IP_CKSUM_GOOD, PKT_RX_IP_CKSUM_MASK, NULL },
 593                 { PKT_RX_IP_CKSUM_NONE, PKT_RX_IP_CKSUM_MASK, NULL },
 594                 { PKT_RX_IP_CKSUM_UNKNOWN, PKT_RX_IP_CKSUM_MASK,
 595                   "PKT_RX_IP_CKSUM_UNKNOWN" },
 596                 { PKT_RX_EIP_CKSUM_BAD, PKT_RX_EIP_CKSUM_BAD, NULL },
 597                 { PKT_RX_VLAN_STRIPPED, PKT_RX_VLAN_STRIPPED, NULL },
 598                 { PKT_RX_IEEE1588_PTP, PKT_RX_IEEE1588_PTP, NULL },
 599                 { PKT_RX_IEEE1588_TMST, PKT_RX_IEEE1588_TMST, NULL },
 600                 { PKT_RX_FDIR_ID, PKT_RX_FDIR_ID, NULL },
 601                 { PKT_RX_FDIR_FLX, PKT_RX_FDIR_FLX, NULL },
 602                 { PKT_RX_QINQ_STRIPPED, PKT_RX_QINQ_STRIPPED, NULL },
 603                 { PKT_RX_LRO, PKT_RX_LRO, NULL },
 604                 { PKT_RX_TIMESTAMP, PKT_RX_TIMESTAMP, NULL },
 605                 { PKT_RX_SEC_OFFLOAD, PKT_RX_SEC_OFFLOAD, NULL },
 606                 { PKT_RX_SEC_OFFLOAD_FAILED, PKT_RX_SEC_OFFLOAD_FAILED, NULL },
 607                 { PKT_RX_QINQ, PKT_RX_QINQ, NULL },
 608                 { PKT_RX_OUTER_L4_CKSUM_BAD, PKT_RX_OUTER_L4_CKSUM_MASK, NULL },
 609                 { PKT_RX_OUTER_L4_CKSUM_GOOD, PKT_RX_OUTER_L4_CKSUM_MASK,
 610                   NULL },
 611                 { PKT_RX_OUTER_L4_CKSUM_INVALID, PKT_RX_OUTER_L4_CKSUM_MASK,
 612                   NULL },
 613                 { PKT_RX_OUTER_L4_CKSUM_UNKNOWN, PKT_RX_OUTER_L4_CKSUM_MASK,
 614                   "PKT_RX_OUTER_L4_CKSUM_UNKNOWN" },
 615         };
 616         const char *name;
 617         unsigned int i;
 618         int ret;
 619
 620         if (buflen == 0)
 621                 return -1;
 622
 623         buf[0] = '\0';
 624         for (i = 0; i < RTE_DIM(rx_flags); i++) {
 625                 if ((mask & rx_flags[i].mask) != rx_flags[i].flag)
 626                         continue;
 627                 name = rte_get_rx_ol_flag_name(rx_flags[i].flag);
 628                 if (name == NULL)
 629                         name = rx_flags[i].default_name;
 630                 ret = snprintf(buf, buflen, "%s ", name);
 631                 if (ret < 0)
 632                         return -1;
 633                 if ((size_t)ret >= buflen)
 634                         return -1;
 635                 buf += ret;
 636                 buflen -= ret;
 637         }
 638
 639         return 0;
 640 }
 641
 642 /*
 643  * Get the name of a TX offload flag. Must be kept synchronized with flag
 644  * definitions in rte_mbuf.h.
 645  */
 646 const char *rte_get_tx_ol_flag_name(uint64_t mask)
 647 {
 648         switch (mask) {
 649         case PKT_TX_VLAN: return "PKT_TX_VLAN";
 650         case PKT_TX_IP_CKSUM: return "PKT_TX_IP_CKSUM";
 651         case PKT_TX_TCP_CKSUM: return "PKT_TX_TCP_CKSUM";
 652         case PKT_TX_SCTP_CKSUM: return "PKT_TX_SCTP_CKSUM";
 653         case PKT_TX_UDP_CKSUM: return "PKT_TX_UDP_CKSUM";
 654         case PKT_TX_IEEE1588_TMST: return "PKT_TX_IEEE1588_TMST";
 655         case PKT_TX_TCP_SEG: return "PKT_TX_TCP_SEG";
 656         case PKT_TX_IPV4: return "PKT_TX_IPV4";
 657         case PKT_TX_IPV6: return "PKT_TX_IPV6";
 658         case PKT_TX_OUTER_IP_CKSUM: return "PKT_TX_OUTER_IP_CKSUM";
 659         case PKT_TX_OUTER_IPV4: return "PKT_TX_OUTER_IPV4";
 660         case PKT_TX_OUTER_IPV6: return "PKT_TX_OUTER_IPV6";
 661         case PKT_TX_TUNNEL_VXLAN: return "PKT_TX_TUNNEL_VXLAN";
 662         case PKT_TX_TUNNEL_GTP: return "PKT_TX_TUNNEL_GTP";
 663         case PKT_TX_TUNNEL_GRE: return "PKT_TX_TUNNEL_GRE";
 664         case PKT_TX_TUNNEL_IPIP: return "PKT_TX_TUNNEL_IPIP";
 665         case PKT_TX_TUNNEL_GENEVE: return "PKT_TX_TUNNEL_GENEVE";
 666         case PKT_TX_TUNNEL_MPLSINUDP: return "PKT_TX_TUNNEL_MPLSINUDP";
 667         case PKT_TX_TUNNEL_VXLAN_GPE: return "PKT_TX_TUNNEL_VXLAN_GPE";
 668         case PKT_TX_TUNNEL_IP: return "PKT_TX_TUNNEL_IP";
 669         case PKT_TX_TUNNEL_UDP: return "PKT_TX_TUNNEL_UDP";
 670         case PKT_TX_QINQ: return "PKT_TX_QINQ";
 671         case PKT_TX_MACSEC: return "PKT_TX_MACSEC";
 672         case PKT_TX_SEC_OFFLOAD: return "PKT_TX_SEC_OFFLOAD";
 673         case PKT_TX_UDP_SEG: return "PKT_TX_UDP_SEG";
 674         case PKT_TX_OUTER_UDP_CKSUM: return "PKT_TX_OUTER_UDP_CKSUM";
 675         default: return NULL;
 676         }
 677 }
 678
 679 /* write the list of tx ol flags in buffer buf */
 680 int
 681 rte_get_tx_ol_flag_list(uint64_t mask, char *buf, size_t buflen)
 682 {
 683         const struct flag_mask tx_flags[] = {
 684                 { PKT_TX_VLAN, PKT_TX_VLAN, NULL },
 685                 { PKT_TX_IP_CKSUM, PKT_TX_IP_CKSUM, NULL },
 686                 { PKT_TX_TCP_CKSUM, PKT_TX_L4_MASK, NULL },
 687                 { PKT_TX_SCTP_CKSUM, PKT_TX_L4_MASK, NULL },
 688                 { PKT_TX_UDP_CKSUM, PKT_TX_L4_MASK, NULL },
 689                 { PKT_TX_L4_NO_CKSUM, PKT_TX_L4_MASK, "PKT_TX_L4_NO_CKSUM" },
 690                 { PKT_TX_IEEE1588_TMST, PKT_TX_IEEE1588_TMST, NULL },
 691                 { PKT_TX_TCP_SEG, PKT_TX_TCP_SEG, NULL },
 692                 { PKT_TX_IPV4, PKT_TX_IPV4, NULL },
 693                 { PKT_TX_IPV6, PKT_TX_IPV6, NULL },
 694                 { PKT_TX_OUTER_IP_CKSUM, PKT_TX_OUTER_IP_CKSUM, NULL },
 695                 { PKT_TX_OUTER_IPV4, PKT_TX_OUTER_IPV4, NULL },
 696                 { PKT_TX_OUTER_IPV6, PKT_TX_OUTER_IPV6, NULL },
 697                 { PKT_TX_TUNNEL_VXLAN, PKT_TX_TUNNEL_MASK, NULL },
 698                 { PKT_TX_TUNNEL_GTP, PKT_TX_TUNNEL_MASK, NULL },
 699                 { PKT_TX_TUNNEL_GRE, PKT_TX_TUNNEL_MASK, NULL },
 700                 { PKT_TX_TUNNEL_IPIP, PKT_TX_TUNNEL_MASK, NULL },
 701                 { PKT_TX_TUNNEL_GENEVE, PKT_TX_TUNNEL_MASK, NULL },
 702                 { PKT_TX_TUNNEL_MPLSINUDP, PKT_TX_TUNNEL_MASK, NULL },
 703                 { PKT_TX_TUNNEL_VXLAN_GPE, PKT_TX_TUNNEL_MASK, NULL },
 704                 { PKT_TX_TUNNEL_IP, PKT_TX_TUNNEL_MASK, NULL },
 705                 { PKT_TX_TUNNEL_UDP, PKT_TX_TUNNEL_MASK, NULL },
 706                 { PKT_TX_QINQ, PKT_TX_QINQ, NULL },
 707                 { PKT_TX_MACSEC, PKT_TX_MACSEC, NULL },
 708                 { PKT_TX_SEC_OFFLOAD, PKT_TX_SEC_OFFLOAD, NULL },
 709                 { PKT_TX_UDP_SEG, PKT_TX_UDP_SEG, NULL },
 710                 { PKT_TX_OUTER_UDP_CKSUM, PKT_TX_OUTER_UDP_CKSUM, NULL },
 711         };
 712         const char *name;
 713         unsigned int i;
 714         int ret;
 715
 716         if (buflen == 0)
 717                 return -1;
 718
 719         buf[0] = '\0';
 720         for (i = 0; i < RTE_DIM(tx_flags); i++) {
 721                 if ((mask & tx_flags[i].mask) != tx_flags[i].flag)
 722                         continue;
 723                 name = rte_get_tx_ol_flag_name(tx_flags[i].flag);
 724                 if (name == NULL)
 725                         name = tx_flags[i].default_name;
 726                 ret = snprintf(buf, buflen, "%s ", name);
 727                 if (ret < 0)
 728                         return -1;
 729                 if ((size_t)ret >= buflen)
 730                         return -1;
 731                 buf += ret;
 732                 buflen -= ret;
 733         }
 734
 735         return 0;
 736 }