#include "config-host.h"

#include "qemu-common.h"

#include "trace.h"

#include "monitor.h"

#include "block_int.h"

#include "blockjob.h"

#include "module.h"

#include "qjson.h"

#include "sysemu.h"

#include "notify.h"

#include "qemu-coroutine.h"

#include "qmp-commands.h"

#include "qemu-timer.h"

#ifdef CONFIG_BSD

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/ioctl.h>

#include <sys/queue.h>

#ifndef __DragonFly__

#include <sys/disk.h>

#ifdef _WIN32

#include <windows.h>

#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */

typedef enum {

BDRV_REQ_COPY_ON_READ = 0x1,

BDRV_REQ_ZERO_WRITE = 0x2,

} BdrvRequestFlags;

static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);

static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,

int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

BlockDriverCompletionFunc *cb, void *opaque);

static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,

int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

BlockDriverCompletionFunc *cb, void *opaque);

static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,

int64_t sector_num, int nb_sectors,

QEMUIOVector *iov);

static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,

int64_t sector_num, int nb_sectors,

QEMUIOVector *iov);

static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,

int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

BdrvRequestFlags flags);

static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,

int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

BdrvRequestFlags flags);

static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,

int64_t sector_num,

QEMUIOVector *qiov,

int nb_sectors,

BlockDriverCompletionFunc *cb,

void *opaque,

bool is_write);

static void coroutine_fn bdrv_co_do_rw(void *opaque);

static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,

int64_t sector_num, int nb_sectors);

static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,

bool is_write, double elapsed_time, uint64_t *wait);

static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,

double elapsed_time, uint64_t *wait);

static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,

bool is_write, int64_t *wait);

static QTAILQ_HEAD(, BlockDriverState) bdrv_states =

QTAILQ_HEAD_INITIALIZER(bdrv_states);

static QLIST_HEAD(, BlockDriver) bdrv_drivers =

QLIST_HEAD_INITIALIZER(bdrv_drivers);

static BlockDriverState *bs_snapshots;

static int use_bdrv_whitelist;

#ifdef _WIN32

static int is_windows_drive_prefix(const char *filename)

{

return (((filename[0] >= 'a' && filename[0] <= 'z') ||

(filename[0] >= 'A' && filename[0] <= 'Z')) &&

filename[1] == ':');

}

int is_windows_drive(const char *filename)

{

if (is_windows_drive_prefix(filename) &&

filename[2] == '\0')

return 1;

if (strstart(filename, "\\\\.\\", NULL) ||

strstart(filename, "//./", NULL))

return 1;

return 0;

}

void bdrv_io_limits_disable(BlockDriverState *bs)

{

bs->io_limits_enabled = false;

while (qemu_co_queue_next(&bs->throttled_reqs));

if (bs->block_timer) {

qemu_del_timer(bs->block_timer);

qemu_free_timer(bs->block_timer);

bs->block_timer = NULL;

}

bs->slice_start = 0;

bs->slice_end = 0;

bs->slice_time = 0;

memset(&bs->io_base, 0, sizeof(bs->io_base));

}

static void bdrv_block_timer(void *opaque)

{

BlockDriverState *bs = opaque;

qemu_co_queue_next(&bs->throttled_reqs);

}

void bdrv_io_limits_enable(BlockDriverState *bs)

{

qemu_co_queue_init(&bs->throttled_reqs);

bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);

bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;

bs->slice_start = qemu_get_clock_ns(vm_clock);

bs->slice_end = bs->slice_start + bs->slice_time;

memset(&bs->io_base, 0, sizeof(bs->io_base));

bs->io_limits_enabled = true;

}

bool bdrv_io_limits_enabled(BlockDriverState *bs)

{

BlockIOLimit *io_limits = &bs->io_limits;

return io_limits->bps[BLOCK_IO_LIMIT_READ]

|| io_limits->bps[BLOCK_IO_LIMIT_WRITE]

|| io_limits->bps[BLOCK_IO_LIMIT_TOTAL]

|| io_limits->iops[BLOCK_IO_LIMIT_READ]

|| io_limits->iops[BLOCK_IO_LIMIT_WRITE]

|| io_limits->iops[BLOCK_IO_LIMIT_TOTAL];

}

