diff --git a/block.c b/block.c
index 0ac5b163d2aa19368ff54f2bc04a1f76b626d2dd..26c39825676bd0f37e028edac89eef774cf73c5f 100644
--- a/block.c
+++ b/block.c
@@ -6692,6 +6692,22 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
                                 bdrv_get_device_or_node_name(bs));
         return true;
     }
+
+    /*
+     * When migration puts a BDRV_O_INACTIVE flag on driver's open_flags,
+     * we fake a blocker that doesn't exist. From now on, block jobs
+     * will not be permitted.
+     */
+    if ((op == BLOCK_OP_TYPE_RESIZE || op == BLOCK_OP_TYPE_COMMIT_SOURCE ||
+         op == BLOCK_OP_TYPE_MIRROR_SOURCE || op == BLOCK_OP_TYPE_MIRROR_TARGET) &&
+         (bs->open_flags & BDRV_O_INACTIVE)) {
+        if (errp) {
+            error_setg(errp, "block device is in use by migration with"
+                       " a driver BDRV_O_INACTIVE flag setted");
+        }
+        return true;
+    }
+
     return false;
 }
 
diff --git a/blockdev.c b/blockdev.c
index 10a73fa423d8cef8c42515cab5a26ec7646329d0..3ce294ec4a7cb4c0b83dd1171bd8f78cd9732de8 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -492,6 +492,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
     QDict *interval_dict = NULL;
     QList *interval_list = NULL;
     const char *id;
+    const char *cache;
     BlockdevDetectZeroesOptions detect_zeroes =
         BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
     const char *throttling_group = NULL;
@@ -555,7 +556,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
         qdict_put_str(bs_opts, "driver", buf);
     }
 
-    on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
+    on_write_error = BLOCKDEV_ON_ERROR_REPORT;
     if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
         on_write_error = parse_block_error_action(buf, 0, &error);
         if (error) {
@@ -583,6 +584,21 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
 
     read_only = qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false);
 
