This patch contains implemention for APIs. Basically it is a layer
above qemu block general layer now.
Signed-off-by: Wenchao Xia <xiaw...@linux.vnet.ibm.com>
---
libqblock/libqblock-error.c | 57 +++
libqblock/libqblock.c | 1071 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 1128 insertions(+), 0 deletions(-)
diff --git a/libqblock/libqblock-error.c b/libqblock/libqblock-error.c
index e69de29..ca78b50 100644
--- a/libqblock/libqblock-error.c
+++ b/libqblock/libqblock-error.c
@@ -0,0 +1,57 @@
+/*
+ * QEMU block layer library
+ *
+ * Copyright IBM, Corp. 2013
+ *
+ * Authors:
+ * Wenchao Xia <xiaw...@linux.vnet.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ *
+ */
+
+#include "libqblock-error.h"
+#include "libqblock-internal.h"
+
+void qb_error_get_human_str(QBlockContext *context,
+ char *buf, size_t buf_size)
+{
+ const char *err_ret_str;
+ switch (context->err_ret) {
+ case QB_ERR_INTERNAL_ERR:
+ err_ret_str = "Internal error.";
+ break;
+ case QB_ERR_INVALID_PARAM:
+ err_ret_str = "Invalid param.";
+ break;
+ case QB_ERR_BLOCK_OUT_OF_RANGE:
+ err_ret_str = "request is out of image's range.";
+ break;
+ default:
+ err_ret_str = "Unknown error.";
+ break;
+ }
+ if (context == NULL) {
+ snprintf(buf, buf_size, "%s", err_ret_str);
+ return;
+ }
+
+ if (context->err_ret == QB_ERR_INTERNAL_ERR) {
+ snprintf(buf, buf_size, "%s %s errno [%d]. strerror [%s].",
+ err_ret_str, context->g_error->message,
+ context->err_no, strerror(-context->err_no));
+ } else {
+ snprintf(buf, buf_size, "%s %s",
+ err_ret_str, context->g_error->message);
+ }
+ return;
+}
+
+int qb_error_get_errno(QBlockContext *context)
+{
+ if (context->err_ret == QB_ERR_INTERNAL_ERR) {
+ return context->err_no;
+ }
+ return 0;
+}
diff --git a/libqblock/libqblock.c b/libqblock/libqblock.c
index e69de29..5458ee4 100644
--- a/libqblock/libqblock.c
+++ b/libqblock/libqblock.c
@@ -0,0 +1,1071 @@
+/*
+ * QEMU block layer library
+ *
+ * Copyright IBM, Corp. 2013
+ *
+ * Authors:
+ * Wenchao Xia <xiaw...@linux.vnet.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ *
+ */
+
+#include <unistd.h>
+#include <stdarg.h>
+#include <pthread.h>
+
+#include "libqblock.h"
+#include "libqblock-internal.h"
+
+#include "block/block_int.h"
+
+#define LIBQB_FILENAME_MAX 4096
+
+typedef struct LibqbFormatStrMapping {
+ const char *fmt_str;
+ QBlockFormat fmt_type;
+} LibqbFormatStrMapping;
+
+LibqbFormatStrMapping libqb_fmtstr_table[] = {
+ {"cow", QB_FMT_COW},
+ {"qed", QB_FMT_QED},
+ {"qcow", QB_FMT_QCOW},
+ {"qcow2", QB_FMT_QCOW2},
+ {"raw", QB_FMT_RAW},
+ {"rbd", QB_FMT_RBD},
+ {"sheepdog", QB_FMT_SHEEPDOG},
+ {"vdi", QB_FMT_VDI},
+ {"vmdk", QB_FMT_VMDK},
+ {"vpc", QB_FMT_VPC},
+ {NULL, 0},
+};
+
+__attribute__((constructor))
+static void libqblock_init(void)
+{
+ /* Todo: add an assertion about the ABI. */
+ qemu_init_main_loop();
+ bdrv_init();
+}
+
+const char *qb_fmttype2str(QBlockFormat fmt_type)
+{
+ int i = 0;
+ LibqbFormatStrMapping *tb = libqb_fmtstr_table;
+
+ if ((fmt_type <= QB_FMT_NONE) || (fmt_type >= QB_FMT_MAX)) {
+ return NULL;
+ }
+ while (tb[i].fmt_str != NULL) {
+ if (tb[i].fmt_type == fmt_type) {
+ return tb[i].fmt_str;
+ }
+ i++;
+ }
+ return NULL;
+}
+
+QBlockFormat qb_str2fmttype(const char *fmt_str)
+{
+ int i = 0;
+ LibqbFormatStrMapping *tb = libqb_fmtstr_table;
+
+ if (fmt_str == NULL) {
+ return QB_FMT_NONE;
+ }
+ while (tb[i].fmt_str != NULL) {
+ if ((strcmp(fmt_str, tb[i].fmt_str) == 0)) {
+ return tb[i].fmt_type;
+ }
+ i++;
+ }
+ return QB_FMT_NONE;
+}
+
+static void set_context_err(QBlockContext *context, int err_ret,
+ const char *fmt, ...)
+{
+ va_list ap;
+
+ if (context->g_error != NULL) {
+ g_error_free(context->g_error);
+ }
+
+ va_start(ap, fmt);
+ context->g_error = g_error_new_valist(G_LIBQBLOCK_ERROR, err_ret, fmt, ap);
+ va_end(ap);
+
+ context->err_ret = err_ret;
+ if (err_ret == QB_ERR_INTERNAL_ERR) {
+ context->err_no = -errno;
+ } else {
+ context->err_no = 0;
+ }
+}
+
+int qb_context_new(QBlockContext **p_context)
+{
+ *p_context = g_malloc0_n(1, sizeof(QBlockContext));
+
+ /* AIO code could comes here later. */
+ return 0;
+}
+
+void qb_context_delete(QBlockContext **p_context)
+{
+ if ((*p_context)->g_error != NULL) {
+ g_error_free((*p_context)->g_error);
+ }
+ QB_FREE(*p_context);
+ return;
+}
+
+int qb_image_new(QBlockContext *context,
+ QBlockImage **p_qbi)
+{
+ *p_qbi = g_malloc0_n(1, sizeof(QBlockImage));
+ (*p_qbi)->bdrvs = bdrv_new("hda");
+ if ((*p_qbi)->bdrvs == NULL) {
+ QB_FREE(*p_qbi);
+ set_context_err(context, QB_ERR_INTERNAL_ERR,
+ "failed to create the driver.");
+ return context->err_ret;
+ }
+ (*p_qbi)->ref_count = 1;
+ return 0;
+}
+
+void qb_image_ref(QBlockContext *context,
+ QBlockImage **p_qbi)
+{
+ (*p_qbi)->ref_count++;
+}
+
+void qb_image_unref(QBlockContext *context,
+ QBlockImage **p_qbi)
+{
+ (*p_qbi)->ref_count--;
+ if ((*p_qbi)->ref_count > 0) {
+ return;
+ }
+ if ((*p_qbi)->filename != NULL) {
+ qb_close(context, *p_qbi);
+ }
+ if ((*p_qbi)->bdrvs != NULL) {
+ bdrv_delete((*p_qbi)->bdrvs);
+ (*p_qbi)->bdrvs = NULL;
+ }
+ QB_FREE(*p_qbi);
+ return;
+}
+
+int qb_loc_info_new(QBlockContext *context,
+ QBlockLocationInfo **p_loc)
+{
+ *p_loc = g_malloc0_n(1, sizeof(QBlockLocationInfo));
+ return 0;
+}
+
+void qb_loc_info_delete(QBlockContext *context,
+ QBlockLocationInfo **p_loc)
+{
+ QB_FREE(*p_loc);
+}
+
+int qb_fmt_info_new(QBlockContext *context,
+ QBlockFormatInfo **p_fmt)
+{
+ *p_fmt = g_malloc0_n(1, sizeof(QBlockFormatInfo));
+ return 0;
+}
+
+void qb_fmt_info_delete(QBlockContext *context,
+ QBlockFormatInfo **p_fmt)
+{
+ QB_FREE(*p_fmt);
+}
+
+/* return 0 if every thing is fine */
+static int loc_check_params(QBlockContext *context,
+ QBlockLocationInfo *loc)
+{
+ context->err_ret = 0;
+
+ switch (loc->prot_type) {
+ case QB_PROTO_FILE:
+ if (loc->o_file.filename == NULL) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Filename was not set.");
+ goto out;
+ }
+ if (path_has_protocol(loc->o_file.filename) > 0) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "filename [%s] had protocol.",
+ loc->o_file.filename);
+ goto out;
+ }
+ break;
+ default:
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Protocol type [%d] was not valid.",
+ loc->prot_type);
+ break;
+ }
+
+ out:
+ return context->err_ret;
+}
+
+/* translate loc structure to internal filename, returned char* need free,
+ * assuming filename is not NULL. *filename would be set to NULL if no valid
+ * filename found. *filename must be freed later.
+ * return 0 if no error with *filename set.
+ */
+static int loc2filename(QBlockContext *context,
+ QBlockLocationInfo *loc,
+ char **p_filename)
+{
+ context->err_ret = 0;
+
+ if (*p_filename != NULL) {
+ QB_FREE(*p_filename);
+ }
+ switch (loc->prot_type) {
+ case QB_PROTO_FILE:
+ *p_filename = g_strdup(loc->o_file.filename);
+ break;
+ default:
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "protocol type [%d] is not supported.",
+ loc->prot_type);
+ break;
+ }
+
+ return context->err_ret;
+}
+
+/* translate filename to location, loc->prot_type = NONE if fail, filename
+ must be valid. loc internal char pointer must be freed later.
+ * return 0 if no error.
+ */
+static int filename2loc(QBlockContext *context,
+ QBlockLocationInfo *loc,
+ const char *filename)
+{
+ context->err_ret = 0;
+
+ if (path_has_protocol(filename) > 0) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Filename [%s] had protocol, not supported now.",
+ filename);
+ goto out;
+ }
+
+ loc->prot_type = QB_PROTO_FILE;
+ switch (loc->prot_type) {
+ case QB_PROTO_FILE:
+ loc->o_file.filename = g_strdup(filename);
+ break;
+ default:
+ break;
+ }
+
+ out:
+ return context->err_ret;
+}
+
+/* return 0 if OK, or qblock error number */
+static int set_backing_file_options(QBlockContext *context,
+ QEMUOptionParameter *param,
+ QBlockLocationInfo *loc,
+ QBlockFormat *fmt)
+{
+ char *backing_filename = NULL;
+ const char *fmtstr_backing = NULL;
+ int ret = 0;
+
+ if (loc == NULL) {
+ goto out;
+ }
+
+ ret = loc2filename(context, loc, &backing_filename);
+ /* ret can < 0 if loc have not been set, mean user did not specify backing
+ file, so need to check return value */
+
+ ret = 0;
+
+ if (backing_filename) {
+ ret = set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, backing_filename);
+ assert(ret == 0);
+ if (fmt == NULL) {
+ goto out;
+ }
+ fmtstr_backing = qb_fmttype2str(*fmt);
+ if (fmtstr_backing) {
+ ret = set_option_parameter(param,
+ BLOCK_OPT_BACKING_FMT, fmtstr_backing);
+ assert(ret == 0);
+ }
+ }
+
+ out:
+ g_free(backing_filename);
+ return ret;
+}
+
+int qb_create(QBlockContext *context,
+ QBlockImage *qbi,
+ QBlockLocationInfo *loc,
+ QBlockFormatInfo *fmt,
+ int flag)
+{
+ int ret = 0, bd_ret;
+ char *filename = NULL;
+ BlockDriverState *bs = NULL;
+ BlockDriver *drv = NULL, *backing_drv = NULL;
+ bool tmp_bool;
+
+ const char *fmtstr = NULL, *tmp = NULL;
+ QEMUOptionParameter *param = NULL, *create_options = NULL;
+ QEMUOptionParameter *backing_fmt, *backing_file, *size;
+ QBlockFormatOptionsCOW *o_cow = NULL;
+ QBlockFormatOptionsQED *o_qed = NULL;
+ QBlockFormatOptionsQCOW *o_qcow = NULL;
+ QBlockFormatOptionsQCOW2 *o_qcow2 = NULL;
+ QBlockFormatOptionsRAW *o_raw = NULL;
+ QBlockFormatOptionsRBD *o_rbd = NULL;
+ QBlockFormatOptionsSD *o_sd = NULL;
+ QBlockFormatOptionsVDI *o_vdi = NULL;
+ QBlockFormatOptionsVMDK *o_vmdk = NULL;
+ QBlockFormatOptionsVPC *o_vpc = NULL;
+
+
+ /* check parameters */
+ if (flag & (~LIBQBLOCK_O_VALID_MASK)) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "invalid flag was set.");
+ ret = context->err_ret;
+ goto out;
+ }
+
+ if ((loc == NULL) || (qbi == NULL) || (fmt == NULL)) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Got unexpected NULL pointer in parameters.");
+ ret = context->err_ret;
+ goto out;
+ }
+
+ ret = loc_check_params(context, loc);
+ if (ret != 0) {
+ goto out;
+ }
+
+ /* internal translate */
+ ret = loc2filename(context, loc, &filename);
+ if (ret != 0) {
+ goto out;
+ }
+
+ fmtstr = qb_fmttype2str(fmt->fmt_type);
+ if (fmtstr == NULL) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Got unexpected NULL pointer in parameters.");
+ ret = context->err_ret;
+ goto out;
+ }
+
+ drv = bdrv_find_format(fmtstr);
+ assert(drv != NULL);
+
+ create_options = append_option_parameters(create_options,
+ drv->create_options);
+ param = parse_option_parameters("", create_options, param);
+
+ bd_ret = set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, fmt->virt_size);
+ assert(bd_ret == 0);
+
+ switch (fmt->fmt_type) {
+ case QB_FMT_COW:
+ o_cow = &fmt->o_cow;
+ /* do not need to check loc, it may be not set */
+ ret = set_backing_file_options(context, param,
+ &o_cow->backing_loc, NULL);
+ if (ret != 0) {
+ goto out;
+ }
+ break;
+ case QB_FMT_QED:
+ o_qed = &fmt->o_qed;
+ ret = set_backing_file_options(context, param,
+ &o_qed->backing_loc, &o_qed->backing_fmt);
+ if (ret != 0) {
+ goto out;
+ }
+ bd_ret = set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_qed->cluster_size);
+ assert(bd_ret == 0);
+ bd_ret = set_option_parameter_int(param,
+ BLOCK_OPT_TABLE_SIZE, o_qed->table_size);
+ assert(bd_ret == 0);
+ break;
+ case QB_FMT_QCOW:
+ o_qcow = &fmt->o_qcow;
+ ret = set_backing_file_options(context, param,
+ &o_qcow->backing_loc, NULL);
+ if (ret != 0) {
+ goto out;
+ }
+ tmp = o_qcow->encrypt ? "on" : "off";
+ bd_ret = set_option_parameter(param, BLOCK_OPT_ENCRYPT, tmp);
+ assert(bd_ret == 0);
+ break;
+ case QB_FMT_QCOW2:
+ o_qcow2 = &fmt->o_qcow2;
+ ret = set_backing_file_options(context, param,
+ &o_qcow2->backing_loc, &o_qcow2->backing_fmt);
+ if (ret != 0) {
+ goto out;
+ }
+ tmp = o_qcow2->encrypt ? "on" : "off";
+ bd_ret = set_option_parameter(param, BLOCK_OPT_ENCRYPT, tmp);
+ assert(bd_ret == 0);
+ bd_ret = set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_qcow2->cluster_size);
+ assert(bd_ret == 0);
+
+ if (o_qcow2->cpt_lv != QB_FMT_QCOW2_COMPAT_DEFAULT) {
+ tmp = o_qcow2->cpt_lv == QB_FMT_QCOW2_COMPAT_V0_10 ? "0.10" :
"1.1";
+ bd_ret = set_option_parameter(param,
+ BLOCK_OPT_COMPAT_LEVEL, tmp);
+ assert(bd_ret == 0);
+ }
+
+ if (o_qcow2->pre_mode != QB_FMT_QCOW2_PREALLOC_DEFAULT) {
+ tmp = o_qcow2->pre_mode == QB_FMT_QCOW2_PREALLOC_OFF ?
+ "off" : "metadata";
+ bd_ret = set_option_parameter(param,
+ BLOCK_OPT_PREALLOC, tmp);
+ assert(bd_ret == 0);
+ }
+ break;
+
+ case QB_FMT_RAW:
+ o_raw = &fmt->o_raw;
+ /* do nothing now. */
+ break;
+ case QB_FMT_RBD:
+ o_rbd = &fmt->o_rbd;
+ bd_ret = set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_rbd->cluster_size);
+ assert(bd_ret == 0);
+ break;
+ case QB_FMT_SHEEPDOG:
+ o_sd = &fmt->o_sd;
+ ret = set_backing_file_options(context, param,
+ &o_sd->backing_loc, NULL);
+ if (ret != 0) {
+ goto out;
+ }
+ if (o_sd->pre_mode != QB_FMT_SD_PREALLOC_DEFAULT) {
+ tmp = o_sd->pre_mode == QB_FMT_SD_PREALLOC_OFF ? "off" : "full";
+ bd_ret = set_option_parameter(param,
+ BLOCK_OPT_PREALLOC, tmp);
+ assert(bd_ret == 0);
+ }
+ break;
+ case QB_FMT_VDI:
+ o_vdi = &fmt->o_vdi;
+ /* following option is not always valid depends on configuration */
+ set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_vdi->cluster_size);
+ if (o_vdi->pre_mode != QB_FMT_VDI_PREALLOC_DEFAULT) {
+ tmp_bool = o_sd->pre_mode == QB_FMT_VDI_PREALLOC_METADATA ?
+ true : false;
+ set_option_parameter_int(param, "static", tmp_bool);
+ }
+ break;
+ case QB_FMT_VMDK:
+ o_vmdk = &fmt->o_vmdk;
+ ret = set_backing_file_options(context, param,
+ &o_vmdk->backing_loc, NULL);
+ if (ret != 0) {
+ goto out;
+ }
+
+ if (o_vmdk->cpt_lv != QB_FMT_VMDK_COMPAT_DEFAULT) {
+ tmp_bool = o_vmdk->cpt_lv == QB_FMT_VMDK_COMPAT_VMDKV6_TRUE ?
+ true : false;
+ bd_ret = set_option_parameter_int(param, BLOCK_OPT_COMPAT6,
+ tmp_bool);
+ assert(bd_ret == 0);
+ }
+ if (o_vmdk->subfmt != QB_FMT_VMDK_SUBFMT_DEFAULT) {
+ switch (o_vmdk->subfmt) {
+ case QB_FMT_VMDK_SUBFMT_MONOLITHIC_SPARSE:
+ tmp = "monolithicSparse";
+ break;
+ case QB_FMT_VMDK_SUBFMT_MONOLITHIC_FLAT:
+ tmp = "monolithicFlat";
+ break;
+ case QB_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_SPARSE:
+ tmp = "twoGbMaxExtentSparse";
+ break;
+ case QB_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_FLAT:
+ tmp = "twoGbMaxExtentFlat";
+ break;
+ case QB_FMT_VMDK_SUBFMT_STREAM_OPTIMIZED:
+ tmp = "streamOptimized";
+ break;
+ default:
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "invalid VMDK sumfmt type %d was set.", o_vmdk->subfmt);
+ ret = context->err_ret;
+ goto out;
+ break;
+ }
+ bd_ret = set_option_parameter(param,
+ BLOCK_OPT_SUBFMT, tmp);
+ assert(bd_ret == 0);
+ }
+ break;
+ case QB_FMT_VPC:
+ o_vpc = &fmt->o_vpc;
+ if (o_vpc->subfmt != QB_FMT_VPC_SUBFMT_DEFAULT) {
+ tmp = o_vpc->subfmt == QB_FMT_VPC_SUBFMT_DYNAMIC ?
+ "dynamic" : "fixed";
+ bd_ret = set_option_parameter(param,
+ BLOCK_OPT_SUBFMT, tmp);
+ assert(bd_ret == 0);
+ }
+ break;
+ default:
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "invalid format type %d was set.", fmt->fmt_type);
+ ret = context->err_ret;
+ goto out;
+ break;
+ }
+
+ backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
+ if (backing_file && backing_file->value.s) {
+ if (!strcmp(filename, backing_file->value.s)) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Backing file is the same with new file.");
+ ret = context->err_ret;
+ goto out;
+ }
+ }
+
+ backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
+ if (backing_fmt && backing_fmt->value.s) {
+ backing_drv = bdrv_find_format(backing_fmt->value.s);
+ assert(backing_drv != NULL);
+ }
+
+ size = get_option_parameter(param, BLOCK_OPT_SIZE);
+ if (size && size->value.n <= 0) {
+ if (backing_file && backing_file->value.s) {
+ uint64_t size;
+ char buf[32];
+ int back_flags;
+
+ /* backing files always opened read-only */
+ back_flags =
+ flag &
+ ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
+
+ bs = bdrv_new("");
+
+ ret = bdrv_open(bs, backing_file->value.s,
+ back_flags, backing_drv);
+ if (ret < 0) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Failed to open the backing file.");
+ ret = context->err_ret;
+ goto out;
+ }
+ bdrv_get_geometry(bs, &size);
+ size *= BDRV_SECTOR_SIZE;
+
+ snprintf(buf, sizeof(buf), "%" PRId64, size);
+ set_option_parameter(param, BLOCK_OPT_SIZE, buf);
+ } else {
+ set_context_err(context, QB_ERR_INTERNAL_ERR,
+ "Neither size or backing file was not set.");
+ ret = context->err_ret;
+ goto out;
+ }
+ }
+
+ bd_ret = bdrv_create(drv, filename, param);
+
+
+ if (bd_ret < 0) {
+ const char *errstr;
+ if (bd_ret == -ENOTSUP) {
+ errstr = "formatting option not supported.";
+ } else if (bd_ret == -EFBIG) {
+ errstr = "The image size is too large.";
+ } else {
+ errstr = "Error in creating the image.";
+ }
+ set_context_err(context, QB_ERR_INTERNAL_ERR, errstr);
+ ret = context->err_ret;
+ }
+
+out:
+ free_option_parameters(create_options);
+ free_option_parameters(param);
+ g_free(filename);
+ if (bs) {
+ bdrv_delete(bs);
+ }
+
+ return ret;
+}
+
+int qb_open(QBlockContext *context,
+ QBlockImage *qbi,
+ QBlockLocationInfo *loc,
+ QBlockFormatInfo *fmt,
+ int flag)
+{
+ int ret = 0, bd_ret;
+ BlockDriverState *bs;
+ BlockDriver *bd;
+ const char *fmtstr;
+ char *filename = NULL;
+
+ /* take care of user settings */
+ /* do nothing now */
+
+ /* check parameters */
+ if (flag & (~LIBQBLOCK_O_VALID_MASK)) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Invalid flag was set.");
+ ret = context->err_ret;
+ goto out;
+ }
+
+ if ((loc == NULL) || (qbi == NULL)) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Got unexpected NULL pointer in parameters.");
+ ret = context->err_ret;
+ goto out;
+ }
+
+ ret = loc_check_params(context, loc);
+ if (ret != 0) {
+ goto out;
+ }
+
+ /* internal translate */
+ ret = loc2filename(context, loc, &filename);
+ if (ret != 0) {
+ goto out;
+ }
+
+ fmtstr = NULL;
+ bd = NULL;
+ if (fmt != NULL) {
+ fmtstr = qb_fmttype2str(fmt->fmt_type);
+ }
+
+ if (fmtstr != NULL) {
+ bd = bdrv_find_format(fmtstr);
+ assert(bd != NULL);
+ }
+
+ /* do real opening */
+ bs = qbi->bdrvs;
+ bd_ret = bdrv_open(bs, filename, flag, bd);
+ if (bd_ret < 0) {
+ set_context_err(context, QB_ERR_INTERNAL_ERR,
+ "Failed in opening with driver, bd_ret is %d.", bd_ret);
+ ret = context->err_ret;
+ goto out;
+ }
+
+ if (qbi->filename != NULL) {
+ g_free(qbi->filename);
+ }
+ qbi->filename = g_strdup(filename);
+
+ out:
+ g_free(filename);
+ return ret;
+}
+
+void qb_close(QBlockContext *context,
+ QBlockImage *qbi)
+{
+ BlockDriverState *bs;
+
+ bs = qbi->bdrvs;
+
+ if (qbi->filename != NULL) {
+ QB_FREE(qbi->filename);
+ bdrv_close(bs);
+ }
+ return;
+}
+
+int32_t qb_read(QBlockContext *context,
+ QBlockImage *qbi,
+ uint8_t *buf,
+ uint32_t len,
+ uint64_t offset)
+{
+ int bd_ret;
+ BlockDriverState *bs;
+
+ context->err_ret = 0;
+ bs = qbi->bdrvs;
+
+ if (len <= 0) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Param len is less or equal to zero.");
+ return context->err_ret;
+ }
+
+ bd_ret = bdrv_pread(bs, offset, buf, len);
+ if (bd_ret < 0) {
+ set_context_err(context, QB_ERR_INTERNAL_ERR,
+ "I/O errors.");
+ context->err_no = bd_ret;
+ return context->err_ret;
+ }
+
+ return bd_ret;
+}
+
+int32_t qb_write(QBlockContext *context,
+ QBlockImage *qbi,
+ const uint8_t *buf,
+ uint32_t len,
+ uint64_t offset)
+{
+ int bd_ret;
+ BlockDriverState *bs;
+
+ context->err_ret = 0;
+ bs = qbi->bdrvs;
+
+ if (len <= 0) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Param len is less or equal to zero.");
+ return context->err_ret;
+ }
+
+ bd_ret = bdrv_pwrite(bs, offset, buf, len);
+ if (bd_ret < 0) {
+ set_context_err(context, QB_ERR_INTERNAL_ERR,
+ "I/O errors.");
+ context->err_no = bd_ret;
+ return context->err_ret;
+ }
+
+ return bd_ret;
+}
+
+int qb_flush(QBlockContext *context,
+ QBlockImage *qbi)
+{
+ int bd_ret;
+ BlockDriverState *bs;
+
+ context->err_ret = 0;
+ bs = qbi->bdrvs;
+ bd_ret = bdrv_flush(bs);
+ if (bd_ret < 0) {
+ set_context_err(context, QB_ERR_INTERNAL_ERR,
+ "Internal error.");
+ }
+ return context->err_ret;
+}
+
+int qb_check_allocation(QBlockContext *context,
+ QBlockImage *qbi,
+ uint64_t start,
+ int64_t length,
+ int *pstatus,
+ int64_t *plength)
+{
+ int ret;
+ int sector_start, sector_num, num;
+ BlockDriverState *bs;
+ unsigned int real_len, ret_len;
+
+ context->err_ret = 0;
+ bs = qbi->bdrvs;
+
+ /* Now bdrv_is_allocated take nb_sectors as int with unit sector, but this
+ API take length as int64_t with unit bytes, so a check is needed to ensure
+ no silent error will happen in translating bytes to sector later if length
+ is too big.
+ max_sectors is set to INT_MAX - 1 in case of that real_len is bigger
+ than length.
+ Gcc issue? a = (0x7ffffffe << 9) was compiled to 0xfffffffffffffc00, it
+ should be 0xfffffffc00, so use variable instead of direct macro
+ calculation. */
+ if (sizeof(int) < (sizeof(int64_t) - BDRV_SECTOR_BITS/8)) {
+ int64_t max_sectors = INT_MAX - 1;
+ int64_t max_bytes = max_sectors << BDRV_SECTOR_BITS;
+
+ if (length > max_bytes) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Length is too big.");
+ goto out;
+ }
+ }
+
+ if (length <= 0) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Length is not valid.");
+ goto out;
+ }
+
+ if (qbi->filename == NULL) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Image was not opened first.");
+ goto out;
+ }
+
+ /* translate to sector */
+ sector_start = start >> BDRV_SECTOR_BITS;
+ real_len = (start & (~BDRV_SECTOR_MASK)) + length;
+ sector_num = real_len >> BDRV_SECTOR_BITS;
+ if ((real_len & (~BDRV_SECTOR_MASK)) != 0) {
+ sector_num++;
+ }
+
+ ret = bdrv_is_allocated(bs, sector_start, sector_num, &num);
+ if ((ret == 0) && (num == 0)) {
+ set_context_err(context, QB_ERR_BLOCK_OUT_OF_RANGE,
+ "Start position was bigger than the image's size.");
+ goto out;
+ }
+
+ *pstatus = ret;
+ ret_len = (num << BDRV_SECTOR_BITS) - (start & (~BDRV_SECTOR_MASK));
+ if (ret_len > length) {
+ ret_len = length;
+ }
+ *plength = ret_len;
+
+ out:
+ return context->err_ret;
+}
+
+static void qb_setup_info_addr(const QBlockStaticInfo *info,
+ QBlockStaticInfoAddr *info_addr)
+{
+ const QBlockLocationInfo *backing_loc = NULL;
+ const bool *encrypt = NULL;
+ const QBlockFormatInfo *fmt = &info->fmt;
+
+ memset(info_addr, 0, sizeof(QBlockStaticInfoAddr));
+
+ switch (fmt->fmt_type) {
+ case QB_FMT_COW:
+ backing_loc = &fmt->o_cow.backing_loc;
+ break;
+ case QB_FMT_QED:
+ backing_loc = &fmt->o_qed.backing_loc;
+ break;
+ case QB_FMT_QCOW:
+ backing_loc = &fmt->o_qcow.backing_loc;
+ encrypt = &fmt->o_qcow.encrypt;
+ break;
+ case QB_FMT_QCOW2:
+ backing_loc = &fmt->o_qcow2.backing_loc;
+ encrypt = &fmt->o_qcow2.encrypt;
+ break;
+ case QB_FMT_RAW:
+ break;
+ case QB_FMT_RBD:
+ break;
+ case QB_FMT_SHEEPDOG:
+ backing_loc = &fmt->o_sd.backing_loc;
+ break;
+ case QB_FMT_VDI:
+ break;
+ case QB_FMT_VMDK:
+ backing_loc = &fmt->o_vmdk.backing_loc;
+ break;
+ case QB_FMT_VPC:
+ break;
+ default:
+ break;
+ }
+
+ info_addr->backing_loc = (QBlockLocationInfo *)backing_loc;
+ info_addr->encrypt = (bool *)encrypt;
+ return;
+}
+
+const uint64_t *qb_get_virt_size(const QBlockStaticInfo *info)
+{
+ return &info->fmt.virt_size;
+}
+
+const QBlockLocationInfo *qb_get_backing_loc(const QBlockStaticInfo *info)
+{
+ QBlockStaticInfoAddr addr;
+ qb_setup_info_addr(info, &addr);
+ return addr.backing_loc;
+}
+
+const bool *qb_get_encrypt(const QBlockStaticInfo *info)
+{
+ QBlockStaticInfoAddr addr;
+ qb_setup_info_addr(info, &addr);
+ return addr.encrypt;
+}
+
+int qb_info_image_static_get(QBlockContext *context,
+ QBlockImage *qbi,
+ QBlockStaticInfo **p_info)
+{
+ int ret = 0;
+ BlockDriverState *bs;
+ QBlockStaticInfo *info;
+ QBlockStaticInfoAddr addr;
+ const char *fmt_str;
+ uint64_t total_sectors;
+ char backing_filename[LIBQB_FILENAME_MAX];
+
+ if (qbi->filename == NULL) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Block Image was not opened.");
+ ret = context->err_ret;
+ goto out;
+ }
+
+ info = g_malloc0_n(1, sizeof(QBlockStaticInfo));
+
+ bs = qbi->bdrvs;
+
+ ret = filename2loc(context,
+ &info->loc,
+ qbi->filename);
+ if (ret < 0) {
+ goto free;
+ }
+
+ fmt_str = bdrv_get_format_name(bs);
+ info->fmt.fmt_type = qb_str2fmttype(fmt_str);
+ if (info->fmt.fmt_type == QB_FMT_NONE) {
+ set_context_err(context, QB_ERR_INVALID_PARAM,
+ "Image format %s not valid.", fmt_str);
+ ret = context->err_ret;
+ goto free;
+ }
+
+ /* we got the format type and basic location info now, setup the struct
+ pointer to the internal members */
+ qb_setup_info_addr(info, &addr);
+
+ bdrv_get_geometry(bs, &total_sectors);
+ info->fmt.virt_size = total_sectors * BDRV_SECTOR_SIZE;
+
+ if (addr.encrypt != NULL) {
+ *(addr.encrypt) = bdrv_is_encrypted(bs);
+ }
+
+ bdrv_get_full_backing_filename(bs, backing_filename,
+ sizeof(backing_filename));
+ if (backing_filename[0] != '\0') {
+ assert(addr.backing_loc != NULL);
+ ret = filename2loc(context,
+ addr.backing_loc,
+ backing_filename);
+ if (ret < 0) {
+ goto free;
+ }
+ }
+
+ info->sector_size = BDRV_SECTOR_SIZE;
+ *p_info = info;
+
+ out:
+ return ret;
+ free:
+ qb_info_image_static_delete(context, &info);
+ return ret;
+}
+
+/* free locations if it has string allocated on heap. */
+static void loc_free(QBlockLocationInfo *loc)
+{
+ switch (loc->prot_type) {
+ case QB_PROTO_FILE:
+ g_free((void *)(loc->o_file.filename));
+ loc->o_file.filename = NULL;
+ break;
+ default:
+ break;
+ }
+}
+
+/* free fmt related resoure. */
+static void fmt_free(QBlockFormatInfo *fmt)
+{
+ switch (fmt->fmt_type) {
+ case QB_FMT_COW:
+ loc_free(&fmt->o_cow.backing_loc);
+ break;
+ case QB_FMT_QED:
+ loc_free(&fmt->o_qed.backing_loc);
+ break;
+ case QB_FMT_QCOW:
+ loc_free(&fmt->o_qcow.backing_loc);
+ break;
+ case QB_FMT_QCOW2:
+ loc_free(&fmt->o_qcow2.backing_loc);
+ break;
+ case QB_FMT_RAW:
+ break;
+ case QB_FMT_RBD:
+ break;
+ case QB_FMT_SHEEPDOG:
+ loc_free(&fmt->o_sd.backing_loc);
+ break;
+ case QB_FMT_VDI:
+ break;
+ case QB_FMT_VMDK:
+ loc_free(&fmt->o_vmdk.backing_loc);
+ break;
+ case QB_FMT_VPC:
+ break;
+ default:
+ break;
+ }
+ return;
+}
+
+void qb_info_image_static_delete(QBlockContext *context,
+ QBlockStaticInfo **p_info)
+{
+ loc_free(&(*p_info)->loc);
+ fmt_free(&(*p_info)->fmt);
+ QB_FREE(*p_info);
+}
+
+QBlockLocationInfo *qb_loc_info_dup(const QBlockLocationInfo *prot)
+{
+ QBlockLocationInfo *p = g_malloc0_n(1, sizeof(QBlockLocationInfo));
+ p->prot_type = prot->prot_type;
+ switch (p->prot_type) {
+ case QB_PROTO_FILE:
+ p->o_file.filename =
+ g_strdup(prot->o_file.filename);
+ break;
+ default:
+ break;
+ }
+ return p;
+}
--
1.7.1