static void bdrv_io_limits_intercept(BlockDriverState *bs,

bool is_write, int nb_sectors)

{

int64_t wait_time = -1;

if (!qemu_co_queue_empty(&bs->throttled_reqs)) {

qemu_co_queue_wait(&bs->throttled_reqs);

}

/* In fact, we hope to keep each request's timing, in FIFO mode. The next

while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {

qemu_mod_timer(bs->block_timer,

wait_time + qemu_get_clock_ns(vm_clock));

qemu_co_queue_wait_insert_head(&bs->throttled_reqs);

}

qemu_co_queue_next(&bs->throttled_reqs);

}

static int path_has_protocol(const char *path)

{

const char *p;

#ifdef _WIN32

if (is_windows_drive(path) ||

is_windows_drive_prefix(path)) {

return 0;

}

p = path + strcspn(path, ":/\\");

p = path + strcspn(path, ":/");

return *p == ':';

}

int path_is_absolute(const char *path)

{

#ifdef _WIN32

/* specific case for names like: "\\.\d:" */

if (is_windows_drive(path) || is_windows_drive_prefix(path)) {

return 1;

}

return (*path == '/' || *path == '\\');

return (*path == '/');

}

void path_combine(char *dest, int dest_size,

const char *base_path,

const char *filename)

{

const char *p, *p1;

int len;

if (dest_size <= 0)

return;

if (path_is_absolute(filename)) {

pstrcpy(dest, dest_size, filename);

} else {

p = strchr(base_path, ':');

if (p)

p++;

else

p = base_path;

p1 = strrchr(base_path, '/');

#ifdef _WIN32

{

const char *p2;

p2 = strrchr(base_path, '\\');

if (!p1 || p2 > p1)

p1 = p2;

}

if (p1)

p1++;

else

p1 = base_path;

if (p1 > p)

p = p1;

len = p - base_path;

if (len > dest_size - 1)

len = dest_size - 1;

memcpy(dest, base_path, len);

dest[len] = '\0';

pstrcat(dest, dest_size, filename);

}

}

void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)

{

if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {

pstrcpy(dest, sz, bs->backing_file);

} else {

path_combine(dest, sz, bs->filename, bs->backing_file);

}

}

void bdrv_register(BlockDriver *bdrv)

{

/* Block drivers without coroutine functions need emulation */

if (!bdrv->bdrv_co_readv) {

bdrv->bdrv_co_readv = bdrv_co_readv_em;

bdrv->bdrv_co_writev = bdrv_co_writev_em;

/* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if

if (!bdrv->bdrv_aio_readv) {

/* add AIO emulation layer */

bdrv->bdrv_aio_readv = bdrv_aio_readv_em;

bdrv->bdrv_aio_writev = bdrv_aio_writev_em;

}

}

QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);

}

BlockDriverState *bdrv_new(const char *device_name)

{

BlockDriverState *bs;

bs = g_malloc0(sizeof(BlockDriverState));

pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);

if (device_name[0] != '\0') {

QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);

}

bdrv_iostatus_disable(bs);

notifier_list_init(&bs->close_notifiers);

return bs;

}

void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)

{

notifier_list_add(&bs->close_notifiers, notify);

}

BlockDriver *bdrv_find_format(const char *format_name)

{

BlockDriver *drv1;

QLIST_FOREACH(drv1, &bdrv_drivers, list) {

if (!strcmp(drv1->format_name, format_name)) {

return drv1;

}

}

return NULL;

}

static int bdrv_is_whitelisted(BlockDriver *drv)

{

static const char *whitelist[] = {

CONFIG_BDRV_WHITELIST

};

const char **p;

if (!whitelist[0])

return 1; /* no whitelist, anything goes */

for (p = whitelist; *p; p++) {

if (!strcmp(drv->format_name, *p)) {

return 1;

}

}

return 0;

}

BlockDriver *bdrv_find_whitelisted_format(const char *format_name)

{

BlockDriver *drv = bdrv_find_format(format_name);

return drv && bdrv_is_whitelisted(drv) ? drv : NULL;

}

typedef struct CreateCo {

BlockDriver *drv;

char *filename;

QEMUOptionParameter *options;

int ret;

} CreateCo;

