lib/librte_bpf/bpf_pkt.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <stdarg.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <errno.h>
   9 #include <stdint.h>
  10 #include <unistd.h>
  11 #include <inttypes.h>
  12
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <fcntl.h>
  16 #include <sys/queue.h>
  17
  18 #include <rte_common.h>
  19 #include <rte_byteorder.h>
  20 #include <rte_malloc.h>
  21 #include <rte_log.h>
  22 #include <rte_debug.h>
  23 #include <rte_cycles.h>
  24 #include <rte_eal.h>
  25 #include <rte_per_lcore.h>
  26 #include <rte_lcore.h>
  27 #include <rte_atomic.h>
  28 #include <rte_mbuf.h>
  29 #include <rte_ethdev.h>
  30
  31 #include <rte_bpf_ethdev.h>
  32 #include "bpf_impl.h"
  33
  34 /*
  35  * information about installed BPF rx/tx callback
  36  */
  37
  38 struct bpf_eth_cbi {
  39         /* used by both data & control path */
  40         uint32_t use;    /*usage counter */
  41         const struct rte_eth_rxtx_callback *cb;  /* callback handle */
  42         struct rte_bpf *bpf;
  43         struct rte_bpf_jit jit;
  44         /* used by control path only */
  45         LIST_ENTRY(bpf_eth_cbi) link;
  46         uint16_t port;
  47         uint16_t queue;
  48 } __rte_cache_aligned;
  49
  50 /*
  51  * Odd number means that callback is used by datapath.
  52  * Even number means that callback is not used by datapath.
  53  */
  54 #define BPF_ETH_CBI_INUSE  1
  55
  56 /*
  57  * List to manage RX/TX installed callbacks.
  58  */
  59 LIST_HEAD(bpf_eth_cbi_list, bpf_eth_cbi);
  60
  61 enum {
  62         BPF_ETH_RX,
  63         BPF_ETH_TX,
  64         BPF_ETH_NUM,
  65 };
  66
  67 /*
  68  * information about all installed BPF rx/tx callbacks
  69  */
  70 struct bpf_eth_cbh {
  71         rte_spinlock_t lock;
  72         struct bpf_eth_cbi_list list;
  73         uint32_t type;
  74 };
  75
  76 static struct bpf_eth_cbh rx_cbh = {
  77         .lock = RTE_SPINLOCK_INITIALIZER,
  78         .list = LIST_HEAD_INITIALIZER(list),
  79         .type = BPF_ETH_RX,
  80 };
  81
  82 static struct bpf_eth_cbh tx_cbh = {
  83         .lock = RTE_SPINLOCK_INITIALIZER,
  84         .list = LIST_HEAD_INITIALIZER(list),
  85         .type = BPF_ETH_TX,
  86 };
  87
  88 /*
  89  * Marks given callback as used by datapath.
  90  */
  91 static __rte_always_inline void
  92 bpf_eth_cbi_inuse(struct bpf_eth_cbi *cbi)
  93 {
  94         cbi->use++;
  95         /* make sure no store/load reordering could happen */
  96         rte_smp_mb();
  97 }
  98
  99 /*
 100  * Marks given callback list as not used by datapath.
 101  */
 102 static __rte_always_inline void
 103 bpf_eth_cbi_unuse(struct bpf_eth_cbi *cbi)
 104 {
 105         /* make sure all previous loads are completed */
 106         rte_smp_rmb();
 107         cbi->use++;
 108 }
 109
 110 /*
 111  * Waits till datapath finished using given callback.
 112  */
 113 static void
 114 bpf_eth_cbi_wait(const struct bpf_eth_cbi *cbi)
 115 {
 116         uint32_t nuse, puse;
 117
 118         /* make sure all previous loads and stores are completed */
 119         rte_smp_mb();
 120
 121         puse = cbi->use;
 122
 123         /* in use, busy wait till current RX/TX iteration is finished */
 124         if ((puse & BPF_ETH_CBI_INUSE) != 0) {
 125                 do {
 126                         rte_pause();
 127                         rte_compiler_barrier();
 128                         nuse = cbi->use;
 129                 } while (nuse == puse);
 130         }
 131 }
 132
 133 static void
 134 bpf_eth_cbi_cleanup(struct bpf_eth_cbi *bc)
 135 {
 136         bc->bpf = NULL;
 137         memset(&bc->jit, 0, sizeof(bc->jit));
 138 }
 139
 140 static struct bpf_eth_cbi *
 141 bpf_eth_cbh_find(struct bpf_eth_cbh *cbh, uint16_t port, uint16_t queue)
 142 {
 143         struct bpf_eth_cbi *cbi;
 144
 145         LIST_FOREACH(cbi, &cbh->list, link) {
 146                 if (cbi->port == port && cbi->queue == queue)
 147                         break;
 148         }
 149         return cbi;
 150 }
 151
 152 static struct bpf_eth_cbi *
 153 bpf_eth_cbh_add(struct bpf_eth_cbh *cbh, uint16_t port, uint16_t queue)
 154 {
 155         struct bpf_eth_cbi *cbi;
 156
 157         /* return an existing one */
 158         cbi = bpf_eth_cbh_find(cbh, port, queue);
 159         if (cbi != NULL)
 160                 return cbi;
 161
 162         cbi = rte_zmalloc(NULL, sizeof(*cbi), RTE_CACHE_LINE_SIZE);
 163         if (cbi != NULL) {
 164                 cbi->port = port;
 165                 cbi->queue = queue;
 166                 LIST_INSERT_HEAD(&cbh->list, cbi, link);
 167         }
 168         return cbi;
 169 }
 170
 171 /*
 172  * BPF packet processing routinies.
 173  */
 174
 175 static inline uint32_t
 176 apply_filter(struct rte_mbuf *mb[], const uint64_t rc[], uint32_t num,
 177         uint32_t drop)
 178 {
 179         uint32_t i, j, k;
 180         struct rte_mbuf *dr[num];
 181
 182         for (i = 0, j = 0, k = 0; i != num; i++) {
 183
 184                 /* filter matches */
 185                 if (rc[i] != 0)
 186                         mb[j++] = mb[i];
 187                 /* no match */
 188                 else
 189                         dr[k++] = mb[i];
 190         }
 191
 192         if (drop != 0) {
 193                 /* free filtered out mbufs */
 194                 for (i = 0; i != k; i++)
 195                         rte_pktmbuf_free(dr[i]);
 196         } else {
 197                 /* copy filtered out mbufs beyond good ones */
 198                 for (i = 0; i != k; i++)
 199                         mb[j + i] = dr[i];
 200         }
 201
 202         return j;
 203 }
 204
 205 static inline uint32_t
 206 pkt_filter_vm(const struct rte_bpf *bpf, struct rte_mbuf *mb[], uint32_t num,
 207         uint32_t drop)
 208 {
 209         uint32_t i;
 210         void *dp[num];
 211         uint64_t rc[num];
 212
 213         for (i = 0; i != num; i++)
 214                 dp[i] = rte_pktmbuf_mtod(mb[i], void *);
 215
 216         rte_bpf_exec_burst(bpf, dp, rc, num);
 217         return apply_filter(mb, rc, num, drop);
 218 }
 219
 220 static inline uint32_t
 221 pkt_filter_jit(const struct rte_bpf_jit *jit, struct rte_mbuf *mb[],
 222         uint32_t num, uint32_t drop)
 223 {
 224         uint32_t i, n;
 225         void *dp;
 226         uint64_t rc[num];
 227
 228         n = 0;
 229         for (i = 0; i != num; i++) {
 230                 dp = rte_pktmbuf_mtod(mb[i], void *);
 231                 rc[i] = jit->func(dp);
 232                 n += (rc[i] == 0);
 233         }
 234
 235         if (n != 0)
 236                 num = apply_filter(mb, rc, num, drop);
 237
 238         return num;
 239 }
 240
 241 static inline uint32_t
 242 pkt_filter_mb_vm(const struct rte_bpf *bpf, struct rte_mbuf *mb[], uint32_t num,
 243         uint32_t drop)
 244 {
 245         uint64_t rc[num];
 246
 247         rte_bpf_exec_burst(bpf, (void **)mb, rc, num);
 248         return apply_filter(mb, rc, num, drop);
 249 }
 250
 251 static inline uint32_t
 252 pkt_filter_mb_jit(const struct rte_bpf_jit *jit, struct rte_mbuf *mb[],
 253         uint32_t num, uint32_t drop)
 254 {
 255         uint32_t i, n;
 256         uint64_t rc[num];
 257
 258         n = 0;
 259         for (i = 0; i != num; i++) {
 260                 rc[i] = jit->func(mb[i]);
 261                 n += (rc[i] == 0);
 262         }
 263
 264         if (n != 0)
 265                 num = apply_filter(mb, rc, num, drop);
 266
 267         return num;
 268 }
 269
 270 /*
 271  * RX/TX callbacks for raw data bpf.
 272  */
 273
 274 static uint16_t
 275 bpf_rx_callback_vm(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 276         struct rte_mbuf *pkt[], uint16_t nb_pkts,
 277         __rte_unused uint16_t max_pkts, void *user_param)
 278 {
 279         struct bpf_eth_cbi *cbi;
 280         uint16_t rc;
 281
 282         cbi = user_param;
 283
 284         bpf_eth_cbi_inuse(cbi);
 285         rc = (cbi->cb != NULL) ?
 286                 pkt_filter_vm(cbi->bpf, pkt, nb_pkts, 1) :
 287                 nb_pkts;
 288         bpf_eth_cbi_unuse(cbi);
 289         return rc;
 290 }
 291
 292 static uint16_t
 293 bpf_rx_callback_jit(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 294         struct rte_mbuf *pkt[], uint16_t nb_pkts,
 295         __rte_unused uint16_t max_pkts, void *user_param)
 296 {
 297         struct bpf_eth_cbi *cbi;
 298         uint16_t rc;
 299
 300         cbi = user_param;
 301         bpf_eth_cbi_inuse(cbi);
 302         rc = (cbi->cb != NULL) ?
 303                 pkt_filter_jit(&cbi->jit, pkt, nb_pkts, 1) :
 304                 nb_pkts;
 305         bpf_eth_cbi_unuse(cbi);
 306         return rc;
 307 }
 308
 309 static uint16_t
 310 bpf_tx_callback_vm(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 311         struct rte_mbuf *pkt[], uint16_t nb_pkts, void *user_param)
 312 {
 313         struct bpf_eth_cbi *cbi;
 314         uint16_t rc;
 315
 316         cbi = user_param;
 317         bpf_eth_cbi_inuse(cbi);
 318         rc = (cbi->cb != NULL) ?
 319                 pkt_filter_vm(cbi->bpf, pkt, nb_pkts, 0) :
 320                 nb_pkts;
 321         bpf_eth_cbi_unuse(cbi);
 322         return rc;
 323 }
 324
 325 static uint16_t
 326 bpf_tx_callback_jit(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 327         struct rte_mbuf *pkt[], uint16_t nb_pkts, void *user_param)
 328 {
 329         struct bpf_eth_cbi *cbi;
 330         uint16_t rc;
 331
 332         cbi = user_param;
 333         bpf_eth_cbi_inuse(cbi);
 334         rc = (cbi->cb != NULL) ?
 335                 pkt_filter_jit(&cbi->jit, pkt, nb_pkts, 0) :
 336                 nb_pkts;
 337         bpf_eth_cbi_unuse(cbi);
 338         return rc;
 339 }
 340
 341 /*
 342  * RX/TX callbacks for mbuf.
 343  */
 344
 345 static uint16_t
 346 bpf_rx_callback_mb_vm(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 347         struct rte_mbuf *pkt[], uint16_t nb_pkts,
 348         __rte_unused uint16_t max_pkts, void *user_param)
 349 {
 350         struct bpf_eth_cbi *cbi;
 351         uint16_t rc;
 352
 353         cbi = user_param;
 354         bpf_eth_cbi_inuse(cbi);
 355         rc = (cbi->cb != NULL) ?
 356                 pkt_filter_mb_vm(cbi->bpf, pkt, nb_pkts, 1) :
 357                 nb_pkts;
 358         bpf_eth_cbi_unuse(cbi);
 359         return rc;
 360 }
 361
 362 static uint16_t
 363 bpf_rx_callback_mb_jit(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 364         struct rte_mbuf *pkt[], uint16_t nb_pkts,
 365         __rte_unused uint16_t max_pkts, void *user_param)
 366 {
 367         struct bpf_eth_cbi *cbi;
 368         uint16_t rc;
 369
 370         cbi = user_param;
 371         bpf_eth_cbi_inuse(cbi);
 372         rc = (cbi->cb != NULL) ?
 373                 pkt_filter_mb_jit(&cbi->jit, pkt, nb_pkts, 1) :
 374                 nb_pkts;
 375         bpf_eth_cbi_unuse(cbi);
 376         return rc;
 377 }
 378
 379 static uint16_t
 380 bpf_tx_callback_mb_vm(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 381         struct rte_mbuf *pkt[], uint16_t nb_pkts, void *user_param)
 382 {
 383         struct bpf_eth_cbi *cbi;
 384         uint16_t rc;
 385
 386         cbi = user_param;
 387         bpf_eth_cbi_inuse(cbi);
 388         rc = (cbi->cb != NULL) ?
 389                 pkt_filter_mb_vm(cbi->bpf, pkt, nb_pkts, 0) :
 390                 nb_pkts;
 391         bpf_eth_cbi_unuse(cbi);
 392         return rc;
 393 }
 394
 395 static uint16_t
 396 bpf_tx_callback_mb_jit(__rte_unused uint16_t port, __rte_unused uint16_t queue,
 397         struct rte_mbuf *pkt[], uint16_t nb_pkts, void *user_param)
 398 {
 399         struct bpf_eth_cbi *cbi;
 400         uint16_t rc;
 401
 402         cbi = user_param;
 403         bpf_eth_cbi_inuse(cbi);
 404         rc = (cbi->cb != NULL) ?
 405                 pkt_filter_mb_jit(&cbi->jit, pkt, nb_pkts, 0) :
 406                 nb_pkts;
 407         bpf_eth_cbi_unuse(cbi);
 408         return rc;
 409 }
 410
 411 static rte_rx_callback_fn
 412 select_rx_callback(enum rte_bpf_arg_type type, uint32_t flags)
 413 {
 414         if (flags & RTE_BPF_ETH_F_JIT) {
 415                 if (type == RTE_BPF_ARG_PTR)
 416                         return bpf_rx_callback_jit;
 417                 else if (type == RTE_BPF_ARG_PTR_MBUF)
 418                         return bpf_rx_callback_mb_jit;
 419         } else if (type == RTE_BPF_ARG_PTR)
 420                 return bpf_rx_callback_vm;
 421         else if (type == RTE_BPF_ARG_PTR_MBUF)
 422                 return bpf_rx_callback_mb_vm;
 423
 424         return NULL;
 425 }
 426
 427 static rte_tx_callback_fn
 428 select_tx_callback(enum rte_bpf_arg_type type, uint32_t flags)
 429 {
 430         if (flags & RTE_BPF_ETH_F_JIT) {
 431                 if (type == RTE_BPF_ARG_PTR)
 432                         return bpf_tx_callback_jit;
 433                 else if (type == RTE_BPF_ARG_PTR_MBUF)
 434                         return bpf_tx_callback_mb_jit;
 435         } else if (type == RTE_BPF_ARG_PTR)
 436                 return bpf_tx_callback_vm;
 437         else if (type == RTE_BPF_ARG_PTR_MBUF)
 438                 return bpf_tx_callback_mb_vm;
 439
 440         return NULL;
 441 }
 442
 443 /*
 444  * helper function to perform BPF unload for given port/queue.
 445  * have to introduce extra complexity (and possible slowdown) here,
 446  * as right now there is no safe generic way to remove RX/TX callback
 447  * while IO is active.
 448  * Still don't free memory allocated for callback handle itself,
 449  * again right now there is no safe way to do that without stopping RX/TX
 450  * on given port/queue first.
 451  */
 452 static void
 453 bpf_eth_cbi_unload(struct bpf_eth_cbi *bc)
 454 {
 455         /* mark this cbi as empty */
 456         bc->cb = NULL;
 457         rte_smp_mb();
 458
 459         /* make sure datapath doesn't use bpf anymore, then destroy bpf */
 460         bpf_eth_cbi_wait(bc);
 461         rte_bpf_destroy(bc->bpf);
 462         bpf_eth_cbi_cleanup(bc);
 463 }
 464
 465 static void
 466 bpf_eth_unload(struct bpf_eth_cbh *cbh, uint16_t port, uint16_t queue)
 467 {
 468         struct bpf_eth_cbi *bc;
 469
 470         bc = bpf_eth_cbh_find(cbh, port, queue);
 471         if (bc == NULL || bc->cb == NULL)
 472                 return;
 473
 474         if (cbh->type == BPF_ETH_RX)
 475                 rte_eth_remove_rx_callback(port, queue, bc->cb);
 476         else
 477                 rte_eth_remove_tx_callback(port, queue, bc->cb);
 478
 479         bpf_eth_cbi_unload(bc);
 480 }
 481
 482
 483 void
 484 rte_bpf_eth_rx_unload(uint16_t port, uint16_t queue)
 485 {
 486         struct bpf_eth_cbh *cbh;
 487
 488         cbh = &rx_cbh;
 489         rte_spinlock_lock(&cbh->lock);
 490         bpf_eth_unload(cbh, port, queue);
 491         rte_spinlock_unlock(&cbh->lock);
 492 }
 493
 494 void
 495 rte_bpf_eth_tx_unload(uint16_t port, uint16_t queue)
 496 {
 497         struct bpf_eth_cbh *cbh;
 498
 499         cbh = &tx_cbh;
 500         rte_spinlock_lock(&cbh->lock);
 501         bpf_eth_unload(cbh, port, queue);
 502         rte_spinlock_unlock(&cbh->lock);
 503 }
 504
 505 static int
 506 bpf_eth_elf_load(struct bpf_eth_cbh *cbh, uint16_t port, uint16_t queue,
 507         const struct rte_bpf_prm *prm, const char *fname, const char *sname,
 508         uint32_t flags)
 509 {
 510         int32_t rc;
 511         struct bpf_eth_cbi *bc;
 512         struct rte_bpf *bpf;
 513         rte_rx_callback_fn frx;
 514         rte_tx_callback_fn ftx;
 515         struct rte_bpf_jit jit;
 516
 517         frx = NULL;
 518         ftx = NULL;
 519
 520         if (prm == NULL || rte_eth_dev_is_valid_port(port) == 0 ||
 521                         queue >= RTE_MAX_QUEUES_PER_PORT)
 522                 return -EINVAL;
 523
 524         if (cbh->type == BPF_ETH_RX)
 525                 frx = select_rx_callback(prm->prog_arg.type, flags);
 526         else
 527                 ftx = select_tx_callback(prm->prog_arg.type, flags);
 528
 529         if (frx == NULL && ftx == NULL) {
 530                 RTE_BPF_LOG(ERR, "%s(%u, %u): no callback selected;\n",
 531                         __func__, port, queue);
 532                 return -EINVAL;
 533         }
 534
 535         bpf = rte_bpf_elf_load(prm, fname, sname);
 536         if (bpf == NULL)
 537                 return -rte_errno;
 538
 539         rte_bpf_get_jit(bpf, &jit);
 540
 541         if ((flags & RTE_BPF_ETH_F_JIT) != 0 && jit.func == NULL) {
 542                 RTE_BPF_LOG(ERR, "%s(%u, %u): no JIT generated;\n",
 543                         __func__, port, queue);
 544                 rte_bpf_destroy(bpf);
 545                 return -ENOTSUP;
 546         }
 547
 548         /* setup/update global callback info */
 549         bc = bpf_eth_cbh_add(cbh, port, queue);
 550         if (bc == NULL)
 551                 return -ENOMEM;
 552
 553         /* remove old one, if any */
 554         if (bc->cb != NULL)
 555                 bpf_eth_unload(cbh, port, queue);
 556
 557         bc->bpf = bpf;
 558         bc->jit = jit;
 559
 560         if (cbh->type == BPF_ETH_RX)
 561                 bc->cb = rte_eth_add_rx_callback(port, queue, frx, bc);
 562         else
 563                 bc->cb = rte_eth_add_tx_callback(port, queue, ftx, bc);
 564
 565         if (bc->cb == NULL) {
 566                 rc = -rte_errno;
 567                 rte_bpf_destroy(bpf);
 568                 bpf_eth_cbi_cleanup(bc);
 569         } else
 570                 rc = 0;
 571
 572         return rc;
 573 }
 574
 575 int
 576 rte_bpf_eth_rx_elf_load(uint16_t port, uint16_t queue,
 577         const struct rte_bpf_prm *prm, const char *fname, const char *sname,
 578         uint32_t flags)
 579 {
 580         int32_t rc;
 581         struct bpf_eth_cbh *cbh;
 582
 583         cbh = &rx_cbh;
 584         rte_spinlock_lock(&cbh->lock);
 585         rc = bpf_eth_elf_load(cbh, port, queue, prm, fname, sname, flags);
 586         rte_spinlock_unlock(&cbh->lock);
 587
 588         return rc;
 589 }
 590
 591 int
 592 rte_bpf_eth_tx_elf_load(uint16_t port, uint16_t queue,
 593         const struct rte_bpf_prm *prm, const char *fname, const char *sname,
 594         uint32_t flags)
 595 {
 596         int32_t rc;
 597         struct bpf_eth_cbh *cbh;
 598
 599         cbh = &tx_cbh;
 600         rte_spinlock_lock(&cbh->lock);
 601         rc = bpf_eth_elf_load(cbh, port, queue, prm, fname, sname, flags);
 602         rte_spinlock_unlock(&cbh->lock);
 603
 604         return rc;
 605 }