On Thu, Aug 9, 2012 at 10:12 AM, Wenchao Xia <address@hidden> wrote:
This patch is the API design.
Signed-off-by: Wenchao Xia <address@hidden>
---
libqblock.c | 670 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
libqblock.h | 447 +++++++++++++++++++++++++++++++++++++++
2 files changed, 1117 insertions(+), 0 deletions(-)
create mode 100644 libqblock.c
create mode 100644 libqblock.h
diff --git a/libqblock.c b/libqblock.c
new file mode 100644
index 0000000..52e46dc
--- /dev/null
+++ b/libqblock.c
@@ -0,0 +1,670 @@
+/*
+ * Copyright IBM Corp. 2012
+ *
+ * Authors:
+ * Wenchao Xia <address@hidden>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Current address of FSF is:
51 Franklin Street, Fifth Floor
Boston, MA 02110-1301
USA
However, please use the recommended web version like other files.
+}
+
+int qb_state_new(struct QBlockState **qbs)
+{
+ *qbs = FUNC_CALLOC(1, sizeof(struct QBlockState));
+ if (*qbs == NULL) {
+ return QB_ERR_MEM_ERR;
+ }
+ (*qbs)->bdrvs = bdrv_new("hda");
+ if ((*qbs)->bdrvs == NULL) {
+ CLEAN_FREE(*qbs);
+ return QB_ERR_INTERNAL_ERR;
+ }
+ return 0;
+}
+
+void qb_state_free(struct QBlockState **qbs)
+{
+ CLEAN_FREE((*qbs)->filename);
+ if ((*qbs)->bdrvs == NULL) {
+ bdrv_delete((*qbs)->bdrvs);
+ (*qbs)->bdrvs = NULL;
+ }
+ CLEAN_FREE(*qbs);
+ return;
Remove.
+}
+
+static const char *fmt2str(enum QBlockFormat fmt)
+{
+ const char *ret = NULL;
+ switch (fmt) {
+ case QB_FMT_COW:
+ ret = "cow";
+ break;
+ case QB_FMT_QED:
+ ret = "qed";
+ break;
+ case QB_FMT_QCOW:
+ ret = "qcow";
+ break;
+ case QB_FMT_QCOW2:
+ ret = "qcow2";
+ break;
+ case QB_FMT_RAW:
+ ret = "raw";
+ break;
+ case QB_FMT_RBD:
+ ret = "rbd";
+ break;
+ case QB_FMT_SHEEPDOG:
+ ret = "sheepdog";
+ break;
+ case QB_FMT_VDI:
+ ret = "vdi";
+ break;
+ case QB_FMT_VMDK:
+ ret = "vmdk";
+ break;
+ case QB_FMT_VPC:
+ ret = "vpc";
+ break;
+ default:
+ break;
+ }
+ return ret;
+}
+
+static enum QBlockFormat str2fmt(const char *fmt)
+{
+ enum QBlockFormat ret = QB_FMT_NONE;
+ if (0 == strcmp(fmt, "cow")) {
Please use natural order:
strcmp(fmt, "cow") == 0
+ ret = QB_FMT_COW;
+ } else if (0 == strcmp(fmt, "qed")) {
+ ret = QB_FMT_QED;
+ } else if (0 == strcmp(fmt, "qcow")) {
+ ret = QB_FMT_QCOW;
+ } else if (0 == strcmp(fmt, "qcow2")) {
+ ret = QB_FMT_QCOW2;
+ } else if (0 == strcmp(fmt, "raw")) {
+ ret = QB_FMT_RAW;
+ } else if (0 == strcmp(fmt, "rbd")) {
+ ret = QB_FMT_RBD;
+ } else if (0 == strcmp(fmt, "sheepdog")) {
+ ret = QB_FMT_SHEEPDOG;
+ } else if (0 == strcmp(fmt, "vdi")) {
+ ret = QB_FMT_VDI;
+ } else if (0 == strcmp(fmt, "vmdk")) {
+ ret = QB_FMT_VMDK;
+ } else if (0 == strcmp(fmt, "vpc")) {
+ ret = QB_FMT_VPC;
+ }
+ return ret;
+}
+
+/* copy information and take care the member difference in differect version.
+ Assuming all new member are added in the tail, struct size is the first
+ member, this is old to new version, src have its struct_size set. */
+static void qboo_adjust_o2n(struct QBlockOptionOpen *dest,
+ struct QBlockOptionOpen *src)
+{
+ /* for simple it does memcpy now, need to take care of embbed structure */
+ memcpy(dest, src, src->struct_size);
Since later there will be a field by field copy, I'd use:
*dest = *src;
+}
+
+int qb_open(struct QBlockState *qbs, struct QBlockOptionOpen *op)
+{
+ int ret = 0, bd_ret;
+ BlockDriverState *bs;
+ struct QBlockOptionOpen qboo;
+ BlockDriver *bd;
+ const char *fmt;
+
+ /* take care of user settings */
+ qboo_adjust_o2n(&qboo, op);
+
+ /* check parameters */
+ if (qboo.o_loc.filename == NULL) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "filename was not set.";
+ qbs->err_no = 0;
+ goto out;
+ }
+
+ if (path_has_protocol(qboo.o_loc.filename) > 0) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "filename have protocol.";
had
+ qbs->err_no = 0;
+ goto out;
+ }
+
+ if (qboo.o_loc.protocol >= QB_PROTO_MAX) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "protocol was not supported.";
+ qbs->err_no = 0;
+ goto out;
+ }
+
+ bd = NULL;
+ fmt = fmt2str(qboo.o_fmt_type);
+ if (fmt != NULL) {
+ bd = bdrv_find_format(fmt);
+ assert(bd != NULL);
+ }
What should happen in the NULL fmt case, goto out?
+
+
+ /* do real openning */
+ bs = qbs->bdrvs;
+ bd_ret = bdrv_open(bs, qboo.o_loc.filename, qboo.o_flag, bd);
+ if (bd_ret < 0) {
+ ret = QB_ERR_INTERNAL_ERR;
+ qbs->err_msg = "failed to open the file.";
+ qbs->err_no = -errno;
+ goto out;
+ }
+
+ if (qbs->filename != NULL) {
+ FUNC_FREE(qbs->filename);
+ }
+ qbs->filename = strdup(qboo.o_loc.filename);
+ if (qbs->filename == NULL) {
+ ret = QB_ERR_INVALID_PARAM;
+ set_err_nomem(qbs);
+ goto out;
+ }
+
+ out:
+ return ret;
+}
+
+void qb_close(struct QBlockState *qbs)
+{
+ BlockDriverState *bs;
+
+ bs = qbs->bdrvs;
+ bdrv_close(bs);
+ return;
Delete return
+}
+
+/* copy information and take care the member difference in differect version.
+ Assuming all new member are added in the tail, struct size is the first
+ member, this is old to new version, src have its struct_size set. */
+static void qboc_adjust_o2n(struct QBlockOptionCreate *dest,
+ struct QBlockOptionCreate *src)
+{
+ /* for simple it does memcpy now, need to take care of embbed structure */
+ memcpy(dest, src, src->struct_size);
+}
+
+int qb_create(struct QBlockState *qbs, struct QBlockOptionCreate *op)
+{
+ int ret = 0, bd_ret;
+ BlockDriverState *bs = NULL;
+ BlockDriver *drv = NULL, *backing_drv = NULL;
+ struct QBlockOptionCreate qbco;
+ const char *fmt = NULL, *fmt_backing_str = NULL, *tmp;
+ QEMUOptionParameter *param = NULL, *create_options = NULL;
+ QEMUOptionParameter *backing_fmt, *backing_file, *size;
+ struct QBlockOption_cow *o_cow = NULL;
+ struct QBlockOption_qed *o_qed = NULL;
+ struct QBlockOption_qcow *o_qcow = NULL;
+ struct QBlockOption_qcow2 *o_qcow2 = NULL;
+ struct QBlockOption_raw *o_raw = NULL;
+ struct QBlockOption_rbd *o_rbd = NULL;
+ struct QBlockOption_sheepdog *o_sd = NULL;
+ struct QBlockOption_vdi *o_vdi = NULL;
+ struct QBlockOption_vmdk *o_vmdk = NULL;
+ struct QBlockOption_vpc *o_vpc = NULL;
+ int backing_flag = 0;
+
+ /* take care of user settings */
+ qboc_adjust_o2n(&qbco, op);
+
+ /* check parameters */
+ if (qbco.o_loc.filename == NULL) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "filename was not set.";
+ qbs->err_no = 0;
+ goto out;
+ }
+
+ if (path_has_protocol(qbco.o_loc.filename) > 0) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "filename have protocol.";
+ qbs->err_no = 0;
+ goto out;
+ }
+
+ if (qbco.o_loc.protocol >= QB_PROTO_MAX) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "protocol was not supported.";
+ qbs->err_no = 0;
+ goto out;
+ }
+
+ /* set parameters */
+ fmt = fmt2str(qbco.o_fmt.fmt_type);
+ if (fmt == NULL) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "format is not valid.";
+ qbs->err_no = 0;
+ goto out;
+ }
+ drv = bdrv_find_format(fmt);
+ assert(drv != NULL);
+
+ create_options = append_option_parameters(create_options,
+ drv->create_options);
+ param = parse_option_parameters("", create_options, param);
+
+ switch (qbco.o_fmt.fmt_type) {
+ case QB_FMT_COW:
+ o_cow = &qbco.o_fmt.fmt_op.o_cow;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_cow->virt_size));
expr == 0, also below
+ if (o_cow->backing_file) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, o_cow->backing_file));
+ }
+ backing_flag = o_cow->backing_flag;
+ break;
+ case QB_FMT_QED:
+ o_qed = &qbco.o_fmt.fmt_op.o_qed;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_qed->virt_size));
+ if (o_qed->backing_file) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, o_qed->backing_file));
+ }
+ fmt_backing_str = fmt2str(o_qed->backing_fmt);
+ if (fmt_backing_str) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FMT, fmt_backing_str));
+ }
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_qed->cluster_size));
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_TABLE_SIZE, o_qed->table_size));
+ backing_flag = o_qed->backing_flag;
+ break;
+ case QB_FMT_QCOW:
+ o_qcow = &qbco.o_fmt.fmt_op.o_qcow;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_qcow->virt_size));
+ if (o_qcow->backing_file) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, o_qcow->backing_file));
+ }
+ tmp = o_qcow->encrypt ? "on" : "off";
+ assert(0 == set_option_parameter(param, BLOCK_OPT_ENCRYPT, tmp));
+ backing_flag = o_qcow->backing_flag;
+ break;
+ case QB_FMT_QCOW2:
+ o_qcow2 = &qbco.o_fmt.fmt_op.o_qcow2;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_qcow2->virt_size));
+ if (o_qcow2->backing_file) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, o_qcow2->backing_file));
+ }
+ fmt_backing_str = fmt2str(o_qcow2->backing_fmt);
+ if (fmt_backing_str) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FMT, fmt_backing_str));
+ }
+ if (o_qcow2->compat_level) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_COMPAT_LEVEL, o_qcow2->compat_level));
+ }
+ tmp = o_qcow2->encrypt ? "on" : "off";
+ assert(0 == set_option_parameter(param, BLOCK_OPT_ENCRYPT, tmp));
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_qcow2->cluster_size));
+ if (o_qcow2->prealloc_mode) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_PREALLOC, o_qcow2->prealloc_mode));
+ }
+ backing_flag = o_qcow2->backing_flag;
+ break;
+ case QB_FMT_RAW:
+ o_raw = &qbco.o_fmt.fmt_op.o_raw;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_raw->virt_size));
+ break;
+ case QB_FMT_RBD:
+ o_rbd = &qbco.o_fmt.fmt_op.o_rbd;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_rbd->virt_size));
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_rbd->cluster_size));
+ break;
+ case QB_FMT_SHEEPDOG:
+ o_sd = &qbco.o_fmt.fmt_op.o_sheepdog;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_sd->virt_size));
+ if (o_sd->backing_file) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, o_sd->backing_file));
+ }
+ if (o_sd->prealloc_mode) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_PREALLOC, o_sd->prealloc_mode));
+ }
+ backing_flag = o_sd->backing_flag;
+ break;
+ case QB_FMT_VDI:
+ o_vdi = &qbco.o_fmt.fmt_op.o_vdi;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_vdi->virt_size));
+ /* following option is not always valid depends on configuration */
+ set_option_parameter_int(param,
+ BLOCK_OPT_CLUSTER_SIZE, o_vdi->cluster_size);
+ set_option_parameter_int(param, "static", o_vdi->prealloc_mode);
+ break;
+ case QB_FMT_VMDK:
+ o_vmdk = &qbco.o_fmt.fmt_op.o_vmdk;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_vmdk->virt_size));
+ if (o_vmdk->backing_file) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_BACKING_FILE, o_vmdk->backing_file));
+ }
+ tmp = o_vmdk->compat_version6 ? "on" : "off";
+ assert(0 == set_option_parameter(param, BLOCK_OPT_COMPAT6, tmp));
+ if (o_vmdk->subfmt) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_SUBFMT, o_vmdk->subfmt));
+ }
+ backing_flag = o_vmdk->backing_flag;
+ break;
+ case QB_FMT_VPC:
+ o_vpc = &qbco.o_fmt.fmt_op.o_vpc;
+ assert(0 == set_option_parameter_int(param,
+ BLOCK_OPT_SIZE, o_vpc->virt_size));
+ if (o_vpc->subfmt) {
+ assert(0 == set_option_parameter(param,
+ BLOCK_OPT_SUBFMT, o_vpc->subfmt));
+ }
+ break;
+ default:
+ break;
+ }
+
+ backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
+ if (backing_file && backing_file->value.s) {
+ if (!strcmp(op->o_loc.filename, backing_file->value.s)) {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "backing file is the same with new file.";
same as the new file
+ qbs->err_no = 0;
+ 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 =
+ backing_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) {
+ ret = QB_ERR_INTERNAL_ERR;
+ qbs->err_msg = "failed to open the backing file.";
+ qbs->err_no = -errno;
+ goto out;
+ }
+ bdrv_get_geometry(bs, &size);
+ size *= 512;
Where's the #define?
+
+ snprintf(buf, sizeof(buf), "%" PRId64, size);
+ set_option_parameter(param, BLOCK_OPT_SIZE, buf);
+ } else {
+ ret = QB_ERR_INVALID_PARAM;
+ qbs->err_msg = "neither size or backing file was not set.";
+ qbs->err_no = 0;
+ goto out;
+ }
+ }
+
+ bd_ret = bdrv_create(drv, op->o_loc.filename, param);
+
+ if (bd_ret < 0) {
+ ret = QB_ERR_INTERNAL_ERR;
+ qbs->err_no = bd_ret;
+ if (bd_ret == -ENOTSUP) {
+ qbs->err_msg = "formatting option not supported.";
s/f/F/
+ } else if (bd_ret == -EFBIG) {
+ qbs->err_msg = "The image size is too large.";
+ } else {
+ qbs->err_msg = "Error in creating the image.";
+ }
+ goto out;
+ }
+
+out:
+ free_option_parameters(create_options);
+ free_option_parameters(param);
+
+ if (bs) {
+ bdrv_delete(bs);
+ }
+
+ return ret;
+}
+
+/* ignore case that len is not alligned to 512 now. */
aligned
+int qb_read(struct QBlockState *qbs, const void *buf, size_t len,
+ off_t offset)
+{
+ int ret = 0, bd_ret;
+ BlockDriverState *bs;
+
+ bs = qbs->bdrvs;
+
+ assert((len & 0x01ff) == 0);
+ assert((offset & 0x01ff) == 0);
Also here use the #defined constant.
+ bd_ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, len >> 9);
+ if (bd_ret < 0) {
+ ret = QB_ERR_INTERNAL_ERR;
+ qbs->err_no = bd_ret;
+ if (bd_ret == -EIO) {
+ qbs->err_msg = "Generic I/O error.";
+ } else if (bd_ret == -ENOMEDIUM) {
+ qbs->err_msg = "No meida inserted.";
media
+ } else if (bd_ret == -EINVAL) {
+ qbs->err_msg = "Sector was not correct.";
+ } else {
+ qbs->err_msg = "Internal error.";
+ }
+ }
+ return ret;
+}
+
+/* ignore case that len is not alligned to 512 now. */
+int qb_write(struct QBlockState *qbs, const void *buf, size_t len,
+ off_t offset)
+{
+ int ret = 0, bd_ret;
+ BlockDriverState *bs;
+
+ bs = qbs->bdrvs;
+
+ assert((len & 0x01ff) == 0);
+ assert((offset & 0x01ff) == 0);
+ bd_ret = bdrv_write(bs, offset >> 9, buf, len >> 9);
+ if (bd_ret < 0) {
+ ret = QB_ERR_INTERNAL_ERR;
+ qbs->err_no = bd_ret;
+ if (bd_ret == -EIO) {
+ qbs->err_msg = "Generic I/O error.";
+ } else if (bd_ret == -ENOMEDIUM) {
+ qbs->err_msg = "No meida inserted.";
+ } else if (bd_ret == -EINVAL) {
+ qbs->err_msg = "Sector was not correct.";
+ } else if (bd_ret == -EACCES) {
+ qbs->err_msg = "Ready only device.";
+ } else {
+ qbs->err_msg = "Internal error.";
+ }
+ }
+ return ret;
+}
+
+int qb_flush(struct QBlockState *qbs)
+{
+ int ret = 0, bd_ret;
+ BlockDriverState *bs;
+
+ bs = qbs->bdrvs;
+ bd_ret = bdrv_flush(bs);
+ if (bd_ret < 0) {
+ ret = QB_ERR_INTERNAL_ERR;
+ qbs->err_no = bd_ret;
+ qbs->err_msg = NULL;
+ }
+ return ret;
+}
+
+int qb_infoimage_get(struct QBlockState *qbs, struct QBlockInfoImage **info)
+{
+ int ret = 0;
+ BlockDriverState *bs;
+ const char *tmp;
+ uint64_t total_sectors;
+ char backing_filename[1024];
+
+ struct QBlockInfoImage *ifimg = FUNC_CALLOC(1,
+ sizeof(struct QBlockInfoImage));
+ if (ifimg == NULL) {
+ ret = QB_ERR_MEM_ERR;
+ set_err_nomem(qbs);
+ goto out;
+ }
+
+ bs = qbs->bdrvs;
+ ifimg->filename = strdup(qbs->filename);
+ if (ifimg->filename == NULL) {
+ ret = QB_ERR_MEM_ERR;
+ set_err_nomem(qbs);
+ goto err;
+ }
+ tmp = bdrv_get_format_name(bs);
+ ifimg->format = str2fmt(tmp);
+ /* support only file now */
+ ifimg->protocol = QB_PROTO_FILE;
+
+ bdrv_get_geometry(bs, &total_sectors);
+ ifimg->virt_size = total_sectors * 512;
+ ifimg->allocated_size = bdrv_get_allocated_file_size(bs);
+ ifimg->encrypt = bdrv_is_encrypted(bs);
+ bdrv_get_full_backing_filename(bs, backing_filename,
+ sizeof(backing_filename));
+ if (backing_filename[0] != '\0') {
+ ifimg->backing_filename = strdup(backing_filename);
+ if (ifimg->backing_filename == NULL) {
+ ret = QB_ERR_MEM_ERR;
+ set_err_nomem(qbs);
+ goto err;
+ }
+ }
+
+ *info = ifimg;
+ out:
+ return ret;
+ err:
+ qb_infoimage_free(&ifimg);
+ return ret;
+}
+
+void qb_infoimage_free(struct QBlockInfoImage **info)
+{
+ if (*info == NULL) {
+ return;
+ }
+ FUNC_FREE((*info)->filename);
+ FUNC_FREE((*info)->backing_filename);
+ FUNC_FREE(*info);
+ *info = NULL;
+ return;
+}
+
+bool qb_supports_format(enum QBlockFormat fmt)
+{
+ if (fmt < QB_FMT_MAX) {
+ return true;
+ }
+ return false;
+}
+
+bool qb_supports_protocol(enum QBlockProtocol proto)
+{
+ if (proto < QB_PROTO_MAX) {
+ return true;
+ }
+ return false;
+}
+
+const char *qb_error_get_detail(struct QBlockState *qbs, int *err_num)
+{
+ *err_num = qbs->err_no;
+ return qbs->err_msg;
+}
diff --git a/libqblock.h b/libqblock.h
new file mode 100644
index 0000000..d2e9502
--- /dev/null
+++ b/libqblock.h
@@ -0,0 +1,447 @@
+/*
+ * Copyright IBM Corp. 2012
+ *
+ * Authors:
+ * Wenchao Xia <address@hidden>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
web version
+ */
+
+#ifndef LIBQBLOCK_H
+#define LIBQBLOCK_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define bool _Bool
#include <stdbool.h>
+
+#define QB_ERR_MEM_ERR (-1)
+#define QB_ERR_INTERNAL_ERR (-2)
+#define QB_ERR_INVALID_PARAM (-3)
+
+/* this library is designed around this core struct. */
+struct QBlockState;
+
+/*
+ libarary init
library
+ This function get the library ready to use.
+ */
Please use markup for the comments, see for example memory.h.
+
+union QBlockOption_fmt {
+ struct QBlockOption_cow o_cow;
+ struct QBlockOption_qed o_qed;
+ struct QBlockOption_qcow o_qcow;
+ struct QBlockOption_qcow2 o_qcow2;
+ struct QBlockOption_raw o_raw;
+ struct QBlockOption_rbd o_rbd;
+ struct QBlockOption_sheepdog o_sheepdog;
+ struct QBlockOption_vdi o_vdi;
+ struct QBlockOption_vmdk o_vmdk;
+ struct QBlockOption_vpc o_vpc;
+};
+
+struct QBlockOptionFormat {
+ int struct_size;
+ enum QBlockFormat fmt_type;
+ union QBlockOption_fmt fmt_op;
+};
+
+/* struct_size in o_loc and o_fmt must set. To make this structure extensible,
+ all new member must be added in the tail of each structure. */
+struct QBlockOptionCreate {
+ int struct_size;
+ struct QBlockLocInfo o_loc;
+ struct QBlockOptionFormat o_fmt;
+};
+
+/*
+ create a new QBlockOptionCreate structure.
+ params:
+ op: out, pointer that will receive created structure.
+ fmt: format want to use.
+ return:
+ 0 on succeed, negative on failure.
+ */
+static inline int qb_oc_new(struct QBlockOptionCreate **op,
+ enum QBlockFormat fmt)
+{
+ *op = calloc(1, sizeof(struct QBlockOptionCreate));
+ if (*op == NULL) {
+ return QB_ERR_MEM_ERR;
+ }
+ (*op)->struct_size = sizeof(struct QBlockOptionCreate);
+ (*op)->o_loc.struct_size = sizeof(struct QBlockLocInfo);
+ (*op)->o_fmt.struct_size = sizeof(struct QBlockOptionFormat);
+
+ switch (fmt) {
+ case QB_FMT_COW:
+ (*op)->o_fmt.fmt_op.o_cow.struct_size =
+ sizeof(struct QBlockOption_cow);
+ break;
+ case QB_FMT_QED:
+ (*op)->o_fmt.fmt_op.o_qed.struct_size =
+ sizeof(struct QBlockOption_qed);
+ break;
+ case QB_FMT_QCOW:
+ (*op)->o_fmt.fmt_op.o_qcow.struct_size =
+ sizeof(struct QBlockOption_qcow);
+ break;
+ case QB_FMT_QCOW2:
+ (*op)->o_fmt.fmt_op.o_qcow2.struct_size =
+ sizeof(struct QBlockOption_qcow2);
+ break;
+ case QB_FMT_RAW:
+ (*op)->o_fmt.fmt_op.o_raw.struct_size =
+ sizeof(struct QBlockOption_raw);
+ break;
+ case QB_FMT_RBD:
+ (*op)->o_fmt.fmt_op.o_rbd.struct_size =
+ sizeof(struct QBlockOption_rbd);
+ break;
+ case QB_FMT_SHEEPDOG:
+ (*op)->o_fmt.fmt_op.o_sheepdog.struct_size =
+ sizeof(struct QBlockOption_sheepdog);
+ break;
+ case QB_FMT_VDI:
+ (*op)->o_fmt.fmt_op.o_vdi.struct_size =
+ sizeof(struct QBlockOption_vdi);
+ break;
+ case QB_FMT_VMDK:
+ (*op)->o_fmt.fmt_op.o_vmdk.struct_size =
+ sizeof(struct QBlockOption_vmdk);
+ break;
+ case QB_FMT_VPC:
+ (*op)->o_fmt.fmt_op.o_vpc.struct_size =
+ sizeof(struct QBlockOption_vpc);
+ break;
+ default:
+ break;
+ }
+ (*op)->o_fmt.fmt_type = fmt;
+ return 0;
+}
+
+/*
+ free QBlockOptionCreate structure.
+ params:
+ op: in, *op will be set as NULL after called.
+ return:
+ void
+ */
+static inline void qb_oc_free(struct QBlockOptionCreate **op)
+{
+ free(*op);
+ *op = NULL;
+}
+/*
+ create a block file.
+ params:
+ qbs: in, pointer to QBlockState.
+ op: in, create option.
+ return:
+ negative on fail, 0 on success.
+ */
+int qb_create(struct QBlockState *qbs, struct QBlockOptionCreate *op);
+
+
+/* sync access */
+/*
+ block sync read.
+ params:
+ qbs: in, pointer to QBlockState.
+ buf: out, buffer that receive the content.
+ len: in, length to read.
+ offset: in, offset in the block data.
+ return:
+ negative on fail, 0 on success.
+ */
+int qb_read(struct QBlockState *qbs, const void *buf, size_t len,
+ off_t offset);
+
+/*
+ block sync read.
+ params:
+ qbs: in, pointer to QBlockState.
+ buf: in, buffer that would be wrote.
+ len: in, length to write.
+ offset: in, offset in the block data.
+ return:
+ negative on fail, 0 on success.
+ */
+int qb_write(struct QBlockState *qbs, const void *buf, size_t len,
+ off_t offset);
+
+/*
+ block sync flush.
+ params:
+ qbs: in, pointer to QBlockState.
+ return:
+ negative on fail, 0 on success.
+ */
+int qb_flush(struct QBlockState *qbs);
+
+/* information */
+/* image related info, static information, from user perspective. */
+/* now it is a plain structure, wonder if it could be foldered into embbed one
+ to reflect that format related information better. */
+struct QBlockInfoImage {
+ int struct_size;
+ char *filename;
+ enum QBlockProtocol protocol;
+ enum QBlockFormat format;
+ size_t virt_size;
+ /* advance info */
+ size_t allocated_size;
+ bool encrypt;
+ char *backing_filename;
+};
+
+/* image info */
+/*
+ get image info.
+ params:
+ qbs: in, pointer to QBlockState.
+ info, out, pointer that would receive the information.
+ return:
+ negative on fail, 0 on success.
+ */
+int qb_infoimage_get(struct QBlockState *qbs, struct QBlockInfoImage **info);
+
+/*
+ free image info.
+ params:
+ info, in, pointer, *info would be set to NULL after function called.
+ return:
+ void.
+ */
+void qb_infoimage_free(struct QBlockInfoImage **info);
+
+/* misc */
+bool qb_supports_format(enum QBlockFormat fmt);
+bool qb_supports_protocol(enum QBlockProtocol proto);
+
A comment here stating that the string may not be free()d.