static void coroutine_fn bdrv_create_co_entry(void *opaque)

{

CreateCo *cco = opaque;

assert(cco->drv);

cco->ret = cco->drv->bdrv_create(cco->filename, cco->options);

}

int bdrv_create(BlockDriver *drv, const char* filename,

QEMUOptionParameter *options)

{

int ret;

Coroutine *co;

CreateCo cco = {

.drv = drv,

.filename = g_strdup(filename),

.options = options,

.ret = NOT_DONE,

};

if (!drv->bdrv_create) {

ret = -ENOTSUP;

goto out;

}

if (qemu_in_coroutine()) {

/* Fast-path if already in coroutine context */

bdrv_create_co_entry(&cco);

} else {

co = qemu_coroutine_create(bdrv_create_co_entry);

qemu_coroutine_enter(co, &cco);

while (cco.ret == NOT_DONE) {

qemu_aio_wait();

}

}

ret = cco.ret;

out:

g_free(cco.filename);

return ret;

}

int bdrv_create_file(const char* filename, QEMUOptionParameter *options)

{

BlockDriver *drv;

drv = bdrv_find_protocol(filename);

if (drv == NULL) {

return -ENOENT;

}

return bdrv_create(drv, filename, options);

}

int get_tmp_filename(char *filename, int size)

{

#ifdef _WIN32

char temp_dir[MAX_PATH];

/* GetTempFileName requires that its output buffer (4th param)

assert(size >= MAX_PATH);

return (GetTempPath(MAX_PATH, temp_dir)

&& GetTempFileName(temp_dir, "qem", 0, filename)

? 0 : -GetLastError());

int fd;

const char *tmpdir;

tmpdir = getenv("TMPDIR");

if (!tmpdir)

tmpdir = "/tmp";

if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {

return -EOVERFLOW;

}

fd = mkstemp(filename);

if (fd < 0) {

return -errno;

}

if (close(fd) != 0) {

unlink(filename);

return -errno;

}

return 0;

}

static BlockDriver *find_hdev_driver(const char *filename)

{

int score_max = 0, score;

BlockDriver *drv = NULL, *d;

QLIST_FOREACH(d, &bdrv_drivers, list) {

if (d->bdrv_probe_device) {

score = d->bdrv_probe_device(filename);

if (score > score_max) {

score_max = score;

drv = d;

}

}

}

return drv;

}

BlockDriver *bdrv_find_protocol(const char *filename)

{

BlockDriver *drv1;

char protocol[128];

int len;

const char *p;

/* TODO Drivers without bdrv_file_open must be specified explicitly */

/*

drv1 = find_hdev_driver(filename);

if (drv1) {

return drv1;

}

if (!path_has_protocol(filename)) {

return bdrv_find_format("file");

}

p = strchr(filename, ':');

assert(p != NULL);

len = p - filename;

if (len > sizeof(protocol) - 1)

len = sizeof(protocol) - 1;

memcpy(protocol, filename, len);

protocol[len] = '\0';

QLIST_FOREACH(drv1, &bdrv_drivers, list) {

if (drv1->protocol_name &&

!strcmp(drv1->protocol_name, protocol)) {

return drv1;

}

}

return NULL;

}

static int find_image_format(const char *filename, BlockDriver **pdrv)

{

int ret, score, score_max;

BlockDriver *drv1, *drv;

uint8_t buf[2048];

BlockDriverState *bs;

ret = bdrv_file_open(&bs, filename, 0);

if (ret < 0) {

*pdrv = NULL;

return ret;

}

/* Return the raw BlockDriver * to scsi-generic devices or empty drives */

if (bs->sg || !bdrv_is_inserted(bs)) {

bdrv_delete(bs);

drv = bdrv_find_format("raw");

if (!drv) {

ret = -ENOENT;

}

*pdrv = drv;

return ret;

}

ret = bdrv_pread(bs, 0, buf, sizeof(buf));

bdrv_delete(bs);

if (ret < 0) {

*pdrv = NULL;

return ret;

}

score_max = 0;

drv = NULL;

QLIST_FOREACH(drv1, &bdrv_drivers, list) {

if (drv1->bdrv_probe) {

score = drv1->bdrv_probe(buf, ret, filename);

if (score > score_max) {

score_max = score;

drv = drv1;

}

}

}

if (!drv) {

ret = -ENOENT;

}

*pdrv = drv;

return ret;

}

