]> git.proxmox.com Git - mirror_qemu.git/blame - hw/virtio-blk.c
Add bdrv_aio_multiwrite
[mirror_qemu.git] / hw / virtio-blk.c
CommitLineData
6e02c38d
AL
1/*
2 * Virtio Block Device
3 *
4 * Copyright IBM, Corp. 2007
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
869a5c6d
AL
14#include <qemu-common.h>
15#include <sysemu.h>
6e02c38d
AL
16#include "virtio-blk.h"
17#include "block_int.h"
1063b8b1
CH
18#ifdef __linux__
19# include <scsi/sg.h>
20#endif
6e02c38d
AL
21
22typedef struct VirtIOBlock
23{
24 VirtIODevice vdev;
25 BlockDriverState *bs;
26 VirtQueue *vq;
869a5c6d 27 void *rq;
bf011293 28 char serial_str[BLOCK_SERIAL_STRLEN + 1];
213189ab 29 QEMUBH *bh;
6e02c38d
AL
30} VirtIOBlock;
31
32static VirtIOBlock *to_virtio_blk(VirtIODevice *vdev)
33{
34 return (VirtIOBlock *)vdev;
35}
36
bf011293 37/* store identify data in little endian format
38 */
39static inline void put_le16(uint16_t *p, unsigned int v)
40{
41 *p = cpu_to_le16(v);
42}
43
44/* copy to *dst from *src, nul pad dst tail as needed to len bytes
45 */
46static inline void padstr(char *dst, const char *src, int len)
47{
48 while (len--)
49 *dst++ = *src ? *src++ : '\0';
50}
51
52/* setup simulated identify data as appropriate for virtio block device
53 *
54 * ref: AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
55 */
56static inline void virtio_identify_template(struct virtio_blk_config *bc)
57{
58 uint16_t *p = &bc->identify[0];
59 uint64_t lba_sectors = bc->capacity;
60
61 memset(p, 0, sizeof(bc->identify));
62 put_le16(p + 0, 0x0); /* ATA device */
63 padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware revision */
64 padstr((char *)(p + 27), "QEMU VIRT_BLK", 40); /* model# */
65 put_le16(p + 47, 0x80ff); /* max xfer 255 sectors */
66 put_le16(p + 49, 0x0b00); /* support IORDY/LBA/DMA */
67 put_le16(p + 59, 0x1ff); /* cur xfer 255 sectors */
68 put_le16(p + 80, 0x1f0); /* support ATA8/7/6/5/4 */
69 put_le16(p + 81, 0x16);
70 put_le16(p + 82, 0x400);
71 put_le16(p + 83, 0x400);
72 put_le16(p + 100, lba_sectors);
73 put_le16(p + 101, lba_sectors >> 16);
74 put_le16(p + 102, lba_sectors >> 32);
75 put_le16(p + 103, lba_sectors >> 48);
76}
77
6e02c38d
AL
78typedef struct VirtIOBlockReq
79{
80 VirtIOBlock *dev;
81 VirtQueueElement elem;
82 struct virtio_blk_inhdr *in;
83 struct virtio_blk_outhdr *out;
1063b8b1 84 struct virtio_scsi_inhdr *scsi;
d28a1b6e 85 QEMUIOVector qiov;
869a5c6d 86 struct VirtIOBlockReq *next;
6e02c38d
AL
87} VirtIOBlockReq;
88
869a5c6d
AL
89static void virtio_blk_req_complete(VirtIOBlockReq *req, int status)
90{
91 VirtIOBlock *s = req->dev;
92
93 req->in->status = status;
d28a1b6e 94 virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
869a5c6d
AL
95 virtio_notify(&s->vdev, s->vq);
96
869a5c6d
AL
97 qemu_free(req);
98}
99
100static int virtio_blk_handle_write_error(VirtIOBlockReq *req, int error)
101{
102 BlockInterfaceErrorAction action = drive_get_onerror(req->dev->bs);
103 VirtIOBlock *s = req->dev;
104
105 if (action == BLOCK_ERR_IGNORE)
106 return 0;
107
108 if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
109 || action == BLOCK_ERR_STOP_ANY) {
110 req->next = s->rq;
111 s->rq = req;
112 vm_stop(0);
113 } else {
114 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
115 }
116
117 return 1;
118}
119
6e02c38d
AL
120static void virtio_blk_rw_complete(void *opaque, int ret)
121{
122 VirtIOBlockReq *req = opaque;
6e02c38d 123
d28a1b6e 124 if (ret && (req->out->type & VIRTIO_BLK_T_OUT)) {
869a5c6d
AL
125 if (virtio_blk_handle_write_error(req, -ret))
126 return;
6e02c38d
AL
127 }
128
869a5c6d
AL
129 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
130}
6e02c38d 131
869a5c6d
AL
132static VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s)
133{
134 VirtIOBlockReq *req = qemu_mallocz(sizeof(*req));
487414f1 135 req->dev = s;
869a5c6d 136 return req;
6e02c38d
AL
137}
138
139static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s)
140{
869a5c6d 141 VirtIOBlockReq *req = virtio_blk_alloc_request(s);
6e02c38d 142
869a5c6d
AL
143 if (req != NULL) {
144 if (!virtqueue_pop(s->vq, &req->elem)) {
145 qemu_free(req);
146 return NULL;
147 }
6e02c38d
AL
148 }
149
150 return req;
151}
152
1063b8b1
CH
153#ifdef __linux__
154static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
155{
156 struct sg_io_hdr hdr;
157 int ret, size = 0;
158 int status;
159 int i;
160
161 /*
162 * We require at least one output segment each for the virtio_blk_outhdr
163 * and the SCSI command block.
164 *
165 * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
166 * and the sense buffer pointer in the input segments.
167 */
168 if (req->elem.out_num < 2 || req->elem.in_num < 3) {
169 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
170 return;
171 }
172
173 /*
174 * No support for bidirection commands yet.
175 */
176 if (req->elem.out_num > 2 && req->elem.in_num > 3) {
177 virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
178 return;
179 }
180
181 /*
182 * The scsi inhdr is placed in the second-to-last input segment, just
183 * before the regular inhdr.
184 */
185 req->scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;
186 size = sizeof(*req->in) + sizeof(*req->scsi);
187
188 memset(&hdr, 0, sizeof(struct sg_io_hdr));
189 hdr.interface_id = 'S';
190 hdr.cmd_len = req->elem.out_sg[1].iov_len;
191 hdr.cmdp = req->elem.out_sg[1].iov_base;
192 hdr.dxfer_len = 0;
193
194 if (req->elem.out_num > 2) {
195 /*
196 * If there are more than the minimally required 2 output segments
197 * there is write payload starting from the third iovec.
198 */
199 hdr.dxfer_direction = SG_DXFER_TO_DEV;
200 hdr.iovec_count = req->elem.out_num - 2;
201
202 for (i = 0; i < hdr.iovec_count; i++)
203 hdr.dxfer_len += req->elem.out_sg[i + 2].iov_len;
204
205 hdr.dxferp = req->elem.out_sg + 2;
206
207 } else if (req->elem.in_num > 3) {
208 /*
209 * If we have more than 3 input segments the guest wants to actually
210 * read data.
211 */
212 hdr.dxfer_direction = SG_DXFER_FROM_DEV;
213 hdr.iovec_count = req->elem.in_num - 3;
214 for (i = 0; i < hdr.iovec_count; i++)
215 hdr.dxfer_len += req->elem.in_sg[i].iov_len;
216
217 hdr.dxferp = req->elem.in_sg;
218 size += hdr.dxfer_len;
219 } else {
220 /*
221 * Some SCSI commands don't actually transfer any data.
222 */
223 hdr.dxfer_direction = SG_DXFER_NONE;
224 }
225
226 hdr.sbp = req->elem.in_sg[req->elem.in_num - 3].iov_base;
227 hdr.mx_sb_len = req->elem.in_sg[req->elem.in_num - 3].iov_len;
228 size += hdr.mx_sb_len;
229
230 ret = bdrv_ioctl(req->dev->bs, SG_IO, &hdr);
231 if (ret) {
232 status = VIRTIO_BLK_S_UNSUPP;
233 hdr.status = ret;
234 hdr.resid = hdr.dxfer_len;
235 } else if (hdr.status) {
236 status = VIRTIO_BLK_S_IOERR;
237 } else {
238 status = VIRTIO_BLK_S_OK;
239 }
240
241 req->scsi->errors = hdr.status;
242 req->scsi->residual = hdr.resid;
243 req->scsi->sense_len = hdr.sb_len_wr;
244 req->scsi->data_len = hdr.dxfer_len;
245
246 virtio_blk_req_complete(req, status);
247}
248#else
249static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
250{
251 virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
252}
253#endif /* __linux__ */
254
d28a1b6e 255static void virtio_blk_handle_write(VirtIOBlockReq *req)
869a5c6d 256{
87b245db
CH
257 BlockDriverAIOCB *acb;
258
259 acb = bdrv_aio_writev(req->dev->bs, req->out->sector, &req->qiov,
260 req->qiov.size / 512, virtio_blk_rw_complete, req);
261 if (!acb) {
262 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
263 }
d28a1b6e 264}
869a5c6d 265
d28a1b6e
AL
266static void virtio_blk_handle_read(VirtIOBlockReq *req)
267{
87b245db
CH
268 BlockDriverAIOCB *acb;
269
270 acb = bdrv_aio_readv(req->dev->bs, req->out->sector, &req->qiov,
271 req->qiov.size / 512, virtio_blk_rw_complete, req);
272 if (!acb) {
273 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
274 }
869a5c6d
AL
275}
276
6e02c38d
AL
277static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
278{
279 VirtIOBlock *s = to_virtio_blk(vdev);
280 VirtIOBlockReq *req;
281
282 while ((req = virtio_blk_get_request(s))) {
6e02c38d
AL
283 if (req->elem.out_num < 1 || req->elem.in_num < 1) {
284 fprintf(stderr, "virtio-blk missing headers\n");
285 exit(1);
286 }
287
288 if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||
289 req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {
290 fprintf(stderr, "virtio-blk header not in correct element\n");
291 exit(1);
292 }
293
294 req->out = (void *)req->elem.out_sg[0].iov_base;
295 req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;
296
297 if (req->out->type & VIRTIO_BLK_T_SCSI_CMD) {
1063b8b1 298 virtio_blk_handle_scsi(req);
6e02c38d 299 } else if (req->out->type & VIRTIO_BLK_T_OUT) {
d28a1b6e
AL
300 qemu_iovec_init_external(&req->qiov, &req->elem.out_sg[1],
301 req->elem.out_num - 1);
302 virtio_blk_handle_write(req);
6e02c38d 303 } else {
d28a1b6e
AL
304 qemu_iovec_init_external(&req->qiov, &req->elem.in_sg[0],
305 req->elem.in_num - 1);
306 virtio_blk_handle_read(req);
6e02c38d
AL
307 }
308 }
309 /*
310 * FIXME: Want to check for completions before returning to guest mode,
311 * so cached reads and writes are reported as quickly as possible. But
312 * that should be done in the generic block layer.
313 */
314}
315
213189ab 316static void virtio_blk_dma_restart_bh(void *opaque)
869a5c6d
AL
317{
318 VirtIOBlock *s = opaque;
319 VirtIOBlockReq *req = s->rq;
320
213189ab
MA
321 qemu_bh_delete(s->bh);
322 s->bh = NULL;
869a5c6d
AL
323
324 s->rq = NULL;
325
326 while (req) {
327 virtio_blk_handle_write(req);
328 req = req->next;
329 }
330}
331
213189ab
MA
332static void virtio_blk_dma_restart_cb(void *opaque, int running, int reason)
333{
334 VirtIOBlock *s = opaque;
335
336 if (!running)
337 return;
338
339 if (!s->bh) {
340 s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);
341 qemu_bh_schedule(s->bh);
342 }
343}
344
6e02c38d
AL
345static void virtio_blk_reset(VirtIODevice *vdev)
346{
347 /*
348 * This should cancel pending requests, but can't do nicely until there
349 * are per-device request lists.
350 */
351 qemu_aio_flush();
352}
353
bf011293 354/* coalesce internal state, copy to pci i/o region 0
355 */
6e02c38d
AL
356static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
357{
358 VirtIOBlock *s = to_virtio_blk(vdev);
359 struct virtio_blk_config blkcfg;
360 uint64_t capacity;
361 int cylinders, heads, secs;
362
363 bdrv_get_geometry(s->bs, &capacity);
364 bdrv_get_geometry_hint(s->bs, &cylinders, &heads, &secs);
5c5dafdc 365 memset(&blkcfg, 0, sizeof(blkcfg));
6e02c38d
AL
366 stq_raw(&blkcfg.capacity, capacity);
367 stl_raw(&blkcfg.seg_max, 128 - 2);
368 stw_raw(&blkcfg.cylinders, cylinders);
369 blkcfg.heads = heads;
370 blkcfg.sectors = secs;
c7085da7 371 blkcfg.size_max = 0;
bf011293 372 virtio_identify_template(&blkcfg);
373 memcpy(&blkcfg.identify[VIRTIO_BLK_ID_SN], s->serial_str,
374 VIRTIO_BLK_ID_SN_BYTES);
6e02c38d
AL
375 memcpy(config, &blkcfg, sizeof(blkcfg));
376}
377
378static uint32_t virtio_blk_get_features(VirtIODevice *vdev)
379{
bf011293 380 VirtIOBlock *s = to_virtio_blk(vdev);
1063b8b1
CH
381 uint32_t features = 0;
382
383 features |= (1 << VIRTIO_BLK_F_SEG_MAX);
384 features |= (1 << VIRTIO_BLK_F_GEOMETRY);
385#ifdef __linux__
386 features |= (1 << VIRTIO_BLK_F_SCSI);
387#endif
bf011293 388 if (strcmp(s->serial_str, "0"))
389 features |= 1 << VIRTIO_BLK_F_IDENTIFY;
1063b8b1
CH
390
391 return features;
6e02c38d
AL
392}
393
394static void virtio_blk_save(QEMUFile *f, void *opaque)
395{
396 VirtIOBlock *s = opaque;
869a5c6d
AL
397 VirtIOBlockReq *req = s->rq;
398
6e02c38d 399 virtio_save(&s->vdev, f);
869a5c6d
AL
400
401 while (req) {
402 qemu_put_sbyte(f, 1);
403 qemu_put_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem));
404 req = req->next;
405 }
406 qemu_put_sbyte(f, 0);
6e02c38d
AL
407}
408
409static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id)
410{
411 VirtIOBlock *s = opaque;
412
869a5c6d 413 if (version_id != 2)
6e02c38d
AL
414 return -EINVAL;
415
416 virtio_load(&s->vdev, f);
869a5c6d
AL
417 while (qemu_get_sbyte(f)) {
418 VirtIOBlockReq *req = virtio_blk_alloc_request(s);
419 qemu_get_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem));
420 req->next = s->rq;
421 s->rq = req->next;
422 }
6e02c38d
AL
423
424 return 0;
425}
426
d176c495 427VirtIODevice *virtio_blk_init(DeviceState *dev, DriveInfo *dinfo)
6e02c38d
AL
428{
429 VirtIOBlock *s;
430 int cylinders, heads, secs;
431 static int virtio_blk_id;
bf011293 432 char *ps;
cf21e106 433
53c25cea
PB
434 s = (VirtIOBlock *)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK,
435 sizeof(struct virtio_blk_config),
436 sizeof(VirtIOBlock));
6e02c38d
AL
437
438 s->vdev.get_config = virtio_blk_update_config;
439 s->vdev.get_features = virtio_blk_get_features;
440 s->vdev.reset = virtio_blk_reset;
d176c495 441 s->bs = dinfo->bdrv;
869a5c6d 442 s->rq = NULL;
d176c495 443 if (strlen(ps = (char *)drive_get_serial(s->bs)))
bf011293 444 strncpy(s->serial_str, ps, sizeof(s->serial_str));
445 else
446 snprintf(s->serial_str, sizeof(s->serial_str), "0");
d176c495 447 s->bs->private = dev;
6e02c38d
AL
448 bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs);
449 bdrv_set_geometry_hint(s->bs, cylinders, heads, secs);
450
451 s->vq = virtio_add_queue(&s->vdev, 128, virtio_blk_handle_output);
452
869a5c6d
AL
453 qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
454 register_savevm("virtio-blk", virtio_blk_id++, 2,
6e02c38d
AL
455 virtio_blk_save, virtio_blk_load, s);
456
53c25cea 457 return &s->vdev;
6e02c38d 458}