1 2#include "qemu-common.h" 3#include "block_int.h" 4#include "module.h" 5 6static 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*/ 15static 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 35static 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 51static 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 57static 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 69static 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 91static 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 98typedef struct RawScrubberBounce 99{ 100 BlockDriverCompletionFunc *cb; 101 void *opaque; 102 QEMUIOVector qiov; 103} RawScrubberBounce; 104 105static 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 119static 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 168static void raw_close(BlockDriverState *bs) 169{ 170} 171 172static void raw_flush(BlockDriverState *bs) 173{ 174 bdrv_flush(bs->file); 175} 176 177static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, 178 BlockDriverCompletionFunc *cb, void *opaque) 179{ 180 return bdrv_aio_flush(bs->file, cb, opaque); 181} 182 183static int64_t raw_getlength(BlockDriverState *bs) 184{ 185 return bdrv_getlength(bs->file); 186} 187 188static int raw_truncate(BlockDriverState *bs, int64_t offset) 189{ 190 return bdrv_truncate(bs->file, offset); 191} 192 193static 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 198static int raw_is_inserted(BlockDriverState *bs) 199{ 200 return bdrv_is_inserted(bs->file); 201} 202 203static int raw_eject(BlockDriverState *bs, int eject_flag) 204{ 205 return bdrv_eject(bs->file, eject_flag); 206} 207 208static int raw_set_locked(BlockDriverState *bs, int locked) 209{ 210 bdrv_set_locked(bs->file, locked); 211 return 0; 212} 213 214static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 215{ 216 return bdrv_ioctl(bs->file, req, buf); 217} 218 219static 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 226static int raw_create(const char *filename, QEMUOptionParameter *options) 227{ 228 return bdrv_create_file(filename, options); 229} 230 231static QEMUOptionParameter raw_create_options[] = { 232 { 233 .name = BLOCK_OPT_SIZE, 234 .type = OPT_SIZE, 235 .help = "Virtual disk size" 236 }, 237 { NULL } 238}; 239 240static int raw_has_zero_init(BlockDriverState *bs) 241{ 242 return bdrv_has_zero_init(bs->file); 243} 244 245static 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 275static void bdrv_raw_init(void) 276{ 277 bdrv_register(&bdrv_raw); 278} 279 280block_init(bdrv_raw_init); 281