static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)

{

BlockDriver *drv = bs->drv;

/* Do not attempt drv->bdrv_getlength() on scsi-generic devices */

if (bs->sg)

return 0;

/* query actual device if possible, otherwise just trust the hint */

if (drv->bdrv_getlength) {

int64_t length = drv->bdrv_getlength(bs);

if (length < 0) {

return length;

}

hint = length >> BDRV_SECTOR_BITS;

}

bs->total_sectors = hint;

return 0;

}

int bdrv_parse_cache_flags(const char *mode, int *flags)

{

*flags &= ~BDRV_O_CACHE_MASK;

if (!strcmp(mode, "off") || !strcmp(mode, "none")) {

*flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;

} else if (!strcmp(mode, "directsync")) {

*flags |= BDRV_O_NOCACHE;

} else if (!strcmp(mode, "writeback")) {

*flags |= BDRV_O_CACHE_WB;

} else if (!strcmp(mode, "unsafe")) {

*flags |= BDRV_O_CACHE_WB;

*flags |= BDRV_O_NO_FLUSH;

} else if (!strcmp(mode, "writethrough")) {

/* this is the default */

} else {

return -1;

}

return 0;

}

void bdrv_enable_copy_on_read(BlockDriverState *bs)

{

bs->copy_on_read++;

}

void bdrv_disable_copy_on_read(BlockDriverState *bs)

{

assert(bs->copy_on_read > 0);

bs->copy_on_read--;

}

static int bdrv_open_common(BlockDriverState *bs, const char *filename,

int flags, BlockDriver *drv)

{

int ret, open_flags;

assert(drv != NULL);

assert(bs->file == NULL);

trace_bdrv_open_common(bs, filename, flags, drv->format_name);

bs->open_flags = flags;

bs->buffer_alignment = 512;

assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */

if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {

bdrv_enable_copy_on_read(bs);

}

pstrcpy(bs->filename, sizeof(bs->filename), filename);

if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {

return -ENOTSUP;

}

bs->drv = drv;

bs->opaque = g_malloc0(drv->instance_size);

bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);

open_flags = flags | BDRV_O_CACHE_WB;

/*

open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

/*

if (bs->is_temporary) {

open_flags |= BDRV_O_RDWR;

}

bs->read_only = !(open_flags & BDRV_O_RDWR);

/* Open the image, either directly or using a protocol */

if (drv->bdrv_file_open) {

ret = drv->bdrv_file_open(bs, filename, open_flags);

} else {

ret = bdrv_file_open(&bs->file, filename, open_flags);

if (ret >= 0) {

ret = drv->bdrv_open(bs, open_flags);

}

}

if (ret < 0) {

goto free_and_fail;

}

ret = refresh_total_sectors(bs, bs->total_sectors);

if (ret < 0) {

goto free_and_fail;

}

#ifndef _WIN32

if (bs->is_temporary) {

unlink(filename);

}

return 0;

free_and_fail:

if (bs->file) {

bdrv_delete(bs->file);

bs->file = NULL;

}

g_free(bs->opaque);

bs->opaque = NULL;

bs->drv = NULL;

return ret;

}

int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)

{

BlockDriverState *bs;

BlockDriver *drv;

int ret;

drv = bdrv_find_protocol(filename);

if (!drv) {

return -ENOENT;

}

bs = bdrv_new("");

ret = bdrv_open_common(bs, filename, flags, drv);

if (ret < 0) {

bdrv_delete(bs);

return ret;

}

bs->growable = 1;

*pbs = bs;

return 0;

}

int bdrv_open_backing_file(BlockDriverState *bs)

{

char backing_filename[PATH_MAX];

int back_flags, ret;

BlockDriver *back_drv = NULL;

if (bs->backing_hd != NULL) {

return 0;

}

bs->open_flags &= ~BDRV_O_NO_BACKING;

if (bs->backing_file[0] == '\0') {

return 0;

}

bs->backing_hd = bdrv_new("");

bdrv_get_full_backing_filename(bs, backing_filename,

sizeof(backing_filename));

if (bs->backing_format[0] != '\0') {

back_drv = bdrv_find_format(bs->backing_format);

}

/* backing files always opened read-only */

back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT);

ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);

