diff --git a/MAINTAINERS b/MAINTAINERS index 1036c370fa..d48a4e8a8b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3115,6 +3115,12 @@ F: include/qemu/vhost-user-server.h F: tests/qtest/libqos/vhost-user-blk.c F: util/vhost-user-server.c +FUSE block device exports +M: Max Reitz +L: qemu-block@nongnu.org +S: Supported +F: block/export/fuse.c + Replication M: Wen Congyang M: Xie Changlong diff --git a/block.c b/block.c index f1cedac362..8f177504d4 100644 --- a/block.c +++ b/block.c @@ -26,6 +26,7 @@ #include "block/trace.h" #include "block/block_int.h" #include "block/blockjob.h" +#include "block/fuse.h" #include "block/nbd.h" #include "block/qdict.h" #include "qemu/error-report.h" @@ -961,6 +962,11 @@ int refresh_total_sectors(BlockDriverState *bs, int64_t hint) } bs->total_sectors = hint; + + if (bs->total_sectors * BDRV_SECTOR_SIZE > BDRV_MAX_LENGTH) { + return -EFBIG; + } + return 0; } @@ -5534,6 +5540,7 @@ void bdrv_get_backing_filename(BlockDriverState *bs, int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) { + int ret; BlockDriver *drv = bs->drv; /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ if (!drv) { @@ -5547,7 +5554,16 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) return -ENOTSUP; } memset(bdi, 0, sizeof(*bdi)); - return drv->bdrv_get_info(bs, bdi); + ret = drv->bdrv_get_info(bs, bdi); + if (ret < 0) { + return ret; + } + + if (bdi->cluster_size > BDRV_MAX_ALIGNMENT) { + return -EINVAL; + } + + return 0; } ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs, diff --git a/block/accounting.c b/block/accounting.c index 8d41c8a83a..2030851d79 100644 --- a/block/accounting.c +++ b/block/accounting.c @@ -199,29 +199,27 @@ static void block_account_one_io(BlockAcctStats *stats, BlockAcctCookie *cookie, return; } - qemu_mutex_lock(&stats->lock); + WITH_QEMU_LOCK_GUARD(&stats->lock) { + if (failed) { + stats->failed_ops[cookie->type]++; + } else { + stats->nr_bytes[cookie->type] += cookie->bytes; + stats->nr_ops[cookie->type]++; + } - if (failed) { - stats->failed_ops[cookie->type]++; - } else { - stats->nr_bytes[cookie->type] += cookie->bytes; - stats->nr_ops[cookie->type]++; - } + block_latency_histogram_account(&stats->latency_histogram[cookie->type], + latency_ns); - block_latency_histogram_account(&stats->latency_histogram[cookie->type], - latency_ns); + if (!failed || stats->account_failed) { + stats->total_time_ns[cookie->type] += latency_ns; + stats->last_access_time_ns = time_ns; - if (!failed || stats->account_failed) { - stats->total_time_ns[cookie->type] += latency_ns; - stats->last_access_time_ns = time_ns; - - QSLIST_FOREACH(s, &stats->intervals, entries) { - timed_average_account(&s->latency[cookie->type], latency_ns); + QSLIST_FOREACH(s, &stats->intervals, entries) { + timed_average_account(&s->latency[cookie->type], latency_ns); + } } } - qemu_mutex_unlock(&stats->lock); - cookie->type = BLOCK_ACCT_NONE; } diff --git a/block/curl.c b/block/curl.c index 4f907c47be..d24a4c5897 100644 --- a/block/curl.c +++ b/block/curl.c @@ -564,23 +564,23 @@ static void curl_detach_aio_context(BlockDriverState *bs) BDRVCURLState *s = bs->opaque; int i; - qemu_mutex_lock(&s->mutex); - for (i = 0; i < CURL_NUM_STATES; i++) { - if (s->states[i].in_use) { - curl_clean_state(&s->states[i]); + WITH_QEMU_LOCK_GUARD(&s->mutex) { + for (i = 0; i < CURL_NUM_STATES; i++) { + if (s->states[i].in_use) { + curl_clean_state(&s->states[i]); + } + if (s->states[i].curl) { + curl_easy_cleanup(s->states[i].curl); + s->states[i].curl = NULL; + } + g_free(s->states[i].orig_buf); + s->states[i].orig_buf = NULL; } - if (s->states[i].curl) { - curl_easy_cleanup(s->states[i].curl); - s->states[i].curl = NULL; + if (s->multi) { + curl_multi_cleanup(s->multi); + s->multi = NULL; } - g_free(s->states[i].orig_buf); - s->states[i].orig_buf = NULL; } - if (s->multi) { - curl_multi_cleanup(s->multi); - s->multi = NULL; - } - qemu_mutex_unlock(&s->mutex); timer_del(&s->timer); } diff --git a/block/export/export.c b/block/export/export.c index bad6f21b1c..b716c1522c 100644 --- a/block/export/export.c +++ b/block/export/export.c @@ -17,6 +17,7 @@ #include "sysemu/block-backend.h" #include "sysemu/iothread.h" #include "block/export.h" +#include "block/fuse.h" #include "block/nbd.h" #include "qapi/error.h" #include "qapi/qapi-commands-block-export.h" @@ -31,6 +32,9 @@ static const BlockExportDriver *blk_exp_drivers[] = { #ifdef CONFIG_VHOST_USER_BLK_SERVER &blk_exp_vhost_user_blk, #endif +#ifdef CONFIG_FUSE + &blk_exp_fuse, +#endif }; /* Only accessed from the main thread */ diff --git a/block/export/fuse.c b/block/export/fuse.c new file mode 100644 index 0000000000..38f74c94da --- /dev/null +++ b/block/export/fuse.c @@ -0,0 +1,726 @@ +/* + * Present a block device as a raw image through FUSE + * + * Copyright (c) 2020 Max Reitz + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; under version 2 or later of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#define FUSE_USE_VERSION 31 + +#include "qemu/osdep.h" +#include "block/aio.h" +#include "block/block.h" +#include "block/export.h" +#include "block/fuse.h" +#include "block/qapi.h" +#include "qapi/error.h" +#include "qapi/qapi-commands-block.h" +#include "sysemu/block-backend.h" + +#include +#include + + +/* Prevent overly long bounce buffer allocations */ +#define FUSE_MAX_BOUNCE_BYTES (MIN(BDRV_REQUEST_MAX_BYTES, 64 * 1024 * 1024)) + + +typedef struct FuseExport { + BlockExport common; + + struct fuse_session *fuse_session; + struct fuse_buf fuse_buf; + bool mounted, fd_handler_set_up; + + char *mountpoint; + bool writable; + bool growable; +} FuseExport; + +static GHashTable *exports; +static const struct fuse_lowlevel_ops fuse_ops; + +static void fuse_export_shutdown(BlockExport *exp); +static void fuse_export_delete(BlockExport *exp); + +static void init_exports_table(void); + +static int setup_fuse_export(FuseExport *exp, const char *mountpoint, + Error **errp); +static void read_from_fuse_export(void *opaque); + +static bool is_regular_file(const char *path, Error **errp); + + +static int fuse_export_create(BlockExport *blk_exp, + BlockExportOptions *blk_exp_args, + Error **errp) +{ + FuseExport *exp = container_of(blk_exp, FuseExport, common); + BlockExportOptionsFuse *args = &blk_exp_args->u.fuse; + int ret; + + assert(blk_exp_args->type == BLOCK_EXPORT_TYPE_FUSE); + + /* For growable exports, take the RESIZE permission */ + if (args->growable) { + uint64_t blk_perm, blk_shared_perm; + + blk_get_perm(exp->common.blk, &blk_perm, &blk_shared_perm); + + ret = blk_set_perm(exp->common.blk, blk_perm | BLK_PERM_RESIZE, + blk_shared_perm, errp); + if (ret < 0) { + return ret; + } + } + + init_exports_table(); + + /* + * It is important to do this check before calling is_regular_file() -- + * that function will do a stat(), which we would have to handle if we + * already exported something on @mountpoint. But we cannot, because + * we are currently caught up here. + * (Note that ideally we would want to resolve relative paths here, + * but bdrv_make_absolute_filename() might do the wrong thing for + * paths that contain colons, and realpath() would resolve symlinks, + * which we do not want: The mount point is not going to be the + * symlink's destination, but the link itself.) + * So this will not catch all potential clashes, but hopefully at + * least the most common one of specifying exactly the same path + * string twice. + */ + if (g_hash_table_contains(exports, args->mountpoint)) { + error_setg(errp, "There already is a FUSE export on '%s'", + args->mountpoint); + ret = -EEXIST; + goto fail; + } + + if (!is_regular_file(args->mountpoint, errp)) { + ret = -EINVAL; + goto fail; + } + + exp->mountpoint = g_strdup(args->mountpoint); + exp->writable = blk_exp_args->writable; + exp->growable = args->growable; + + ret = setup_fuse_export(exp, args->mountpoint, errp); + if (ret < 0) { + goto fail; + } + + return 0; + +fail: + fuse_export_delete(blk_exp); + return ret; +} + +/** + * Allocates the global @exports hash table. + */ +static void init_exports_table(void) +{ + if (exports) { + return; + } + + exports = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); +} + +/** + * Create exp->fuse_session and mount it. + */ +static int setup_fuse_export(FuseExport *exp, const char *mountpoint, + Error **errp) +{ + const char *fuse_argv[4]; + char *mount_opts; + struct fuse_args fuse_args; + int ret; + + /* Needs to match what fuse_init() sets. Only max_read must be supplied. */ + mount_opts = g_strdup_printf("max_read=%zu", FUSE_MAX_BOUNCE_BYTES); + + fuse_argv[0] = ""; /* Dummy program name */ + fuse_argv[1] = "-o"; + fuse_argv[2] = mount_opts; + fuse_argv[3] = NULL; + fuse_args = (struct fuse_args)FUSE_ARGS_INIT(3, (char **)fuse_argv); + + exp->fuse_session = fuse_session_new(&fuse_args, &fuse_ops, + sizeof(fuse_ops), exp); + g_free(mount_opts); + if (!exp->fuse_session) { + error_setg(errp, "Failed to set up FUSE session"); + ret = -EIO; + goto fail; + } + + ret = fuse_session_mount(exp->fuse_session, mountpoint); + if (ret < 0) { + error_setg(errp, "Failed to mount FUSE session to export"); + ret = -EIO; + goto fail; + } + exp->mounted = true; + + g_hash_table_insert(exports, g_strdup(mountpoint), NULL); + + aio_set_fd_handler(exp->common.ctx, + fuse_session_fd(exp->fuse_session), true, + read_from_fuse_export, NULL, NULL, exp); + exp->fd_handler_set_up = true; + + return 0; + +fail: + fuse_export_shutdown(&exp->common); + return ret; +} + +/** + * Callback to be invoked when the FUSE session FD can be read from. + * (This is basically the FUSE event loop.) + */ +static void read_from_fuse_export(void *opaque) +{ + FuseExport *exp = opaque; + int ret; + + blk_exp_ref(&exp->common); + + do { + ret = fuse_session_receive_buf(exp->fuse_session, &exp->fuse_buf); + } while (ret == -EINTR); + if (ret < 0) { + goto out; + } + + fuse_session_process_buf(exp->fuse_session, &exp->fuse_buf); + +out: + blk_exp_unref(&exp->common); +} + +static void fuse_export_shutdown(BlockExport *blk_exp) +{ + FuseExport *exp = container_of(blk_exp, FuseExport, common); + + if (exp->fuse_session) { + fuse_session_exit(exp->fuse_session); + + if (exp->fd_handler_set_up) { + aio_set_fd_handler(exp->common.ctx, + fuse_session_fd(exp->fuse_session), true, + NULL, NULL, NULL, NULL); + exp->fd_handler_set_up = false; + } + } + + if (exp->mountpoint) { + /* + * Safe to drop now, because we will not handle any requests + * for this export anymore anyway. + */ + g_hash_table_remove(exports, exp->mountpoint); + } +} + +static void fuse_export_delete(BlockExport *blk_exp) +{ + FuseExport *exp = container_of(blk_exp, FuseExport, common); + + if (exp->fuse_session) { + if (exp->mounted) { + fuse_session_unmount(exp->fuse_session); + } + + fuse_session_destroy(exp->fuse_session); + } + + free(exp->fuse_buf.mem); + g_free(exp->mountpoint); +} + +/** + * Check whether @path points to a regular file. If not, put an + * appropriate message into *errp. + */ +static bool is_regular_file(const char *path, Error **errp) +{ + struct stat statbuf; + int ret; + + ret = stat(path, &statbuf); + if (ret < 0) { + error_setg_errno(errp, errno, "Failed to stat '%s'", path); + return false; + } + + if (!S_ISREG(statbuf.st_mode)) { + error_setg(errp, "'%s' is not a regular file", path); + return false; + } + + return true; +} + +/** + * A chance to set change some parameters supplied to FUSE_INIT. + */ +static void fuse_init(void *userdata, struct fuse_conn_info *conn) +{ + /* + * MIN_NON_ZERO() would not be wrong here, but what we set here + * must equal what has been passed to fuse_session_new(). + * Therefore, as long as max_read must be passed as a mount option + * (which libfuse claims will be changed at some point), we have + * to set max_read to a fixed value here. + */ + conn->max_read = FUSE_MAX_BOUNCE_BYTES; + + conn->max_write = MIN_NON_ZERO(BDRV_REQUEST_MAX_BYTES, conn->max_write); +} + +/** + * Let clients look up files. Always return ENOENT because we only + * care about the mountpoint itself. + */ +static void fuse_lookup(fuse_req_t req, fuse_ino_t parent, const char *name) +{ + fuse_reply_err(req, ENOENT); +} + +/** + * Let clients get file attributes (i.e., stat() the file). + */ +static void fuse_getattr(fuse_req_t req, fuse_ino_t inode, + struct fuse_file_info *fi) +{ + struct stat statbuf; + int64_t length, allocated_blocks; + time_t now = time(NULL); + FuseExport *exp = fuse_req_userdata(req); + mode_t mode; + + length = blk_getlength(exp->common.blk); + if (length < 0) { + fuse_reply_err(req, -length); + return; + } + + allocated_blocks = bdrv_get_allocated_file_size(blk_bs(exp->common.blk)); + if (allocated_blocks <= 0) { + allocated_blocks = DIV_ROUND_UP(length, 512); + } else { + allocated_blocks = DIV_ROUND_UP(allocated_blocks, 512); + } + + mode = S_IFREG | S_IRUSR; + if (exp->writable) { + mode |= S_IWUSR; + } + + statbuf = (struct stat) { + .st_ino = inode, + .st_mode = mode, + .st_nlink = 1, + .st_uid = getuid(), + .st_gid = getgid(), + .st_size = length, + .st_blksize = blk_bs(exp->common.blk)->bl.request_alignment, + .st_blocks = allocated_blocks, + .st_atime = now, + .st_mtime = now, + .st_ctime = now, + }; + + fuse_reply_attr(req, &statbuf, 1.); +} + +static int fuse_do_truncate(const FuseExport *exp, int64_t size, + bool req_zero_write, PreallocMode prealloc) +{ + uint64_t blk_perm, blk_shared_perm; + BdrvRequestFlags truncate_flags = 0; + int ret; + + if (req_zero_write) { + truncate_flags |= BDRV_REQ_ZERO_WRITE; + } + + /* Growable exports have a permanent RESIZE permission */ + if (!exp->growable) { + blk_get_perm(exp->common.blk, &blk_perm, &blk_shared_perm); + + ret = blk_set_perm(exp->common.blk, blk_perm | BLK_PERM_RESIZE, + blk_shared_perm, NULL); + if (ret < 0) { + return ret; + } + } + + ret = blk_truncate(exp->common.blk, size, true, prealloc, + truncate_flags, NULL); + + if (!exp->growable) { + /* Must succeed, because we are only giving up the RESIZE permission */ + blk_set_perm(exp->common.blk, blk_perm, blk_shared_perm, &error_abort); + } + + return ret; +} + +/** + * Let clients set file attributes. Only resizing is supported. + */ +static void fuse_setattr(fuse_req_t req, fuse_ino_t inode, struct stat *statbuf, + int to_set, struct fuse_file_info *fi) +{ + FuseExport *exp = fuse_req_userdata(req); + int ret; + + if (!exp->writable) { + fuse_reply_err(req, EACCES); + return; + } + + if (to_set & ~FUSE_SET_ATTR_SIZE) { + fuse_reply_err(req, ENOTSUP); + return; + } + + ret = fuse_do_truncate(exp, statbuf->st_size, true, PREALLOC_MODE_OFF); + if (ret < 0) { + fuse_reply_err(req, -ret); + return; + } + + fuse_getattr(req, inode, fi); +} + +/** + * Let clients open a file (i.e., the exported image). + */ +static void fuse_open(fuse_req_t req, fuse_ino_t inode, + struct fuse_file_info *fi) +{ + fuse_reply_open(req, fi); +} + +/** + * Handle client reads from the exported image. + */ +static void fuse_read(fuse_req_t req, fuse_ino_t inode, + size_t size, off_t offset, struct fuse_file_info *fi) +{ + FuseExport *exp = fuse_req_userdata(req); + int64_t length; + void *buf; + int ret; + + /* Limited by max_read, should not happen */ + if (size > FUSE_MAX_BOUNCE_BYTES) { + fuse_reply_err(req, EINVAL); + return; + } + + /** + * Clients will expect short reads at EOF, so we have to limit + * offset+size to the image length. + */ + length = blk_getlength(exp->common.blk); + if (length < 0) { + fuse_reply_err(req, -length); + return; + } + + if (offset + size > length) { + size = length - offset; + } + + buf = qemu_try_blockalign(blk_bs(exp->common.blk), size); + if (!buf) { + fuse_reply_err(req, ENOMEM); + return; + } + + ret = blk_pread(exp->common.blk, offset, buf, size); + if (ret >= 0) { + fuse_reply_buf(req, buf, size); + } else { + fuse_reply_err(req, -ret); + } + + qemu_vfree(buf); +} + +/** + * Handle client writes to the exported image. + */ +static void fuse_write(fuse_req_t req, fuse_ino_t inode, const char *buf, + size_t size, off_t offset, struct fuse_file_info *fi) +{ + FuseExport *exp = fuse_req_userdata(req); + int64_t length; + int ret; + + /* Limited by max_write, should not happen */ + if (size > BDRV_REQUEST_MAX_BYTES) { + fuse_reply_err(req, EINVAL); + return; + } + + if (!exp->writable) { + fuse_reply_err(req, EACCES); + return; + } + + /** + * Clients will expect short writes at EOF, so we have to limit + * offset+size to the image length. + */ + length = blk_getlength(exp->common.blk); + if (length < 0) { + fuse_reply_err(req, -length); + return; + } + + if (offset + size > length) { + if (exp->growable) { + ret = fuse_do_truncate(exp, offset + size, true, PREALLOC_MODE_OFF); + if (ret < 0) { + fuse_reply_err(req, -ret); + return; + } + } else { + size = length - offset; + } + } + + ret = blk_pwrite(exp->common.blk, offset, buf, size, 0); + if (ret >= 0) { + fuse_reply_write(req, size); + } else { + fuse_reply_err(req, -ret); + } +} + +/** + * Let clients perform various fallocate() operations. + */ +static void fuse_fallocate(fuse_req_t req, fuse_ino_t inode, int mode, + off_t offset, off_t length, + struct fuse_file_info *fi) +{ + FuseExport *exp = fuse_req_userdata(req); + int64_t blk_len; + int ret; + + if (!exp->writable) { + fuse_reply_err(req, EACCES); + return; + } + + blk_len = blk_getlength(exp->common.blk); + if (blk_len < 0) { + fuse_reply_err(req, -blk_len); + return; + } + + if (mode & FALLOC_FL_KEEP_SIZE) { + length = MIN(length, blk_len - offset); + } + + if (mode & FALLOC_FL_PUNCH_HOLE) { + if (!(mode & FALLOC_FL_KEEP_SIZE)) { + fuse_reply_err(req, EINVAL); + return; + } + + do { + int size = MIN(length, BDRV_REQUEST_MAX_BYTES); + + ret = blk_pdiscard(exp->common.blk, offset, size); + offset += size; + length -= size; + } while (ret == 0 && length > 0); + } else if (mode & FALLOC_FL_ZERO_RANGE) { + if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + length > blk_len) { + /* No need for zeroes, we are going to write them ourselves */ + ret = fuse_do_truncate(exp, offset + length, false, + PREALLOC_MODE_OFF); + if (ret < 0) { + fuse_reply_err(req, -ret); + return; + } + } + + do { + int size = MIN(length, BDRV_REQUEST_MAX_BYTES); + + ret = blk_pwrite_zeroes(exp->common.blk, + offset, size, 0); + offset += size; + length -= size; + } while (ret == 0 && length > 0); + } else if (!mode) { + /* We can only fallocate at the EOF with a truncate */ + if (offset < blk_len) { + fuse_reply_err(req, EOPNOTSUPP); + return; + } + + if (offset > blk_len) { + /* No preallocation needed here */ + ret = fuse_do_truncate(exp, offset, true, PREALLOC_MODE_OFF); + if (ret < 0) { + fuse_reply_err(req, -ret); + return; + } + } + + ret = fuse_do_truncate(exp, offset + length, true, + PREALLOC_MODE_FALLOC); + } else { + ret = -EOPNOTSUPP; + } + + fuse_reply_err(req, ret < 0 ? -ret : 0); +} + +/** + * Let clients fsync the exported image. + */ +static void fuse_fsync(fuse_req_t req, fuse_ino_t inode, int datasync, + struct fuse_file_info *fi) +{ + FuseExport *exp = fuse_req_userdata(req); + int ret; + + ret = blk_flush(exp->common.blk); + fuse_reply_err(req, ret < 0 ? -ret : 0); +} + +/** + * Called before an FD to the exported image is closed. (libfuse + * notes this to be a way to return last-minute errors.) + */ +static void fuse_flush(fuse_req_t req, fuse_ino_t inode, + struct fuse_file_info *fi) +{ + fuse_fsync(req, inode, 1, fi); +} + +#ifdef CONFIG_FUSE_LSEEK +/** + * Let clients inquire allocation status. + */ +static void fuse_lseek(fuse_req_t req, fuse_ino_t inode, off_t offset, + int whence, struct fuse_file_info *fi) +{ + FuseExport *exp = fuse_req_userdata(req); + + if (whence != SEEK_HOLE && whence != SEEK_DATA) { + fuse_reply_err(req, EINVAL); + return; + } + + while (true) { + int64_t pnum; + int ret; + + ret = bdrv_block_status_above(blk_bs(exp->common.blk), NULL, + offset, INT64_MAX, &pnum, NULL, NULL); + if (ret < 0) { + fuse_reply_err(req, -ret); + return; + } + + if (!pnum && (ret & BDRV_BLOCK_EOF)) { + int64_t blk_len; + + /* + * If blk_getlength() rounds (e.g. by sectors), then the + * export length will be rounded, too. However, + * bdrv_block_status_above() may return EOF at unaligned + * offsets. We must not let this become visible and thus + * always simulate a hole between @offset (the real EOF) + * and @blk_len (the client-visible EOF). + */ + + blk_len = blk_getlength(exp->common.blk); + if (blk_len < 0) { + fuse_reply_err(req, -blk_len); + return; + } + + if (offset > blk_len || whence == SEEK_DATA) { + fuse_reply_err(req, ENXIO); + } else { + fuse_reply_lseek(req, offset); + } + return; + } + + if (ret & BDRV_BLOCK_DATA) { + if (whence == SEEK_DATA) { + fuse_reply_lseek(req, offset); + return; + } + } else { + if (whence == SEEK_HOLE) { + fuse_reply_lseek(req, offset); + return; + } + } + + /* Safety check against infinite loops */ + if (!pnum) { + fuse_reply_err(req, ENXIO); + return; + } + + offset += pnum; + } +} +#endif + +static const struct fuse_lowlevel_ops fuse_ops = { + .init = fuse_init, + .lookup = fuse_lookup, + .getattr = fuse_getattr, + .setattr = fuse_setattr, + .open = fuse_open, + .read = fuse_read, + .write = fuse_write, + .fallocate = fuse_fallocate, + .flush = fuse_flush, + .fsync = fuse_fsync, +#ifdef CONFIG_FUSE_LSEEK + .lseek = fuse_lseek, +#endif +}; + +const BlockExportDriver blk_exp_fuse = { + .type = BLOCK_EXPORT_TYPE_FUSE, + .instance_size = sizeof(FuseExport), + .create = fuse_export_create, + .delete = fuse_export_delete, + .request_shutdown = fuse_export_shutdown, +}; diff --git a/block/export/meson.build b/block/export/meson.build index 135b356775..0a08e384c7 100644 --- a/block/export/meson.build +++ b/block/export/meson.build @@ -3,3 +3,5 @@ blockdev_ss.add(files('export.c')) if have_vhost_user_blk_server blockdev_ss.add(files('vhost-user-blk-server.c')) endif + +blockdev_ss.add(when: fuse, if_true: files('fuse.c')) diff --git a/block/file-posix.c b/block/file-posix.c index d5fd1dbcd2..83e2cc5530 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -2926,7 +2926,6 @@ raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes, #ifdef CONFIG_FALLOCATE if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) { BdrvTrackedRequest *req; - uint64_t end; /* * This is a workaround for a bug in the Linux XFS driver, @@ -2950,9 +2949,9 @@ raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes, assert(req->offset <= offset); assert(req->offset + req->bytes >= offset + bytes); - end = INT64_MAX & -(uint64_t)bs->bl.request_alignment; - req->bytes = end - req->offset; - req->overlap_bytes = req->bytes; + req->bytes = BDRV_MAX_LENGTH - req->offset; + + assert(bdrv_check_request(req->offset, req->bytes) == 0); bdrv_mark_request_serialising(req, bs->bl.request_alignment); } @@ -3104,7 +3103,7 @@ static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared, } /* Copy locks to the new fd */ - if (s->perm_change_fd) { + if (s->perm_change_fd && s->use_lock) { ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared, false, errp); if (ret < 0) { diff --git a/block/io.c b/block/io.c index ec5e152bb7..24205f5168 100644 --- a/block/io.c +++ b/block/io.c @@ -135,10 +135,10 @@ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src) void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) { + ERRP_GUARD(); BlockDriver *drv = bs->drv; BdrvChild *c; bool have_limits; - Error *local_err = NULL; memset(&bs->bl, 0, sizeof(bs->bl)); @@ -156,9 +156,8 @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) QLIST_FOREACH(c, &bs->children, next) { if (c->role & (BDRV_CHILD_DATA | BDRV_CHILD_FILTERED | BDRV_CHILD_COW)) { - bdrv_refresh_limits(c->bs, &local_err); - if (local_err) { - error_propagate(errp, local_err); + bdrv_refresh_limits(c->bs, errp); + if (*errp) { return; } bdrv_merge_limits(&bs->bl, &c->bs->bl); @@ -177,6 +176,13 @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) /* Then let the driver override it */ if (drv->bdrv_refresh_limits) { drv->bdrv_refresh_limits(bs, errp); + if (*errp) { + return; + } + } + + if (bs->bl.request_alignment > BDRV_MAX_ALIGNMENT) { + error_setg(errp, "Driver requires too large request alignment"); } } @@ -306,17 +312,7 @@ static void bdrv_co_drain_bh_cb(void *opaque) if (bs) { AioContext *ctx = bdrv_get_aio_context(bs); - AioContext *co_ctx = qemu_coroutine_get_aio_context(co); - - /* - * When the coroutine yielded, the lock for its home context was - * released, so we need to re-acquire it here. If it explicitly - * acquired a different context, the lock is still held and we don't - * want to lock it a second time (or AIO_WAIT_WHILE() would hang). - */ - if (ctx == co_ctx) { - aio_context_acquire(ctx); - } + aio_context_acquire(ctx); bdrv_dec_in_flight(bs); if (data->begin) { assert(!data->drained_end_counter); @@ -328,9 +324,7 @@ static void bdrv_co_drain_bh_cb(void *opaque) data->ignore_bds_parents, data->drained_end_counter); } - if (ctx == co_ctx) { - aio_context_release(ctx); - } + aio_context_release(ctx); } else { assert(data->begin); bdrv_drain_all_begin(); @@ -348,13 +342,16 @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs, int *drained_end_counter) { BdrvCoDrainData data; + Coroutine *self = qemu_coroutine_self(); + AioContext *ctx = bdrv_get_aio_context(bs); + AioContext *co_ctx = qemu_coroutine_get_aio_context(self); /* Calling bdrv_drain() from a BH ensures the current coroutine yields and * other coroutines run if they were queued by aio_co_enter(). */ assert(qemu_in_coroutine()); data = (BdrvCoDrainData) { - .co = qemu_coroutine_self(), + .co = self, .bs = bs, .done = false, .begin = begin, @@ -368,13 +365,29 @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs, if (bs) { bdrv_inc_in_flight(bs); } - replay_bh_schedule_oneshot_event(bdrv_get_aio_context(bs), - bdrv_co_drain_bh_cb, &data); + + /* + * Temporarily drop the lock across yield or we would get deadlocks. + * bdrv_co_drain_bh_cb() reaquires the lock as needed. + * + * When we yield below, the lock for the current context will be + * released, so if this is actually the lock that protects bs, don't drop + * it a second time. + */ + if (ctx != co_ctx) { + aio_context_release(ctx); + } + replay_bh_schedule_oneshot_event(ctx, bdrv_co_drain_bh_cb, &data); qemu_coroutine_yield(); /* If we are resumed from some other event (such as an aio completion or a * timer callback), it is a bug in the caller that should be fixed. */ assert(data.done); + + /* Reaquire the AioContext of bs if we dropped it */ + if (ctx != co_ctx) { + aio_context_acquire(ctx); + } } void bdrv_do_drained_begin_quiesce(BlockDriverState *bs, @@ -885,18 +898,31 @@ static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self return waited; } -static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, - size_t size) +int bdrv_check_request(int64_t offset, int64_t bytes) { - if (size > BDRV_REQUEST_MAX_BYTES) { + if (offset < 0 || bytes < 0) { return -EIO; } - if (!bdrv_is_inserted(bs)) { - return -ENOMEDIUM; + if (bytes > BDRV_MAX_LENGTH) { + return -EIO; } - if (offset < 0) { + if (offset > BDRV_MAX_LENGTH - bytes) { + return -EIO; + } + + return 0; +} + +static int bdrv_check_request32(int64_t offset, int64_t bytes) +{ + int ret = bdrv_check_request(offset, bytes); + if (ret < 0) { + return ret; + } + + if (bytes > BDRV_REQUEST_MAX_BYTES) { return -EIO; } @@ -1643,7 +1669,11 @@ int coroutine_fn bdrv_co_preadv_part(BdrvChild *child, trace_bdrv_co_preadv(bs, offset, bytes, flags); - ret = bdrv_check_byte_request(bs, offset, bytes); + if (!bdrv_is_inserted(bs)) { + return -ENOMEDIUM; + } + + ret = bdrv_check_request32(offset, bytes); if (ret < 0) { return ret; } @@ -2055,11 +2085,11 @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child, trace_bdrv_co_pwritev(child->bs, offset, bytes, flags); - if (!bs->drv) { + if (!bdrv_is_inserted(bs)) { return -ENOMEDIUM; } - ret = bdrv_check_byte_request(bs, offset, bytes); + ret = bdrv_check_request32(offset, bytes); if (ret < 0) { return ret; } @@ -2789,8 +2819,9 @@ int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset, return -EPERM; } - if (offset < 0 || bytes < 0 || bytes > INT64_MAX - offset) { - return -EIO; + ret = bdrv_check_request(offset, bytes); + if (ret < 0) { + return ret; } /* Do nothing if disabled. */ @@ -3046,10 +3077,10 @@ static int coroutine_fn bdrv_co_copy_range_internal( assert(!(read_flags & BDRV_REQ_NO_FALLBACK)); assert(!(write_flags & BDRV_REQ_NO_FALLBACK)); - if (!dst || !dst->bs) { + if (!dst || !dst->bs || !bdrv_is_inserted(dst->bs)) { return -ENOMEDIUM; } - ret = bdrv_check_byte_request(dst->bs, dst_offset, bytes); + ret = bdrv_check_request32(dst_offset, bytes); if (ret) { return ret; } @@ -3057,10 +3088,10 @@ static int coroutine_fn bdrv_co_copy_range_internal( return bdrv_co_pwrite_zeroes(dst, dst_offset, bytes, write_flags); } - if (!src || !src->bs) { + if (!src || !src->bs || !bdrv_is_inserted(src->bs)) { return -ENOMEDIUM; } - ret = bdrv_check_byte_request(src->bs, src_offset, bytes); + ret = bdrv_check_request32(src_offset, bytes); if (ret) { return ret; } @@ -3190,6 +3221,13 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, return -EINVAL; } + ret = bdrv_check_request(offset, 0); + if (ret < 0) { + error_setg(errp, "Required too big image size, it must be not greater " + "than %" PRId64, BDRV_MAX_LENGTH); + return ret; + } + old_size = bdrv_getlength(bs); if (old_size < 0) { error_setg_errno(errp, -old_size, "Failed to get old image size"); diff --git a/block/iscsi.c b/block/iscsi.c index e30a7e3606..7d4b3b56d5 100644 --- a/block/iscsi.c +++ b/block/iscsi.c @@ -322,25 +322,23 @@ iscsi_aio_cancel(BlockAIOCB *blockacb) IscsiAIOCB *acb = (IscsiAIOCB *)blockacb; IscsiLun *iscsilun = acb->iscsilun; - qemu_mutex_lock(&iscsilun->mutex); + WITH_QEMU_LOCK_GUARD(&iscsilun->mutex) { - /* If it was cancelled or completed already, our work is done here */ - if (acb->cancelled || acb->status != -EINPROGRESS) { - qemu_mutex_unlock(&iscsilun->mutex); - return; + /* If it was cancelled or completed already, our work is done here */ + if (acb->cancelled || acb->status != -EINPROGRESS) { + return; + } + + acb->cancelled = true; + + qemu_aio_ref(acb); /* released in iscsi_abort_task_cb() */ + + /* send a task mgmt call to the target to cancel the task on the target */ + if (iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task, + iscsi_abort_task_cb, acb) < 0) { + qemu_aio_unref(acb); /* since iscsi_abort_task_cb() won't be called */ + } } - - acb->cancelled = true; - - qemu_aio_ref(acb); /* released in iscsi_abort_task_cb() */ - - /* send a task mgmt call to the target to cancel the task on the target */ - if (iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task, - iscsi_abort_task_cb, acb) < 0) { - qemu_aio_unref(acb); /* since iscsi_abort_task_cb() won't be called */ - } - - qemu_mutex_unlock(&iscsilun->mutex); } static const AIOCBInfo iscsi_aiocb_info = { @@ -375,22 +373,22 @@ static void iscsi_timed_check_events(void *opaque) { IscsiLun *iscsilun = opaque; - qemu_mutex_lock(&iscsilun->mutex); + WITH_QEMU_LOCK_GUARD(&iscsilun->mutex) { + /* check for timed out requests */ + iscsi_service(iscsilun->iscsi, 0); - /* check for timed out requests */ - iscsi_service(iscsilun->iscsi, 0); + if (iscsilun->request_timed_out) { + iscsilun->request_timed_out = false; + iscsi_reconnect(iscsilun->iscsi); + } - if (iscsilun->request_timed_out) { - iscsilun->request_timed_out = false; - iscsi_reconnect(iscsilun->iscsi); + /* + * newer versions of libiscsi may return zero events. Ensure we are + * able to return to service once this situation changes. + */ + iscsi_set_events(iscsilun); } - /* newer versions of libiscsi may return zero events. Ensure we are able - * to return to service once this situation changes. */ - iscsi_set_events(iscsilun); - - qemu_mutex_unlock(&iscsilun->mutex); - timer_mod(iscsilun->event_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + EVENT_INTERVAL); } diff --git a/block/throttle-groups.c b/block/throttle-groups.c index e2f2813c0f..abd16ed9db 100644 --- a/block/throttle-groups.c +++ b/block/throttle-groups.c @@ -546,7 +546,7 @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm, tgm->aio_context = ctx; qatomic_set(&tgm->restart_pending, 0); - qemu_mutex_lock(&tg->lock); + QEMU_LOCK_GUARD(&tg->lock); /* If the ThrottleGroup is new set this ThrottleGroupMember as the token */ for (i = 0; i < 2; i++) { if (!tg->tokens[i]) { @@ -565,8 +565,6 @@ void throttle_group_register_tgm(ThrottleGroupMember *tgm, qemu_co_mutex_init(&tgm->throttled_reqs_lock); qemu_co_queue_init(&tgm->throttled_reqs[0]); qemu_co_queue_init(&tgm->throttled_reqs[1]); - - qemu_mutex_unlock(&tg->lock); } /* Unregister a ThrottleGroupMember from its group, removing it from the list, @@ -594,25 +592,25 @@ void throttle_group_unregister_tgm(ThrottleGroupMember *tgm) /* Wait for throttle_group_restart_queue_entry() coroutines to finish */ AIO_WAIT_WHILE(tgm->aio_context, qatomic_read(&tgm->restart_pending) > 0); - qemu_mutex_lock(&tg->lock); - for (i = 0; i < 2; i++) { - assert(tgm->pending_reqs[i] == 0); - assert(qemu_co_queue_empty(&tgm->throttled_reqs[i])); - assert(!timer_pending(tgm->throttle_timers.timers[i])); - if (tg->tokens[i] == tgm) { - token = throttle_group_next_tgm(tgm); - /* Take care of the case where this is the last tgm in the group */ - if (token == tgm) { - token = NULL; + WITH_QEMU_LOCK_GUARD(&tg->lock) { + for (i = 0; i < 2; i++) { + assert(tgm->pending_reqs[i] == 0); + assert(qemu_co_queue_empty(&tgm->throttled_reqs[i])); + assert(!timer_pending(tgm->throttle_timers.timers[i])); + if (tg->tokens[i] == tgm) { + token = throttle_group_next_tgm(tgm); + /* Take care of the case where this is the last tgm in the group */ + if (token == tgm) { + token = NULL; + } + tg->tokens[i] = token; } - tg->tokens[i] = token; } - } - /* remove the current tgm from the list */ - QLIST_REMOVE(tgm, round_robin); - throttle_timers_destroy(&tgm->throttle_timers); - qemu_mutex_unlock(&tg->lock); + /* remove the current tgm from the list */ + QLIST_REMOVE(tgm, round_robin); + throttle_timers_destroy(&tgm->throttle_timers); + } throttle_group_unref(&tg->ts); tgm->throttle_state = NULL; @@ -638,14 +636,14 @@ void throttle_group_detach_aio_context(ThrottleGroupMember *tgm) assert(qemu_co_queue_empty(&tgm->throttled_reqs[1])); /* Kick off next ThrottleGroupMember, if necessary */ - qemu_mutex_lock(&tg->lock); - for (i = 0; i < 2; i++) { - if (timer_pending(tt->timers[i])) { - tg->any_timer_armed[i] = false; - schedule_next_request(tgm, i); + WITH_QEMU_LOCK_GUARD(&tg->lock) { + for (i = 0; i < 2; i++) { + if (timer_pending(tt->timers[i])) { + tg->any_timer_armed[i] = false; + schedule_next_request(tgm, i); + } } } - qemu_mutex_unlock(&tg->lock); throttle_timers_detach_aio_context(tt); tgm->aio_context = NULL; diff --git a/blockdev.c b/blockdev.c index 6c7be7c522..412354b4b6 100644 --- a/blockdev.c +++ b/blockdev.c @@ -2454,7 +2454,7 @@ void coroutine_fn qmp_block_resize(bool has_device, const char *device, int64_t size, Error **errp) { Error *local_err = NULL; - BlockBackend *blk = NULL; + BlockBackend *blk; BlockDriverState *bs; AioContext *old_ctx; @@ -2468,27 +2468,29 @@ void coroutine_fn qmp_block_resize(bool has_device, const char *device, if (size < 0) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size"); - goto out; + return; } if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) { error_setg(errp, QERR_DEVICE_IN_USE, device); - goto out; + return; } blk = blk_new_with_bs(bs, BLK_PERM_RESIZE, BLK_PERM_ALL, errp); if (!blk) { - goto out; + return; } + bdrv_co_lock(bs); bdrv_drained_begin(bs); + bdrv_co_unlock(bs); + old_ctx = bdrv_co_enter(bs); blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp); bdrv_co_leave(bs, old_ctx); - bdrv_drained_end(bs); -out: bdrv_co_lock(bs); + bdrv_drained_end(bs); blk_unref(blk); bdrv_co_unlock(bs); } diff --git a/configure b/configure index 18c26e0389..3f823ed163 100755 --- a/configure +++ b/configure @@ -449,6 +449,8 @@ meson="" ninja="" skip_meson=no gettext="" +fuse="auto" +fuse_lseek="auto" bogus_os="no" malloc_trim="auto" @@ -1525,6 +1527,14 @@ for opt do ;; --disable-libdaxctl) libdaxctl=no ;; + --enable-fuse) fuse="enabled" + ;; + --disable-fuse) fuse="disabled" + ;; + --enable-fuse-lseek) fuse_lseek="enabled" + ;; + --disable-fuse-lseek) fuse_lseek="disabled" + ;; *) echo "ERROR: unknown option $opt" echo "Try '$0 --help' for more information" @@ -1850,6 +1860,8 @@ disabled with --disable-FEATURE, default is enabled if available: xkbcommon xkbcommon support rng-none dummy RNG, avoid using /dev/(u)random and getrandom() libdaxctl libdaxctl support + fuse FUSE block device export + fuse-lseek SEEK_HOLE/SEEK_DATA support for FUSE exports NOTE: The object files are built at the place where configure is launched EOF @@ -7014,6 +7026,7 @@ NINJA=$ninja $meson setup \ -Diconv=$iconv -Dcurses=$curses -Dlibudev=$libudev\ -Ddocs=$docs -Dsphinx_build=$sphinx_build -Dinstall_blobs=$blobs \ -Dvhost_user_blk_server=$vhost_user_blk_server \ + -Dfuse=$fuse -Dfuse_lseek=$fuse_lseek \ $cross_arg \ "$PWD" "$source_path" diff --git a/include/block/block.h b/include/block/block.h index c9d7c58765..5b81e33e94 100644 --- a/include/block/block.h +++ b/include/block/block.h @@ -142,6 +142,16 @@ typedef struct HDGeometry { INT_MAX >> BDRV_SECTOR_BITS) #define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS) +/* + * We want allow aligning requests and disk length up to any 32bit alignment + * and don't afraid of overflow. + * To achieve it, and in the same time use some pretty number as maximum disk + * size, let's define maximum "length" (a limit for any offset/bytes request and + * for disk size) to be the greatest power of 2 less than INT64_MAX. + */ +#define BDRV_MAX_ALIGNMENT (1L << 30) +#define BDRV_MAX_LENGTH (QEMU_ALIGN_DOWN(INT64_MAX, BDRV_MAX_ALIGNMENT)) + /* * Allocation status flags for bdrv_block_status() and friends. * diff --git a/include/block/block_int.h b/include/block/block_int.h index 95d9333be1..1eeafc118c 100644 --- a/include/block/block_int.h +++ b/include/block/block_int.h @@ -70,6 +70,12 @@ enum BdrvTrackedRequestType { BDRV_TRACKED_TRUNCATE, }; +/* + * That is not quite good that BdrvTrackedRequest structure is public, + * as block/io.c is very careful about incoming offset/bytes being + * correct. Be sure to assert bdrv_check_request() succeeded after any + * modification of BdrvTrackedRequest object out of block/io.c + */ typedef struct BdrvTrackedRequest { BlockDriverState *bs; int64_t offset; @@ -87,6 +93,8 @@ typedef struct BdrvTrackedRequest { struct BdrvTrackedRequest *waiting_for; } BdrvTrackedRequest; +int bdrv_check_request(int64_t offset, int64_t bytes); + struct BlockDriver { const char *format_name; int instance_size; diff --git a/include/block/fuse.h b/include/block/fuse.h new file mode 100644 index 0000000000..ffa91fe364 --- /dev/null +++ b/include/block/fuse.h @@ -0,0 +1,30 @@ +/* + * Present a block device as a raw image through FUSE + * + * Copyright (c) 2020 Max Reitz + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; under version 2 or later of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#ifndef BLOCK_FUSE_H +#define BLOCK_FUSE_H + +#ifdef CONFIG_FUSE + +#include "block/export.h" + +extern const BlockExportDriver blk_exp_fuse; + +#endif /* CONFIG_FUSE */ + +#endif diff --git a/meson.build b/meson.build index 9ea05ab49f..f344b25955 100644 --- a/meson.build +++ b/meson.build @@ -773,6 +773,28 @@ elif get_option('vhost_user_blk_server').disabled() or not have_system have_vhost_user_blk_server = false endif +if get_option('fuse').disabled() and get_option('fuse_lseek').enabled() + error('Cannot enable fuse-lseek while fuse is disabled') +endif + +fuse = dependency('fuse3', required: get_option('fuse'), + version: '>=3.1', method: 'pkg-config', + static: enable_static) + +fuse_lseek = not_found +if not get_option('fuse_lseek').disabled() + if fuse.version().version_compare('>=3.8') + # Dummy dependency + fuse_lseek = declare_dependency() + elif get_option('fuse_lseek').enabled() + if fuse.found() + error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version()) + else + error('fuse-lseek requires libfuse, which was not found') + endif + endif +endif + ################# # config-host.h # ################# @@ -807,6 +829,8 @@ config_host_data.set('CONFIG_KEYUTILS', keyutils.found()) config_host_data.set('CONFIG_GETTID', has_gettid) config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim) config_host_data.set('CONFIG_STATX', has_statx) +config_host_data.set('CONFIG_FUSE', fuse.found()) +config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found()) config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version())) config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0]) config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1]) @@ -2208,6 +2232,8 @@ endif summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')} summary_info += {'rng-none': config_host.has_key('CONFIG_RNG_NONE')} summary_info += {'Linux keyring': config_host.has_key('CONFIG_SECRET_KEYRING')} +summary_info += {'FUSE exports': fuse.found()} +summary_info += {'FUSE lseek': fuse_lseek.found()} summary(summary_info, bool_yn: true) if not supported_cpus.contains(cpu) diff --git a/meson_options.txt b/meson_options.txt index f6f64785fe..74ac853548 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -66,6 +66,10 @@ option('virtiofsd', type: 'feature', value: 'auto', description: 'build virtiofs daemon (virtiofsd)') option('vhost_user_blk_server', type: 'feature', value: 'auto', description: 'build vhost-user-blk server') +option('fuse', type: 'feature', value: 'auto', + description: 'FUSE block device export') +option('fuse_lseek', type : 'feature', value : 'auto', + description: 'SEEK_HOLE/SEEK_DATA support for FUSE exports') option('capstone', type: 'combo', value: 'auto', choices: ['disabled', 'enabled', 'auto', 'system', 'internal'], diff --git a/net/can/can_host.c b/net/can/can_host.c index be4547d913..ba7f163d0a 100644 --- a/net/can/can_host.c +++ b/net/can/can_host.c @@ -53,6 +53,11 @@ static void can_host_connect(CanHostState *ch, Error **errp) CanHostClass *chc = CAN_HOST_GET_CLASS(ch); Error *local_err = NULL; + if (ch->bus == NULL) { + error_setg(errp, "'canbus' property not set"); + return; + } + chc->connect(ch, &local_err); if (local_err) { error_propagate(errp, local_err); diff --git a/qapi/block-export.json b/qapi/block-export.json index 4eeac7842d..e819e70cac 100644 --- a/qapi/block-export.json +++ b/qapi/block-export.json @@ -120,6 +120,25 @@ '*logical-block-size': 'size', '*num-queues': 'uint16'} } +## +# @BlockExportOptionsFuse: +# +# Options for exporting a block graph node on some (file) mountpoint +# as a raw image. +# +# @mountpoint: Path on which to export the block device via FUSE. +# This must point to an existing regular file. +# +# @growable: Whether writes beyond the EOF should grow the block node +# accordingly. (default: false) +# +# Since: 6.0 +## +{ 'struct': 'BlockExportOptionsFuse', + 'data': { 'mountpoint': 'str', + '*growable': 'bool' }, + 'if': 'defined(CONFIG_FUSE)' } + ## # @NbdServerAddOptions: # @@ -222,11 +241,13 @@ # # @nbd: NBD export # @vhost-user-blk: vhost-user-blk export (since 5.2) +# @fuse: FUSE export (since: 6.0) # # Since: 4.2 ## { 'enum': 'BlockExportType', - 'data': [ 'nbd', 'vhost-user-blk' ] } + 'data': [ 'nbd', 'vhost-user-blk', + { 'name': 'fuse', 'if': 'defined(CONFIG_FUSE)' } ] } ## # @BlockExportOptions: @@ -267,7 +288,9 @@ 'discriminator': 'type', 'data': { 'nbd': 'BlockExportOptionsNbd', - 'vhost-user-blk': 'BlockExportOptionsVhostUserBlk' + 'vhost-user-blk': 'BlockExportOptionsVhostUserBlk', + 'fuse': { 'type': 'BlockExportOptionsFuse', + 'if': 'defined(CONFIG_FUSE)' } } } ## diff --git a/storage-daemon/qemu-storage-daemon.c b/storage-daemon/qemu-storage-daemon.c index 7c914b0dc1..e0c87edbdd 100644 --- a/storage-daemon/qemu-storage-daemon.c +++ b/storage-daemon/qemu-storage-daemon.c @@ -314,6 +314,9 @@ int main(int argc, char *argv[]) main_loop_wait(false); } + bdrv_drain_all_begin(); + bdrv_close_all(); + monitor_cleanup(); qemu_chr_cleanup(); user_creatable_cleanup(); diff --git a/tests/qemu-iotests/025 b/tests/qemu-iotests/025 index e05d833452..1569d912f4 100755 --- a/tests/qemu-iotests/025 +++ b/tests/qemu-iotests/025 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.pattern _supported_fmt raw qcow2 qed luks -_supported_proto file sheepdog rbd nfs +_supported_proto file sheepdog rbd nfs fuse echo "=== Creating image" echo diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026 index b9713eb591..9ecc5880b1 100755 --- a/tests/qemu-iotests/026 +++ b/tests/qemu-iotests/026 @@ -41,7 +41,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Currently only qcow2 supports rebasing _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _default_cache_mode writethrough _supported_cache_modes writethrough none # The refcount table tests expect a certain minimum width for refcount entries diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028 index 6dd3ae09a3..57d34aae99 100755 --- a/tests/qemu-iotests/028 +++ b/tests/qemu-iotests/028 @@ -46,7 +46,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Any format supporting backing files except vmdk and qcow which do not support # smaller backing files. _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse _supported_os Linux # Choose a size that is not necessarily a cluster size multiple for image @@ -116,16 +116,10 @@ else QEMU_COMM_TIMEOUT=1 fi -# Silence output since it contains the disk image path and QEMU's readline -# character echoing makes it very hard to filter the output. Plus, there -# is no telling how many times the command will repeat before succeeding. -# (Note that creating the image results in a "Formatting..." message over -# stdout, which is the same channel the monitor uses. We cannot reliably -# wait for it because the monitor output may interact with it in such a -# way that _timed_wait_for cannot read it. However, once the block job is -# done, we know that the "Formatting..." message must have appeared -# already, so the output is still deterministic.) -silent=y _send_qemu_cmd $h "drive_backup disk ${TEST_IMG}.copy" "(qemu)" +TEST_IMG="$TEST_IMG.copy" _make_test_img $image_size +_send_qemu_cmd $h "drive_backup -n disk ${TEST_IMG}.copy" "(qemu)" \ + | _filter_imgfmt + silent=y qemu_cmd_repeat=20 _send_qemu_cmd $h "info block-jobs" "No active jobs" _send_qemu_cmd $h "info block-jobs" "No active jobs" _send_qemu_cmd $h 'quit' "" diff --git a/tests/qemu-iotests/028.out b/tests/qemu-iotests/028.out index 5a68de5c46..e580488216 100644 --- a/tests/qemu-iotests/028.out +++ b/tests/qemu-iotests/028.out @@ -468,6 +468,9 @@ No errors were found on the image. block-backup +Formatting 'TEST_DIR/t.IMGFMT.copy', fmt=IMGFMT size=4294968832 +QEMU X.Y.Z monitor - type 'help' for more information +(qemu) drive_backup -n disk TEST_DIR/t.IMGFMT.copy (qemu) info block-jobs No active jobs === IO: pattern 195 diff --git a/tests/qemu-iotests/031 b/tests/qemu-iotests/031 index 646ecd593f..2bcbc5886e 100755 --- a/tests/qemu-iotests/031 +++ b/tests/qemu-iotests/031 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This tests qcow2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # We want to test compat=0.10, which does not support external data # files or refcount widths other than 16 _unsupported_imgopts data_file 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' diff --git a/tests/qemu-iotests/034 b/tests/qemu-iotests/034 index ac2d687c71..08f7aea6d5 100755 --- a/tests/qemu-iotests/034 +++ b/tests/qemu-iotests/034 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow qcow2 vmdk qed -_supported_proto file +_supported_proto file fuse _supported_os Linux _unsupported_imgopts "subformat=monolithicFlat" \ "subformat=twoGbMaxExtentFlat" \ diff --git a/tests/qemu-iotests/036 b/tests/qemu-iotests/036 index cf522de7a1..6b82638080 100755 --- a/tests/qemu-iotests/036 +++ b/tests/qemu-iotests/036 @@ -42,7 +42,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This tests qcow2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # Only qcow2v3 and later supports feature bits; # qcow2.py does not support external data files; # this test requires a cluster size large enough for the feature table diff --git a/tests/qemu-iotests/037 b/tests/qemu-iotests/037 index e1187ac24a..bb893c43dc 100755 --- a/tests/qemu-iotests/037 +++ b/tests/qemu-iotests/037 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow qcow2 vmdk qed -_supported_proto file +_supported_proto file fuse _unsupported_imgopts "subformat=monolithicFlat" \ "subformat=twoGbMaxExtentFlat" \ "subformat=twoGbMaxExtentSparse" \ diff --git a/tests/qemu-iotests/038 b/tests/qemu-iotests/038 index a253231f5b..30f1f73c25 100755 --- a/tests/qemu-iotests/038 +++ b/tests/qemu-iotests/038 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse _supported_os Linux CLUSTER_SIZE=2M diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 index 42f6503138..ad3867c3fc 100755 --- a/tests/qemu-iotests/039 +++ b/tests/qemu-iotests/039 @@ -40,7 +40,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux _default_cache_mode writethrough _supported_cache_modes writethrough diff --git a/tests/qemu-iotests/046 b/tests/qemu-iotests/046 index 88b3363c19..ed6fae3529 100755 --- a/tests/qemu-iotests/046 +++ b/tests/qemu-iotests/046 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # data_file does not support compressed clusters _unsupported_imgopts data_file @@ -47,6 +47,8 @@ size=128M echo echo "== creating backing file for COW tests ==" +TEST_IMG_SAVE=$TEST_IMG +TEST_IMG="$TEST_IMG.base" _make_test_img $size backing_io() @@ -67,8 +69,7 @@ backing_io() backing_io 0 32 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io -mv "$TEST_IMG" "$TEST_IMG.base" - +TEST_IMG=$TEST_IMG_SAVE _make_test_img -b "$TEST_IMG.base" -F $IMGFMT 6G echo diff --git a/tests/qemu-iotests/046.out b/tests/qemu-iotests/046.out index b022bcddd5..66ad987ab3 100644 --- a/tests/qemu-iotests/046.out +++ b/tests/qemu-iotests/046.out @@ -1,7 +1,7 @@ QA output created by 046 == creating backing file for COW tests == -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728 wrote 65536/65536 bytes at offset 0 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 65536/65536 bytes at offset 65536 diff --git a/tests/qemu-iotests/050 b/tests/qemu-iotests/050 index 4b0a390c43..741bdb610e 100755 --- a/tests/qemu-iotests/050 +++ b/tests/qemu-iotests/050 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse echo echo "== Creating images ==" diff --git a/tests/qemu-iotests/054 b/tests/qemu-iotests/054 index a8905b60d0..40922db2b1 100755 --- a/tests/qemu-iotests/054 +++ b/tests/qemu-iotests/054 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse echo echo "creating too large image (1 EB)" diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 index 94c0d5accc..4b81d1aa51 100755 --- a/tests/qemu-iotests/060 +++ b/tests/qemu-iotests/060 @@ -46,7 +46,7 @@ _filter_io_error() # This tests qcow2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # These tests only work for compat=1.1 images without an external # data file with refcount_bits=16 diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071 index 88faebcc1d..49faae6684 100755 --- a/tests/qemu-iotests/071 +++ b/tests/qemu-iotests/071 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _require_drivers blkdebug blkverify # blkdebug can only inject errors on bs->file, not on the data_file, # so thie test does not work with external data files @@ -61,8 +61,17 @@ echo echo "=== Testing blkverify through filename ===" echo -TEST_IMG="$TEST_IMG.base" IMGFMT="raw" _make_test_img --no-opts $IMG_SIZE |\ - _filter_imgfmt +# _make_test_img may set variables that we need to retain. Everything +# in a pipe is executed in a subshell, so doing so would throw away +# all changes. Therefore, we have to store the output in some temp +# file and filter that. +scratch_out="$TEST_DIR/img-create.out" + +TEST_IMG="$TEST_IMG.base" IMGFMT="raw" _make_test_img --no-opts $IMG_SIZE \ + >"$scratch_out" +_filter_imgfmt <"$scratch_out" +rm -f "$scratch_out" + _make_test_img $IMG_SIZE $QEMU_IO -c "open -o driver=raw,file.driver=blkverify,file.raw.filename=$TEST_IMG.base $TEST_IMG" \ -c 'read 0 512' -c 'write -P 42 0x38000 512' -c 'read -P 42 0x38000 512' | _filter_qemu_io @@ -76,8 +85,10 @@ echo echo "=== Testing blkverify through file blockref ===" echo -TEST_IMG="$TEST_IMG.base" IMGFMT="raw" _make_test_img --no-opts $IMG_SIZE |\ - _filter_imgfmt +TEST_IMG="$TEST_IMG.base" IMGFMT="raw" _make_test_img --no-opts $IMG_SIZE \ + >"$scratch_out" +_filter_imgfmt <"$scratch_out" + _make_test_img $IMG_SIZE $QEMU_IO -c "open -o driver=raw,file.driver=blkverify,file.raw.filename=$TEST_IMG.base,file.test.driver=$IMGFMT,file.test.file.filename=$TEST_IMG" \ -c 'read 0 512' -c 'write -P 42 0x38000 512' -c 'read -P 42 0x38000 512' | _filter_qemu_io diff --git a/tests/qemu-iotests/079 b/tests/qemu-iotests/079 index 3642b51feb..0f0d94a2ac 100755 --- a/tests/qemu-iotests/079 +++ b/tests/qemu-iotests/079 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file nfs +_supported_proto file nfs fuse # Some containers (e.g. non-x86 on Travis) do not allow large files _require_large_file 4G diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 index 7588c63b6c..bda8617c38 100755 --- a/tests/qemu-iotests/080 +++ b/tests/qemu-iotests/080 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # - Internal snapshots are (currently) impossible with refcount_bits=1, # and generally impossible with external data files diff --git a/tests/qemu-iotests/089 b/tests/qemu-iotests/089 index 66c5415abe..f0929b64c0 100755 --- a/tests/qemu-iotests/089 +++ b/tests/qemu-iotests/089 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # Because anything other than 16 would change the output of qemu_io -c info _unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' @@ -62,7 +62,8 @@ TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE $QEMU_IO -c 'write -P 42 0 512' -c 'write -P 23 512 512' \ -c 'write -P 66 1024 512' "$TEST_IMG.base" | _filter_qemu_io -$QEMU_IMG convert -f raw -O $IMGFMT "$TEST_IMG.base" "$TEST_IMG" +_make_test_img $IMG_SIZE +$QEMU_IMG convert -f raw -O $IMGFMT -n "$TEST_IMG.base" "$TEST_IMG" $QEMU_IO_PROG --cache $CACHEMODE --aio $AIOMODE \ -c 'read -P 42 0 512' -c 'read -P 23 512 512' \ diff --git a/tests/qemu-iotests/089.out b/tests/qemu-iotests/089.out index 15682c2886..c53fc4823a 100644 --- a/tests/qemu-iotests/089.out +++ b/tests/qemu-iotests/089.out @@ -9,6 +9,7 @@ wrote 512/512 bytes at offset 512 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset 1024 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 read 512/512 bytes at offset 0 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) read 512/512 bytes at offset 512 diff --git a/tests/qemu-iotests/090 b/tests/qemu-iotests/090 index 1246e4f910..87e872ebf4 100755 --- a/tests/qemu-iotests/090 +++ b/tests/qemu-iotests/090 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file nfs +_supported_proto file nfs fuse # External data files do not support compressed clusters _unsupported_imgopts data_file diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091 index 68fbfd777b..8dee168bf6 100755 --- a/tests/qemu-iotests/091 +++ b/tests/qemu-iotests/091 @@ -44,7 +44,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux _supported_cache_modes writethrough none writeback _default_cache_mode none writeback @@ -96,7 +96,8 @@ _send_qemu_cmd $h2 'qemu-io disk flush' "(qemu)" _send_qemu_cmd $h2 'quit' "" _send_qemu_cmd $h1 'quit' "" -wait +wait=yes _cleanup_qemu >/dev/null + echo "Check image pattern" ${QEMU_IO} -c "read -P 0x22 0 4M" "${TEST_IMG}" | _filter_testdir | _filter_qemu_io diff --git a/tests/qemu-iotests/095 b/tests/qemu-iotests/095 index 77a5f0f3f5..7604ae6966 100755 --- a/tests/qemu-iotests/095 +++ b/tests/qemu-iotests/095 @@ -44,7 +44,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse size_smaller=5M size_larger=100M diff --git a/tests/qemu-iotests/097 b/tests/qemu-iotests/097 index d910a8b107..1837d4e8e0 100755 --- a/tests/qemu-iotests/097 +++ b/tests/qemu-iotests/097 @@ -41,7 +41,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Any format supporting backing files and bdrv_make_empty _supported_fmt qcow qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux diff --git a/tests/qemu-iotests/098 b/tests/qemu-iotests/098 index f2ccdd7909..a35ce7205e 100755 --- a/tests/qemu-iotests/098 +++ b/tests/qemu-iotests/098 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.pattern _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # The code path we want to test here only works for compat=1.1 images; # blkdebug can only inject errors on bs->file, so external data files # do not work with this test diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102 index b898df436f..2cc3efd1ed 100755 --- a/tests/qemu-iotests/102 +++ b/tests/qemu-iotests/102 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse IMG_SIZE=64K diff --git a/tests/qemu-iotests/103 b/tests/qemu-iotests/103 index 8c1ebe0443..220481db4c 100755 --- a/tests/qemu-iotests/103 +++ b/tests/qemu-iotests/103 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file nfs +_supported_proto file nfs fuse # Internal snapshots are (currently) impossible with refcount_bits=1, # and generally impossible with external data files _unsupported_imgopts 'refcount_bits=1[^0-9]' data_file diff --git a/tests/qemu-iotests/106 b/tests/qemu-iotests/106 index a20659d443..20ad7bd5a2 100755 --- a/tests/qemu-iotests/106 +++ b/tests/qemu-iotests/106 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt raw -_supported_proto file +_supported_proto file fuse _supported_os Linux # in kB diff --git a/tests/qemu-iotests/107 b/tests/qemu-iotests/107 index 268ba27688..d24829ccf9 100755 --- a/tests/qemu-iotests/107 +++ b/tests/qemu-iotests/107 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file nfs +_supported_proto file nfs fuse IMG_SIZE=64K diff --git a/tests/qemu-iotests/108 b/tests/qemu-iotests/108 index 5f7076fba4..ba67748bdf 100755 --- a/tests/qemu-iotests/108 +++ b/tests/qemu-iotests/108 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This tests qcow2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # This test directly modifies a refblock so it relies on refcount_bits being 16; # and the low-level modification it performs are not tuned for external data diff --git a/tests/qemu-iotests/111 b/tests/qemu-iotests/111 index 3b43d1bd83..bd839a39f4 100755 --- a/tests/qemu-iotests/111 +++ b/tests/qemu-iotests/111 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qed qcow qcow2 vmdk -_supported_proto file +_supported_proto file fuse _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" _make_test_img -b "$TEST_IMG.inexistent" diff --git a/tests/qemu-iotests/112 b/tests/qemu-iotests/112 index 20ff5c224a..6e413f5651 100755 --- a/tests/qemu-iotests/112 +++ b/tests/qemu-iotests/112 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This tests qcow2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # This test will set refcount_bits on its own which would conflict with the # manual setting; compat will be overridden as well; # and external data files do not work well with our refcount testing diff --git a/tests/qemu-iotests/115 b/tests/qemu-iotests/115 index d254b18342..7f53987d1b 100755 --- a/tests/qemu-iotests/115 +++ b/tests/qemu-iotests/115 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # This test relies on refcounts being 64 bits wide (which does not work with # compat=0.10) _unsupported_imgopts 'refcount_bits=\([^6]\|.\([^4]\|$\)\)' 'compat=0.10' diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117 index f37b34f8b1..9039555ac4 100755 --- a/tests/qemu-iotests/117 +++ b/tests/qemu-iotests/117 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _make_test_img 64k diff --git a/tests/qemu-iotests/120 b/tests/qemu-iotests/120 index 2931a7550f..45c55c1c01 100755 --- a/tests/qemu-iotests/120 +++ b/tests/qemu-iotests/120 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt generic -_supported_proto file +_supported_proto file fuse _unsupported_fmt luks _require_drivers raw diff --git a/tests/qemu-iotests/121 b/tests/qemu-iotests/121 index 90ea0db737..8357ce089a 100755 --- a/tests/qemu-iotests/121 +++ b/tests/qemu-iotests/121 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # Refcount structures are used much differently with external data # files diff --git a/tests/qemu-iotests/127 b/tests/qemu-iotests/127 index e2ac2f5536..77fdfd0205 100755 --- a/tests/qemu-iotests/127 +++ b/tests/qemu-iotests/127 @@ -41,7 +41,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _require_devices virtio-scsi scsi-hd diff --git a/tests/qemu-iotests/133 b/tests/qemu-iotests/133 index 4070fd9457..bc82d8ebd7 100755 --- a/tests/qemu-iotests/133 +++ b/tests/qemu-iotests/133 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse TEST_IMG="$TEST_IMG.base" _make_test_img 64M _make_test_img -b "$TEST_IMG.base" -F $IMGFMT diff --git a/tests/qemu-iotests/137 b/tests/qemu-iotests/137 index 7ae86892f7..de555a91c9 100755 --- a/tests/qemu-iotests/137 +++ b/tests/qemu-iotests/137 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # We are going to use lazy-refcounts _unsupported_imgopts 'compat=0.10' diff --git a/tests/qemu-iotests/138 b/tests/qemu-iotests/138 index 1d5b0bed6d..e87a64eb89 100755 --- a/tests/qemu-iotests/138 +++ b/tests/qemu-iotests/138 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This tests qcow2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # With an external data file, data clusters are not refcounted # (so qemu-img check would not do much); diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140 index 309b177e77..ff6b904fa0 100755 --- a/tests/qemu-iotests/140 +++ b/tests/qemu-iotests/140 @@ -44,7 +44,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt generic -_supported_proto file +_supported_proto file fuse _supported_os Linux _make_test_img 64k diff --git a/tests/qemu-iotests/154 b/tests/qemu-iotests/154 index 7f1c0d9bd9..34a1c051b6 100755 --- a/tests/qemu-iotests/154 +++ b/tests/qemu-iotests/154 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux CLUSTER_SIZE=4k diff --git a/tests/qemu-iotests/161 b/tests/qemu-iotests/161 index e270976d87..4fb7d0cbf0 100755 --- a/tests/qemu-iotests/161 +++ b/tests/qemu-iotests/161 @@ -42,15 +42,15 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Any format implementing BlockDriver.bdrv_change_backing_file _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse _supported_os Linux IMG_SIZE=1M # Create the images -TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE | _filter_imgfmt -TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" -F $IMGFMT | _filter_imgfmt -_make_test_img -b "$TEST_IMG.int" -F $IMGFMT -F $IMGFMT | _filter_imgfmt +TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE +TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" -F $IMGFMT +_make_test_img -b "$TEST_IMG.int" -F $IMGFMT -F $IMGFMT # First test: reopen $TEST.IMG changing the detect-zeroes option on # its backing file ($TEST_IMG.int). @@ -105,9 +105,9 @@ echo echo "*** Commit and then change an option on the backing file" echo # Create the images again -TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE | _filter_imgfmt -TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" -F $IMGFMT| _filter_imgfmt -_make_test_img -b "$TEST_IMG.int" -F $IMGFMT | _filter_imgfmt +TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE +TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" -F $IMGFMT +_make_test_img -b "$TEST_IMG.int" -F $IMGFMT _launch_qemu -drive if=none,file="${TEST_IMG}" _send_qemu_cmd $QEMU_HANDLE \ diff --git a/tests/qemu-iotests/171 b/tests/qemu-iotests/171 index 341064a1c6..f3582edb10 100755 --- a/tests/qemu-iotests/171 +++ b/tests/qemu-iotests/171 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt raw -_supported_proto file +_supported_proto file fuse _supported_os Linux diff --git a/tests/qemu-iotests/174 b/tests/qemu-iotests/174 index e2f14a38c6..1b0dd2e8b7 100755 --- a/tests/qemu-iotests/174 +++ b/tests/qemu-iotests/174 @@ -40,7 +40,15 @@ _unsupported_fmt raw size=256K -IMGFMT=raw IMGKEYSECRET= _make_test_img --no-opts $size | _filter_imgfmt + +# _make_test_img may set variables that we need to retain. Everything +# in a pipe is executed in a subshell, so doing so would throw away +# all changes. Therefore, we have to store the output in some temp +# file and filter that. +scratch_out="$TEST_DIR/img-create.out" +IMGFMT=raw IMGKEYSECRET= _make_test_img --no-opts $size >"$scratch_out" +_filter_imgfmt <"$scratch_out" +rm -f "$scratch_out" echo echo "== reading wrong format should fail ==" diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175 index 00a626aa63..21a77a2bf5 100755 --- a/tests/qemu-iotests/175 +++ b/tests/qemu-iotests/175 @@ -71,7 +71,7 @@ EOF . ./common.filter _supported_fmt raw -_supported_proto file +_supported_proto file fuse _supported_os Linux _default_cache_mode none @@ -89,20 +89,20 @@ min_blocks=$(stat -c '%b' "$TEST_DIR/empty") echo echo "== creating image with default preallocation ==" -_make_test_img -o extent_size_hint=0 $size | _filter_imgfmt +_make_test_img -o extent_size_hint=0 $size stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size for mode in off full falloc; do echo echo "== creating image with preallocation $mode ==" - _make_test_img -o preallocation=$mode,extent_size_hint=0 $size | _filter_imgfmt + _make_test_img -o preallocation=$mode,extent_size_hint=0 $size stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size done for new_size in 4096 1048576; do echo echo "== resize empty image with block_resize ==" - _make_test_img -o extent_size_hint=0 0 | _filter_imgfmt + _make_test_img -o extent_size_hint=0 0 _block_resize $TEST_IMG $new_size >/dev/null stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $new_size done diff --git a/tests/qemu-iotests/176 b/tests/qemu-iotests/176 index 2565ff12ee..5ce3b27069 100755 --- a/tests/qemu-iotests/176 +++ b/tests/qemu-iotests/176 @@ -45,7 +45,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This test is specific to qcow2 _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # Persistent dirty bitmaps require compat=1.1; # Internal snapshots forbid using an external data file diff --git a/tests/qemu-iotests/177 b/tests/qemu-iotests/177 index 5d4a77a6ab..595bfd4236 100755 --- a/tests/qemu-iotests/177 +++ b/tests/qemu-iotests/177 @@ -40,7 +40,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # tests specific to compat=1.1. _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse CLUSTER_SIZE=1M size=128M diff --git a/tests/qemu-iotests/179 b/tests/qemu-iotests/179 index 11a20cb1bf..7ada04c641 100755 --- a/tests/qemu-iotests/179 +++ b/tests/qemu-iotests/179 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # v2 images can't mark clusters as zero diff --git a/tests/qemu-iotests/183 b/tests/qemu-iotests/183 index acdbefa310..d889a3b19c 100755 --- a/tests/qemu-iotests/183 +++ b/tests/qemu-iotests/183 @@ -44,7 +44,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_os Linux FreeBSD NetBSD _supported_fmt qcow2 raw qed quorum -_supported_proto file +_supported_proto file fuse size=64M _make_test_img $size diff --git a/tests/qemu-iotests/186 b/tests/qemu-iotests/186 index 3ea0442d44..0db25b0e68 100755 --- a/tests/qemu-iotests/186 +++ b/tests/qemu-iotests/186 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _require_drivers null-co if [ "$QEMU_DEFAULT_MACHINE" != "pc" ]; then diff --git a/tests/qemu-iotests/187 b/tests/qemu-iotests/187 index c6e1dc57a0..f262d83e3a 100755 --- a/tests/qemu-iotests/187 +++ b/tests/qemu-iotests/187 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse size=64M _make_test_img $size diff --git a/tests/qemu-iotests/191 b/tests/qemu-iotests/191 index d17462e1e4..95a891350d 100755 --- a/tests/qemu-iotests/191 +++ b/tests/qemu-iotests/191 @@ -42,7 +42,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # An external data file would change the query-named-block-nodes output _unsupported_imgopts data_file diff --git a/tests/qemu-iotests/195 b/tests/qemu-iotests/195 index 2351d55fe1..967af5b7b5 100755 --- a/tests/qemu-iotests/195 +++ b/tests/qemu-iotests/195 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse do_run_qemu() { diff --git a/tests/qemu-iotests/200 b/tests/qemu-iotests/200 index 59f7854b9f..046539154f 100755 --- a/tests/qemu-iotests/200 +++ b/tests/qemu-iotests/200 @@ -42,10 +42,9 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse -BACKING_IMG="${TEST_DIR}/backing.img" -TEST_IMG="${TEST_DIR}/test.img" +BACKING_IMG="$TEST_IMG.base" TEST_IMG="$BACKING_IMG" _make_test_img 512M _make_test_img -F $IMGFMT -b "$BACKING_IMG" 512M diff --git a/tests/qemu-iotests/200.out b/tests/qemu-iotests/200.out index a6776070e4..5883f16ac3 100644 --- a/tests/qemu-iotests/200.out +++ b/tests/qemu-iotests/200.out @@ -1,6 +1,6 @@ QA output created by 200 -Formatting 'TEST_DIR/backing.img', fmt=IMGFMT size=536870912 -Formatting 'TEST_DIR/test.img', fmt=IMGFMT size=536870912 backing_file=TEST_DIR/backing.img backing_fmt=IMGFMT +Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=536870912 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=536870912 backing_file=TEST_DIR/t.IMGFMT.base backing_fmt=IMGFMT wrote 314572800/314572800 bytes at offset 512 300 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) diff --git a/tests/qemu-iotests/204 b/tests/qemu-iotests/204 index 6770fa9b96..536bb8b534 100755 --- a/tests/qemu-iotests/204 +++ b/tests/qemu-iotests/204 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # This test assumes that discard leaves zero clusters; see test 177 for # other tests that also work in older images _unsupported_imgopts 'compat=0.10' diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206 index 11bc51f256..d12d7cb566 100755 --- a/tests/qemu-iotests/206 +++ b/tests/qemu-iotests/206 @@ -23,7 +23,8 @@ import iotests from iotests import imgfmt -iotests.script_initialize(supported_fmts=['qcow2']) +iotests.script_initialize(supported_fmts=['qcow2'], + supported_protocols=['file']) iotests.verify_working_luks() with iotests.FilePath('t.qcow2') as disk_path, \ @@ -201,7 +202,7 @@ with iotests.FilePath('t.qcow2') as disk_path, \ vm.launch() for size in [ 1234, 18446744073709551104, 9223372036854775808, - 9223372036854775296 ]: + 9223372036854775296, 9223372035781033984 ]: vm.blockdev_create({ 'driver': imgfmt, 'file': 'node0', 'size': size }) diff --git a/tests/qemu-iotests/206.out b/tests/qemu-iotests/206.out index a100849fcb..e8a36de00b 100644 --- a/tests/qemu-iotests/206.out +++ b/tests/qemu-iotests/206.out @@ -180,6 +180,12 @@ Job failed: Could not resize image: Image size cannot be negative {"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "qcow2", "file": "node0", "size": 9223372036854775296}}} {"return": {}} +Job failed: Could not resize image: Required too big image size, it must be not greater than 9223372035781033984 +{"execute": "job-dismiss", "arguments": {"id": "job0"}} +{"return": {}} + +{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "qcow2", "file": "node0", "size": 9223372035781033984}}} +{"return": {}} Job failed: Could not resize image: Failed to grow the L1 table: File too large {"execute": "job-dismiss", "arguments": {"id": "job0"}} {"return": {}} diff --git a/tests/qemu-iotests/214 b/tests/qemu-iotests/214 index af677d90b8..75ae7a14b5 100755 --- a/tests/qemu-iotests/214 +++ b/tests/qemu-iotests/214 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # Repairing the corrupted image requires qemu-img check to store a # refcount up to 3, which requires at least two refcount bits. diff --git a/tests/qemu-iotests/217 b/tests/qemu-iotests/217 index d89116ccad..7385342498 100755 --- a/tests/qemu-iotests/217 +++ b/tests/qemu-iotests/217 @@ -36,7 +36,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This test is specific to qcow2 _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # This test needs clusters with at least a refcount of 2 so that # OFLAG_COPIED is not set. refcount_bits=1 is therefore unsupported. diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220 index a9259b7127..9ba3b3fdcb 100755 --- a/tests/qemu-iotests/220 +++ b/tests/qemu-iotests/220 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.pattern _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # To use a different refcount width but 16 bits we need compat=1.1, # and external data files do not support compressed clusters. diff --git a/tests/qemu-iotests/221 b/tests/qemu-iotests/221 index 0e9096fec7..7e6086b205 100755 --- a/tests/qemu-iotests/221 +++ b/tests/qemu-iotests/221 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt raw -_supported_proto file +_supported_proto file fuse _supported_os Linux _default_cache_mode writeback @@ -46,6 +46,13 @@ echo "=== Check mapping of unaligned raw image ===" echo _make_test_img 65537 # qemu-img create rounds size up + +# file-posix allocates the first block of any images when it is created; +# the size of this block depends on the host page size and the file +# system block size, none of which are constant. Discard the whole +# image so we will not see this allocation in qemu-img map's output. +$QEMU_IO -c 'discard 0 65537' "$TEST_IMG" | _filter_qemu_io + $QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map truncate --size=65537 "$TEST_IMG" # so we resize it and check again diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out index dca024a0c3..93846c7dab 100644 --- a/tests/qemu-iotests/221.out +++ b/tests/qemu-iotests/221.out @@ -3,18 +3,16 @@ QA output created by 221 === Check mapping of unaligned raw image === Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65537 -[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, -{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] -[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, -{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] +discard 65537/65537 bytes at offset 0 +64.001 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] +[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] wrote 1/1 bytes at offset 65536 1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) -[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, -{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, +[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] -[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, -{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, +[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] *** done diff --git a/tests/qemu-iotests/229 b/tests/qemu-iotests/229 index 89a5359f32..273ac2472d 100755 --- a/tests/qemu-iotests/229 +++ b/tests/qemu-iotests/229 @@ -44,15 +44,14 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Needs backing file and backing format support _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse _supported_os Linux # blkdebug can only inject errors on bs->file, so external data files # do not work with this test _unsupported_imgopts data_file -DEST_IMG="$TEST_DIR/d.$IMGFMT" -TEST_IMG="$TEST_DIR/b.$IMGFMT" +DEST_IMG="$TEST_IMG.dest" BLKDEBUG_CONF="$TEST_DIR/blkdebug.conf" _make_test_img 2M diff --git a/tests/qemu-iotests/229.out b/tests/qemu-iotests/229.out index 4de6dfaa28..7eed393013 100644 --- a/tests/qemu-iotests/229.out +++ b/tests/qemu-iotests/229.out @@ -1,6 +1,6 @@ QA output created by 229 -Formatting 'TEST_DIR/b.IMGFMT', fmt=IMGFMT size=2097152 -Formatting 'TEST_DIR/d.IMGFMT', fmt=IMGFMT size=2097152 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2097152 +Formatting 'TEST_DIR/t.IMGFMT.dest', fmt=IMGFMT size=2097152 wrote 2097152/2097152 bytes at offset 0 2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) {'execute': 'qmp_capabilities'} @@ -8,7 +8,7 @@ wrote 2097152/2097152 bytes at offset 0 === Starting drive-mirror, causing error & stop === -{'execute': 'drive-mirror', 'arguments': {'device': 'testdisk', 'format': 'IMGFMT', 'target': 'blkdebug:TEST_DIR/blkdebug.conf:TEST_DIR/d.IMGFMT', 'sync': 'full', 'mode': 'existing', 'on-source-error': 'stop', 'on-target-error': 'stop' }} +{'execute': 'drive-mirror', 'arguments': {'device': 'testdisk', 'format': 'IMGFMT', 'target': 'blkdebug:TEST_DIR/blkdebug.conf:TEST_DIR/t.IMGFMT.dest', 'sync': 'full', 'mode': 'existing', 'on-source-error': 'stop', 'on-target-error': 'stop' }} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "testdisk"}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "testdisk"}} {"return": {}} diff --git a/tests/qemu-iotests/242 b/tests/qemu-iotests/242 index 64f1bd95e4..a16de3085f 100755 --- a/tests/qemu-iotests/242 +++ b/tests/qemu-iotests/242 @@ -24,7 +24,8 @@ import struct from iotests import qemu_img_create, qemu_io, qemu_img_pipe, \ file_path, img_info_log, log, filter_qemu_io -iotests.script_initialize(supported_fmts=['qcow2']) +iotests.script_initialize(supported_fmts=['qcow2'], + supported_protocols=['file']) disk = file_path('disk') chunk = 256 * 1024 diff --git a/tests/qemu-iotests/247 b/tests/qemu-iotests/247 index 87e37b39e2..6cf2679750 100755 --- a/tests/qemu-iotests/247 +++ b/tests/qemu-iotests/247 @@ -41,7 +41,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Requires backing files and .bdrv_change_backing_file support _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse size=128M diff --git a/tests/qemu-iotests/249 b/tests/qemu-iotests/249 index 68f13ed328..29453b8c90 100755 --- a/tests/qemu-iotests/249 +++ b/tests/qemu-iotests/249 @@ -42,15 +42,15 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Any format implementing BlockDriver.bdrv_change_backing_file _supported_fmt qcow2 qed -_supported_proto file +_supported_proto file fuse _supported_os Linux IMG_SIZE=1M # Create the images: base <- int <- active -TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE | _filter_imgfmt -TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" -F $IMGFMT | _filter_imgfmt -_make_test_img -b "$TEST_IMG.int" -F $IMGFMT | _filter_imgfmt +TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE +TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" -F $IMGFMT +_make_test_img -b "$TEST_IMG.int" -F $IMGFMT # Launch QEMU with these two drives: # none0: base (read-only) diff --git a/tests/qemu-iotests/250 b/tests/qemu-iotests/250 index 9bb6b94d74..3df275c76b 100755 --- a/tests/qemu-iotests/250 +++ b/tests/qemu-iotests/250 @@ -37,7 +37,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # This test does not make much sense with external data files _unsupported_imgopts data_file diff --git a/tests/qemu-iotests/252 b/tests/qemu-iotests/252 index 6662f4c9de..1d74afff99 100755 --- a/tests/qemu-iotests/252 +++ b/tests/qemu-iotests/252 @@ -42,7 +42,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # zero cluster support _supported_fmt qcow2 _unsupported_imgopts 'compat=0.10' -_supported_proto file +_supported_proto file fuse _supported_os Linux CLUSTER_SIZE=65536 diff --git a/tests/qemu-iotests/265 b/tests/qemu-iotests/265 index 00f2ec769e..0e800fb524 100755 --- a/tests/qemu-iotests/265 +++ b/tests/qemu-iotests/265 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # qcow2-specific test _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux echo '--- Writing to the image ---' diff --git a/tests/qemu-iotests/268 b/tests/qemu-iotests/268 index 78c3f4db3a..ddf4312284 100755 --- a/tests/qemu-iotests/268 +++ b/tests/qemu-iotests/268 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse echo echo "== Required alignment larger than cluster size ==" diff --git a/tests/qemu-iotests/272 b/tests/qemu-iotests/272 index c2f782d47b..de475bf6f0 100755 --- a/tests/qemu-iotests/272 +++ b/tests/qemu-iotests/272 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This is a qcow2 regression test _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # External data files do not support compression; # We need an exact cluster size (2M) and refcount width (2) so we can diff --git a/tests/qemu-iotests/273 b/tests/qemu-iotests/273 index 41ffbf39c4..79b4ab4b05 100755 --- a/tests/qemu-iotests/273 +++ b/tests/qemu-iotests/273 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # This is a qcow2 regression test _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # External data files would add nodes to the block graph, so it would # not match the reference output diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279 index 5515d4ed01..2a6315cf17 100755 --- a/tests/qemu-iotests/279 +++ b/tests/qemu-iotests/279 @@ -36,7 +36,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 # Backing files are required... _supported_fmt qcow qcow2 vmdk qed -_supported_proto file +_supported_proto file fuse _supported_os Linux _unsupported_imgopts "subformat=monolithicFlat" \ "subformat=twoGbMaxExtentFlat" \ diff --git a/tests/qemu-iotests/286 b/tests/qemu-iotests/286 index f14445ba4a..f64e0eccea 100755 --- a/tests/qemu-iotests/286 +++ b/tests/qemu-iotests/286 @@ -35,7 +35,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.qemu _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # Internal snapshots are (currently) impossible with refcount_bits=1, # and generally impossible with external data files _unsupported_imgopts 'refcount_bits=1[^0-9]' data_file diff --git a/tests/qemu-iotests/287 b/tests/qemu-iotests/287 index f98a4cadc1..3bb383fd4b 100755 --- a/tests/qemu-iotests/287 +++ b/tests/qemu-iotests/287 @@ -32,7 +32,7 @@ status=1 # failure is the default! # This tests qocw2-specific low-level functionality _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux _unsupported_imgopts 'compat=0.10' data_file @@ -51,8 +51,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 CLUSTER_SIZE=65536 # Check if we can run this test. -if IMGOPTS='compression_type=zstd' _make_test_img 64M | - grep "Invalid parameter 'zstd'"; then +output=$(_make_test_img -o 'compression_type=zstd' 64M; _cleanup_test_img) +if echo "$output" | grep -q "Invalid parameter 'zstd'"; then _notrun "ZSTD is disabled" fi diff --git a/tests/qemu-iotests/289 b/tests/qemu-iotests/289 index 1c11d4030e..fe69bde1eb 100755 --- a/tests/qemu-iotests/289 +++ b/tests/qemu-iotests/289 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.pattern _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse # This is a v3-exclusive test; # As for data_file, error paths often very much depend on whether # there is an external data file or not; so we create one exactly when diff --git a/tests/qemu-iotests/290 b/tests/qemu-iotests/290 index 01ee14dcfb..35c38d4f80 100755 --- a/tests/qemu-iotests/290 +++ b/tests/qemu-iotests/290 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux _unsupported_imgopts 'compat=0.10' refcount_bits data_file diff --git a/tests/qemu-iotests/291 b/tests/qemu-iotests/291 index ecef9eec62..bc70d5e389 100755 --- a/tests/qemu-iotests/291 +++ b/tests/qemu-iotests/291 @@ -36,7 +36,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.nbd _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux _require_command QEMU_NBD # compat=0.10 does not support bitmaps diff --git a/tests/qemu-iotests/292 b/tests/qemu-iotests/292 index 83ab19231d..3ae2772e3b 100755 --- a/tests/qemu-iotests/292 +++ b/tests/qemu-iotests/292 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux # We need qemu-img map to show the file where the data is allocated, # but with an external data file, it will show that instead of the diff --git a/tests/qemu-iotests/293 b/tests/qemu-iotests/293 index f86fe3b413..3363bf07f0 100755 --- a/tests/qemu-iotests/293 +++ b/tests/qemu-iotests/293 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 luks -_supported_proto file #TODO +_supported_proto file fuse #TODO _require_working_luks QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT diff --git a/tests/qemu-iotests/294 b/tests/qemu-iotests/294 index 9c95ed8c9a..87da35db49 100755 --- a/tests/qemu-iotests/294 +++ b/tests/qemu-iotests/294 @@ -34,7 +34,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt luks -_supported_proto file #TODO +_supported_proto file fuse #TODO QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT diff --git a/tests/qemu-iotests/305 b/tests/qemu-iotests/305 index 768818af4a..5a415eb2a4 100755 --- a/tests/qemu-iotests/305 +++ b/tests/qemu-iotests/305 @@ -38,7 +38,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.filter _supported_fmt qcow2 -_supported_proto file +_supported_proto file fuse _supported_os Linux _unsupported_imgopts cluster_size refcount_bits extended_l2 compat=0.10 data_file diff --git a/tests/qemu-iotests/308 b/tests/qemu-iotests/308 new file mode 100755 index 0000000000..b30f4400f6 --- /dev/null +++ b/tests/qemu-iotests/308 @@ -0,0 +1,339 @@ +#!/usr/bin/env bash +# +# Test FUSE exports (in ways that are not captured by the generic +# tests) +# +# Copyright (C) 2020 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# + +seq=$(basename "$0") +echo "QA output created by $seq" + +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_qemu + _cleanup_test_img + rmdir "$EXT_MP" 2>/dev/null + rm -f "$EXT_MP" + rm -f "$COPIED_IMG" +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter +. ./common.qemu + +# Generic format, but needs a plain filename +_supported_fmt generic +if [ "$IMGOPTSSYNTAX" = "true" ]; then + _unsupported_fmt $IMGFMT +fi +# We need the image to have exactly the specified size, and VPC does +# not allow that by default +_unsupported_fmt vpc + +_supported_proto file # We create the FUSE export manually +_supported_os Linux # We need /dev/urandom + +# $1: Export ID +# $2: Options (beyond the node-name and ID) +# $3: Expected return value (defaults to 'return') +# $4: Node to export (defaults to 'node-format') +fuse_export_add() +{ + _send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'block-export-add', + 'arguments': { + 'type': 'fuse', + 'id': '$1', + 'node-name': '${4:-node-format}', + $2 + } }" \ + "${3:-return}" \ + | _filter_imgfmt +} + +# $1: Export ID +fuse_export_del() +{ + _send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'block-export-del', + 'arguments': { + 'id': '$1' + } }" \ + 'return' + + _send_qemu_cmd $QEMU_HANDLE \ + '' \ + 'BLOCK_EXPORT_DELETED' +} + +# Return the length of the protocol file +# $1: Protocol node export mount point +# $2: Original file (to compare) +get_proto_len() +{ + len1=$(stat -c '%s' "$1") + len2=$(stat -c '%s' "$2") + + if [ "$len1" != "$len2" ]; then + echo 'ERROR: Length of export and original differ:' >&2 + echo "$len1 != $len2" >&2 + else + echo '(OK: Lengths of export and original are the same)' >&2 + fi + + echo "$len1" +} + +COPIED_IMG="$TEST_IMG.copy" +EXT_MP="$TEST_IMG.fuse" + +echo '=== Set up ===' + +# Create image with random data +_make_test_img 64M +$QEMU_IO -c 'write -s /dev/urandom 0 64M' "$TEST_IMG" | _filter_qemu_io + +_launch_qemu +_send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'qmp_capabilities'}" \ + 'return' + +# Separate blockdev-add calls for format and protocol so we can remove +# the format layer later on +_send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'blockdev-add', + 'arguments': { + 'driver': 'file', + 'node-name': 'node-protocol', + 'filename': '$TEST_IMG' + } }" \ + 'return' + +_send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'blockdev-add', + 'arguments': { + 'driver': '$IMGFMT', + 'node-name': 'node-format', + 'file': 'node-protocol' + } }" \ + 'return' + +echo +echo '=== Mountpoint not present ===' + +rmdir "$EXT_MP" 2>/dev/null +rm -f "$EXT_MP" +output=$(fuse_export_add 'export-err' "'mountpoint': '$EXT_MP'" error) + +if echo "$output" | grep -q "Invalid parameter 'fuse'"; then + _notrun 'No FUSE support' +fi + +echo "$output" + +echo +echo '=== Mountpoint is a directory ===' + +mkdir "$EXT_MP" +fuse_export_add 'export-err' "'mountpoint': '$EXT_MP'" error +rmdir "$EXT_MP" + +echo +echo '=== Mountpoint is a regular file ===' + +touch "$EXT_MP" +fuse_export_add 'export-mp' "'mountpoint': '$EXT_MP'" + +# Check that the export presents the same data as the original image +$QEMU_IMG compare -f raw -F $IMGFMT -U "$EXT_MP" "$TEST_IMG" + +echo +echo '=== Mount over existing file ===' + +# This is the coolest feature of FUSE exports: You can transparently +# make images in any format appear as raw images +fuse_export_add 'export-img' "'mountpoint': '$TEST_IMG'" + +# Accesses both exports at the same time, so we get a concurrency test +$QEMU_IMG compare -f raw -F raw -U "$EXT_MP" "$TEST_IMG" + +# Just to be sure, we later want to compare the data offline. Also, +# this allows us to see that cp works without complaining. +# (This is not a given, because cp will expect a short read at EOF. +# Internally, qemu does not allow short reads, so we have to check +# whether the FUSE export driver lets them work.) +cp "$TEST_IMG" "$COPIED_IMG" + +# $TEST_IMG will be in mode 0400 because it is read-only; we are going +# to write to the copy, so make it writable +chmod 0600 "$COPIED_IMG" + +echo +echo '=== Double export ===' + +# We have already seen that exporting a node twice works fine, but you +# cannot export anything twice on the same mount point. The reason is +# that qemu has to stat the given mount point, and this would have to +# be answered by the same qemu instance if it already has an export +# there. However, it cannot answer the stat because it is itself +# caught up in that same stat. +fuse_export_add 'export-err' "'mountpoint': '$EXT_MP'" error + +echo +echo '=== Remove export ===' + +# Double-check that $EXT_MP appears as a non-empty file (the raw image) +$QEMU_IMG info -f raw "$EXT_MP" | grep 'virtual size' + +fuse_export_del 'export-mp' + +# See that the file appears empty again +$QEMU_IMG info -f raw "$EXT_MP" | grep 'virtual size' + +echo +echo '=== Writable export ===' + +fuse_export_add 'export-mp' "'mountpoint': '$EXT_MP', 'writable': true" + +# Check that writing to the read-only export fails +$QEMU_IO -f raw -c 'write -P 42 1M 64k' "$TEST_IMG" | _filter_qemu_io + +# But here it should work +$QEMU_IO -f raw -c 'write -P 42 1M 64k' "$EXT_MP" | _filter_qemu_io + +# (Adjust the copy, too) +$QEMU_IO -f raw -c 'write -P 42 1M 64k' "$COPIED_IMG" | _filter_qemu_io + +echo +echo '=== Resizing exports ===' + +# Here, we need to export the protocol node -- the format layer may +# not be growable, simply because the format does not support it. + +# Remove all exports and the format node first so permissions will not +# get in the way +fuse_export_del 'export-mp' +fuse_export_del 'export-img' + +_send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'blockdev-del', + 'arguments': { + 'node-name': 'node-format' + } }" \ + 'return' + +# Now export the protocol node +fuse_export_add \ + 'export-mp' \ + "'mountpoint': '$EXT_MP', 'writable': true" \ + 'return' \ + 'node-protocol' + +echo +echo '--- Try growing non-growable export ---' + +# Get the current size so we can write beyond the EOF +orig_len=$(get_proto_len "$EXT_MP" "$TEST_IMG") +orig_disk_usage=$(stat -c '%b' "$TEST_IMG") + +# Should fail (exports are non-growable by default) +# (Note that qemu-io can never write beyond the EOF, so we have to use +# dd here) +dd if=/dev/zero of="$EXT_MP" bs=1 count=64k seek=$orig_len 2>&1 \ + | _filter_testdir | _filter_imgfmt + +echo +echo '--- Resize export ---' + +# But we can truncate it explicitly; even with fallocate +fallocate -o "$orig_len" -l 64k "$EXT_MP" + +new_len=$(get_proto_len "$EXT_MP" "$TEST_IMG") +if [ "$new_len" != "$((orig_len + 65536))" ]; then + echo 'ERROR: Unexpected post-truncate image size:' + echo "$new_len != $((orig_len + 65536))" +else + echo 'OK: Post-truncate image size is as expected' +fi + +new_disk_usage=$(stat -c '%b' "$TEST_IMG") +if [ "$new_disk_usage" -gt "$orig_disk_usage" ]; then + echo 'OK: Disk usage grew with fallocate' +else + echo 'ERROR: Disk usage did not grow despite fallocate:' + echo "$orig_disk_usage => $new_disk_usage" +fi + +echo +echo '--- Try growing growable export ---' + +# Now export as growable +fuse_export_del 'export-mp' +fuse_export_add \ + 'export-mp' \ + "'mountpoint': '$EXT_MP', 'writable': true, 'growable': true" \ + 'return' \ + 'node-protocol' + +# Now we should be able to write beyond the EOF +dd if=/dev/zero of="$EXT_MP" bs=1 count=64k seek=$new_len 2>&1 \ + | _filter_testdir | _filter_imgfmt + +new_len=$(get_proto_len "$EXT_MP" "$TEST_IMG") +if [ "$new_len" != "$((orig_len + 131072))" ]; then + echo 'ERROR: Unexpected post-grow image size:' + echo "$new_len != $((orig_len + 131072))" +else + echo 'OK: Post-grow image size is as expected' +fi + +echo +echo '--- Shrink export ---' + +# Now go back to the original size +truncate -s "$orig_len" "$EXT_MP" + +new_len=$(get_proto_len "$EXT_MP" "$TEST_IMG") +if [ "$new_len" != "$orig_len" ]; then + echo 'ERROR: Unexpected post-truncate image size:' + echo "$new_len != $orig_len" +else + echo 'OK: Post-truncate image size is as expected' +fi + +echo +echo '=== Tear down ===' + +_send_qemu_cmd $QEMU_HANDLE \ + "{'execute': 'quit'}" \ + 'return' + +wait=yes _cleanup_qemu + +echo +echo '=== Compare copy with original ===' + +$QEMU_IMG compare -f raw -F $IMGFMT "$COPIED_IMG" "$TEST_IMG" + +# success, all done +echo "*** done" +rm -f $seq.full +status=0 diff --git a/tests/qemu-iotests/308.out b/tests/qemu-iotests/308.out new file mode 100644 index 0000000000..b93aceed2e --- /dev/null +++ b/tests/qemu-iotests/308.out @@ -0,0 +1,97 @@ +QA output created by 308 +=== Set up === +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 +wrote 67108864/67108864 bytes at offset 0 +64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +{'execute': 'qmp_capabilities'} +{"return": {}} +{'execute': 'blockdev-add', 'arguments': { 'driver': 'file', 'node-name': 'node-protocol', 'filename': 'TEST_DIR/t.IMGFMT' } } +{"return": {}} +{'execute': 'blockdev-add', 'arguments': { 'driver': 'IMGFMT', 'node-name': 'node-format', 'file': 'node-protocol' } } +{"return": {}} + +=== Mountpoint not present === +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-err', 'node-name': 'node-format', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse' } } +{"error": {"class": "GenericError", "desc": "Failed to stat 'TEST_DIR/t.IMGFMT.fuse': No such file or directory"}} + +=== Mountpoint is a directory === +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-err', 'node-name': 'node-format', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse' } } +{"error": {"class": "GenericError", "desc": "'TEST_DIR/t.IMGFMT.fuse' is not a regular file"}} + +=== Mountpoint is a regular file === +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-mp', 'node-name': 'node-format', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse' } } +{"return": {}} +Images are identical. + +=== Mount over existing file === +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-img', 'node-name': 'node-format', 'mountpoint': 'TEST_DIR/t.IMGFMT' } } +{"return": {}} +Images are identical. + +=== Double export === +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-err', 'node-name': 'node-format', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse' } } +{"error": {"class": "GenericError", "desc": "There already is a FUSE export on 'TEST_DIR/t.IMGFMT.fuse'"}} + +=== Remove export === +virtual size: 64 MiB (67108864 bytes) +{'execute': 'block-export-del', 'arguments': { 'id': 'export-mp' } } +{"return": {}} +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "export-mp"}} +virtual size: 0 B (0 bytes) + +=== Writable export === +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-mp', 'node-name': 'node-format', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse', 'writable': true } } +{"return": {}} +write failed: Permission denied +wrote 65536/65536 bytes at offset 1048576 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +wrote 65536/65536 bytes at offset 1048576 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + +=== Resizing exports === +{'execute': 'block-export-del', 'arguments': { 'id': 'export-mp' } } +{"return": {}} +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "export-mp"}} +{'execute': 'block-export-del', 'arguments': { 'id': 'export-img' } } +{"return": {}} +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "export-img"}} +{'execute': 'blockdev-del', 'arguments': { 'node-name': 'node-format' } } +{"return": {}} +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-mp', 'node-name': 'node-protocol', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse', 'writable': true } } +{"return": {}} + +--- Try growing non-growable export --- +(OK: Lengths of export and original are the same) +dd: error writing 'TEST_DIR/t.IMGFMT.fuse': Input/output error +1+0 records in +0+0 records out + +--- Resize export --- +(OK: Lengths of export and original are the same) +OK: Post-truncate image size is as expected +OK: Disk usage grew with fallocate + +--- Try growing growable export --- +{'execute': 'block-export-del', 'arguments': { 'id': 'export-mp' } } +{"return": {}} +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "export-mp"}} +{'execute': 'block-export-add', 'arguments': { 'type': 'fuse', 'id': 'export-mp', 'node-name': 'node-protocol', 'mountpoint': 'TEST_DIR/t.IMGFMT.fuse', 'writable': true, 'growable': true } } +{"return": {}} +65536+0 records in +65536+0 records out +(OK: Lengths of export and original are the same) +OK: Post-grow image size is as expected + +--- Shrink export --- +(OK: Lengths of export and original are the same) +OK: Post-truncate image size is as expected + +=== Tear down === +{'execute': 'quit'} +{"return": {}} +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}} +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_EXPORT_DELETED", "data": {"id": "export-mp"}} + +=== Compare copy with original === +Images are identical. +*** done diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check index 678b6e4910..952762d5ed 100755 --- a/tests/qemu-iotests/check +++ b/tests/qemu-iotests/check @@ -270,6 +270,7 @@ image protocol options -rbd test rbd -sheepdog test sheepdog -nbd test nbd + -fuse test fuse -ssh test ssh -nfs test nfs @@ -382,6 +383,11 @@ testlist options xpand=false ;; + -fuse) + IMGPROTO=fuse + xpand=false + ;; + -ssh) IMGPROTO=ssh xpand=false @@ -644,6 +650,17 @@ if [ -z $QEMU_NBD_PROG ]; then fi export QEMU_NBD_PROG="$(type -p "$QEMU_NBD_PROG")" +if [ -z "$QSD_PROG" ]; then + if [ -x "$build_iotests/qemu-storage-daemon" ]; then + export QSD_PROG="$build_iotests/qemu-storage-daemon" + elif [ -x "$build_root/storage-daemon/qemu-storage-daemon" ]; then + export QSD_PROG="$build_root/storage-daemon/qemu-storage-daemon" + else + _init_error "qemu-storage-daemon not found" + fi +fi +export QSD_PROG="$(type -p "$QSD_PROG")" + if [ -x "$build_iotests/socket_scm_helper" ] then export SOCKET_SCM_HELPER="$build_iotests/socket_scm_helper" diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter index 838ed15793..172ea5752e 100644 --- a/tests/qemu-iotests/common.filter +++ b/tests/qemu-iotests/common.filter @@ -44,7 +44,8 @@ _filter_qom_path() _filter_testdir() { $SED -e "s#$TEST_DIR/#TEST_DIR/#g" \ - -e "s#$SOCK_DIR/#SOCK_DIR/#g" + -e "s#$SOCK_DIR/#SOCK_DIR/#g" \ + -e "s#SOCK_DIR/fuse-#TEST_DIR/#g" } # replace occurrences of the actual IMGFMT value with IMGFMT @@ -127,6 +128,7 @@ _filter_img_create_filenames() -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ -e "s#$TEST_DIR#TEST_DIR#g" \ -e "s#$SOCK_DIR#SOCK_DIR#g" \ + -e 's#SOCK_DIR/fuse-#TEST_DIR/#g' \ -e "s#$IMGFMT#IMGFMT#g" \ -e 's#nbd:127.0.0.1:[0-9]\\+#TEST_DIR/t.IMGFMT#g' \ -e 's#nbd+unix:///\??socket=SOCK_DIR/nbd#TEST_DIR/t.IMGFMT#g' @@ -227,6 +229,7 @@ _filter_img_info() -e "s#$IMGFMT#IMGFMT#g" \ -e 's#nbd://127.0.0.1:[0-9]\\+$#TEST_DIR/t.IMGFMT#g' \ -e 's#nbd+unix:///\??socket=SOCK_DIR/nbd#TEST_DIR/t.IMGFMT#g' \ + -e 's#SOCK_DIR/fuse-#TEST_DIR/#g' \ -e "/encrypted: yes/d" \ -e "/cluster_size: [0-9]\\+/d" \ -e "/table_size: [0-9]\\+/d" \ diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc index 494490a272..29354654cc 100644 --- a/tests/qemu-iotests/common.rc +++ b/tests/qemu-iotests/common.rc @@ -124,6 +124,7 @@ fi : ${VALGRIND_QEMU_IMG=$VALGRIND_QEMU} : ${VALGRIND_QEMU_IO=$VALGRIND_QEMU} : ${VALGRIND_QEMU_NBD=$VALGRIND_QEMU} +: ${VALGRIND_QSD=$VALGRIND_QEMU} # The Valgrind own parameters may be set with # its environment variable VALGRIND_OPTS, e.g. @@ -211,6 +212,21 @@ _qemu_nbd_wrapper() return $RETVAL } +_qemu_storage_daemon_wrapper() +{ + local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind + ( + if [ -n "${QSD_NEED_PID}" ]; then + echo $BASHPID > "${QEMU_TEST_DIR}/qemu-storage-daemon.pid" + fi + VALGRIND_QEMU="${VALGRIND_QSD}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \ + "$QSD_PROG" $QSD_OPTIONS "$@" + ) + RETVAL=$? + _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL + return $RETVAL +} + # Valgrind bug #409141 https://bugs.kde.org/show_bug.cgi?id=409141 # Until valgrind 3.16+ is ubiquitous, we must work around a hang in # valgrind when issuing sigkill. Disable valgrind for this invocation. @@ -223,6 +239,7 @@ export QEMU=_qemu_wrapper export QEMU_IMG=_qemu_img_wrapper export QEMU_IO=_qemu_io_wrapper export QEMU_NBD=_qemu_nbd_wrapper +export QSD=_qemu_storage_daemon_wrapper if [ "$IMGOPTSSYNTAX" = "true" ]; then DRIVER="driver=$IMGFMT" @@ -240,6 +257,9 @@ if [ "$IMGOPTSSYNTAX" = "true" ]; then TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix" TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd" + elif [ "$IMGPROTO" = "fuse" ]; then + TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT + TEST_IMG="$DRIVER,file.filename=$SOCK_DIR/fuse-t.$IMGFMT" elif [ "$IMGPROTO" = "ssh" ]; then TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE" @@ -256,6 +276,9 @@ else elif [ "$IMGPROTO" = "nbd" ]; then TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT TEST_IMG="nbd+unix:///?socket=$SOCK_DIR/nbd" + elif [ "$IMGPROTO" = "fuse" ]; then + TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT + TEST_IMG="$SOCK_DIR/fuse-t.$IMGFMT" elif [ "$IMGPROTO" = "ssh" ]; then TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT REMOTE_TEST_DIR="ssh://\\($USER@\\)\\?127.0.0.1\\(:[0-9]\\+\\)\\?$TEST_DIR" @@ -268,8 +291,12 @@ else TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT fi fi +ORIG_TEST_IMG_FILE=$TEST_IMG_FILE ORIG_TEST_IMG="$TEST_IMG" +FUSE_PIDS=() +FUSE_EXPORTS=() + if [ -z "$TEST_DIR" ]; then TEST_DIR=$PWD/scratch fi @@ -330,6 +357,34 @@ _get_data_file() | sed -e "s#\\\$TEST_IMG#$1#" } +# Translate a $TEST_IMG to its corresponding $TEST_IMG_FILE for +# different protocols +_test_img_to_test_img_file() +{ + case "$IMGPROTO" in + file) + echo "$1" + ;; + + fuse) + echo "$1" | sed -e "s#$SOCK_DIR/fuse-#$TEST_DIR/#" + ;; + + nfs) + echo "$1" | sed -e "s#nfs://127.0.0.1##" + ;; + + ssh) + echo "$1" | \ + sed -e "s#ssh://\\($USER@\\)\\?127.0.0.1\\(:[0-9]\\+\\)\\?##" + ;; + + *) + return 1 + ;; + esac +} + _make_test_img() { # extra qemu-img options can be added by tests @@ -343,10 +398,24 @@ _make_test_img() local opts_param=false local misc_params=() - if [ -n "$TEST_IMG_FILE" ]; then - img_name=$TEST_IMG_FILE - else + if [[ $IMGPROTO == fuse && $TEST_IMG == $SOCK_DIR/fuse-* ]]; then + # The caller may be trying to overwrite an existing image + _rm_test_img "$TEST_IMG" + fi + + if [ -z "$TEST_IMG_FILE" ]; then img_name=$TEST_IMG + elif [ "$IMGOPTSSYNTAX" != "true" -a \ + "$TEST_IMG_FILE" = "$ORIG_TEST_IMG_FILE" ]; then + # Handle cases of tests only updating TEST_IMG, but not TEST_IMG_FILE + img_name=$(_test_img_to_test_img_file "$TEST_IMG") + if [ "$?" != 0 ]; then + img_name=$TEST_IMG_FILE + fi + else + # $TEST_IMG_FILE is not the default value, so it definitely has been + # modified by the test + img_name=$TEST_IMG_FILE fi if [ -n "$IMGOPTS" ]; then @@ -418,11 +487,105 @@ _make_test_img() eval "$QEMU_NBD -v -t -k '$SOCK_DIR/nbd' -f $IMGFMT -e 42 -x '' $TEST_IMG_FILE >/dev/null &" sleep 1 # FIXME: qemu-nbd needs to be listening before we continue fi + + if [ $IMGPROTO = "fuse" -a -f "$img_name" ]; then + local export_mp + local pid + local pidfile + local timeout + + export_mp=$(echo "$img_name" | sed -e "s#$TEST_DIR/#$SOCK_DIR/fuse-#") + if ! echo "$export_mp" | grep -q "^$SOCK_DIR"; then + echo 'Cannot use FUSE exports with images outside of TEST_DIR' >&2 + return 1 + fi + + touch "$export_mp" + rm -f "$SOCK_DIR/fuse-output" + + # Usually, users would export formatted nodes. But we present fuse as a + # protocol-level driver here, so we have to leave the format to the + # client. + QSD_NEED_PID=y $QSD \ + --blockdev file,node-name=export-node,filename=$img_name,discard=unmap \ + --export fuse,id=fuse-export,node-name=export-node,mountpoint="$export_mp",writable=on,growable=on \ + & + + pidfile="$QEMU_TEST_DIR/qemu-storage-daemon.pid" + + # Wait for the PID file + while [ ! -f "$pidfile" ]; do + sleep 0.5 + done + + pid=$(cat "$pidfile") + rm -f "$pidfile" + + FUSE_PIDS+=($pid) + FUSE_EXPORTS+=("$export_mp") + fi } _rm_test_img() { local img=$1 + + if [[ $IMGPROTO == fuse && $img == $SOCK_DIR/fuse-* ]]; then + # Drop a FUSE export + local df_output + local i + local image_file + local index='' + local timeout + + for i in "${!FUSE_EXPORTS[@]}"; do + if [ "${FUSE_EXPORTS[i]}" = "$img" ]; then + index=$i + break + fi + done + + if [ -z "$index" ]; then + # Probably gone already + return 0 + fi + + kill "${FUSE_PIDS[index]}" + + # Wait until the mount is gone + timeout=10 # *0.5 s + while true; do + # Will show the mount point; if the mount is still there, + # it will be $img. + df_output=$(df "$img" 2>/dev/null) + + # But df may also show an error ("Transpoint endpoint not + # connected"), so retry in such cases + if [ -n "$df_output" ]; then + if ! echo "$df_output" | grep -q "$img"; then + break + fi + fi + + sleep 0.5 + + timeout=$((timeout - 1)) + if [ "$timeout" = 0 ]; then + echo 'Failed to take down FUSE export' >&2 + return 1 + fi + done + + rm -f "$img" + + unset "FUSE_PIDS[$index]" + unset "FUSE_EXPORTS[$index]" + + image_file=$(echo "$img" | sed -e "s#$SOCK_DIR/fuse-#$TEST_DIR/#") + _rm_test_img "$image_file" + return + fi + if [ "$IMGFMT" = "vmdk" ]; then # Remove all the extents for vmdk "$QEMU_IMG" info "$img" 2>/dev/null | grep 'filename:' | cut -f 2 -d: \ @@ -445,6 +608,17 @@ _cleanup_test_img() rm -f "$TEST_IMG_FILE" ;; + fuse) + local mp + + for mp in "${FUSE_EXPORTS[@]}"; do + _rm_test_img "$mp" + done + + FUSE_PIDS=() + FUSE_EXPORTS=() + ;; + file) _rm_test_img "$TEST_DIR/t.$IMGFMT" _rm_test_img "$TEST_DIR/t.$IMGFMT.orig" @@ -511,6 +685,7 @@ _img_info() sed -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \ -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ -e "s#$TEST_DIR#TEST_DIR#g" \ + -e "s#$SOCK_DIR/fuse-#TEST_DIR/#g" \ -e "s#$IMGFMT#IMGFMT#g" \ -e "/^disk size:/ D" \ -e "/actual-size/ D" | \ diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 2960dff728..9a8394b4cd 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -315,4 +315,5 @@ 304 rw quick 305 rw quick 307 rw quick export +308 rw 309 rw auto quick diff --git a/tests/test-write-threshold.c b/tests/test-write-threshold.c index 97ca12f710..4cf032652d 100644 --- a/tests/test-write-threshold.c +++ b/tests/test-write-threshold.c @@ -64,6 +64,8 @@ static void test_threshold_not_trigger(void) req.offset = 1024; req.bytes = 1024; + assert(bdrv_check_request(req.offset, req.bytes) == 0); + bdrv_write_threshold_set(&bs, threshold); amount = bdrv_write_threshold_exceeded(&bs, &req); g_assert_cmpuint(amount, ==, 0); @@ -82,6 +84,8 @@ static void test_threshold_trigger(void) req.offset = (4 * 1024 * 1024) - 1024; req.bytes = 2 * 1024; + assert(bdrv_check_request(req.offset, req.bytes) == 0); + bdrv_write_threshold_set(&bs, threshold); amount = bdrv_write_threshold_exceeded(&bs, &req); g_assert_cmpuint(amount, >=, 1024);