sys/net/netmap/netmap_generic.c

   1 /*
   2  * Copyright (C) 2013 Universita` di Pisa. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *   1. Redistributions of source code must retain the above copyright
   8  *      notice, this list of conditions and the following disclaimer.
   9  *   2. Redistributions in binary form must reproduce the above copyright
  10  *      notice, this list of conditions and the following disclaimer in the
  11  *      documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 /*
  27  * This module implements netmap support on top of standard,
  28  * unmodified device drivers.
  29  *
  30  * A NIOCREGIF request is handled here if the device does not
  31  * have native support. TX and RX rings are emulated as follows:
  32  *
  33  * NIOCREGIF
  34  *      We preallocate a block of TX mbufs (roughly as many as
  35  *      tx descriptors; the number is not critical) to speed up
  36  *      operation during transmissions. The refcount on most of
  37  *      these buffers is artificially bumped up so we can recycle
  38  *      them more easily. Also, the destructor is intercepted
  39  *      so we use it as an interrupt notification to wake up
  40  *      processes blocked on a poll().
  41  *
  42  *      For each receive ring we allocate one "struct mbq"
  43  *      (an mbuf tailq plus a spinlock). We intercept packets
  44  *      (through if_input)
  45  *      on the receive path and put them in the mbq from which
  46  *      netmap receive routines can grab them.
  47  *
  48  * TX:
  49  *      in the generic_txsync() routine, netmap buffers are copied
  50  *      (or linked, in a future) to the preallocated mbufs
  51  *      and pushed to the transmit queue. Some of these mbufs
  52  *      (those with NS_REPORT, or otherwise every half ring)
  53  *      have the refcount=1, others have refcount=2.
  54  *      When the destructor is invoked, we take that as
  55  *      a notification that all mbufs up to that one in
  56  *      the specific ring have been completed, and generate
  57  *      the equivalent of a transmit interrupt.
  58  *
  59  * RX:
  60  *
  61  */
  62
  63 /* __FBSDID("$FreeBSD: head/sys/dev/netmap/netmap.c 257666 2013-11-05 01:06:22Z luigi $"); */
  64
  65 #include <sys/types.h>
  66 #include <sys/errno.h>
  67 #include <sys/malloc.h>
  68 #include <sys/lock.h>   /* PROT_EXEC */
  69 #include <sys/socket.h> /* sockaddrs */
  70 #include <sys/event.h>
  71 #include <net/if.h>
  72 #include <net/if_var.h>
  73 #include <sys/bus.h>        /* bus_dmamap_* in netmap_kern.h */
  74
  75 // XXX temporary - D() defined here
  76 #include <net/netmap.h>
  77 #include "netmap_kern.h"
  78 #include "netmap_mem2.h"
  79
  80 #define rtnl_lock() D("rtnl_lock called");
  81 #define rtnl_unlock() D("rtnl_lock called");
  82 #define MBUF_TXQ(m)     ((m)->m_pkthdr.hash)
  83 #define smp_mb()
  84
  85 /*
  86  * mbuf wrappers
  87  */
  88
  89 /*
  90  * we allocate an EXT_PACKET
  91  */
  92 #define netmap_get_mbuf(len) m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR)
  93
  94 /* mbuf destructor, also need to change the type to EXT_EXTREF,
  95  * add an M_NOFREE flag, and then clear the flag and
  96  * chain into uma_zfree(zone_pack, mf)
  97  * (or reinstall the buffer ?)
  98  */
  99 #define SET_MBUF_DESTRUCTOR(m, fn)      do {            \
 100                 (m)->m_ext.ext_free = (void *)fn;       \
 101                 /* (m)->m_ext.ext_type = EXT_EXTREF; */ \
 102         } while (0)
 103
 104
 105 #define GET_MBUF_REFCNT(m)      ((m)->m_ext.ref_cnt ? *(m)->m_ext.ref_cnt : -1)
 106
 107 /* ======================== usage stats =========================== */
 108
 109 #ifdef RATE
 110 #define IFRATE(x) x
 111 struct rate_stats {
 112     unsigned long txpkt;
 113     unsigned long txsync;
 114     unsigned long txirq;
 115     unsigned long rxpkt;
 116     unsigned long rxirq;
 117     unsigned long rxsync;
 118 };
 119
 120 struct rate_context {
 121     unsigned refcount;
 122     struct timer_list timer;
 123     struct rate_stats new;
 124     struct rate_stats old;
 125 };
 126
 127 #define RATE_PRINTK(_NAME_) \
 128     printk( #_NAME_ " = %lu Hz\n", (cur._NAME_ - ctx->old._NAME_)/RATE_PERIOD);
 129 #define RATE_PERIOD  2
 130 static void rate_callback(unsigned long arg)
 131 {
 132     struct rate_context * ctx = (struct rate_context *)arg;
 133     struct rate_stats cur = ctx->new;
 134     int r;
 135
 136     RATE_PRINTK(txpkt);
 137     RATE_PRINTK(txsync);
 138     RATE_PRINTK(txirq);
 139     RATE_PRINTK(rxpkt);
 140     RATE_PRINTK(rxsync);
 141     RATE_PRINTK(rxirq);
 142     printk("\n");
 143
 144     ctx->old = cur;
 145     r = mod_timer(&ctx->timer, jiffies +
 146                                 msecs_to_jiffies(RATE_PERIOD * 1000));
 147     if (unlikely(r))
 148         D("[v1000] Error: mod_timer()");
 149 }
 150
 151 static struct rate_context rate_ctx;
 152
 153 #else /* !RATE */
 154 #define IFRATE(x)
 155 #endif /* !RATE */
 156
 157
 158 /* =============== GENERIC NETMAP ADAPTER SUPPORT ================= */
 159 #define GENERIC_BUF_SIZE        netmap_buf_size    /* Size of the mbufs in the Tx pool. */
 160
 161 /*
 162  * Wrapper used by the generic adapter layer to notify
 163  * the poller threads. Differently from netmap_rx_irq(), we check
 164  * only IFCAP_NETMAP instead of NAF_NATIVE_ON to enable the irq.
 165  */
 166 static int
 167 netmap_generic_irq(struct ifnet *ifp, u_int q, u_int *work_done)
 168 {
 169         if (unlikely(!(ifp->if_capenable & IFCAP_NETMAP)))
 170                 return 0;
 171
 172         return netmap_common_irq(ifp, q, work_done);
 173 }
 174
 175
 176 /* Enable/disable netmap mode for a generic network interface. */
 177 int generic_netmap_register(struct netmap_adapter *na, int enable)
 178 {
 179     struct ifnet *ifp = na->ifp;
 180     struct netmap_generic_adapter *gna = (struct netmap_generic_adapter *)na;
 181     struct mbuf *m;
 182     int error;
 183     int i, r;
 184
 185     if (!na)
 186         return EINVAL;
 187
 188 #ifdef REG_RESET
 189     error = ifp->netdev_ops->ndo_stop(ifp);
 190     if (error) {
 191         return error;
 192     }
 193 #endif /* REG_RESET */
 194
 195     if (enable) { /* Enable netmap mode. */
 196         /* Initialize the rx queue, as generic_rx_handler() can
 197          * be called as soon as netmap_catch_rx() returns.
 198          */
 199         for (r=0; r<na->num_rx_rings; r++) {
 200             mbq_safe_init(&na->rx_rings[r].rx_queue);
 201             na->rx_rings[r].nr_ntc = 0;
 202         }
 203
 204         /* Init the mitigation timer. */
 205         netmap_mitigation_init(gna);
 206
 207         /*
 208          * Preallocate packet buffers for the tx rings.
 209          */
 210         for (r=0; r<na->num_tx_rings; r++) {
 211             na->tx_rings[r].nr_ntc = 0;
 212             na->tx_rings[r].tx_pool = kmalloc(na->num_tx_desc * sizeof(struct mbuf *),
 213                                     M_DEVBUF, M_NOWAIT | M_ZERO);
 214             if (!na->tx_rings[r].tx_pool) {
 215                 D("tx_pool allocation failed");
 216                 error = ENOMEM;
 217                 goto free_tx_pool;
 218             }
 219             for (i=0; i<na->num_tx_desc; i++) {
 220                 m = netmap_get_mbuf(GENERIC_BUF_SIZE);
 221                 if (!m) {
 222                     D("tx_pool[%d] allocation failed", i);
 223                     error = ENOMEM;
 224                     goto free_mbufs;
 225                 }
 226                 na->tx_rings[r].tx_pool[i] = m;
 227             }
 228         }
 229         rtnl_lock();
 230         /* Prepare to intercept incoming traffic. */
 231         error = netmap_catch_rx(na, 1);
 232         if (error) {
 233             D("netdev_rx_handler_register() failed");
 234             goto register_handler;
 235         }
 236         ifp->if_capenable |= IFCAP_NETMAP;
 237
 238         /* Make netmap control the packet steering. */
 239         netmap_catch_packet_steering(gna, 1);
 240
 241         rtnl_unlock();
 242
 243 #ifdef RATE
 244         if (rate_ctx.refcount == 0) {
 245             D("setup_timer()");
 246             memset(&rate_ctx, 0, sizeof(rate_ctx));
 247             setup_timer(&rate_ctx.timer, &rate_callback, (unsigned long)&rate_ctx);
 248             if (mod_timer(&rate_ctx.timer, jiffies + msecs_to_jiffies(1500))) {
 249                 D("Error: mod_timer()");
 250             }
 251         }
 252         rate_ctx.refcount++;
 253 #endif /* RATE */
 254
 255     } else { /* Disable netmap mode. */
 256         rtnl_lock();
 257
 258         ifp->if_capenable &= ~IFCAP_NETMAP;
 259
 260         /* Release packet steering control. */
 261         netmap_catch_packet_steering(gna, 0);
 262
 263         /* Do not intercept packets on the rx path. */
 264         netmap_catch_rx(na, 0);
 265
 266         rtnl_unlock();
 267
 268         /* Free the mbufs going to the netmap rings */
 269         for (r=0; r<na->num_rx_rings; r++) {
 270             mbq_safe_purge(&na->rx_rings[r].rx_queue);
 271             mbq_safe_destroy(&na->rx_rings[r].rx_queue);
 272         }
 273
 274         netmap_mitigation_cleanup(gna);
 275
 276         for (r=0; r<na->num_tx_rings; r++) {
 277             for (i=0; i<na->num_tx_desc; i++) {
 278                 m_freem(na->tx_rings[r].tx_pool[i]);
 279             }
 280             kfree(na->tx_rings[r].tx_pool, M_DEVBUF);
 281         }
 282
 283 #ifdef RATE
 284         if (--rate_ctx.refcount == 0) {
 285             D("del_timer()");
 286             del_timer(&rate_ctx.timer);
 287         }
 288 #endif
 289     }
 290
 291 #ifdef REG_RESET
 292     error = ifp->netdev_ops->ndo_open(ifp);
 293     if (error) {
 294         goto alloc_tx_pool;
 295     }
 296 #endif
 297
 298     return 0;
 299
 300 register_handler:
 301     rtnl_unlock();
 302 free_tx_pool:
 303     r--;
 304     i = na->num_tx_desc;  /* Useless, but just to stay safe. */
 305 free_mbufs:
 306     i--;
 307     for (; r>=0; r--) {
 308         for (; i>=0; i--) {
 309             m_freem(na->tx_rings[r].tx_pool[i]);
 310         }
 311         kfree(na->tx_rings[r].tx_pool, M_DEVBUF);
 312         i = na->num_tx_desc - 1;
 313     }
 314
 315     return error;
 316 }
 317
 318 /*
 319  * Callback invoked when the device driver frees an mbuf used
 320  * by netmap to transmit a packet. This usually happens when
 321  * the NIC notifies the driver that transmission is completed.
 322  */
 323 static void
 324 generic_mbuf_destructor(struct mbuf *m)
 325 {
 326     if (netmap_verbose)
 327             D("Tx irq (%p) queue %d", m, MBUF_TXQ(m));
 328     netmap_generic_irq(MBUF_IFP(m), MBUF_TXQ(m), NULL);
 329 #if 0
 330     m->m_ext.ext_type = EXT_PACKET;
 331 #endif
 332     m->m_ext.ext_free = NULL;
 333 #if 0
 334     if (*(m->m_ext.ref_cnt) == 0)
 335         *(m->m_ext.ref_cnt) = 1;
 336     uma_zfree(zone_pack, m);
 337 #endif
 338     IFRATE(rate_ctx.new.txirq++);
 339 }
 340
 341 /* Record completed transmissions and update hwavail.
 342  *
 343  * nr_ntc is the oldest tx buffer not yet completed
 344  * (same as nr_hwavail + nr_hwcur + 1),
 345  * nr_hwcur is the first unsent buffer.
 346  * When cleaning, we try to recover buffers between nr_ntc and nr_hwcur.
 347  */
 348 static int
 349 generic_netmap_tx_clean(struct netmap_kring *kring)
 350 {
 351     u_int num_slots = kring->nkr_num_slots;
 352     u_int ntc = kring->nr_ntc;
 353     u_int hwcur = kring->nr_hwcur;
 354     u_int n = 0;
 355     struct mbuf **tx_pool = kring->tx_pool;
 356
 357     while (ntc != hwcur) { /* buffers not completed */
 358         struct mbuf *m = tx_pool[ntc];
 359
 360         if (unlikely(m == NULL)) {
 361             /* try to replenish the entry */
 362             tx_pool[ntc] = m = netmap_get_mbuf(GENERIC_BUF_SIZE);
 363             if (unlikely(m == NULL)) {
 364                 D("mbuf allocation failed, XXX error");
 365                 // XXX how do we proceed ? break ?
 366                 return -ENOMEM;
 367             }
 368 #if 0
 369         } else if (GET_MBUF_REFCNT(m) != 1) {
 370             break; /* This mbuf is still busy: its refcnt is 2. */
 371 #endif
 372         }
 373         if (unlikely(++ntc == num_slots)) {
 374             ntc = 0;
 375         }
 376         n++;
 377     }
 378     kring->nr_ntc = ntc;
 379     kring->nr_hwavail += n;
 380     ND("tx completed [%d] -> hwavail %d", n, kring->nr_hwavail);
 381
 382     return n;
 383 }
 384
 385
 386 /*
 387  * We have pending packets in the driver between nr_ntc and j.
 388  * Compute a position in the middle, to be used to generate
 389  * a notification.
 390  */
 391 static inline u_int
 392 generic_tx_event_middle(struct netmap_kring *kring, u_int hwcur)
 393 {
 394     u_int n = kring->nkr_num_slots;
 395     u_int ntc = kring->nr_ntc;
 396     u_int e;
 397
 398     if (hwcur >= ntc) {
 399         e = (hwcur + ntc) / 2;
 400     } else { /* wrap around */
 401         e = (hwcur + n + ntc) / 2;
 402         if (e >= n) {
 403             e -= n;
 404         }
 405     }
 406
 407     if (unlikely(e >= n)) {
 408         D("This cannot happen");
 409         e = 0;
 410     }
 411
 412     return e;
 413 }
 414
 415 /*
 416  * We have pending packets in the driver between nr_ntc and hwcur.
 417  * Schedule a notification approximately in the middle of the two.
 418  * There is a race but this is only called within txsync which does
 419  * a double check.
 420  */
 421 static void
 422 generic_set_tx_event(struct netmap_kring *kring, u_int hwcur)
 423 {
 424     struct mbuf *m;
 425     u_int e;
 426
 427     if (kring->nr_ntc == hwcur) {
 428         return;
 429     }
 430     e = generic_tx_event_middle(kring, hwcur);
 431
 432     m = kring->tx_pool[e];
 433     if (m == NULL) {
 434         /* This can happen if there is already an event on the netmap
 435            slot 'e': There is nothing to do. */
 436         return;
 437     }
 438     ND("Event at %d mbuf %p refcnt %d", e, m, GET_MBUF_REFCNT(m));
 439     kring->tx_pool[e] = NULL;
 440     SET_MBUF_DESTRUCTOR(m, generic_mbuf_destructor);
 441
 442     // XXX wmb() ?
 443     /* Decrement the refcount an free it if we have the last one. */
 444     m_freem(m);
 445     smp_mb();
 446 }
 447
 448
 449 /*
 450  * generic_netmap_txsync() transforms netmap buffers into mbufs
 451  * and passes them to the standard device driver
 452  * (ndo_start_xmit() or ifp->if_transmit() ).
 453  * On linux this is not done directly, but using dev_queue_xmit(),
 454  * since it implements the TX flow control (and takes some locks).
 455  */
 456 static int
 457 generic_netmap_txsync(struct netmap_adapter *na, u_int ring_nr, int flags)
 458 {
 459     struct ifnet *ifp = na->ifp;
 460     struct netmap_kring *kring = &na->tx_rings[ring_nr];
 461     struct netmap_ring *ring = kring->ring;
 462     u_int j, k, num_slots = kring->nkr_num_slots;
 463     int new_slots, ntx;
 464
 465     IFRATE(rate_ctx.new.txsync++);
 466
 467     // TODO: handle the case of mbuf allocation failure
 468     /* first, reclaim completed buffers */
 469     generic_netmap_tx_clean(kring);
 470
 471     /* Take a copy of ring->cur now, and never read it again. */
 472     k = ring->cur;
 473     if (unlikely(k >= num_slots)) {
 474         return netmap_ring_reinit(kring);
 475     }
 476
 477     rmb();
 478     j = kring->nr_hwcur;
 479     /*
 480     * 'new_slots' counts how many new slots have been added:
 481      * everything from hwcur to cur, excluding reserved ones, if any.
 482      * nr_hwreserved start from hwcur and counts how many slots were
 483      * not sent to the NIC from the previous round.
 484      */
 485     new_slots = k - j - kring->nr_hwreserved;
 486     if (new_slots < 0) {
 487         new_slots += num_slots;
 488     }
 489     ntx = 0;
 490     if (j != k) {
 491         /* Process new packets to send:
 492          * j is the current index in the netmap ring.
 493          */
 494         while (j != k) {
 495             struct netmap_slot *slot = &ring->slot[j]; /* Current slot in the netmap ring */
 496             void *addr = NMB(slot);
 497             u_int len = slot->len;
 498             struct mbuf *m;
 499             int tx_ret;
 500
 501             if (unlikely(addr == netmap_buffer_base || len > NETMAP_BUF_SIZE)) {
 502                 return netmap_ring_reinit(kring);
 503             }
 504             /* Tale a mbuf from the tx pool and copy in the user packet. */
 505             m = kring->tx_pool[j];
 506             if (unlikely(!m)) {
 507                 RD(5, "This should never happen");
 508                 kring->tx_pool[j] = m = netmap_get_mbuf(GENERIC_BUF_SIZE);
 509                 if (unlikely(m == NULL)) {
 510                     D("mbuf allocation failed");
 511                     break;
 512                 }
 513             }
 514             /* XXX we should ask notifications when NS_REPORT is set,
 515              * or roughly every half frame. We can optimize this
 516              * by lazily requesting notifications only when a
 517              * transmission fails. Probably the best way is to
 518              * break on failures and set notifications when
 519              * ring->avail == 0 || j != k
 520              */
 521             tx_ret = generic_xmit_frame(ifp, m, addr, len, ring_nr);
 522             if (unlikely(tx_ret)) {
 523                 RD(5, "start_xmit failed: err %d [%u,%u,%u,%u]",
 524                         tx_ret, kring->nr_ntc, j, k, kring->nr_hwavail);
 525                 /*
 526                  * No room for this mbuf in the device driver.
 527                  * Request a notification FOR A PREVIOUS MBUF,
 528                  * then call generic_netmap_tx_clean(kring) to do the
 529                  * double check and see if we can free more buffers.
 530                  * If there is space continue, else break;
 531                  * NOTE: the double check is necessary if the problem
 532                  * occurs in the txsync call after selrecord().
 533                  * Also, we need some way to tell the caller that not
 534                  * all buffers were queued onto the device (this was
 535                  * not a problem with native netmap driver where space
 536                  * is preallocated). The bridge has a similar problem
 537                  * and we solve it there by dropping the excess packets.
 538                  */
 539                 generic_set_tx_event(kring, j);
 540                 if (generic_netmap_tx_clean(kring)) { /* space now available */
 541                     continue;
 542                 } else {
 543                     break;
 544                 }
 545             }
 546             slot->flags &= ~(NS_REPORT | NS_BUF_CHANGED);
 547             if (unlikely(++j == num_slots))
 548                 j = 0;
 549             ntx++;
 550         }
 551
 552         /* Update hwcur to the next slot to transmit. */
 553         kring->nr_hwcur = j;
 554
 555         /*
 556          * Report all new slots as unavailable, even those not sent.
 557          * We account for them with with hwreserved, so that
 558          * nr_hwreserved =:= cur - nr_hwcur
 559          */
 560         kring->nr_hwavail -= new_slots;
 561         kring->nr_hwreserved = k - j;
 562         if (kring->nr_hwreserved < 0) {
 563             kring->nr_hwreserved += num_slots;
 564         }
 565
 566         IFRATE(rate_ctx.new.txpkt += ntx);
 567
 568         if (!kring->nr_hwavail) {
 569             /* No more available slots? Set a notification event
 570              * on a netmap slot that will be cleaned in the future.
 571              * No doublecheck is performed, since txsync() will be
 572              * called twice by netmap_poll().
 573              */
 574             generic_set_tx_event(kring, j);
 575         }
 576         ND("tx #%d, hwavail = %d", n, kring->nr_hwavail);
 577     }
 578
 579     /* Synchronize the user's view to the kernel view. */
 580     ring->avail = kring->nr_hwavail;
 581     ring->reserved = kring->nr_hwreserved;
 582
 583     return 0;
 584 }
 585
 586 /*
 587  * This handler is registered (through netmap_catch_rx())
 588  * within the attached network interface
 589  * in the RX subsystem, so that every mbuf passed up by
 590  * the driver can be stolen to the network stack.
 591  * Stolen packets are put in a queue where the
 592  * generic_netmap_rxsync() callback can extract them.
 593  */
 594 void generic_rx_handler(struct ifnet *ifp, struct mbuf *m)
 595 {
 596     struct netmap_adapter *na = NA(ifp);
 597     struct netmap_generic_adapter *gna = (struct netmap_generic_adapter *)na;
 598     u_int work_done;
 599     u_int rr = 0; // receive ring number
 600
 601     ND("called");
 602     /* limit the size of the queue */
 603     if (unlikely(mbq_len(&na->rx_rings[rr].rx_queue) > 1024)) {
 604         m_freem(m);
 605     } else {
 606         mbq_safe_enqueue(&na->rx_rings[rr].rx_queue, m);
 607     }
 608
 609     if (netmap_generic_mit < 32768) {
 610         /* no rx mitigation, pass notification up */
 611         netmap_generic_irq(na->ifp, rr, &work_done);
 612         IFRATE(rate_ctx.new.rxirq++);
 613     } else {
 614         /* same as send combining, filter notification if there is a
 615          * pending timer, otherwise pass it up and start a timer.
 616          */
 617         if (likely(netmap_mitigation_active(gna))) {
 618             /* Record that there is some pending work. */
 619             gna->mit_pending = 1;
 620         } else {
 621             netmap_generic_irq(na->ifp, rr, &work_done);
 622             IFRATE(rate_ctx.new.rxirq++);
 623             netmap_mitigation_start(gna);
 624         }
 625     }
 626 }
 627
 628 /*
 629  * generic_netmap_rxsync() extracts mbufs from the queue filled by
 630  * generic_netmap_rx_handler() and puts their content in the netmap
 631  * receive ring.
 632  * Access must be protected because the rx handler is asynchronous,
 633  */
 634 static int
 635 generic_netmap_rxsync(struct netmap_adapter *na, u_int ring_nr, int flags)
 636 {
 637     struct netmap_kring *kring = &na->rx_rings[ring_nr];
 638     struct netmap_ring *ring = kring->ring;
 639     u_int j, n, lim = kring->nkr_num_slots - 1;
 640     int force_update = (flags & NAF_FORCE_READ) || kring->nr_kflags & NKR_PENDINTR;
 641     u_int k, resvd = ring->reserved;
 642
 643     if (ring->cur > lim)
 644         return netmap_ring_reinit(kring);
 645
 646     /* Import newly received packets into the netmap ring. */
 647     if (netmap_no_pendintr || force_update) {
 648         uint16_t slot_flags = kring->nkr_slot_flags;
 649         struct mbuf *m;
 650
 651         n = 0;
 652         j = kring->nr_ntc; /* first empty slot in the receive ring */
 653         /* extract buffers from the rx queue, stop at most one
 654          * slot before nr_hwcur (index k)
 655          */
 656         k = (kring->nr_hwcur) ? kring->nr_hwcur-1 : lim;
 657         while (j != k) {
 658             int len;
 659             void *addr = NMB(&ring->slot[j]);
 660
 661             if (addr == netmap_buffer_base) { /* Bad buffer */
 662                 return netmap_ring_reinit(kring);
 663             }
 664             /*
 665              * Call the locked version of the function.
 666              *  XXX Ideally we could grab a batch of mbufs at once,
 667              * by changing rx_queue into a ring.
 668              */
 669             m = mbq_safe_dequeue(&kring->rx_queue);
 670             if (!m)
 671                 break;
 672             len = MBUF_LEN(m);
 673             m_copydata(m, 0, len, addr);
 674             ring->slot[j].len = len;
 675             ring->slot[j].flags = slot_flags;
 676             m_freem(m);
 677             if (unlikely(j++ == lim))
 678                 j = 0;
 679             n++;
 680         }
 681         if (n) {
 682             kring->nr_ntc = j;
 683             kring->nr_hwavail += n;
 684             IFRATE(rate_ctx.new.rxpkt += n);
 685         }
 686         kring->nr_kflags &= ~NKR_PENDINTR;
 687     }
 688
 689     // XXX should we invert the order ?
 690     /* Skip past packets that userspace has released */
 691     j = kring->nr_hwcur;
 692     k = ring->cur;
 693     if (resvd > 0) {
 694         if (resvd + ring->avail >= lim + 1) {
 695             D("XXX invalid reserve/avail %d %d", resvd, ring->avail);
 696             ring->reserved = resvd = 0; // XXX panic...
 697         }
 698         k = (k >= resvd) ? k - resvd : k + lim + 1 - resvd;
 699     }
 700     if (j != k) {
 701         /* Userspace has released some packets. */
 702         for (n = 0; j != k; n++) {
 703             struct netmap_slot *slot = &ring->slot[j];
 704
 705             slot->flags &= ~NS_BUF_CHANGED;
 706             if (unlikely(j++ == lim))
 707                 j = 0;
 708         }
 709         kring->nr_hwavail -= n;
 710         kring->nr_hwcur = k;
 711     }
 712     /* Tell userspace that there are new packets. */
 713     ring->avail = kring->nr_hwavail - resvd;
 714     IFRATE(rate_ctx.new.rxsync++);
 715
 716     return 0;
 717 }
 718
 719 static void
 720 generic_netmap_dtor(struct netmap_adapter *na)
 721 {
 722     struct ifnet *ifp = na->ifp;
 723     struct netmap_generic_adapter *gna = (struct netmap_generic_adapter*)na;
 724     struct netmap_adapter *prev_na = gna->prev;
 725
 726     if (prev_na != NULL) {
 727         D("Released generic NA %p", gna);
 728 #if 0
 729         if_rele(na->ifp);
 730 #endif
 731         netmap_adapter_put(prev_na);
 732     }
 733     if (ifp != NULL) {
 734         WNA(ifp) = prev_na;
 735         D("Restored native NA %p", prev_na);
 736         na->ifp = NULL;
 737     }
 738 }
 739
 740 /*
 741  * generic_netmap_attach() makes it possible to use netmap on
 742  * a device without native netmap support.
 743  * This is less performant than native support but potentially
 744  * faster than raw sockets or similar schemes.
 745  *
 746  * In this "emulated" mode, netmap rings do not necessarily
 747  * have the same size as those in the NIC. We use a default
 748  * value and possibly override it if the OS has ways to fetch the
 749  * actual configuration.
 750  */
 751 int
 752 generic_netmap_attach(struct ifnet *ifp)
 753 {
 754     struct netmap_adapter *na;
 755     struct netmap_generic_adapter *gna;
 756     int retval;
 757     u_int num_tx_desc, num_rx_desc;
 758
 759     num_tx_desc = num_rx_desc = netmap_generic_ringsize; /* starting point */
 760
 761     generic_find_num_desc(ifp, &num_tx_desc, &num_rx_desc);
 762     ND("Netmap ring size: TX = %d, RX = %d", num_tx_desc, num_rx_desc);
 763
 764     gna = kmalloc(sizeof(*gna), M_DEVBUF, M_NOWAIT | M_ZERO);
 765     if (gna == NULL) {
 766         D("no memory on attach, give up");
 767         return ENOMEM;
 768     }
 769     na = (struct netmap_adapter *)gna;
 770     na->ifp = ifp;
 771     na->num_tx_desc = num_tx_desc;
 772     na->num_rx_desc = num_rx_desc;
 773     na->nm_register = &generic_netmap_register;
 774     na->nm_txsync = &generic_netmap_txsync;
 775     na->nm_rxsync = &generic_netmap_rxsync;
 776     na->nm_dtor = &generic_netmap_dtor;
 777     /* when using generic, IFCAP_NETMAP is set so we force
 778      * NAF_SKIP_INTR to use the regular interrupt handler
 779      */
 780     na->na_flags = NAF_SKIP_INTR;
 781
 782     ND("[GNA] num_tx_queues(%d), real_num_tx_queues(%d), len(%lu)",
 783                 ifp->num_tx_queues, ifp->real_num_tx_queues,
 784                 ifp->tx_queue_len);
 785     ND("[GNA] num_rx_queues(%d), real_num_rx_queues(%d)",
 786                 ifp->num_rx_queues, ifp->real_num_rx_queues);
 787
 788     generic_find_num_queues(ifp, &na->num_tx_rings, &na->num_rx_rings);
 789
 790     retval = netmap_attach_common(na);
 791     if (retval) {
 792         kfree(gna, M_DEVBUF);
 793     }
 794
 795     return retval;
 796 }