VMM: Converted virtio headers to rely on types from stdint
authorMichael Taufen <mtaufen@gmail.com>
Tue, 3 May 2016 22:38:32 +0000 (15:38 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 13 May 2016 14:42:56 +0000 (10:42 -0400)
Signed-off-by: Michael Taufen <mtaufen@gmail.com>
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
user/vmm/include/vmm/virtio_9p.h
user/vmm/include/vmm/virtio_balloon.h
user/vmm/include/vmm/virtio_blk.h
user/vmm/include/vmm/virtio_console.h
user/vmm/include/vmm/virtio_gpu.h
user/vmm/include/vmm/virtio_input.h
user/vmm/include/vmm/virtio_net.h
user/vmm/include/vmm/virtio_pci.h
user/vmm/include/vmm/virtio_ring.h
user/vmm/include/vmm/virtio_scsi.h

index a363720..ec49852 100644 (file)
@@ -24,6 +24,7 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
+#include <stdint.h>
 #include <vmm/virtio_ids.h>
 #include <vmm/virtio_config.h>
 
@@ -34,9 +35,7 @@
 
 struct virtio_9p_config {
        /* length of the tag name */
-       __u16 tag_len;
+       uint16_t tag_len;
        /* non-NULL terminated tag name */
-       __u8 tag[0];
+       uint8_t tag[0];
 } __attribute__((packed));
-
-
index a5622df..9b44cdd 100644 (file)
@@ -24,6 +24,7 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
+#include <stdint.h>
 #include <vmm/virtio_ids.h>
 #include <vmm/virtio_config.h>
 
@@ -37,9 +38,9 @@
 
 struct virtio_balloon_config {
        /* Number of pages host wants Guest to give up. */
-       __u32 num_pages;
+       uint32_t num_pages;
        /* Number of pages we've actually got in balloon. */
-       __u32 actual;
+       uint32_t actual;
 };
 
 #define VIRTIO_BALLOON_S_SWAP_IN  0   /* Amount of memory swapped in */
@@ -74,8 +75,6 @@ struct virtio_balloon_config {
  * without the packed attribute.
  */
 struct virtio_balloon_stat {
-       __virtio16 tag;
-       __virtio64 val;
+       uint16_t tag;
+       uint64_t val;
 } __attribute__((packed));
-
-
index ba4c648..dbaaca4 100644 (file)
@@ -24,6 +24,7 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
+#include <stdint.h>
 #include <vmm/virtio_ids.h>
 #include <vmm/virtio_config.h>
 
 
 struct virtio_blk_config {
        /* The capacity (in 512-byte sectors). */
-       __u64 capacity;
+       uint64_t capacity;
        /* The maximum segment size (if VIRTIO_BLK_F_SIZE_MAX) */
-       __u32 size_max;
+       uint32_t size_max;
        /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */
-       __u32 seg_max;
+       uint32_t seg_max;
        /* geometry of the device (if VIRTIO_BLK_F_GEOMETRY) */
        struct virtio_blk_geometry {
-               __u16 cylinders;
-               __u8 heads;
-               __u8 sectors;
+               uint16_t cylinders;
+               uint8_t heads;
+               uint8_t sectors;
        } geometry;
 
        /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
-       __u32 blk_size;
+       uint32_t blk_size;
 
        /* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY  */
        /* exponent for physical block per logical block. */
-       __u8 physical_block_exp;
+       uint8_t physical_block_exp;
        /* alignment offset in logical blocks. */
-       __u8 alignment_offset;
+       uint8_t alignment_offset;
        /* minimum I/O size without performance penalty in logical blocks. */
-       __u16 min_io_size;
+       uint16_t min_io_size;
        /* optimal sustained I/O size in logical blocks. */
-       __u32 opt_io_size;
+       uint32_t opt_io_size;
 
        /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */
-       __u8 wce;
-       __u8 unused;
+       uint8_t wce;
+       uint8_t unused;
 
        /* number of vqs, only available when VIRTIO_BLK_F_MQ is set */
-       __u16 num_queues;
+       uint16_t num_queues;
 } __attribute__((packed));
 
 /*
@@ -123,19 +124,19 @@ struct virtio_blk_config {
  */
 struct virtio_blk_outhdr {
        /* VIRTIO_BLK_T* */
-       __virtio32 type;
+       uint32_t type;
        /* io priority. */
-       __virtio32 ioprio;
+       uint32_t ioprio;
        /* Sector (ie. 512 byte offset) */
-       __virtio64 sector;
+       uint64_t sector;
 };
 
 #ifndef VIRTIO_BLK_NO_LEGACY
 struct virtio_scsi_inhdr {
-       __virtio32 errors;
-       __virtio32 data_len;
-       __virtio32 sense_len;
-       __virtio32 residual;
+       uint32_t errors;
+       uint32_t data_len;
+       uint32_t sense_len;
+       uint32_t residual;
 };
 #endif /* !VIRTIO_BLK_NO_LEGACY */
 
@@ -143,4 +144,3 @@ struct virtio_scsi_inhdr {
 #define VIRTIO_BLK_S_OK                0
 #define VIRTIO_BLK_S_IOERR     1
 #define VIRTIO_BLK_S_UNSUPP    2
-
index 088cfc4..14cbdfc 100644 (file)
@@ -30,6 +30,7 @@
  * Copyright (C) Amit Shah <amit.shah@redhat.com>, 2009, 2010, 2011
  */
 #pragma once
+#include <stdint.h>
 #include <vmm/virtio_ids.h>
 #include <vmm/virtio_config.h>
 
 
 struct virtio_console_config {
        /* colums of the screens */
-       __u16 cols;
+       uint16_t cols;
        /* rows of the screens */
-       __u16 rows;
+       uint16_t rows;
        /* max. number of ports this device can hold */
-       __u32 max_nr_ports;
+       uint32_t max_nr_ports;
        /* emergency write register */
-       __u32 emerg_wr;
+       uint32_t emerg_wr;
 } __attribute__((packed));
 
 /*
@@ -56,9 +57,9 @@ struct virtio_console_config {
  * particular port.
  */
 struct virtio_console_control {
-       __virtio32 id;          /* Port number */
-       __virtio16 event;       /* The kind of control event (see below) */
-       __virtio16 value;       /* Extra information for the key */
+       uint32_t id;            /* Port number */
+       uint16_t event; /* The kind of control event (see below) */
+       uint16_t value; /* Extra information for the key */
 };
 
 /* Some events for control messages */
@@ -70,6 +71,3 @@ struct virtio_console_control {
 #define VIRTIO_CONSOLE_RESIZE          5
 #define VIRTIO_CONSOLE_PORT_OPEN       6
 #define VIRTIO_CONSOLE_PORT_NAME       7
-
-
-
index 4df629c..41da223 100644 (file)
@@ -36,7 +36,7 @@
  */
 
 #pragma once
-
+#include <stdint.h>
 
 #define VIRTIO_GPU_F_VIRGL 0
 
@@ -87,100 +87,100 @@ enum virtio_gpu_ctrl_type {
 #define VIRTIO_GPU_FLAG_FENCE (1 << 0)
 
 struct virtio_gpu_ctrl_hdr {
-       __le32 type;
-       __le32 flags;
-       __le64 fence_id;
-       __le32 ctx_id;
-       __le32 padding;
+       uint32_t type;
+       uint32_t flags;
+       uint64_t fence_id;
+       uint32_t ctx_id;
+       uint32_t padding;
 };
 
 /* data passed in the cursor vq */
 
 struct virtio_gpu_cursor_pos {
-       __le32 scanout_id;
-       __le32 x;
-       __le32 y;
-       __le32 padding;
+       uint32_t scanout_id;
+       uint32_t x;
+       uint32_t y;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_UPDATE_CURSOR, VIRTIO_GPU_CMD_MOVE_CURSOR */
 struct virtio_gpu_update_cursor {
        struct virtio_gpu_ctrl_hdr hdr;
        struct virtio_gpu_cursor_pos pos;  /* update & move */
-       __le32 resource_id;           /* update only */
-       __le32 hot_x;                 /* update only */
-       __le32 hot_y;                 /* update only */
-       __le32 padding;
+       uint32_t resource_id;           /* update only */
+       uint32_t hot_x;                 /* update only */
+       uint32_t hot_y;                 /* update only */
+       uint32_t padding;
 };
 
 /* data passed in the control vq, 2d related */
 
 struct virtio_gpu_rect {
-       __le32 x;
-       __le32 y;
-       __le32 width;
-       __le32 height;
+       uint32_t x;
+       uint32_t y;
+       uint32_t width;
+       uint32_t height;
 };
 
 /* VIRTIO_GPU_CMD_RESOURCE_UNREF */
 struct virtio_gpu_resource_unref {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 resource_id;
-       __le32 padding;
+       uint32_t resource_id;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: create a 2d resource with a format */
 struct virtio_gpu_resource_create_2d {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 resource_id;
-       __le32 format;
-       __le32 width;
-       __le32 height;
+       uint32_t resource_id;
+       uint32_t format;
+       uint32_t width;
+       uint32_t height;
 };
 
 /* VIRTIO_GPU_CMD_SET_SCANOUT */
 struct virtio_gpu_set_scanout {
        struct virtio_gpu_ctrl_hdr hdr;
        struct virtio_gpu_rect r;
-       __le32 scanout_id;
-       __le32 resource_id;
+       uint32_t scanout_id;
+       uint32_t resource_id;
 };
 
 /* VIRTIO_GPU_CMD_RESOURCE_FLUSH */
 struct virtio_gpu_resource_flush {
        struct virtio_gpu_ctrl_hdr hdr;
        struct virtio_gpu_rect r;
-       __le32 resource_id;
-       __le32 padding;
+       uint32_t resource_id;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: simple transfer to_host */
 struct virtio_gpu_transfer_to_host_2d {
        struct virtio_gpu_ctrl_hdr hdr;
        struct virtio_gpu_rect r;
-       __le64 offset;
-       __le32 resource_id;
-       __le32 padding;
+       uint64_t offset;
+       uint32_t resource_id;
+       uint32_t padding;
 };
 
 struct virtio_gpu_mem_entry {
-       __le64 addr;
-       __le32 length;
-       __le32 padding;
+       uint64_t addr;
+       uint32_t length;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING */
 struct virtio_gpu_resource_attach_backing {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 resource_id;
-       __le32 nr_entries;
+       uint32_t resource_id;
+       uint32_t nr_entries;
 };
 
 /* VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING */
 struct virtio_gpu_resource_detach_backing {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 resource_id;
-       __le32 padding;
+       uint32_t resource_id;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_RESP_OK_DISPLAY_INFO */
@@ -189,52 +189,52 @@ struct virtio_gpu_resp_display_info {
        struct virtio_gpu_ctrl_hdr hdr;
        struct virtio_gpu_display_one {
                struct virtio_gpu_rect r;
-               __le32 enabled;
-               __le32 flags;
+               uint32_t enabled;
+               uint32_t flags;
        } pmodes[VIRTIO_GPU_MAX_SCANOUTS];
 };
 
 /* data passed in the control vq, 3d related */
 
 struct virtio_gpu_box {
-       __le32 x, y, z;
-       __le32 w, h, d;
+       uint32_t x, y, z;
+       uint32_t w, h, d;
 };
 
 /* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D, VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D */
 struct virtio_gpu_transfer_host_3d {
        struct virtio_gpu_ctrl_hdr hdr;
        struct virtio_gpu_box box;
-       __le64 offset;
-       __le32 resource_id;
-       __le32 level;
-       __le32 stride;
-       __le32 layer_stride;
+       uint64_t offset;
+       uint32_t resource_id;
+       uint32_t level;
+       uint32_t stride;
+       uint32_t layer_stride;
 };
 
 /* VIRTIO_GPU_CMD_RESOURCE_CREATE_3D */
 #define VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP (1 << 0)
 struct virtio_gpu_resource_create_3d {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 resource_id;
-       __le32 target;
-       __le32 format;
-       __le32 bind;
-       __le32 width;
-       __le32 height;
-       __le32 depth;
-       __le32 array_size;
-       __le32 last_level;
-       __le32 nr_samples;
-       __le32 flags;
-       __le32 padding;
+       uint32_t resource_id;
+       uint32_t target;
+       uint32_t format;
+       uint32_t bind;
+       uint32_t width;
+       uint32_t height;
+       uint32_t depth;
+       uint32_t array_size;
+       uint32_t last_level;
+       uint32_t nr_samples;
+       uint32_t flags;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_CTX_CREATE */
 struct virtio_gpu_ctx_create {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 nlen;
-       __le32 padding;
+       uint32_t nlen;
+       uint32_t padding;
        char debug_name[64];
 };
 
@@ -246,15 +246,15 @@ struct virtio_gpu_ctx_destroy {
 /* VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE, VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE */
 struct virtio_gpu_ctx_resource {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 resource_id;
-       __le32 padding;
+       uint32_t resource_id;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_SUBMIT_3D */
 struct virtio_gpu_cmd_submit {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 size;
-       __le32 padding;
+       uint32_t size;
+       uint32_t padding;
 };
 
 #define VIRTIO_GPU_CAPSET_VIRGL 1
@@ -262,39 +262,39 @@ struct virtio_gpu_cmd_submit {
 /* VIRTIO_GPU_CMD_GET_CAPSET_INFO */
 struct virtio_gpu_get_capset_info {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 capset_index;
-       __le32 padding;
+       uint32_t capset_index;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_RESP_OK_CAPSET_INFO */
 struct virtio_gpu_resp_capset_info {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 capset_id;
-       __le32 capset_max_version;
-       __le32 capset_max_size;
-       __le32 padding;
+       uint32_t capset_id;
+       uint32_t capset_max_version;
+       uint32_t capset_max_size;
+       uint32_t padding;
 };
 
 /* VIRTIO_GPU_CMD_GET_CAPSET */
 struct virtio_gpu_get_capset {
        struct virtio_gpu_ctrl_hdr hdr;
-       __le32 capset_id;
-       __le32 capset_version;
+       uint32_t capset_id;
+       uint32_t capset_version;
 };
 
 /* VIRTIO_GPU_RESP_OK_CAPSET */
 struct virtio_gpu_resp_capset {
        struct virtio_gpu_ctrl_hdr hdr;
-       __u8 capset_data[];
+       uint8_t capset_data[];
 };
 
 #define VIRTIO_GPU_EVENT_DISPLAY (1 << 0)
 
 struct virtio_gpu_config {
-       __u32 events_read;
-       __u32 events_clear;
-       __u32 num_scanouts;
-       __u32 num_capsets;
+       uint32_t events_read;
+       uint32_t events_clear;
+       uint32_t num_scanouts;
+       uint32_t num_capsets;
 };
 
 /* simple formats for fbcon/X use */
index e5c5725..742580f 100644 (file)
@@ -26,6 +26,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
 
+#include <stdint.h>
 
 enum virtio_input_config_select {
        VIRTIO_INPUT_CFG_UNSET      = 0x00,
@@ -38,37 +39,35 @@ enum virtio_input_config_select {
 };
 
 struct virtio_input_absinfo {
-       __u32 min;
-       __u32 max;
-       __u32 fuzz;
-       __u32 flat;
-       __u32 res;
+       uint32_t min;
+       uint32_t max;
+       uint32_t fuzz;
+       uint32_t flat;
+       uint32_t res;
 };
 
 struct virtio_input_devids {
-       __u16 bustype;
-       __u16 vendor;
-       __u16 product;
-       __u16 version;
+       uint16_t bustype;
+       uint16_t vendor;
+       uint16_t product;
+       uint16_t version;
 };
 
 struct virtio_input_config {
-       __u8    select;
-       __u8    subsel;
-       __u8    size;
-       __u8    reserved[5];
+       uint8_t    select;
+       uint8_t    subsel;
+       uint8_t    size;
+       uint8_t    reserved[5];
        union {
                char string[128];
-               __u8 bitmap[128];
+               uint8_t bitmap[128];
                struct virtio_input_absinfo abs;
                struct virtio_input_devids ids;
        } u;
 };
 
 struct virtio_input_event {
-       __le16 type;
-       __le16 code;
-       __le32 value;
+       uint16_t type;
+       uint16_t code;
+       uint32_t value;
 };
-
-
index 28c5376..31b8f54 100644 (file)
@@ -24,6 +24,7 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
+#include <stdint.h>
 #include <vmm/virtio_ids.h>
 #include <vmm/virtio_config.h>
 #include <linux/if_ether.h>
 
 struct virtio_net_config {
        /* The config defining mac address (if VIRTIO_NET_F_MAC) */
-       __u8 mac[ETH_ALEN];
+       uint8_t mac[ETH_ALEN];
        /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
-       __u16 status;
+       uint16_t status;
        /* Maximum number of each of transmit and receive queues;
         * see VIRTIO_NET_F_MQ and VIRTIO_NET_CTRL_MQ.
         * Legal values are between 1 and 0x8000
         */
-       __u16 max_virtqueue_pairs;
+       uint16_t max_virtqueue_pairs;
 } __attribute__((packed));
 
 /*
@@ -82,18 +83,18 @@ struct virtio_net_config {
 struct virtio_net_hdr_v1 {
 #define VIRTIO_NET_HDR_F_NEEDS_CSUM    1       /* Use csum_start, csum_offset */
 #define VIRTIO_NET_HDR_F_DATA_VALID    2       /* Csum is valid */
-       __u8 flags;
+       uint8_t flags;
 #define VIRTIO_NET_HDR_GSO_NONE                0       /* Not a GSO frame */
 #define VIRTIO_NET_HDR_GSO_TCPV4       1       /* GSO frame, IPv4 TCP (TSO) */
 #define VIRTIO_NET_HDR_GSO_UDP         3       /* GSO frame, IPv4 UDP (UFO) */
 #define VIRTIO_NET_HDR_GSO_TCPV6       4       /* GSO frame, IPv6 TCP */
 #define VIRTIO_NET_HDR_GSO_ECN         0x80    /* TCP has ECN set */
-       __u8 gso_type;
-       __virtio16 hdr_len;     /* Ethernet + IP + tcp/udp hdrs */
-       __virtio16 gso_size;    /* Bytes to append to hdr_len per frame */
-       __virtio16 csum_start;  /* Position to start checksumming from */
-       __virtio16 csum_offset; /* Offset after that to place checksum */
-       __virtio16 num_buffers; /* Number of merged rx buffers */
+       uint8_t gso_type;
+       uint16_t hdr_len;       /* Ethernet + IP + tcp/udp hdrs */
+       uint16_t gso_size;      /* Bytes to append to hdr_len per frame */
+       uint16_t csum_start;    /* Position to start checksumming from */
+       uint16_t csum_offset;   /* Offset after that to place checksum */
+       uint16_t num_buffers;   /* Number of merged rx buffers */
 };
 
 #ifndef VIRTIO_NET_NO_LEGACY
@@ -103,20 +104,20 @@ struct virtio_net_hdr_v1 {
  * specify GSO or CSUM features, you can simply ignore the header. */
 struct virtio_net_hdr {
        /* See VIRTIO_NET_HDR_F_* */
-       __u8 flags;
+       uint8_t flags;
        /* See VIRTIO_NET_HDR_GSO_* */
-       __u8 gso_type;
-       __virtio16 hdr_len;             /* Ethernet + IP + tcp/udp hdrs */
-       __virtio16 gso_size;            /* Bytes to append to hdr_len per frame */
-       __virtio16 csum_start;  /* Position to start checksumming from */
-       __virtio16 csum_offset; /* Offset after that to place checksum */
+       uint8_t gso_type;
+       uint16_t hdr_len;               /* Ethernet + IP + tcp/udp hdrs */
+       uint16_t gso_size;              /* Bytes to append to hdr_len per frame */
+       uint16_t csum_start;    /* Position to start checksumming from */
+       uint16_t csum_offset;   /* Offset after that to place checksum */
 };
 
 /* This is the version of the header to use when the MRG_RXBUF
  * feature has been negotiated. */
 struct virtio_net_hdr_mrg_rxbuf {
        struct virtio_net_hdr hdr;
-       __virtio16 num_buffers; /* Number of merged rx buffers */
+       uint16_t num_buffers;   /* Number of merged rx buffers */
 };
 #endif /* ...VIRTIO_NET_NO_LEGACY */
 
@@ -128,11 +129,11 @@ struct virtio_net_hdr_mrg_rxbuf {
  * command goes in between.
  */
 struct virtio_net_ctrl_hdr {
-       __u8 class;
-       __u8 cmd;
+       uint8_t class;
+       uint8_t cmd;
 } __attribute__((packed));
 
-typedef __u8 virtio_net_ctrl_ack;
+typedef uint8_t virtio_net_ctrl_ack;
 
 #define VIRTIO_NET_OK     0
 #define VIRTIO_NET_ERR    1
@@ -172,8 +173,8 @@ typedef __u8 virtio_net_ctrl_ack;
  * VIRTIO_NET_F_CTRL_MAC_ADDR feature is available.
  */
 struct virtio_net_ctrl_mac {
-       __virtio32 entries;
-       __u8 macs[][ETH_ALEN];
+       uint32_t entries;
+       uint8_t macs[][ETH_ALEN];
 } __attribute__((packed));
 
 #define VIRTIO_NET_CTRL_MAC    1
@@ -216,7 +217,7 @@ struct virtio_net_ctrl_mac {
  * specified.
  */
 struct virtio_net_ctrl_mq {
-       __virtio16 virtqueue_pairs;
+       uint16_t virtqueue_pairs;
 };
 
 #define VIRTIO_NET_CTRL_MQ   4
@@ -238,5 +239,3 @@ struct virtio_net_ctrl_mq {
  */
 #define VIRTIO_NET_CTRL_GUEST_OFFLOADS   5
 #define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET        0
-
-
index 4e4cf8a..ce44ed8 100644 (file)
@@ -38,6 +38,8 @@
 
 #pragma once
 
+#include <stdint.h>
+
 #ifndef VIRTIO_PCI_NO_LEGACY
 
 /* A 32-bit r/o bitmask of the features supported by the host */
 
 /* This is the PCI capability header: */
 struct virtio_pci_cap {
-       __u8 cap_vndr;          /* Generic PCI field: PCI_CAP_ID_VNDR */
-       __u8 cap_next;          /* Generic PCI field: next ptr. */
-       __u8 cap_len;           /* Generic PCI field: capability length */
-       __u8 cfg_type;          /* Identifies the structure. */
-       __u8 bar;               /* Where to find it. */
-       __u8 padding[3];        /* Pad to full dword. */
-       __le32 offset;          /* Offset within bar. */
-       __le32 length;          /* Length of the structure, in bytes. */
+       uint8_t cap_vndr;               /* Generic PCI field: PCI_CAP_ID_VNDR */
+       uint8_t cap_next;               /* Generic PCI field: next ptr. */
+       uint8_t cap_len;                /* Generic PCI field: capability length */
+       uint8_t cfg_type;               /* Identifies the structure. */
+       uint8_t bar;            /* Where to find it. */
+       uint8_t padding[3];     /* Pad to full dword. */
+       uint32_t offset;                /* Offset within bar. */
+       uint32_t length;                /* Length of the structure, in bytes. */
 };
 
 struct virtio_pci_notify_cap {
        struct virtio_pci_cap cap;
-       __le32 notify_off_multiplier;   /* Multiplier for queue_notify_off. */
+       uint32_t notify_off_multiplier; /* Multiplier for queue_notify_off. */
 };
 
 /* Fields in VIRTIO_PCI_CAP_COMMON_CFG: */
 struct virtio_pci_common_cfg {
        /* About the whole device. */
-       __le32 device_feature_select;   /* read-write */
-       __le32 device_feature;          /* read-only */
-       __le32 guest_feature_select;    /* read-write */
-       __le32 guest_feature;           /* read-write */
-       __le16 msix_config;             /* read-write */
-       __le16 num_queues;              /* read-only */
-       __u8 device_status;             /* read-write */
-       __u8 config_generation;         /* read-only */
+       uint32_t device_feature_select; /* read-write */
+       uint32_t device_feature;                /* read-only */
+       uint32_t guest_feature_select;  /* read-write */
+       uint32_t guest_feature;         /* read-write */
+       uint16_t msix_config;           /* read-write */
+       uint16_t num_queues;            /* read-only */
+       uint8_t device_status;          /* read-write */
+       uint8_t config_generation;              /* read-only */
 
        /* About a specific virtqueue. */
-       __le16 queue_select;            /* read-write */
-       __le16 queue_size;              /* read-write, power of 2. */
-       __le16 queue_msix_vector;       /* read-write */
-       __le16 queue_enable;            /* read-write */
-       __le16 queue_notify_off;        /* read-only */
-       __le32 queue_desc_lo;           /* read-write */
-       __le32 queue_desc_hi;           /* read-write */
-       __le32 queue_avail_lo;          /* read-write */
-       __le32 queue_avail_hi;          /* read-write */
-       __le32 queue_used_lo;           /* read-write */
-       __le32 queue_used_hi;           /* read-write */
+       uint16_t queue_select;          /* read-write */
+       uint16_t queue_size;            /* read-write, power of 2. */
+       uint16_t queue_msix_vector;     /* read-write */
+       uint16_t queue_enable;          /* read-write */
+       uint16_t queue_notify_off;      /* read-only */
+       uint32_t queue_desc_lo;         /* read-write */
+       uint32_t queue_desc_hi;         /* read-write */
+       uint32_t queue_avail_lo;                /* read-write */
+       uint32_t queue_avail_hi;                /* read-write */
+       uint32_t queue_used_lo;         /* read-write */
+       uint32_t queue_used_hi;         /* read-write */
 };
 
 /* Fields in VIRTIO_PCI_CAP_PCI_CFG: */
 struct virtio_pci_cfg_cap {
        struct virtio_pci_cap cap;
-       __u8 pci_cfg_data[4]; /* Data for BAR access. */
+       uint8_t pci_cfg_data[4]; /* Data for BAR access. */
 };
 
 /* Macro versions of offsets for the Old Timers! */
@@ -192,5 +194,3 @@ struct virtio_pci_cfg_cap {
 #define VIRTIO_PCI_COMMON_Q_USEDHI     52
 
 #endif /* VIRTIO_PCI_NO_MODERN */
-
-
index 43abc4e..09bce1a 100644 (file)
@@ -31,6 +31,7 @@
  *
  * Copyright Rusty Russell IBM Corporation 2007. */
 
+#include <stdint.h>
 
 /* This marks a buffer as continuing via the next field. */
 #define VRING_DESC_F_NEXT      1
 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
 struct vring_desc {
        /* Address (guest-physical). */
-       __virtio64 addr;
+       uint64_t addr;
        /* Length. */
-       __virtio32 len;
+       uint32_t len;
        /* The flags as indicated above. */
-       __virtio16 flags;
+       uint16_t flags;
        /* We chain unused descriptors via this, too */
-       __virtio16 next;
+       uint16_t next;
 };
 
 struct vring_avail {
-       __virtio16 flags;
-       __virtio16 idx;
-       __virtio16 ring[];
+       uint16_t flags;
+       uint16_t idx;
+       uint16_t ring[];
 };
 
 /* u32 is used here for ids for padding reasons. */
 struct vring_used_elem {
        /* Index of start of used descriptor chain. */
-       __virtio32 id;
+       uint32_t id;
        /* Total length of the descriptor chain which was used (written to) */
-       __virtio32 len;
+       uint32_t len;
 };
 
 struct vring_used {
-       __virtio16 flags;
-       __virtio16 idx;
+       uint16_t flags;
+       uint16_t idx;
        struct vring_used_elem ring[];
 };
 
@@ -133,7 +134,7 @@ struct vring {
 /* We publish the used event index at the end of the available ring, and vice
  * versa. They are at the end for backwards compatibility. */
 #define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
-#define vring_avail_event(vr) (*(__virtio16 *)&(vr)->used->ring[(vr)->num])
+#define vring_avail_event(vr) (*(uint16_t *)&(vr)->used->ring[(vr)->num])
 
 static inline void vring_init(struct vring *vr, unsigned int num, void *p,
                              unsigned long align)
@@ -141,29 +142,28 @@ static inline void vring_init(struct vring *vr, unsigned int num, void *p,
        vr->num = num;
        vr->desc = p;
        vr->avail = p + num*sizeof(struct vring_desc);
-       vr->used = (void *)(((uintptr_t)&vr->avail->ring[num] + sizeof(__virtio16)
+       vr->used = (void *)(((uintptr_t)&vr->avail->ring[num] + sizeof(uint16_t)
                + align-1) & ~(align - 1));
 }
 
 static inline unsigned vring_size(unsigned int num, unsigned long align)
 {
-       return ((sizeof(struct vring_desc) * num + sizeof(__virtio16) * (3 + num)
+       return ((sizeof(struct vring_desc) * num + sizeof(uint16_t) * (3 + num)
                 + align - 1) & ~(align - 1))
-               + sizeof(__virtio16) * 3 + sizeof(struct vring_used_elem) * num;
+               + sizeof(uint16_t) * 3 + sizeof(struct vring_used_elem) * num;
 }
 
 /* The following is used with USED_EVENT_IDX and AVAIL_EVENT_IDX */
 /* Assuming a given event_idx value from the other side, if
  * we have just incremented index from old to new_idx,
  * should we trigger an event? */
-static inline int vring_need_event(__u16 event_idx, __u16 new_idx, __u16 old)
+static inline int vring_need_event(uint16_t event_idx,
+                                   uint16_t new_idx, uint16_t old)
 {
        /* Note: Xen has similar logic for notification hold-off
         * in include/xen/interface/io/ring.h with req_event and req_prod
         * corresponding to event_idx + 1 and new_idx respectively.
         * Note also that req_event and req_prod in Xen start at 1,
         * event indexes in virtio start at 0. */
-       return (__u16)(new_idx - event_idx - 1) < (__u16)(new_idx - old);
+       return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old);
 }
-
-
index 582ab68..0e1e860 100644 (file)
@@ -26,6 +26,8 @@
 
 #pragma once
 
+ #include <stdint.h>
+
 /* Default values of the CDB and sense data size configuration fields */
 #define VIRTIO_SCSI_CDB_DEFAULT_SIZE   32
 #define VIRTIO_SCSI_SENSE_DEFAULT_SIZE 96
 
 /* SCSI command request, followed by data-out */
 struct virtio_scsi_cmd_req {
-       __u8 lun[8];            /* Logical Unit Number */
-       __virtio64 tag;         /* Command identifier */
-       __u8 task_attr;         /* Task attribute */
-       __u8 prio;              /* SAM command priority field */
-       __u8 crn;
-       __u8 cdb[VIRTIO_SCSI_CDB_SIZE];
+       uint8_t lun[8];         /* Logical Unit Number */
+       uint64_t tag;           /* Command identifier */
+       uint8_t task_attr;              /* Task attribute */
+       uint8_t prio;           /* SAM command priority field */
+       uint8_t crn;
+       uint8_t cdb[VIRTIO_SCSI_CDB_SIZE];
 } __attribute__((packed));
 
 /* SCSI command request, followed by protection information */
 struct virtio_scsi_cmd_req_pi {
-       __u8 lun[8];            /* Logical Unit Number */
-       __virtio64 tag;         /* Command identifier */
-       __u8 task_attr;         /* Task attribute */
-       __u8 prio;              /* SAM command priority field */
-       __u8 crn;
-       __virtio32 pi_bytesout; /* DataOUT PI Number of bytes */
-       __virtio32 pi_bytesin;          /* DataIN PI Number of bytes */
-       __u8 cdb[VIRTIO_SCSI_CDB_SIZE];
+       uint8_t lun[8];         /* Logical Unit Number */
+       uint64_t tag;           /* Command identifier */
+       uint8_t task_attr;              /* Task attribute */
+       uint8_t prio;           /* SAM command priority field */
+       uint8_t crn;
+       uint32_t pi_bytesout;   /* DataOUT PI Number of bytes */
+       uint32_t pi_bytesin;            /* DataIN PI Number of bytes */
+       uint8_t cdb[VIRTIO_SCSI_CDB_SIZE];
 } __attribute__((packed));
 
 /* Response, followed by sense data and data-in */
 struct virtio_scsi_cmd_resp {
-       __virtio32 sense_len;           /* Sense data length */
-       __virtio32 resid;               /* Residual bytes in data buffer */
-       __virtio16 status_qualifier;    /* Status qualifier */
-       __u8 status;            /* Command completion status */
-       __u8 response;          /* Response values */
-       __u8 sense[VIRTIO_SCSI_SENSE_SIZE];
+       uint32_t sense_len;             /* Sense data length */
+       uint32_t resid;         /* Residual bytes in data buffer */
+       uint16_t status_qualifier;      /* Status qualifier */
+       uint8_t status;         /* Command completion status */
+       uint8_t response;               /* Response values */
+       uint8_t sense[VIRTIO_SCSI_SENSE_SIZE];
 } __attribute__((packed));
 
 /* Task Management Request */
 struct virtio_scsi_ctrl_tmf_req {
-       __virtio32 type;
-       __virtio32 subtype;
-       __u8 lun[8];
-       __virtio64 tag;
+       uint32_t type;
+       uint32_t subtype;
+       uint8_t lun[8];
+       uint64_t tag;
 } __attribute__((packed));
 
 struct virtio_scsi_ctrl_tmf_resp {
-       __u8 response;
+       uint8_t response;
 } __attribute__((packed));
 
 /* Asynchronous notification query/subscription */
 struct virtio_scsi_ctrl_an_req {
-       __virtio32 type;
-       __u8 lun[8];
-       __virtio32 event_requested;
+       uint32_t type;
+       uint8_t lun[8];
+       uint32_t event_requested;
 } __attribute__((packed));
 
 struct virtio_scsi_ctrl_an_resp {
-       __virtio32 event_actual;
-       __u8 response;
+       uint32_t event_actual;
+       uint8_t response;
 } __attribute__((packed));
 
 struct virtio_scsi_event {
-       __virtio32 event;
-       __u8 lun[8];
-       __virtio32 reason;
+       uint32_t event;
+       uint8_t lun[8];
+       uint32_t reason;
 } __attribute__((packed));
 
 struct virtio_scsi_config {
-       __u32 num_queues;
-       __u32 seg_max;
-       __u32 max_sectors;
-       __u32 cmd_per_lun;
-       __u32 event_info_size;
-       __u32 sense_size;
-       __u32 cdb_size;
-       __u16 max_channel;
-       __u16 max_target;
-       __u32 max_lun;
+       uint32_t num_queues;
+       uint32_t seg_max;
+       uint32_t max_sectors;
+       uint32_t cmd_per_lun;
+       uint32_t event_info_size;
+       uint32_t sense_size;
+       uint32_t cdb_size;
+       uint16_t max_channel;
+       uint16_t max_target;
+       uint32_t max_lun;
 } __attribute__((packed));
 
 /* Feature Bits */
@@ -164,6 +166,3 @@ struct virtio_scsi_config {
 #define VIRTIO_SCSI_S_ORDERED                  1
 #define VIRTIO_SCSI_S_HEAD                     2
 #define VIRTIO_SCSI_S_ACA                      3
-
-
-