1
2
3
4
5
6
7
8
9
10
11
12#include "qemu/osdep.h"
13#include "block/block.h"
14#include "subprojects/libvhost-user/libvhost-user.h"
15#include "standard-headers/linux/virtio_blk.h"
16#include "qemu/vhost-user-server.h"
17#include "vhost-user-blk-server.h"
18#include "qapi/error.h"
19#include "qom/object_interfaces.h"
20#include "sysemu/block-backend.h"
21#include "util/block-helpers.h"
22
23
24
25
26
27#define VIRTIO_BLK_SECTOR_BITS 9
28#define VIRTIO_BLK_SECTOR_SIZE (1ull << VIRTIO_BLK_SECTOR_BITS)
29
30enum {
31 VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,
32 VHOST_USER_BLK_MAX_DISCARD_SECTORS = 32768,
33 VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS = 32768,
34};
35struct virtio_blk_inhdr {
36 unsigned char status;
37};
38
39typedef struct VuBlkReq {
40 VuVirtqElement elem;
41 int64_t sector_num;
42 size_t size;
43 struct virtio_blk_inhdr *in;
44 struct virtio_blk_outhdr out;
45 VuServer *server;
46 struct VuVirtq *vq;
47} VuBlkReq;
48
49
50typedef struct {
51 BlockExport export;
52 VuServer vu_server;
53 uint32_t blk_size;
54 QIOChannelSocket *sioc;
55 struct virtio_blk_config blkcfg;
56 bool writable;
57} VuBlkExport;
58
59static void vu_blk_req_complete(VuBlkReq *req)
60{
61 VuDev *vu_dev = &req->server->vu_dev;
62
63
64 vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
65 vu_queue_notify(vu_dev, req->vq);
66
67 free(req);
68}
69
70static bool vu_blk_sect_range_ok(VuBlkExport *vexp, uint64_t sector,
71 size_t size)
72{
73 uint64_t nb_sectors = size >> BDRV_SECTOR_BITS;
74 uint64_t total_sectors;
75
76 if (nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
77 return false;
78 }
79 if ((sector << VIRTIO_BLK_SECTOR_BITS) % vexp->blk_size) {
80 return false;
81 }
82 blk_get_geometry(vexp->export.blk, &total_sectors);
83 if (sector > total_sectors || nb_sectors > total_sectors - sector) {
84 return false;
85 }
86 return true;
87}
88
89static int coroutine_fn
90vu_blk_discard_write_zeroes(VuBlkExport *vexp, struct iovec *iov,
91 uint32_t iovcnt, uint32_t type)
92{
93 BlockBackend *blk = vexp->export.blk;
94 struct virtio_blk_discard_write_zeroes desc;
95 ssize_t size;
96 uint64_t sector;
97 uint32_t num_sectors;
98 uint32_t max_sectors;
99 uint32_t flags;
100 int bytes;
101
102
103 if (unlikely(iov_size(iov, iovcnt) > sizeof(desc))) {
104 return VIRTIO_BLK_S_UNSUPP;
105 }
106
107 size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
108 if (unlikely(size != sizeof(desc))) {
109 error_report("Invalid size %zd, expected %zu", size, sizeof(desc));
110 return VIRTIO_BLK_S_IOERR;
111 }
112
113 sector = le64_to_cpu(desc.sector);
114 num_sectors = le32_to_cpu(desc.num_sectors);
115 flags = le32_to_cpu(desc.flags);
116 max_sectors = (type == VIRTIO_BLK_T_WRITE_ZEROES) ?
117 VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS :
118 VHOST_USER_BLK_MAX_DISCARD_SECTORS;
119
120
121 if (unlikely(num_sectors > max_sectors)) {
122 return VIRTIO_BLK_S_IOERR;
123 }
124
125 bytes = num_sectors << VIRTIO_BLK_SECTOR_BITS;
126
127 if (unlikely(!vu_blk_sect_range_ok(vexp, sector, bytes))) {
128 return VIRTIO_BLK_S_IOERR;
129 }
130
131
132
133
134
135 if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
136 return VIRTIO_BLK_S_UNSUPP;
137 }
138
139 if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
140 int blk_flags = 0;
141
142 if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
143 blk_flags |= BDRV_REQ_MAY_UNMAP;
144 }
145
146 if (blk_co_pwrite_zeroes(blk, sector << VIRTIO_BLK_SECTOR_BITS,
147 bytes, blk_flags) == 0) {
148 return VIRTIO_BLK_S_OK;
149 }
150 } else if (type == VIRTIO_BLK_T_DISCARD) {
151
152
153
154
155 if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
156 return VIRTIO_BLK_S_UNSUPP;
157 }
158
159 if (blk_co_pdiscard(blk, sector << VIRTIO_BLK_SECTOR_BITS,
160 bytes) == 0) {
161 return VIRTIO_BLK_S_OK;
162 }
163 }
164
165 return VIRTIO_BLK_S_IOERR;
166}
167
168static void coroutine_fn vu_blk_virtio_process_req(void *opaque)
169{
170 VuBlkReq *req = opaque;
171 VuServer *server = req->server;
172 VuVirtqElement *elem = &req->elem;
173 uint32_t type;
174
175 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
176 BlockBackend *blk = vexp->export.blk;
177
178 struct iovec *in_iov = elem->in_sg;
179 struct iovec *out_iov = elem->out_sg;
180 unsigned in_num = elem->in_num;
181 unsigned out_num = elem->out_num;
182
183
184 if (elem->out_num < 1 || elem->in_num < 1) {
185 error_report("virtio-blk request missing headers");
186 goto err;
187 }
188
189 if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
190 sizeof(req->out)) != sizeof(req->out))) {
191 error_report("virtio-blk request outhdr too short");
192 goto err;
193 }
194
195 iov_discard_front(&out_iov, &out_num, sizeof(req->out));
196
197 if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
198 error_report("virtio-blk request inhdr too short");
199 goto err;
200 }
201
202
203 req->in = (void *)in_iov[in_num - 1].iov_base
204 + in_iov[in_num - 1].iov_len
205 - sizeof(struct virtio_blk_inhdr);
206 iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
207
208 type = le32_to_cpu(req->out.type);
209 switch (type & ~VIRTIO_BLK_T_BARRIER) {
210 case VIRTIO_BLK_T_IN:
211 case VIRTIO_BLK_T_OUT: {
212 QEMUIOVector qiov;
213 int64_t offset;
214 ssize_t ret = 0;
215 bool is_write = type & VIRTIO_BLK_T_OUT;
216 req->sector_num = le64_to_cpu(req->out.sector);
217
218 if (is_write && !vexp->writable) {
219 req->in->status = VIRTIO_BLK_S_IOERR;
220 break;
221 }
222
223 if (is_write) {
224 qemu_iovec_init_external(&qiov, out_iov, out_num);
225 } else {
226 qemu_iovec_init_external(&qiov, in_iov, in_num);
227 }
228
229 if (unlikely(!vu_blk_sect_range_ok(vexp,
230 req->sector_num,
231 qiov.size))) {
232 req->in->status = VIRTIO_BLK_S_IOERR;
233 break;
234 }
235
236 offset = req->sector_num << VIRTIO_BLK_SECTOR_BITS;
237
238 if (is_write) {
239 ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);
240 } else {
241 ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);
242 }
243 if (ret >= 0) {
244 req->in->status = VIRTIO_BLK_S_OK;
245 } else {
246 req->in->status = VIRTIO_BLK_S_IOERR;
247 }
248 break;
249 }
250 case VIRTIO_BLK_T_FLUSH:
251 if (blk_co_flush(blk) == 0) {
252 req->in->status = VIRTIO_BLK_S_OK;
253 } else {
254 req->in->status = VIRTIO_BLK_S_IOERR;
255 }
256 break;
257 case VIRTIO_BLK_T_GET_ID: {
258 size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
259 VIRTIO_BLK_ID_BYTES);
260 snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
261 req->in->status = VIRTIO_BLK_S_OK;
262 req->size = elem->in_sg[0].iov_len;
263 break;
264 }
265 case VIRTIO_BLK_T_DISCARD:
266 case VIRTIO_BLK_T_WRITE_ZEROES: {
267 if (!vexp->writable) {
268 req->in->status = VIRTIO_BLK_S_IOERR;
269 break;
270 }
271
272 req->in->status = vu_blk_discard_write_zeroes(vexp, out_iov, out_num,
273 type);
274 break;
275 }
276 default:
277 req->in->status = VIRTIO_BLK_S_UNSUPP;
278 break;
279 }
280
281 vu_blk_req_complete(req);
282 return;
283
284err:
285 free(req);
286}
287
288static void vu_blk_process_vq(VuDev *vu_dev, int idx)
289{
290 VuServer *server = container_of(vu_dev, VuServer, vu_dev);
291 VuVirtq *vq = vu_get_queue(vu_dev, idx);
292
293 while (1) {
294 VuBlkReq *req;
295
296 req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));
297 if (!req) {
298 break;
299 }
300
301 req->server = server;
302 req->vq = vq;
303
304 Coroutine *co =
305 qemu_coroutine_create(vu_blk_virtio_process_req, req);
306 qemu_coroutine_enter(co);
307 }
308}
309
310static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)
311{
312 VuVirtq *vq;
313
314 assert(vu_dev);
315
316 vq = vu_get_queue(vu_dev, idx);
317 vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);
318}
319
320static uint64_t vu_blk_get_features(VuDev *dev)
321{
322 uint64_t features;
323 VuServer *server = container_of(dev, VuServer, vu_dev);
324 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
325 features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
326 1ull << VIRTIO_BLK_F_SEG_MAX |
327 1ull << VIRTIO_BLK_F_TOPOLOGY |
328 1ull << VIRTIO_BLK_F_BLK_SIZE |
329 1ull << VIRTIO_BLK_F_FLUSH |
330 1ull << VIRTIO_BLK_F_DISCARD |
331 1ull << VIRTIO_BLK_F_WRITE_ZEROES |
332 1ull << VIRTIO_BLK_F_CONFIG_WCE |
333 1ull << VIRTIO_BLK_F_MQ |
334 1ull << VIRTIO_F_VERSION_1 |
335 1ull << VIRTIO_RING_F_INDIRECT_DESC |
336 1ull << VIRTIO_RING_F_EVENT_IDX |
337 1ull << VHOST_USER_F_PROTOCOL_FEATURES;
338
339 if (!vexp->writable) {
340 features |= 1ull << VIRTIO_BLK_F_RO;
341 }
342
343 return features;
344}
345
346static uint64_t vu_blk_get_protocol_features(VuDev *dev)
347{
348 return 1ull << VHOST_USER_PROTOCOL_F_CONFIG;
349}
350
351static int
352vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
353{
354 VuServer *server = container_of(vu_dev, VuServer, vu_dev);
355 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
356
357 if (len > sizeof(struct virtio_blk_config)) {
358 return -1;
359 }
360
361 memcpy(config, &vexp->blkcfg, len);
362 return 0;
363}
364
365static int
366vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,
367 uint32_t offset, uint32_t size, uint32_t flags)
368{
369 VuServer *server = container_of(vu_dev, VuServer, vu_dev);
370 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
371 uint8_t wce;
372
373
374 if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
375 return -EINVAL;
376 }
377
378 if (offset != offsetof(struct virtio_blk_config, wce) ||
379 size != 1) {
380 return -EINVAL;
381 }
382
383 wce = *data;
384 vexp->blkcfg.wce = wce;
385 blk_set_enable_write_cache(vexp->export.blk, wce);
386 return 0;
387}
388
389
390
391
392
393
394
395
396
397static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
398{
399 if (vmsg->request == VHOST_USER_NONE) {
400 dev->panic(dev, "disconnect");
401 return true;
402 }
403 return false;
404}
405
406static const VuDevIface vu_blk_iface = {
407 .get_features = vu_blk_get_features,
408 .queue_set_started = vu_blk_queue_set_started,
409 .get_protocol_features = vu_blk_get_protocol_features,
410 .get_config = vu_blk_get_config,
411 .set_config = vu_blk_set_config,
412 .process_msg = vu_blk_process_msg,
413};
414
415static void blk_aio_attached(AioContext *ctx, void *opaque)
416{
417 VuBlkExport *vexp = opaque;
418
419 vexp->export.ctx = ctx;
420 vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
421}
422
423static void blk_aio_detach(void *opaque)
424{
425 VuBlkExport *vexp = opaque;
426
427 vhost_user_server_detach_aio_context(&vexp->vu_server);
428 vexp->export.ctx = NULL;
429}
430
431static void
432vu_blk_initialize_config(BlockDriverState *bs,
433 struct virtio_blk_config *config,
434 uint32_t blk_size,
435 uint16_t num_queues)
436{
437 config->capacity =
438 cpu_to_le64(bdrv_getlength(bs) >> VIRTIO_BLK_SECTOR_BITS);
439 config->blk_size = cpu_to_le32(blk_size);
440 config->size_max = cpu_to_le32(0);
441 config->seg_max = cpu_to_le32(128 - 2);
442 config->min_io_size = cpu_to_le16(1);
443 config->opt_io_size = cpu_to_le32(1);
444 config->num_queues = cpu_to_le16(num_queues);
445 config->max_discard_sectors =
446 cpu_to_le32(VHOST_USER_BLK_MAX_DISCARD_SECTORS);
447 config->max_discard_seg = cpu_to_le32(1);
448 config->discard_sector_alignment =
449 cpu_to_le32(blk_size >> VIRTIO_BLK_SECTOR_BITS);
450 config->max_write_zeroes_sectors
451 = cpu_to_le32(VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS);
452 config->max_write_zeroes_seg = cpu_to_le32(1);
453}
454
455static void vu_blk_exp_request_shutdown(BlockExport *exp)
456{
457 VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
458
459 vhost_user_server_stop(&vexp->vu_server);
460}
461
462static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
463 Error **errp)
464{
465 VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
466 BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
467 Error *local_err = NULL;
468 uint64_t logical_block_size;
469 uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;
470
471 vexp->writable = opts->writable;
472 vexp->blkcfg.wce = 0;
473
474 if (vu_opts->has_logical_block_size) {
475 logical_block_size = vu_opts->logical_block_size;
476 } else {
477 logical_block_size = VIRTIO_BLK_SECTOR_SIZE;
478 }
479 check_block_size(exp->id, "logical-block-size", logical_block_size,
480 &local_err);
481 if (local_err) {
482 error_propagate(errp, local_err);
483 return -EINVAL;
484 }
485 vexp->blk_size = logical_block_size;
486 blk_set_guest_block_size(exp->blk, logical_block_size);
487
488 if (vu_opts->has_num_queues) {
489 num_queues = vu_opts->num_queues;
490 }
491 if (num_queues == 0) {
492 error_setg(errp, "num-queues must be greater than 0");
493 return -EINVAL;
494 }
495
496 vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
497 logical_block_size, num_queues);
498
499 blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
500 vexp);
501
502 if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
503 num_queues, &vu_blk_iface, errp)) {
504 blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
505 blk_aio_detach, vexp);
506 return -EADDRNOTAVAIL;
507 }
508
509 return 0;
510}
511
512static void vu_blk_exp_delete(BlockExport *exp)
513{
514 VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
515
516 blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
517 vexp);
518}
519
520const BlockExportDriver blk_exp_vhost_user_blk = {
521 .type = BLOCK_EXPORT_TYPE_VHOST_USER_BLK,
522 .instance_size = sizeof(VuBlkExport),
523 .create = vu_blk_exp_create,
524 .delete = vu_blk_exp_delete,
525 .request_shutdown = vu_blk_exp_request_shutdown,
526};
527
