From patchwork Mon Sep 3 09:18:41 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wayne Xia X-Patchwork-Id: 181337 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 367792C0093 for ; Mon, 3 Sep 2012 19:22:15 +1000 (EST) Received: from localhost ([::1]:42443 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1T8SrF-0003wM-4u for incoming@patchwork.ozlabs.org; Mon, 03 Sep 2012 05:22:13 -0400 Received: from eggs.gnu.org ([208.118.235.92]:42544) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1T8Sqy-0003wF-Qb for qemu-devel@nongnu.org; Mon, 03 Sep 2012 05:22:00 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1T8Sqr-0007ny-14 for qemu-devel@nongnu.org; Mon, 03 Sep 2012 05:21:56 -0400 Received: from e23smtp01.au.ibm.com ([202.81.31.143]:59593) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1T8Sqp-0007nh-Mr for qemu-devel@nongnu.org; Mon, 03 Sep 2012 05:21:48 -0400 Received: from /spool/local by e23smtp01.au.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Mon, 3 Sep 2012 19:20:30 +1000 Received: from d23relay03.au.ibm.com (202.81.31.245) by e23smtp01.au.ibm.com (202.81.31.207) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Mon, 3 Sep 2012 19:20:28 +1000 Received: from d23av02.au.ibm.com (d23av02.au.ibm.com [9.190.235.138]) by d23relay03.au.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id q839LeqR25428144 for ; Mon, 3 Sep 2012 19:21:40 +1000 Received: from d23av02.au.ibm.com (loopback [127.0.0.1]) by d23av02.au.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id q839LdON018172 for ; Mon, 3 Sep 2012 19:21:40 +1000 Received: from RedHat62GAWSWenchao ([9.115.122.34]) by d23av02.au.ibm.com (8.14.4/8.13.1/NCO v10.0 AVin) with ESMTP id q839JI4h012127; Mon, 3 Sep 2012 19:21:38 +1000 From: Wenchao Xia To: qemu-devel@nongnu.org Date: Mon, 3 Sep 2012 17:18:41 +0800 Message-Id: <1346663926-20188-2-git-send-email-xiawenc@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1346663926-20188-1-git-send-email-xiawenc@linux.vnet.ibm.com> References: <1346663926-20188-1-git-send-email-xiawenc@linux.vnet.ibm.com> x-cbid: 12090309-1618-0000-0000-00000264B02A X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 202.81.31.143 Cc: kwolf@redhat.com, aliguori@us.ibm.com, stefanha@gmail.com, pbonzini@redhat.com, eblake@redhat.com, Wenchao Xia Subject: [Qemu-devel] [PATCH 1/6] libqblock APIs X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org This patch contains the major APIs in the library. Important APIs: 1 QBroker. These structure was used to retrieve errors, every thread must create one first, Later maybe thread related staff could be added into it. 2 QBlockState. It stands for an block image object. 3 QBlockInfoImageStatic. Now it is not folded with location and format. 4 ABI was kept with reserved members. structure, because it would cause caller more codes to find one member. Signed-off-by: Wenchao Xia --- libqblock/libqblock.c | 859 +++++++++++++++++++++++++++++++++++++++++++++++++ libqblock/libqblock.h | 251 ++++++++++++++ 2 files changed, 1110 insertions(+), 0 deletions(-) create mode 100644 libqblock/libqblock.c create mode 100644 libqblock/libqblock.h diff --git a/libqblock/libqblock.c b/libqblock/libqblock.c new file mode 100644 index 0000000..3983802 --- /dev/null +++ b/libqblock/libqblock.c @@ -0,0 +1,859 @@ +/* + * QEMU block layer library + * + * Copyright IBM, Corp. 2012 + * + * Authors: + * Wenchao Xia + * + * 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 +#include + +#include "libqblock.h" +#include "libqblock-helper.h" + +#include "qemu-aio.h" + +void libqblock_init(void) +{ + bdrv_init(); + qemu_init_main_loop(); +} + +int qb_broker_new(struct QBroker **broker) +{ + *broker = FUNC_CALLOC(1, sizeof(struct QBroker)); + if (*broker == NULL) { + return QB_ERR_MEM_ERR; + } + return 0; +} + +void qb_broker_delete(struct QBroker **broker) +{ + CLEAN_FREE(*broker); + return; +} + +int qb_state_new(struct QBroker *broker, + struct QBlockState **qbs) +{ + *qbs = FUNC_CALLOC(1, sizeof(struct QBlockState)); + if (*qbs == NULL) { + set_broker_err_nomem(broker); + return broker->err_ret; + } + (*qbs)->bdrvs = bdrv_new("hda"); + if ((*qbs)->bdrvs == NULL) { + CLEAN_FREE(*qbs); + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "failed to create the driver."); + return broker->err_ret; + } + return 0; +} + +void qb_state_delete(struct QBroker *broker, + struct QBlockState **qbs) +{ + CLEAN_FREE((*qbs)->filename); + if ((*qbs)->bdrvs != NULL) { + bdrv_delete((*qbs)->bdrvs); + (*qbs)->bdrvs = NULL; + } + CLEAN_FREE(*qbs); + return; +} + +int qb_ol_new(struct QBroker *broker, + struct QBlockOptionLoc **op) +{ + *op = FUNC_CALLOC(1, sizeof(struct QBlockOptionLoc)); + if (*op == NULL) { + set_broker_err_nomem(broker); + return broker->err_ret; + } + return 0; +} + +void qb_ol_delete(struct QBroker *broker, + struct QBlockOptionLoc **op) +{ + CLEAN_FREE(*op); +} + +int qb_of_new(struct QBroker *broker, + struct QBlockOptionFormat **op) +{ + *op = FUNC_CALLOC(1, sizeof(struct QBlockOptionFormat)); + if (*op == NULL) { + set_broker_err_nomem(broker); + return broker->err_ret; + } + return 0; +} + +void qb_of_delete(struct QBroker *broker, + struct QBlockOptionFormat **op) +{ + CLEAN_FREE(*op); +} + +/* return 0 if every thing is fine */ +static int loc_check_params(struct QBroker *broker, + struct QBlockOptionLoc *loc) +{ + broker->err_ret = 0; + + switch (loc->prot_type) { + case QB_PROTO_FILE: + if (loc->prot_op.o_file.filename == NULL) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Filename was not set."); + goto out; + } + if (path_has_protocol(loc->prot_op.o_file.filename) > 0) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "filename [%s] had protocol.", + loc->prot_op.o_file.filename); + goto out; + } + break; + default: + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Protocol type [%d] was not valid.", + loc->prot_type); + break; + } + + out: + return broker->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(struct QBroker *broker, + struct QBlockOptionLoc *loc, + char **filename) +{ + broker->err_ret = 0; + + if (*filename != NULL) { + CLEAN_FREE(*filename); + } + switch (loc->prot_type) { + case QB_PROTO_FILE: + *filename = strdup(loc->prot_op.o_file.filename); + if (*filename == NULL) { + set_broker_err_nomem(broker); + } + break; + default: + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "protocol type [%d] is not supported.", + loc->prot_type); + break; + } + + return broker->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(struct QBroker *broker, + struct QBlockOptionLoc *loc, + const char *filename) +{ + broker->err_ret = 0; + + if (path_has_protocol(filename) > 0) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Filename [%s] had protocol, not supportted now.", + filename); + goto out; + } + + loc->prot_type = QB_PROTO_FILE; + switch (loc->prot_type) { + case QB_PROTO_FILE: + loc->prot_op.o_file.filename = strdup(filename); + if (loc->prot_op.o_file.filename == NULL) { + set_broker_err_nomem(broker); + goto out; + } + break; + default: + break; + } + + out: + return broker->err_ret; +} + +/* return 0 if OK, or qblock error number */ +static int set_backing_file_options(struct QBroker *broker, + QEMUOptionParameter *param, + struct QBlockOptionLoc *loc, + enum QBlockFormat *fmt) +{ + char *backing_filename = NULL; + const char *fmtstr_backing = NULL; + int ret = 0; + + if (loc == NULL) { + goto out; + } + + ret = loc2filename(broker, loc, &backing_filename); + /* ret can < 0 if loc have not been set, mean user did not specify backing + file */ + if (ret == QB_ERR_MEM_ERR) { + goto out; + } + 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 = fmt2str(*fmt); + if (fmtstr_backing) { + ret = set_option_parameter(param, + BLOCK_OPT_BACKING_FMT, fmtstr_backing); + assert(ret == 0); + } + } + + out: + FUNC_FREE(backing_filename); + return ret; +} + +int qb_create(struct QBroker *broker, + struct QBlockState *qbs, + struct QBlockOptionLoc *loc, + struct QBlockOptionFormat *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; + struct QBlockOption_fmt_cow *o_cow = NULL; + struct QBlockOption_fmt_qed *o_qed = NULL; + struct QBlockOption_fmt_qcow *o_qcow = NULL; + struct QBlockOption_fmt_qcow2 *o_qcow2 = NULL; + struct QBlockOption_fmt_raw *o_raw = NULL; + struct QBlockOption_fmt_rbd *o_rbd = NULL; + struct QBlockOption_fmt_sheepdog *o_sd = NULL; + struct QBlockOption_fmt_vdi *o_vdi = NULL; + struct QBlockOption_fmt_vmdk *o_vmdk = NULL; + struct QBlockOption_fmt_vpc *o_vpc = NULL; + + + /* check parameters */ + if (flag & (~LIBQBLOCK_O_VALID_MASK)) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "invalid flag was set."); + ret = broker->err_ret; + goto out; + } + + if ((loc == NULL) || (qbs == NULL) || (fmt == NULL)) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Got unexpected NULL pointer in parameters."); + ret = broker->err_ret; + goto out; + } + + ret = loc_check_params(broker, loc); + if (ret != 0) { + goto out; + } + + /* internal translate */ + ret = loc2filename(broker, loc, &filename); + if (ret != 0) { + goto out; + } + + fmtstr = fmt2str(fmt->fmt_type); + if (fmtstr == NULL) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Got unexpected NULL pointer in parameters."); + ret = broker->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); + + switch (fmt->fmt_type) { + case QB_FMT_COW: + o_cow = &(fmt->fmt_op.o_cow); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_cow->virt_size); + assert(bd_ret == 0); + /* do not need to check loc, it may be not set */ + ret = set_backing_file_options(broker, param, + &o_cow->backing_loc, NULL); + if (ret != 0) { + goto out; + } + break; + case QB_FMT_QED: + o_qed = &(fmt->fmt_op.o_qed); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_qed->virt_size); + assert(bd_ret == 0); + ret = set_backing_file_options(broker, 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->fmt_op.o_qcow); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_qcow->virt_size); + assert(bd_ret == 0); + ret = set_backing_file_options(broker, 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->fmt_op.o_qcow2); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_qcow2->virt_size); + assert(bd_ret == 0); + ret = set_backing_file_options(broker, 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 != QBO_FMT_QCOW2_CPT_NONE) { + tmp = o_qcow2->cpt_lv == QBO_FMT_QCOW2_CPT_V010 ? "0.10" : "1.1"; + bd_ret = set_option_parameter(param, + BLOCK_OPT_COMPAT_LEVEL, tmp); + assert(bd_ret == 0); + } + + if (o_qcow2->pre_mode != QBO_FMT_QCOW2_PREALLOC_NONE) { + tmp = o_qcow2->pre_mode == QBO_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->fmt_op.o_raw); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_raw->virt_size); + assert(bd_ret == 0); + break; + case QB_FMT_RBD: + o_rbd = &(fmt->fmt_op.o_rbd); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_rbd->virt_size); + assert(bd_ret == 0); + 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->fmt_op.o_sheepdog); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_sd->virt_size); + assert(bd_ret == 0); + ret = set_backing_file_options(broker, param, + &o_sd->backing_loc, NULL); + if (ret != 0) { + goto out; + } + if (o_sd->pre_mode != QBO_FMT_SD_PREALLOC_NONE) { + tmp = o_sd->pre_mode == QBO_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->fmt_op.o_vdi); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_vdi->virt_size); + assert(bd_ret == 0); + /* 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 != QBO_FMT_VDI_PREALLOC_NONE) { + tmp_bool = o_sd->pre_mode == QBO_FMT_VDI_PREALLOC_TRUE ? + true : false; + set_option_parameter_int(param, "static", tmp_bool); + } + break; + case QB_FMT_VMDK: + o_vmdk = &(fmt->fmt_op.o_vmdk); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_vmdk->virt_size); + assert(bd_ret == 0); + ret = set_backing_file_options(broker, param, + &o_vmdk->backing_loc, NULL); + if (ret != 0) { + goto out; + } + + if (o_vmdk->cpt_lv != QBO_FMT_VMDK_CPT_NONE) { + tmp_bool = o_vmdk->cpt_lv == QBO_FMT_VMDK_CPT_VMDKV6_TRUE ? + true : false; + bd_ret = set_option_parameter_int(param, BLOCK_OPT_COMPAT6, + tmp_bool); + assert(bd_ret == 0); + } + if (o_vmdk->subfmt != QBO_FMT_VMDK_SUBFMT_MONOLITHIC_NONE) { + switch (o_vmdk->subfmt) { + case QBO_FMT_VMDK_SUBFMT_MONOLITHIC_SPARSE: + tmp = "monolithicSparse"; + break; + case QBO_FMT_VMDK_SUBFMT_MONOLITHIC_FLAT: + tmp = "monolithicFlat"; + break; + case QBO_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_SPARSE: + tmp = "twoGbMaxExtentSparse"; + break; + case QBO_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_FLAT: + tmp = "twoGbMaxExtentFlat"; + break; + case QBO_FMT_VMDK_SUBFMT_STREAM_OPTIMIZED: + tmp = "streamOptimized"; + break; + default: + assert(false); + break; + } + bd_ret = set_option_parameter(param, + BLOCK_OPT_SUBFMT, tmp); + assert(bd_ret == 0); + } + break; + case QB_FMT_VPC: + o_vpc = &(fmt->fmt_op.o_vpc); + bd_ret = set_option_parameter_int(param, + BLOCK_OPT_SIZE, o_vpc->virt_size); + assert(bd_ret == 0); + if (o_vpc->subfmt != QBO_FMT_VPC_SUBFMT_NONE) { + tmp = o_vpc->subfmt == QBO_FMT_VPC_SUBFMT_DYNAMIC ? + "dynamic" : "fixed"; + bd_ret = set_option_parameter(param, + BLOCK_OPT_SUBFMT, tmp); + assert(bd_ret == 0); + } + break; + default: + assert(false); + 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_broker_err(broker, QB_ERR_INVALID_PARAM, + "Backing file is the same with new file."); + ret = broker->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_broker_err(broker, QB_ERR_INVALID_PARAM, + "Failed to open the backing file."); + ret = broker->err_ret; + goto out; + } + bdrv_get_geometry(bs, &size); + size *= SECTOR_SIZE; + + snprintf(buf, sizeof(buf), "%" PRId64, size); + set_option_parameter(param, BLOCK_OPT_SIZE, buf); + } else { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Neither size or backing file was not set."); + ret = broker->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_broker_err(broker, QB_ERR_INTERNAL_ERR, errstr); + ret = broker->err_ret; + } + +out: + free_option_parameters(create_options); + free_option_parameters(param); + FUNC_FREE(filename); + if (bs) { + bdrv_delete(bs); + } + + return ret; +} + +int qb_open(struct QBroker *broker, + struct QBlockState *qbs, + struct QBlockOptionLoc *loc, + struct QBlockOptionFormat *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_broker_err(broker, QB_ERR_INVALID_PARAM, + "Invalid flag was set."); + ret = broker->err_ret; + goto out; + } + + if ((loc == NULL) || (qbs == NULL)) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Got unexpected NULL pointer in parameters."); + ret = broker->err_ret; + goto out; + } + + ret = loc_check_params(broker, loc); + if (ret != 0) { + goto out; + } + + /* internal translate */ + ret = loc2filename(broker, loc, &filename); + if (ret != 0) { + goto out; + } + + fmtstr = NULL; + bd = NULL; + if (fmt != NULL) { + fmtstr = fmt2str(fmt->fmt_type); + } + + if (fmtstr != NULL) { + bd = bdrv_find_format(fmtstr); + assert(bd != NULL); + } + + /* do real openning */ + bs = qbs->bdrvs; + bd_ret = bdrv_open(bs, filename, flag, bd); + if (bd_ret < 0) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Failed in opening with driver, bd_ret is %d.", bd_ret); + ret = broker->err_ret; + goto out; + } + + if (qbs->filename != NULL) { + FUNC_FREE(qbs->filename); + } + qbs->filename = strdup(filename); + if (qbs->filename == NULL) { + set_broker_err_nomem(broker); + ret = broker->err_ret; + bdrv_close(bs); + goto out; + } + + out: + FUNC_FREE(filename); + return ret; +} + +void qb_close(struct QBroker *broker, + struct QBlockState *qbs) +{ + BlockDriverState *bs; + + bs = qbs->bdrvs; + + if (qbs->filename != NULL) { + CLEAN_FREE(qbs->filename); + bdrv_close(bs); + } + return; +} + +int qb_read(struct QBroker *broker, + struct QBlockState *qbs, + const void *buf, + size_t len, + off_t offset) +{ + int bd_ret; + BlockDriverState *bs; + + broker->err_ret = 0; + bs = qbs->bdrvs; + + assert((len & SECTOR_SIZE_MASK) == 0); + assert((offset & SECTOR_SIZE_MASK) == 0); + bd_ret = bdrv_read(bs, offset >> SECTOR_SIZE_BITS_NUM, + (uint8_t *)buf, len >> SECTOR_SIZE_BITS_NUM); + if (bd_ret < 0) { + if (bd_ret == -EIO) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Generic I/O error."); + } else if (bd_ret == -ENOMEDIUM) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "No meida inserted."); + } else if (bd_ret == -EINVAL) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Sector was not correct."); + } else { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Internal error."); + } + } + return broker->err_ret; +} + +int qb_write(struct QBroker *broker, + struct QBlockState *qbs, + const void *buf, + size_t len, + off_t offset) +{ + int bd_ret; + BlockDriverState *bs; + + broker->err_ret = 0; + bs = qbs->bdrvs; + + assert((len & SECTOR_SIZE_MASK) == 0); + assert((offset & SECTOR_SIZE_MASK) == 0); + bd_ret = bdrv_write(bs, offset >> SECTOR_SIZE_BITS_NUM, + (uint8_t *)buf, len >> SECTOR_SIZE_BITS_NUM); + if (bd_ret < 0) { + if (bd_ret == -EIO) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Generic I/O error."); + } else if (bd_ret == -ENOMEDIUM) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "No meida inserted."); + } else if (bd_ret == -EINVAL) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Sector was not correct."); + } else { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Internal error."); + } + } + return broker->err_ret; +} + +int qb_flush(struct QBroker *broker, + struct QBlockState *qbs) +{ + int bd_ret; + BlockDriverState *bs; + + broker->err_ret = 0; + bs = qbs->bdrvs; + bd_ret = bdrv_flush(bs); + if (bd_ret < 0) { + set_broker_err(broker, QB_ERR_INTERNAL_ERR, + "Internal error."); + } + return broker->err_ret; +} + +int qb_is_allocated(struct QBroker *broker, + struct QBlockState *qbs, + int64_t sector_num, + int nb_sectors, + int *pnum) +{ + int ret; + BlockDriverState *bs; + + broker->err_ret = 0; + bs = qbs->bdrvs; + + if (qbs->filename == NULL) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Image was not opened first."); + ret = broker->err_ret; + goto out; + } + + ret = bdrv_is_allocated(bs, sector_num, nb_sectors, pnum); + + out: + return ret; +} + +int qb_info_image_static_get(struct QBroker *broker, + struct QBlockState *qbs, + struct QBlockInfoImageStatic **info) +{ + int ret = 0; + BlockDriverState *bs; + struct QBlockInfoImageStatic *info_tmp; + const char *fmt_str; + size_t total_sectors; + char backing_filename[1024]; + + if (qbs->filename == NULL) { + set_broker_err(broker, QB_ERR_INVALID_PARAM, + "Block Image was not openned."); + ret = broker->err_ret; + goto out; + } + + info_tmp = FUNC_CALLOC(1, sizeof(struct QBlockInfoImageStatic)); + if (info_tmp == NULL) { + set_broker_err_nomem(broker); + ret = broker->err_ret; + goto out; + } + + bs = qbs->bdrvs; + + ret = filename2loc(broker, + &(info_tmp->loc), + qbs->filename); + if (ret < 0) { + goto free; + } + + fmt_str = bdrv_get_format_name(bs); + info_tmp->fmt_type = str2fmt(fmt_str); + + bdrv_get_geometry(bs, &total_sectors); + info_tmp->virt_size = total_sectors * SECTOR_SIZE; + + info_tmp->allocated_size = bdrv_get_allocated_file_size(bs); + info_tmp->encrypt = bdrv_is_encrypted(bs); + + bdrv_get_full_backing_filename(bs, backing_filename, + sizeof(backing_filename)); + if (backing_filename[0] != '\0') { + ret = filename2loc(broker, + &(info_tmp->backing_loc), + backing_filename); + if (ret < 0) { + goto free; + } + } + + *info = info_tmp; + + out: + return ret; + free: + qb_info_image_static_delete(broker, &info_tmp); + return ret; +} + +/* free locations if it has string allocated on heap. */ +static void loc_free(struct QBlockOptionLoc *loc) +{ + switch (loc->prot_type) { + case QB_PROTO_FILE: + CLEAN_FREE(loc->prot_op.o_file.filename); + break; + default: + break; + } +} + +void qb_info_image_static_delete(struct QBroker *broker, + struct QBlockInfoImageStatic **info) +{ + loc_free(&(*info)->loc); + loc_free(&(*info)->backing_loc); + + CLEAN_FREE(*info); +} diff --git a/libqblock/libqblock.h b/libqblock/libqblock.h new file mode 100644 index 0000000..e64e1fd --- /dev/null +++ b/libqblock/libqblock.h @@ -0,0 +1,251 @@ +/* + * QEMU block layer library + * + * Copyright IBM, Corp. 2012 + * + * Authors: + * Wenchao Xia + * + * 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. + * + */ + +#ifndef LIBQBLOCK_H +#define LIBQBLOCK_H + +#include "libqblock-types.h" +#include "libqblock-error.h" + + +/** + * libqblock_init: Initialize the library + */ +void libqblock_init(void); + +/** + * qb_broker_new: allocate a new broker + * + * Broker is used to pass operation to libqblock, and got feed back from it. + * + * Returns 0 on success, negative value on fail. + * + * @broker: used to receive the created struct. + */ +int qb_broker_new(struct QBroker **broker); + +/** + * qb_broker_delete: delete broker + * + * Broker will be freed and set to NULL. + * + * @broker: operation broker to be deleted. + */ +void qb_broker_delete(struct QBroker **broker); + +/** + * qb_state_new: allocate a new QBloctState struct + * + * Following qblock action were based on this struct + * + * Returns 0 if succeed, negative value on fail. + * + * @broker: operation broker. + * @qbs: used to receive the created struct. + */ +int qb_state_new(struct QBroker *broker, + struct QBlockState **qbs); + +/** + * qb_state_delete: free a QBloctState struct + * + * if it is opened, a qb_close must be called before free. + * + * @broker: operation broker. + * @qbs: pointer to the struct's pointer. + */ +void qb_state_delete(struct QBroker *broker, + struct QBlockState **qbs); + +/** + * qb_ol_new: create a new struct QBlockOptionLoc. + * + * return 0 on success, negative on fail. + * + * @broker: operation broker. + * @op: pointer to receive the new created one. + */ +int qb_ol_new(struct QBroker *broker, + struct QBlockOptionLoc **op); + +/** + * qb_ol_delete: free a struct QBlockOptionLoc. + * + * @broker: operation broker. + * @op: pointer to the object, *op would be set to NULL. + */ +void qb_ol_delete(struct QBroker *broker, + struct QBlockOptionLoc **op); + +/** + * qb_of_new: create a new QBlockOptionFormat structure. + * + * return 0 on success, negative on fail. + * + * @broker: operation broker. + * @op: pointer that will receive created struct. + */ +int qb_of_new(struct QBroker *broker, + struct QBlockOptionFormat **op); + +/** + * qb_of_delete: free QBlockOptionFormat structure. + * + * @broker: operation broker. + * @op: pointer to the struct, *op would be set to NULL. + */ +void qb_of_delete(struct QBroker *broker, + struct QBlockOptionFormat **op); + + +/** + * qb_open: open a block object. + * + * return 0 on success, negative on fail. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + * @loc: location options for open, how to find the image. + * @fmt: format options, how to extract the data, only valid member now is + fmt->fmt_type, set NULL if you want auto discovery the format. + * @flag: behavior control flags. + */ +int qb_open(struct QBroker *broker, + struct QBlockState *qbs, + struct QBlockOptionLoc *loc, + struct QBlockOptionFormat *fmt, + int flag); + +/** + * qb_close: close a block object. + * + * qb_flush is automaticlly done inside. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + */ +void qb_close(struct QBroker *broker, + struct QBlockState *qbs); + +/** + * qb_create: create a block image or object. + * + * Note: Create operation would not open the image automatically. + * + * return negative on fail, 0 on success. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + * @loc: location options for open, how to find the image. + * @fmt: format options, how to extract the data. + * @flag: behavior control flags. + */ +int qb_create(struct QBroker *broker, + struct QBlockState *qbs, + struct QBlockOptionLoc *loc, + struct QBlockOptionFormat *fmt, + int flag); + + +/* sync access */ +/** + * qb_read: block sync read. + * + * return negative on fail, 0 on success. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + * @buf: buffer that receive the content. + * @len: length to read. + * @offset: offset in the block data. + */ +int qb_read(struct QBroker *broker, + struct QBlockState *qbs, + const void *buf, + size_t len, + off_t offset); +/** + * qb_write: block sync write. + * + * return negative on fail, 0 on success. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + * @buf: buffer that receive the content. + * @len: length to write. + * @offset: offset in the block data. + */ +int qb_write(struct QBroker *broker, + struct QBlockState *qbs, + const void *buf, + size_t len, + off_t offset); + +/** + * qb_flush: block sync flush. + * + * return negative on fail, 0 on success. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + */ +int qb_flush(struct QBroker *broker, + struct QBlockState *qbs); + + +/* advance image APIs */ +/** + * qb_is_allocated: check if following sectors was allocated on the image. + * + * return negative on fail, 0 or 1 on success. 0 means unallocated, 1 means + *allocated. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + * @sector_num: start sector number. If 'sector_num' is beyond the end of the + *disk image the return value is 0 and 'pnum' is set to 0. + * @nb_sectors: how many sector would be checked, it is the max value 'pnum' + *should be set to. If nb_sectors goes beyond the end of the disk image it + *will be clamped. + * @pnum: pointer to receive how many sectors are allocated or unallocated. + */ +int qb_is_allocated(struct QBroker *broker, + struct QBlockState *qbs, + int64_t sector_num, + int nb_sectors, + int *pnum); + +/* image information */ +/** + * qb_get_image_info: get image info. + * + * return negative on fail, 0 on success. + * + * @broker: operation broker. + * @qbs: pointer to struct QBlockState. + * @info: pointer that would receive the information. + */ +int qb_info_image_static_get(struct QBroker *broker, + struct QBlockState *qbs, + struct QBlockInfoImageStatic **info); + +/** + * qb_delete_image_info: free image info. + * + * @broker: operation broker. + * @info: pointer to the information struct. + */ +void qb_info_image_static_delete(struct QBroker *broker, + struct QBlockInfoImageStatic **info); + +#endif