From patchwork Sat Sep 29 08:13:35 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wayne Xia X-Patchwork-Id: 188019 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 D11092C00F1 for ; Sat, 29 Sep 2012 18:15:31 +1000 (EST) Received: from localhost ([::1]:59095 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1THsCv-0004pv-Sg for incoming@patchwork.ozlabs.org; Sat, 29 Sep 2012 04:15:29 -0400 Received: from eggs.gnu.org ([208.118.235.92]:58607) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1THsCb-0004gv-3o for qemu-devel@nongnu.org; Sat, 29 Sep 2012 04:15:10 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1THsCZ-0004fk-An for qemu-devel@nongnu.org; Sat, 29 Sep 2012 04:15:08 -0400 Received: from e28smtp06.in.ibm.com ([122.248.162.6]:36975) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1THsCY-0004Zv-EF for qemu-devel@nongnu.org; Sat, 29 Sep 2012 04:15:07 -0400 Received: from /spool/local by e28smtp06.in.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Sat, 29 Sep 2012 13:45:03 +0530 Received: from d28relay02.in.ibm.com (9.184.220.59) by e28smtp06.in.ibm.com (192.168.1.136) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Sat, 29 Sep 2012 13:45:01 +0530 Received: from d28av04.in.ibm.com (d28av04.in.ibm.com [9.184.220.66]) by d28relay02.in.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id q8T8F0EM39125160 for ; Sat, 29 Sep 2012 13:45:00 +0530 Received: from d28av04.in.ibm.com (loopback [127.0.0.1]) by d28av04.in.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id q8T8F0FR030421 for ; Sat, 29 Sep 2012 18:15:00 +1000 Received: from RedHat62GAWSWenchao (wenchaox.cn.ibm.com [9.115.122.38]) by d28av04.in.ibm.com (8.14.4/8.13.1/NCO v10.0 AVin) with ESMTP id q8T8DKHw027550; Sat, 29 Sep 2012 18:14:59 +1000 From: Wenchao Xia To: qemu-devel@nongnu.org Date: Sat, 29 Sep 2012 16:13:35 +0800 Message-Id: <1348906418-16471-3-git-send-email-xiawenc@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1348906418-16471-1-git-send-email-xiawenc@linux.vnet.ibm.com> References: <1348906418-16471-1-git-send-email-xiawenc@linux.vnet.ibm.com> x-cbid: 12092908-9574-0000-0000-000004A3C515 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 122.248.162.6 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 V5 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 macro 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 | 75 ++++++++++++ libqblock/libqblock-types.h | 256 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 331 insertions(+), 0 deletions(-) diff --git a/libqblock/libqblock-internal.h b/libqblock/libqblock-internal.h index e69de29..52f567a 100644 --- a/libqblock/libqblock-internal.h +++ b/libqblock/libqblock-internal.h @@ -0,0 +1,75 @@ +/* + * 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 FUNC_STRDUP(p) g_strdup((p)) + +#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 QBlockContext { + /* 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 */ +}; + +/** + * 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 properties directly. + * + * @virt_size: virtual size, it is always not NULL. + * @backing_loc: backing file location. + * @encrypt: encryption flag. +*/ + +struct QBlockStaticInfoAddr { + uint64_t *virt_size; + QBlockLocationInfo *backing_loc; + bool *encrypt; +}; + +#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 index e69de29..3e67aa2 100644 --- a/libqblock/libqblock-types.h +++ b/libqblock/libqblock-types.h @@ -0,0 +1,256 @@ +/* + * 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 +#endif + +/* this library is designed around this core struct. */ +typedef struct QBlockState QBlockState; + +/* every thread should have a context. */ +typedef struct QBlockContext QBlockContext; + +/* 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 QBlockProtocol { + QB_PROTO_NONE = 0, + QB_PROTO_FILE, + QB_PROTO_MAX +} QBlockProtocol; + +typedef struct QBlockProtocolOptionsFile { + const char *filename; +} QBlockProtocolOptionsFile; + +/** + * struct QBlockLocationInfo: contains information about how to find the image + * + * @prot_type: protocol type, now only support FILE. + * @o_file: file protocol related attributes. + * @reserved: reserved bytes for ABI. + */ +#define QBLOCK_PROT_OPTIONS_UNION_SIZE (512) +typedef struct QBlockLocationInfo { + QBlockProtocol prot_type; + union { + QBlockProtocolOptionsFile o_file; + uint64_t reserved[QBLOCK_PROT_OPTIONS_UNION_SIZE/8]; + }; +} QBlockLocationInfo; + + +/* format related options */ +typedef enum QBlockFormat { + 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 +} QBlockFormat; + +typedef struct QBlockFormatOptionsCOW { + uint64_t virt_size; + QBlockLocationInfo backing_loc; +} QBlockFormatOptionsCOW; + +typedef struct QBlockFormatOptionsQED { + uint64_t virt_size; + QBlockLocationInfo backing_loc; + QBlockFormat backing_fmt; + uint64_t cluster_size; /* unit is bytes */ + uint64_t table_size; /* unit is clusters */ +} QBlockFormatOptionsQED; + +typedef struct QBlockFormatOptionsQCOW { + uint64_t virt_size; + QBlockLocationInfo backing_loc; + bool encrypt; +} QBlockFormatOptionsQCOW; + +/* "Compatibility level (0.10 or 1.1)" */ +typedef enum QBlockFormatOptionsQCOW2CompatLv { + QB_FMT_QCOW2_COMPAT_DEFAULT = 0, + QB_FMT_QCOW2_COMPAT_V0_10, + QB_FMT_QCOW2_COMPAT_V1_10, +} QBlockFormatOptionsQCOW2CompatLv; + +/* off or metadata */ +typedef enum QBlockFormatOptionsQCOW2PreAlloc { + QB_FMT_QCOW2_PREALLOC_DEFAULT = 0, + QB_FMT_QCOW2_PREALLOC_OFF, + QB_FMT_QCOW2_PREALLOC_METADATA, +} QBlockFormatOptionsQCOW2PreAlloc; + +typedef struct QBlockFormatOptionsQCOW2 { + uint64_t virt_size; + QBlockLocationInfo backing_loc; + QBlockFormat backing_fmt; + bool encrypt; + uint64_t cluster_size; /* unit is bytes */ + QBlockFormatOptionsQCOW2CompatLv cpt_lv; + QBlockFormatOptionsQCOW2PreAlloc pre_mode; +} QBlockFormatOptionsQCOW2; + +typedef struct QBlockFormatOptionsRAW { + uint64_t virt_size; +} QBlockFormatOptionsRAW; + +typedef struct QBlockFormatOptionsRBD { + uint64_t virt_size; + uint64_t cluster_size; +} QBlockFormatOptionsRBD; + +/* off or full */ +typedef enum QBlockFormatOptionsSDPreAlloc { + QB_FMT_SD_PREALLOC_DEFAULT = 0, + QB_FMT_SD_PREALLOC_OFF, + QB_FMT_SD_PREALLOC_FULL, +} QBlockFormatOptionsSDPreAlloc; + +typedef struct QBlockFormatOptionsSD { + uint64_t virt_size; + QBlockLocationInfo backing_loc; + QBlockFormatOptionsSDPreAlloc pre_mode; +} QBlockFormatOptionsSD; + +typedef enum QBlockFormatOptionsVDIPreAlloc { + QB_FMT_VDI_PREALLOC_DEFAULT = 0, + QB_FMT_VDI_PREALLOC_OFF, + QB_FMT_VDI_PREALLOC_METADATA, +} QBlockFormatOptionsVDIPreAlloc; + +typedef struct QBlockFormatOptionsVDI { + uint64_t virt_size; + uint64_t cluster_size; + QBlockFormatOptionsVDIPreAlloc pre_mode; +} QBlockFormatOptionsVDI; + +/* whether compact to vmdk verion 6 */ +typedef enum QBlockFormatOptionsVMDKCompatLv { + QB_FMT_VMDK_COMPAT_DEFAULT = 0, + QB_FMT_VMDK_COMPAT_VMDKV6_FALSE, + QB_FMT_VMDK_COMPAT_VMDKV6_TRUE, +} QBlockFormatOptionsVMDKCompatLv; + +/* vmdk flat extent format, values: +"{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | +twoGbMaxExtentFlat | streamOptimized} */ +typedef enum QBlockFormatOptionsVMDKSubfmt { + QB_FMT_VMDK_SUBFMT_DEFAULT = 0, + QB_FMT_VMDK_SUBFMT_MONOLITHIC_SPARSE, + QB_FMT_VMDK_SUBFMT_MONOLITHIC_FLAT, + QB_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_SPARSE, + QB_FMT_VMDK_SUBFMT_TWOGBMAX_EXTENT_FLAT, + QB_FMT_VMDK_SUBFMT_STREAM_OPTIMIZED, +} QBlockFormatOptionsVMDKSubfmt; + +typedef struct QBlockFormatOptionsVMDK { + uint64_t virt_size; + QBlockLocationInfo backing_loc; + QBlockFormatOptionsVMDKCompatLv cpt_lv; + QBlockFormatOptionsVMDKSubfmt subfmt; +} QBlockFormatOptionsVMDK; + +/* "{dynamic (default) | fixed} " */ +typedef enum QBlockFormatOptionsVPCSubfmt { + QB_FMT_VPC_SUBFMT_DEFAULT = 0, + QB_FMT_VPC_SUBFMT_DYNAMIC, + QB_FMT_VPC_SUBFMT_FIXED, +} QBlockFormatOptionsVPCSubfmt; + +typedef struct QBlockFormatOptionsVPC { + uint64_t virt_size; + QBlockFormatOptionsVPCSubfmt subfmt; +} QBlockFormatOptionsVPC; + +#define QBLOCK_FMT_OPTIONS_UNION_SIZE (QBLOCK_PROT_OPTIONS_UNION_SIZE*2) + +/** + * struct QBlockFormatInfo: contains information about how to retrieve data + * from the image + * + * @fmt_type: format type. + * @o_cow~@o_vdi: format related attributes. + * @reserved: reserved bytes for ABI. + */ +typedef struct QBlockFormatInfo { + QBlockFormat fmt_type; + union { + QBlockFormatOptionsCOW o_cow; + QBlockFormatOptionsQED o_qed; + QBlockFormatOptionsQCOW o_qcow; + QBlockFormatOptionsQCOW2 o_qcow2; + QBlockFormatOptionsRAW o_raw; + QBlockFormatOptionsRBD o_rbd; + QBlockFormatOptionsSD o_sd; + QBlockFormatOptionsVDI o_vdi; + QBlockFormatOptionsVMDK o_vmdk; + QBlockFormatOptionsVPC o_vpc; + uint64_t reserved[QBLOCK_FMT_OPTIONS_UNION_SIZE/8]; + }; +} QBlockFormatInfo; + +typedef struct QBlockStaticInfoAddr QBlockStaticInfoAddr; + +/** + * QBlockStaticInfo: information about the block image. + * + * @member_addr: libqblock internal usage. + * @loc: location information. + * @fmt: format information. + * @sector_size: how many bytes in a sector, it is 512 usually. + */ +typedef struct QBlockStaticInfo { + QBlockStaticInfoAddr *member_addr; + QBlockLocationInfo loc; + QBlockFormatInfo fmt; + int sector_size; +} QBlockStaticInfo; + + +#endif