if (ret < 0) {

bdrv_delete(bs->backing_hd);

bs->backing_hd = NULL;

bs->open_flags |= BDRV_O_NO_BACKING;

return ret;

}

return 0;

}

int bdrv_open(BlockDriverState *bs, const char *filename, int flags,

BlockDriver *drv)

{

int ret;

/* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */

char tmp_filename[PATH_MAX + 1];

if (flags & BDRV_O_SNAPSHOT) {

BlockDriverState *bs1;

int64_t total_size;

int is_protocol = 0;

BlockDriver *bdrv_qcow2;

QEMUOptionParameter *options;

char backing_filename[PATH_MAX];

/* if snapshot, we create a temporary backing file and open it

/* if there is a backing file, use it */

bs1 = bdrv_new("");

ret = bdrv_open(bs1, filename, 0, drv);

if (ret < 0) {

bdrv_delete(bs1);

return ret;

}

total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;

if (bs1->drv && bs1->drv->protocol_name)

is_protocol = 1;

bdrv_delete(bs1);

ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));

if (ret < 0) {

return ret;

}

/* Real path is meaningless for protocols */

if (is_protocol)

snprintf(backing_filename, sizeof(backing_filename),

"%s", filename);

else if (!realpath(filename, backing_filename))

return -errno;

bdrv_qcow2 = bdrv_find_format("qcow2");

options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);

set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);

set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);

if (drv) {

set_option_parameter(options, BLOCK_OPT_BACKING_FMT,

drv->format_name);

}

ret = bdrv_create(bdrv_qcow2, tmp_filename, options);

free_option_parameters(options);

if (ret < 0) {

return ret;

}

filename = tmp_filename;

drv = bdrv_qcow2;

bs->is_temporary = 1;

}

/* Find the right image format driver */

if (!drv) {

ret = find_image_format(filename, &drv);

}

if (!drv) {

goto unlink_and_fail;

}

if (flags & BDRV_O_RDWR) {

flags |= BDRV_O_ALLOW_RDWR;

}

/* Open the image */

ret = bdrv_open_common(bs, filename, flags, drv);

if (ret < 0) {

goto unlink_and_fail;

}

/* If there is a backing file, use it */

if ((flags & BDRV_O_NO_BACKING) == 0) {

ret = bdrv_open_backing_file(bs);

if (ret < 0) {

bdrv_close(bs);

return ret;

}

}

if (!bdrv_key_required(bs)) {

bdrv_dev_change_media_cb(bs, true);

}

/* throttling disk I/O limits */

if (bs->io_limits_enabled) {

bdrv_io_limits_enable(bs);

}

return 0;

unlink_and_fail:

if (bs->is_temporary) {

unlink(filename);

}

return ret;

}

typedef struct BlockReopenQueueEntry {

bool prepared;

BDRVReopenState state;

QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;

} BlockReopenQueueEntry;

BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,

BlockDriverState *bs, int flags)

{

assert(bs != NULL);

BlockReopenQueueEntry *bs_entry;

if (bs_queue == NULL) {

bs_queue = g_new0(BlockReopenQueue, 1);

QSIMPLEQ_INIT(bs_queue);

}

if (bs->file) {

bdrv_reopen_queue(bs_queue, bs->file, flags);

}

bs_entry = g_new0(BlockReopenQueueEntry, 1);

QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);

bs_entry->state.bs = bs;

bs_entry->state.flags = flags;

return bs_queue;

}

int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)

{

int ret = -1;

BlockReopenQueueEntry *bs_entry, *next;

Error *local_err = NULL;

assert(bs_queue != NULL);

bdrv_drain_all();

QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {

if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {

error_propagate(errp, local_err);

goto cleanup;

}

bs_entry->prepared = true;

}

/* If we reach this point, we have success and just need to apply the

QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {

bdrv_reopen_commit(&bs_entry->state);

}

ret = 0;

cleanup:

QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {

if (ret && bs_entry->prepared) {

bdrv_reopen_abort(&bs_entry->state);

}

g_free(bs_entry);

}

g_free(bs_queue);

return ret;

}

int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)