lib/librte_pdump/rte_pdump.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2018 Intel Corporation
   3  */
   4
   5 #include <rte_memcpy.h>
   6 #include <rte_mbuf.h>
   7 #include <rte_ethdev.h>
   8 #include <rte_lcore.h>
   9 #include <rte_log.h>
  10 #include <rte_errno.h>
  11 #include <rte_string_fns.h>
  12
  13 #include "rte_pdump.h"
  14
  15 #define DEVICE_ID_SIZE 64
  16 /* Macros for printing using RTE_LOG */
  17 #define RTE_LOGTYPE_PDUMP RTE_LOGTYPE_USER1
  18
  19 /* Used for the multi-process communication */
  20 #define PDUMP_MP        "mp_pdump"
  21
  22 enum pdump_operation {
  23         DISABLE = 1,
  24         ENABLE = 2
  25 };
  26
  27 enum pdump_version {
  28         V1 = 1
  29 };
  30
  31 struct pdump_request {
  32         uint16_t ver;
  33         uint16_t op;
  34         uint32_t flags;
  35         union pdump_data {
  36                 struct enable_v1 {
  37                         char device[DEVICE_ID_SIZE];
  38                         uint16_t queue;
  39                         struct rte_ring *ring;
  40                         struct rte_mempool *mp;
  41                         void *filter;
  42                 } en_v1;
  43                 struct disable_v1 {
  44                         char device[DEVICE_ID_SIZE];
  45                         uint16_t queue;
  46                         struct rte_ring *ring;
  47                         struct rte_mempool *mp;
  48                         void *filter;
  49                 } dis_v1;
  50         } data;
  51 };
  52
  53 struct pdump_response {
  54         uint16_t ver;
  55         uint16_t res_op;
  56         int32_t err_value;
  57 };
  58
  59 static struct pdump_rxtx_cbs {
  60         struct rte_ring *ring;
  61         struct rte_mempool *mp;
  62         const struct rte_eth_rxtx_callback *cb;
  63         void *filter;
  64 } rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
  65 tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
  66
  67 static inline int
  68 pdump_pktmbuf_copy_data(struct rte_mbuf *seg, const struct rte_mbuf *m)
  69 {
  70         if (rte_pktmbuf_tailroom(seg) < m->data_len) {
  71                 RTE_LOG(ERR, PDUMP,
  72                         "User mempool: insufficient data_len of mbuf\n");
  73                 return -EINVAL;
  74         }
  75
  76         seg->port = m->port;
  77         seg->vlan_tci = m->vlan_tci;
  78         seg->hash = m->hash;
  79         seg->tx_offload = m->tx_offload;
  80         seg->ol_flags = m->ol_flags;
  81         seg->packet_type = m->packet_type;
  82         seg->vlan_tci_outer = m->vlan_tci_outer;
  83         seg->data_len = m->data_len;
  84         seg->pkt_len = seg->data_len;
  85         rte_memcpy(rte_pktmbuf_mtod(seg, void *),
  86                         rte_pktmbuf_mtod(m, void *),
  87                         rte_pktmbuf_data_len(seg));
  88
  89         return 0;
  90 }
  91
  92 static inline struct rte_mbuf *
  93 pdump_pktmbuf_copy(struct rte_mbuf *m, struct rte_mempool *mp)
  94 {
  95         struct rte_mbuf *m_dup, *seg, **prev;
  96         uint32_t pktlen;
  97         uint16_t nseg;
  98
  99         m_dup = rte_pktmbuf_alloc(mp);
 100         if (unlikely(m_dup == NULL))
 101                 return NULL;
 102
 103         seg = m_dup;
 104         prev = &seg->next;
 105         pktlen = m->pkt_len;
 106         nseg = 0;
 107
 108         do {
 109                 nseg++;
 110                 if (pdump_pktmbuf_copy_data(seg, m) < 0) {
 111                         if (seg != m_dup)
 112                                 rte_pktmbuf_free_seg(seg);
 113                         rte_pktmbuf_free(m_dup);
 114                         return NULL;
 115                 }
 116                 *prev = seg;
 117                 prev = &seg->next;
 118         } while ((m = m->next) != NULL &&
 119                         (seg = rte_pktmbuf_alloc(mp)) != NULL);
 120
 121         *prev = NULL;
 122         m_dup->nb_segs = nseg;
 123         m_dup->pkt_len = pktlen;
 124
 125         /* Allocation of new indirect segment failed */
 126         if (unlikely(seg == NULL)) {
 127                 rte_pktmbuf_free(m_dup);
 128                 return NULL;
 129         }
 130
 131         __rte_mbuf_sanity_check(m_dup, 1);
 132         return m_dup;
 133 }
 134
 135 static inline void
 136 pdump_copy(struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
 137 {
 138         unsigned i;
 139         int ring_enq;
 140         uint16_t d_pkts = 0;
 141         struct rte_mbuf *dup_bufs[nb_pkts];
 142         struct pdump_rxtx_cbs *cbs;
 143         struct rte_ring *ring;
 144         struct rte_mempool *mp;
 145         struct rte_mbuf *p;
 146
 147         cbs  = user_params;
 148         ring = cbs->ring;
 149         mp = cbs->mp;
 150         for (i = 0; i < nb_pkts; i++) {
 151                 p = pdump_pktmbuf_copy(pkts[i], mp);
 152                 if (p)
 153                         dup_bufs[d_pkts++] = p;
 154         }
 155
 156         ring_enq = rte_ring_enqueue_burst(ring, (void *)dup_bufs, d_pkts, NULL);
 157         if (unlikely(ring_enq < d_pkts)) {
 158                 RTE_LOG(DEBUG, PDUMP,
 159                         "only %d of packets enqueued to ring\n", ring_enq);
 160                 do {
 161                         rte_pktmbuf_free(dup_bufs[ring_enq]);
 162                 } while (++ring_enq < d_pkts);
 163         }
 164 }
 165
 166 static uint16_t
 167 pdump_rx(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
 168         struct rte_mbuf **pkts, uint16_t nb_pkts,
 169         uint16_t max_pkts __rte_unused,
 170         void *user_params)
 171 {
 172         pdump_copy(pkts, nb_pkts, user_params);
 173         return nb_pkts;
 174 }
 175
 176 static uint16_t
 177 pdump_tx(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
 178                 struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
 179 {
 180         pdump_copy(pkts, nb_pkts, user_params);
 181         return nb_pkts;
 182 }
 183
 184 static int
 185 pdump_register_rx_callbacks(uint16_t end_q, uint16_t port, uint16_t queue,
 186                                 struct rte_ring *ring, struct rte_mempool *mp,
 187                                 uint16_t operation)
 188 {
 189         uint16_t qid;
 190         struct pdump_rxtx_cbs *cbs = NULL;
 191
 192         qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
 193         for (; qid < end_q; qid++) {
 194                 cbs = &rx_cbs[port][qid];
 195                 if (cbs && operation == ENABLE) {
 196                         if (cbs->cb) {
 197                                 RTE_LOG(ERR, PDUMP,
 198                                         "failed to add rx callback for port=%d "
 199                                         "and queue=%d, callback already exists\n",
 200                                         port, qid);
 201                                 return -EEXIST;
 202                         }
 203                         cbs->ring = ring;
 204                         cbs->mp = mp;
 205                         cbs->cb = rte_eth_add_first_rx_callback(port, qid,
 206                                                                 pdump_rx, cbs);
 207                         if (cbs->cb == NULL) {
 208                                 RTE_LOG(ERR, PDUMP,
 209                                         "failed to add rx callback, errno=%d\n",
 210                                         rte_errno);
 211                                 return rte_errno;
 212                         }
 213                 }
 214                 if (cbs && operation == DISABLE) {
 215                         int ret;
 216
 217                         if (cbs->cb == NULL) {
 218                                 RTE_LOG(ERR, PDUMP,
 219                                         "failed to delete non existing rx "
 220                                         "callback for port=%d and queue=%d\n",
 221                                         port, qid);
 222                                 return -EINVAL;
 223                         }
 224                         ret = rte_eth_remove_rx_callback(port, qid, cbs->cb);
 225                         if (ret < 0) {
 226                                 RTE_LOG(ERR, PDUMP,
 227                                         "failed to remove rx callback, errno=%d\n",
 228                                         -ret);
 229                                 return ret;
 230                         }
 231                         cbs->cb = NULL;
 232                 }
 233         }
 234
 235         return 0;
 236 }
 237
 238 static int
 239 pdump_register_tx_callbacks(uint16_t end_q, uint16_t port, uint16_t queue,
 240                                 struct rte_ring *ring, struct rte_mempool *mp,
 241                                 uint16_t operation)
 242 {
 243
 244         uint16_t qid;
 245         struct pdump_rxtx_cbs *cbs = NULL;
 246
 247         qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
 248         for (; qid < end_q; qid++) {
 249                 cbs = &tx_cbs[port][qid];
 250                 if (cbs && operation == ENABLE) {
 251                         if (cbs->cb) {
 252                                 RTE_LOG(ERR, PDUMP,
 253                                         "failed to add tx callback for port=%d "
 254                                         "and queue=%d, callback already exists\n",
 255                                         port, qid);
 256                                 return -EEXIST;
 257                         }
 258                         cbs->ring = ring;
 259                         cbs->mp = mp;
 260                         cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
 261                                                                 cbs);
 262                         if (cbs->cb == NULL) {
 263                                 RTE_LOG(ERR, PDUMP,
 264                                         "failed to add tx callback, errno=%d\n",
 265                                         rte_errno);
 266                                 return rte_errno;
 267                         }
 268                 }
 269                 if (cbs && operation == DISABLE) {
 270                         int ret;
 271
 272                         if (cbs->cb == NULL) {
 273                                 RTE_LOG(ERR, PDUMP,
 274                                         "failed to delete non existing tx "
 275                                         "callback for port=%d and queue=%d\n",
 276                                         port, qid);
 277                                 return -EINVAL;
 278                         }
 279                         ret = rte_eth_remove_tx_callback(port, qid, cbs->cb);
 280                         if (ret < 0) {
 281                                 RTE_LOG(ERR, PDUMP,
 282                                         "failed to remove tx callback, errno=%d\n",
 283                                         -ret);
 284                                 return ret;
 285                         }
 286                         cbs->cb = NULL;
 287                 }
 288         }
 289
 290         return 0;
 291 }
 292
 293 static int
 294 set_pdump_rxtx_cbs(const struct pdump_request *p)
 295 {
 296         uint16_t nb_rx_q = 0, nb_tx_q = 0, end_q, queue;
 297         uint16_t port;
 298         int ret = 0;
 299         uint32_t flags;
 300         uint16_t operation;
 301         struct rte_ring *ring;
 302         struct rte_mempool *mp;
 303
 304         flags = p->flags;
 305         operation = p->op;
 306         if (operation == ENABLE) {
 307                 ret = rte_eth_dev_get_port_by_name(p->data.en_v1.device,
 308                                 &port);
 309                 if (ret < 0) {
 310                         RTE_LOG(ERR, PDUMP,
 311                                 "failed to get port id for device id=%s\n",
 312                                 p->data.en_v1.device);
 313                         return -EINVAL;
 314                 }
 315                 queue = p->data.en_v1.queue;
 316                 ring = p->data.en_v1.ring;
 317                 mp = p->data.en_v1.mp;
 318         } else {
 319                 ret = rte_eth_dev_get_port_by_name(p->data.dis_v1.device,
 320                                 &port);
 321                 if (ret < 0) {
 322                         RTE_LOG(ERR, PDUMP,
 323                                 "failed to get port id for device id=%s\n",
 324                                 p->data.dis_v1.device);
 325                         return -EINVAL;
 326                 }
 327                 queue = p->data.dis_v1.queue;
 328                 ring = p->data.dis_v1.ring;
 329                 mp = p->data.dis_v1.mp;
 330         }
 331
 332         /* validation if packet capture is for all queues */
 333         if (queue == RTE_PDUMP_ALL_QUEUES) {
 334                 struct rte_eth_dev_info dev_info;
 335
 336                 rte_eth_dev_info_get(port, &dev_info);
 337                 nb_rx_q = dev_info.nb_rx_queues;
 338                 nb_tx_q = dev_info.nb_tx_queues;
 339                 if (nb_rx_q == 0 && flags & RTE_PDUMP_FLAG_RX) {
 340                         RTE_LOG(ERR, PDUMP,
 341                                 "number of rx queues cannot be 0\n");
 342                         return -EINVAL;
 343                 }
 344                 if (nb_tx_q == 0 && flags & RTE_PDUMP_FLAG_TX) {
 345                         RTE_LOG(ERR, PDUMP,
 346                                 "number of tx queues cannot be 0\n");
 347                         return -EINVAL;
 348                 }
 349                 if ((nb_tx_q == 0 || nb_rx_q == 0) &&
 350                         flags == RTE_PDUMP_FLAG_RXTX) {
 351                         RTE_LOG(ERR, PDUMP,
 352                                 "both tx&rx queues must be non zero\n");
 353                         return -EINVAL;
 354                 }
 355         }
 356
 357         /* register RX callback */
 358         if (flags & RTE_PDUMP_FLAG_RX) {
 359                 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
 360                 ret = pdump_register_rx_callbacks(end_q, port, queue, ring, mp,
 361                                                         operation);
 362                 if (ret < 0)
 363                         return ret;
 364         }
 365
 366         /* register TX callback */
 367         if (flags & RTE_PDUMP_FLAG_TX) {
 368                 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
 369                 ret = pdump_register_tx_callbacks(end_q, port, queue, ring, mp,
 370                                                         operation);
 371                 if (ret < 0)
 372                         return ret;
 373         }
 374
 375         return ret;
 376 }
 377
 378 static int
 379 pdump_server(const struct rte_mp_msg *mp_msg, const void *peer)
 380 {
 381         struct rte_mp_msg mp_resp;
 382         const struct pdump_request *cli_req;
 383         struct pdump_response *resp = (struct pdump_response *)&mp_resp.param;
 384
 385         /* recv client requests */
 386         if (mp_msg->len_param != sizeof(*cli_req)) {
 387                 RTE_LOG(ERR, PDUMP, "failed to recv from client\n");
 388                 resp->err_value = -EINVAL;
 389         } else {
 390                 cli_req = (const struct pdump_request *)mp_msg->param;
 391                 resp->ver = cli_req->ver;
 392                 resp->res_op = cli_req->op;
 393                 resp->err_value = set_pdump_rxtx_cbs(cli_req);
 394         }
 395
 396         strlcpy(mp_resp.name, PDUMP_MP, RTE_MP_MAX_NAME_LEN);
 397         mp_resp.len_param = sizeof(*resp);
 398         mp_resp.num_fds = 0;
 399         if (rte_mp_reply(&mp_resp, peer) < 0) {
 400                 RTE_LOG(ERR, PDUMP, "failed to send to client:%s, %s:%d\n",
 401                         strerror(rte_errno), __func__, __LINE__);
 402                 return -1;
 403         }
 404
 405         return 0;
 406 }
 407
 408 int
 409 rte_pdump_init(void)
 410 {
 411         int ret = rte_mp_action_register(PDUMP_MP, pdump_server);
 412         if (ret && rte_errno != ENOTSUP)
 413                 return -1;
 414         return 0;
 415 }
 416
 417 int
 418 rte_pdump_uninit(void)
 419 {
 420         rte_mp_action_unregister(PDUMP_MP);
 421
 422         return 0;
 423 }
 424
 425 static int
 426 pdump_validate_ring_mp(struct rte_ring *ring, struct rte_mempool *mp)
 427 {
 428         if (ring == NULL || mp == NULL) {
 429                 RTE_LOG(ERR, PDUMP, "NULL ring or mempool are passed %s:%d\n",
 430                         __func__, __LINE__);
 431                 rte_errno = EINVAL;
 432                 return -1;
 433         }
 434         if (mp->flags & MEMPOOL_F_SP_PUT || mp->flags & MEMPOOL_F_SC_GET) {
 435                 RTE_LOG(ERR, PDUMP, "mempool with either SP or SC settings"
 436                 " is not valid for pdump, should have MP and MC settings\n");
 437                 rte_errno = EINVAL;
 438                 return -1;
 439         }
 440         if (ring->prod.single || ring->cons.single) {
 441                 RTE_LOG(ERR, PDUMP, "ring with either SP or SC settings"
 442                 " is not valid for pdump, should have MP and MC settings\n");
 443                 rte_errno = EINVAL;
 444                 return -1;
 445         }
 446
 447         return 0;
 448 }
 449
 450 static int
 451 pdump_validate_flags(uint32_t flags)
 452 {
 453         if (flags != RTE_PDUMP_FLAG_RX && flags != RTE_PDUMP_FLAG_TX &&
 454                 flags != RTE_PDUMP_FLAG_RXTX) {
 455                 RTE_LOG(ERR, PDUMP,
 456                         "invalid flags, should be either rx/tx/rxtx\n");
 457                 rte_errno = EINVAL;
 458                 return -1;
 459         }
 460
 461         return 0;
 462 }
 463
 464 static int
 465 pdump_validate_port(uint16_t port, char *name)
 466 {
 467         int ret = 0;
 468
 469         if (port >= RTE_MAX_ETHPORTS) {
 470                 RTE_LOG(ERR, PDUMP, "Invalid port id %u, %s:%d\n", port,
 471                         __func__, __LINE__);
 472                 rte_errno = EINVAL;
 473                 return -1;
 474         }
 475
 476         ret = rte_eth_dev_get_name_by_port(port, name);
 477         if (ret < 0) {
 478                 RTE_LOG(ERR, PDUMP,
 479                         "port id to name mapping failed for port id=%u, %s:%d\n",
 480                         port, __func__, __LINE__);
 481                 rte_errno = EINVAL;
 482                 return -1;
 483         }
 484
 485         return 0;
 486 }
 487
 488 static int
 489 pdump_prepare_client_request(char *device, uint16_t queue,
 490                                 uint32_t flags,
 491                                 uint16_t operation,
 492                                 struct rte_ring *ring,
 493                                 struct rte_mempool *mp,
 494                                 void *filter)
 495 {
 496         int ret = -1;
 497         struct rte_mp_msg mp_req, *mp_rep;
 498         struct rte_mp_reply mp_reply;
 499         struct timespec ts = {.tv_sec = 5, .tv_nsec = 0};
 500         struct pdump_request *req = (struct pdump_request *)mp_req.param;
 501         struct pdump_response *resp;
 502
 503         req->ver = 1;
 504         req->flags = flags;
 505         req->op = operation;
 506         if ((operation & ENABLE) != 0) {
 507                 strlcpy(req->data.en_v1.device, device,
 508                         sizeof(req->data.en_v1.device));
 509                 req->data.en_v1.queue = queue;
 510                 req->data.en_v1.ring = ring;
 511                 req->data.en_v1.mp = mp;
 512                 req->data.en_v1.filter = filter;
 513         } else {
 514                 strlcpy(req->data.dis_v1.device, device,
 515                         sizeof(req->data.dis_v1.device));
 516                 req->data.dis_v1.queue = queue;
 517                 req->data.dis_v1.ring = NULL;
 518                 req->data.dis_v1.mp = NULL;
 519                 req->data.dis_v1.filter = NULL;
 520         }
 521
 522         strlcpy(mp_req.name, PDUMP_MP, RTE_MP_MAX_NAME_LEN);
 523         mp_req.len_param = sizeof(*req);
 524         mp_req.num_fds = 0;
 525         if (rte_mp_request_sync(&mp_req, &mp_reply, &ts) == 0) {
 526                 mp_rep = &mp_reply.msgs[0];
 527                 resp = (struct pdump_response *)mp_rep->param;
 528                 rte_errno = resp->err_value;
 529                 if (!resp->err_value)
 530                         ret = 0;
 531                 free(mp_reply.msgs);
 532         }
 533
 534         if (ret < 0)
 535                 RTE_LOG(ERR, PDUMP,
 536                         "client request for pdump enable/disable failed\n");
 537         return ret;
 538 }
 539
 540 int
 541 rte_pdump_enable(uint16_t port, uint16_t queue, uint32_t flags,
 542                         struct rte_ring *ring,
 543                         struct rte_mempool *mp,
 544                         void *filter)
 545 {
 546
 547         int ret = 0;
 548         char name[DEVICE_ID_SIZE];
 549
 550         ret = pdump_validate_port(port, name);
 551         if (ret < 0)
 552                 return ret;
 553         ret = pdump_validate_ring_mp(ring, mp);
 554         if (ret < 0)
 555                 return ret;
 556         ret = pdump_validate_flags(flags);
 557         if (ret < 0)
 558                 return ret;
 559
 560         ret = pdump_prepare_client_request(name, queue, flags,
 561                                                 ENABLE, ring, mp, filter);
 562
 563         return ret;
 564 }
 565
 566 int
 567 rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
 568                                 uint32_t flags,
 569                                 struct rte_ring *ring,
 570                                 struct rte_mempool *mp,
 571                                 void *filter)
 572 {
 573         int ret = 0;
 574
 575         ret = pdump_validate_ring_mp(ring, mp);
 576         if (ret < 0)
 577                 return ret;
 578         ret = pdump_validate_flags(flags);
 579         if (ret < 0)
 580                 return ret;
 581
 582         ret = pdump_prepare_client_request(device_id, queue, flags,
 583                                                 ENABLE, ring, mp, filter);
 584
 585         return ret;
 586 }
 587
 588 int
 589 rte_pdump_disable(uint16_t port, uint16_t queue, uint32_t flags)
 590 {
 591         int ret = 0;
 592         char name[DEVICE_ID_SIZE];
 593
 594         ret = pdump_validate_port(port, name);
 595         if (ret < 0)
 596                 return ret;
 597         ret = pdump_validate_flags(flags);
 598         if (ret < 0)
 599                 return ret;
 600
 601         ret = pdump_prepare_client_request(name, queue, flags,
 602                                                 DISABLE, NULL, NULL, NULL);
 603
 604         return ret;
 605 }
 606
 607 int
 608 rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
 609                                 uint32_t flags)
 610 {
 611         int ret = 0;
 612
 613         ret = pdump_validate_flags(flags);
 614         if (ret < 0)
 615                 return ret;
 616
 617         ret = pdump_prepare_client_request(device_id, queue, flags,
 618                                                 DISABLE, NULL, NULL, NULL);
 619
 620         return ret;
 621 }