Lines Matching refs:drv
178 static int bdrv_is_whitelisted(BlockDriver *drv)
189 if (!strcmp(drv->format_name, *p)) {
198 BlockDriver *drv = bdrv_find_format(format_name);
199 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
202 int bdrv_create(BlockDriver *drv, const char* filename,
205 if (!drv->bdrv_create)
208 return drv->bdrv_create(filename, options);
213 BlockDriver *drv;
215 drv = bdrv_find_protocol(filename);
216 if (drv == NULL) {
217 drv = bdrv_find_format("file");
220 return bdrv_create(drv, filename, options);
273 BlockDriver *drv = NULL, *d;
280 drv = d;
285 return drv;
336 BlockDriver *drv1, *drv;
349 drv = bdrv_find_format("raw");
350 if (!drv) {
353 *pdrv = drv;
365 drv = NULL;
371 drv = drv1;
375 if (!drv) {
378 *pdrv = drv;
387 BlockDriver *drv = bs->drv;
389 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
394 if (drv->bdrv_getlength) {
395 int64_t length = drv->bdrv_getlength(bs);
410 int flags, BlockDriver *drv)
414 assert(drv != NULL);
426 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
430 bs->drv = drv;
431 bs->opaque = qemu_mallocz(drv->instance_size);
456 if (drv->bdrv_file_open) {
457 ret = drv->bdrv_file_open(bs, filename, open_flags);
461 ret = drv->bdrv_open(bs, open_flags);
490 bs->drv = NULL;
500 BlockDriver *drv;
503 drv = bdrv_find_protocol(filename);
504 if (!drv) {
509 ret = bdrv_open_common(bs, filename, flags, drv);
523 BlockDriver *drv)
542 ret = bdrv_open(bs1, filename, 0, drv);
549 if (bs1->drv && bs1->drv->protocol_name)
568 if (drv) {
570 drv->format_name);
580 drv = bdrv_qcow2;
585 if (!drv) {
586 ret = find_image_format(filename, &drv);
590 if (!drv) {
595 ret = bdrv_open_common(bs, filename, flags, drv);
649 if (bs->drv) {
657 bs->drv->bdrv_close(bs);
665 bs->drv = NULL;
734 if (bs->drv->bdrv_check == NULL) {
739 return bs->drv->bdrv_check(bs, res);
747 BlockDriver *drv = bs->drv;
755 if (!drv)
775 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR, drv);
780 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, drv);
784 bs->drv = NULL;
797 if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
811 if (drv->bdrv_make_empty) {
812 ret = drv->bdrv_make_empty(bs);
831 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, drv);
835 bs->drv = NULL;
865 BlockDriver *drv = bs->drv;
867 if (drv->bdrv_change_backing_file != NULL) {
868 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
907 BlockDriver *drv = bs->drv;
909 if (!drv)
914 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
954 BlockDriver *drv = bs->drv;
955 if (!bs->drv)
970 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
1109 BlockDriver *drv = bs->drv;
1111 if (!drv)
1113 if (!drv->bdrv_truncate)
1117 ret = drv->bdrv_truncate(bs, offset);
1129 BlockDriver *drv = bs->drv;
1130 if (!drv)
1137 if (!bs->growable || !drv->bdrv_getlength) {
1140 return drv->bdrv_getlength(bs);
1385 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1388 ret = bs->drv->bdrv_set_key(bs, key);
1403 if (!bs->drv) {
1406 pstrcpy(buf, buf_size, bs->drv->format_name);
1413 BlockDriver *drv;
1415 QLIST_FOREACH(drv, &bdrv_drivers, list) {
1416 it(opaque, drv->format_name);
1460 if (bs->drv && bs->drv->bdrv_flush)
1461 bs->drv->bdrv_flush(bs);
1469 if (bs->drv && !bdrv_is_read_only(bs) &&
1478 assert(bs->drv);
1480 if (bs->drv->bdrv_has_zero_init) {
1481 return bs->drv->bdrv_has_zero_init(bs);
1502 if (!bs->drv->bdrv_is_allocated) {
1511 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1568 monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1570 qdict_get_str(qdict, "drv"),
1612 if (bs->drv) {
1616 obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1619 bs->drv->format_name,
1729 BlockDriver *drv = bs->drv;
1730 if (!drv)
1732 if (!drv->bdrv_write_compressed)
1741 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1746 BlockDriver *drv = bs->drv;
1747 if (!drv)
1749 if (!drv->bdrv_get_info)
1752 return drv->bdrv_get_info(bs, bdi);
1758 BlockDriver *drv = bs->drv;
1759 if (!drv)
1761 if (drv->bdrv_save_vmstate)
1762 return drv->bdrv_save_vmstate(bs, buf, pos, size);
1771 BlockDriver *drv = bs->drv;
1772 if (!drv)
1774 if (drv->bdrv_load_vmstate)
1775 return drv->bdrv_load_vmstate(bs, buf, pos, size);
1783 BlockDriver *drv = bs->drv;
1785 if (!drv || !drv->bdrv_debug_event) {
1789 return drv->bdrv_debug_event(bs, event);
1798 BlockDriver *drv = bs->drv;
1799 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1803 if (!drv->bdrv_snapshot_create) {
1839 BlockDriver *drv = bs->drv;
1840 if (!drv)
1842 if (drv->bdrv_snapshot_create)
1843 return drv
1852 BlockDriver *drv = bs->drv;
1855 if (!drv)
1857 if (drv->bdrv_snapshot_goto)
1858 return drv->bdrv_snapshot_goto(bs, snapshot_id);
1861 drv->bdrv_close(bs);
1863 open_ret = drv->bdrv_open(bs, bs->open_flags);
1866 bs->drv = NULL;
1877 BlockDriver *drv = bs->drv;
1878 if (!drv)
1880 if (drv->bdrv_snapshot_delete)
1881 return drv->bdrv_snapshot_delete(bs, snapshot_id);
1890 BlockDriver *drv = bs->drv;
1891 if (!drv)
1893 if (drv->bdrv_snapshot_list)
1894 return drv->bdrv_snapshot_list(bs, psn_info);
1981 BlockDriver *drv = bs->drv;
1984 if (!drv)
1989 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
2005 BlockDriver *drv = bs->drv;
2008 if (!drv)
2019 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2122 if (!merge && bs->drv->bdrv_merge_requests) {
2123 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2260 BlockDriver *drv = bs->drv;
2266 if (!drv)
2268 return drv->bdrv_aio_flush(bs, cb, opaque);
2515 BlockDriver *drv = bs->drv;
2517 if (!drv)
2519 if (!drv->bdrv_is_inserted)
2521 ret = drv->bdrv_is_inserted(bs);
2531 BlockDriver *drv = bs->drv;
2534 if (!drv || !drv->bdrv_media_changed)
2537 ret = drv->bdrv_media_changed(bs);
2549 BlockDriver *drv = bs->drv;
2556 if (!drv || !drv->bdrv_eject) {
2559 ret = drv->bdrv_eject(bs, eject_flag);
2582 BlockDriver *drv = bs->drv;
2585 if (drv && drv->bdrv_set_locked) {
2586 drv->bdrv_set_locked(bs, locked);
2594 BlockDriver *drv = bs->drv;
2596 if (drv && drv->bdrv_ioctl)
2597 return drv->bdrv_ioctl(bs, req, buf);
2605 BlockDriver *drv = bs->drv;
2607 if (drv && drv->bdrv_aio_ioctl)
2608 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
