sys/net/netmap.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (C) 2011-2014 Matteo Landi, Luigi Rizzo. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  *   1. Redistributions of source code must retain the above copyright
  11  *      notice, this list of conditions and the following disclaimer.
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``S IS''AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * $FreeBSD$
  31  *
  32  * Definitions of constants and the structures used by the netmap
  33  * framework, for the part visible to both kernel and userspace.
  34  * Detailed info on netmap is available with "man netmap" or at
  35  *
  36  *      http://info.iet.unipi.it/~luigi/netmap/
  37  *
  38  * This API is also used to communicate with the VALE software switch
  39  */
  40
  41 #ifndef _NET_NETMAP_H_
  42 #define _NET_NETMAP_H_
  43
  44 #define NETMAP_API      12              /* current API version */
  45
  46 #define NETMAP_MIN_API  11              /* min and max versions accepted */
  47 #define NETMAP_MAX_API  15
  48 /*
  49  * Some fields should be cache-aligned to reduce contention.
  50  * The alignment is architecture and OS dependent, but rather than
  51  * digging into OS headers to find the exact value we use an estimate
  52  * that should cover most architectures.
  53  */
  54 #define NM_CACHE_ALIGN  128
  55
  56 /*
  57  * --- Netmap data structures ---
  58  *
  59  * The userspace data structures used by netmap are shown below.
  60  * They are allocated by the kernel and mmap()ed by userspace threads.
  61  * Pointers are implemented as memory offsets or indexes,
  62  * so that they can be easily dereferenced in kernel and userspace.
  63
  64    KERNEL (opaque, obviously)
  65
  66   ====================================================================
  67                                          |
  68    USERSPACE                             |      struct netmap_ring
  69                                          +---->+---------------+
  70                                              / | head,cur,tail |
  71    struct netmap_if (nifp, 1 per fd)        /  | buf_ofs       |
  72     +---------------+                      /   | other fields  |
  73     | ni_tx_rings   |                     /    +===============+
  74     | ni_rx_rings   |                    /     | buf_idx, len  | slot[0]
  75     |               |                   /      | flags, ptr    |
  76     |               |                  /       +---------------+
  77     +===============+                 /        | buf_idx, len  | slot[1]
  78     | txring_ofs[0] | (rel.to nifp)--'         | flags, ptr    |
  79     | txring_ofs[1] |                          +---------------+
  80      (tx+1 entries)                           (num_slots entries)
  81     | txring_ofs[t] |                          | buf_idx, len  | slot[n-1]
  82     +---------------+                          | flags, ptr    |
  83     | rxring_ofs[0] |                          +---------------+
  84     | rxring_ofs[1] |
  85      (rx+1 entries)
  86     | rxring_ofs[r] |
  87     +---------------+
  88
  89  * For each "interface" (NIC, host stack, PIPE, VALE switch port) bound to
  90  * a file descriptor, the mmap()ed region contains a (logically readonly)
  91  * struct netmap_if pointing to struct netmap_ring's.
  92  *
  93  * There is one netmap_ring per physical NIC ring, plus one tx/rx ring
  94  * pair attached to the host stack (this pair is unused for non-NIC ports).
  95  *
  96  * All physical/host stack ports share the same memory region,
  97  * so that zero-copy can be implemented between them.
  98  * VALE switch ports instead have separate memory regions.
  99  *
 100  * The netmap_ring is the userspace-visible replica of the NIC ring.
 101  * Each slot has the index of a buffer (MTU-sized and residing in the
 102  * mmapped region), its length and some flags. An extra 64-bit pointer
 103  * is provided for user-supplied buffers in the tx path.
 104  *
 105  * In user space, the buffer address is computed as
 106  *      (char *)ring + buf_ofs + index * NETMAP_BUF_SIZE
 107  *
 108  * Added in NETMAP_API 11:
 109  *
 110  * + NIOCREGIF can request the allocation of extra spare buffers from
 111  *   the same memory pool. The desired number of buffers must be in
 112  *   nr_arg3. The ioctl may return fewer buffers, depending on memory
 113  *   availability. nr_arg3 will return the actual value, and, once
 114  *   mapped, nifp->ni_bufs_head will be the index of the first buffer.
 115  *
 116  *   The buffers are linked to each other using the first uint32_t
 117  *   as the index. On close, ni_bufs_head must point to the list of
 118  *   buffers to be released.
 119  *
 120  * + NIOCREGIF can request space for extra rings (and buffers)
 121  *   allocated in the same memory space. The number of extra rings
 122  *   is in nr_arg1, and is advisory. This is a no-op on NICs where
 123  *   the size of the memory space is fixed.
 124  *
 125  * + NIOCREGIF can attach to PIPE rings sharing the same memory
 126  *   space with a parent device. The ifname indicates the parent device,
 127  *   which must already exist. Flags in nr_flags indicate if we want to
 128  *   bind the master or slave side, the index (from nr_ringid)
 129  *   is just a cookie and does not need to be sequential.
 130  *
 131  * + NIOCREGIF can also attach to 'monitor' rings that replicate
 132  *   the content of specific rings, also from the same memory space.
 133  *
 134  *   Extra flags in nr_flags support the above functions.
 135  *   Application libraries may use the following naming scheme:
 136  *      netmap:foo                      all NIC ring pairs
 137  *      netmap:foo^                     only host ring pair
 138  *      netmap:foo+                     all NIC ring + host ring pairs
 139  *      netmap:foo-k                    the k-th NIC ring pair
 140  *      netmap:foo{k                    PIPE ring pair k, master side
 141  *      netmap:foo}k                    PIPE ring pair k, slave side
 142  *
 143  * Some notes about host rings:
 144  *
 145  * + The RX host ring is used to store those packets that the host network
 146  *   stack is trying to transmit through a NIC queue, but only if that queue
 147  *   is currently in netmap mode. Netmap will not intercept host stack mbufs
 148  *   designated to NIC queues that are not in netmap mode. As a consequence,
 149  *   registering a netmap port with netmap:foo^ is not enough to intercept
 150  *   mbufs in the RX host ring; the netmap port should be registered with
 151  *   netmap:foo*, or another registration should be done to open at least a
 152  *   NIC TX queue in netmap mode.
 153  *
 154  * + Netmap is not currently able to deal with intercepted trasmit mbufs which
 155  *   require offloadings like TSO, UFO, checksumming offloadings, etc. It is
 156  *   responsibility of the user to disable those offloadings (e.g. using
 157  *   ifconfig on FreeBSD or ethtool -K on Linux) for an interface that is being
 158  *   used in netmap mode. If the offloadings are not disabled, GSO and/or
 159  *   unchecksummed packets may be dropped immediately or end up in the host RX
 160  *   ring, and will be dropped as soon as the packet reaches another netmap
 161  *   adapter.
 162  */
 163
 164 /*
 165  * struct netmap_slot is a buffer descriptor
 166  */
 167 struct netmap_slot {
 168         uint32_t buf_idx;       /* buffer index */
 169         uint16_t len;           /* length for this slot */
 170         uint16_t flags;         /* buf changed, etc. */
 171         uint64_t ptr;           /* pointer for indirect buffers */
 172 };
 173
 174 /*
 175  * The following flags control how the slot is used
 176  */
 177
 178 #define NS_BUF_CHANGED  0x0001  /* buf_idx changed */
 179         /*
 180          * must be set whenever buf_idx is changed (as it might be
 181          * necessary to recompute the physical address and mapping)
 182          *
 183          * It is also set by the kernel whenever the buf_idx is
 184          * changed internally (e.g., by pipes). Applications may
 185          * use this information to know when they can reuse the
 186          * contents of previously prepared buffers.
 187          */
 188
 189 #define NS_REPORT       0x0002  /* ask the hardware to report results */
 190         /*
 191          * Request notification when slot is used by the hardware.
 192          * Normally transmit completions are handled lazily and
 193          * may be unreported. This flag lets us know when a slot
 194          * has been sent (e.g. to terminate the sender).
 195          */
 196
 197 #define NS_FORWARD      0x0004  /* pass packet 'forward' */
 198         /*
 199          * (Only for physical ports, rx rings with NR_FORWARD set).
 200          * Slot released to the kernel (i.e. before ring->head) with
 201          * this flag set are passed to the peer ring (host/NIC),
 202          * thus restoring the host-NIC connection for these slots.
 203          * This supports efficient traffic monitoring or firewalling.
 204          */
 205
 206 #define NS_NO_LEARN     0x0008  /* disable bridge learning */
 207         /*
 208          * On a VALE switch, do not 'learn' the source port for
 209          * this buffer.
 210          */
 211
 212 #define NS_INDIRECT     0x0010  /* userspace buffer */
 213         /*
 214          * (VALE tx rings only) data is in a userspace buffer,
 215          * whose address is in the 'ptr' field in the slot.
 216          */
 217
 218 #define NS_MOREFRAG     0x0020  /* packet has more fragments */
 219         /*
 220          * (VALE ports, ptnetmap ports and some NIC ports, e.g.
 221          * ixgbe and i40e on Linux)
 222          * Set on all but the last slot of a multi-segment packet.
 223          * The 'len' field refers to the individual fragment.
 224          */
 225
 226 #define NS_PORT_SHIFT   8
 227 #define NS_PORT_MASK    (0xff << NS_PORT_SHIFT)
 228         /*
 229          * The high 8 bits of the flag, if not zero, indicate the
 230          * destination port for the VALE switch, overriding
 231          * the lookup table.
 232          */
 233
 234 #define NS_RFRAGS(_slot)        ( ((_slot)->flags >> 8) & 0xff)
 235         /*
 236          * (VALE rx rings only) the high 8 bits
 237          *  are the number of fragments.
 238          */
 239
 240
 241 /*
 242  * struct netmap_ring
 243  *
 244  * Netmap representation of a TX or RX ring (also known as "queue").
 245  * This is a queue implemented as a fixed-size circular array.
 246  * At the software level the important fields are: head, cur, tail.
 247  *
 248  * In TX rings:
 249  *
 250  *      head    first slot available for transmission.
 251  *      cur     wakeup point. select() and poll() will unblock
 252  *              when 'tail' moves past 'cur'
 253  *      tail    (readonly) first slot reserved to the kernel
 254  *
 255  *      [head .. tail-1] can be used for new packets to send;
 256  *      'head' and 'cur' must be incremented as slots are filled
 257  *          with new packets to be sent;
 258  *      'cur' can be moved further ahead if we need more space
 259  *      for new transmissions. XXX todo (2014-03-12)
 260  *
 261  * In RX rings:
 262  *
 263  *      head    first valid received packet
 264  *      cur     wakeup point. select() and poll() will unblock
 265  *              when 'tail' moves past 'cur'
 266  *      tail    (readonly) first slot reserved to the kernel
 267  *
 268  *      [head .. tail-1] contain received packets;
 269  *      'head' and 'cur' must be incremented as slots are consumed
 270  *              and can be returned to the kernel;
 271  *      'cur' can be moved further ahead if we want to wait for
 272  *              new packets without returning the previous ones.
 273  *
 274  * DATA OWNERSHIP/LOCKING:
 275  *      The netmap_ring, and all slots and buffers in the range
 276  *      [head .. tail-1] are owned by the user program;
 277  *      the kernel only accesses them during a netmap system call
 278  *      and in the user thread context.
 279  *
 280  *      Other slots and buffers are reserved for use by the kernel
 281  */
 282 struct netmap_ring {
 283         /*
 284          * buf_ofs is meant to be used through macros.
 285          * It contains the offset of the buffer region from this
 286          * descriptor.
 287          */
 288         const int64_t   buf_ofs;
 289         const uint32_t  num_slots;      /* number of slots in the ring. */
 290         const uint32_t  nr_buf_size;
 291         const uint16_t  ringid;
 292         const uint16_t  dir;            /* 0: tx, 1: rx */
 293
 294         uint32_t        head;           /* (u) first user slot */
 295         uint32_t        cur;            /* (u) wakeup point */
 296         uint32_t        tail;           /* (k) first kernel slot */
 297
 298         uint32_t        flags;
 299
 300         struct timeval  ts;             /* (k) time of last *sync() */
 301
 302         /* opaque room for a mutex or similar object */
 303 #if !defined(_WIN32) || defined(__CYGWIN__)
 304         uint8_t __attribute__((__aligned__(NM_CACHE_ALIGN))) sem[128];
 305 #else
 306         uint8_t __declspec(align(NM_CACHE_ALIGN)) sem[128];
 307 #endif
 308
 309         /* the slots follow. This struct has variable size */
 310         struct netmap_slot slot[0];     /* array of slots. */
 311 };
 312
 313
 314 /*
 315  * RING FLAGS
 316  */
 317 #define NR_TIMESTAMP    0x0002          /* set timestamp on *sync() */
 318         /*
 319          * updates the 'ts' field on each netmap syscall. This saves
 320          * saves a separate gettimeofday(), and is not much worse than
 321          * software timestamps generated in the interrupt handler.
 322          */
 323
 324 #define NR_FORWARD      0x0004          /* enable NS_FORWARD for ring */
 325         /*
 326          * Enables the NS_FORWARD slot flag for the ring.
 327          */
 328
 329 /*
 330  * Helper functions for kernel and userspace
 331  */
 332
 333 /*
 334  * check if space is available in the ring.
 335  */
 336 static inline int
 337 nm_ring_empty(struct netmap_ring *ring)
 338 {
 339         return (ring->cur == ring->tail);
 340 }
 341
 342 /*
 343  * Netmap representation of an interface and its queue(s).
 344  * This is initialized by the kernel when binding a file
 345  * descriptor to a port, and should be considered as readonly
 346  * by user programs. The kernel never uses it.
 347  *
 348  * There is one netmap_if for each file descriptor on which we want
 349  * to select/poll.
 350  * select/poll operates on one or all pairs depending on the value of
 351  * nmr_queueid passed on the ioctl.
 352  */
 353 struct netmap_if {
 354         char            ni_name[IFNAMSIZ]; /* name of the interface. */
 355         const uint32_t  ni_version;     /* API version, currently unused */
 356         const uint32_t  ni_flags;       /* properties */
 357 #define NI_PRIV_MEM     0x1             /* private memory region */
 358
 359         /*
 360          * The number of packet rings available in netmap mode.
 361          * Physical NICs can have different numbers of tx and rx rings.
 362          * Physical NICs also have a 'host' ring pair.
 363          * Additionally, clients can request additional ring pairs to
 364          * be used for internal communication.
 365          */
 366         const uint32_t  ni_tx_rings;    /* number of HW tx rings */
 367         const uint32_t  ni_rx_rings;    /* number of HW rx rings */
 368
 369         uint32_t        ni_bufs_head;   /* head index for extra bufs */
 370         uint32_t        ni_spare1[5];
 371         /*
 372          * The following array contains the offset of each netmap ring
 373          * from this structure, in the following order:
 374          * NIC tx rings (ni_tx_rings); host tx ring (1); extra tx rings;
 375          * NIC rx rings (ni_rx_rings); host tx ring (1); extra rx rings.
 376          *
 377          * The area is filled up by the kernel on NIOCREGIF,
 378          * and then only read by userspace code.
 379          */
 380         const ssize_t   ring_ofs[0];
 381 };
 382
 383 /* Legacy interface to interact with a netmap control device.
 384  * Included for backward compatibility. The user should not include this
 385  * file directly. */
 386 #include "netmap_legacy.h"
 387
 388 /*
 389  * New API to control netmap control devices. New applications should only use
 390  * nmreq_xyz structs with the NIOCCTRL ioctl() command.
 391  *
 392  * NIOCCTRL takes a nmreq_header struct, which contains the required
 393  * API version, the name of a netmap port, a command type, and pointers
 394  * to request body and options.
 395  *
 396  *      nr_name (in)
 397  *              The name of the port (em0, valeXXX:YYY, eth0{pn1 etc.)
 398  *
 399  *      nr_version (in/out)
 400  *              Must match NETMAP_API as used in the kernel, error otherwise.
 401  *              Always returns the desired value on output.
 402  *
 403  *      nr_reqtype (in)
 404  *              One of the NETMAP_REQ_* command types below
 405  *
 406  *      nr_body (in)
 407  *              Pointer to a command-specific struct, described by one
 408  *              of the struct nmreq_xyz below.
 409  *
 410  *      nr_options (in)
 411  *              Command specific options, if any.
 412  *
 413  * A NETMAP_REQ_REGISTER command activates netmap mode on the netmap
 414  * port (e.g. physical interface) specified by nmreq_header.nr_name.
 415  * The request body (struct nmreq_register) has several arguments to
 416  * specify how the port is to be registered.
 417  *
 418  *      nr_tx_slots, nr_tx_slots, nr_tx_rings, nr_rx_rings (in/out)
 419  *              On input, non-zero values may be used to reconfigure the port
 420  *              according to the requested values, but this is not guaranteed.
 421  *              On output the actual values in use are reported.
 422  *
 423  *      nr_mode (in)
 424  *              Indicate what set of rings must be bound to the netmap
 425  *              device (e.g. all NIC rings, host rings only, NIC and
 426  *              host rings, ...). Values are in NR_REG_*.
 427  *
 428  *      nr_ringid (in)
 429  *              If nr_mode == NR_REG_ONE_NIC (only a single couple of TX/RX
 430  *              rings), indicate which NIC TX and/or RX ring is to be bound
 431  *              (0..nr_*x_rings-1).
 432  *
 433  *      nr_flags (in)
 434  *              Indicate special options for how to open the port.
 435  *
 436  *              NR_NO_TX_POLL can be OR-ed to make select()/poll() push
 437  *                      packets on tx rings only if POLLOUT is set.
 438  *                      The default is to push any pending packet.
 439  *
 440  *              NR_DO_RX_POLL can be OR-ed to make select()/poll() release
 441  *                      packets on rx rings also when POLLIN is NOT set.
 442  *                      The default is to touch the rx ring only with POLLIN.
 443  *                      Note that this is the opposite of TX because it
 444  *                      reflects the common usage.
 445  *
 446  *              Other options are NR_MONITOR_TX, NR_MONITOR_RX, NR_ZCOPY_MON,
 447  *              NR_EXCLUSIVE, NR_RX_RINGS_ONLY, NR_TX_RINGS_ONLY and
 448  *              NR_ACCEPT_VNET_HDR.
 449  *
 450  *      nr_mem_id (in/out)
 451  *              The identity of the memory region used.
 452  *              On input, 0 means the system decides autonomously,
 453  *              other values may try to select a specific region.
 454  *              On return the actual value is reported.
 455  *              Region '1' is the global allocator, normally shared
 456  *              by all interfaces. Other values are private regions.
 457  *              If two ports the same region zero-copy is possible.
 458  *
 459  *      nr_extra_bufs (in/out)
 460  *              Number of extra buffers to be allocated.
 461  *
 462  * The other NETMAP_REQ_* commands are described below.
 463  *
 464  */
 465
 466 /* maximum size of a request, including all options */
 467 #define NETMAP_REQ_MAXSIZE      4096
 468
 469 /* Header common to all request options. */
 470 struct nmreq_option {
 471         /* Pointer ot the next option. */
 472         uint64_t                nro_next;
 473         /* Option type. */
 474         uint32_t                nro_reqtype;
 475         /* (out) status of the option:
 476          * 0: recognized and processed
 477          * !=0: errno value
 478          */
 479         uint32_t                nro_status;
 480 };
 481
 482 /* Header common to all requests. Do not reorder these fields, as we need
 483  * the second one (nr_reqtype) to know how much to copy from/to userspace. */
 484 struct nmreq_header {
 485         uint16_t                nr_version;     /* API version */
 486         uint16_t                nr_reqtype;     /* nmreq type (NETMAP_REQ_*) */
 487         uint32_t                nr_reserved;    /* must be zero */
 488 #define NETMAP_REQ_IFNAMSIZ     64
 489         char                    nr_name[NETMAP_REQ_IFNAMSIZ]; /* port name */
 490         uint64_t                nr_options;     /* command-specific options */
 491         uint64_t                nr_body;        /* ptr to nmreq_xyz struct */
 492 };
 493
 494 enum {
 495         /* Register a netmap port with the device. */
 496         NETMAP_REQ_REGISTER = 1,
 497         /* Get information from a netmap port. */
 498         NETMAP_REQ_PORT_INFO_GET,
 499         /* Attach a netmap port to a VALE switch. */
 500         NETMAP_REQ_VALE_ATTACH,
 501         /* Detach a netmap port from a VALE switch. */
 502         NETMAP_REQ_VALE_DETACH,
 503         /* List the ports attached to a VALE switch. */
 504         NETMAP_REQ_VALE_LIST,
 505         /* Set the port header length (was virtio-net header length). */
 506         NETMAP_REQ_PORT_HDR_SET,
 507         /* Get the port header length (was virtio-net header length). */
 508         NETMAP_REQ_PORT_HDR_GET,
 509         /* Create a new persistent VALE port. */
 510         NETMAP_REQ_VALE_NEWIF,
 511         /* Delete a persistent VALE port. */
 512         NETMAP_REQ_VALE_DELIF,
 513         /* Enable polling kernel thread(s) on an attached VALE port. */
 514         NETMAP_REQ_VALE_POLLING_ENABLE,
 515         /* Disable polling kernel thread(s) on an attached VALE port. */
 516         NETMAP_REQ_VALE_POLLING_DISABLE,
 517         /* Get info about the pools of a memory allocator. */
 518         NETMAP_REQ_POOLS_INFO_GET,
 519 };
 520
 521 enum {
 522         /* On NETMAP_REQ_REGISTER, ask netmap to use memory allocated
 523          * from user-space allocated memory pools (e.g. hugepages). */
 524         NETMAP_REQ_OPT_EXTMEM = 1,
 525 };
 526
 527 /*
 528  * nr_reqtype: NETMAP_REQ_REGISTER
 529  * Bind (register) a netmap port to this control device.
 530  */
 531 struct nmreq_register {
 532         uint64_t        nr_offset;      /* nifp offset in the shared region */
 533         uint64_t        nr_memsize;     /* size of the shared region */
 534         uint32_t        nr_tx_slots;    /* slots in tx rings */
 535         uint32_t        nr_rx_slots;    /* slots in rx rings */
 536         uint16_t        nr_tx_rings;    /* number of tx rings */
 537         uint16_t        nr_rx_rings;    /* number of rx rings */
 538
 539         uint16_t        nr_mem_id;      /* id of the memory allocator */
 540         uint16_t        nr_ringid;      /* ring(s) we care about */
 541         uint32_t        nr_mode;        /* specify NR_REG_* modes */
 542
 543         uint64_t        nr_flags;       /* additional flags (see below) */
 544 /* monitors use nr_ringid and nr_mode to select the rings to monitor */
 545 #define NR_MONITOR_TX   0x100
 546 #define NR_MONITOR_RX   0x200
 547 #define NR_ZCOPY_MON    0x400
 548 /* request exclusive access to the selected rings */
 549 #define NR_EXCLUSIVE    0x800
 550 /* request ptnetmap host support */
 551 #define NR_PASSTHROUGH_HOST     NR_PTNETMAP_HOST /* deprecated */
 552 #define NR_PTNETMAP_HOST        0x1000
 553 #define NR_RX_RINGS_ONLY        0x2000
 554 #define NR_TX_RINGS_ONLY        0x4000
 555 /* Applications set this flag if they are able to deal with virtio-net headers,
 556  * that is send/receive frames that start with a virtio-net header.
 557  * If not set, NIOCREGIF will fail with netmap ports that require applications
 558  * to use those headers. If the flag is set, the application can use the
 559  * NETMAP_VNET_HDR_GET command to figure out the header length. */
 560 #define NR_ACCEPT_VNET_HDR      0x8000
 561 /* The following two have the same meaning of NETMAP_NO_TX_POLL and
 562  * NETMAP_DO_RX_POLL. */
 563 #define NR_DO_RX_POLL           0x10000
 564 #define NR_NO_TX_POLL           0x20000
 565
 566         uint32_t        nr_extra_bufs;  /* number of requested extra buffers */
 567 };
 568
 569 /* Valid values for nmreq_register.nr_mode (see above). */
 570 enum {  NR_REG_DEFAULT  = 0,    /* backward compat, should not be used. */
 571         NR_REG_ALL_NIC  = 1,
 572         NR_REG_SW       = 2,
 573         NR_REG_NIC_SW   = 3,
 574         NR_REG_ONE_NIC  = 4,
 575         NR_REG_PIPE_MASTER = 5, /* deprecated, use "x{y" port name syntax */
 576         NR_REG_PIPE_SLAVE = 6,  /* deprecated, use "x}y" port name syntax */
 577 };
 578
 579 /* A single ioctl number is shared by all the new API command.
 580  * Demultiplexing is done using the nr_hdr.nr_reqtype field.
 581  * FreeBSD uses the size value embedded in the _IOWR to determine
 582  * how much to copy in/out, so we define the ioctl() command
 583  * specifying only nmreq_header, and copyin/copyout the rest. */
 584 #define NIOCCTRL        _IOWR('i', 151, struct nmreq_header)
 585
 586 /* The ioctl commands to sync TX/RX netmap rings.
 587  * NIOCTXSYNC, NIOCRXSYNC synchronize tx or rx queues,
 588  *      whose identity is set in NIOCREGIF through nr_ringid.
 589  *      These are non blocking and take no argument. */
 590 #define NIOCTXSYNC      _IO('i', 148) /* sync tx queues */
 591 #define NIOCRXSYNC      _IO('i', 149) /* sync rx queues */
 592
 593 /*
 594  * nr_reqtype: NETMAP_REQ_PORT_INFO_GET
 595  * Get information about a netmap port, including number of rings.
 596  * slots per ring, id of the memory allocator, etc.
 597  */
 598 struct nmreq_port_info_get {
 599         uint64_t        nr_offset;      /* nifp offset in the shared region */
 600         uint64_t        nr_memsize;     /* size of the shared region */
 601         uint32_t        nr_tx_slots;    /* slots in tx rings */
 602         uint32_t        nr_rx_slots;    /* slots in rx rings */
 603         uint16_t        nr_tx_rings;    /* number of tx rings */
 604         uint16_t        nr_rx_rings;    /* number of rx rings */
 605         uint16_t        nr_mem_id;      /* id of the memory allocator */
 606 };
 607
 608 #define NM_BDG_NAME             "vale"  /* prefix for bridge port name */
 609
 610 /*
 611  * nr_reqtype: NETMAP_REQ_VALE_ATTACH
 612  * Attach a netmap port to a VALE switch. Both the name of the netmap
 613  * port and the VALE switch are specified through the nr_name argument.
 614  * The attach operation could need to register a port, so at least
 615  * the same arguments are available.
 616  * port_index will contain the index where the port has been attached.
 617  */
 618 struct nmreq_vale_attach {
 619         struct nmreq_register reg;
 620         uint32_t port_index;
 621 };
 622
 623 /*
 624  * nr_reqtype: NETMAP_REQ_VALE_DETACH
 625  * Detach a netmap port from a VALE switch. Both the name of the netmap
 626  * port and the VALE switch are specified through the nr_name argument.
 627  * port_index will contain the index where the port was attached.
 628  */
 629 struct nmreq_vale_detach {
 630         uint32_t port_index;
 631 };
 632
 633 /*
 634  * nr_reqtype: NETMAP_REQ_VALE_LIST
 635  * List the ports of a VALE switch.
 636  */
 637 struct nmreq_vale_list {
 638         /* Name of the VALE port (valeXXX:YYY) or empty. */
 639         uint16_t        nr_bridge_idx;
 640         uint32_t        nr_port_idx;
 641 };
 642
 643 /*
 644  * nr_reqtype: NETMAP_REQ_PORT_HDR_SET or NETMAP_REQ_PORT_HDR_GET
 645  * Set the port header length.
 646  */
 647 struct nmreq_port_hdr {
 648         uint32_t        nr_hdr_len;
 649 };
 650
 651 /*
 652  * nr_reqtype: NETMAP_REQ_VALE_NEWIF
 653  * Create a new persistent VALE port.
 654  */
 655 struct nmreq_vale_newif {
 656         uint32_t        nr_tx_slots;    /* slots in tx rings */
 657         uint32_t        nr_rx_slots;    /* slots in rx rings */
 658         uint16_t        nr_tx_rings;    /* number of tx rings */
 659         uint16_t        nr_rx_rings;    /* number of rx rings */
 660         uint16_t        nr_mem_id;      /* id of the memory allocator */
 661 };
 662
 663 /*
 664  * nr_reqtype: NETMAP_REQ_VALE_POLLING_ENABLE or NETMAP_REQ_VALE_POLLING_DISABLE
 665  * Enable or disable polling kthreads on a VALE port.
 666  */
 667 struct nmreq_vale_polling {
 668         uint32_t        nr_mode;
 669 #define NETMAP_POLLING_MODE_SINGLE_CPU 1
 670 #define NETMAP_POLLING_MODE_MULTI_CPU 2
 671         uint32_t        nr_first_cpu_id;
 672         uint32_t        nr_num_polling_cpus;
 673 };
 674
 675 /*
 676  * nr_reqtype: NETMAP_REQ_POOLS_INFO_GET
 677  * Get info about the pools of the memory allocator of the port bound
 678  * to a given netmap control device (used i.e. by a ptnetmap-enabled
 679  * hypervisor). The nr_hdr.nr_name field is ignored.
 680  */
 681 struct nmreq_pools_info {
 682         uint64_t        nr_memsize;
 683         uint16_t        nr_mem_id;
 684         uint64_t        nr_if_pool_offset;
 685         uint32_t        nr_if_pool_objtotal;
 686         uint32_t        nr_if_pool_objsize;
 687         uint64_t        nr_ring_pool_offset;
 688         uint32_t        nr_ring_pool_objtotal;
 689         uint32_t        nr_ring_pool_objsize;
 690         uint64_t        nr_buf_pool_offset;
 691         uint32_t        nr_buf_pool_objtotal;
 692         uint32_t        nr_buf_pool_objsize;
 693 };
 694
 695 /*
 696  * data for NETMAP_REQ_OPT_* options
 697  */
 698
 699 struct nmreq_opt_extmem {
 700         struct nmreq_option     nro_opt;        /* common header */
 701         uint64_t                nro_usrptr;     /* (in) ptr to usr memory */
 702         struct nmreq_pools_info nro_info;       /* (in/out) */
 703 };
 704
 705 #endif /* _NET_NETMAP_H_ */