1 /* 2 * Block driver for Parallels disk image format 3 * 4 * Copyright (c) 2007 Alex Beregszaszi 5 * 6 * This code is based on comparing different disk images created by Parallels. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a copy 9 * of this software and associated documentation files (the "Software"), to deal 10 * in the Software without restriction, including without limitation the rights 11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 * copies of the Software, and to permit persons to whom the Software is 13 * furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included in 16 * all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 * THE SOFTWARE. 25 */ 26 #include "qemu-common.h" 27 #include "block/block_int.h" 28 #include "qemu/module.h" 29 30 /**************************************************************/ 31 32 #define HEADER_MAGIC "WithoutFreeSpace" 33 #define HEADER_VERSION 2 34 #define HEADER_SIZE 64 35 36 // always little-endian 37 struct parallels_header { 38 char magic[16]; // "WithoutFreeSpace" 39 uint32_t version; 40 uint32_t heads; 41 uint32_t cylinders; 42 uint32_t tracks; 43 uint32_t catalog_entries; 44 uint32_t nb_sectors; 45 char padding[24]; 46 } QEMU_PACKED; 47 48 typedef struct BDRVParallelsState { 49 CoMutex lock; 50 51 uint32_t *catalog_bitmap; 52 unsigned int catalog_size; 53 54 unsigned int tracks; 55 } BDRVParallelsState; 56 57 static int parallels_probe(const uint8_t *buf, int buf_size, const char *filename) 58 { 59 const struct parallels_header *ph = (const void *)buf; 60 61 if (buf_size < HEADER_SIZE) 62 return 0; 63 64 if (!memcmp(ph->magic, HEADER_MAGIC, 16) && 65 (le32_to_cpu(ph->version) == HEADER_VERSION)) 66 return 100; 67 68 return 0; 69 } 70 71 static int parallels_open(BlockDriverState *bs, QDict *options, int flags, 72 Error **errp) 73 { 74 BDRVParallelsState *s = bs->opaque; 75 int i; 76 struct parallels_header ph; 77 int ret; 78 79 bs->read_only = 1; // no write support yet 80 81 ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph)); 82 if (ret < 0) { 83 goto fail; 84 } 85 86 if (memcmp(ph.magic, HEADER_MAGIC, 16) || 87 (le32_to_cpu(ph.version) != HEADER_VERSION)) { 88 error_setg(errp, "Image not in Parallels format"); 89 ret = -EINVAL; 90 goto fail; 91 } 92 93 bs->total_sectors = le32_to_cpu(ph.nb_sectors); 94 95 s->tracks = le32_to_cpu(ph.tracks); 96 if (s->tracks == 0) { 97 error_setg(errp, "Invalid image: Zero sectors per track"); 98 ret = -EINVAL; 99 goto fail; 100 } 101 102 s->catalog_size = le32_to_cpu(ph.catalog_entries); 103 if (s->catalog_size > INT_MAX / 4) { 104 error_setg(errp, "Catalog too large"); 105 ret = -EFBIG; 106 goto fail; 107 } 108 s->catalog_bitmap = g_malloc(s->catalog_size * 4); 109 110 ret = bdrv_pread(bs->file, 64, s->catalog_bitmap, s->catalog_size * 4); 111 if (ret < 0) { 112 goto fail; 113 } 114 115 for (i = 0; i < s->catalog_size; i++) 116 le32_to_cpus(&s->catalog_bitmap[i]); 117 118 qemu_co_mutex_init(&s->lock); 119 return 0; 120 121 fail: 122 g_free(s->catalog_bitmap); 123 return ret; 124 } 125 126 static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) 127 { 128 BDRVParallelsState *s = bs->opaque; 129 uint32_t index, offset; 130 131 index = sector_num / s->tracks; 132 offset = sector_num % s->tracks; 133 134 /* not allocated */ 135 if ((index > s->catalog_size) || (s->catalog_bitmap[index] == 0)) 136 return -1; 137 return (uint64_t)(s->catalog_bitmap[index] + offset) * 512; 138 } 139 140 static int parallels_read(BlockDriverState *bs, int64_t sector_num, 141 uint8_t *buf, int nb_sectors) 142 { 143 while (nb_sectors > 0) { 144 int64_t position = seek_to_sector(bs, sector_num); 145 if (position >= 0) { 146 if (bdrv_pread(bs->file, position, buf, 512) != 512) 147 return -1; 148 } else { 149 memset(buf, 0, 512); 150 } 151 nb_sectors--; 152 sector_num++; 153 buf += 512; 154 } 155 return 0; 156 } 157 158 static coroutine_fn int parallels_co_read(BlockDriverState *bs, int64_t sector_num, 159 uint8_t *buf, int nb_sectors) 160 { 161 int ret; 162 BDRVParallelsState *s = bs->opaque; 163 qemu_co_mutex_lock(&s->lock); 164 ret = parallels_read(bs, sector_num, buf, nb_sectors); 165 qemu_co_mutex_unlock(&s->lock); 166 return ret; 167 } 168 169 static void parallels_close(BlockDriverState *bs) 170 { 171 BDRVParallelsState *s = bs->opaque; 172 g_free(s->catalog_bitmap); 173 } 174 175 static BlockDriver bdrv_parallels = { 176 .format_name = "parallels", 177 .instance_size = sizeof(BDRVParallelsState), 178 .bdrv_probe = parallels_probe, 179 .bdrv_open = parallels_open, 180 .bdrv_read = parallels_co_read, 181 .bdrv_close = parallels_close, 182 }; 183 184 static void bdrv_parallels_init(void) 185 { 186 bdrv_register(&bdrv_parallels); 187 } 188 189 block_init(bdrv_parallels_init); 190