Revision 18846dee
| b/block.c | ||
|---|---|---|
| 665 | 665 |
|
| 666 | 666 |
void bdrv_delete(BlockDriverState *bs) |
| 667 | 667 |
{
|
| 668 |
assert(!bs->peer); |
|
| 669 |
|
|
| 668 | 670 |
/* remove from list, if necessary */ |
| 669 | 671 |
if (bs->device_name[0] != '\0') {
|
| 670 | 672 |
QTAILQ_REMOVE(&bdrv_states, bs, list); |
| ... | ... | |
| 678 | 680 |
qemu_free(bs); |
| 679 | 681 |
} |
| 680 | 682 |
|
| 683 |
int bdrv_attach(BlockDriverState *bs, DeviceState *qdev) |
|
| 684 |
{
|
|
| 685 |
if (bs->peer) {
|
|
| 686 |
return -EBUSY; |
|
| 687 |
} |
|
| 688 |
bs->peer = qdev; |
|
| 689 |
return 0; |
|
| 690 |
} |
|
| 691 |
|
|
| 692 |
void bdrv_detach(BlockDriverState *bs, DeviceState *qdev) |
|
| 693 |
{
|
|
| 694 |
assert(bs->peer == qdev); |
|
| 695 |
bs->peer = NULL; |
|
| 696 |
} |
|
| 697 |
|
|
| 698 |
DeviceState *bdrv_get_attached(BlockDriverState *bs) |
|
| 699 |
{
|
|
| 700 |
return bs->peer; |
|
| 701 |
} |
|
| 702 |
|
|
| 681 | 703 |
/* |
| 682 | 704 |
* Run consistency checks on an image |
| 683 | 705 |
* |
| b/block.h | ||
|---|---|---|
| 71 | 71 |
int bdrv_open(BlockDriverState *bs, const char *filename, int flags, |
| 72 | 72 |
BlockDriver *drv); |
| 73 | 73 |
void bdrv_close(BlockDriverState *bs); |
| 74 |
int bdrv_attach(BlockDriverState *bs, DeviceState *qdev); |
|
| 75 |
void bdrv_detach(BlockDriverState *bs, DeviceState *qdev); |
|
| 76 |
DeviceState *bdrv_get_attached(BlockDriverState *bs); |
|
| 74 | 77 |
int bdrv_check(BlockDriverState *bs); |
| 75 | 78 |
int bdrv_read(BlockDriverState *bs, int64_t sector_num, |
| 76 | 79 |
uint8_t *buf, int nb_sectors); |
| b/block_int.h | ||
|---|---|---|
| 148 | 148 |
BlockDriver *drv; /* NULL means no media */ |
| 149 | 149 |
void *opaque; |
| 150 | 150 |
|
| 151 |
DeviceState *peer; |
|
| 152 |
|
|
| 151 | 153 |
char filename[1024]; |
| 152 | 154 |
char backing_file[1024]; /* if non zero, the image is a diff of |
| 153 | 155 |
this file image */ |
| b/hw/fdc.c | ||
|---|---|---|
| 1860 | 1860 |
|
| 1861 | 1861 |
dev = isa_create("isa-fdc");
|
| 1862 | 1862 |
if (fds[0]) {
|
| 1863 |
qdev_prop_set_drive(&dev->qdev, "driveA", fds[0]->bdrv); |
|
| 1863 |
qdev_prop_set_drive_nofail(&dev->qdev, "driveA", fds[0]->bdrv);
|
|
| 1864 | 1864 |
} |
| 1865 | 1865 |
if (fds[1]) {
|
| 1866 |
qdev_prop_set_drive(&dev->qdev, "driveB", fds[1]->bdrv); |
|
| 1866 |
qdev_prop_set_drive_nofail(&dev->qdev, "driveB", fds[1]->bdrv);
|
|
| 1867 | 1867 |
} |
| 1868 | 1868 |
if (qdev_init(&dev->qdev) < 0) |
| 1869 | 1869 |
return NULL; |
| ... | ... | |
| 1882 | 1882 |
fdctrl = &sys->state; |
| 1883 | 1883 |
fdctrl->dma_chann = dma_chann; /* FIXME */ |
| 1884 | 1884 |
if (fds[0]) {
|
| 1885 |
qdev_prop_set_drive(dev, "driveA", fds[0]->bdrv); |
|
| 1885 |
qdev_prop_set_drive_nofail(dev, "driveA", fds[0]->bdrv);
|
|
| 1886 | 1886 |
} |
| 1887 | 1887 |
if (fds[1]) {
|
| 1888 |
qdev_prop_set_drive(dev, "driveB", fds[1]->bdrv); |
|
| 1888 |
qdev_prop_set_drive_nofail(dev, "driveB", fds[1]->bdrv);
|
|
| 1889 | 1889 |
} |
| 1890 | 1890 |
qdev_init_nofail(dev); |
| 1891 | 1891 |
sysbus_connect_irq(&sys->busdev, 0, irq); |
| ... | ... | |
| 1903 | 1903 |
|
| 1904 | 1904 |
dev = qdev_create(NULL, "SUNW,fdtwo"); |
| 1905 | 1905 |
if (fds[0]) {
|
| 1906 |
qdev_prop_set_drive(dev, "drive", fds[0]->bdrv); |
|
| 1906 |
qdev_prop_set_drive_nofail(dev, "drive", fds[0]->bdrv);
|
|
| 1907 | 1907 |
} |
| 1908 | 1908 |
qdev_init_nofail(dev); |
| 1909 | 1909 |
sys = DO_UPCAST(FDCtrlSysBus, busdev.qdev, dev); |
| b/hw/ide/qdev.c | ||
|---|---|---|
| 83 | 83 |
|
| 84 | 84 |
dev = qdev_create(&bus->qbus, "ide-drive"); |
| 85 | 85 |
qdev_prop_set_uint32(dev, "unit", unit); |
| 86 |
qdev_prop_set_drive(dev, "drive", drive->bdrv); |
|
| 86 |
qdev_prop_set_drive_nofail(dev, "drive", drive->bdrv);
|
|
| 87 | 87 |
qdev_init_nofail(dev); |
| 88 | 88 |
return DO_UPCAST(IDEDevice, qdev, dev); |
| 89 | 89 |
} |
| b/hw/pci-hotplug.c | ||
|---|---|---|
| 214 | 214 |
return NULL; |
| 215 | 215 |
} |
| 216 | 216 |
dev = pci_create(bus, devfn, "virtio-blk-pci"); |
| 217 |
qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv); |
|
| 217 |
if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) {
|
|
| 218 |
qdev_free(&dev->qdev); |
|
| 219 |
dev = NULL; |
|
| 220 |
break; |
|
| 221 |
} |
|
| 218 | 222 |
if (qdev_init(&dev->qdev) < 0) |
| 219 | 223 |
dev = NULL; |
| 220 | 224 |
break; |
| b/hw/qdev-properties.c | ||
|---|---|---|
| 311 | 311 |
bs = bdrv_find(str); |
| 312 | 312 |
if (bs == NULL) |
| 313 | 313 |
return -ENOENT; |
| 314 |
if (bdrv_attach(bs, dev) < 0) |
|
| 315 |
return -EEXIST; |
|
| 314 | 316 |
*ptr = bs; |
| 315 | 317 |
return 0; |
| 316 | 318 |
} |
| ... | ... | |
| 320 | 322 |
BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); |
| 321 | 323 |
|
| 322 | 324 |
if (*ptr) {
|
| 325 |
bdrv_detach(*ptr, dev); |
|
| 323 | 326 |
blockdev_auto_del(*ptr); |
| 324 | 327 |
} |
| 325 | 328 |
} |
| ... | ... | |
| 660 | 663 |
qdev_prop_set(dev, name, &value, PROP_TYPE_STRING); |
| 661 | 664 |
} |
| 662 | 665 |
|
| 663 |
void qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value)
|
|
| 666 |
int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value)
|
|
| 664 | 667 |
{
|
| 668 |
int res; |
|
| 669 |
|
|
| 670 |
res = bdrv_attach(value, dev); |
|
| 671 |
if (res < 0) {
|
|
| 672 |
error_report("Can't attach drive %s to %s.%s: %s",
|
|
| 673 |
bdrv_get_device_name(value), |
|
| 674 |
dev->id ? dev->id : dev->info->name, |
|
| 675 |
name, strerror(-res)); |
|
| 676 |
return -1; |
|
| 677 |
} |
|
| 665 | 678 |
qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE); |
| 679 |
return 0; |
|
| 666 | 680 |
} |
| 667 | 681 |
|
| 682 |
void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value) |
|
| 683 |
{
|
|
| 684 |
if (qdev_prop_set_drive(dev, name, value) < 0) {
|
|
| 685 |
exit(1); |
|
| 686 |
} |
|
| 687 |
} |
|
| 668 | 688 |
void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value) |
| 669 | 689 |
{
|
| 670 | 690 |
qdev_prop_set(dev, name, &value, PROP_TYPE_CHR); |
| b/hw/qdev.h | ||
|---|---|---|
| 275 | 275 |
void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value); |
| 276 | 276 |
void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value); |
| 277 | 277 |
void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value); |
| 278 |
void qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value); |
|
| 278 |
int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value) QEMU_WARN_UNUSED_RESULT; |
|
| 279 |
void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value); |
|
| 279 | 280 |
void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value); |
| 280 | 281 |
/* FIXME: Remove opaque pointer properties. */ |
| 281 | 282 |
void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value); |
| b/hw/s390-virtio.c | ||
|---|---|---|
| 262 | 262 |
} |
| 263 | 263 |
|
| 264 | 264 |
dev = qdev_create((BusState *)s390_bus, "virtio-blk-s390"); |
| 265 |
qdev_prop_set_drive(dev, "drive", dinfo->bdrv); |
|
| 265 |
qdev_prop_set_drive_nofail(dev, "drive", dinfo->bdrv);
|
|
| 266 | 266 |
qdev_init_nofail(dev); |
| 267 | 267 |
} |
| 268 | 268 |
} |
| b/hw/scsi-bus.c | ||
|---|---|---|
| 91 | 91 |
driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk"; |
| 92 | 92 |
dev = qdev_create(&bus->qbus, driver); |
| 93 | 93 |
qdev_prop_set_uint32(dev, "scsi-id", unit); |
| 94 |
qdev_prop_set_drive(dev, "drive", bdrv); |
|
| 94 |
if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {
|
|
| 95 |
qdev_free(dev); |
|
| 96 |
return NULL; |
|
| 97 |
} |
|
| 95 | 98 |
if (qdev_init(dev) < 0) |
| 96 | 99 |
return NULL; |
| 97 | 100 |
return DO_UPCAST(SCSIDevice, qdev, dev); |
| b/hw/usb-msd.c | ||
|---|---|---|
| 532 | 532 |
/* |
| 533 | 533 |
* Hack alert: this pretends to be a block device, but it's really |
| 534 | 534 |
* a SCSI bus that can serve only a single device, which it |
| 535 |
* creates automatically. Two drive properties pointing to the
|
|
| 536 |
* same drive is not good: free_drive() dies for the second one.
|
|
| 537 |
* Zap the one we're not going to use.
|
|
| 535 |
* creates automatically. But first it needs to detach from its
|
|
| 536 |
* blockdev, or else scsi_bus_legacy_add_drive() dies when it
|
|
| 537 |
* attaches again.
|
|
| 538 | 538 |
* |
| 539 | 539 |
* The hack is probably a bad idea. |
| 540 | 540 |
*/ |
| 541 |
bdrv_detach(bs, &s->dev.qdev); |
|
| 541 | 542 |
s->conf.bs = NULL; |
| 542 | 543 |
|
| 543 | 544 |
s->dev.speed = USB_SPEED_FULL; |
| ... | ... | |
| 609 | 610 |
if (!dev) {
|
| 610 | 611 |
return NULL; |
| 611 | 612 |
} |
| 612 |
qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv); |
|
| 613 |
if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) {
|
|
| 614 |
qdev_free(&dev->qdev); |
|
| 615 |
return NULL; |
|
| 616 |
} |
|
| 613 | 617 |
if (qdev_init(&dev->qdev) < 0) |
| 614 | 618 |
return NULL; |
| 615 | 619 |
|
Also available in: Unified diff