extras/deprecated/netmap/net_netmap.h

   1 /*
   2  * Copyright (C) 2011-2014 Matteo Landi, Luigi Rizzo. 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  *
   8  *   1. Redistributions of source code must retain the above copyright
   9  *      notice, this list of conditions and the following disclaimer.
  10  *   2. Redistributions in binary form must reproduce the above copyright
  11  *      notice, this list of conditions and the following disclaimer in the
  12  *      documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``S IS''AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * $FreeBSD: head/sys/net/netmap.h 251139 2013-05-30 14:07:14Z luigi $
  29  *
  30  * Definitions of constants and the structures used by the netmap
  31  * framework, for the part visible to both kernel and userspace.
  32  * Detailed info on netmap is available with "man netmap" or at
  33  *
  34  *      http://info.iet.unipi.it/~luigi/netmap/
  35  *
  36  * This API is also used to communicate with the VALE software switch
  37  */
  38
  39 #ifndef _NET_NETMAP_H_
  40 #define _NET_NETMAP_H_
  41
  42 #define NETMAP_API      11              /* current API version */
  43
  44 #define NETMAP_MIN_API  11              /* min and max versions accepted */
  45 #define NETMAP_MAX_API  15
  46 /*
  47  * Some fields should be cache-aligned to reduce contention.
  48  * The alignment is architecture and OS dependent, but rather than
  49  * digging into OS headers to find the exact value we use an estimate
  50  * that should cover most architectures.
  51  */
  52 #define NM_CACHE_ALIGN  128
  53
  54 /*
  55  * --- Netmap data structures ---
  56  *
  57  * The userspace data structures used by netmap are shown below.
  58  * They are allocated by the kernel and mmap()ed by userspace threads.
  59  * Pointers are implemented as memory offsets or indexes,
  60  * so that they can be easily dereferenced in kernel and userspace.
  61
  62    KERNEL (opaque, obviously)
  63
  64   ====================================================================
  65                                          |
  66    USERSPACE                             |      struct netmap_ring
  67                                          +---->+---------------+
  68                                              / | head,cur,tail |
  69    struct netmap_if (nifp, 1 per fd)        /  | buf_ofs       |
  70     +---------------+                      /   | other fields  |
  71     | ni_tx_rings   |                     /    +===============+
  72     | ni_rx_rings   |                    /     | buf_idx, len  | slot[0]
  73     |               |                   /      | flags, ptr    |
  74     |               |                  /       +---------------+
  75     +===============+                 /        | buf_idx, len  | slot[1]
  76     | txring_ofs[0] | (rel.to nifp)--'         | flags, ptr    |
  77     | txring_ofs[1] |                          +---------------+
  78      (tx+1 entries)                           (num_slots entries)
  79     | txring_ofs[t] |                          | buf_idx, len  | slot[n-1]
  80     +---------------+                          | flags, ptr    |
  81     | rxring_ofs[0] |                          +---------------+
  82     | rxring_ofs[1] |
  83      (rx+1 entries)
  84     | rxring_ofs[r] |
  85     +---------------+
  86
  87  * For each "interface" (NIC, host stack, PIPE, VALE switch port) bound to
  88  * a file descriptor, the mmap()ed region contains a (logically readonly)
  89  * struct netmap_if pointing to struct netmap_ring's.
  90  *
  91  * There is one netmap_ring per physical NIC ring, plus one tx/rx ring
  92  * pair attached to the host stack (this pair is unused for non-NIC ports).
  93  *
  94  * All physical/host stack ports share the same memory region,
  95  * so that zero-copy can be implemented between them.
  96  * VALE switch ports instead have separate memory regions.
  97  *
  98  * The netmap_ring is the userspace-visible replica of the NIC ring.
  99  * Each slot has the index of a buffer (MTU-sized and residing in the
 100  * mmapped region), its length and some flags. An extra 64-bit pointer
 101  * is provided for user-supplied buffers in the tx path.
 102  *
 103  * In user space, the buffer address is computed as
 104  *      (char *)ring + buf_ofs + index * NETMAP_BUF_SIZE
 105  *
 106  * Added in NETMAP_API 11:
 107  *
 108  * + NIOCREGIF can request the allocation of extra spare buffers from
 109  *   the same memory pool. The desired number of buffers must be in
 110  *   nr_arg3. The ioctl may return fewer buffers, depending on memory
 111  *   availability. nr_arg3 will return the actual value, and, once
 112  *   mapped, nifp->ni_bufs_head will be the index of the first buffer.
 113  *
 114  *   The buffers are linked to each other using the first uint32_t
 115  *   as the index. On close, ni_bufs_head must point to the list of
 116  *   buffers to be released.
 117  *
 118  * + NIOCREGIF can request space for extra rings (and buffers)
 119  *   allocated in the same memory space. The number of extra rings
 120  *   is in nr_arg1, and is advisory. This is a no-op on NICs where
 121  *   the size of the memory space is fixed.
 122  *
 123  * + NIOCREGIF can attach to PIPE rings sharing the same memory
 124  *   space with a parent device. The ifname indicates the parent device,
 125  *   which must already exist. Flags in nr_flags indicate if we want to
 126  *   bind the master or slave side, the index (from nr_ringid)
 127  *   is just a cookie and does not need to be sequential.
 128  *
 129  * + NIOCREGIF can also attach to 'monitor' rings that replicate
 130  *   the content of specific rings, also from the same memory space.
 131  *
 132  *   Extra flags in nr_flags support the above functions.
 133  *   Application libraries may use the following naming scheme:
 134  *      netmap:foo                      all NIC ring pairs
 135  *      netmap:foo^                     only host ring pair
 136  *      netmap:foo+                     all NIC ring + host ring pairs
 137  *      netmap:foo-k                    the k-th NIC ring pair
 138  *      netmap:foo{k                    PIPE ring pair k, master side
 139  *      netmap:foo}k                    PIPE ring pair k, slave side
 140  */
 141
 142 /*
 143  * struct netmap_slot is a buffer descriptor
 144  */
 145 struct netmap_slot {
 146         uint32_t buf_idx;       /* buffer index */
 147         uint16_t len;           /* length for this slot */
 148         uint16_t flags;         /* buf changed, etc. */
 149         uint64_t ptr;           /* pointer for indirect buffers */
 150 };
 151
 152 /*
 153  * The following flags control how the slot is used
 154  */
 155
 156 #define NS_BUF_CHANGED  0x0001  /* buf_idx changed */
 157         /*
 158          * must be set whenever buf_idx is changed (as it might be
 159          * necessary to recompute the physical address and mapping)
 160          *
 161          * It is also set by the kernel whenever the buf_idx is
 162          * changed internally (e.g., by pipes). Applications may
 163          * use this information to know when they can reuse the
 164          * contents of previously prepared buffers.
 165          */
 166
 167 #define NS_REPORT       0x0002  /* ask the hardware to report results */
 168         /*
 169          * Request notification when slot is used by the hardware.
 170          * Normally transmit completions are handled lazily and
 171          * may be unreported. This flag lets us know when a slot
 172          * has been sent (e.g. to terminate the sender).
 173          */
 174
 175 #define NS_FORWARD      0x0004  /* pass packet 'forward' */
 176         /*
 177          * (Only for physical ports, rx rings with NR_FORWARD set).
 178          * Slot released to the kernel (i.e. before ring->head) with
 179          * this flag set are passed to the peer ring (host/NIC),
 180          * thus restoring the host-NIC connection for these slots.
 181          * This supports efficient traffic monitoring or firewalling.
 182          */
 183
 184 #define NS_NO_LEARN     0x0008  /* disable bridge learning */
 185         /*
 186          * On a VALE switch, do not 'learn' the source port for
 187          * this buffer.
 188          */
 189
 190 #define NS_INDIRECT     0x0010  /* userspace buffer */
 191         /*
 192          * (VALE tx rings only) data is in a userspace buffer,
 193          * whose address is in the 'ptr' field in the slot.
 194          */
 195
 196 #define NS_MOREFRAG     0x0020  /* packet has more fragments */
 197         /*
 198          * (VALE ports only)
 199          * Set on all but the last slot of a multi-segment packet.
 200          * The 'len' field refers to the individual fragment.
 201          */
 202
 203 #define NS_PORT_SHIFT   8
 204 #define NS_PORT_MASK    (0xff << NS_PORT_SHIFT)
 205         /*
 206          * The high 8 bits of the flag, if not zero, indicate the
 207          * destination port for the VALE switch, overriding
 208          * the lookup table.
 209          */
 210
 211 #define NS_RFRAGS(_slot)        ( ((_slot)->flags >> 8) & 0xff)
 212         /*
 213          * (VALE rx rings only) the high 8 bits
 214          *  are the number of fragments.
 215          */
 216
 217
 218 /*
 219  * struct netmap_ring
 220  *
 221  * Netmap representation of a TX or RX ring (also known as "queue").
 222  * This is a queue implemented as a fixed-size circular array.
 223  * At the software level the important fields are: head, cur, tail.
 224  *
 225  * In TX rings:
 226  *
 227  *      head    first slot available for transmission.
 228  *      cur     wakeup point. select() and poll() will unblock
 229  *              when 'tail' moves past 'cur'
 230  *      tail    (readonly) first slot reserved to the kernel
 231  *
 232  *      [head .. tail-1] can be used for new packets to send;
 233  *      'head' and 'cur' must be incremented as slots are filled
 234  *          with new packets to be sent;
 235  *      'cur' can be moved further ahead if we need more space
 236  *      for new transmissions. XXX todo (2014-03-12)
 237  *
 238  * In RX rings:
 239  *
 240  *      head    first valid received packet
 241  *      cur     wakeup point. select() and poll() will unblock
 242  *              when 'tail' moves past 'cur'
 243  *      tail    (readonly) first slot reserved to the kernel
 244  *
 245  *      [head .. tail-1] contain received packets;
 246  *      'head' and 'cur' must be incremented as slots are consumed
 247  *              and can be returned to the kernel;
 248  *      'cur' can be moved further ahead if we want to wait for
 249  *              new packets without returning the previous ones.
 250  *
 251  * DATA OWNERSHIP/LOCKING:
 252  *      The netmap_ring, and all slots and buffers in the range
 253  *      [head .. tail-1] are owned by the user program;
 254  *      the kernel only accesses them during a netmap system call
 255  *      and in the user thread context.
 256  *
 257  *      Other slots and buffers are reserved for use by the kernel
 258  */
 259 struct netmap_ring {
 260         /*
 261          * buf_ofs is meant to be used through macros.
 262          * It contains the offset of the buffer region from this
 263          * descriptor.
 264          */
 265         const int64_t   buf_ofs;
 266         const uint32_t  num_slots;      /* number of slots in the ring. */
 267         const uint32_t  nr_buf_size;
 268         const uint16_t  ringid;
 269         const uint16_t  dir;            /* 0: tx, 1: rx */
 270
 271         uint32_t        head;           /* (u) first user slot */
 272         uint32_t        cur;            /* (u) wakeup point */
 273         uint32_t        tail;           /* (k) first kernel slot */
 274
 275         uint32_t        flags;
 276
 277         struct timeval  ts;             /* (k) time of last *sync() */
 278
 279         /* opaque room for a mutex or similar object */
 280 #if !defined(_WIN32) || defined(__CYGWIN__)
 281         uint8_t __attribute__((__aligned__(NM_CACHE_ALIGN))) sem[128];
 282 #else
 283         uint8_t __declspec(align(NM_CACHE_ALIGN)) sem[128];
 284 #endif
 285
 286         /* the slots follow. This struct has variable size */
 287         struct netmap_slot slot[0];     /* array of slots. */
 288 };
 289
 290
 291 /*
 292  * RING FLAGS
 293  */
 294 #define NR_TIMESTAMP    0x0002          /* set timestamp on *sync() */
 295         /*
 296          * updates the 'ts' field on each netmap syscall. This saves
 297          * saves a separate gettimeofday(), and is not much worse than
 298          * software timestamps generated in the interrupt handler.
 299          */
 300
 301 #define NR_FORWARD      0x0004          /* enable NS_FORWARD for ring */
 302         /*
 303          * Enables the NS_FORWARD slot flag for the ring.
 304          */
 305
 306
 307 /*
 308  * Netmap representation of an interface and its queue(s).
 309  * This is initialized by the kernel when binding a file
 310  * descriptor to a port, and should be considered as readonly
 311  * by user programs. The kernel never uses it.
 312  *
 313  * There is one netmap_if for each file descriptor on which we want
 314  * to select/poll.
 315  * select/poll operates on one or all pairs depending on the value of
 316  * nmr_queueid passed on the ioctl.
 317  */
 318 struct netmap_if {
 319         char            ni_name[IFNAMSIZ]; /* name of the interface. */
 320         const uint32_t  ni_version;     /* API version, currently unused */
 321         const uint32_t  ni_flags;       /* properties */
 322 #define NI_PRIV_MEM     0x1             /* private memory region */
 323
 324         /*
 325          * The number of packet rings available in netmap mode.
 326          * Physical NICs can have different numbers of tx and rx rings.
 327          * Physical NICs also have a 'host' ring pair.
 328          * Additionally, clients can request additional ring pairs to
 329          * be used for internal communication.
 330          */
 331         const uint32_t  ni_tx_rings;    /* number of HW tx rings */
 332         const uint32_t  ni_rx_rings;    /* number of HW rx rings */
 333
 334         uint32_t        ni_bufs_head;   /* head index for extra bufs */
 335         uint32_t        ni_spare1[5];
 336         /*
 337          * The following array contains the offset of each netmap ring
 338          * from this structure, in the following order:
 339          * NIC tx rings (ni_tx_rings); host tx ring (1); extra tx rings;
 340          * NIC rx rings (ni_rx_rings); host tx ring (1); extra rx rings.
 341          *
 342          * The area is filled up by the kernel on NIOCREGIF,
 343          * and then only read by userspace code.
 344          */
 345         const ssize_t   ring_ofs[0];
 346 };
 347
 348
 349 #ifndef NIOCREGIF
 350 /*
 351  * ioctl names and related fields
 352  *
 353  * NIOCTXSYNC, NIOCRXSYNC synchronize tx or rx queues,
 354  *      whose identity is set in NIOCREGIF through nr_ringid.
 355  *      These are non blocking and take no argument.
 356  *
 357  * NIOCGINFO takes a struct ifreq, the interface name is the input,
 358  *      the outputs are number of queues and number of descriptor
 359  *      for each queue (useful to set number of threads etc.).
 360  *      The info returned is only advisory and may change before
 361  *      the interface is bound to a file descriptor.
 362  *
 363  * NIOCREGIF takes an interface name within a struct nmre,
 364  *      and activates netmap mode on the interface (if possible).
 365  *
 366  * The argument to NIOCGINFO/NIOCREGIF overlays struct ifreq so we
 367  * can pass it down to other NIC-related ioctls.
 368  *
 369  * The actual argument (struct nmreq) has a number of options to request
 370  * different functions.
 371  * The following are used in NIOCREGIF when nr_cmd == 0:
 372  *
 373  * nr_name      (in)
 374  *      The name of the port (em0, valeXXX:YYY, etc.)
 375  *      limited to IFNAMSIZ for backward compatibility.
 376  *
 377  * nr_version   (in/out)
 378  *      Must match NETMAP_API as used in the kernel, error otherwise.
 379  *      Always returns the desired value on output.
 380  *
 381  * nr_tx_slots, nr_tx_slots, nr_tx_rings, nr_rx_rings (in/out)
 382  *      On input, non-zero values may be used to reconfigure the port
 383  *      according to the requested values, but this is not guaranteed.
 384  *      On output the actual values in use are reported.
 385  *
 386  * nr_ringid (in)
 387  *      Indicates how rings should be bound to the file descriptors.
 388  *      If nr_flags != 0, then the low bits (in NETMAP_RING_MASK)
 389  *      are used to indicate the ring number, and nr_flags specifies
 390  *      the actual rings to bind. NETMAP_NO_TX_POLL is unaffected.
 391  *
 392  *      NOTE: THE FOLLOWING (nr_flags == 0) IS DEPRECATED:
 393  *      If nr_flags == 0, NETMAP_HW_RING and NETMAP_SW_RING control
 394  *      the binding as follows:
 395  *      0 (default)                     binds all physical rings
 396  *      NETMAP_HW_RING | ring number    binds a single ring pair
 397  *      NETMAP_SW_RING                  binds only the host tx/rx rings
 398  *
 399  *      NETMAP_NO_TX_POLL can be OR-ed to make select()/poll() push
 400  *              packets on tx rings only if POLLOUT is set.
 401  *              The default is to push any pending packet.
 402  *
 403  *      NETMAP_DO_RX_POLL can be OR-ed to make select()/poll() release
 404  *              packets on rx rings also when POLLIN is NOT set.
 405  *              The default is to touch the rx ring only with POLLIN.
 406  *              Note that this is the opposite of TX because it
 407  *              reflects the common usage.
 408  *
 409  *      NOTE: NETMAP_PRIV_MEM IS DEPRECATED, use nr_arg2 instead.
 410  *      NETMAP_PRIV_MEM is set on return for ports that do not use
 411  *              the global memory allocator.
 412  *              This information is not significant and applications
 413  *              should look at the region id in nr_arg2
 414  *
 415  * nr_flags     is the recommended mode to indicate which rings should
 416  *              be bound to a file descriptor. Values are NR_REG_*
 417  *
 418  * nr_arg1 (in) The number of extra rings to be reserved.
 419  *              Especially when allocating a VALE port the system only
 420  *              allocates the amount of memory needed for the port.
 421  *              If more shared memory rings are desired (e.g. for pipes),
 422  *              the first invocation for the same basename/allocator
 423  *              should specify a suitable number. Memory cannot be
 424  *              extended after the first allocation without closing
 425  *              all ports on the same region.
 426  *
 427  * nr_arg2 (in/out) The identity of the memory region used.
 428  *              On input, 0 means the system decides autonomously,
 429  *              other values may try to select a specific region.
 430  *              On return the actual value is reported.
 431  *              Region '1' is the global allocator, normally shared
 432  *              by all interfaces. Other values are private regions.
 433  *              If two ports the same region zero-copy is possible.
 434  *
 435  * nr_arg3 (in/out)     number of extra buffers to be allocated.
 436  *
 437  *
 438  *
 439  * nr_cmd (in)  if non-zero indicates a special command:
 440  *      NETMAP_BDG_ATTACH        and nr_name = vale*:ifname
 441  *              attaches the NIC to the switch; nr_ringid specifies
 442  *              which rings to use. Used by vale-ctl -a ...
 443  *          nr_arg1 = NETMAP_BDG_HOST also attaches the host port
 444  *              as in vale-ctl -h ...
 445  *
 446  *      NETMAP_BDG_DETACH       and nr_name = vale*:ifname
 447  *              disconnects a previously attached NIC.
 448  *              Used by vale-ctl -d ...
 449  *
 450  *      NETMAP_BDG_LIST
 451  *              list the configuration of VALE switches.
 452  *
 453  *      NETMAP_BDG_VNET_HDR
 454  *              Set the virtio-net header length used by the client
 455  *              of a VALE switch port.
 456  *
 457  *      NETMAP_BDG_NEWIF
 458  *              create a persistent VALE port with name nr_name.
 459  *              Used by vale-ctl -n ...
 460  *
 461  *      NETMAP_BDG_DELIF
 462  *              delete a persistent VALE port. Used by vale-ctl -d ...
 463  *
 464  * nr_arg1, nr_arg2, nr_arg3  (in/out)          command specific
 465  *
 466  *
 467  *
 468  */
 469
 470
 471 /*
 472  * struct nmreq overlays a struct ifreq (just the name)
 473  */
 474 struct nmreq {
 475         char            nr_name[IFNAMSIZ];
 476         uint32_t        nr_version;     /* API version */
 477         uint32_t        nr_offset;      /* nifp offset in the shared region */
 478         uint32_t        nr_memsize;     /* size of the shared region */
 479         uint32_t        nr_tx_slots;    /* slots in tx rings */
 480         uint32_t        nr_rx_slots;    /* slots in rx rings */
 481         uint16_t        nr_tx_rings;    /* number of tx rings */
 482         uint16_t        nr_rx_rings;    /* number of rx rings */
 483
 484         uint16_t        nr_ringid;      /* ring(s) we care about */
 485 #define NETMAP_HW_RING          0x4000  /* single NIC ring pair */
 486 #define NETMAP_SW_RING          0x2000  /* only host ring pair */
 487
 488 #define NETMAP_RING_MASK        0x0fff  /* the ring number */
 489
 490 #define NETMAP_NO_TX_POLL       0x1000  /* no automatic txsync on poll */
 491
 492 #define NETMAP_DO_RX_POLL       0x8000  /* DO automatic rxsync on poll */
 493
 494         uint16_t        nr_cmd;
 495 #define NETMAP_BDG_ATTACH       1       /* attach the NIC */
 496 #define NETMAP_BDG_DETACH       2       /* detach the NIC */
 497 #define NETMAP_BDG_REGOPS       3       /* register bridge callbacks */
 498 #define NETMAP_BDG_LIST         4       /* get bridge's info */
 499 #define NETMAP_BDG_VNET_HDR     5       /* set the port virtio-net-hdr length */
 500 #define NETMAP_BDG_OFFSET       NETMAP_BDG_VNET_HDR     /* deprecated alias */
 501 #define NETMAP_BDG_NEWIF        6       /* create a virtual port */
 502 #define NETMAP_BDG_DELIF        7       /* destroy a virtual port */
 503 #define NETMAP_PT_HOST_CREATE   8       /* create ptnetmap kthreads */
 504 #define NETMAP_PT_HOST_DELETE   9       /* delete ptnetmap kthreads */
 505 #define NETMAP_BDG_POLLING_ON   10      /* delete polling kthread */
 506 #define NETMAP_BDG_POLLING_OFF  11      /* delete polling kthread */
 507 #define NETMAP_VNET_HDR_GET     12      /* get the port virtio-net-hdr length */
 508         uint16_t        nr_arg1;        /* reserve extra rings in NIOCREGIF */
 509 #define NETMAP_BDG_HOST         1       /* attach the host stack on ATTACH */
 510
 511         uint16_t        nr_arg2;
 512         uint32_t        nr_arg3;        /* req. extra buffers in NIOCREGIF */
 513         uint32_t        nr_flags;
 514         /* various modes, extends nr_ringid */
 515         uint32_t        spare2[1];
 516 };
 517
 518 #define NR_REG_MASK             0xf /* values for nr_flags */
 519 enum {  NR_REG_DEFAULT  = 0,    /* backward compat, should not be used. */
 520         NR_REG_ALL_NIC  = 1,
 521         NR_REG_SW       = 2,
 522         NR_REG_NIC_SW   = 3,
 523         NR_REG_ONE_NIC  = 4,
 524         NR_REG_PIPE_MASTER = 5,
 525         NR_REG_PIPE_SLAVE = 6,
 526 };
 527 /* monitor uses the NR_REG to select the rings to monitor */
 528 #define NR_MONITOR_TX   0x100
 529 #define NR_MONITOR_RX   0x200
 530 #define NR_ZCOPY_MON    0x400
 531 /* request exclusive access to the selected rings */
 532 #define NR_EXCLUSIVE    0x800
 533 /* request ptnetmap host support */
 534 #define NR_PASSTHROUGH_HOST     NR_PTNETMAP_HOST /* deprecated */
 535 #define NR_PTNETMAP_HOST        0x1000
 536 #define NR_RX_RINGS_ONLY        0x2000
 537 #define NR_TX_RINGS_ONLY        0x4000
 538 /* Applications set this flag if they are able to deal with virtio-net headers,
 539  * that is send/receive frames that start with a virtio-net header.
 540  * If not set, NIOCREGIF will fail with netmap ports that require applications
 541  * to use those headers. If the flag is set, the application can use the
 542  * NETMAP_VNET_HDR_GET command to figure out the header length. */
 543 #define NR_ACCEPT_VNET_HDR      0x8000
 544
 545
 546 /*
 547  * Windows does not have _IOWR(). _IO(), _IOW() and _IOR() are defined
 548  * in ws2def.h but not sure if they are in the form we need.
 549  * XXX so we redefine them
 550  * in a convenient way to use for DeviceIoControl signatures
 551  */
 552 #ifdef _WIN32
 553 #undef _IO      // ws2def.h
 554 #define _WIN_NM_IOCTL_TYPE 40000
 555 #define _IO(_c, _n)     CTL_CODE(_WIN_NM_IOCTL_TYPE, ((_n) + 0x800) , \
 556                 METHOD_BUFFERED, FILE_ANY_ACCESS  )
 557 #define _IO_direct(_c, _n)      CTL_CODE(_WIN_NM_IOCTL_TYPE, ((_n) + 0x800) , \
 558                 METHOD_OUT_DIRECT, FILE_ANY_ACCESS  )
 559
 560 #define _IOWR(_c, _n, _s)       _IO(_c, _n)
 561
 562 /* We havesome internal sysctl in addition to the externally visible ones */
 563 #define NETMAP_MMAP _IO_direct('i', 160)        // note METHOD_OUT_DIRECT
 564 #define NETMAP_POLL _IO('i', 162)
 565
 566 /* and also two setsockopt for sysctl emulation */
 567 #define NETMAP_SETSOCKOPT _IO('i', 140)
 568 #define NETMAP_GETSOCKOPT _IO('i', 141)
 569
 570
 571 //These linknames are for the Netmap Core Driver
 572 #define NETMAP_NT_DEVICE_NAME                   L"\\Device\\NETMAP"
 573 #define NETMAP_DOS_DEVICE_NAME                  L"\\DosDevices\\netmap"
 574
 575 //Definition of a structure used to pass a virtual address within an IOCTL
 576 typedef struct _MEMORY_ENTRY {
 577         PVOID       pUsermodeVirtualAddress;
 578 } MEMORY_ENTRY, *PMEMORY_ENTRY;
 579
 580 typedef struct _POLL_REQUEST_DATA {
 581         int events;
 582         int timeout;
 583         int revents;
 584 } POLL_REQUEST_DATA;
 585
 586 #endif /* _WIN32 */
 587
 588 /*
 589  * FreeBSD uses the size value embedded in the _IOWR to determine
 590  * how much to copy in/out. So we need it to match the actual
 591  * data structure we pass. We put some spares in the structure
 592  * to ease compatibility with other versions
 593  */
 594 #define NIOCGINFO       _IOWR('i', 145, struct nmreq) /* return IF info */
 595 #define NIOCREGIF       _IOWR('i', 146, struct nmreq) /* interface register */
 596 #define NIOCTXSYNC      _IO('i', 148) /* sync tx queues */
 597 #define NIOCRXSYNC      _IO('i', 149) /* sync rx queues */
 598 #define NIOCCONFIG      _IOWR('i',150, struct nm_ifreq) /* for ext. modules */
 599 #endif /* !NIOCREGIF */
 600
 601
 602 /*
 603  * Helper functions for kernel and userspace
 604  */
 605
 606 /*
 607  * check if space is available in the ring.
 608  */
 609 static inline int
 610 nm_ring_empty(struct netmap_ring *ring)
 611 {
 612         return (ring->cur == ring->tail);
 613 }
 614
 615 /*
 616  * Opaque structure that is passed to an external kernel
 617  * module via ioctl(fd, NIOCCONFIG, req) for a user-owned
 618  * bridge port (at this point ephemeral VALE interface).
 619  */
 620 #define NM_IFRDATA_LEN 256
 621 struct nm_ifreq {
 622         char nifr_name[IFNAMSIZ];
 623         char data[NM_IFRDATA_LEN];
 624 };
 625
 626 /*
 627  * netmap kernel thread configuration
 628  */
 629 /* bhyve/vmm.ko MSIX parameters for IOCTL */
 630 struct ptn_vmm_ioctl_msix {
 631         uint64_t        msg;
 632         uint64_t        addr;
 633 };
 634
 635 /* IOCTL parameters */
 636 struct nm_kth_ioctl {
 637         u_long                          com;
 638         /* TODO: use union */
 639         union {
 640                 struct ptn_vmm_ioctl_msix msix;
 641         } data;
 642 };
 643
 644 /* Configuration of a ptnetmap ring */
 645 struct ptnet_ring_cfg {
 646         uint64_t ioeventfd;             /* eventfd in linux, tsleep() parameter in FreeBSD */
 647         uint64_t irqfd;                 /* eventfd in linux, ioctl fd in FreeBSD */
 648         struct nm_kth_ioctl ioctl;      /* ioctl parameter to send irq (only used in bhyve/FreeBSD) */
 649 };
 650 #endif /* _NET_NETMAP_H_ */