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