From patchwork Tue Sep 18 09:01:56 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wayne Xia X-Patchwork-Id: 184658 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 247812C0096 for ; Tue, 18 Sep 2012 19:04:29 +1000 (EST) Received: from localhost ([::1]:39410 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TDtjG-0004R5-Tp for incoming@patchwork.ozlabs.org; Tue, 18 Sep 2012 05:04:26 -0400 Received: from eggs.gnu.org ([208.118.235.92]:39006) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TDtik-00043I-B6 for qemu-devel@nongnu.org; Tue, 18 Sep 2012 05:04:04 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1TDtie-0005u1-Is for qemu-devel@nongnu.org; Tue, 18 Sep 2012 05:03:54 -0400 Received: from e23smtp05.au.ibm.com ([202.81.31.147]:45399) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TDtid-0005td-O8 for qemu-devel@nongnu.org; Tue, 18 Sep 2012 05:03:48 -0400 Received: from /spool/local by e23smtp05.au.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Tue, 18 Sep 2012 19:02:34 +1000 Received: from d23relay05.au.ibm.com (202.81.31.247) by e23smtp05.au.ibm.com (202.81.31.211) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Tue, 18 Sep 2012 19:02:29 +1000 Received: from d23av04.au.ibm.com (d23av04.au.ibm.com [9.190.235.139]) by d23relay05.au.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id q8I8sCqf065846 for ; Tue, 18 Sep 2012 18:54:12 +1000 Received: from d23av04.au.ibm.com (loopback [127.0.0.1]) by d23av04.au.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id q8I93Z6c007102 for ; Tue, 18 Sep 2012 19:03:36 +1000 Received: from RedHat62GAWSWenchao (wenchaox.cn.ibm.com [9.115.122.81] (may be forged)) by d23av04.au.ibm.com (8.14.4/8.13.1/NCO v10.0 AVin) with ESMTP id q8I9230x004250; Tue, 18 Sep 2012 19:03:33 +1000 From: Wenchao Xia To: qemu-devel@nongnu.org Date: Tue, 18 Sep 2012 17:01:56 +0800 Message-Id: <1347958919-30380-3-git-send-email-xiawenc@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1347958919-30380-1-git-send-email-xiawenc@linux.vnet.ibm.com> References: <1347958919-30380-1-git-send-email-xiawenc@linux.vnet.ibm.com> x-cbid: 12091809-1396-0000-0000-000001E31D0B X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 202.81.31.147 Cc: kwolf@redhat.com, aliguori@us.ibm.com, stefanha@gmail.com, blauwirbel@gmail.com, pbonzini@redhat.com, eblake@redhat.com, Wenchao Xia Subject: [Qemu-devel] [PATCH V3 2/5] libqblock type defines 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 type and defines used in APIs, one file for public usage by user, one for libqblock internal usage. Signed-off-by: Wenchao Xia --- libqblock/libqblock-internal.h | 56 +++++++++ libqblock/libqblock-types.h | 268 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 324 insertions(+), 0 deletions(-) create mode 100644 libqblock/libqblock-internal.h create mode 100644 libqblock/libqblock-types.h diff --git a/libqblock/libqblock-internal.h b/libqblock/libqblock-internal.h new file mode 100644 index 0000000..87f32be --- /dev/null +++ b/libqblock/libqblock-internal.h @@ -0,0 +1,56 @@ +/* + * 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_INTERNAL +#define LIBQBLOCK_INTERNAL + +#include "glib.h" + +#include "block.h" +#include "block_int.h" +#include "libqblock-types.h" + +/* this file contains defines and types used inside the library. */ + +#define FUNC_FREE(p) g_free((p)) +#define FUNC_MALLOC(size) g_malloc((size)) +#define FUNC_CALLOC(nmemb, size) g_malloc0((nmemb)*(size)) + +#define CLEAN_FREE(p) { \ + FUNC_FREE(p); \ + (p) = NULL; \ +} + +/* details should be hidden to user */ +struct QBlockState { + BlockDriverState *bdrvs; + /* internal used file name now, if it is not NULL, it means + image was opened. + */ + char *filename; +} ; + +struct QBroker { + /* last error */ + GError *g_error; + int err_ret; /* 1st level of error, the libqblock error number */ + int err_no; /* 2nd level of error, errno what below reports */ +}; + +#define G_LIBQBLOCK_ERROR g_libqbock_error_quark() + +static inline GQuark g_libqbock_error_quark(void) +{ + return g_quark_from_static_string("g-libqblock-error-quark"); +} +#endif diff --git a/libqblock/libqblock-types.h b/libqblock/libqblock-types.h new file mode 100644 index 0000000..3c548b8 --- /dev/null +++ b/libqblock/libqblock-types.h @@ -0,0 +1,268 @@ +/* + * 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_TYPES_H +#define LIBQBLOCK_TYPES_H + +#include +#include +#include + +#if defined(__GNUC__) && __GNUC__ >= 4 + #ifdef LIBQB_BUILD + #define DLL_PUBLIC __attribute__((visibility("default"))) + #else + #define DLL_PUBLIC + #endif +#else + #warning : gcc compiler version < 4, symbols can not be hidden. +#endif + +/* this library is designed around this core struct. */ +typedef struct QBlockState QBlockState; + +/* every thread should have a broker. */ +typedef struct QBroker QBroker; + +/* flag used in open and create */ +#define LIBQBLOCK_O_RDWR 0x0002 +/* do not use the host page cache */ +#define LIBQBLOCK_O_NOCACHE 0x0020 +/* use write-back caching */ +#define LIBQBLOCK_O_CACHE_WB 0x0040 +/* don't open the backing file */ +#define LIBQBLOCK_O_NO_BACKING 0x0100 +/* disable flushing on this disk */ +#define LIBQBLOCK_O_NO_FLUSH 0x0200 + +#define LIBQBLOCK_O_CACHE_MASK \ + (LIBQBLOCK_O_NOCACHE | LIBQBLOCK_O_CACHE_WB | LIBQBLOCK_O_NO_FLUSH) + +#define LIBQBLOCK_O_VALID_MASK \ + (LIBQBLOCK_O_RDWR | LIBQBLOCK_O_NOCACHE | LIBQBLOCK_O_CACHE_WB | \ + LIBQBLOCK_O_NO_BACKING | LIBQBLOCK_O_NO_FLUSH) + +typedef enum QBlockProtType { + QB_PROT_NONE = 0, + QB_PROT_FILE, + QB_PROT_MAX +} QBlockProtType; + +typedef struct QBlockProtOptionFile { + const char *filename; +} QBlockProtOptionFile; + +#define QBLOCK_PROT_OPTIONS_UNION_SIZE (512) +typedef union QBlockProtOptionsUnion { + QBlockProtOptionFile o_file; + uint8_t reserved[QBLOCK_PROT_OPTIONS_UNION_SIZE]; +} QBlockProtOptionsUnion; + +/** + * struct QBlockProtInfo: contains information about how to find the image + * + * @prot_type: protocol type, now only support FILE. + * @prot_op: protocol related options. + */ +typedef struct QBlockProtInfo { + QBlockProtType prot_type; + QBlockProtOptionsUnion prot_op; +} QBlockProtInfo; + + +/* format related options */ +typedef enum QBlockFmtType { + QB_FMT_NONE = 0, + QB_FMT_COW, + QB_FMT_QED, + QB_FMT_QCOW, + QB_FMT_QCOW2, + QB_FMT_RAW, + QB_FMT_RBD, + QB_FMT_SHEEPDOG, + QB_FMT_VDI, + QB_FMT_VMDK, + QB_FMT_VPC, + QB_FMT_MAX +} QBlockFmtType; + +typedef struct QBlockFmtOptionCow { + uint64_t virt_size; + QBlockProtInfo backing_loc; +} QBlockFmtOptionCow; + +typedef struct QBlockFmtOptionQed { + uint64_t virt_size; + QBlockProtInfo backing_loc; + QBlockFmtType backing_fmt; + uint64_t cluster_size; /* unit is bytes */ + uint64_t table_size; /* unit is clusters */ +} QBlockFmtOptionQed; + +typedef struct QBlockFmtOptionQcow { + uint64_t virt_size; + QBlockProtInfo backing_loc; + bool encrypt; +} QBlockFmtOptionQcow; + +/* "Compatibility level (0.10 or 1.1)" */ +typedef enum QBlockFmtOptionQcow2CptLv { + QBO_FMT_QCOW2_CPT_NONE = 0, + QBO_FMT_QCOW2_CPT_V010, + QBO_FMT_QCOW2_CPT_V110, +} QBlockFmtOptionQcow2CptLv; + +/* off or metadata */ +typedef enum QBlockFmtOptionQcow2PreAllocType { + QBO_FMT_QCOW2_PREALLOC_NONE = 0, + QBO_FMT_QCOW2_PREALLOC_OFF, + QBO_FMT_QCOW2_PREALLOC_METADATA, +} QBlockFmtOptionQcow2PreAllocType; + +typedef struct QBlockFmtOptionQcow2 { + uint64_t virt_size; + QBlockProtInfo backing_loc; + QBlockFmtType backing_fmt; + bool encrypt; + uint64_t cluster_size; /* unit is bytes */ + QBlockFmtOptionQcow2CptLv cpt_lv; + QBlockFmtOptionQcow2PreAllocType pre_mode; +} QBlockFmtOptionQcow2; + +typedef struct QBlockFmtOptionRaw { + uint64_t virt_size; +} QBlockFmtOptionRaw; + +typedef struct QBlockFmtOptionRbd { + uint64_t virt_size; + uint64_t cluster_size; +} QBlockFmtOptionRbd; + +/* off or full */ +typedef enum QBlockFmtOptionSheepdogPreAllocType { + QBO_FMT_SD_PREALLOC_NONE = 0, + QBO_FMT_SD_PREALLOC_OFF, + QBO_FMT_SD_PREALLOC_FULL, +} QBlockFmtOptionSheepdogPreAllocType; + +typedef struct QBlockFmtOptionSheepdog { + uint64_t virt_size; + QBlockProtInfo backing_loc; + QBlockFmtOptionSheepdogPreAllocType pre_mode; +} QBlockFmtOptionSheepdog; + +typedef enum QBlockFmtOptionVdiPreAllocType { + QBO_FMT_VDI_PREALLOC_NONE = 0, + QBO_FMT_VDI_PREALLOC_FALSE, + QBO_FMT_VDI_PREALLOC_TRUE, +} QBlockFmtOptionVdiPreAllocType; + +typedef struct QBlockFmtOptionVdi { + uint64_t virt_size; + uint64_t cluster_size; + QBlockFmtOptionVdiPreAllocType pre_mode; +} QBlockFmtOptionVdi; + +/* whether compact to vmdk verion 6 */ +typedef enum QBlockFmtOptionVmdkCptLv { + QBO_FMT_VMDK_CPT_NONE = 0, + QBO_FMT_VMDK_CPT_VMDKV6_FALSE, + QBO_FMT_VMDK_CPT_VMDKV6_TRUE, +} QBlockFmtOptionVmdkCptLv; + +/* vmdk flat extent format, values: +"{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | +twoGbMaxExtentFlat | streamOptimized} */ +typedef enum QBlockFmtOptionVmdkSubfmtType { + QBO_FMT_VMDK_SUBFMT_MONOLITHIC_NONE = 0, + QBO_FMT_VMDK_SUBFMT_MONOLITHIC_SPARSE, + QBO_FMT_VMDK_SUBFMT_MONOLITHIC_FLAT, + QBO_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_SPARSE, + QBO_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_FLAT, + QBO_FMT_VMDK_SUBFMT_STREAM_OPTIMIZED, +} QBlockFmtOptionVmdkSubfmtType; + +typedef struct QBlockFmtOptionVmdk { + uint64_t virt_size; + QBlockProtInfo backing_loc; + QBlockFmtOptionVmdkCptLv cpt_lv; + QBlockFmtOptionVmdkSubfmtType subfmt; +} QBlockFmtOptionVmdk; + +/* "{dynamic (default) | fixed} " */ +typedef enum QBlockFmtOptionVpcSubfmtType { + QBO_FMT_VPC_SUBFMT_NONE = 0, + QBO_FMT_VPC_SUBFMT_DYNAMIC, + QBO_FMT_VPC_SUBFMT_FIXED, +} QBlockFmtOptionVpcSubfmtType; + +typedef struct QBlockFmtOptionVpc { + uint64_t virt_size; + QBlockFmtOptionVpcSubfmtType subfmt; +} QBlockFmtOptionVpc; + +#define QBLOCK_FMT_OPTIONS_UNION_SIZE (QBLOCK_PROT_OPTIONS_UNION_SIZE*2) +typedef union QBlockFmtOptionsUnion { + QBlockFmtOptionCow o_cow; + QBlockFmtOptionQed o_qed; + QBlockFmtOptionQcow o_qcow; + QBlockFmtOptionQcow2 o_qcow2; + QBlockFmtOptionRaw o_raw; + QBlockFmtOptionRbd o_rbd; + QBlockFmtOptionSheepdog o_sheepdog; + QBlockFmtOptionVdi o_vdi; + QBlockFmtOptionVmdk o_vmdk; + QBlockFmtOptionVpc o_vpc; + uint8_t reserved[QBLOCK_FMT_OPTIONS_UNION_SIZE]; +} QBlockFmtOptionsUnion; + +typedef struct QBlockFmtInfo { + QBlockFmtType fmt_type; + QBlockFmtOptionsUnion fmt_op; +} QBlockFmtInfo; + +/** + * QBlockStaticInfoAddr: a structure contains a set of pointer. + * + * this struct contains a set of pointer pointing to some + * property related to format or protocol. If a property is not available, + * it will be set as NULL. User could use this to get property directly. + * + * @virt_size: virtual size, it is always not NULL. + * @backing_loc: backing file location. + * @encrypt: encryption flag. +*/ + +typedef struct QBlockStaticInfoAddr { + uint64_t *virt_size; + QBlockProtInfo *backing_loc; + bool *encrypt; +} QBlockStaticInfoAddr; + +/** + * QBlockStaticInfo: information about the block image. + * + * @member_addr: contains pointer which can be used to access the structure. + * @loc: location information. + * @fmt: format information. + * @sector_size: how many bytes in a sector, it is 512 usually. + */ +typedef struct QBlockStaticInfo { + QBlockStaticInfoAddr *member_addr; + QBlockProtInfo loc; + QBlockFmtInfo fmt; + int sector_size; +} QBlockStaticInfo; + + +#endif