1#ifndef _LINUX_VIRTIO_NET_H 2#define _LINUX_VIRTIO_NET_H 3/* This header is BSD licensed so anyone can use the definitions to implement 4 * compatible drivers/servers. 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 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. Neither the name of IBM nor the names of its contributors 15 * may be used to endorse or promote products derived from this software 16 * without specific prior written permission. 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. */ 28#include "standard-headers/linux/types.h" 29#include "standard-headers/linux/virtio_ids.h" 30#include "standard-headers/linux/virtio_config.h" 31#include "standard-headers/linux/virtio_types.h" 32#include "standard-headers/linux/if_ether.h" 33 34/* The feature bitmap for virtio net */ 35#define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */ 36#define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */ 37#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2 /* Dynamic offload configuration. */ 38#define VIRTIO_NET_F_MTU 3 /* Initial MTU advice */ 39#define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */ 40#define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */ 41#define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */ 42#define VIRTIO_NET_F_GUEST_ECN 9 /* Guest can handle TSO[6] w/ ECN in. */ 43#define VIRTIO_NET_F_GUEST_UFO 10 /* Guest can handle UFO in. */ 44#define VIRTIO_NET_F_HOST_TSO4 11 /* Host can handle TSOv4 in. */ 45#define VIRTIO_NET_F_HOST_TSO6 12 /* Host can handle TSOv6 in. */ 46#define VIRTIO_NET_F_HOST_ECN 13 /* Host can handle TSO[6] w/ ECN in. */ 47#define VIRTIO_NET_F_HOST_UFO 14 /* Host can handle UFO in. */ 48#define VIRTIO_NET_F_MRG_RXBUF 15 /* Host can merge receive buffers. */ 49#define VIRTIO_NET_F_STATUS 16 /* virtio_net_config.status available */ 50#define VIRTIO_NET_F_CTRL_VQ 17 /* Control channel available */ 51#define VIRTIO_NET_F_CTRL_RX 18 /* Control channel RX mode support */ 52#define VIRTIO_NET_F_CTRL_VLAN 19 /* Control channel VLAN filtering */ 53#define VIRTIO_NET_F_CTRL_RX_EXTRA 20 /* Extra RX mode control support */ 54#define VIRTIO_NET_F_GUEST_ANNOUNCE 21 /* Guest can announce device on the 55 * network */ 56#define VIRTIO_NET_F_MQ 22 /* Device supports Receive Flow 57 * Steering */ 58#define VIRTIO_NET_F_CTRL_MAC_ADDR 23 /* Set MAC address */ 59#define VIRTIO_NET_F_NOTF_COAL 53 /* Device supports notifications coalescing */ 60#define VIRTIO_NET_F_GUEST_USO4 54 /* Guest can handle USOv4 in. */ 61#define VIRTIO_NET_F_GUEST_USO6 55 /* Guest can handle USOv6 in. */ 62#define VIRTIO_NET_F_HOST_USO 56 /* Host can handle USO in. */ 63#define VIRTIO_NET_F_HASH_REPORT 57 /* Supports hash report */ 64#define VIRTIO_NET_F_RSS 60 /* Supports RSS RX steering */ 65#define VIRTIO_NET_F_RSC_EXT 61 /* extended coalescing info */ 66#define VIRTIO_NET_F_STANDBY 62 /* Act as standby for another device 67 * with the same MAC. 68 */ 69#define VIRTIO_NET_F_SPEED_DUPLEX 63 /* Device set linkspeed and duplex */ 70 71#ifndef VIRTIO_NET_NO_LEGACY 72#define VIRTIO_NET_F_GSO 6 /* Host handles pkts w/ any GSO type */ 73#endif /* VIRTIO_NET_NO_LEGACY */ 74 75#define VIRTIO_NET_S_LINK_UP 1 /* Link is up */ 76#define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */ 77 78/* supported/enabled hash types */ 79#define VIRTIO_NET_RSS_HASH_TYPE_IPv4 (1 << 0) 80#define VIRTIO_NET_RSS_HASH_TYPE_TCPv4 (1 << 1) 81#define VIRTIO_NET_RSS_HASH_TYPE_UDPv4 (1 << 2) 82#define VIRTIO_NET_RSS_HASH_TYPE_IPv6 (1 << 3) 83#define VIRTIO_NET_RSS_HASH_TYPE_TCPv6 (1 << 4) 84#define VIRTIO_NET_RSS_HASH_TYPE_UDPv6 (1 << 5) 85#define VIRTIO_NET_RSS_HASH_TYPE_IP_EX (1 << 6) 86#define VIRTIO_NET_RSS_HASH_TYPE_TCP_EX (1 << 7) 87#define VIRTIO_NET_RSS_HASH_TYPE_UDP_EX (1 << 8) 88 89struct virtio_net_config { 90 /* The config defining mac address (if VIRTIO_NET_F_MAC) */ 91 uint8_t mac[ETH_ALEN]; 92 /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */ 93 __virtio16 status; 94 /* Maximum number of each of transmit and receive queues; 95 * see VIRTIO_NET_F_MQ and VIRTIO_NET_CTRL_MQ. 96 * Legal values are between 1 and 0x8000 97 */ 98 __virtio16 max_virtqueue_pairs; 99 /* Default maximum transmit unit advice */ 100 __virtio16 mtu; 101 /* 102 * speed, in units of 1Mb. All values 0 to INT_MAX are legal. 103 * Any other value stands for unknown. 104 */ 105 uint32_t speed; 106 /* 107 * 0x00 - half duplex 108 * 0x01 - full duplex 109 * Any other value stands for unknown. 110 */ 111 uint8_t duplex; 112 /* maximum size of RSS key */ 113 uint8_t rss_max_key_size; 114 /* maximum number of indirection table entries */ 115 uint16_t rss_max_indirection_table_length; 116 /* bitmask of supported VIRTIO_NET_RSS_HASH_ types */ 117 uint32_t supported_hash_types; 118} QEMU_PACKED; 119 120/* 121 * This header comes first in the scatter-gather list. If you don't 122 * specify GSO or CSUM features, you can simply ignore the header. 123 * 124 * This is bitwise-equivalent to the legacy struct virtio_net_hdr_mrg_rxbuf, 125 * only flattened. 126 */ 127struct virtio_net_hdr_v1 { 128#define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 /* Use csum_start, csum_offset */ 129#define VIRTIO_NET_HDR_F_DATA_VALID 2 /* Csum is valid */ 130#define VIRTIO_NET_HDR_F_RSC_INFO 4 /* rsc info in csum_ fields */ 131 uint8_t flags; 132#define VIRTIO_NET_HDR_GSO_NONE 0 /* Not a GSO frame */ 133#define VIRTIO_NET_HDR_GSO_TCPV4 1 /* GSO frame, IPv4 TCP (TSO) */ 134#define VIRTIO_NET_HDR_GSO_UDP 3 /* GSO frame, IPv4 UDP (UFO) */ 135#define VIRTIO_NET_HDR_GSO_TCPV6 4 /* GSO frame, IPv6 TCP */ 136#define VIRTIO_NET_HDR_GSO_UDP_L4 5 /* GSO frame, IPv4& IPv6 UDP (USO) */ 137#define VIRTIO_NET_HDR_GSO_ECN 0x80 /* TCP has ECN set */ 138 uint8_t gso_type; 139 __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */ 140 __virtio16 gso_size; /* Bytes to append to hdr_len per frame */ 141 union { 142 struct { 143 __virtio16 csum_start; 144 __virtio16 csum_offset; 145 }; 146 /* Checksum calculation */ 147 struct { 148 /* Position to start checksumming from */ 149 __virtio16 start; 150 /* Offset after that to place checksum */ 151 __virtio16 offset; 152 } csum; 153 /* Receive Segment Coalescing */ 154 struct { 155 /* Number of coalesced segments */ 156 uint16_t segments; 157 /* Number of duplicated acks */ 158 uint16_t dup_acks; 159 } rsc; 160 }; 161 __virtio16 num_buffers; /* Number of merged rx buffers */ 162}; 163 164struct virtio_net_hdr_v1_hash { 165 struct virtio_net_hdr_v1 hdr; 166 uint32_t hash_value; 167#define VIRTIO_NET_HASH_REPORT_NONE 0 168#define VIRTIO_NET_HASH_REPORT_IPv4 1 169#define VIRTIO_NET_HASH_REPORT_TCPv4 2 170#define VIRTIO_NET_HASH_REPORT_UDPv4 3 171#define VIRTIO_NET_HASH_REPORT_IPv6 4 172#define VIRTIO_NET_HASH_REPORT_TCPv6 5 173#define VIRTIO_NET_HASH_REPORT_UDPv6 6 174#define VIRTIO_NET_HASH_REPORT_IPv6_EX 7 175#define VIRTIO_NET_HASH_REPORT_TCPv6_EX 8 176#define VIRTIO_NET_HASH_REPORT_UDPv6_EX 9 177 uint16_t hash_report; 178 uint16_t padding; 179}; 180 181#ifndef VIRTIO_NET_NO_LEGACY 182/* This header comes first in the scatter-gather list. 183 * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated, it must 184 * be the first element of the scatter-gather list. If you don't 185 * specify GSO or CSUM features, you can simply ignore the header. */ 186struct virtio_net_hdr { 187 /* See VIRTIO_NET_HDR_F_* */ 188 uint8_t flags; 189 /* See VIRTIO_NET_HDR_GSO_* */ 190 uint8_t gso_type; 191 __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */ 192 __virtio16 gso_size; /* Bytes to append to hdr_len per frame */ 193 __virtio16 csum_start; /* Position to start checksumming from */ 194 __virtio16 csum_offset; /* Offset after that to place checksum */ 195}; 196 197/* This is the version of the header to use when the MRG_RXBUF 198 * feature has been negotiated. */ 199struct virtio_net_hdr_mrg_rxbuf { 200 struct virtio_net_hdr hdr; 201 __virtio16 num_buffers; /* Number of merged rx buffers */ 202}; 203#endif /* ...VIRTIO_NET_NO_LEGACY */ 204 205/* 206 * Control virtqueue data structures 207 * 208 * The control virtqueue expects a header in the first sg entry 209 * and an ack/status response in the last entry. Data for the 210 * command goes in between. 211 */ 212struct virtio_net_ctrl_hdr { 213 uint8_t class; 214 uint8_t cmd; 215} QEMU_PACKED; 216 217typedef uint8_t virtio_net_ctrl_ack; 218 219#define VIRTIO_NET_OK 0 220#define VIRTIO_NET_ERR 1 221 222/* 223 * Control the RX mode, ie. promisucous, allmulti, etc... 224 * All commands require an "out" sg entry containing a 1 byte 225 * state value, zero = disable, non-zero = enable. Commands 226 * 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature. 227 * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA. 228 */ 229#define VIRTIO_NET_CTRL_RX 0 230 #define VIRTIO_NET_CTRL_RX_PROMISC 0 231 #define VIRTIO_NET_CTRL_RX_ALLMULTI 1 232 #define VIRTIO_NET_CTRL_RX_ALLUNI 2 233 #define VIRTIO_NET_CTRL_RX_NOMULTI 3 234 #define VIRTIO_NET_CTRL_RX_NOUNI 4 235 #define VIRTIO_NET_CTRL_RX_NOBCAST 5 236 237/* 238 * Control the MAC 239 * 240 * The MAC filter table is managed by the hypervisor, the guest should 241 * assume the size is infinite. Filtering should be considered 242 * non-perfect, ie. based on hypervisor resources, the guest may 243 * received packets from sources not specified in the filter list. 244 * 245 * In addition to the class/cmd header, the TABLE_SET command requires 246 * two out scatterlists. Each contains a 4 byte count of entries followed 247 * by a concatenated byte stream of the ETH_ALEN MAC addresses. The 248 * first sg list contains unicast addresses, the second is for multicast. 249 * This functionality is present if the VIRTIO_NET_F_CTRL_RX feature 250 * is available. 251 * 252 * The ADDR_SET command requests one out scatterlist, it contains a 253 * 6 bytes MAC address. This functionality is present if the 254 * VIRTIO_NET_F_CTRL_MAC_ADDR feature is available. 255 */ 256struct virtio_net_ctrl_mac { 257 __virtio32 entries; 258 uint8_t macs[][ETH_ALEN]; 259} QEMU_PACKED; 260 261#define VIRTIO_NET_CTRL_MAC 1 262 #define VIRTIO_NET_CTRL_MAC_TABLE_SET 0 263 #define VIRTIO_NET_CTRL_MAC_ADDR_SET 1 264 265/* 266 * Control VLAN filtering 267 * 268 * The VLAN filter table is controlled via a simple ADD/DEL interface. 269 * VLAN IDs not added may be filterd by the hypervisor. Del is the 270 * opposite of add. Both commands expect an out entry containing a 2 271 * byte VLAN ID. VLAN filterting is available with the 272 * VIRTIO_NET_F_CTRL_VLAN feature bit. 273 */ 274#define VIRTIO_NET_CTRL_VLAN 2 275 #define VIRTIO_NET_CTRL_VLAN_ADD 0 276 #define VIRTIO_NET_CTRL_VLAN_DEL 1 277 278/* 279 * Control link announce acknowledgement 280 * 281 * The command VIRTIO_NET_CTRL_ANNOUNCE_ACK is used to indicate that 282 * driver has recevied the notification; device would clear the 283 * VIRTIO_NET_S_ANNOUNCE bit in the status field after it receives 284 * this command. 285 */ 286#define VIRTIO_NET_CTRL_ANNOUNCE 3 287 #define VIRTIO_NET_CTRL_ANNOUNCE_ACK 0 288 289/* 290 * Control Receive Flow Steering 291 */ 292#define VIRTIO_NET_CTRL_MQ 4 293/* 294 * The command VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 295 * enables Receive Flow Steering, specifying the number of the transmit and 296 * receive queues that will be used. After the command is consumed and acked by 297 * the device, the device will not steer new packets on receive virtqueues 298 * other than specified nor read from transmit virtqueues other than specified. 299 * Accordingly, driver should not transmit new packets on virtqueues other than 300 * specified. 301 */ 302struct virtio_net_ctrl_mq { 303 __virtio16 virtqueue_pairs; 304}; 305 306 #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 0 307 #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1 308 #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000 309 310/* 311 * The command VIRTIO_NET_CTRL_MQ_RSS_CONFIG has the same effect as 312 * VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET does and additionally configures 313 * the receive steering to use a hash calculated for incoming packet 314 * to decide on receive virtqueue to place the packet. The command 315 * also provides parameters to calculate a hash and receive virtqueue. 316 */ 317struct virtio_net_rss_config { 318 uint32_t hash_types; 319 uint16_t indirection_table_mask; 320 uint16_t unclassified_queue; 321 uint16_t indirection_table[1/* + indirection_table_mask */]; 322 uint16_t max_tx_vq; 323 uint8_t hash_key_length; 324 uint8_t hash_key_data[/* hash_key_length */]; 325}; 326 327 #define VIRTIO_NET_CTRL_MQ_RSS_CONFIG 1 328 329/* 330 * The command VIRTIO_NET_CTRL_MQ_HASH_CONFIG requests the device 331 * to include in the virtio header of the packet the value of the 332 * calculated hash and the report type of hash. It also provides 333 * parameters for hash calculation. The command requires feature 334 * VIRTIO_NET_F_HASH_REPORT to be negotiated to extend the 335 * layout of virtio header as defined in virtio_net_hdr_v1_hash. 336 */ 337struct virtio_net_hash_config { 338 uint32_t hash_types; 339 /* for compatibility with virtio_net_rss_config */ 340 uint16_t reserved[4]; 341 uint8_t hash_key_length; 342 uint8_t hash_key_data[/* hash_key_length */]; 343}; 344 345 #define VIRTIO_NET_CTRL_MQ_HASH_CONFIG 2 346 347/* 348 * Control network offloads 349 * 350 * Reconfigures the network offloads that Guest can handle. 351 * 352 * Available with the VIRTIO_NET_F_CTRL_GUEST_OFFLOADS feature bit. 353 * 354 * Command data format matches the feature bit mask exactly. 355 * 356 * See VIRTIO_NET_F_GUEST_* for the list of offloads 357 * that can be enabled/disabled. 358 */ 359#define VIRTIO_NET_CTRL_GUEST_OFFLOADS 5 360#define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET 0 361 362/* 363 * Control notifications coalescing. 364 * 365 * Request the device to change the notifications coalescing parameters. 366 * 367 * Available with the VIRTIO_NET_F_NOTF_COAL feature bit. 368 */ 369#define VIRTIO_NET_CTRL_NOTF_COAL 6 370/* 371 * Set the tx-usecs/tx-max-packets parameters. 372 */ 373struct virtio_net_ctrl_coal_tx { 374 /* Maximum number of packets to send before a TX notification */ 375 uint32_t tx_max_packets; 376 /* Maximum number of usecs to delay a TX notification */ 377 uint32_t tx_usecs; 378}; 379 380#define VIRTIO_NET_CTRL_NOTF_COAL_TX_SET 0 381 382/* 383 * Set the rx-usecs/rx-max-packets parameters. 384 */ 385struct virtio_net_ctrl_coal_rx { 386 /* Maximum number of packets to receive before a RX notification */ 387 uint32_t rx_max_packets; 388 /* Maximum number of usecs to delay a RX notification */ 389 uint32_t rx_usecs; 390}; 391 392#define VIRTIO_NET_CTRL_NOTF_COAL_RX_SET 1 393 394#endif /* _LINUX_VIRTIO_NET_H */ 395