static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
{
    BDRVCloopState *s = bs->opaque;
    uint32_t offsets_size, max_compressed_block_size = 1, i;
    int ret;
    bs->read_only = 1;
    /* read header */
    ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
    if (ret < 0) {
        return ret;
    s->block_size = be32_to_cpu(s->block_size);
    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4);
    if (ret < 0) {
        return ret;
    s->n_blocks = be32_to_cpu(s->n_blocks);
    /* read offsets */
    offsets_size = s->n_blocks * sizeof(uint64_t);
    s->offsets = g_malloc(offsets_size);
    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size);
    if (ret < 0) {
        goto fail;
    for(i=0;i<s->n_blocks;i++) {
        s->offsets[i] = be64_to_cpu(s->offsets[i]);
        if (i > 0) {
            uint32_t size = s->offsets[i] - s->offsets[i - 1];
            if (size > max_compressed_block_size) {
                max_compressed_block_size = size;
    /* initialize zlib engine */
    s->compressed_block = g_malloc(max_compressed_block_size + 1);
    s->uncompressed_block = g_malloc(s->block_size);
    if (inflateInit(&s->zstream) != Z_OK) {
        ret = -EINVAL;
        goto fail;
    s->current_block = s->n_blocks;
    s->sectors_per_block = s->block_size/512;
    bs->total_sectors = s->n_blocks * s->sectors_per_block;
    qemu_co_mutex_init(&s->lock);
    return 0;
fail:
    g_free(s->offsets);
    g_free(s->compressed_block);
    g_free(s->uncompressed_block);
    return ret;
static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
{
    BDRVCloopState *s = bs->opaque;
    uint32_t offsets_size, max_compressed_block_size = 1, i;
    int ret;
    bs->read_only = 1;
    
    ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
    if (ret < 0) {
        return ret;
    s->block_size = be32_to_cpu(s->block_size);
    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4);
    if (ret < 0) {
        return ret;
    s->n_blocks = be32_to_cpu(s->n_blocks);
    
    offsets_size = s->n_blocks * sizeof(uint64_t);
    s->offsets = g_malloc(offsets_size);
    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size);
    if (ret < 0) {
        goto fail;
    for(i=0;i<s->n_blocks;i++) {
        s->offsets[i] = be64_to_cpu(s->offsets[i]);
        if (i > 0) {
            uint32_t size = s->offsets[i] - s->offsets[i - 1];
            if (size > max_compressed_block_size) {
                max_compressed_block_size = size;
    
    s->compressed_block = g_malloc(max_compressed_block_size + 1);
    s->uncompressed_block = g_malloc(s->block_size);
    if (inflateInit(&s->zstream) != Z_OK) {
        ret = -EINVAL;
        goto fail;
    s->current_block = s->n_blocks;
    s->sectors_per_block = s->block_size/512;
    bs->total_sectors = s->n_blocks * s->sectors_per_block;
    qemu_co_mutex_init(&s->lock);
    return 0;
fail:
    g_free(s->offsets);
    g_free(s->compressed_block);
    g_free(s->uncompressed_block);
    return ret;
static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,
                      Error **VAR_3)
{
    BDRVCloopState *s = VAR_0->opaque;
    uint32_t offsets_size, max_compressed_block_size = 1, i;
    int VAR_4;
    VAR_0->read_only = 1;
    
    VAR_4 = bdrv_pread(VAR_0->file, 128, &s->block_size, 4);
    if (VAR_4 < 0) {
        return VAR_4;
    s->block_size = be32_to_cpu(s->block_size);
    VAR_4 = bdrv_pread(VAR_0->file, 128 + 4, &s->n_blocks, 4);
    if (VAR_4 < 0) {
        return VAR_4;
    s->n_blocks = be32_to_cpu(s->n_blocks);
    
    offsets_size = s->n_blocks * sizeof(uint64_t);
    s->offsets = g_malloc(offsets_size);
    VAR_4 = bdrv_pread(VAR_0->file, 128 + 4 + 4, s->offsets, offsets_size);
    if (VAR_4 < 0) {
        goto fail;
    for(i=0;i<s->n_blocks;i++) {
        s->offsets[i] = be64_to_cpu(s->offsets[i]);
        if (i > 0) {
            uint32_t size = s->offsets[i] - s->offsets[i - 1];
            if (size > max_compressed_block_size) {
                max_compressed_block_size = size;
    
    s->compressed_block = g_malloc(max_compressed_block_size + 1);
    s->uncompressed_block = g_malloc(s->block_size);
    if (inflateInit(&s->zstream) != Z_OK) {
        VAR_4 = -EINVAL;
        goto fail;
    s->current_block = s->n_blocks;
    s->sectors_per_block = s->block_size/512;
    VAR_0->total_sectors = s->n_blocks * s->sectors_per_block;
    qemu_co_mutex_init(&s->lock);
    return 0;
fail:
    g_free(s->offsets);
    g_free(s->compressed_block);
    g_free(s->uncompressed_block);
    return VAR_4;
static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,
Error **VAR_3)
{ BDRVCloopState *s = VAR_0->opaque; uint32_t offsets_size, max_compressed_block_size = 1, i; int VAR_4; VAR_0->read_only = 1; VAR_4 = bdrv_pread(VAR_0->file, 128, &s->block_size, 4); if (VAR_4 < 0) { return VAR_4; s->block_size = be32_to_cpu(s->block_size); VAR_4 = bdrv_pread(VAR_0->file, 128 + 4, &s->n_blocks, 4); if (VAR_4 < 0) { return VAR_4; s->n_blocks = be32_to_cpu(s->n_blocks); offsets_size = s->n_blocks * sizeof(uint64_t); s->offsets = g_malloc(offsets_size); VAR_4 = bdrv_pread(VAR_0->file, 128 + 4 + 4, s->offsets, offsets_size); if (VAR_4 < 0) { goto fail; for(i=0;i<s->n_blocks;i++) { s->offsets[i] = be64_to_cpu(s->offsets[i]); if (i > 0) { uint32_t size = s->offsets[i] - s->offsets[i - 1]; if (size > max_compressed_block_size) { max_compressed_block_size = size; s->compressed_block = g_malloc(max_compressed_block_size + 1); s->uncompressed_block = g_malloc(s->block_size); if (inflateInit(&s->zstream) != Z_OK) { VAR_4 = -EINVAL; goto fail; s->current_block = s->n_blocks; s->sectors_per_block = s->block_size/512; VAR_0->total_sectors = s->n_blocks * s->sectors_per_block; qemu_co_mutex_init(&s->lock); return 0; fail:
g_free(s->offsets); g_free(s->compressed_block); g_free(s->uncompressed_block); return VAR_4;