1 2 #include "qemu-common.h" 3 #include "block_int.h" 4 #include "module.h" 5 6 static int raw_open(BlockDriverState *bs, int flags) 7 { 8 bs->sg = bs->file->sg; 9 return 0; 10 } 11 12 /* check for the user attempting to write something that looks like a 13 block format header to the beginning of the image and fail out. 14 */ 15 static int check_for_block_signature(BlockDriverState *bs, const uint8_t *buf) 16 { 17 static const uint8_t signatures[][4] = { 18 { 'Q', 'F', 'I', 0xfb }, /* qcow/qcow2 */ 19 { 'C', 'O', 'W', 'D' }, /* VMDK3 */ 20 { 'V', 'M', 'D', 'K' }, /* VMDK4 */ 21 { 'O', 'O', 'O', 'M' }, /* UML COW */ 22 {} 23 }; 24 int i; 25 26 for (i = 0; signatures[i][0] != 0; i++) { 27 if (memcmp(buf, signatures[i], 4) == 0) { 28 return 1; 29 } 30 } 31 32 return 0; 33 } 34 35 static int check_write_unsafe(BlockDriverState *bs, int64_t sector_num, 36 const uint8_t *buf, int nb_sectors) 37 { 38 /* assume that if the user specifies the format explicitly, then assume 39 that they will continue to do so and provide no safety net */ 40 if (!bs->probed) { 41 return 0; 42 } 43 44 if (sector_num == 0 && nb_sectors > 0) { 45 return check_for_block_signature(bs, buf); 46 } 47 48 return 0; 49 } 50 51 static int raw_read(BlockDriverState *bs, int64_t sector_num, 52 uint8_t *buf, int nb_sectors) 53 { 54 return bdrv_read(bs->file, sector_num, buf, nb_sectors); 55 } 56 57 static int raw_write_scrubbed_bootsect(BlockDriverState *bs, 58 const uint8_t *buf) 59 { 60 uint8_t bootsect[512]; 61 62 /* scrub the dangerous signature */ 63 memcpy(bootsect, buf, 512); 64 memset(bootsect, 0, 4); 65 66 return bdrv_write(bs->file, 0, bootsect, 1); 67 } 68 69 static int raw_write(BlockDriverState *bs, int64_t sector_num, 70 const uint8_t *buf, int nb_sectors) 71 { 72 if (check_write_unsafe(bs, sector_num, buf, nb_sectors)) { 73 int ret; 74 75 ret = raw_write_scrubbed_bootsect(bs, buf); 76 if (ret < 0) { 77 return ret; 78 } 79 80 ret = bdrv_write(bs->file, 1, buf + 512, nb_sectors - 1); 81 if (ret < 0) { 82 return ret; 83 } 84 85 return ret + 512; 86 } 87 88 return bdrv_write(bs->file, sector_num, buf, nb_sectors); 89 } 90 91 static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, 92 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 93 BlockDriverCompletionFunc *cb, void *opaque) 94 { 95 return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque); 96 } 97 98 typedef struct RawScrubberBounce 99 { 100 BlockDriverCompletionFunc *cb; 101 void *opaque; 102 QEMUIOVector qiov; 103 } RawScrubberBounce; 104 105 static void raw_aio_writev_scrubbed(void *opaque, int ret) 106 { 107 RawScrubberBounce *b = opaque; 108 109 if (ret < 0) { 110 b->cb(b->opaque, ret); 111 } else { 112 b->cb(b->opaque, ret + 512); 113 } 114 115 qemu_iovec_destroy(&b->qiov); 116 qemu_free(b); 117 } 118 119 static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, 120 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 121 BlockDriverCompletionFunc *cb, void *opaque) 122 { 123 const uint8_t *first_buf; 124 int first_buf_index = 0, i; 125 126 /* This is probably being paranoid, but handle cases of zero size 127 vectors. */ 128 for (i = 0; i < qiov->niov; i++) { 129 if (qiov->iov[i].iov_len) { 130 assert(qiov->iov[i].iov_len >= 512); 131 first_buf_index = i; 132 break; 133 } 134 } 135 136 first_buf = qiov->iov[first_buf_index].iov_base; 137 138 if (check_write_unsafe(bs, sector_num, first_buf, nb_sectors)) { 139 RawScrubberBounce *b; 140 int ret; 141 142 /* write the first sector using sync I/O */ 143 ret = raw_write_scrubbed_bootsect(bs, first_buf); 144 if (ret < 0) { 145 return NULL; 146 } 147 148 /* adjust request to be everything but first sector */ 149 150 b = qemu_malloc(sizeof(*b)); 151 b->cb = cb; 152 b->opaque = opaque; 153 154 qemu_iovec_init(&b->qiov, qiov->nalloc); 155 qemu_iovec_concat(&b->qiov, qiov, qiov->size); 156 157 b->qiov.size -= 512; 158 b->qiov.iov[first_buf_index].iov_base += 512; 159 b->qiov.iov[first_buf_index].iov_len -= 512; 160 161 return bdrv_aio_writev(bs->file, sector_num + 1, &b->qiov, 162 nb_sectors - 1, raw_aio_writev_scrubbed, b); 163 } 164 165 return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque); 166 } 167 168 static void raw_close(BlockDriverState *bs) 169 { 170 } 171 172 static void raw_flush(BlockDriverState *bs) 173 { 174 bdrv_flush(bs->file); 175 } 176 177 static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, 178 BlockDriverCompletionFunc *cb, void *opaque) 179 { 180 return bdrv_aio_flush(bs->file, cb, opaque); 181 } 182 183 static int64_t raw_getlength(BlockDriverState *bs) 184 { 185 return bdrv_getlength(bs->file); 186 } 187 188 static int raw_truncate(BlockDriverState *bs, int64_t offset) 189 { 190 return bdrv_truncate(bs->file, offset); 191 } 192 193 static int raw_probe(const uint8_t *buf, int buf_size, const char *filename) 194 { 195 return 1; /* everything can be opened as raw image */ 196 } 197 198 static int raw_is_inserted(BlockDriverState *bs) 199 { 200 return bdrv_is_inserted(bs->file); 201 } 202 203 static int raw_eject(BlockDriverState *bs, int eject_flag) 204 { 205 return bdrv_eject(bs->file, eject_flag); 206 } 207 208 static int raw_set_locked(BlockDriverState *bs, int locked) 209 { 210 bdrv_set_locked(bs->file, locked); 211 return 0; 212 } 213 214 static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 215 { 216 return bdrv_ioctl(bs->file, req, buf); 217 } 218 219 static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs, 220 unsigned long int req, void *buf, 221 BlockDriverCompletionFunc *cb, void *opaque) 222 { 223 return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque); 224 } 225 226 static int raw_create(const char *filename, QEMUOptionParameter *options) 227 { 228 return bdrv_create_file(filename, options); 229 } 230 231 static QEMUOptionParameter raw_create_options[] = { 232 { 233 .name = BLOCK_OPT_SIZE, 234 .type = OPT_SIZE, 235 .help = "Virtual disk size" 236 }, 237 { NULL } 238 }; 239 240 static int raw_has_zero_init(BlockDriverState *bs) 241 { 242 return bdrv_has_zero_init(bs->file); 243 } 244 245 static BlockDriver bdrv_raw = { 246 .format_name = "raw", 247 248 /* It's really 0, but we need to make qemu_malloc() happy */ 249 .instance_size = 1, 250 251 .bdrv_open = raw_open, 252 .bdrv_close = raw_close, 253 .bdrv_read = raw_read, 254 .bdrv_write = raw_write, 255 .bdrv_flush = raw_flush, 256 .bdrv_probe = raw_probe, 257 .bdrv_getlength = raw_getlength, 258 .bdrv_truncate = raw_truncate, 259 260 .bdrv_aio_readv = raw_aio_readv, 261 .bdrv_aio_writev = raw_aio_writev, 262 .bdrv_aio_flush = raw_aio_flush, 263 264 .bdrv_is_inserted = raw_is_inserted, 265 .bdrv_eject = raw_eject, 266 .bdrv_set_locked = raw_set_locked, 267 .bdrv_ioctl = raw_ioctl, 268 .bdrv_aio_ioctl = raw_aio_ioctl, 269 270 .bdrv_create = raw_create, 271 .create_options = raw_create_options, 272 .bdrv_has_zero_init = raw_has_zero_init, 273 }; 274 275 static void bdrv_raw_init(void) 276 { 277 bdrv_register(&bdrv_raw); 278 } 279 280 block_init(bdrv_raw_init); 281
