logo

oasis-root

Compiled tree of Oasis Linux based on own branch at <https://hacktivis.me/git/oasis/> git clone https://anongit.hacktivis.me/git/oasis-root.git

virtio_net.h (18633B)


  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 <linux/types.h>
  29. #include <linux/virtio_ids.h>
  30. #include <linux/virtio_config.h>
  31. #include <linux/virtio_types.h>
  32. #include <linux/if_ether.h>
  33. /* The feature bitmap for virtio net */
  34. #define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */
  35. #define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */
  36. #define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2 /* Dynamic offload configuration. */
  37. #define VIRTIO_NET_F_MTU 3 /* Initial MTU advice */
  38. #define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */
  39. #define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */
  40. #define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */
  41. #define VIRTIO_NET_F_GUEST_ECN 9 /* Guest can handle TSO[6] w/ ECN in. */
  42. #define VIRTIO_NET_F_GUEST_UFO 10 /* Guest can handle UFO in. */
  43. #define VIRTIO_NET_F_HOST_TSO4 11 /* Host can handle TSOv4 in. */
  44. #define VIRTIO_NET_F_HOST_TSO6 12 /* Host can handle TSOv6 in. */
  45. #define VIRTIO_NET_F_HOST_ECN 13 /* Host can handle TSO[6] w/ ECN in. */
  46. #define VIRTIO_NET_F_HOST_UFO 14 /* Host can handle UFO in. */
  47. #define VIRTIO_NET_F_MRG_RXBUF 15 /* Host can merge receive buffers. */
  48. #define VIRTIO_NET_F_STATUS 16 /* virtio_net_config.status available */
  49. #define VIRTIO_NET_F_CTRL_VQ 17 /* Control channel available */
  50. #define VIRTIO_NET_F_CTRL_RX 18 /* Control channel RX mode support */
  51. #define VIRTIO_NET_F_CTRL_VLAN 19 /* Control channel VLAN filtering */
  52. #define VIRTIO_NET_F_CTRL_RX_EXTRA 20 /* Extra RX mode control support */
  53. #define VIRTIO_NET_F_GUEST_ANNOUNCE 21 /* Guest can announce device on the
  54. * network */
  55. #define VIRTIO_NET_F_MQ 22 /* Device supports Receive Flow
  56. * Steering */
  57. #define VIRTIO_NET_F_CTRL_MAC_ADDR 23 /* Set MAC address */
  58. #define VIRTIO_NET_F_DEVICE_STATS 50 /* Device can provide device-level statistics. */
  59. #define VIRTIO_NET_F_VQ_NOTF_COAL 52 /* Device supports virtqueue notification coalescing */
  60. #define VIRTIO_NET_F_NOTF_COAL 53 /* Device supports notifications coalescing */
  61. #define VIRTIO_NET_F_GUEST_USO4 54 /* Guest can handle USOv4 in. */
  62. #define VIRTIO_NET_F_GUEST_USO6 55 /* Guest can handle USOv6 in. */
  63. #define VIRTIO_NET_F_HOST_USO 56 /* Host can handle USO in. */
  64. #define VIRTIO_NET_F_HASH_REPORT 57 /* Supports hash report */
  65. #define VIRTIO_NET_F_GUEST_HDRLEN 59 /* Guest provides the exact hdr_len value. */
  66. #define VIRTIO_NET_F_RSS 60 /* Supports RSS RX steering */
  67. #define VIRTIO_NET_F_RSC_EXT 61 /* extended coalescing info */
  68. #define VIRTIO_NET_F_STANDBY 62 /* Act as standby for another device
  69. * with the same MAC.
  70. */
  71. #define VIRTIO_NET_F_SPEED_DUPLEX 63 /* Device set linkspeed and duplex */
  72. #ifndef VIRTIO_NET_NO_LEGACY
  73. #define VIRTIO_NET_F_GSO 6 /* Host handles pkts w/ any GSO type */
  74. #endif /* VIRTIO_NET_NO_LEGACY */
  75. #define VIRTIO_NET_S_LINK_UP 1 /* Link is up */
  76. #define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */
  77. /* supported/enabled hash types */
  78. #define VIRTIO_NET_RSS_HASH_TYPE_IPv4 (1 << 0)
  79. #define VIRTIO_NET_RSS_HASH_TYPE_TCPv4 (1 << 1)
  80. #define VIRTIO_NET_RSS_HASH_TYPE_UDPv4 (1 << 2)
  81. #define VIRTIO_NET_RSS_HASH_TYPE_IPv6 (1 << 3)
  82. #define VIRTIO_NET_RSS_HASH_TYPE_TCPv6 (1 << 4)
  83. #define VIRTIO_NET_RSS_HASH_TYPE_UDPv6 (1 << 5)
  84. #define VIRTIO_NET_RSS_HASH_TYPE_IP_EX (1 << 6)
  85. #define VIRTIO_NET_RSS_HASH_TYPE_TCP_EX (1 << 7)
  86. #define VIRTIO_NET_RSS_HASH_TYPE_UDP_EX (1 << 8)
  87. struct virtio_net_config {
  88. /* The config defining mac address (if VIRTIO_NET_F_MAC) */
  89. __u8 mac[ETH_ALEN];
  90. /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
  91. __virtio16 status;
  92. /* Maximum number of each of transmit and receive queues;
  93. * see VIRTIO_NET_F_MQ and VIRTIO_NET_CTRL_MQ.
  94. * Legal values are between 1 and 0x8000
  95. */
  96. __virtio16 max_virtqueue_pairs;
  97. /* Default maximum transmit unit advice */
  98. __virtio16 mtu;
  99. /*
  100. * speed, in units of 1Mb. All values 0 to INT_MAX are legal.
  101. * Any other value stands for unknown.
  102. */
  103. __le32 speed;
  104. /*
  105. * 0x00 - half duplex
  106. * 0x01 - full duplex
  107. * Any other value stands for unknown.
  108. */
  109. __u8 duplex;
  110. /* maximum size of RSS key */
  111. __u8 rss_max_key_size;
  112. /* maximum number of indirection table entries */
  113. __le16 rss_max_indirection_table_length;
  114. /* bitmask of supported VIRTIO_NET_RSS_HASH_ types */
  115. __le32 supported_hash_types;
  116. } __attribute__((packed));
  117. /*
  118. * This header comes first in the scatter-gather list. If you don't
  119. * specify GSO or CSUM features, you can simply ignore the header.
  120. *
  121. * This is bitwise-equivalent to the legacy struct virtio_net_hdr_mrg_rxbuf,
  122. * only flattened.
  123. */
  124. struct virtio_net_hdr_v1 {
  125. #define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 /* Use csum_start, csum_offset */
  126. #define VIRTIO_NET_HDR_F_DATA_VALID 2 /* Csum is valid */
  127. #define VIRTIO_NET_HDR_F_RSC_INFO 4 /* rsc info in csum_ fields */
  128. __u8 flags;
  129. #define VIRTIO_NET_HDR_GSO_NONE 0 /* Not a GSO frame */
  130. #define VIRTIO_NET_HDR_GSO_TCPV4 1 /* GSO frame, IPv4 TCP (TSO) */
  131. #define VIRTIO_NET_HDR_GSO_UDP 3 /* GSO frame, IPv4 UDP (UFO) */
  132. #define VIRTIO_NET_HDR_GSO_TCPV6 4 /* GSO frame, IPv6 TCP */
  133. #define VIRTIO_NET_HDR_GSO_UDP_L4 5 /* GSO frame, IPv4& IPv6 UDP (USO) */
  134. #define VIRTIO_NET_HDR_GSO_ECN 0x80 /* TCP has ECN set */
  135. __u8 gso_type;
  136. __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
  137. __virtio16 gso_size; /* Bytes to append to hdr_len per frame */
  138. union {
  139. struct {
  140. __virtio16 csum_start;
  141. __virtio16 csum_offset;
  142. };
  143. /* Checksum calculation */
  144. struct {
  145. /* Position to start checksumming from */
  146. __virtio16 start;
  147. /* Offset after that to place checksum */
  148. __virtio16 offset;
  149. } csum;
  150. /* Receive Segment Coalescing */
  151. struct {
  152. /* Number of coalesced segments */
  153. __le16 segments;
  154. /* Number of duplicated acks */
  155. __le16 dup_acks;
  156. } rsc;
  157. };
  158. __virtio16 num_buffers; /* Number of merged rx buffers */
  159. };
  160. struct virtio_net_hdr_v1_hash {
  161. struct virtio_net_hdr_v1 hdr;
  162. __le32 hash_value;
  163. #define VIRTIO_NET_HASH_REPORT_NONE 0
  164. #define VIRTIO_NET_HASH_REPORT_IPv4 1
  165. #define VIRTIO_NET_HASH_REPORT_TCPv4 2
  166. #define VIRTIO_NET_HASH_REPORT_UDPv4 3
  167. #define VIRTIO_NET_HASH_REPORT_IPv6 4
  168. #define VIRTIO_NET_HASH_REPORT_TCPv6 5
  169. #define VIRTIO_NET_HASH_REPORT_UDPv6 6
  170. #define VIRTIO_NET_HASH_REPORT_IPv6_EX 7
  171. #define VIRTIO_NET_HASH_REPORT_TCPv6_EX 8
  172. #define VIRTIO_NET_HASH_REPORT_UDPv6_EX 9
  173. __le16 hash_report;
  174. __le16 padding;
  175. };
  176. #ifndef VIRTIO_NET_NO_LEGACY
  177. /* This header comes first in the scatter-gather list.
  178. * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated, it must
  179. * be the first element of the scatter-gather list. If you don't
  180. * specify GSO or CSUM features, you can simply ignore the header. */
  181. struct virtio_net_hdr {
  182. /* See VIRTIO_NET_HDR_F_* */
  183. __u8 flags;
  184. /* See VIRTIO_NET_HDR_GSO_* */
  185. __u8 gso_type;
  186. __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
  187. __virtio16 gso_size; /* Bytes to append to hdr_len per frame */
  188. __virtio16 csum_start; /* Position to start checksumming from */
  189. __virtio16 csum_offset; /* Offset after that to place checksum */
  190. };
  191. /* This is the version of the header to use when the MRG_RXBUF
  192. * feature has been negotiated. */
  193. struct virtio_net_hdr_mrg_rxbuf {
  194. struct virtio_net_hdr hdr;
  195. __virtio16 num_buffers; /* Number of merged rx buffers */
  196. };
  197. #endif /* ...VIRTIO_NET_NO_LEGACY */
  198. /*
  199. * Control virtqueue data structures
  200. *
  201. * The control virtqueue expects a header in the first sg entry
  202. * and an ack/status response in the last entry. Data for the
  203. * command goes in between.
  204. */
  205. struct virtio_net_ctrl_hdr {
  206. __u8 class;
  207. __u8 cmd;
  208. } __attribute__((packed));
  209. typedef __u8 virtio_net_ctrl_ack;
  210. #define VIRTIO_NET_OK 0
  211. #define VIRTIO_NET_ERR 1
  212. /*
  213. * Control the RX mode, ie. promisucous, allmulti, etc...
  214. * All commands require an "out" sg entry containing a 1 byte
  215. * state value, zero = disable, non-zero = enable. Commands
  216. * 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature.
  217. * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA.
  218. */
  219. #define VIRTIO_NET_CTRL_RX 0
  220. #define VIRTIO_NET_CTRL_RX_PROMISC 0
  221. #define VIRTIO_NET_CTRL_RX_ALLMULTI 1
  222. #define VIRTIO_NET_CTRL_RX_ALLUNI 2
  223. #define VIRTIO_NET_CTRL_RX_NOMULTI 3
  224. #define VIRTIO_NET_CTRL_RX_NOUNI 4
  225. #define VIRTIO_NET_CTRL_RX_NOBCAST 5
  226. /*
  227. * Control the MAC
  228. *
  229. * The MAC filter table is managed by the hypervisor, the guest should
  230. * assume the size is infinite. Filtering should be considered
  231. * non-perfect, ie. based on hypervisor resources, the guest may
  232. * received packets from sources not specified in the filter list.
  233. *
  234. * In addition to the class/cmd header, the TABLE_SET command requires
  235. * two out scatterlists. Each contains a 4 byte count of entries followed
  236. * by a concatenated byte stream of the ETH_ALEN MAC addresses. The
  237. * first sg list contains unicast addresses, the second is for multicast.
  238. * This functionality is present if the VIRTIO_NET_F_CTRL_RX feature
  239. * is available.
  240. *
  241. * The ADDR_SET command requests one out scatterlist, it contains a
  242. * 6 bytes MAC address. This functionality is present if the
  243. * VIRTIO_NET_F_CTRL_MAC_ADDR feature is available.
  244. */
  245. struct virtio_net_ctrl_mac {
  246. __virtio32 entries;
  247. __u8 macs[][ETH_ALEN];
  248. } __attribute__((packed));
  249. #define VIRTIO_NET_CTRL_MAC 1
  250. #define VIRTIO_NET_CTRL_MAC_TABLE_SET 0
  251. #define VIRTIO_NET_CTRL_MAC_ADDR_SET 1
  252. /*
  253. * Control VLAN filtering
  254. *
  255. * The VLAN filter table is controlled via a simple ADD/DEL interface.
  256. * VLAN IDs not added may be filterd by the hypervisor. Del is the
  257. * opposite of add. Both commands expect an out entry containing a 2
  258. * byte VLAN ID. VLAN filterting is available with the
  259. * VIRTIO_NET_F_CTRL_VLAN feature bit.
  260. */
  261. #define VIRTIO_NET_CTRL_VLAN 2
  262. #define VIRTIO_NET_CTRL_VLAN_ADD 0
  263. #define VIRTIO_NET_CTRL_VLAN_DEL 1
  264. /*
  265. * Control link announce acknowledgement
  266. *
  267. * The command VIRTIO_NET_CTRL_ANNOUNCE_ACK is used to indicate that
  268. * driver has recevied the notification; device would clear the
  269. * VIRTIO_NET_S_ANNOUNCE bit in the status field after it receives
  270. * this command.
  271. */
  272. #define VIRTIO_NET_CTRL_ANNOUNCE 3
  273. #define VIRTIO_NET_CTRL_ANNOUNCE_ACK 0
  274. /*
  275. * Control Receive Flow Steering
  276. */
  277. #define VIRTIO_NET_CTRL_MQ 4
  278. /*
  279. * The command VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET
  280. * enables Receive Flow Steering, specifying the number of the transmit and
  281. * receive queues that will be used. After the command is consumed and acked by
  282. * the device, the device will not steer new packets on receive virtqueues
  283. * other than specified nor read from transmit virtqueues other than specified.
  284. * Accordingly, driver should not transmit new packets on virtqueues other than
  285. * specified.
  286. */
  287. struct virtio_net_ctrl_mq {
  288. __virtio16 virtqueue_pairs;
  289. };
  290. #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 0
  291. #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1
  292. #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000
  293. /*
  294. * The command VIRTIO_NET_CTRL_MQ_RSS_CONFIG has the same effect as
  295. * VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET does and additionally configures
  296. * the receive steering to use a hash calculated for incoming packet
  297. * to decide on receive virtqueue to place the packet. The command
  298. * also provides parameters to calculate a hash and receive virtqueue.
  299. */
  300. struct virtio_net_rss_config {
  301. __le32 hash_types;
  302. __le16 indirection_table_mask;
  303. __le16 unclassified_queue;
  304. __le16 indirection_table[1/* + indirection_table_mask */];
  305. __le16 max_tx_vq;
  306. __u8 hash_key_length;
  307. __u8 hash_key_data[/* hash_key_length */];
  308. };
  309. #define VIRTIO_NET_CTRL_MQ_RSS_CONFIG 1
  310. /*
  311. * The command VIRTIO_NET_CTRL_MQ_HASH_CONFIG requests the device
  312. * to include in the virtio header of the packet the value of the
  313. * calculated hash and the report type of hash. It also provides
  314. * parameters for hash calculation. The command requires feature
  315. * VIRTIO_NET_F_HASH_REPORT to be negotiated to extend the
  316. * layout of virtio header as defined in virtio_net_hdr_v1_hash.
  317. */
  318. struct virtio_net_hash_config {
  319. __le32 hash_types;
  320. /* for compatibility with virtio_net_rss_config */
  321. __le16 reserved[4];
  322. __u8 hash_key_length;
  323. __u8 hash_key_data[/* hash_key_length */];
  324. };
  325. #define VIRTIO_NET_CTRL_MQ_HASH_CONFIG 2
  326. /*
  327. * Control network offloads
  328. *
  329. * Reconfigures the network offloads that Guest can handle.
  330. *
  331. * Available with the VIRTIO_NET_F_CTRL_GUEST_OFFLOADS feature bit.
  332. *
  333. * Command data format matches the feature bit mask exactly.
  334. *
  335. * See VIRTIO_NET_F_GUEST_* for the list of offloads
  336. * that can be enabled/disabled.
  337. */
  338. #define VIRTIO_NET_CTRL_GUEST_OFFLOADS 5
  339. #define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET 0
  340. /*
  341. * Control notifications coalescing.
  342. *
  343. * Request the device to change the notifications coalescing parameters.
  344. *
  345. * Available with the VIRTIO_NET_F_NOTF_COAL feature bit.
  346. */
  347. #define VIRTIO_NET_CTRL_NOTF_COAL 6
  348. /*
  349. * Set the tx-usecs/tx-max-packets parameters.
  350. */
  351. struct virtio_net_ctrl_coal_tx {
  352. /* Maximum number of packets to send before a TX notification */
  353. __le32 tx_max_packets;
  354. /* Maximum number of usecs to delay a TX notification */
  355. __le32 tx_usecs;
  356. };
  357. #define VIRTIO_NET_CTRL_NOTF_COAL_TX_SET 0
  358. /*
  359. * Set the rx-usecs/rx-max-packets parameters.
  360. */
  361. struct virtio_net_ctrl_coal_rx {
  362. /* Maximum number of packets to receive before a RX notification */
  363. __le32 rx_max_packets;
  364. /* Maximum number of usecs to delay a RX notification */
  365. __le32 rx_usecs;
  366. };
  367. #define VIRTIO_NET_CTRL_NOTF_COAL_RX_SET 1
  368. #define VIRTIO_NET_CTRL_NOTF_COAL_VQ_SET 2
  369. #define VIRTIO_NET_CTRL_NOTF_COAL_VQ_GET 3
  370. struct virtio_net_ctrl_coal {
  371. __le32 max_packets;
  372. __le32 max_usecs;
  373. };
  374. struct virtio_net_ctrl_coal_vq {
  375. __le16 vqn;
  376. __le16 reserved;
  377. struct virtio_net_ctrl_coal coal;
  378. };
  379. /*
  380. * Device Statistics
  381. */
  382. #define VIRTIO_NET_CTRL_STATS 8
  383. #define VIRTIO_NET_CTRL_STATS_QUERY 0
  384. #define VIRTIO_NET_CTRL_STATS_GET 1
  385. struct virtio_net_stats_capabilities {
  386. #define VIRTIO_NET_STATS_TYPE_CVQ (1ULL << 32)
  387. #define VIRTIO_NET_STATS_TYPE_RX_BASIC (1ULL << 0)
  388. #define VIRTIO_NET_STATS_TYPE_RX_CSUM (1ULL << 1)
  389. #define VIRTIO_NET_STATS_TYPE_RX_GSO (1ULL << 2)
  390. #define VIRTIO_NET_STATS_TYPE_RX_SPEED (1ULL << 3)
  391. #define VIRTIO_NET_STATS_TYPE_TX_BASIC (1ULL << 16)
  392. #define VIRTIO_NET_STATS_TYPE_TX_CSUM (1ULL << 17)
  393. #define VIRTIO_NET_STATS_TYPE_TX_GSO (1ULL << 18)
  394. #define VIRTIO_NET_STATS_TYPE_TX_SPEED (1ULL << 19)
  395. __le64 supported_stats_types[1];
  396. };
  397. struct virtio_net_ctrl_queue_stats {
  398. struct {
  399. __le16 vq_index;
  400. __le16 reserved[3];
  401. __le64 types_bitmap[1];
  402. } stats[1];
  403. };
  404. struct virtio_net_stats_reply_hdr {
  405. #define VIRTIO_NET_STATS_TYPE_REPLY_CVQ 32
  406. #define VIRTIO_NET_STATS_TYPE_REPLY_RX_BASIC 0
  407. #define VIRTIO_NET_STATS_TYPE_REPLY_RX_CSUM 1
  408. #define VIRTIO_NET_STATS_TYPE_REPLY_RX_GSO 2
  409. #define VIRTIO_NET_STATS_TYPE_REPLY_RX_SPEED 3
  410. #define VIRTIO_NET_STATS_TYPE_REPLY_TX_BASIC 16
  411. #define VIRTIO_NET_STATS_TYPE_REPLY_TX_CSUM 17
  412. #define VIRTIO_NET_STATS_TYPE_REPLY_TX_GSO 18
  413. #define VIRTIO_NET_STATS_TYPE_REPLY_TX_SPEED 19
  414. __u8 type;
  415. __u8 reserved;
  416. __le16 vq_index;
  417. __le16 reserved1;
  418. __le16 size;
  419. };
  420. struct virtio_net_stats_cvq {
  421. struct virtio_net_stats_reply_hdr hdr;
  422. __le64 command_num;
  423. __le64 ok_num;
  424. };
  425. struct virtio_net_stats_rx_basic {
  426. struct virtio_net_stats_reply_hdr hdr;
  427. __le64 rx_notifications;
  428. __le64 rx_packets;
  429. __le64 rx_bytes;
  430. __le64 rx_interrupts;
  431. __le64 rx_drops;
  432. __le64 rx_drop_overruns;
  433. };
  434. struct virtio_net_stats_tx_basic {
  435. struct virtio_net_stats_reply_hdr hdr;
  436. __le64 tx_notifications;
  437. __le64 tx_packets;
  438. __le64 tx_bytes;
  439. __le64 tx_interrupts;
  440. __le64 tx_drops;
  441. __le64 tx_drop_malformed;
  442. };
  443. struct virtio_net_stats_rx_csum {
  444. struct virtio_net_stats_reply_hdr hdr;
  445. __le64 rx_csum_valid;
  446. __le64 rx_needs_csum;
  447. __le64 rx_csum_none;
  448. __le64 rx_csum_bad;
  449. };
  450. struct virtio_net_stats_tx_csum {
  451. struct virtio_net_stats_reply_hdr hdr;
  452. __le64 tx_csum_none;
  453. __le64 tx_needs_csum;
  454. };
  455. struct virtio_net_stats_rx_gso {
  456. struct virtio_net_stats_reply_hdr hdr;
  457. __le64 rx_gso_packets;
  458. __le64 rx_gso_bytes;
  459. __le64 rx_gso_packets_coalesced;
  460. __le64 rx_gso_bytes_coalesced;
  461. };
  462. struct virtio_net_stats_tx_gso {
  463. struct virtio_net_stats_reply_hdr hdr;
  464. __le64 tx_gso_packets;
  465. __le64 tx_gso_bytes;
  466. __le64 tx_gso_segments;
  467. __le64 tx_gso_segments_bytes;
  468. __le64 tx_gso_packets_noseg;
  469. __le64 tx_gso_bytes_noseg;
  470. };
  471. struct virtio_net_stats_rx_speed {
  472. struct virtio_net_stats_reply_hdr hdr;
  473. /* rx_{packets,bytes}_allowance_exceeded are too long. So rename to
  474. * short name.
  475. */
  476. __le64 rx_ratelimit_packets;
  477. __le64 rx_ratelimit_bytes;
  478. };
  479. struct virtio_net_stats_tx_speed {
  480. struct virtio_net_stats_reply_hdr hdr;
  481. /* tx_{packets,bytes}_allowance_exceeded are too long. So rename to
  482. * short name.
  483. */
  484. __le64 tx_ratelimit_packets;
  485. __le64 tx_ratelimit_bytes;
  486. };
  487. #endif /* _LINUX_VIRTIO_NET_H */