2007-12-15 17:28:36 +00:00
|
|
|
/*
|
|
|
|
* Block driver for RAW files (win32)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2018-02-01 11:18:46 +00:00
|
|
|
|
2016-01-18 18:01:42 +00:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 08:01:28 +00:00
|
|
|
#include "qapi/error.h"
|
2016-03-20 17:16:19 +00:00
|
|
|
#include "qemu/cutils.h"
|
2012-12-17 17:19:44 +00:00
|
|
|
#include "block/block_int.h"
|
2012-12-17 17:20:00 +00:00
|
|
|
#include "qemu/module.h"
|
2018-02-01 11:18:46 +00:00
|
|
|
#include "qemu/option.h"
|
2016-07-04 16:33:20 +00:00
|
|
|
#include "block/raw-aio.h"
|
2012-06-09 02:48:28 +00:00
|
|
|
#include "trace.h"
|
2012-12-17 17:19:44 +00:00
|
|
|
#include "block/thread-pool.h"
|
2012-12-17 17:20:00 +00:00
|
|
|
#include "qemu/iov.h"
|
2018-02-01 11:18:39 +00:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2015-03-17 17:29:20 +00:00
|
|
|
#include "qapi/qmp/qstring.h"
|
2009-03-08 16:26:59 +00:00
|
|
|
#include <windows.h>
|
2007-12-15 17:28:36 +00:00
|
|
|
#include <winioctl.h>
|
|
|
|
|
|
|
|
#define FTYPE_FILE 0
|
|
|
|
#define FTYPE_CD 1
|
|
|
|
#define FTYPE_HARDDISK 2
|
|
|
|
|
2012-06-09 02:48:28 +00:00
|
|
|
typedef struct RawWin32AIOData {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
HANDLE hfile;
|
|
|
|
struct iovec *aio_iov;
|
|
|
|
int aio_niov;
|
|
|
|
size_t aio_nbytes;
|
|
|
|
off64_t aio_offset;
|
|
|
|
int aio_type;
|
|
|
|
} RawWin32AIOData;
|
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
typedef struct BDRVRawState {
|
|
|
|
HANDLE hfile;
|
|
|
|
int type;
|
|
|
|
char drive_path[16]; /* format: "d:\" */
|
2012-10-26 09:43:58 +00:00
|
|
|
QEMUWin32AIOState *aio;
|
2007-12-15 17:28:36 +00:00
|
|
|
} BDRVRawState;
|
|
|
|
|
2021-08-25 17:36:25 +00:00
|
|
|
typedef struct BDRVRawReopenState {
|
|
|
|
HANDLE hfile;
|
|
|
|
} BDRVRawReopenState;
|
|
|
|
|
2012-06-09 02:48:28 +00:00
|
|
|
/*
|
|
|
|
* Read/writes the data to/from a given linear buffer.
|
|
|
|
*
|
|
|
|
* Returns the number of bytes handles or -errno in case of an error. Short
|
|
|
|
* reads are only returned if the end of the file is reached.
|
|
|
|
*/
|
|
|
|
static size_t handle_aiocb_rw(RawWin32AIOData *aiocb)
|
|
|
|
{
|
|
|
|
size_t offset = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < aiocb->aio_niov; i++) {
|
|
|
|
OVERLAPPED ov;
|
|
|
|
DWORD ret, ret_count, len;
|
|
|
|
|
|
|
|
memset(&ov, 0, sizeof(ov));
|
|
|
|
ov.Offset = (aiocb->aio_offset + offset);
|
|
|
|
ov.OffsetHigh = (aiocb->aio_offset + offset) >> 32;
|
|
|
|
len = aiocb->aio_iov[i].iov_len;
|
|
|
|
if (aiocb->aio_type & QEMU_AIO_WRITE) {
|
|
|
|
ret = WriteFile(aiocb->hfile, aiocb->aio_iov[i].iov_base,
|
|
|
|
len, &ret_count, &ov);
|
|
|
|
} else {
|
|
|
|
ret = ReadFile(aiocb->hfile, aiocb->aio_iov[i].iov_base,
|
|
|
|
len, &ret_count, &ov);
|
|
|
|
}
|
|
|
|
if (!ret) {
|
|
|
|
ret_count = 0;
|
|
|
|
}
|
|
|
|
if (ret_count != len) {
|
2013-09-09 09:14:55 +00:00
|
|
|
offset += ret_count;
|
2012-06-09 02:48:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aio_worker(void *arg)
|
|
|
|
{
|
|
|
|
RawWin32AIOData *aiocb = arg;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
size_t count;
|
|
|
|
|
|
|
|
switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
|
|
|
|
case QEMU_AIO_READ:
|
|
|
|
count = handle_aiocb_rw(aiocb);
|
2015-02-05 18:58:24 +00:00
|
|
|
if (count < aiocb->aio_nbytes) {
|
2012-06-09 02:48:28 +00:00
|
|
|
/* A short read means that we have reached EOF. Pad the buffer
|
|
|
|
* with zeros for bytes after EOF. */
|
|
|
|
iov_memset(aiocb->aio_iov, aiocb->aio_niov, count,
|
|
|
|
0, aiocb->aio_nbytes - count);
|
|
|
|
|
|
|
|
count = aiocb->aio_nbytes;
|
|
|
|
}
|
|
|
|
if (count == aiocb->aio_nbytes) {
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case QEMU_AIO_WRITE:
|
|
|
|
count = handle_aiocb_rw(aiocb);
|
|
|
|
if (count == aiocb->aio_nbytes) {
|
2015-09-23 12:58:21 +00:00
|
|
|
ret = 0;
|
2012-06-09 02:48:28 +00:00
|
|
|
} else {
|
2015-09-23 12:58:21 +00:00
|
|
|
ret = -EINVAL;
|
2012-06-09 02:48:28 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case QEMU_AIO_FLUSH:
|
|
|
|
if (!FlushFileBuffers(aiocb->hfile)) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-10-01 11:04:39 +00:00
|
|
|
g_free(aiocb);
|
2012-06-09 02:48:28 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:14 +00:00
|
|
|
static BlockAIOCB *paio_submit(BlockDriverState *bs, HANDLE hfile,
|
2016-07-15 23:22:55 +00:00
|
|
|
int64_t offset, QEMUIOVector *qiov, int count,
|
2014-10-07 11:59:15 +00:00
|
|
|
BlockCompletionFunc *cb, void *opaque, int type)
|
2012-06-09 02:48:28 +00:00
|
|
|
{
|
2015-10-01 11:04:39 +00:00
|
|
|
RawWin32AIOData *acb = g_new(RawWin32AIOData, 1);
|
2013-03-07 12:41:49 +00:00
|
|
|
ThreadPool *pool;
|
2012-06-09 02:48:28 +00:00
|
|
|
|
|
|
|
acb->bs = bs;
|
|
|
|
acb->hfile = hfile;
|
|
|
|
acb->aio_type = type;
|
|
|
|
|
|
|
|
if (qiov) {
|
|
|
|
acb->aio_iov = qiov->iov;
|
|
|
|
acb->aio_niov = qiov->niov;
|
2016-07-15 23:22:55 +00:00
|
|
|
assert(qiov->size == count);
|
2012-06-09 02:48:28 +00:00
|
|
|
}
|
2016-07-15 23:22:55 +00:00
|
|
|
acb->aio_nbytes = count;
|
|
|
|
acb->aio_offset = offset;
|
2012-06-09 02:48:28 +00:00
|
|
|
|
2018-07-10 06:31:15 +00:00
|
|
|
trace_file_paio_submit(acb, opaque, offset, count, type);
|
2013-03-07 12:41:49 +00:00
|
|
|
pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
|
|
|
|
return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
|
2012-06-09 02:48:28 +00:00
|
|
|
}
|
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
int qemu_ftruncate64(int fd, int64_t length)
|
|
|
|
{
|
|
|
|
LARGE_INTEGER li;
|
2011-08-20 10:10:05 +00:00
|
|
|
DWORD dw;
|
2007-12-15 17:28:36 +00:00
|
|
|
LONG high;
|
|
|
|
HANDLE h;
|
|
|
|
BOOL res;
|
|
|
|
|
|
|
|
if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0)
|
2018-12-13 22:37:37 +00:00
|
|
|
return -1;
|
2007-12-15 17:28:36 +00:00
|
|
|
|
|
|
|
h = (HANDLE)_get_osfhandle(fd);
|
|
|
|
|
|
|
|
/* get current position, ftruncate do not change position */
|
|
|
|
li.HighPart = 0;
|
|
|
|
li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
|
2011-08-20 10:10:05 +00:00
|
|
|
if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
|
2018-12-13 22:37:37 +00:00
|
|
|
return -1;
|
2011-08-20 10:10:05 +00:00
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
|
|
|
|
high = length >> 32;
|
2011-08-20 10:10:05 +00:00
|
|
|
dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN);
|
|
|
|
if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
|
2018-12-13 22:37:37 +00:00
|
|
|
return -1;
|
2011-08-20 10:10:05 +00:00
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
res = SetEndOfFile(h);
|
|
|
|
|
|
|
|
/* back to old position */
|
|
|
|
SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN);
|
|
|
|
return res ? 0 : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int set_sparse(int fd)
|
|
|
|
{
|
|
|
|
DWORD returned;
|
|
|
|
return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE,
|
2018-12-13 22:37:37 +00:00
|
|
|
NULL, 0, NULL, 0, &returned, NULL);
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
2014-05-08 14:34:50 +00:00
|
|
|
static void raw_detach_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
|
|
|
|
if (s->aio) {
|
|
|
|
win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void raw_attach_aio_context(BlockDriverState *bs,
|
|
|
|
AioContext *new_context)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
|
|
|
|
if (s->aio) {
|
|
|
|
win32_aio_attach_aio_context(s->aio, new_context);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-23 22:37:16 +00:00
|
|
|
static void raw_probe_alignment(BlockDriverState *bs, Error **errp)
|
2011-11-29 11:42:20 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
DWORD sectorsPerCluster, freeClusters, totalClusters, count;
|
|
|
|
DISK_GEOMETRY_EX dg;
|
|
|
|
BOOL status;
|
|
|
|
|
|
|
|
if (s->type == FTYPE_CD) {
|
2016-06-23 22:37:24 +00:00
|
|
|
bs->bl.request_alignment = 2048;
|
2011-11-29 11:42:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (s->type == FTYPE_HARDDISK) {
|
|
|
|
status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
|
|
|
|
NULL, 0, &dg, sizeof(dg), &count, NULL);
|
|
|
|
if (status != 0) {
|
2016-06-23 22:37:24 +00:00
|
|
|
bs->bl.request_alignment = dg.Geometry.BytesPerSector;
|
2011-11-29 11:42:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* try GetDiskFreeSpace too */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->drive_path[0]) {
|
|
|
|
GetDiskFreeSpace(s->drive_path, §orsPerCluster,
|
|
|
|
&dg.Geometry.BytesPerSector,
|
|
|
|
&freeClusters, &totalClusters);
|
2016-06-23 22:37:24 +00:00
|
|
|
bs->bl.request_alignment = dg.Geometry.BytesPerSector;
|
2018-04-24 19:25:02 +00:00
|
|
|
return;
|
2011-11-29 11:42:20 +00:00
|
|
|
}
|
2018-04-24 19:25:02 +00:00
|
|
|
|
|
|
|
/* XXX Does Windows support AIO on less than 512-byte alignment? */
|
|
|
|
bs->bl.request_alignment = 512;
|
2011-11-29 11:42:20 +00:00
|
|
|
}
|
|
|
|
|
2016-09-08 13:09:01 +00:00
|
|
|
static void raw_parse_flags(int flags, bool use_aio, int *access_flags,
|
|
|
|
DWORD *overlapped)
|
2012-09-20 19:13:21 +00:00
|
|
|
{
|
|
|
|
assert(access_flags != NULL);
|
|
|
|
assert(overlapped != NULL);
|
|
|
|
|
|
|
|
if (flags & BDRV_O_RDWR) {
|
|
|
|
*access_flags = GENERIC_READ | GENERIC_WRITE;
|
|
|
|
} else {
|
|
|
|
*access_flags = GENERIC_READ;
|
|
|
|
}
|
|
|
|
|
|
|
|
*overlapped = FILE_ATTRIBUTE_NORMAL;
|
2016-09-08 13:09:01 +00:00
|
|
|
if (use_aio) {
|
2012-10-26 09:43:58 +00:00
|
|
|
*overlapped |= FILE_FLAG_OVERLAPPED;
|
|
|
|
}
|
2012-09-20 19:13:21 +00:00
|
|
|
if (flags & BDRV_O_NOCACHE) {
|
|
|
|
*overlapped |= FILE_FLAG_NO_BUFFERING;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-05 21:41:39 +00:00
|
|
|
static void raw_parse_filename(const char *filename, QDict *options,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2017-05-22 19:52:16 +00:00
|
|
|
bdrv_parse_filename_strip_prefix(filename, "file:", options);
|
2014-03-05 21:41:39 +00:00
|
|
|
}
|
|
|
|
|
2013-04-10 09:34:56 +00:00
|
|
|
static QemuOptsList raw_runtime_opts = {
|
|
|
|
.name = "raw",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = "filename",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "File name of the image",
|
|
|
|
},
|
2016-09-08 13:09:01 +00:00
|
|
|
{
|
|
|
|
.name = "aio",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "host AIO implementation (threads, native)",
|
|
|
|
},
|
2020-09-07 09:27:39 +00:00
|
|
|
{
|
|
|
|
.name = "locking",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "file locking mode (on/off/auto, default: auto)",
|
|
|
|
},
|
2013-04-10 09:34:56 +00:00
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2016-09-08 13:09:01 +00:00
|
|
|
static bool get_aio_option(QemuOpts *opts, int flags, Error **errp)
|
|
|
|
{
|
|
|
|
BlockdevAioOptions aio, aio_default;
|
|
|
|
|
|
|
|
aio_default = (flags & BDRV_O_NATIVE_AIO) ? BLOCKDEV_AIO_OPTIONS_NATIVE
|
|
|
|
: BLOCKDEV_AIO_OPTIONS_THREADS;
|
2017-08-24 08:46:10 +00:00
|
|
|
aio = qapi_enum_parse(&BlockdevAioOptions_lookup, qemu_opt_get(opts, "aio"),
|
2017-08-24 08:45:57 +00:00
|
|
|
aio_default, errp);
|
2016-09-08 13:09:01 +00:00
|
|
|
|
|
|
|
switch (aio) {
|
|
|
|
case BLOCKDEV_AIO_OPTIONS_NATIVE:
|
|
|
|
return true;
|
|
|
|
case BLOCKDEV_AIO_OPTIONS_THREADS:
|
|
|
|
return false;
|
|
|
|
default:
|
|
|
|
error_setg(errp, "Invalid AIO option");
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-09-05 12:22:29 +00:00
|
|
|
static int raw_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
2010-01-20 17:13:42 +00:00
|
|
|
int access_flags;
|
2007-12-15 17:28:36 +00:00
|
|
|
DWORD overlapped;
|
2013-04-10 09:34:56 +00:00
|
|
|
QemuOpts *opts;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
const char *filename;
|
2016-09-08 13:09:01 +00:00
|
|
|
bool use_aio;
|
2020-09-07 09:27:39 +00:00
|
|
|
OnOffAuto locking;
|
2013-04-10 09:34:56 +00:00
|
|
|
int ret;
|
2007-12-15 17:28:36 +00:00
|
|
|
|
|
|
|
s->type = FTYPE_FILE;
|
|
|
|
|
2014-01-02 02:49:17 +00:00
|
|
|
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
|
2020-07-07 16:06:03 +00:00
|
|
|
if (!qemu_opts_absorb_qdict(opts, options, errp)) {
|
2013-04-10 09:34:56 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2020-09-07 09:27:39 +00:00
|
|
|
locking = qapi_enum_parse(&OnOffAuto_lookup,
|
|
|
|
qemu_opt_get(opts, "locking"),
|
|
|
|
ON_OFF_AUTO_AUTO, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
switch (locking) {
|
|
|
|
case ON_OFF_AUTO_ON:
|
2017-05-02 16:35:51 +00:00
|
|
|
error_setg(errp, "locking=on is not supported on Windows");
|
2017-05-16 07:42:55 +00:00
|
|
|
ret = -EINVAL;
|
2017-05-02 16:35:51 +00:00
|
|
|
goto fail;
|
2020-09-07 09:27:39 +00:00
|
|
|
case ON_OFF_AUTO_OFF:
|
|
|
|
case ON_OFF_AUTO_AUTO:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2017-05-02 16:35:51 +00:00
|
|
|
}
|
|
|
|
|
2013-04-10 09:34:56 +00:00
|
|
|
filename = qemu_opt_get(opts, "filename");
|
|
|
|
|
2016-09-08 13:09:01 +00:00
|
|
|
use_aio = get_aio_option(opts, flags, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
raw_parse_flags(flags, use_aio, &access_flags, &overlapped);
|
2013-04-10 09:34:56 +00:00
|
|
|
|
2011-11-29 11:42:20 +00:00
|
|
|
if (filename[0] && filename[1] == ':') {
|
|
|
|
snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", filename[0]);
|
|
|
|
} else if (filename[0] == '\\' && filename[1] == '\\') {
|
|
|
|
s->drive_path[0] = 0;
|
|
|
|
} else {
|
|
|
|
/* Relative path. */
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
GetCurrentDirectory(MAX_PATH, buf);
|
|
|
|
snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]);
|
|
|
|
}
|
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
s->hfile = CreateFile(filename, access_flags,
|
2021-08-25 17:36:25 +00:00
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
2010-01-20 17:13:42 +00:00
|
|
|
OPEN_EXISTING, overlapped, NULL);
|
2007-12-15 17:28:36 +00:00
|
|
|
if (s->hfile == INVALID_HANDLE_VALUE) {
|
|
|
|
int err = GetLastError();
|
|
|
|
|
2016-10-11 14:12:35 +00:00
|
|
|
error_setg_win32(errp, err, "Could not open '%s'", filename);
|
2013-04-10 09:34:56 +00:00
|
|
|
if (err == ERROR_ACCESS_DENIED) {
|
|
|
|
ret = -EACCES;
|
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
goto fail;
|
2012-10-26 09:43:58 +00:00
|
|
|
}
|
|
|
|
|
2016-09-08 13:09:01 +00:00
|
|
|
if (use_aio) {
|
2014-05-08 14:34:49 +00:00
|
|
|
s->aio = win32_aio_init();
|
|
|
|
if (s->aio == NULL) {
|
|
|
|
CloseHandle(s->hfile);
|
|
|
|
error_setg(errp, "Could not initialize AIO");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = win32_aio_attach(s->aio, s->hfile);
|
2012-10-26 09:43:58 +00:00
|
|
|
if (ret < 0) {
|
2014-05-08 14:34:49 +00:00
|
|
|
win32_aio_cleanup(s->aio);
|
2012-10-26 09:43:58 +00:00
|
|
|
CloseHandle(s->hfile);
|
2013-10-10 13:44:02 +00:00
|
|
|
error_setg_errno(errp, -ret, "Could not enable AIO");
|
2013-04-10 09:34:56 +00:00
|
|
|
goto fail;
|
2012-10-26 09:43:58 +00:00
|
|
|
}
|
2014-05-08 14:34:50 +00:00
|
|
|
|
|
|
|
win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
2013-04-10 09:34:56 +00:00
|
|
|
|
2020-04-28 20:28:58 +00:00
|
|
|
/* When extending regular files, we get zeros from the OS */
|
|
|
|
bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
|
|
|
|
|
2013-04-10 09:34:56 +00:00
|
|
|
ret = 0;
|
|
|
|
fail:
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return ret;
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
2018-04-24 19:25:02 +00:00
|
|
|
static BlockAIOCB *raw_aio_preadv(BlockDriverState *bs,
|
block: use int64_t instead of uint64_t in driver read handlers
We are generally moving to int64_t for both offset and bytes parameters
on all io paths.
Main motivation is realization of 64-bit write_zeroes operation for
fast zeroing large disk chunks, up to the whole disk.
We chose signed type, to be consistent with off_t (which is signed) and
with possibility for signed return type (where negative value means
error).
So, convert driver read handlers parameters which are already 64bit to
signed type.
While being here, convert also flags parameter to be BdrvRequestFlags.
Now let's consider all callers. Simple
git grep '\->bdrv_\(aio\|co\)_preadv\(_part\)\?'
shows that's there three callers of driver function:
bdrv_driver_preadv() in block/io.c, passes int64_t, checked by
bdrv_check_qiov_request() to be non-negative.
qcow2_load_vmstate() does bdrv_check_qiov_request().
do_perform_cow_read() has uint64_t argument. And a lot of things in
qcow2 driver are uint64_t, so converting it is big job. But we must
not work with requests that don't satisfy bdrv_check_qiov_request(),
so let's just assert it here.
Still, the functions may be called directly, not only by drv->...
Let's check:
git grep '\.bdrv_\(aio\|co\)_preadv\(_part\)\?\s*=' | \
awk '{print $4}' | sed 's/,//' | sed 's/&//' | sort | uniq | \
while read func; do git grep "$func(" | \
grep -v "$func(BlockDriverState"; done
The only one such caller:
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, &data, 1);
...
ret = bdrv_replace_test_co_preadv(bs, 0, 1, &qiov, 0);
in tests/unit/test-bdrv-drain.c, and it's OK obviously.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20210903102807.27127-4-vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
[eblake: fix typos]
Signed-off-by: Eric Blake <eblake@redhat.com>
2021-09-03 10:27:59 +00:00
|
|
|
int64_t offset, int64_t bytes,
|
|
|
|
QEMUIOVector *qiov, BdrvRequestFlags flags,
|
2018-04-24 19:25:02 +00:00
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
2012-10-26 09:43:58 +00:00
|
|
|
if (s->aio) {
|
2018-04-24 19:25:02 +00:00
|
|
|
return win32_aio_submit(bs, s->aio, s->hfile, offset, bytes, qiov,
|
|
|
|
cb, opaque, QEMU_AIO_READ);
|
2012-10-26 09:43:58 +00:00
|
|
|
} else {
|
2018-04-24 19:25:02 +00:00
|
|
|
return paio_submit(bs, s->hfile, offset, qiov, bytes,
|
2012-10-26 09:43:58 +00:00
|
|
|
cb, opaque, QEMU_AIO_READ);
|
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
2018-04-24 19:25:02 +00:00
|
|
|
static BlockAIOCB *raw_aio_pwritev(BlockDriverState *bs,
|
block: use int64_t instead of uint64_t in driver write handlers
We are generally moving to int64_t for both offset and bytes parameters
on all io paths.
Main motivation is realization of 64-bit write_zeroes operation for
fast zeroing large disk chunks, up to the whole disk.
We chose signed type, to be consistent with off_t (which is signed) and
with possibility for signed return type (where negative value means
error).
So, convert driver write handlers parameters which are already 64bit to
signed type.
While being here, convert also flags parameter to be BdrvRequestFlags.
Now let's consider all callers. Simple
git grep '\->bdrv_\(aio\|co\)_pwritev\(_part\)\?'
shows that's there three callers of driver function:
bdrv_driver_pwritev() and bdrv_driver_pwritev_compressed() in
block/io.c, both pass int64_t, checked by bdrv_check_qiov_request() to
be non-negative.
qcow2_save_vmstate() does bdrv_check_qiov_request().
Still, the functions may be called directly, not only by drv->...
Let's check:
git grep '\.bdrv_\(aio\|co\)_pwritev\(_part\)\?\s*=' | \
awk '{print $4}' | sed 's/,//' | sed 's/&//' | sort | uniq | \
while read func; do git grep "$func(" | \
grep -v "$func(BlockDriverState"; done
shows several callers:
qcow2:
qcow2_co_truncate() write at most up to @offset, which is checked in
generic qcow2_co_truncate() by bdrv_check_request().
qcow2_co_pwritev_compressed_task() pass the request (or part of the
request) that already went through normal write path, so it should
be OK
qcow:
qcow_co_pwritev_compressed() pass int64_t, it's updated by this patch
quorum:
quorum_co_pwrite_zeroes() pass int64_t and int - OK
throttle:
throttle_co_pwritev_compressed() pass int64_t, it's updated by this
patch
vmdk:
vmdk_co_pwritev_compressed() pass int64_t, it's updated by this
patch
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20210903102807.27127-5-vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
2021-09-03 10:28:00 +00:00
|
|
|
int64_t offset, int64_t bytes,
|
|
|
|
QEMUIOVector *qiov, BdrvRequestFlags flags,
|
2018-04-24 19:25:02 +00:00
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
2012-10-26 09:43:58 +00:00
|
|
|
if (s->aio) {
|
2018-04-24 19:25:02 +00:00
|
|
|
return win32_aio_submit(bs, s->aio, s->hfile, offset, bytes, qiov,
|
|
|
|
cb, opaque, QEMU_AIO_WRITE);
|
2012-10-26 09:43:58 +00:00
|
|
|
} else {
|
2018-04-24 19:25:02 +00:00
|
|
|
return paio_submit(bs, s->hfile, offset, qiov, bytes,
|
2012-10-26 09:43:58 +00:00
|
|
|
cb, opaque, QEMU_AIO_WRITE);
|
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
2014-10-07 11:59:14 +00:00
|
|
|
static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
|
2014-10-07 11:59:15 +00:00
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
2012-06-09 02:48:28 +00:00
|
|
|
return paio_submit(bs, s->hfile, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void raw_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
2014-05-08 14:34:49 +00:00
|
|
|
|
|
|
|
if (s->aio) {
|
2014-05-08 14:34:50 +00:00
|
|
|
win32_aio_detach_aio_context(s->aio, bdrv_get_aio_context(bs));
|
2014-05-08 14:34:49 +00:00
|
|
|
win32_aio_cleanup(s->aio);
|
|
|
|
s->aio = NULL;
|
|
|
|
}
|
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
CloseHandle(s->hfile);
|
2014-04-11 17:16:36 +00:00
|
|
|
if (bs->open_flags & BDRV_O_TEMPORARY) {
|
|
|
|
unlink(bs->filename);
|
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
block: Convert .bdrv_truncate callback to coroutine_fn
bdrv_truncate() is an operation that can block (even for a quite long
time, depending on the PreallocMode) in I/O paths that shouldn't block.
Convert it to a coroutine_fn so that we have the infrastructure for
drivers to make their .bdrv_co_truncate implementation asynchronous.
This change could potentially introduce new race conditions because
bdrv_truncate() isn't necessarily executed atomically any more. Whether
this is a problem needs to be evaluated for each block driver that
supports truncate:
* file-posix/win32, gluster, iscsi, nfs, rbd, ssh, sheepdog: The
protocol drivers are trivially safe because they don't actually yield
yet, so there is no change in behaviour.
* copy-on-read, crypto, raw-format: Essentially just filter drivers that
pass the request to a child node, no problem.
* qcow2: The implementation modifies metadata, so it needs to hold
s->lock to be safe with concurrent I/O requests. In order to avoid
double locking, this requires pulling the locking out into
preallocate_co() and using qcow2_write_caches() instead of
bdrv_flush().
* qed: Does a single header update, this is fine without locking.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
2018-06-21 15:54:35 +00:00
|
|
|
static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
|
2019-09-18 09:51:40 +00:00
|
|
|
bool exact, PreallocMode prealloc,
|
2020-04-24 12:54:39 +00:00
|
|
|
BdrvRequestFlags flags, Error **errp)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
2009-04-05 18:03:31 +00:00
|
|
|
LONG low, high;
|
2012-12-10 11:56:22 +00:00
|
|
|
DWORD dwPtrLow;
|
2007-12-15 17:28:36 +00:00
|
|
|
|
2017-06-13 20:20:52 +00:00
|
|
|
if (prealloc != PREALLOC_MODE_OFF) {
|
|
|
|
error_setg(errp, "Unsupported preallocation mode '%s'",
|
2017-08-24 08:46:08 +00:00
|
|
|
PreallocMode_str(prealloc));
|
2017-06-13 20:20:52 +00:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
low = offset;
|
|
|
|
high = offset >> 32;
|
2012-12-10 11:56:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* An error has occurred if the return value is INVALID_SET_FILE_POINTER
|
|
|
|
* and GetLastError doesn't return NO_ERROR.
|
|
|
|
*/
|
|
|
|
dwPtrLow = SetFilePointer(s->hfile, low, &high, FILE_BEGIN);
|
|
|
|
if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
|
2017-03-28 20:51:28 +00:00
|
|
|
error_setg_win32(errp, GetLastError(), "SetFilePointer error");
|
2012-12-10 11:56:22 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
if (SetEndOfFile(s->hfile) == 0) {
|
2017-03-28 20:51:28 +00:00
|
|
|
error_setg_win32(errp, GetLastError(), "SetEndOfFile error");
|
2007-12-15 17:28:36 +00:00
|
|
|
return -EIO;
|
2012-12-10 11:56:22 +00:00
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t raw_getlength(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
LARGE_INTEGER l;
|
|
|
|
ULARGE_INTEGER available, total, total_free;
|
|
|
|
DISK_GEOMETRY_EX dg;
|
|
|
|
DWORD count;
|
|
|
|
BOOL status;
|
|
|
|
|
|
|
|
switch(s->type) {
|
|
|
|
case FTYPE_FILE:
|
2009-04-05 18:03:31 +00:00
|
|
|
l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
|
2007-12-15 17:28:36 +00:00
|
|
|
if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
|
|
|
|
return -EIO;
|
|
|
|
break;
|
|
|
|
case FTYPE_CD:
|
|
|
|
if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free))
|
|
|
|
return -EIO;
|
|
|
|
l.QuadPart = total.QuadPart;
|
|
|
|
break;
|
|
|
|
case FTYPE_HARDDISK:
|
|
|
|
status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
|
|
|
|
NULL, 0, &dg, sizeof(dg), &count, NULL);
|
|
|
|
if (status != 0) {
|
|
|
|
l = dg.DiskSize;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
return l.QuadPart;
|
|
|
|
}
|
|
|
|
|
2011-07-12 11:56:39 +00:00
|
|
|
static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
|
|
|
|
DWORD * high);
|
|
|
|
get_compressed_t get_compressed;
|
|
|
|
struct _stati64 st;
|
|
|
|
const char *filename = bs->filename;
|
|
|
|
/* WinNT support GetCompressedFileSize to determine allocate size */
|
|
|
|
get_compressed =
|
|
|
|
(get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
|
|
|
|
"GetCompressedFileSizeA");
|
|
|
|
if (get_compressed) {
|
|
|
|
DWORD high, low;
|
|
|
|
low = get_compressed(filename, &high);
|
|
|
|
if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) {
|
|
|
|
return (((int64_t) high) << 32) + low;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_stati64(filename, &st) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return st.st_size;
|
|
|
|
}
|
|
|
|
|
2018-02-05 15:24:32 +00:00
|
|
|
static int raw_co_create(BlockdevCreateOptions *options, Error **errp)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
2018-02-05 15:24:32 +00:00
|
|
|
BlockdevCreateOptionsFile *file_opts;
|
2007-12-15 17:28:36 +00:00
|
|
|
int fd;
|
|
|
|
|
2018-02-05 15:24:32 +00:00
|
|
|
assert(options->driver == BLOCKDEV_DRIVER_FILE);
|
|
|
|
file_opts = &options->u.file;
|
2014-03-05 21:41:40 +00:00
|
|
|
|
2018-02-05 15:24:32 +00:00
|
|
|
if (file_opts->has_preallocation) {
|
|
|
|
error_setg(errp, "Preallocation is not supported on Windows");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (file_opts->has_nocow) {
|
|
|
|
error_setg(errp, "nocow is not supported on Windows");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
|
2020-07-01 14:22:43 +00:00
|
|
|
fd = qemu_create(file_opts->filename, O_WRONLY | O_TRUNC | O_BINARY,
|
|
|
|
0644, errp);
|
2013-10-10 13:44:02 +00:00
|
|
|
if (fd < 0) {
|
2007-12-15 17:28:36 +00:00
|
|
|
return -EIO;
|
2013-10-10 13:44:02 +00:00
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
set_sparse(fd);
|
2018-02-05 15:24:32 +00:00
|
|
|
ftruncate(fd, file_opts->size);
|
2012-08-14 20:43:46 +00:00
|
|
|
qemu_close(fd);
|
2018-02-05 15:24:32 +00:00
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-03-26 01:12:17 +00:00
|
|
|
static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
|
|
|
|
const char *filename,
|
|
|
|
QemuOpts *opts,
|
2018-02-05 15:24:32 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
BlockdevCreateOptions options;
|
|
|
|
int64_t total_size = 0;
|
|
|
|
|
|
|
|
strstart(filename, "file:", &filename);
|
|
|
|
|
|
|
|
/* Read out options */
|
|
|
|
total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
|
|
|
|
BDRV_SECTOR_SIZE);
|
|
|
|
|
|
|
|
options = (BlockdevCreateOptions) {
|
|
|
|
.driver = BLOCKDEV_DRIVER_FILE,
|
|
|
|
.u.file = {
|
|
|
|
.filename = (char *) filename,
|
|
|
|
.size = total_size,
|
|
|
|
.has_preallocation = false,
|
|
|
|
.has_nocow = false,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
return raw_co_create(&options, errp);
|
|
|
|
}
|
2014-06-05 09:21:02 +00:00
|
|
|
|
2021-08-25 17:36:25 +00:00
|
|
|
static int raw_reopen_prepare(BDRVReopenState *state,
|
|
|
|
BlockReopenQueue *queue, Error **errp)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = state->bs->opaque;
|
|
|
|
BDRVRawReopenState *rs;
|
|
|
|
int access_flags;
|
|
|
|
DWORD overlapped;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (s->type != FTYPE_FILE) {
|
|
|
|
error_setg(errp, "Can only reopen files");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rs = g_new0(BDRVRawReopenState, 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We do not support changing any options (only flags). By leaving
|
|
|
|
* all options in state->options, we tell the generic reopen code
|
|
|
|
* that we do not support changing any of them, so it will verify
|
|
|
|
* that their values did not change.
|
|
|
|
*/
|
|
|
|
|
|
|
|
raw_parse_flags(state->flags, s->aio != NULL, &access_flags, &overlapped);
|
|
|
|
rs->hfile = CreateFile(state->bs->filename, access_flags,
|
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
|
|
OPEN_EXISTING, overlapped, NULL);
|
|
|
|
|
|
|
|
if (rs->hfile == INVALID_HANDLE_VALUE) {
|
|
|
|
int err = GetLastError();
|
|
|
|
|
|
|
|
error_setg_win32(errp, err, "Could not reopen '%s'",
|
|
|
|
state->bs->filename);
|
|
|
|
if (err == ERROR_ACCESS_DENIED) {
|
|
|
|
ret = -EACCES;
|
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->aio) {
|
|
|
|
ret = win32_aio_attach(s->aio, rs->hfile);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "Could not enable AIO");
|
|
|
|
CloseHandle(rs->hfile);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
state->opaque = rs;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
g_free(rs);
|
|
|
|
state->opaque = NULL;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void raw_reopen_commit(BDRVReopenState *state)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = state->bs->opaque;
|
|
|
|
BDRVRawReopenState *rs = state->opaque;
|
|
|
|
|
|
|
|
assert(rs != NULL);
|
|
|
|
|
|
|
|
CloseHandle(s->hfile);
|
|
|
|
s->hfile = rs->hfile;
|
|
|
|
|
|
|
|
g_free(rs);
|
|
|
|
state->opaque = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void raw_reopen_abort(BDRVReopenState *state)
|
|
|
|
{
|
|
|
|
BDRVRawReopenState *rs = state->opaque;
|
|
|
|
|
|
|
|
if (!rs) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rs->hfile != INVALID_HANDLE_VALUE) {
|
|
|
|
CloseHandle(rs->hfile);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(rs);
|
|
|
|
state->opaque = NULL;
|
|
|
|
}
|
|
|
|
|
2014-06-05 09:21:02 +00:00
|
|
|
static QemuOptsList raw_create_opts = {
|
|
|
|
.name = "raw-create-opts",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_SIZE,
|
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Virtual disk size"
|
|
|
|
},
|
|
|
|
{ /* end of list */ }
|
|
|
|
}
|
2009-05-18 14:42:10 +00:00
|
|
|
};
|
|
|
|
|
2014-12-02 17:32:41 +00:00
|
|
|
BlockDriver bdrv_file = {
|
2010-04-07 20:30:24 +00:00
|
|
|
.format_name = "file",
|
|
|
|
.protocol_name = "file",
|
2009-04-07 18:23:51 +00:00
|
|
|
.instance_size = sizeof(BDRVRawState),
|
2013-09-24 15:07:04 +00:00
|
|
|
.bdrv_needs_filename = true,
|
2014-03-05 21:41:39 +00:00
|
|
|
.bdrv_parse_filename = raw_parse_filename,
|
2014-06-05 09:21:02 +00:00
|
|
|
.bdrv_file_open = raw_open,
|
2016-06-23 22:37:16 +00:00
|
|
|
.bdrv_refresh_limits = raw_probe_alignment,
|
2014-06-05 09:21:02 +00:00
|
|
|
.bdrv_close = raw_close,
|
2018-01-18 12:43:45 +00:00
|
|
|
.bdrv_co_create_opts = raw_co_create_opts,
|
2013-06-28 10:47:42 +00:00
|
|
|
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
2011-11-10 16:25:44 +00:00
|
|
|
|
2021-08-25 17:36:25 +00:00
|
|
|
.bdrv_reopen_prepare = raw_reopen_prepare,
|
|
|
|
.bdrv_reopen_commit = raw_reopen_commit,
|
|
|
|
.bdrv_reopen_abort = raw_reopen_abort,
|
|
|
|
|
2018-04-24 19:25:02 +00:00
|
|
|
.bdrv_aio_preadv = raw_aio_preadv,
|
|
|
|
.bdrv_aio_pwritev = raw_aio_pwritev,
|
2012-06-09 02:48:28 +00:00
|
|
|
.bdrv_aio_flush = raw_aio_flush,
|
2011-11-10 16:25:44 +00:00
|
|
|
|
block: Convert .bdrv_truncate callback to coroutine_fn
bdrv_truncate() is an operation that can block (even for a quite long
time, depending on the PreallocMode) in I/O paths that shouldn't block.
Convert it to a coroutine_fn so that we have the infrastructure for
drivers to make their .bdrv_co_truncate implementation asynchronous.
This change could potentially introduce new race conditions because
bdrv_truncate() isn't necessarily executed atomically any more. Whether
this is a problem needs to be evaluated for each block driver that
supports truncate:
* file-posix/win32, gluster, iscsi, nfs, rbd, ssh, sheepdog: The
protocol drivers are trivially safe because they don't actually yield
yet, so there is no change in behaviour.
* copy-on-read, crypto, raw-format: Essentially just filter drivers that
pass the request to a child node, no problem.
* qcow2: The implementation modifies metadata, so it needs to hold
s->lock to be safe with concurrent I/O requests. In order to avoid
double locking, this requires pulling the locking out into
preallocate_co() and using qcow2_write_caches() instead of
bdrv_flush().
* qed: Does a single header update, this is fine without locking.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
2018-06-21 15:54:35 +00:00
|
|
|
.bdrv_co_truncate = raw_co_truncate,
|
2009-04-07 18:23:51 +00:00
|
|
|
.bdrv_getlength = raw_getlength,
|
2011-07-12 11:56:39 +00:00
|
|
|
.bdrv_get_allocated_file_size
|
|
|
|
= raw_get_allocated_file_size,
|
2009-05-18 14:42:10 +00:00
|
|
|
|
2014-06-05 09:21:02 +00:00
|
|
|
.create_opts = &raw_create_opts,
|
2007-12-15 17:28:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/***********************************************/
|
|
|
|
/* host device */
|
|
|
|
|
|
|
|
static int find_cdrom(char *cdrom_name, int cdrom_name_size)
|
|
|
|
{
|
|
|
|
char drives[256], *pdrv = drives;
|
|
|
|
UINT type;
|
|
|
|
|
|
|
|
memset(drives, 0, sizeof(drives));
|
|
|
|
GetLogicalDriveStrings(sizeof(drives), drives);
|
|
|
|
while(pdrv[0] != '\0') {
|
|
|
|
type = GetDriveType(pdrv);
|
|
|
|
switch(type) {
|
|
|
|
case DRIVE_CDROM:
|
|
|
|
snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pdrv += lstrlen(pdrv) + 1;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_device_type(BlockDriverState *bs, const char *filename)
|
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
UINT type;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
if (strstart(filename, "\\\\.\\", &p) ||
|
|
|
|
strstart(filename, "//./", &p)) {
|
|
|
|
if (stristart(p, "PhysicalDrive", NULL))
|
|
|
|
return FTYPE_HARDDISK;
|
|
|
|
snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]);
|
|
|
|
type = GetDriveType(s->drive_path);
|
2009-04-07 01:24:53 +00:00
|
|
|
switch (type) {
|
|
|
|
case DRIVE_REMOVABLE:
|
|
|
|
case DRIVE_FIXED:
|
|
|
|
return FTYPE_HARDDISK;
|
|
|
|
case DRIVE_CDROM:
|
2007-12-15 17:28:36 +00:00
|
|
|
return FTYPE_CD;
|
2009-04-07 01:24:53 +00:00
|
|
|
default:
|
2007-12-15 17:28:36 +00:00
|
|
|
return FTYPE_FILE;
|
2009-04-07 01:24:53 +00:00
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
} else {
|
|
|
|
return FTYPE_FILE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-15 12:04:22 +00:00
|
|
|
static int hdev_probe_device(const char *filename)
|
|
|
|
{
|
|
|
|
if (strstart(filename, "/dev/cdrom", NULL))
|
|
|
|
return 100;
|
|
|
|
if (is_windows_drive(filename))
|
|
|
|
return 100;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-07 23:39:45 +00:00
|
|
|
static void hdev_parse_filename(const char *filename, QDict *options,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2017-05-22 19:52:16 +00:00
|
|
|
bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
|
2014-03-07 23:39:45 +00:00
|
|
|
}
|
|
|
|
|
2018-04-24 19:25:02 +00:00
|
|
|
static void hdev_refresh_limits(BlockDriverState *bs, Error **errp)
|
|
|
|
{
|
|
|
|
/* XXX Does Windows support AIO on less than 512-byte alignment? */
|
|
|
|
bs->bl.request_alignment = 512;
|
|
|
|
}
|
|
|
|
|
2013-09-05 12:22:29 +00:00
|
|
|
static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
2007-12-15 17:28:36 +00:00
|
|
|
{
|
|
|
|
BDRVRawState *s = bs->opaque;
|
|
|
|
int access_flags, create_flags;
|
2013-09-01 20:59:25 +00:00
|
|
|
int ret = 0;
|
2007-12-15 17:28:36 +00:00
|
|
|
DWORD overlapped;
|
|
|
|
char device_name[64];
|
2013-09-01 20:59:25 +00:00
|
|
|
|
|
|
|
Error *local_err = NULL;
|
|
|
|
const char *filename;
|
2016-09-08 13:09:01 +00:00
|
|
|
bool use_aio;
|
2013-09-01 20:59:25 +00:00
|
|
|
|
2014-01-02 02:49:17 +00:00
|
|
|
QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0,
|
|
|
|
&error_abort);
|
2020-07-07 16:06:03 +00:00
|
|
|
if (!qemu_opts_absorb_qdict(opts, options, errp)) {
|
2013-09-01 20:59:25 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
filename = qemu_opt_get(opts, "filename");
|
2007-12-15 17:28:36 +00:00
|
|
|
|
2016-09-08 13:09:01 +00:00
|
|
|
use_aio = get_aio_option(opts, flags, &local_err);
|
|
|
|
if (!local_err && use_aio) {
|
|
|
|
error_setg(&local_err, "AIO is not supported on Windows host devices");
|
|
|
|
}
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
if (strstart(filename, "/dev/cdrom", NULL)) {
|
2013-09-01 20:59:25 +00:00
|
|
|
if (find_cdrom(device_name, sizeof(device_name)) < 0) {
|
2013-10-10 13:44:02 +00:00
|
|
|
error_setg(errp, "Could not open CD-ROM drive");
|
2013-09-01 20:59:25 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto done;
|
|
|
|
}
|
2007-12-15 17:28:36 +00:00
|
|
|
filename = device_name;
|
|
|
|
} else {
|
|
|
|
/* transform drive letters into device name */
|
|
|
|
if (((filename[0] >= 'a' && filename[0] <= 'z') ||
|
|
|
|
(filename[0] >= 'A' && filename[0] <= 'Z')) &&
|
|
|
|
filename[1] == ':' && filename[2] == '\0') {
|
|
|
|
snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]);
|
|
|
|
filename = device_name;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s->type = find_device_type(bs, filename);
|
|
|
|
|
2016-09-08 13:09:01 +00:00
|
|
|
raw_parse_flags(flags, use_aio, &access_flags, &overlapped);
|
2012-09-20 19:13:21 +00:00
|
|
|
|
2007-12-15 17:28:36 +00:00
|
|
|
create_flags = OPEN_EXISTING;
|
|
|
|
|
|
|
|
s->hfile = CreateFile(filename, access_flags,
|
|
|
|
FILE_SHARE_READ, NULL,
|
|
|
|
create_flags, overlapped, NULL);
|
|
|
|
if (s->hfile == INVALID_HANDLE_VALUE) {
|
|
|
|
int err = GetLastError();
|
|
|
|
|
2013-09-01 20:59:25 +00:00
|
|
|
if (err == ERROR_ACCESS_DENIED) {
|
|
|
|
ret = -EACCES;
|
|
|
|
} else {
|
2013-10-11 12:30:16 +00:00
|
|
|
ret = -EINVAL;
|
2013-09-01 20:59:25 +00:00
|
|
|
}
|
2013-10-11 12:30:16 +00:00
|
|
|
error_setg_errno(errp, -ret, "Could not open device");
|
2013-09-01 20:59:25 +00:00
|
|
|
goto done;
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
2013-09-01 20:59:25 +00:00
|
|
|
|
|
|
|
done:
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return ret;
|
2007-12-15 17:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-05-09 22:03:42 +00:00
|
|
|
static BlockDriver bdrv_host_device = {
|
2009-03-07 22:00:29 +00:00
|
|
|
.format_name = "host_device",
|
2010-04-07 20:30:24 +00:00
|
|
|
.protocol_name = "host_device",
|
2009-03-07 22:00:29 +00:00
|
|
|
.instance_size = sizeof(BDRVRawState),
|
2013-09-24 15:07:04 +00:00
|
|
|
.bdrv_needs_filename = true,
|
2014-03-07 23:39:45 +00:00
|
|
|
.bdrv_parse_filename = hdev_parse_filename,
|
2009-06-15 12:04:22 +00:00
|
|
|
.bdrv_probe_device = hdev_probe_device,
|
2010-04-14 12:17:38 +00:00
|
|
|
.bdrv_file_open = hdev_open,
|
2009-03-07 22:00:29 +00:00
|
|
|
.bdrv_close = raw_close,
|
2018-04-24 19:25:02 +00:00
|
|
|
.bdrv_refresh_limits = hdev_refresh_limits,
|
2007-12-15 17:28:36 +00:00
|
|
|
|
2018-04-24 19:25:02 +00:00
|
|
|
.bdrv_aio_preadv = raw_aio_preadv,
|
|
|
|
.bdrv_aio_pwritev = raw_aio_pwritev,
|
2012-06-09 02:48:28 +00:00
|
|
|
.bdrv_aio_flush = raw_aio_flush,
|
2011-11-10 16:25:44 +00:00
|
|
|
|
2014-05-08 14:34:50 +00:00
|
|
|
.bdrv_detach_aio_context = raw_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = raw_attach_aio_context,
|
|
|
|
|
block: Avoid unecessary drv->bdrv_getlength() calls
The block layer generally keeps the size of an image cached in
bs->total_sectors so that it doesn't have to perform expensive
operations to get the size whenever it needs it.
This doesn't work however when using a backend that can change its size
without qemu being aware of it, i.e. passthrough of removable media like
CD-ROMs or floppy disks. For this reason, the caching is disabled when a
removable device is used.
It is obvious that checking whether the _guest_ device has removable
media isn't the right thing to do when we want to know whether the size
of the host backend can change. To make things worse, non-top-level
BlockDriverStates never have any device attached, which makes qemu
assume they are removable, so drv->bdrv_getlength() is always called on
the protocol layer. In the case of raw-posix, this causes unnecessary
lseek() system calls, which turned out to be rather expensive.
This patch completely changes the logic and disables bs->total_sectors
caching only for certain block driver types, for which a size change is
expected: host_cdrom and host_floppy on POSIX, host_device on win32; also
the raw format in case it sits on top of one of these protocols, but in
the common case the nested bdrv_getlength() call on the protocol driver
will use the cache again and avoid an expensive drv->bdrv_getlength()
call.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
2013-10-29 11:18:58 +00:00
|
|
|
.bdrv_getlength = raw_getlength,
|
|
|
|
.has_variable_length = true,
|
|
|
|
|
2011-07-12 11:56:39 +00:00
|
|
|
.bdrv_get_allocated_file_size
|
|
|
|
= raw_get_allocated_file_size,
|
2007-12-15 17:28:36 +00:00
|
|
|
};
|
2009-05-09 22:03:42 +00:00
|
|
|
|
2010-04-07 20:30:24 +00:00
|
|
|
static void bdrv_file_init(void)
|
2009-05-09 22:03:42 +00:00
|
|
|
{
|
2010-04-07 20:30:24 +00:00
|
|
|
bdrv_register(&bdrv_file);
|
2009-05-09 22:03:42 +00:00
|
|
|
bdrv_register(&bdrv_host_device);
|
|
|
|
}
|
|
|
|
|
2010-04-07 20:30:24 +00:00
|
|
|
block_init(bdrv_file_init);
|