1 /*
2 * Copyright (c) 2018 Citrix Systems Inc.
3 *
4 * This work is licensed under the terms of the GNU GPL, version 2 or later.
5 * See the COPYING file in the top-level directory.
6 */
7
8 #include "qemu/osdep.h"
9 #include "qemu/cutils.h"
10 #include "qemu/main-loop.h"
11 #include "qemu/module.h"
12 #include "qemu/option.h"
13 #include "qapi/error.h"
14 #include "qapi/qapi-commands-block-core.h"
15 #include "qapi/qapi-commands-qom.h"
16 #include "qapi/qapi-visit-block-core.h"
17 #include "qapi/qobject-input-visitor.h"
18 #include "qapi/visitor.h"
19 #include "qapi/qmp/qdict.h"
20 #include "qapi/qmp/qstring.h"
21 #include "qom/object_interfaces.h"
22 #include "hw/block/xen_blkif.h"
23 #include "hw/qdev-properties.h"
24 #include "hw/xen/xen-block.h"
25 #include "hw/xen/xen-backend.h"
26 #include "sysemu/blockdev.h"
27 #include "sysemu/block-backend.h"
28 #include "sysemu/iothread.h"
29 #include "dataplane/xen-block.h"
30 #include "hw/xen/interface/io/xs_wire.h"
31 #include "trace.h"
32
33 #define XVDA_MAJOR 202
34 #define XVDQ_MAJOR (1 << 20)
35 #define XVDBGQCV_MAJOR ((1 << 21) - 1)
36 #define HDA_MAJOR 3
37 #define HDC_MAJOR 22
38 #define SDA_MAJOR 8
39
40
vdev_to_diskno(unsigned int vdev_nr)41 static int vdev_to_diskno(unsigned int vdev_nr)
42 {
43 switch (vdev_nr >> 8) {
44 case XVDA_MAJOR:
45 case SDA_MAJOR:
46 return (vdev_nr >> 4) & 0x15;
47
48 case HDA_MAJOR:
49 return (vdev_nr >> 6) & 1;
50
51 case HDC_MAJOR:
52 return ((vdev_nr >> 6) & 1) + 2;
53
54 case XVDQ_MAJOR ... XVDBGQCV_MAJOR:
55 return (vdev_nr >> 8) & 0xfffff;
56
57 default:
58 return -1;
59 }
60 }
61
62 #define MAX_AUTO_VDEV 4096
63
64 /*
65 * Find a free device name in the xvda → xvdfan range and set it in
66 * blockdev->props.vdev. Our definition of "free" is that there must
67 * be no other disk or partition with the same disk number.
68 *
69 * You are technically permitted to have all of hda, hda1, sda, sda1,
70 * xvda and xvda1 as *separate* PV block devices with separate backing
71 * stores. That doesn't make it a good idea. This code will skip xvda
72 * if *any* of those "conflicting" devices already exists.
73 *
74 * The limit of xvdfan (disk 4095) is fairly arbitrary just to avoid a
75 * stupidly sized bitmap, but Linux as of v6.6 doesn't support anything
76 * higher than that anyway.
77 */
xen_block_find_free_vdev(XenBlockDevice * blockdev,Error ** errp)78 static bool xen_block_find_free_vdev(XenBlockDevice *blockdev, Error **errp)
79 {
80 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(blockdev)));
81 unsigned long used_devs[BITS_TO_LONGS(MAX_AUTO_VDEV)];
82 XenBlockVdev *vdev = &blockdev->props.vdev;
83 char fe_path[XENSTORE_ABS_PATH_MAX + 1];
84 char **existing_frontends;
85 unsigned int nr_existing = 0;
86 unsigned int vdev_nr;
87 int i, disk = 0;
88
89 snprintf(fe_path, sizeof(fe_path), "/local/domain/%u/device/vbd",
90 blockdev->xendev.frontend_id);
91
92 existing_frontends = qemu_xen_xs_directory(xenbus->xsh, XBT_NULL, fe_path,
93 &nr_existing);
94 if (!existing_frontends) {
95 if (errno == ENOENT) {
96 /*
97 * If the frontend directory doesn't exist because there are
98 * no existing vbd devices, that's fine. Just ensure that we
99 * don't dereference the NULL existing_frontends pointer, by
100 * checking that nr_existing is zero so the loop below is not
101 * entered.
102 *
103 * In fact this is redundant since nr_existing is initialized
104 * to zero, but setting it again here makes it abundantly clear
105 * to Coverity, and to the human reader who doesn't know the
106 * semantics of qemu_xen_xs_directory() off the top of their
107 * head.
108 */
109 nr_existing = 0;
110 } else {
111 /* All other errors accessing the frontend directory are fatal. */
112 error_setg_errno(errp, errno, "cannot read %s", fe_path);
113 return false;
114 }
115 }
116
117 memset(used_devs, 0, sizeof(used_devs));
118 for (i = 0; i < nr_existing; i++) {
119 if (qemu_strtoui(existing_frontends[i], NULL, 10, &vdev_nr)) {
120 free(existing_frontends[i]);
121 continue;
122 }
123
124 free(existing_frontends[i]);
125
126 disk = vdev_to_diskno(vdev_nr);
127 if (disk < 0 || disk >= MAX_AUTO_VDEV) {
128 continue;
129 }
130
131 set_bit(disk, used_devs);
132 }
133 free(existing_frontends);
134
135 disk = find_first_zero_bit(used_devs, MAX_AUTO_VDEV);
136 if (disk == MAX_AUTO_VDEV) {
137 error_setg(errp, "cannot find device vdev for block device");
138 return false;
139 }
140
141 vdev->type = XEN_BLOCK_VDEV_TYPE_XVD;
142 vdev->partition = 0;
143 vdev->disk = disk;
144 if (disk < (1 << 4)) {
145 vdev->number = (XVDA_MAJOR << 8) | (disk << 4);
146 } else {
147 vdev->number = (XVDQ_MAJOR << 8) | (disk << 8);
148 }
149 return true;
150 }
151
xen_block_get_name(XenDevice * xendev,Error ** errp)152 static char *xen_block_get_name(XenDevice *xendev, Error **errp)
153 {
154 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
155 XenBlockVdev *vdev = &blockdev->props.vdev;
156
157 if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID &&
158 !xen_block_find_free_vdev(blockdev, errp)) {
159 return NULL;
160 }
161 return g_strdup_printf("%lu", vdev->number);
162 }
163
xen_block_disconnect(XenDevice * xendev,Error ** errp)164 static void xen_block_disconnect(XenDevice *xendev, Error **errp)
165 {
166 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
167 const char *type = object_get_typename(OBJECT(blockdev));
168 XenBlockVdev *vdev = &blockdev->props.vdev;
169
170 trace_xen_block_disconnect(type, vdev->disk, vdev->partition);
171
172 xen_block_dataplane_stop(blockdev->dataplane);
173 }
174
xen_block_connect(XenDevice * xendev,Error ** errp)175 static void xen_block_connect(XenDevice *xendev, Error **errp)
176 {
177 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
178 const char *type = object_get_typename(OBJECT(blockdev));
179 XenBlockVdev *vdev = &blockdev->props.vdev;
180 BlockConf *conf = &blockdev->props.conf;
181 unsigned int feature_large_sector_size;
182 unsigned int order, nr_ring_ref, *ring_ref, event_channel, protocol;
183 char *str;
184
185 trace_xen_block_connect(type, vdev->disk, vdev->partition);
186
187 if (xen_device_frontend_scanf(xendev, "feature-large-sector-size", "%u",
188 &feature_large_sector_size) != 1) {
189 feature_large_sector_size = 0;
190 }
191
192 if (feature_large_sector_size != 1 &&
193 conf->logical_block_size != XEN_BLKIF_SECTOR_SIZE) {
194 error_setg(errp, "logical_block_size != %u not supported by frontend",
195 XEN_BLKIF_SECTOR_SIZE);
196 return;
197 }
198
199 if (xen_device_frontend_scanf(xendev, "ring-page-order", "%u",
200 &order) != 1) {
201 nr_ring_ref = 1;
202 ring_ref = g_new(unsigned int, nr_ring_ref);
203
204 if (xen_device_frontend_scanf(xendev, "ring-ref", "%u",
205 &ring_ref[0]) != 1) {
206 error_setg(errp, "failed to read ring-ref");
207 g_free(ring_ref);
208 return;
209 }
210 } else if (qemu_xen_gnttab_can_map_multi() &&
211 order <= blockdev->props.max_ring_page_order) {
212 unsigned int i;
213
214 nr_ring_ref = 1 << order;
215 ring_ref = g_new(unsigned int, nr_ring_ref);
216
217 for (i = 0; i < nr_ring_ref; i++) {
218 const char *key = g_strdup_printf("ring-ref%u", i);
219
220 if (xen_device_frontend_scanf(xendev, key, "%u",
221 &ring_ref[i]) != 1) {
222 error_setg(errp, "failed to read %s", key);
223 g_free((gpointer)key);
224 g_free(ring_ref);
225 return;
226 }
227
228 g_free((gpointer)key);
229 }
230 } else {
231 error_setg(errp, "invalid ring-page-order (%d)", order);
232 return;
233 }
234
235 if (xen_device_frontend_scanf(xendev, "event-channel", "%u",
236 &event_channel) != 1) {
237 error_setg(errp, "failed to read event-channel");
238 g_free(ring_ref);
239 return;
240 }
241
242 if (xen_device_frontend_scanf(xendev, "protocol", "%ms", &str) != 1) {
243 /* x86 defaults to the 32-bit protocol even for 64-bit guests. */
244 if (object_dynamic_cast(OBJECT(qdev_get_machine()), "x86-machine")) {
245 protocol = BLKIF_PROTOCOL_X86_32;
246 } else {
247 protocol = BLKIF_PROTOCOL_NATIVE;
248 }
249 } else {
250 if (strcmp(str, XEN_IO_PROTO_ABI_X86_32) == 0) {
251 protocol = BLKIF_PROTOCOL_X86_32;
252 } else if (strcmp(str, XEN_IO_PROTO_ABI_X86_64) == 0) {
253 protocol = BLKIF_PROTOCOL_X86_64;
254 } else {
255 protocol = BLKIF_PROTOCOL_NATIVE;
256 }
257
258 free(str);
259 }
260
261 xen_block_dataplane_start(blockdev->dataplane, ring_ref, nr_ring_ref,
262 event_channel, protocol, errp);
263
264 g_free(ring_ref);
265 }
266
xen_block_unrealize(XenDevice * xendev)267 static void xen_block_unrealize(XenDevice *xendev)
268 {
269 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
270 XenBlockDeviceClass *blockdev_class =
271 XEN_BLOCK_DEVICE_GET_CLASS(xendev);
272 const char *type = object_get_typename(OBJECT(blockdev));
273 XenBlockVdev *vdev = &blockdev->props.vdev;
274
275 if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
276 return;
277 }
278
279 trace_xen_block_unrealize(type, vdev->disk, vdev->partition);
280
281 /* Disconnect from the frontend in case this has not already happened */
282 xen_block_disconnect(xendev, NULL);
283
284 xen_block_dataplane_destroy(blockdev->dataplane);
285 blockdev->dataplane = NULL;
286
287 if (blockdev_class->unrealize) {
288 blockdev_class->unrealize(blockdev);
289 }
290 }
291
xen_block_set_size(XenBlockDevice * blockdev)292 static void xen_block_set_size(XenBlockDevice *blockdev)
293 {
294 const char *type = object_get_typename(OBJECT(blockdev));
295 XenBlockVdev *vdev = &blockdev->props.vdev;
296 BlockConf *conf = &blockdev->props.conf;
297 int64_t sectors = blk_getlength(conf->blk) / conf->logical_block_size;
298 XenDevice *xendev = XEN_DEVICE(blockdev);
299
300 trace_xen_block_size(type, vdev->disk, vdev->partition, sectors);
301
302 xen_device_backend_printf(xendev, "sectors", "%"PRIi64, sectors);
303 }
304
xen_block_resize_cb(void * opaque)305 static void xen_block_resize_cb(void *opaque)
306 {
307 XenBlockDevice *blockdev = opaque;
308 XenDevice *xendev = XEN_DEVICE(blockdev);
309 enum xenbus_state state = xen_device_backend_get_state(xendev);
310
311 xen_block_set_size(blockdev);
312
313 /*
314 * Mimic the behaviour of Linux xen-blkback and re-write the state
315 * to trigger the frontend watch.
316 */
317 xen_device_backend_printf(xendev, "state", "%u", state);
318 }
319
320 /* Suspend request handling */
xen_block_drained_begin(void * opaque)321 static void xen_block_drained_begin(void *opaque)
322 {
323 XenBlockDevice *blockdev = opaque;
324
325 xen_block_dataplane_detach(blockdev->dataplane);
326 }
327
328 /* Resume request handling */
xen_block_drained_end(void * opaque)329 static void xen_block_drained_end(void *opaque)
330 {
331 XenBlockDevice *blockdev = opaque;
332
333 xen_block_dataplane_attach(blockdev->dataplane);
334 }
335
336 static const BlockDevOps xen_block_dev_ops = {
337 .resize_cb = xen_block_resize_cb,
338 .drained_begin = xen_block_drained_begin,
339 .drained_end = xen_block_drained_end,
340 };
341
xen_block_realize(XenDevice * xendev,Error ** errp)342 static void xen_block_realize(XenDevice *xendev, Error **errp)
343 {
344 ERRP_GUARD();
345 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
346 XenBlockDeviceClass *blockdev_class =
347 XEN_BLOCK_DEVICE_GET_CLASS(xendev);
348 const char *type = object_get_typename(OBJECT(blockdev));
349 XenBlockVdev *vdev = &blockdev->props.vdev;
350 BlockConf *conf = &blockdev->props.conf;
351 BlockBackend *blk = conf->blk;
352
353 if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
354 error_setg(errp, "vdev property not set");
355 return;
356 }
357
358 trace_xen_block_realize(type, vdev->disk, vdev->partition);
359
360 if (blockdev_class->realize) {
361 blockdev_class->realize(blockdev, errp);
362 if (*errp) {
363 return;
364 }
365 }
366
367 /*
368 * The blkif protocol does not deal with removable media, so it must
369 * always be present, even for CDRom devices.
370 */
371 assert(blk);
372 if (!blk_is_inserted(blk)) {
373 error_setg(errp, "device needs media, but drive is empty");
374 return;
375 }
376
377 if (!blkconf_apply_backend_options(conf, blockdev->info & VDISK_READONLY,
378 true, errp)) {
379 return;
380 }
381
382 if (!(blockdev->info & VDISK_CDROM) &&
383 !blkconf_geometry(conf, NULL, 65535, 255, 255, errp)) {
384 return;
385 }
386
387 if (!blkconf_blocksizes(conf, errp)) {
388 return;
389 }
390
391 if (conf->discard_granularity == -1) {
392 conf->discard_granularity = conf->physical_block_size;
393 }
394
395 if (blk_get_flags(blk) & BDRV_O_UNMAP) {
396 xen_device_backend_printf(xendev, "feature-discard", "%u", 1);
397 xen_device_backend_printf(xendev, "discard-granularity", "%u",
398 conf->discard_granularity);
399 xen_device_backend_printf(xendev, "discard-alignment", "%u", 0);
400 }
401
402 xen_device_backend_printf(xendev, "feature-flush-cache", "%u", 1);
403
404 if (qemu_xen_gnttab_can_map_multi()) {
405 xen_device_backend_printf(xendev, "max-ring-page-order", "%u",
406 blockdev->props.max_ring_page_order);
407 }
408
409 xen_device_backend_printf(xendev, "info", "%u", blockdev->info);
410
411 xen_device_frontend_printf(xendev, "virtual-device", "%lu",
412 vdev->number);
413 xen_device_frontend_printf(xendev, "device-type", "%s",
414 blockdev->device_type);
415
416 xen_device_backend_printf(xendev, "sector-size", "%u",
417 conf->logical_block_size);
418
419 xen_block_set_size(blockdev);
420
421 blockdev->dataplane =
422 xen_block_dataplane_create(xendev, blk, conf->logical_block_size,
423 blockdev->props.iothread);
424
425 blk_set_dev_ops(blk, &xen_block_dev_ops, blockdev);
426 }
427
xen_block_frontend_changed(XenDevice * xendev,enum xenbus_state frontend_state,Error ** errp)428 static void xen_block_frontend_changed(XenDevice *xendev,
429 enum xenbus_state frontend_state,
430 Error **errp)
431 {
432 ERRP_GUARD();
433 enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
434
435 switch (frontend_state) {
436 case XenbusStateInitialised:
437 case XenbusStateConnected:
438 if (backend_state == XenbusStateConnected) {
439 break;
440 }
441
442 xen_block_disconnect(xendev, errp);
443 if (*errp) {
444 break;
445 }
446
447 xen_block_connect(xendev, errp);
448 if (*errp) {
449 break;
450 }
451
452 xen_device_backend_set_state(xendev, XenbusStateConnected);
453 break;
454
455 case XenbusStateClosing:
456 xen_device_backend_set_state(xendev, XenbusStateClosing);
457 break;
458
459 case XenbusStateClosed:
460 case XenbusStateUnknown:
461 xen_block_disconnect(xendev, errp);
462 if (*errp) {
463 break;
464 }
465
466 xen_device_backend_set_state(xendev, XenbusStateClosed);
467 break;
468
469 default:
470 break;
471 }
472 }
473
disk_to_vbd_name(unsigned int disk)474 static char *disk_to_vbd_name(unsigned int disk)
475 {
476 char *name, *prefix = (disk >= 26) ?
477 disk_to_vbd_name((disk / 26) - 1) : g_strdup("");
478
479 name = g_strdup_printf("%s%c", prefix, 'a' + disk % 26);
480 g_free(prefix);
481
482 return name;
483 }
484
xen_block_get_vdev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)485 static void xen_block_get_vdev(Object *obj, Visitor *v, const char *name,
486 void *opaque, Error **errp)
487 {
488 Property *prop = opaque;
489 XenBlockVdev *vdev = object_field_prop_ptr(obj, prop);
490 char *str;
491
492 switch (vdev->type) {
493 case XEN_BLOCK_VDEV_TYPE_DP:
494 str = g_strdup_printf("d%lup%lu", vdev->disk, vdev->partition);
495 break;
496
497 case XEN_BLOCK_VDEV_TYPE_XVD:
498 case XEN_BLOCK_VDEV_TYPE_HD:
499 case XEN_BLOCK_VDEV_TYPE_SD: {
500 char *vbd_name = disk_to_vbd_name(vdev->disk);
501
502 str = g_strdup_printf("%s%s%lu",
503 (vdev->type == XEN_BLOCK_VDEV_TYPE_XVD) ?
504 "xvd" :
505 (vdev->type == XEN_BLOCK_VDEV_TYPE_HD) ?
506 "hd" :
507 "sd",
508 vbd_name, vdev->partition);
509 g_free(vbd_name);
510 break;
511 }
512 default:
513 error_setg(errp, "invalid vdev type");
514 return;
515 }
516
517 visit_type_str(v, name, &str, errp);
518 g_free(str);
519 }
520
vbd_name_to_disk(const char * name,const char ** endp,unsigned long * disk)521 static int vbd_name_to_disk(const char *name, const char **endp,
522 unsigned long *disk)
523 {
524 unsigned int n = 0;
525
526 while (*name != '\0') {
527 if (!g_ascii_isalpha(*name) || !g_ascii_islower(*name)) {
528 break;
529 }
530
531 n *= 26;
532 n += *name++ - 'a' + 1;
533 }
534 *endp = name;
535
536 if (!n) {
537 return -1;
538 }
539
540 *disk = n - 1;
541
542 return 0;
543 }
544
xen_block_set_vdev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)545 static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name,
546 void *opaque, Error **errp)
547 {
548 Property *prop = opaque;
549 XenBlockVdev *vdev = object_field_prop_ptr(obj, prop);
550 char *str, *p;
551 const char *end;
552
553 if (!visit_type_str(v, name, &str, errp)) {
554 return;
555 }
556
557 p = strchr(str, 'd');
558 if (!p) {
559 goto invalid;
560 }
561
562 *p++ = '\0';
563 if (*str == '\0') {
564 vdev->type = XEN_BLOCK_VDEV_TYPE_DP;
565 } else if (strcmp(str, "xv") == 0) {
566 vdev->type = XEN_BLOCK_VDEV_TYPE_XVD;
567 } else if (strcmp(str, "h") == 0) {
568 vdev->type = XEN_BLOCK_VDEV_TYPE_HD;
569 } else if (strcmp(str, "s") == 0) {
570 vdev->type = XEN_BLOCK_VDEV_TYPE_SD;
571 } else {
572 goto invalid;
573 }
574
575 if (vdev->type == XEN_BLOCK_VDEV_TYPE_DP) {
576 if (qemu_strtoul(p, &end, 10, &vdev->disk)) {
577 goto invalid;
578 }
579
580 if (*end == 'p') {
581 if (*(++end) == '\0') {
582 goto invalid;
583 }
584 }
585 } else {
586 if (vbd_name_to_disk(p, &end, &vdev->disk)) {
587 goto invalid;
588 }
589 }
590
591 if (*end != '\0') {
592 p = (char *)end;
593
594 if (qemu_strtoul(p, &end, 10, &vdev->partition)) {
595 goto invalid;
596 }
597
598 if (*end != '\0') {
599 goto invalid;
600 }
601 } else {
602 vdev->partition = 0;
603 }
604
605 switch (vdev->type) {
606 case XEN_BLOCK_VDEV_TYPE_DP:
607 case XEN_BLOCK_VDEV_TYPE_XVD:
608 if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
609 vdev->number = (XVDA_MAJOR << 8) | (vdev->disk << 4) |
610 vdev->partition;
611 } else if (vdev->disk < (1 << 20) && vdev->partition < (1 << 8)) {
612 vdev->number = (XVDQ_MAJOR << 8) | (vdev->disk << 8) |
613 vdev->partition;
614 } else {
615 goto invalid;
616 }
617 break;
618
619 case XEN_BLOCK_VDEV_TYPE_HD:
620 if ((vdev->disk == 0 || vdev->disk == 1) &&
621 vdev->partition < (1 << 6)) {
622 vdev->number = (HDA_MAJOR << 8) | (vdev->disk << 6) |
623 vdev->partition;
624 } else if ((vdev->disk == 2 || vdev->disk == 3) &&
625 vdev->partition < (1 << 6)) {
626 vdev->number = (HDC_MAJOR << 8) | ((vdev->disk - 2) << 6) |
627 vdev->partition;
628 } else {
629 goto invalid;
630 }
631 break;
632
633 case XEN_BLOCK_VDEV_TYPE_SD:
634 if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
635 vdev->number = (SDA_MAJOR << 8) | (vdev->disk << 4) |
636 vdev->partition;
637 } else {
638 goto invalid;
639 }
640 break;
641
642 default:
643 goto invalid;
644 }
645
646 g_free(str);
647 return;
648
649 invalid:
650 error_setg(errp, "invalid virtual disk specifier");
651
652 vdev->type = XEN_BLOCK_VDEV_TYPE_INVALID;
653 g_free(str);
654 }
655
656 /*
657 * This property deals with 'vdev' names adhering to the Xen VBD naming
658 * scheme described in:
659 *
660 * https://xenbits.xen.org/docs/unstable/man/xen-vbd-interface.7.html
661 */
662 const PropertyInfo xen_block_prop_vdev = {
663 .name = "str",
664 .description = "Virtual Disk specifier: d*p*/xvd*/hd*/sd*",
665 .get = xen_block_get_vdev,
666 .set = xen_block_set_vdev,
667 };
668
669 static Property xen_block_props[] = {
670 DEFINE_PROP("vdev", XenBlockDevice, props.vdev,
671 xen_block_prop_vdev, XenBlockVdev),
672 DEFINE_BLOCK_PROPERTIES(XenBlockDevice, props.conf),
673 DEFINE_PROP_UINT32("max-ring-page-order", XenBlockDevice,
674 props.max_ring_page_order, 4),
675 DEFINE_PROP_LINK("iothread", XenBlockDevice, props.iothread,
676 TYPE_IOTHREAD, IOThread *),
677 DEFINE_PROP_END_OF_LIST()
678 };
679
xen_block_class_init(ObjectClass * class,void * data)680 static void xen_block_class_init(ObjectClass *class, void *data)
681 {
682 DeviceClass *dev_class = DEVICE_CLASS(class);
683 XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
684
685 xendev_class->backend = "qdisk";
686 xendev_class->device = "vbd";
687 xendev_class->get_name = xen_block_get_name;
688 xendev_class->realize = xen_block_realize;
689 xendev_class->frontend_changed = xen_block_frontend_changed;
690 xendev_class->unrealize = xen_block_unrealize;
691
692 device_class_set_props(dev_class, xen_block_props);
693 }
694
695 static const TypeInfo xen_block_type_info = {
696 .name = TYPE_XEN_BLOCK_DEVICE,
697 .parent = TYPE_XEN_DEVICE,
698 .instance_size = sizeof(XenBlockDevice),
699 .abstract = true,
700 .class_size = sizeof(XenBlockDeviceClass),
701 .class_init = xen_block_class_init,
702 };
703
xen_disk_unrealize(XenBlockDevice * blockdev)704 static void xen_disk_unrealize(XenBlockDevice *blockdev)
705 {
706 trace_xen_disk_unrealize();
707 }
708
xen_disk_realize(XenBlockDevice * blockdev,Error ** errp)709 static void xen_disk_realize(XenBlockDevice *blockdev, Error **errp)
710 {
711 BlockConf *conf = &blockdev->props.conf;
712
713 trace_xen_disk_realize();
714
715 blockdev->device_type = "disk";
716
717 if (!conf->blk) {
718 error_setg(errp, "drive property not set");
719 return;
720 }
721
722 blockdev->info = blk_supports_write_perm(conf->blk) ? 0 : VDISK_READONLY;
723 }
724
xen_disk_class_init(ObjectClass * class,void * data)725 static void xen_disk_class_init(ObjectClass *class, void *data)
726 {
727 DeviceClass *dev_class = DEVICE_CLASS(class);
728 XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
729
730 blockdev_class->realize = xen_disk_realize;
731 blockdev_class->unrealize = xen_disk_unrealize;
732
733 dev_class->desc = "Xen Disk Device";
734 }
735
736 static const TypeInfo xen_disk_type_info = {
737 .name = TYPE_XEN_DISK_DEVICE,
738 .parent = TYPE_XEN_BLOCK_DEVICE,
739 .instance_size = sizeof(XenDiskDevice),
740 .class_init = xen_disk_class_init,
741 };
742
xen_cdrom_unrealize(XenBlockDevice * blockdev)743 static void xen_cdrom_unrealize(XenBlockDevice *blockdev)
744 {
745 trace_xen_cdrom_unrealize();
746 }
747
xen_cdrom_realize(XenBlockDevice * blockdev,Error ** errp)748 static void xen_cdrom_realize(XenBlockDevice *blockdev, Error **errp)
749 {
750 BlockConf *conf = &blockdev->props.conf;
751
752 trace_xen_cdrom_realize();
753
754 blockdev->device_type = "cdrom";
755
756 if (!conf->blk) {
757 int rc;
758
759 /* Set up an empty drive */
760 conf->blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
761
762 rc = blk_attach_dev(conf->blk, DEVICE(blockdev));
763 if (!rc) {
764 error_setg_errno(errp, -rc, "failed to create drive");
765 return;
766 }
767 }
768
769 blockdev->info = VDISK_READONLY | VDISK_CDROM;
770 }
771
xen_cdrom_class_init(ObjectClass * class,void * data)772 static void xen_cdrom_class_init(ObjectClass *class, void *data)
773 {
774 DeviceClass *dev_class = DEVICE_CLASS(class);
775 XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
776
777 blockdev_class->realize = xen_cdrom_realize;
778 blockdev_class->unrealize = xen_cdrom_unrealize;
779
780 dev_class->desc = "Xen CD-ROM Device";
781 }
782
783 static const TypeInfo xen_cdrom_type_info = {
784 .name = TYPE_XEN_CDROM_DEVICE,
785 .parent = TYPE_XEN_BLOCK_DEVICE,
786 .instance_size = sizeof(XenCDRomDevice),
787 .class_init = xen_cdrom_class_init,
788 };
789
xen_block_register_types(void)790 static void xen_block_register_types(void)
791 {
792 type_register_static(&xen_block_type_info);
793 type_register_static(&xen_disk_type_info);
794 type_register_static(&xen_cdrom_type_info);
795 }
796
type_init(xen_block_register_types)797 type_init(xen_block_register_types)
798
799 static void xen_block_blockdev_del(const char *node_name, Error **errp)
800 {
801 trace_xen_block_blockdev_del(node_name);
802
803 qmp_blockdev_del(node_name, errp);
804 }
805
xen_block_blockdev_add(const char * id,QDict * qdict,Error ** errp)806 static char *xen_block_blockdev_add(const char *id, QDict *qdict,
807 Error **errp)
808 {
809 ERRP_GUARD();
810 const char *driver = qdict_get_try_str(qdict, "driver");
811 BlockdevOptions *options = NULL;
812 char *node_name;
813 Visitor *v;
814
815 if (!driver) {
816 error_setg(errp, "no 'driver' parameter");
817 return NULL;
818 }
819
820 node_name = g_strdup_printf("%s-%s", id, driver);
821 qdict_put_str(qdict, "node-name", node_name);
822
823 trace_xen_block_blockdev_add(node_name);
824
825 v = qobject_input_visitor_new(QOBJECT(qdict));
826 visit_type_BlockdevOptions(v, NULL, &options, errp);
827 visit_free(v);
828 if (!options) {
829 goto fail;
830 }
831
832 qmp_blockdev_add(options, errp);
833
834 if (*errp) {
835 goto fail;
836 }
837
838 qapi_free_BlockdevOptions(options);
839
840 return node_name;
841
842 fail:
843 if (options) {
844 qapi_free_BlockdevOptions(options);
845 }
846 g_free(node_name);
847
848 return NULL;
849 }
850
xen_block_drive_destroy(XenBlockDrive * drive,Error ** errp)851 static void xen_block_drive_destroy(XenBlockDrive *drive, Error **errp)
852 {
853 ERRP_GUARD();
854 char *node_name = drive->node_name;
855
856 if (node_name) {
857 xen_block_blockdev_del(node_name, errp);
858 if (*errp) {
859 return;
860 }
861 g_free(node_name);
862 drive->node_name = NULL;
863 }
864 g_free(drive->id);
865 g_free(drive);
866 }
867
xen_block_drive_create(const char * id,const char * device_type,QDict * opts,Error ** errp)868 static XenBlockDrive *xen_block_drive_create(const char *id,
869 const char *device_type,
870 QDict *opts, Error **errp)
871 {
872 ERRP_GUARD();
873 const char *params = qdict_get_try_str(opts, "params");
874 const char *mode = qdict_get_try_str(opts, "mode");
875 const char *direct_io_safe = qdict_get_try_str(opts, "direct-io-safe");
876 const char *discard_enable = qdict_get_try_str(opts, "discard-enable");
877 char *driver = NULL;
878 char *filename = NULL;
879 XenBlockDrive *drive = NULL;
880 QDict *file_layer;
881 QDict *driver_layer;
882 struct stat st;
883 int rc;
884
885 if (params) {
886 char **v = g_strsplit(params, ":", 2);
887
888 if (v[1] == NULL) {
889 filename = g_strdup(v[0]);
890 driver = g_strdup("raw");
891 } else {
892 if (strcmp(v[0], "aio") == 0) {
893 driver = g_strdup("raw");
894 } else if (strcmp(v[0], "vhd") == 0) {
895 driver = g_strdup("vpc");
896 } else {
897 driver = g_strdup(v[0]);
898 }
899 filename = g_strdup(v[1]);
900 }
901
902 g_strfreev(v);
903 } else {
904 error_setg(errp, "no params");
905 goto done;
906 }
907
908 assert(filename);
909 assert(driver);
910
911 drive = g_new0(XenBlockDrive, 1);
912 drive->id = g_strdup(id);
913
914 rc = stat(filename, &st);
915 if (rc) {
916 error_setg_errno(errp, errno, "Could not stat file '%s'", filename);
917 goto done;
918 }
919
920 file_layer = qdict_new();
921 driver_layer = qdict_new();
922
923 if (S_ISBLK(st.st_mode)) {
924 qdict_put_str(file_layer, "driver", "host_device");
925 } else {
926 qdict_put_str(file_layer, "driver", "file");
927 }
928
929 qdict_put_str(file_layer, "filename", filename);
930
931 if (mode && *mode != 'w') {
932 qdict_put_bool(file_layer, "read-only", true);
933 }
934
935 if (direct_io_safe) {
936 unsigned long value;
937
938 if (!qemu_strtoul(direct_io_safe, NULL, 2, &value) && !!value) {
939 QDict *cache_qdict = qdict_new();
940
941 qdict_put_bool(cache_qdict, "direct", true);
942 qdict_put(file_layer, "cache", cache_qdict);
943
944 qdict_put_str(file_layer, "aio", "native");
945 }
946 }
947
948 if (discard_enable) {
949 unsigned long value;
950
951 if (!qemu_strtoul(discard_enable, NULL, 2, &value) && !!value) {
952 qdict_put_str(file_layer, "discard", "unmap");
953 qdict_put_str(driver_layer, "discard", "unmap");
954 }
955 }
956
957 /*
958 * It is necessary to turn file locking off as an emulated device
959 * may have already opened the same image file.
960 */
961 qdict_put_str(file_layer, "locking", "off");
962
963 qdict_put_str(driver_layer, "driver", driver);
964
965 qdict_put(driver_layer, "file", file_layer);
966
967 g_assert(!drive->node_name);
968 drive->node_name = xen_block_blockdev_add(drive->id, driver_layer,
969 errp);
970
971 qobject_unref(driver_layer);
972
973 done:
974 g_free(filename);
975 g_free(driver);
976 if (*errp) {
977 xen_block_drive_destroy(drive, NULL);
978 return NULL;
979 }
980
981 return drive;
982 }
983
xen_block_drive_get_node_name(XenBlockDrive * drive)984 static const char *xen_block_drive_get_node_name(XenBlockDrive *drive)
985 {
986 return drive->node_name ? drive->node_name : "";
987 }
988
xen_block_iothread_destroy(XenBlockIOThread * iothread,Error ** errp)989 static void xen_block_iothread_destroy(XenBlockIOThread *iothread,
990 Error **errp)
991 {
992 qmp_object_del(iothread->id, errp);
993
994 g_free(iothread->id);
995 g_free(iothread);
996 }
997
xen_block_iothread_create(const char * id,Error ** errp)998 static XenBlockIOThread *xen_block_iothread_create(const char *id,
999 Error **errp)
1000 {
1001 ERRP_GUARD();
1002 XenBlockIOThread *iothread = g_new(XenBlockIOThread, 1);
1003 ObjectOptions *opts;
1004
1005 iothread->id = g_strdup(id);
1006
1007 opts = g_new(ObjectOptions, 1);
1008 *opts = (ObjectOptions) {
1009 .qom_type = OBJECT_TYPE_IOTHREAD,
1010 .id = g_strdup(id),
1011 };
1012 qmp_object_add(opts, errp);
1013 qapi_free_ObjectOptions(opts);
1014
1015 if (*errp) {
1016 g_free(iothread->id);
1017 g_free(iothread);
1018 return NULL;
1019 }
1020
1021 return iothread;
1022 }
1023
xen_block_device_create(XenBackendInstance * backend,QDict * opts,Error ** errp)1024 static void xen_block_device_create(XenBackendInstance *backend,
1025 QDict *opts, Error **errp)
1026 {
1027 ERRP_GUARD();
1028 XenBus *xenbus = xen_backend_get_bus(backend);
1029 const char *name = xen_backend_get_name(backend);
1030 unsigned long number;
1031 const char *vdev, *device_type;
1032 XenBlockDrive *drive = NULL;
1033 XenBlockIOThread *iothread = NULL;
1034 XenDevice *xendev = NULL;
1035 const char *type;
1036 XenBlockDevice *blockdev;
1037
1038 if (qemu_strtoul(name, NULL, 10, &number)) {
1039 error_setg(errp, "failed to parse name '%s'", name);
1040 goto fail;
1041 }
1042
1043 trace_xen_block_device_create(number);
1044
1045 vdev = qdict_get_try_str(opts, "dev");
1046 if (!vdev) {
1047 error_setg(errp, "no dev parameter");
1048 goto fail;
1049 }
1050
1051 device_type = qdict_get_try_str(opts, "device-type");
1052 if (!device_type) {
1053 error_setg(errp, "no device-type parameter");
1054 goto fail;
1055 }
1056
1057 if (!strcmp(device_type, "disk")) {
1058 type = TYPE_XEN_DISK_DEVICE;
1059 } else if (!strcmp(device_type, "cdrom")) {
1060 type = TYPE_XEN_CDROM_DEVICE;
1061 } else {
1062 error_setg(errp, "invalid device-type parameter '%s'", device_type);
1063 goto fail;
1064 }
1065
1066 drive = xen_block_drive_create(vdev, device_type, opts, errp);
1067 if (!drive) {
1068 error_prepend(errp, "failed to create drive: ");
1069 goto fail;
1070 }
1071
1072 iothread = xen_block_iothread_create(vdev, errp);
1073 if (*errp) {
1074 error_prepend(errp, "failed to create iothread: ");
1075 goto fail;
1076 }
1077
1078 xendev = XEN_DEVICE(qdev_new(type));
1079 blockdev = XEN_BLOCK_DEVICE(xendev);
1080
1081 if (!object_property_set_str(OBJECT(xendev), "vdev", vdev,
1082 errp)) {
1083 error_prepend(errp, "failed to set 'vdev': ");
1084 goto fail;
1085 }
1086
1087 if (!object_property_set_str(OBJECT(xendev), "drive",
1088 xen_block_drive_get_node_name(drive),
1089 errp)) {
1090 error_prepend(errp, "failed to set 'drive': ");
1091 goto fail;
1092 }
1093
1094 if (!object_property_set_str(OBJECT(xendev), "iothread", iothread->id,
1095 errp)) {
1096 error_prepend(errp, "failed to set 'iothread': ");
1097 goto fail;
1098 }
1099
1100 blockdev->iothread = iothread;
1101 blockdev->drive = drive;
1102
1103 if (!qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {
1104 error_prepend(errp, "realization of device %s failed: ", type);
1105 goto fail;
1106 }
1107
1108 xen_backend_set_device(backend, xendev);
1109 return;
1110
1111 fail:
1112 if (xendev) {
1113 object_unparent(OBJECT(xendev));
1114 }
1115
1116 if (iothread) {
1117 xen_block_iothread_destroy(iothread, NULL);
1118 }
1119
1120 if (drive) {
1121 xen_block_drive_destroy(drive, NULL);
1122 }
1123 }
1124
xen_block_device_destroy(XenBackendInstance * backend,Error ** errp)1125 static void xen_block_device_destroy(XenBackendInstance *backend,
1126 Error **errp)
1127 {
1128 ERRP_GUARD();
1129 XenDevice *xendev = xen_backend_get_device(backend);
1130 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
1131 XenBlockVdev *vdev = &blockdev->props.vdev;
1132 XenBlockDrive *drive = blockdev->drive;
1133 XenBlockIOThread *iothread = blockdev->iothread;
1134
1135 trace_xen_block_device_destroy(vdev->number);
1136
1137 object_unparent(OBJECT(xendev));
1138
1139 /*
1140 * Drain all pending RCU callbacks as object_unparent() frees `xendev'
1141 * in a RCU callback.
1142 * And due to the property "drive" still existing in `xendev', we
1143 * can't destroy the XenBlockDrive associated with `xendev' with
1144 * xen_block_drive_destroy() below.
1145 */
1146 drain_call_rcu();
1147
1148 if (iothread) {
1149 xen_block_iothread_destroy(iothread, errp);
1150 if (*errp) {
1151 error_prepend(errp, "failed to destroy iothread: ");
1152 return;
1153 }
1154 }
1155
1156 if (drive) {
1157 xen_block_drive_destroy(drive, errp);
1158 if (*errp) {
1159 error_prepend(errp, "failed to destroy drive: ");
1160 return;
1161 }
1162 }
1163 }
1164
1165 static const XenBackendInfo xen_block_backend_info = {
1166 .type = "qdisk",
1167 .create = xen_block_device_create,
1168 .destroy = xen_block_device_destroy,
1169 };
1170
xen_block_register_backend(void)1171 static void xen_block_register_backend(void)
1172 {
1173 xen_backend_register(&xen_block_backend_info);
1174 }
1175
1176 xen_backend_init(xen_block_register_backend);
1177