+    if (!file || !*file) {
+        cache = qdict_get_try_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH);
+        if (cache && !strcmp(cache, "on")) {
+            bdrv_flags |= BDRV_O_NO_FLUSH;
+        }
+
+        cache = qdict_get_try_str(bs_opts, BDRV_OPT_CACHE_DIRECT);
+        if (cache && !strcmp(cache, "on")) {
+            bdrv_flags |= BDRV_O_NOCACHE;
+        }
+
+        qdict_del(bs_opts, BDRV_OPT_CACHE_NO_FLUSH);
+        qdict_del(bs_opts, BDRV_OPT_CACHE_DIRECT);
+    }
+
     /* init */
     if ((!file || !*file) && !qdict_size(bs_opts)) {
         BlockBackendRootState *blk_rs;
diff --git a/hw/block/block.c b/hw/block/block.c
index 26c0767552ff78210906cd68f2122d728f8f1c6c..2cfc93a68e58e39bc49a52b03ed9bdefc05a2435 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -224,9 +224,16 @@ bool blkconf_geometry(BlockConf *conf, int *ptrans,
                       Error **errp)
 {
     if (!conf->cyls && !conf->heads && !conf->secs) {
+        AioContext *ctx = blk_get_aio_context(conf->blk);
+
+        /* Callers may not expect this function to dispatch aio handlers, so
+         * disable external aio such as guest device emulation.
+         */
+        aio_disable_external(ctx);
         hd_geometry_guess(conf->blk,
                           &conf->cyls, &conf->heads, &conf->secs,
                           ptrans);
+        aio_enable_external(ctx);
     } else if (ptrans && *ptrans == BIOS_ATA_TRANSLATION_AUTO) {
         *ptrans = hd_bios_chs_auto_trans(conf->cyls, conf->heads, conf->secs);
     }
diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
index d4914178ea01e3b3de2e8e778caf6960e57df1dd..a1053f4036349e650a09083c1da3f5033bd6abe7 100644
--- a/hw/scsi/scsi-disk.c
+++ b/hw/scsi/scsi-disk.c
@@ -1930,7 +1930,10 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf)
     memset(outbuf, 0, r->buflen);
     switch (req->cmd.buf[0]) {
     case TEST_UNIT_READY:
-        assert(blk_is_available(s->qdev.conf.blk));
+        if (!blk_is_available(s->qdev.conf.blk)) {
+            scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
+            return 0;
+        }
         break;
     case INQUIRY:
         buflen = scsi_disk_emulate_inquiry(req, outbuf);
diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c
index 0306ccc7b1e4827a67aaed926f9333ff4658ad86..1f515860480224ac721b3593acbba3b2c6c8a846 100644
--- a/hw/scsi/scsi-generic.c
+++ b/hw/scsi/scsi-generic.c
@@ -179,6 +179,10 @@ static int scsi_handle_inquiry_reply(SCSIGenericReq *r, SCSIDevice *s, int len)
         (r->req.cmd.buf[1] & 0x01)) {
         page = r->req.cmd.buf[2];
         if (page == 0xb0) {
+            if (s->blocksize == 0) {
+                qemu_log("device blocksize is 0!\n");
+                abort();
+            }
             uint64_t max_transfer = blk_get_max_hw_transfer(s->conf.blk);
             uint32_t max_iov = blk_get_max_hw_iov(s->conf.blk);
 
@@ -314,11 +318,23 @@ static void scsi_read_complete(void * opaque, int ret)
     /* Snoop READ CAPACITY output to set the blocksize.  */
     if (r->req.cmd.buf[0] == READ_CAPACITY_10 &&
         (ldl_be_p(&r->buf[0]) != 0xffffffffU || s->max_lba == 0)) {
-        s->blocksize = ldl_be_p(&r->buf[4]);
+        int new_blocksize = ldl_be_p(&r->buf[4]);
+        if (s->blocksize != new_blocksize) {
+            qemu_log("device id=%s type=%d: blocksize %d change to %d\n",
+                     s->qdev.id ? s->qdev.id : "null", s->type,
+                     s->blocksize, new_blocksize);
+        }
+        s->blocksize = new_blocksize;
         s->max_lba = ldl_be_p(&r->buf[0]) & 0xffffffffULL;
     } else if (r->req.cmd.buf[0] == SERVICE_ACTION_IN_16 &&
                (r->req.cmd.buf[1] & 31) == SAI_READ_CAPACITY_16) {
-        s->blocksize = ldl_be_p(&r->buf[8]);
+        int new_blocksize = ldl_be_p(&r->buf[8]);
+        if (s->blocksize != new_blocksize) {
+            qemu_log("device id=%s type=%d: blocksize %d change to %d\n",
+                     s->qdev.id ? s->qdev.id : "null", s->type,
+                     s->blocksize, new_blocksize);
+        }
+        s->blocksize = new_blocksize;
         s->max_lba = ldq_be_p(&r->buf[0]);
     }
     blk_set_guest_block_size(s->conf.blk, s->blocksize);
diff --git a/nbd/client.c b/nbd/client.c
index 30d5383cb1952fbc4ee5ad57f930217d46e11852..8ed50140f2d4b3fa1627ee511d819b6578a5539c 100644
--- a/nbd/client.c
+++ b/nbd/client.c
@@ -24,6 +24,8 @@
 #include "nbd-internal.h"
 #include "qemu/cutils.h"
 
+#define NBD_TIMEOUT_SECONDS 30
+
 /* Definitions for opaque data types */
 
 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
@@ -1301,6 +1303,12 @@ int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
         }
     }
 
+    if (ioctl(fd, NBD_SET_TIMEOUT, NBD_TIMEOUT_SECONDS) < 0) {
+        int serrno = errno;
+        error_setg(errp, "Failed setting timeout");
+        return -serrno;
+    }
+
     trace_nbd_init_finish();
 
     return 0;
diff --git a/nbd/server.c b/nbd/server.c
index 4630dd732250bea820157bbc7b1a9027fbb7773c..37515ed5209706f28d22f788c7c40cfb1de10649 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -2606,6 +2606,7 @@ static coroutine_fn void nbd_trip(void *opaque)
     NBDRequestData *req;
     NBDRequest request = { 0 };    /* GCC thinks it can be used uninitialized */
     int ret;
+    bool client_closing;
     Error *local_err = NULL;
 
     trace_nbd_trip();
@@ -2681,8 +2682,11 @@ disconnect:
     if (local_err) {
         error_reportf_err(local_err, "Disconnect client, due to: ");
     }
+    client_closing = client->closing;
     nbd_request_put(req);
-    client_close(client, true);
+    if (!client_closing) {
+        client_close(client, true);
+    }
     nbd_client_put(client);
 }
 
diff --git a/qemu-nbd.c b/qemu-nbd.c
index c6c20df68a4dcb49bd47d02bcb5a674e8b9ec729..15a4bc40189a93af2deb4351a715582b64e0a554 100644
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -800,6 +800,10 @@ int main(int argc, char **argv)
     trace_init_file();
     qemu_set_log(LOG_TRACE);
 
+    if (!seen_aio && (flags & BDRV_O_NOCACHE)) {
+        flags |= BDRV_O_NATIVE_AIO;
+    }
+
     socket_activation = check_socket_activation();
     if (socket_activation == 0) {
         setup_address_and_port(&bindto, &port);
diff --git a/scsi/qemu-pr-helper.c b/scsi/qemu-pr-helper.c
index f281daeced8de939154e431b59645e493f1ec02d..bbb9b5774189995a612b1f440398d8a3115cb266 100644
--- a/scsi/qemu-pr-helper.c
+++ b/scsi/qemu-pr-helper.c
@@ -288,9 +288,12 @@ static void multipath_pr_init(void)
 
 static int is_mpath(int fd)
 {
-    struct dm_ioctl dm = { .flags = DM_NOFLUSH_FLAG };
+    struct dm_ioctl dm;
     struct dm_target_spec *tgt;
 
+    memset(&dm, 0, sizeof(struct dm_ioctl));
+    dm.flags = DM_NOFLUSH_FLAG;
+
     tgt = dm_dev_ioctl(fd, DM_TABLE_STATUS, &dm);
     if (!tgt) {
         if (errno == ENXIO) {