OSCL-LXR linux-6.0.1/​include/​xen/​interface/​io/​netif.h	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 /* SPDX-License-Identifier: MIT */
 /******************************************************************************
  * xen_netif.h
  *
  * Unified network-device I/O interface for Xen guest OSes.
  *
  * Copyright (c) 2003-2004, Keir Fraser
  */
 
 #ifndef __XEN_PUBLIC_IO_XEN_NETIF_H__
 #define __XEN_PUBLIC_IO_XEN_NETIF_H__
 
 #include "ring.h"
 #include "../grant_table.h"
 
 /*
  * Older implementation of Xen network frontend / backend has an
  * implicit dependency on the MAX_SKB_FRAGS as the maximum number of
  * ring slots a skb can use. Netfront / netback may not work as
  * expected when frontend and backend have different MAX_SKB_FRAGS.
  *
  * A better approach is to add mechanism for netfront / netback to
  * negotiate this value. However we cannot fix all possible
  * frontends, so we need to define a value which states the minimum
  * slots backend must support.
  *
  * The minimum value derives from older Linux kernel's MAX_SKB_FRAGS
  * (18), which is proved to work with most frontends. Any new backend
  * which doesn't negotiate with frontend should expect frontend to
  * send a valid packet using slots up to this value.
  */
 #define XEN_NETIF_NR_SLOTS_MIN 18
 
 /*
  * Notifications after enqueuing any type of message should be conditional on
  * the appropriate req_event or rsp_event field in the shared ring.
  * If the client sends notification for rx requests then it should specify
  * feature 'feature-rx-notify' via xenbus. Otherwise the backend will assume
  * that it cannot safely queue packets (as it may not be kicked to send them).
  */
 
 /*
  * "feature-split-event-channels" is introduced to separate guest TX
  * and RX notification. Backend either doesn't support this feature or
  * advertises it via xenstore as 0 (disabled) or 1 (enabled).
  *
  * To make use of this feature, frontend should allocate two event
  * channels for TX and RX, advertise them to backend as
  * "event-channel-tx" and "event-channel-rx" respectively. If frontend
  * doesn't want to use this feature, it just writes "event-channel"
  * node as before.
  */
 
 /*
  * Multiple transmit and receive queues:
  * If supported, the backend will write the key "multi-queue-max-queues" to
  * the directory for that vif, and set its value to the maximum supported
  * number of queues.
  * Frontends that are aware of this feature and wish to use it can write the
  * key "multi-queue-num-queues", set to the number they wish to use, which
  * must be greater than zero, and no more than the value reported by the backend
  * in "multi-queue-max-queues".
  *
  * Queues replicate the shared rings and event channels.
  * "feature-split-event-channels" may optionally be used when using
  * multiple queues, but is not mandatory.
  *
  * Each queue consists of one shared ring pair, i.e. there must be the same
  * number of tx and rx rings.
  *
  * For frontends requesting just one queue, the usual event-channel and
  * ring-ref keys are written as before, simplifying the backend processing
  * to avoid distinguishing between a frontend that doesn't understand the
  * multi-queue feature, and one that does, but requested only one queue.
  *
  * Frontends requesting two or more queues must not write the toplevel
  * event-channel (or event-channel-{tx,rx}) and {tx,rx}-ring-ref keys,
  * instead writing those keys under sub-keys having the name "queue-N" where
  * N is the integer ID of the queue for which those keys belong. Queues
  * are indexed from zero. For example, a frontend with two queues and split
  * event channels must write the following set of queue-related keys:
  *
  * /local/domain/1/device/vif/0/multi-queue-num-queues = "2"
  * /local/domain/1/device/vif/0/queue-0 = ""
  * /local/domain/1/device/vif/0/queue-0/tx-ring-ref = "<ring-ref-tx0>"
  * /local/domain/1/device/vif/0/queue-0/rx-ring-ref = "<ring-ref-rx0>"
  * /local/domain/1/device/vif/0/queue-0/event-channel-tx = "<evtchn-tx0>"
  * /local/domain/1/device/vif/0/queue-0/event-channel-rx = "<evtchn-rx0>"
  * /local/domain/1/device/vif/0/queue-1 = ""
  * /local/domain/1/device/vif/0/queue-1/tx-ring-ref = "<ring-ref-tx1>"
  * /local/domain/1/device/vif/0/queue-1/rx-ring-ref = "<ring-ref-rx1"
  * /local/domain/1/device/vif/0/queue-1/event-channel-tx = "<evtchn-tx1>"
  * /local/domain/1/device/vif/0/queue-1/event-channel-rx = "<evtchn-rx1>"
  *
  * If there is any inconsistency in the XenStore data, the backend may
  * choose not to connect any queues, instead treating the request as an
  * error. This includes scenarios where more (or fewer) queues were
  * requested than the frontend provided details for.
  *
  * Mapping of packets to queues is considered to be a function of the
  * transmitting system (backend or frontend) and is not negotiated
  * between the two. Guests are free to transmit packets on any queue
  * they choose, provided it has been set up correctly. Guests must be
  * prepared to receive packets on any queue they have requested be set up.
  */
 
 /*
  * "feature-no-csum-offload" should be used to turn IPv4 TCP/UDP checksum
  * offload off or on. If it is missing then the feature is assumed to be on.
  * "feature-ipv6-csum-offload" should be used to turn IPv6 TCP/UDP checksum
  * offload on or off. If it is missing then the feature is assumed to be off.
  */
 
 /*
  * "feature-gso-tcpv4" and "feature-gso-tcpv6" advertise the capability to
  * handle large TCP packets (in IPv4 or IPv6 form respectively). Neither
  * frontends nor backends are assumed to be capable unless the flags are
  * present.
  */
 
 /*
  * "feature-multicast-control" and "feature-dynamic-multicast-control"
  * advertise the capability to filter ethernet multicast packets in the
  * backend. If the frontend wishes to take advantage of this feature then
  * it may set "request-multicast-control". If the backend only advertises
  * "feature-multicast-control" then "request-multicast-control" must be set
  * before the frontend moves into the connected state. The backend will
  * sample the value on this state transition and any subsequent change in
  * value will have no effect. However, if the backend also advertises
  * "feature-dynamic-multicast-control" then "request-multicast-control"
  * may be set by the frontend at any time. In this case, the backend will
  * watch the value and re-sample on watch events.
  *
  * If the sampled value of "request-multicast-control" is set then the
  * backend transmit side should no longer flood multicast packets to the
  * frontend, it should instead drop any multicast packet that does not
  * match in a filter list.
  * The list is amended by the frontend by sending dummy transmit requests
  * containing XEN_NETIF_EXTRA_TYPE_MCAST_{ADD,DEL} extra-info fragments as
  * specified below.
  * Note that the filter list may be amended even if the sampled value of
  * "request-multicast-control" is not set, however the filter should only
  * be applied if it is set.
  */
 
 /*
  * "xdp-headroom" is used to request that extra space is added
  * for XDP processing.  The value is measured in bytes and passed by
  * the frontend to be consistent between both ends.
  * If the value is greater than zero that means that
  * an RX response is going to be passed to an XDP program for processing.
  * XEN_NETIF_MAX_XDP_HEADROOM defines the maximum headroom offset in bytes
  *
  * "feature-xdp-headroom" is set to "1" by the netback side like other features
  * so a guest can check if an XDP program can be processed.
  */
 #define XEN_NETIF_MAX_XDP_HEADROOM 0x7FFF
 
 /*
  * Control ring
  * ============
  *
  * Some features, such as hashing (detailed below), require a
  * significant amount of out-of-band data to be passed from frontend to
  * backend. Use of xenstore is not suitable for large quantities of data
  * because of quota limitations and so a dedicated 'control ring' is used.
  * The ability of the backend to use a control ring is advertised by
  * setting:
  *
  * /local/domain/X/backend/<domid>/<vif>/feature-ctrl-ring = "1"
  *
  * The frontend provides a control ring to the backend by setting:
  *
  * /local/domain/<domid>/device/vif/<vif>/ctrl-ring-ref = <gref>
  * /local/domain/<domid>/device/vif/<vif>/event-channel-ctrl = <port>
  *
  * where <gref> is the grant reference of the shared page used to
  * implement the control ring and <port> is an event channel to be used
  * as a mailbox interrupt. These keys must be set before the frontend
  * moves into the connected state.
  *
  * The control ring uses a fixed request/response message size and is
  * balanced (i.e. one request to one response), so operationally it is much
  * the same as a transmit or receive ring.
  * Note that there is no requirement that responses are issued in the same
  * order as requests.
  */
 
 /*
  * Hash types
  * ==========
  *
  * For the purposes of the definitions below, 'Packet[]' is an array of
  * octets containing an IP packet without options, 'Array[X..Y]' means a
  * sub-array of 'Array' containing bytes X thru Y inclusive, and '+' is
  * used to indicate concatenation of arrays.
  */
 
 /*
  * A hash calculated over an IP version 4 header as follows:
  *
  * Buffer[0..8] = Packet[12..15] (source address) +
  *                Packet[16..19] (destination address)
  *
  * Result = Hash(Buffer, 8)
  */
 #define _XEN_NETIF_CTRL_HASH_TYPE_IPV4 0
 #define XEN_NETIF_CTRL_HASH_TYPE_IPV4 \
     (1 << _XEN_NETIF_CTRL_HASH_TYPE_IPV4)
 
 /*
  * A hash calculated over an IP version 4 header and TCP header as
  * follows:
  *
  * Buffer[0..12] = Packet[12..15] (source address) +
  *                 Packet[16..19] (destination address) +
  *                 Packet[20..21] (source port) +
  *                 Packet[22..23] (destination port)
  *
  * Result = Hash(Buffer, 12)
  */
 #define _XEN_NETIF_CTRL_HASH_TYPE_IPV4_TCP 1
 #define XEN_NETIF_CTRL_HASH_TYPE_IPV4_TCP \
     (1 << _XEN_NETIF_CTRL_HASH_TYPE_IPV4_TCP)
 
 /*
  * A hash calculated over an IP version 6 header as follows:
  *
  * Buffer[0..32] = Packet[8..23]  (source address ) +
  *                 Packet[24..39] (destination address)
  *
  * Result = Hash(Buffer, 32)
  */
 #define _XEN_NETIF_CTRL_HASH_TYPE_IPV6 2
 #define XEN_NETIF_CTRL_HASH_TYPE_IPV6 \
     (1 << _XEN_NETIF_CTRL_HASH_TYPE_IPV6)
 
 /*
  * A hash calculated over an IP version 6 header and TCP header as
  * follows:
  *
  * Buffer[0..36] = Packet[8..23]  (source address) +
  *                 Packet[24..39] (destination address) +
  *                 Packet[40..41] (source port) +
  *                 Packet[42..43] (destination port)
  *
  * Result = Hash(Buffer, 36)
  */
 #define _XEN_NETIF_CTRL_HASH_TYPE_IPV6_TCP 3
 #define XEN_NETIF_CTRL_HASH_TYPE_IPV6_TCP \
     (1 << _XEN_NETIF_CTRL_HASH_TYPE_IPV6_TCP)
 
 /*
  * Hash algorithms
  * ===============
  */
 
 #define XEN_NETIF_CTRL_HASH_ALGORITHM_NONE 0
 
 /*
  * Toeplitz hash:
  */
 
 #define XEN_NETIF_CTRL_HASH_ALGORITHM_TOEPLITZ 1
 
 /*
  * This algorithm uses a 'key' as well as the data buffer itself.
  * (Buffer[] and Key[] are treated as shift-registers where the MSB of
  * Buffer/Key[0] is considered 'left-most' and the LSB of Buffer/Key[N-1]
  * is the 'right-most').
  *
  * Value = 0
  * For number of bits in Buffer[]
  *    If (left-most bit of Buffer[] is 1)
  *        Value ^= left-most 32 bits of Key[]
  *    Key[] << 1
  *    Buffer[] << 1
  *
  * The code below is provided for convenience where an operating system
  * does not already provide an implementation.
  */
 #ifdef XEN_NETIF_DEFINE_TOEPLITZ
 static uint32_t xen_netif_toeplitz_hash(const uint8_t *key,
                     unsigned int keylen,
                     const uint8_t *buf, unsigned int buflen)
 {
     unsigned int keyi, bufi;
     uint64_t prefix = 0;
     uint64_t hash = 0;
 
     /* Pre-load prefix with the first 8 bytes of the key */
     for (keyi = 0; keyi < 8; keyi++) {
         prefix <<= 8;
         prefix |= (keyi < keylen) ? key[keyi] : 0;
     }
 
     for (bufi = 0; bufi < buflen; bufi++) {
         uint8_t byte = buf[bufi];
         unsigned int bit;
 
         for (bit = 0; bit < 8; bit++) {
             if (byte & 0x80)
                 hash ^= prefix;
             prefix <<= 1;
             byte <<= 1;
         }
 
         /*
          * 'prefix' has now been left-shifted by 8, so
          * OR in the next byte.
          */
         prefix |= (keyi < keylen) ? key[keyi] : 0;
         keyi++;
     }
 
     /* The valid part of the hash is in the upper 32 bits. */
     return hash >> 32;
 }
 #endif              /* XEN_NETIF_DEFINE_TOEPLITZ */
 
 /*
  * Control requests (struct xen_netif_ctrl_request)
  * ================================================
  *
  * All requests have the following format:
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |    id     |   type    |         data[0]       |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |         data[1]       |         data[2]       |
  * +-----+-----+-----+-----+-----------------------+
  *
  * id: the request identifier, echoed in response.
  * type: the type of request (see below)
  * data[]: any data associated with the request (determined by type)
  */
 
 struct xen_netif_ctrl_request {
     uint16_t id;
     uint16_t type;
 
 #define XEN_NETIF_CTRL_TYPE_INVALID               0
 #define XEN_NETIF_CTRL_TYPE_GET_HASH_FLAGS        1
 #define XEN_NETIF_CTRL_TYPE_SET_HASH_FLAGS        2
 #define XEN_NETIF_CTRL_TYPE_SET_HASH_KEY          3
 #define XEN_NETIF_CTRL_TYPE_GET_HASH_MAPPING_SIZE 4
 #define XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING_SIZE 5
 #define XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING      6
 #define XEN_NETIF_CTRL_TYPE_SET_HASH_ALGORITHM    7
 
     uint32_t data[3];
 };
 
 /*
  * Control responses (struct xen_netif_ctrl_response)
  * ==================================================
  *
  * All responses have the following format:
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |    id     |   type    |         status        |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |         data          |
  * +-----+-----+-----+-----+
  *
  * id: the corresponding request identifier
  * type: the type of the corresponding request
  * status: the status of request processing
  * data: any data associated with the response (determined by type and
  *       status)
  */
 
 struct xen_netif_ctrl_response {
     uint16_t id;
     uint16_t type;
     uint32_t status;
 
 #define XEN_NETIF_CTRL_STATUS_SUCCESS           0
 #define XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED     1
 #define XEN_NETIF_CTRL_STATUS_INVALID_PARAMETER 2
 #define XEN_NETIF_CTRL_STATUS_BUFFER_OVERFLOW   3
 
     uint32_t data;
 };
 
 /*
  * Control messages
  * ================
  *
  * XEN_NETIF_CTRL_TYPE_SET_HASH_ALGORITHM
  * --------------------------------------
  *
  * This is sent by the frontend to set the desired hash algorithm.
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_SET_HASH_ALGORITHM
  *  data[0] = a XEN_NETIF_CTRL_HASH_ALGORITHM_* value
  *  data[1] = 0
  *  data[2] = 0
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED     - Operation not
  *                                                     supported
  *           XEN_NETIF_CTRL_STATUS_INVALID_PARAMETER - The algorithm is not
  *                                                     supported
  *           XEN_NETIF_CTRL_STATUS_SUCCESS           - Operation successful
  *
  * NOTE: Setting data[0] to XEN_NETIF_CTRL_HASH_ALGORITHM_NONE disables
  *       hashing and the backend is free to choose how it steers packets
  *       to queues (which is the default behaviour).
  *
  * XEN_NETIF_CTRL_TYPE_GET_HASH_FLAGS
  * ----------------------------------
  *
  * This is sent by the frontend to query the types of hash supported by
  * the backend.
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_GET_HASH_FLAGS
  *  data[0] = 0
  *  data[1] = 0
  *  data[2] = 0
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED - Operation not supported
  *           XEN_NETIF_CTRL_STATUS_SUCCESS       - Operation successful
  *  data   = supported hash types (if operation was successful)
  *
  * NOTE: A valid hash algorithm must be selected before this operation can
  *       succeed.
  *
  * XEN_NETIF_CTRL_TYPE_SET_HASH_FLAGS
  * ----------------------------------
  *
  * This is sent by the frontend to set the types of hash that the backend
  * should calculate. (See above for hash type definitions).
  * Note that the 'maximal' type of hash should always be chosen. For
  * example, if the frontend sets both IPV4 and IPV4_TCP hash types then
  * the latter hash type should be calculated for any TCP packet and the
  * former only calculated for non-TCP packets.
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_SET_HASH_FLAGS
  *  data[0] = bitwise OR of XEN_NETIF_CTRL_HASH_TYPE_* values
  *  data[1] = 0
  *  data[2] = 0
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED     - Operation not
  *                                                     supported
  *           XEN_NETIF_CTRL_STATUS_INVALID_PARAMETER - One or more flag
  *                                                     value is invalid or
  *                                                     unsupported
  *           XEN_NETIF_CTRL_STATUS_SUCCESS           - Operation successful
  *  data   = 0
  *
  * NOTE: A valid hash algorithm must be selected before this operation can
  *       succeed.
  *       Also, setting data[0] to zero disables hashing and the backend
  *       is free to choose how it steers packets to queues.
  *
  * XEN_NETIF_CTRL_TYPE_SET_HASH_KEY
  * --------------------------------
  *
  * This is sent by the frontend to set the key of the hash if the algorithm
  * requires it. (See hash algorithms above).
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_SET_HASH_KEY
  *  data[0] = grant reference of page containing the key (assumed to
  *            start at beginning of grant)
  *  data[1] = size of key in octets
  *  data[2] = 0
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED     - Operation not
  *                                                     supported
  *           XEN_NETIF_CTRL_STATUS_INVALID_PARAMETER - Key size is invalid
  *           XEN_NETIF_CTRL_STATUS_BUFFER_OVERFLOW   - Key size is larger
  *                                                     than the backend
  *                                                     supports
  *           XEN_NETIF_CTRL_STATUS_SUCCESS           - Operation successful
  *  data   = 0
  *
  * NOTE: Any key octets not specified are assumed to be zero (the key
  *       is assumed to be empty by default) and specifying a new key
  *       invalidates any previous key, hence specifying a key size of
  *       zero will clear the key (which ensures that the calculated hash
  *       will always be zero).
  *       The maximum size of key is algorithm and backend specific, but
  *       is also limited by the single grant reference.
  *       The grant reference may be read-only and must remain valid until
  *       the response has been processed.
  *
  * XEN_NETIF_CTRL_TYPE_GET_HASH_MAPPING_SIZE
  * -----------------------------------------
  *
  * This is sent by the frontend to query the maximum size of mapping
  * table supported by the backend. The size is specified in terms of
  * table entries.
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_GET_HASH_MAPPING_SIZE
  *  data[0] = 0
  *  data[1] = 0
  *  data[2] = 0
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED - Operation not supported
  *           XEN_NETIF_CTRL_STATUS_SUCCESS       - Operation successful
  *  data   = maximum number of entries allowed in the mapping table
  *           (if operation was successful) or zero if a mapping table is
  *           not supported (i.e. hash mapping is done only by modular
  *           arithmetic).
  *
  * XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING_SIZE
  * -------------------------------------
  *
  * This is sent by the frontend to set the actual size of the mapping
  * table to be used by the backend. The size is specified in terms of
  * table entries.
  * Any previous table is invalidated by this message and any new table
  * is assumed to be zero filled.
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING_SIZE
  *  data[0] = number of entries in mapping table
  *  data[1] = 0
  *  data[2] = 0
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED     - Operation not
  *                                                     supported
  *           XEN_NETIF_CTRL_STATUS_INVALID_PARAMETER - Table size is invalid
  *           XEN_NETIF_CTRL_STATUS_SUCCESS           - Operation successful
  *  data   = 0
  *
  * NOTE: Setting data[0] to 0 means that hash mapping should be done
  *       using modular arithmetic.
  *
  * XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING
  * ------------------------------------
  *
  * This is sent by the frontend to set the content of the table mapping
  * hash value to queue number. The backend should calculate the hash from
  * the packet header, use it as an index into the table (modulo the size
  * of the table) and then steer the packet to the queue number found at
  * that index.
  *
  * Request:
  *
  *  type    = XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING
  *  data[0] = grant reference of page containing the mapping (sub-)table
  *            (assumed to start at beginning of grant)
  *  data[1] = size of (sub-)table in entries
  *  data[2] = offset, in entries, of sub-table within overall table
  *
  * Response:
  *
  *  status = XEN_NETIF_CTRL_STATUS_NOT_SUPPORTED     - Operation not
  *                                                     supported
  *           XEN_NETIF_CTRL_STATUS_INVALID_PARAMETER - Table size or content
  *                                                     is invalid
  *           XEN_NETIF_CTRL_STATUS_BUFFER_OVERFLOW   - Table size is larger
  *                                                     than the backend
  *                                                     supports
  *           XEN_NETIF_CTRL_STATUS_SUCCESS           - Operation successful
  *  data   = 0
  *
  * NOTE: The overall table has the following format:
  *
  *          0     1     2     3     4     5     6     7  octet
  *       +-----+-----+-----+-----+-----+-----+-----+-----+
  *       |       mapping[0]      |       mapping[1]      |
  *       +-----+-----+-----+-----+-----+-----+-----+-----+
  *       |                       .                       |
  *       |                       .                       |
  *       |                       .                       |
  *       +-----+-----+-----+-----+-----+-----+-----+-----+
  *       |      mapping[N-2]     |      mapping[N-1]     |
  *       +-----+-----+-----+-----+-----+-----+-----+-----+
  *
  *       where N is specified by a XEN_NETIF_CTRL_TYPE_SET_HASH_MAPPING_SIZE
  *       message and each  mapping must specifies a queue between 0 and
  *       "multi-queue-num-queues" (see above).
  *       The backend may support a mapping table larger than can be
  *       mapped by a single grant reference. Thus sub-tables within a
  *       larger table can be individually set by sending multiple messages
  *       with differing offset values. Specifying a new sub-table does not
  *       invalidate any table data outside that range.
  *       The grant reference may be read-only and must remain valid until
  *       the response has been processed.
  */
 
 DEFINE_RING_TYPES(xen_netif_ctrl,
           struct xen_netif_ctrl_request,
           struct xen_netif_ctrl_response);
 
 /*
  * Guest transmit
  * ==============
  *
  * This is the 'wire' format for transmit (frontend -> backend) packets:
  *
  *  Fragment 1: xen_netif_tx_request_t  - flags = XEN_NETTXF_*
  *                                    size = total packet size
  * [Extra 1: xen_netif_extra_info_t]    - (only if fragment 1 flags include
  *                                     XEN_NETTXF_extra_info)
  *  ...
  * [Extra N: xen_netif_extra_info_t]    - (only if extra N-1 flags include
  *                                     XEN_NETIF_EXTRA_MORE)
  *  ...
  *  Fragment N: xen_netif_tx_request_t  - (only if fragment N-1 flags include
  *                                     XEN_NETTXF_more_data - flags on preceding
  *                                     extras are not relevant here)
  *                                    flags = 0
  *                                    size = fragment size
  *
  * NOTE:
  *
  * This format slightly is different from that used for receive
  * (backend -> frontend) packets. Specifically, in a multi-fragment
  * packet the actual size of fragment 1 can only be determined by
  * subtracting the sizes of fragments 2..N from the total packet size.
  *
  * Ring slot size is 12 octets, however not all request/response
  * structs use the full size.
  *
  * tx request data (xen_netif_tx_request_t)
  * ------------------------------------
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | grant ref             | offset    | flags     |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | id        | size      |
  * +-----+-----+-----+-----+
  *
  * grant ref: Reference to buffer page.
  * offset: Offset within buffer page.
  * flags: XEN_NETTXF_*.
  * id: request identifier, echoed in response.
  * size: packet size in bytes.
  *
  * tx response (xen_netif_tx_response_t)
  * ---------------------------------
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | id        | status    | unused                |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | unused                |
  * +-----+-----+-----+-----+
  *
  * id: reflects id in transmit request
  * status: XEN_NETIF_RSP_*
  *
  * Guest receive
  * =============
  *
  * This is the 'wire' format for receive (backend -> frontend) packets:
  *
  *  Fragment 1: xen_netif_rx_request_t  - flags = XEN_NETRXF_*
  *                                    size = fragment size
  * [Extra 1: xen_netif_extra_info_t]    - (only if fragment 1 flags include
  *                                     XEN_NETRXF_extra_info)
  *  ...
  * [Extra N: xen_netif_extra_info_t]    - (only if extra N-1 flags include
  *                                     XEN_NETIF_EXTRA_MORE)
  *  ...
  *  Fragment N: xen_netif_rx_request_t  - (only if fragment N-1 flags include
  *                                     XEN_NETRXF_more_data - flags on preceding
  *                                     extras are not relevant here)
  *                                    flags = 0
  *                                    size = fragment size
  *
  * NOTE:
  *
  * This format slightly is different from that used for transmit
  * (frontend -> backend) packets. Specifically, in a multi-fragment
  * packet the size of the packet can only be determined by summing the
  * sizes of fragments 1..N.
  *
  * Ring slot size is 8 octets.
  *
  * rx request (xen_netif_rx_request_t)
  * -------------------------------
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | id        | pad       | gref                  |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  *
  * id: request identifier, echoed in response.
  * gref: reference to incoming granted frame.
  *
  * rx response (xen_netif_rx_response_t)
  * ---------------------------------
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | id        | offset    | flags     | status    |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  *
  * id: reflects id in receive request
  * offset: offset in page of start of received packet
  * flags: XEN_NETRXF_*
  * status: -ve: XEN_NETIF_RSP_*; +ve: Rx'ed pkt size.
  *
  * NOTE: Historically, to support GSO on the frontend receive side, Linux
  *       netfront does not make use of the rx response id (because, as
  *       described below, extra info structures overlay the id field).
  *       Instead it assumes that responses always appear in the same ring
  *       slot as their corresponding request. Thus, to maintain
  *       compatibility, backends must make sure this is the case.
  *
  * Extra Info
  * ==========
  *
  * Can be present if initial request or response has NET{T,R}XF_extra_info,
  * or previous extra request has XEN_NETIF_EXTRA_MORE.
  *
  * The struct therefore needs to fit into either a tx or rx slot and
  * is therefore limited to 8 octets.
  *
  * NOTE: Because extra info data overlays the usual request/response
  *       structures, there is no id information in the opposite direction.
  *       So, if an extra info overlays an rx response the frontend can
  *       assume that it is in the same ring slot as the request that was
  *       consumed to make the slot available, and the backend must ensure
  *       this assumption is true.
  *
  * extra info (xen_netif_extra_info_t)
  * -------------------------------
  *
  * General format:
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |type |flags| type specific data                |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * | padding for tx        |
  * +-----+-----+-----+-----+
  *
  * type: XEN_NETIF_EXTRA_TYPE_*
  * flags: XEN_NETIF_EXTRA_FLAG_*
  * padding for tx: present only in the tx case due to 8 octet limit
  *                 from rx case. Not shown in type specific entries
  *                 below.
  *
  * XEN_NETIF_EXTRA_TYPE_GSO:
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |type |flags| size      |type | pad | features  |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  *
  * type: Must be XEN_NETIF_EXTRA_TYPE_GSO
  * flags: XEN_NETIF_EXTRA_FLAG_*
  * size: Maximum payload size of each segment. For example,
  *       for TCP this is just the path MSS.
  * type: XEN_NETIF_GSO_TYPE_*: This determines the protocol of
  *       the packet and any extra features required to segment the
  *       packet properly.
  * features: EN_XEN_NETIF_GSO_FEAT_*: This specifies any extra GSO
  *           features required to process this packet, such as ECN
  *           support for TCPv4.
  *
  * XEN_NETIF_EXTRA_TYPE_MCAST_{ADD,DEL}:
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |type |flags| addr                              |
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  *
  * type: Must be XEN_NETIF_EXTRA_TYPE_MCAST_{ADD,DEL}
  * flags: XEN_NETIF_EXTRA_FLAG_*
  * addr: address to add/remove
  *
  * XEN_NETIF_EXTRA_TYPE_HASH:
  *
  * A backend that supports teoplitz hashing is assumed to accept
  * this type of extra info in transmit packets.
  * A frontend that enables hashing is assumed to accept
  * this type of extra info in receive packets.
  *
  *    0     1     2     3     4     5     6     7  octet
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  * |type |flags|htype| alg |LSB ---- value ---- MSB|
  * +-----+-----+-----+-----+-----+-----+-----+-----+
  *
  * type: Must be XEN_NETIF_EXTRA_TYPE_HASH
  * flags: XEN_NETIF_EXTRA_FLAG_*
  * htype: Hash type (one of _XEN_NETIF_CTRL_HASH_TYPE_* - see above)
  * alg: The algorithm used to calculate the hash (one of
  *      XEN_NETIF_CTRL_HASH_TYPE_ALGORITHM_* - see above)
  * value: Hash value
  */
 
 /* Protocol checksum field is blank in the packet (hardware offload)? */
 #define _XEN_NETTXF_csum_blank     (0)
 #define  XEN_NETTXF_csum_blank     (1U<<_XEN_NETTXF_csum_blank)
 
 /* Packet data has been validated against protocol checksum. */
 #define _XEN_NETTXF_data_validated (1)
 #define  XEN_NETTXF_data_validated (1U<<_XEN_NETTXF_data_validated)
 
 /* Packet continues in the next request descriptor. */
 #define _XEN_NETTXF_more_data      (2)
 #define  XEN_NETTXF_more_data      (1U<<_XEN_NETTXF_more_data)
 
 /* Packet to be followed by extra descriptor(s). */
 #define _XEN_NETTXF_extra_info     (3)
 #define  XEN_NETTXF_extra_info     (1U<<_XEN_NETTXF_extra_info)
 
 #define XEN_NETIF_MAX_TX_SIZE 0xFFFF
 struct xen_netif_tx_request {
     grant_ref_t gref;
     uint16_t offset;
     uint16_t flags;
     uint16_t id;
     uint16_t size;
 };
 
 /* Types of xen_netif_extra_info descriptors. */
 #define XEN_NETIF_EXTRA_TYPE_NONE      (0)  /* Never used - invalid */
 #define XEN_NETIF_EXTRA_TYPE_GSO       (1)  /* u.gso */
 #define XEN_NETIF_EXTRA_TYPE_MCAST_ADD (2)  /* u.mcast */
 #define XEN_NETIF_EXTRA_TYPE_MCAST_DEL (3)  /* u.mcast */
 #define XEN_NETIF_EXTRA_TYPE_HASH      (4)  /* u.hash */
 #define XEN_NETIF_EXTRA_TYPE_XDP       (5)  /* u.xdp */
 #define XEN_NETIF_EXTRA_TYPE_MAX       (6)
 
 /* xen_netif_extra_info_t flags. */
 #define _XEN_NETIF_EXTRA_FLAG_MORE (0)
 #define XEN_NETIF_EXTRA_FLAG_MORE  (1U<<_XEN_NETIF_EXTRA_FLAG_MORE)
 
 /* GSO types */
 #define XEN_NETIF_GSO_TYPE_NONE         (0)
 #define XEN_NETIF_GSO_TYPE_TCPV4        (1)
 #define XEN_NETIF_GSO_TYPE_TCPV6        (2)
 
 /*
  * This structure needs to fit within both xen_netif_tx_request_t and
  * xen_netif_rx_response_t for compatibility.
  */
 struct xen_netif_extra_info {
     uint8_t type;
     uint8_t flags;
     union {
         struct {
             uint16_t size;
             uint8_t type;
             uint8_t pad;
             uint16_t features;
         } gso;
         struct {
             uint8_t addr[6];
         } mcast;
         struct {
             uint8_t type;
             uint8_t algorithm;
             uint8_t value[4];
         } hash;
         struct {
             uint16_t headroom;
             uint16_t pad[2];
         } xdp;
         uint16_t pad[3];
     } u;
 };
 
 struct xen_netif_tx_response {
     uint16_t id;
     int16_t status;
 };
 
 struct xen_netif_rx_request {
     uint16_t id;        /* Echoed in response message.        */
     uint16_t pad;
     grant_ref_t gref;
 };
 
 /* Packet data has been validated against protocol checksum. */
 #define _XEN_NETRXF_data_validated (0)
 #define  XEN_NETRXF_data_validated (1U<<_XEN_NETRXF_data_validated)
 
 /* Protocol checksum field is blank in the packet (hardware offload)? */
 #define _XEN_NETRXF_csum_blank     (1)
 #define  XEN_NETRXF_csum_blank     (1U<<_XEN_NETRXF_csum_blank)
 
 /* Packet continues in the next request descriptor. */
 #define _XEN_NETRXF_more_data      (2)
 #define  XEN_NETRXF_more_data      (1U<<_XEN_NETRXF_more_data)
 
 /* Packet to be followed by extra descriptor(s). */
 #define _XEN_NETRXF_extra_info     (3)
 #define  XEN_NETRXF_extra_info     (1U<<_XEN_NETRXF_extra_info)
 
 /* Packet has GSO prefix. Deprecated but included for compatibility */
 #define _XEN_NETRXF_gso_prefix     (4)
 #define  XEN_NETRXF_gso_prefix     (1U<<_XEN_NETRXF_gso_prefix)
 
 struct xen_netif_rx_response {
     uint16_t id;
     uint16_t offset;
     uint16_t flags;
     int16_t status;
 };
 
 /*
  * Generate xen_netif ring structures and types.
  */
 
 DEFINE_RING_TYPES(xen_netif_tx, struct xen_netif_tx_request,
           struct xen_netif_tx_response);
 DEFINE_RING_TYPES(xen_netif_rx, struct xen_netif_rx_request,
           struct xen_netif_rx_response);
 
 #define XEN_NETIF_RSP_DROPPED         -2
 #define XEN_NETIF_RSP_ERROR           -1
 #define XEN_NETIF_RSP_OKAY             0
 /* No response: used for auxiliary requests (e.g., xen_netif_extra_info_t). */
 #define XEN_NETIF_RSP_NULL             1
 
 #endif

This page was automatically generated by the 2.1.0 LXR engine. The LXR team