blob: dad8c0a6a279a3364cc6088bb7871c225e5e0811 [file] [log] [blame]
aliguori6e02c382008-12-04 19:52:44 +00001/*
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
aliguori869a5c62009-01-22 19:52:25 +000014#include <qemu-common.h>
Markus Armbrusterd75d25e2010-07-06 14:37:43 +020015#include "qemu-error.h"
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010016#include "trace.h"
Blue Swirl24463332010-08-24 15:22:24 +000017#include "blockdev.h"
aliguori6e02c382008-12-04 19:52:44 +000018#include "virtio-blk.h"
Christoph Hellwig1063b8b2009-04-27 10:29:14 +020019#ifdef __linux__
20# include <scsi/sg.h>
21#endif
aliguori6e02c382008-12-04 19:52:44 +000022
23typedef struct VirtIOBlock
24{
25 VirtIODevice vdev;
26 BlockDriverState *bs;
27 VirtQueue *vq;
aliguori869a5c62009-01-22 19:52:25 +000028 void *rq;
Markus Armbruster213189a2009-07-28 14:33:41 -040029 QEMUBH *bh;
Christoph Hellwig9752c372010-02-10 23:37:25 +010030 BlockConf *conf;
Markus Armbrustera8686a92011-06-20 11:35:18 +020031 char *serial;
Christoph Hellwig8cfacf02010-03-04 14:20:17 +010032 unsigned short sector_mask;
Alex Williamson9d0d3132010-07-20 11:14:22 -060033 DeviceState *qdev;
aliguori6e02c382008-12-04 19:52:44 +000034} VirtIOBlock;
35
36static VirtIOBlock *to_virtio_blk(VirtIODevice *vdev)
37{
38 return (VirtIOBlock *)vdev;
39}
40
41typedef struct VirtIOBlockReq
42{
43 VirtIOBlock *dev;
44 VirtQueueElement elem;
45 struct virtio_blk_inhdr *in;
46 struct virtio_blk_outhdr *out;
Christoph Hellwig1063b8b2009-04-27 10:29:14 +020047 struct virtio_scsi_inhdr *scsi;
aliguorid28a1b62009-03-28 17:46:14 +000048 QEMUIOVector qiov;
aliguori869a5c62009-01-22 19:52:25 +000049 struct VirtIOBlockReq *next;
aliguori6e02c382008-12-04 19:52:44 +000050} VirtIOBlockReq;
51
aliguori869a5c62009-01-22 19:52:25 +000052static void virtio_blk_req_complete(VirtIOBlockReq *req, int status)
53{
54 VirtIOBlock *s = req->dev;
55
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010056 trace_virtio_blk_req_complete(req, status);
57
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +010058 stb_p(&req->in->status, status);
aliguorid28a1b62009-03-28 17:46:14 +000059 virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in));
aliguori869a5c62009-01-22 19:52:25 +000060 virtio_notify(&s->vdev, s->vq);
61
Anthony Liguori7267c092011-08-20 22:09:37 -050062 g_free(req);
aliguori869a5c62009-01-22 19:52:25 +000063}
64
Kevin Wolff35d68f2009-11-27 13:25:39 +010065static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
66 int is_read)
aliguori869a5c62009-01-22 19:52:25 +000067{
Markus Armbrusterabd7f682010-06-02 18:55:17 +020068 BlockErrorAction action = bdrv_get_on_error(req->dev->bs, is_read);
aliguori869a5c62009-01-22 19:52:25 +000069 VirtIOBlock *s = req->dev;
70
Luiz Capitulinoeaa6c852010-02-03 12:41:04 -020071 if (action == BLOCK_ERR_IGNORE) {
Kevin Wolf908bb942010-03-31 17:46:59 +020072 bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE, is_read);
aliguori869a5c62009-01-22 19:52:25 +000073 return 0;
Luiz Capitulinoeaa6c852010-02-03 12:41:04 -020074 }
aliguori869a5c62009-01-22 19:52:25 +000075
76 if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
77 || action == BLOCK_ERR_STOP_ANY) {
78 req->next = s->rq;
79 s->rq = req;
Kevin Wolf908bb942010-03-31 17:46:59 +020080 bdrv_mon_event(s->bs, BDRV_ACTION_STOP, is_read);
Jan Kiszkae07bbac2011-02-09 16:29:40 +010081 vm_stop(VMSTOP_DISKFULL);
aliguori869a5c62009-01-22 19:52:25 +000082 } else {
83 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
Kevin Wolf908bb942010-03-31 17:46:59 +020084 bdrv_mon_event(s->bs, BDRV_ACTION_REPORT, is_read);
aliguori869a5c62009-01-22 19:52:25 +000085 }
86
87 return 1;
88}
89
aliguori6e02c382008-12-04 19:52:44 +000090static void virtio_blk_rw_complete(void *opaque, int ret)
91{
92 VirtIOBlockReq *req = opaque;
aliguori6e02c382008-12-04 19:52:44 +000093
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010094 trace_virtio_blk_rw_complete(req, ret);
95
Kevin Wolff35d68f2009-11-27 13:25:39 +010096 if (ret) {
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +010097 int is_read = !(ldl_p(&req->out->type) & VIRTIO_BLK_T_OUT);
Kevin Wolff35d68f2009-11-27 13:25:39 +010098 if (virtio_blk_handle_rw_error(req, -ret, is_read))
aliguori869a5c62009-01-22 19:52:25 +000099 return;
aliguori6e02c382008-12-04 19:52:44 +0000100 }
101
Kevin Wolff35d68f2009-11-27 13:25:39 +0100102 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
aliguori869a5c62009-01-22 19:52:25 +0000103}
aliguori6e02c382008-12-04 19:52:44 +0000104
Christoph Hellwigaa659be2009-09-04 19:02:23 +0200105static void virtio_blk_flush_complete(void *opaque, int ret)
106{
107 VirtIOBlockReq *req = opaque;
108
Kevin Wolf8c269b52010-10-20 13:17:30 +0200109 if (ret) {
110 if (virtio_blk_handle_rw_error(req, -ret, 0)) {
111 return;
112 }
113 }
114
115 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
Christoph Hellwigaa659be2009-09-04 19:02:23 +0200116}
117
aliguori869a5c62009-01-22 19:52:25 +0000118static VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s)
119{
Anthony Liguori7267c092011-08-20 22:09:37 -0500120 VirtIOBlockReq *req = g_malloc(sizeof(*req));
aliguori487414f2009-02-05 22:06:05 +0000121 req->dev = s;
Stefan Hajnoczide6c8042010-05-14 22:52:30 +0100122 req->qiov.size = 0;
123 req->next = NULL;
aliguori869a5c62009-01-22 19:52:25 +0000124 return req;
aliguori6e02c382008-12-04 19:52:44 +0000125}
126
127static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s)
128{
aliguori869a5c62009-01-22 19:52:25 +0000129 VirtIOBlockReq *req = virtio_blk_alloc_request(s);
aliguori6e02c382008-12-04 19:52:44 +0000130
aliguori869a5c62009-01-22 19:52:25 +0000131 if (req != NULL) {
132 if (!virtqueue_pop(s->vq, &req->elem)) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500133 g_free(req);
aliguori869a5c62009-01-22 19:52:25 +0000134 return NULL;
135 }
aliguori6e02c382008-12-04 19:52:44 +0000136 }
137
138 return req;
139}
140
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200141#ifdef __linux__
142static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
143{
144 struct sg_io_hdr hdr;
Christoph Hellwig42779062010-01-13 13:30:32 +0100145 int ret;
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200146 int status;
147 int i;
148
149 /*
150 * We require at least one output segment each for the virtio_blk_outhdr
151 * and the SCSI command block.
152 *
153 * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
154 * and the sense buffer pointer in the input segments.
155 */
156 if (req->elem.out_num < 2 || req->elem.in_num < 3) {
157 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
158 return;
159 }
160
161 /*
162 * No support for bidirection commands yet.
163 */
164 if (req->elem.out_num > 2 && req->elem.in_num > 3) {
165 virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
166 return;
167 }
168
169 /*
170 * The scsi inhdr is placed in the second-to-last input segment, just
171 * before the regular inhdr.
172 */
173 req->scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200174
175 memset(&hdr, 0, sizeof(struct sg_io_hdr));
176 hdr.interface_id = 'S';
177 hdr.cmd_len = req->elem.out_sg[1].iov_len;
178 hdr.cmdp = req->elem.out_sg[1].iov_base;
179 hdr.dxfer_len = 0;
180
181 if (req->elem.out_num > 2) {
182 /*
183 * If there are more than the minimally required 2 output segments
184 * there is write payload starting from the third iovec.
185 */
186 hdr.dxfer_direction = SG_DXFER_TO_DEV;
187 hdr.iovec_count = req->elem.out_num - 2;
188
189 for (i = 0; i < hdr.iovec_count; i++)
190 hdr.dxfer_len += req->elem.out_sg[i + 2].iov_len;
191
192 hdr.dxferp = req->elem.out_sg + 2;
193
194 } else if (req->elem.in_num > 3) {
195 /*
196 * If we have more than 3 input segments the guest wants to actually
197 * read data.
198 */
199 hdr.dxfer_direction = SG_DXFER_FROM_DEV;
200 hdr.iovec_count = req->elem.in_num - 3;
201 for (i = 0; i < hdr.iovec_count; i++)
202 hdr.dxfer_len += req->elem.in_sg[i].iov_len;
203
204 hdr.dxferp = req->elem.in_sg;
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200205 } else {
206 /*
207 * Some SCSI commands don't actually transfer any data.
208 */
209 hdr.dxfer_direction = SG_DXFER_NONE;
210 }
211
212 hdr.sbp = req->elem.in_sg[req->elem.in_num - 3].iov_base;
213 hdr.mx_sb_len = req->elem.in_sg[req->elem.in_num - 3].iov_len;
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200214
215 ret = bdrv_ioctl(req->dev->bs, SG_IO, &hdr);
216 if (ret) {
217 status = VIRTIO_BLK_S_UNSUPP;
218 hdr.status = ret;
219 hdr.resid = hdr.dxfer_len;
220 } else if (hdr.status) {
221 status = VIRTIO_BLK_S_IOERR;
222 } else {
223 status = VIRTIO_BLK_S_OK;
224 }
225
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100226 stl_p(&req->scsi->errors, hdr.status);
227 stl_p(&req->scsi->residual, hdr.resid);
228 stl_p(&req->scsi->sense_len, hdr.sb_len_wr);
229 stl_p(&req->scsi->data_len, hdr.dxfer_len);
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200230
231 virtio_blk_req_complete(req, status);
232}
233#else
234static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
235{
236 virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
237}
238#endif /* __linux__ */
239
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200240typedef struct MultiReqBuffer {
241 BlockRequest blkreq[32];
242 unsigned int num_writes;
243} MultiReqBuffer;
244
245static void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb)
aliguori869a5c62009-01-22 19:52:25 +0000246{
Kevin Wolf91553dc2009-09-09 17:53:38 +0200247 int i, ret;
Christoph Hellwig87b245d2009-08-13 16:49:56 +0200248
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200249 if (!mrb->num_writes) {
250 return;
251 }
252
253 ret = bdrv_aio_multiwrite(bs, mrb->blkreq, mrb->num_writes);
Kevin Wolf91553dc2009-09-09 17:53:38 +0200254 if (ret != 0) {
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200255 for (i = 0; i < mrb->num_writes; i++) {
256 if (mrb->blkreq[i].error) {
257 virtio_blk_rw_complete(mrb->blkreq[i].opaque, -EIO);
Kevin Wolf91553dc2009-09-09 17:53:38 +0200258 }
259 }
Christoph Hellwig87b245d2009-08-13 16:49:56 +0200260 }
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200261
262 mrb->num_writes = 0;
aliguorid28a1b62009-03-28 17:46:14 +0000263}
aliguori869a5c62009-01-22 19:52:25 +0000264
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200265static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb)
Christoph Hellwigaa659be2009-09-04 19:02:23 +0200266{
267 BlockDriverAIOCB *acb;
268
Christoph Hellwig618fbb82010-05-19 12:40:09 +0200269 /*
270 * Make sure all outstanding writes are posted to the backing device.
271 */
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200272 virtio_submit_multiwrite(req->dev->bs, mrb);
Christoph Hellwig618fbb82010-05-19 12:40:09 +0200273
Christoph Hellwigaa659be2009-09-04 19:02:23 +0200274 acb = bdrv_aio_flush(req->dev->bs, virtio_blk_flush_complete, req);
275 if (!acb) {
Kevin Wolf18a8d422010-10-27 13:10:15 +0200276 virtio_blk_flush_complete(req, -EIO);
Christoph Hellwigaa659be2009-09-04 19:02:23 +0200277 }
278}
279
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200280static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb)
Kevin Wolf91553dc2009-09-09 17:53:38 +0200281{
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200282 BlockRequest *blkreq;
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100283 uint64_t sector;
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200284
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100285 sector = ldq_p(&req->out->sector);
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +0100286
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100287 trace_virtio_blk_handle_write(req, sector, req->qiov.size / 512);
288
289 if (sector & req->dev->sector_mask) {
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100290 virtio_blk_rw_complete(req, -EIO);
291 return;
292 }
Christoph Hellwig52c05022011-04-06 20:28:34 +0200293 if (req->qiov.size % req->dev->conf->logical_block_size) {
294 virtio_blk_rw_complete(req, -EIO);
295 return;
296 }
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100297
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200298 if (mrb->num_writes == 32) {
299 virtio_submit_multiwrite(req->dev->bs, mrb);
Kevin Wolf91553dc2009-09-09 17:53:38 +0200300 }
301
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200302 blkreq = &mrb->blkreq[mrb->num_writes];
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100303 blkreq->sector = sector;
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200304 blkreq->nb_sectors = req->qiov.size / BDRV_SECTOR_SIZE;
305 blkreq->qiov = &req->qiov;
306 blkreq->cb = virtio_blk_rw_complete;
307 blkreq->opaque = req;
308 blkreq->error = 0;
Kevin Wolf91553dc2009-09-09 17:53:38 +0200309
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200310 mrb->num_writes++;
Kevin Wolf91553dc2009-09-09 17:53:38 +0200311}
312
aliguorid28a1b62009-03-28 17:46:14 +0000313static void virtio_blk_handle_read(VirtIOBlockReq *req)
314{
Christoph Hellwig87b245d2009-08-13 16:49:56 +0200315 BlockDriverAIOCB *acb;
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100316 uint64_t sector;
Christoph Hellwig87b245d2009-08-13 16:49:56 +0200317
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100318 sector = ldq_p(&req->out->sector);
319
320 if (sector & req->dev->sector_mask) {
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100321 virtio_blk_rw_complete(req, -EIO);
322 return;
323 }
Christoph Hellwig52c05022011-04-06 20:28:34 +0200324 if (req->qiov.size % req->dev->conf->logical_block_size) {
325 virtio_blk_rw_complete(req, -EIO);
326 return;
327 }
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100328
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100329 acb = bdrv_aio_readv(req->dev->bs, sector, &req->qiov,
Jes Sorensen1573a352010-05-27 16:20:33 +0200330 req->qiov.size / BDRV_SECTOR_SIZE,
331 virtio_blk_rw_complete, req);
Christoph Hellwig87b245d2009-08-13 16:49:56 +0200332 if (!acb) {
Kevin Wolf6c510fb2010-01-27 13:12:36 +0100333 virtio_blk_rw_complete(req, -EIO);
Christoph Hellwig87b245d2009-08-13 16:49:56 +0200334 }
aliguori869a5c62009-01-22 19:52:25 +0000335}
336
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100337static void virtio_blk_handle_request(VirtIOBlockReq *req,
338 MultiReqBuffer *mrb)
339{
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100340 uint32_t type;
341
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100342 if (req->elem.out_num < 1 || req->elem.in_num < 1) {
Stefan Hajnoczi870cef12010-11-15 20:44:35 +0000343 error_report("virtio-blk missing headers");
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100344 exit(1);
345 }
346
347 if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||
348 req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {
Stefan Hajnoczi870cef12010-11-15 20:44:35 +0000349 error_report("virtio-blk header not in correct element");
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100350 exit(1);
351 }
352
353 req->out = (void *)req->elem.out_sg[0].iov_base;
354 req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;
355
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100356 type = ldl_p(&req->out->type);
357
358 if (type & VIRTIO_BLK_T_FLUSH) {
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200359 virtio_blk_handle_flush(req, mrb);
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100360 } else if (type & VIRTIO_BLK_T_SCSI_CMD) {
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100361 virtio_blk_handle_scsi(req);
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100362 } else if (type & VIRTIO_BLK_T_GET_ID) {
john cooper2930b312010-07-02 13:44:25 -0400363 VirtIOBlock *s = req->dev;
364
Markus Armbrustera8686a92011-06-20 11:35:18 +0200365 /*
366 * NB: per existing s/n string convention the string is
367 * terminated by '\0' only when shorter than buffer.
368 */
369 strncpy(req->elem.in_sg[0].iov_base,
370 s->serial ? s->serial : "",
371 MIN(req->elem.in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES));
john cooper2930b312010-07-02 13:44:25 -0400372 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
Aurelien Jarno92e3c2a2011-01-25 11:55:14 +0100373 } else if (type & VIRTIO_BLK_T_OUT) {
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100374 qemu_iovec_init_external(&req->qiov, &req->elem.out_sg[1],
375 req->elem.out_num - 1);
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200376 virtio_blk_handle_write(req, mrb);
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100377 } else {
378 qemu_iovec_init_external(&req->qiov, &req->elem.in_sg[0],
379 req->elem.in_num - 1);
380 virtio_blk_handle_read(req);
381 }
382}
383
aliguori6e02c382008-12-04 19:52:44 +0000384static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
385{
386 VirtIOBlock *s = to_virtio_blk(vdev);
387 VirtIOBlockReq *req;
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100388 MultiReqBuffer mrb = {
389 .num_writes = 0,
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100390 };
aliguori6e02c382008-12-04 19:52:44 +0000391
392 while ((req = virtio_blk_get_request(s))) {
Kevin Wolfbc6694d2010-01-27 13:12:34 +0100393 virtio_blk_handle_request(req, &mrb);
aliguori6e02c382008-12-04 19:52:44 +0000394 }
Kevin Wolf91553dc2009-09-09 17:53:38 +0200395
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200396 virtio_submit_multiwrite(s->bs, &mrb);
Kevin Wolf91553dc2009-09-09 17:53:38 +0200397
aliguori6e02c382008-12-04 19:52:44 +0000398 /*
399 * FIXME: Want to check for completions before returning to guest mode,
400 * so cached reads and writes are reported as quickly as possible. But
401 * that should be done in the generic block layer.
402 */
403}
404
Markus Armbruster213189a2009-07-28 14:33:41 -0400405static void virtio_blk_dma_restart_bh(void *opaque)
aliguori869a5c62009-01-22 19:52:25 +0000406{
407 VirtIOBlock *s = opaque;
408 VirtIOBlockReq *req = s->rq;
Kevin Wolff1b52862010-01-27 13:12:35 +0100409 MultiReqBuffer mrb = {
410 .num_writes = 0,
Kevin Wolff1b52862010-01-27 13:12:35 +0100411 };
aliguori869a5c62009-01-22 19:52:25 +0000412
Markus Armbruster213189a2009-07-28 14:33:41 -0400413 qemu_bh_delete(s->bh);
414 s->bh = NULL;
aliguori869a5c62009-01-22 19:52:25 +0000415
416 s->rq = NULL;
417
418 while (req) {
Kevin Wolff1b52862010-01-27 13:12:35 +0100419 virtio_blk_handle_request(req, &mrb);
aliguori869a5c62009-01-22 19:52:25 +0000420 req = req->next;
421 }
Kevin Wolff1b52862010-01-27 13:12:35 +0100422
Christoph Hellwigc20fd872010-06-08 18:26:07 +0200423 virtio_submit_multiwrite(s->bs, &mrb);
aliguori869a5c62009-01-22 19:52:25 +0000424}
425
Markus Armbruster213189a2009-07-28 14:33:41 -0400426static void virtio_blk_dma_restart_cb(void *opaque, int running, int reason)
427{
428 VirtIOBlock *s = opaque;
429
430 if (!running)
431 return;
432
433 if (!s->bh) {
434 s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);
435 qemu_bh_schedule(s->bh);
436 }
437}
438
aliguori6e02c382008-12-04 19:52:44 +0000439static void virtio_blk_reset(VirtIODevice *vdev)
440{
441 /*
442 * This should cancel pending requests, but can't do nicely until there
443 * are per-device request lists.
444 */
445 qemu_aio_flush();
446}
447
john cooperbf011292009-06-22 14:26:51 -0400448/* coalesce internal state, copy to pci i/o region 0
449 */
aliguori6e02c382008-12-04 19:52:44 +0000450static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
451{
452 VirtIOBlock *s = to_virtio_blk(vdev);
453 struct virtio_blk_config blkcfg;
454 uint64_t capacity;
455 int cylinders, heads, secs;
456
457 bdrv_get_geometry(s->bs, &capacity);
458 bdrv_get_geometry_hint(s->bs, &cylinders, &heads, &secs);
Gerd Hoffmann5c5dafd2009-06-12 09:50:18 +0200459 memset(&blkcfg, 0, sizeof(blkcfg));
aliguori6e02c382008-12-04 19:52:44 +0000460 stq_raw(&blkcfg.capacity, capacity);
461 stl_raw(&blkcfg.seg_max, 128 - 2);
462 stw_raw(&blkcfg.cylinders, cylinders);
463 blkcfg.heads = heads;
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100464 blkcfg.sectors = secs & ~s->sector_mask;
465 blkcfg.blk_size = s->conf->logical_block_size;
Blue Swirlc7085da2009-06-13 13:20:25 +0000466 blkcfg.size_max = 0;
Christoph Hellwig9752c372010-02-10 23:37:25 +0100467 blkcfg.physical_block_exp = get_physical_block_exp(s->conf);
468 blkcfg.alignment_offset = 0;
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100469 blkcfg.min_io_size = s->conf->min_io_size / blkcfg.blk_size;
470 blkcfg.opt_io_size = s->conf->opt_io_size / blkcfg.blk_size;
hch@lst.de37d5ddd2010-02-10 23:36:49 +0100471 memcpy(config, &blkcfg, sizeof(struct virtio_blk_config));
aliguori6e02c382008-12-04 19:52:44 +0000472}
473
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200474static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features)
aliguori6e02c382008-12-04 19:52:44 +0000475{
john cooperbf011292009-06-22 14:26:51 -0400476 VirtIOBlock *s = to_virtio_blk(vdev);
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200477
478 features |= (1 << VIRTIO_BLK_F_SEG_MAX);
479 features |= (1 << VIRTIO_BLK_F_GEOMETRY);
Christoph Hellwig9752c372010-02-10 23:37:25 +0100480 features |= (1 << VIRTIO_BLK_F_TOPOLOGY);
Christoph Hellwig8cfacf02010-03-04 14:20:17 +0100481 features |= (1 << VIRTIO_BLK_F_BLK_SIZE);
Christoph Hellwigaa659be2009-09-04 19:02:23 +0200482
483 if (bdrv_enable_write_cache(s->bs))
484 features |= (1 << VIRTIO_BLK_F_WCACHE);
Naphtali Spreic79662f2009-10-29 11:42:11 +0200485
486 if (bdrv_is_read_only(s->bs))
487 features |= 1 << VIRTIO_BLK_F_RO;
Christoph Hellwig1063b8b2009-04-27 10:29:14 +0200488
489 return features;
aliguori6e02c382008-12-04 19:52:44 +0000490}
491
492static void virtio_blk_save(QEMUFile *f, void *opaque)
493{
494 VirtIOBlock *s = opaque;
aliguori869a5c62009-01-22 19:52:25 +0000495 VirtIOBlockReq *req = s->rq;
496
aliguori6e02c382008-12-04 19:52:44 +0000497 virtio_save(&s->vdev, f);
aliguori869a5c62009-01-22 19:52:25 +0000498
499 while (req) {
500 qemu_put_sbyte(f, 1);
501 qemu_put_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem));
502 req = req->next;
503 }
504 qemu_put_sbyte(f, 0);
aliguori6e02c382008-12-04 19:52:44 +0000505}
506
507static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id)
508{
509 VirtIOBlock *s = opaque;
510
aliguori869a5c62009-01-22 19:52:25 +0000511 if (version_id != 2)
aliguori6e02c382008-12-04 19:52:44 +0000512 return -EINVAL;
513
514 virtio_load(&s->vdev, f);
aliguori869a5c62009-01-22 19:52:25 +0000515 while (qemu_get_sbyte(f)) {
516 VirtIOBlockReq *req = virtio_blk_alloc_request(s);
517 qemu_get_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem));
518 req->next = s->rq;
Yoshiaki Tamura20a81e42010-06-21 17:50:01 +0900519 s->rq = req;
Kevin Wolfb6a48052010-08-03 16:57:02 +0200520
521 virtqueue_map_sg(req->elem.in_sg, req->elem.in_addr,
522 req->elem.in_num, 1);
523 virtqueue_map_sg(req->elem.out_sg, req->elem.out_addr,
524 req->elem.out_num, 0);
aliguori869a5c62009-01-22 19:52:25 +0000525 }
aliguori6e02c382008-12-04 19:52:44 +0000526
527 return 0;
528}
529
Christoph Hellwige5051fc2011-01-24 13:32:51 +0100530static void virtio_blk_change_cb(void *opaque, int reason)
531{
532 VirtIOBlock *s = opaque;
533
534 if (reason & CHANGE_SIZE) {
535 virtio_notify_config(&s->vdev);
536 }
537}
538
Markus Armbrustera8686a92011-06-20 11:35:18 +0200539VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf,
540 char **serial)
aliguori6e02c382008-12-04 19:52:44 +0000541{
542 VirtIOBlock *s;
543 int cylinders, heads, secs;
544 static int virtio_blk_id;
john cooper2930b312010-07-02 13:44:25 -0400545 DriveInfo *dinfo;
aliguori6e02c382008-12-04 19:52:44 +0000546
Markus Armbrusterd75d25e2010-07-06 14:37:43 +0200547 if (!conf->bs) {
548 error_report("virtio-blk-pci: drive property not set");
549 return NULL;
550 }
Markus Armbruster98f28ad2010-07-06 14:37:44 +0200551 if (!bdrv_is_inserted(conf->bs)) {
552 error_report("Device needs media, but drive is empty");
553 return NULL;
554 }
Markus Armbrusterd75d25e2010-07-06 14:37:43 +0200555
Markus Armbrustera8686a92011-06-20 11:35:18 +0200556 if (!*serial) {
557 /* try to fall back to value set with legacy -drive serial=... */
558 dinfo = drive_get_by_blockdev(conf->bs);
559 if (*dinfo->serial) {
560 *serial = strdup(dinfo->serial);
561 }
562 }
563
Paul Brook53c25ce2009-05-18 14:51:59 +0100564 s = (VirtIOBlock *)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK,
hch@lst.de37d5ddd2010-02-10 23:36:49 +0100565 sizeof(struct virtio_blk_config),
Paul Brook53c25ce2009-05-18 14:51:59 +0100566 sizeof(VirtIOBlock));
aliguori6e02c382008-12-04 19:52:44 +0000567
568 s->vdev.get_config = virtio_blk_update_config;
569 s->vdev.get_features = virtio_blk_get_features;
570 s->vdev.reset = virtio_blk_reset;
Markus Armbrusterf8b6cc02010-05-05 16:36:52 +0200571 s->bs = conf->bs;
Christoph Hellwig9752c372010-02-10 23:37:25 +0100572 s->conf = conf;
Markus Armbrustera8686a92011-06-20 11:35:18 +0200573 s->serial = *serial;
aliguori869a5c62009-01-22 19:52:25 +0000574 s->rq = NULL;
Jes Sorensen1573a352010-05-27 16:20:33 +0200575 s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1;
aliguori6e02c382008-12-04 19:52:44 +0000576 bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs);
aliguori6e02c382008-12-04 19:52:44 +0000577
578 s->vq = virtio_add_queue(&s->vdev, 128, virtio_blk_handle_output);
579
aliguori869a5c62009-01-22 19:52:25 +0000580 qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
Alex Williamson9d0d3132010-07-20 11:14:22 -0600581 s->qdev = dev;
Alex Williamson0be71e32010-06-25 11:09:07 -0600582 register_savevm(dev, "virtio-blk", virtio_blk_id++, 2,
aliguori6e02c382008-12-04 19:52:44 +0000583 virtio_blk_save, virtio_blk_load, s);
Markus Armbruster7d0d6952010-06-25 13:42:14 +0200584 bdrv_set_removable(s->bs, 0);
Christoph Hellwige5051fc2011-01-24 13:32:51 +0100585 bdrv_set_change_cb(s->bs, virtio_blk_change_cb, s);
Christoph Hellwig316a7af2010-09-12 23:43:39 +0200586 s->bs->buffer_alignment = conf->logical_block_size;
Paul Brook07e3af92009-05-14 22:35:08 +0100587
Gleb Natapov1ca4d092010-12-08 13:35:05 +0200588 add_boot_device_path(conf->bootindex, dev, "/disk@0,0");
589
Paul Brook53c25ce2009-05-18 14:51:59 +0100590 return &s->vdev;
Paul Brook07e3af92009-05-14 22:35:08 +0100591}
Alex Williamson9d0d3132010-07-20 11:14:22 -0600592
593void virtio_blk_exit(VirtIODevice *vdev)
594{
595 VirtIOBlock *s = to_virtio_blk(vdev);
596 unregister_savevm(s->qdev, "virtio-blk", s);
Amit Shahd92551f2011-07-27 14:00:30 +0530597 virtio_cleanup(vdev);
Alex Williamson9d0d3132010-07-20 11:14:22 -0600598}