1 /* 2 * Virtio driver bits 3 * 4 * Copyright (c) 2013 Alexander Graf <agraf@suse.de> 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or (at 7 * your option) any later version. See the COPYING file in the top-level 8 * directory. 9 */ 10 11 #ifndef VIRTIO_H 12 #define VIRTIO_H 13 14 #include "s390-ccw.h" 15 16 /* Status byte for guest to report progress, and synchronize features. */ 17 /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */ 18 #define VIRTIO_CONFIG_S_ACKNOWLEDGE 1 19 /* We have found a driver for the device. */ 20 #define VIRTIO_CONFIG_S_DRIVER 2 21 /* Driver has used its parts of the config, and is happy */ 22 #define VIRTIO_CONFIG_S_DRIVER_OK 4 23 /* We've given up on this device. */ 24 #define VIRTIO_CONFIG_S_FAILED 0x80 25 26 enum VirtioDevType { 27 VIRTIO_ID_NET = 1, 28 VIRTIO_ID_BLOCK = 2, 29 VIRTIO_ID_CONSOLE = 3, 30 VIRTIO_ID_BALLOON = 5, 31 VIRTIO_ID_SCSI = 8, 32 }; 33 typedef enum VirtioDevType VirtioDevType; 34 35 struct VirtioDevHeader { 36 VirtioDevType type:8; 37 uint8_t num_vq; 38 uint8_t feature_len; 39 uint8_t config_len; 40 uint8_t status; 41 uint8_t vqconfig[]; 42 } __attribute__((packed)); 43 typedef struct VirtioDevHeader VirtioDevHeader; 44 45 struct VirtioVqConfig { 46 uint64_t token; 47 uint64_t address; 48 uint16_t num; 49 uint8_t pad[6]; 50 } __attribute__((packed)); 51 typedef struct VirtioVqConfig VirtioVqConfig; 52 53 struct VqInfo { 54 uint64_t queue; 55 uint32_t align; 56 uint16_t index; 57 uint16_t num; 58 } __attribute__((packed)); 59 typedef struct VqInfo VqInfo; 60 61 struct VqConfig { 62 uint16_t index; 63 uint16_t num; 64 } __attribute__((packed)); 65 typedef struct VqConfig VqConfig; 66 67 struct VirtioDev { 68 VirtioDevHeader *header; 69 VirtioVqConfig *vqconfig; 70 char *host_features; 71 char *guest_features; 72 char *config; 73 }; 74 typedef struct VirtioDev VirtioDev; 75 76 #define VIRTIO_RING_SIZE (PAGE_SIZE * 8) 77 #define VIRTIO_MAX_VQS 3 78 #define KVM_S390_VIRTIO_RING_ALIGN 4096 79 80 #define VRING_USED_F_NO_NOTIFY 1 81 82 /* This marks a buffer as continuing via the next field. */ 83 #define VRING_DESC_F_NEXT 1 84 /* This marks a buffer as write-only (otherwise read-only). */ 85 #define VRING_DESC_F_WRITE 2 86 /* This means the buffer contains a list of buffer descriptors. */ 87 #define VRING_DESC_F_INDIRECT 4 88 89 /* Internal flag to mark follow-up segments as such */ 90 #define VRING_HIDDEN_IS_CHAIN 256 91 92 /* Virtio ring descriptors: 16 bytes. These can chain together via "next". */ 93 struct VRingDesc { 94 /* Address (guest-physical). */ 95 uint64_t addr; 96 /* Length. */ 97 uint32_t len; 98 /* The flags as indicated above. */ 99 uint16_t flags; 100 /* We chain unused descriptors via this, too */ 101 uint16_t next; 102 } __attribute__((packed)); 103 typedef struct VRingDesc VRingDesc; 104 105 struct VRingAvail { 106 uint16_t flags; 107 uint16_t idx; 108 uint16_t ring[]; 109 } __attribute__((packed)); 110 typedef struct VRingAvail VRingAvail; 111 112 /* uint32_t is used here for ids for padding reasons. */ 113 struct VRingUsedElem { 114 /* Index of start of used descriptor chain. */ 115 uint32_t id; 116 /* Total length of the descriptor chain which was used (written to) */ 117 uint32_t len; 118 } __attribute__((packed)); 119 typedef struct VRingUsedElem VRingUsedElem; 120 121 struct VRingUsed { 122 uint16_t flags; 123 uint16_t idx; 124 VRingUsedElem ring[]; 125 } __attribute__((packed)); 126 typedef struct VRingUsed VRingUsed; 127 128 struct VRing { 129 unsigned int num; 130 int next_idx; 131 int used_idx; 132 VRingDesc *desc; 133 VRingAvail *avail; 134 VRingUsed *used; 135 SubChannelId schid; 136 long cookie; 137 int id; 138 }; 139 typedef struct VRing VRing; 140 141 142 /*********************************************** 143 * Virtio block * 144 ***********************************************/ 145 146 /* 147 * Command types 148 * 149 * Usage is a bit tricky as some bits are used as flags and some are not. 150 * 151 * Rules: 152 * VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or 153 * VIRTIO_BLK_T_BARRIER. VIRTIO_BLK_T_FLUSH is a command of its own 154 * and may not be combined with any of the other flags. 155 */ 156 157 /* These two define direction. */ 158 #define VIRTIO_BLK_T_IN 0 159 #define VIRTIO_BLK_T_OUT 1 160 161 /* This bit says it's a scsi command, not an actual read or write. */ 162 #define VIRTIO_BLK_T_SCSI_CMD 2 163 164 /* Cache flush command */ 165 #define VIRTIO_BLK_T_FLUSH 4 166 167 /* Barrier before this op. */ 168 #define VIRTIO_BLK_T_BARRIER 0x80000000 169 170 /* This is the first element of the read scatter-gather list. */ 171 struct VirtioBlkOuthdr { 172 /* VIRTIO_BLK_T* */ 173 uint32_t type; 174 /* io priority. */ 175 uint32_t ioprio; 176 /* Sector (ie. 512 byte offset) */ 177 uint64_t sector; 178 }; 179 typedef struct VirtioBlkOuthdr VirtioBlkOuthdr; 180 181 struct VirtioBlkConfig { 182 uint64_t capacity; /* in 512-byte sectors */ 183 uint32_t size_max; /* max segment size (if VIRTIO_BLK_F_SIZE_MAX) */ 184 uint32_t seg_max; /* max number of segments (if VIRTIO_BLK_F_SEG_MAX) */ 185 186 struct VirtioBlkGeometry { 187 uint16_t cylinders; 188 uint8_t heads; 189 uint8_t sectors; 190 } geometry; /* (if VIRTIO_BLK_F_GEOMETRY) */ 191 192 uint32_t blk_size; /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */ 193 194 /* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY */ 195 uint8_t physical_block_exp; /* exponent for physical blk per logical blk */ 196 uint8_t alignment_offset; /* alignment offset in logical blocks */ 197 uint16_t min_io_size; /* min I/O size without performance penalty 198 in logical blocks */ 199 uint32_t opt_io_size; /* optimal sustained I/O size in logical blks */ 200 201 uint8_t wce; /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */ 202 } __attribute__((packed)); 203 typedef struct VirtioBlkConfig VirtioBlkConfig; 204 205 enum guessed_disk_nature_type { 206 VIRTIO_GDN_NONE = 0, 207 VIRTIO_GDN_DASD = 1, 208 VIRTIO_GDN_CDROM = 2, 209 VIRTIO_GDN_SCSI = 3, 210 }; 211 typedef enum guessed_disk_nature_type VirtioGDN; 212 213 VirtioGDN virtio_guessed_disk_nature(void); 214 void virtio_assume_scsi(void); 215 void virtio_assume_eckd(void); 216 void virtio_assume_iso9660(void); 217 218 extern bool virtio_disk_is_scsi(void); 219 extern bool virtio_disk_is_eckd(void); 220 extern bool virtio_ipl_disk_is_valid(void); 221 extern int virtio_get_block_size(void); 222 extern uint8_t virtio_get_heads(void); 223 extern uint8_t virtio_get_sectors(void); 224 extern uint64_t virtio_get_blocks(void); 225 extern int virtio_read_many(ulong sector, void *load_addr, int sec_num); 226 227 #define VIRTIO_SECTOR_SIZE 512 228 #define VIRTIO_ISO_BLOCK_SIZE 2048 229 #define VIRTIO_SCSI_BLOCK_SIZE 512 230 231 static inline ulong virtio_sector_adjust(ulong sector) 232 { 233 return sector * (virtio_get_block_size() / VIRTIO_SECTOR_SIZE); 234 } 235 236 struct VirtioScsiConfig { 237 uint32_t num_queues; 238 uint32_t seg_max; 239 uint32_t max_sectors; 240 uint32_t cmd_per_lun; 241 uint32_t event_info_size; 242 uint32_t sense_size; 243 uint32_t cdb_size; 244 uint16_t max_channel; 245 uint16_t max_target; 246 uint32_t max_lun; 247 } __attribute__((packed)); 248 typedef struct VirtioScsiConfig VirtioScsiConfig; 249 250 struct ScsiDevice { 251 uint16_t channel; /* Always 0 in QEMU */ 252 uint16_t target; /* will be scanned over */ 253 uint32_t lun; /* will be reported */ 254 }; 255 typedef struct ScsiDevice ScsiDevice; 256 257 struct VDev { 258 int nr_vqs; 259 VRing *vrings; 260 int cmd_vr_idx; 261 void *ring_area; 262 long wait_reply_timeout; 263 VirtioGDN guessed_disk_nature; 264 SubChannelId schid; 265 SenseId senseid; 266 union { 267 VirtioBlkConfig blk; 268 VirtioScsiConfig scsi; 269 } config; 270 ScsiDevice *scsi_device; 271 bool is_cdrom; 272 int scsi_block_size; 273 int blk_factor; 274 uint64_t scsi_last_block; 275 uint32_t scsi_dev_cyls; 276 uint8_t scsi_dev_heads; 277 }; 278 typedef struct VDev VDev; 279 280 VDev *virtio_get_device(void); 281 VirtioDevType virtio_get_device_type(void); 282 283 struct VirtioCmd { 284 void *data; 285 int size; 286 int flags; 287 }; 288 typedef struct VirtioCmd VirtioCmd; 289 290 int virtio_run(VDev *vdev, int vqid, VirtioCmd *cmd); 291 292 #endif /* VIRTIO_H */ 293