1 /* 2 * QEMU Block driver for CLOOP images 3 * 4 * Copyright (c) 2004 Johannes E. Schindelin 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu-common.h" 25 #include "block_int.h" 26 #include "module.h" 27 #include <zlib.h> 28 29 typedef struct BDRVCloopState { 30 CoMutex lock; 31 uint32_t block_size; 32 uint32_t n_blocks; 33 uint64_t* offsets; 34 uint32_t sectors_per_block; 35 uint32_t current_block; 36 uint8_t *compressed_block; 37 uint8_t *uncompressed_block; 38 z_stream zstream; 39 } BDRVCloopState; 40 41 static int cloop_probe(const uint8_t *buf, int buf_size, const char *filename) 42 { 43 const char* magic_version_2_0="#!/bin/sh\n" 44 "#V2.0 Format\n" 45 "modprobe cloop file=$0 && mount -r -t iso9660 /dev/cloop $1\n"; 46 int length=strlen(magic_version_2_0); 47 if(length>buf_size) 48 length=buf_size; 49 if(!memcmp(magic_version_2_0,buf,length)) 50 return 2; 51 return 0; 52 } 53 54 static int cloop_open(BlockDriverState *bs, int flags) 55 { 56 BDRVCloopState *s = bs->opaque; 57 uint32_t offsets_size,max_compressed_block_size=1,i; 58 59 bs->read_only = 1; 60 61 /* read header */ 62 if (bdrv_pread(bs->file, 128, &s->block_size, 4) < 4) { 63 goto cloop_close; 64 } 65 s->block_size = be32_to_cpu(s->block_size); 66 67 if (bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4) < 4) { 68 goto cloop_close; 69 } 70 s->n_blocks = be32_to_cpu(s->n_blocks); 71 72 /* read offsets */ 73 offsets_size = s->n_blocks * sizeof(uint64_t); 74 s->offsets = g_malloc(offsets_size); 75 if (bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size) < 76 offsets_size) { 77 goto cloop_close; 78 } 79 for(i=0;i<s->n_blocks;i++) { 80 s->offsets[i]=be64_to_cpu(s->offsets[i]); 81 if(i>0) { 82 uint32_t size=s->offsets[i]-s->offsets[i-1]; 83 if(size>max_compressed_block_size) 84 max_compressed_block_size=size; 85 } 86 } 87 88 /* initialize zlib engine */ 89 s->compressed_block = g_malloc(max_compressed_block_size+1); 90 s->uncompressed_block = g_malloc(s->block_size); 91 if(inflateInit(&s->zstream) != Z_OK) 92 goto cloop_close; 93 s->current_block=s->n_blocks; 94 95 s->sectors_per_block = s->block_size/512; 96 bs->total_sectors = s->n_blocks*s->sectors_per_block; 97 qemu_co_mutex_init(&s->lock); 98 return 0; 99 100 cloop_close: 101 return -1; 102 } 103 104 static inline int cloop_read_block(BlockDriverState *bs, int block_num) 105 { 106 BDRVCloopState *s = bs->opaque; 107 108 if(s->current_block != block_num) { 109 int ret; 110 uint32_t bytes = s->offsets[block_num+1]-s->offsets[block_num]; 111 112 ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block, 113 bytes); 114 if (ret != bytes) 115 return -1; 116 117 s->zstream.next_in = s->compressed_block; 118 s->zstream.avail_in = bytes; 119 s->zstream.next_out = s->uncompressed_block; 120 s->zstream.avail_out = s->block_size; 121 ret = inflateReset(&s->zstream); 122 if(ret != Z_OK) 123 return -1; 124 ret = inflate(&s->zstream, Z_FINISH); 125 if(ret != Z_STREAM_END || s->zstream.total_out != s->block_size) 126 return -1; 127 128 s->current_block = block_num; 129 } 130 return 0; 131 } 132 133 static int cloop_read(BlockDriverState *bs, int64_t sector_num, 134 uint8_t *buf, int nb_sectors) 135 { 136 BDRVCloopState *s = bs->opaque; 137 int i; 138 139 for(i=0;i<nb_sectors;i++) { 140 uint32_t sector_offset_in_block=((sector_num+i)%s->sectors_per_block), 141 block_num=(sector_num+i)/s->sectors_per_block; 142 if(cloop_read_block(bs, block_num) != 0) 143 return -1; 144 memcpy(buf+i*512,s->uncompressed_block+sector_offset_in_block*512,512); 145 } 146 return 0; 147 } 148 149 static coroutine_fn int cloop_co_read(BlockDriverState *bs, int64_t sector_num, 150 uint8_t *buf, int nb_sectors) 151 { 152 int ret; 153 BDRVCloopState *s = bs->opaque; 154 qemu_co_mutex_lock(&s->lock); 155 ret = cloop_read(bs, sector_num, buf, nb_sectors); 156 qemu_co_mutex_unlock(&s->lock); 157 return ret; 158 } 159 160 static void cloop_close(BlockDriverState *bs) 161 { 162 BDRVCloopState *s = bs->opaque; 163 if(s->n_blocks>0) 164 free(s->offsets); 165 free(s->compressed_block); 166 free(s->uncompressed_block); 167 inflateEnd(&s->zstream); 168 } 169 170 static BlockDriver bdrv_cloop = { 171 .format_name = "cloop", 172 .instance_size = sizeof(BDRVCloopState), 173 .bdrv_probe = cloop_probe, 174 .bdrv_open = cloop_open, 175 .bdrv_read = cloop_co_read, 176 .bdrv_close = cloop_close, 177 }; 178 179 static void bdrv_cloop_init(void) 180 { 181 bdrv_register(&bdrv_cloop); 182 } 183 184 block_init(bdrv_cloop_init); 185