Annotation of qemu/block.c, revision 1.1.1.17
1.1 root 1: /*
2: * QEMU System Emulator block driver
1.1.1.6 root 3: *
1.1 root 4: * Copyright (c) 2003 Fabrice Bellard
1.1.1.6 root 5: *
1.1 root 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: */
1.1.1.7 root 24: #include "config-host.h"
1.1.1.6 root 25: #include "qemu-common.h"
1.1.1.13 root 26: #include "monitor.h"
1.1 root 27: #include "block_int.h"
1.1.1.13 root 28: #include "module.h"
1.1.1.14 root 29: #include "qemu-objects.h"
1.1 root 30:
1.1.1.14 root 31: #ifdef CONFIG_BSD
1.1 root 32: #include <sys/types.h>
33: #include <sys/stat.h>
34: #include <sys/ioctl.h>
1.1.1.14 root 35: #include <sys/queue.h>
1.1.1.13 root 36: #ifndef __DragonFly__
1.1 root 37: #include <sys/disk.h>
38: #endif
1.1.1.13 root 39: #endif
40:
41: #ifdef _WIN32
42: #include <windows.h>
43: #endif
1.1 root 44:
1.1.1.13 root 45: static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
46: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1.1.1.5 root 47: BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.13 root 48: static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
49: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1.1.1.5 root 50: BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.14 root 51: static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
52: BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.6 root 53: static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1.1.1.5 root 54: uint8_t *buf, int nb_sectors);
55: static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
56: const uint8_t *buf, int nb_sectors);
1.1.1.3 root 57:
1.1.1.6 root 58: BlockDriverState *bdrv_first;
1.1.1.7 root 59:
1.1 root 60: static BlockDriver *first_drv;
61:
1.1.1.14 root 62: /* If non-zero, use only whitelisted block drivers */
63: static int use_bdrv_whitelist;
64:
1.1.1.5 root 65: int path_is_absolute(const char *path)
66: {
67: const char *p;
68: #ifdef _WIN32
69: /* specific case for names like: "\\.\d:" */
70: if (*path == '/' || *path == '\\')
71: return 1;
72: #endif
73: p = strchr(path, ':');
74: if (p)
75: p++;
76: else
77: p = path;
78: #ifdef _WIN32
79: return (*p == '/' || *p == '\\');
80: #else
81: return (*p == '/');
82: #endif
1.1.1.2 root 83: }
84:
1.1.1.5 root 85: /* if filename is absolute, just copy it to dest. Otherwise, build a
86: path to it by considering it is relative to base_path. URL are
87: supported. */
88: void path_combine(char *dest, int dest_size,
89: const char *base_path,
90: const char *filename)
91: {
92: const char *p, *p1;
93: int len;
94:
95: if (dest_size <= 0)
96: return;
97: if (path_is_absolute(filename)) {
98: pstrcpy(dest, dest_size, filename);
99: } else {
100: p = strchr(base_path, ':');
101: if (p)
102: p++;
103: else
104: p = base_path;
105: p1 = strrchr(base_path, '/');
106: #ifdef _WIN32
107: {
108: const char *p2;
109: p2 = strrchr(base_path, '\\');
110: if (!p1 || p2 > p1)
111: p1 = p2;
1.1.1.2 root 112: }
1.1.1.5 root 113: #endif
114: if (p1)
115: p1++;
116: else
117: p1 = base_path;
118: if (p1 > p)
119: p = p1;
120: len = p - base_path;
121: if (len > dest_size - 1)
122: len = dest_size - 1;
123: memcpy(dest, base_path, len);
124: dest[len] = '\0';
125: pstrcat(dest, dest_size, filename);
1.1.1.2 root 126: }
127: }
128:
1.1.1.13 root 129: void bdrv_register(BlockDriver *bdrv)
1.1 root 130: {
1.1.1.13 root 131: if (!bdrv->bdrv_aio_readv) {
1.1.1.5 root 132: /* add AIO emulation layer */
1.1.1.13 root 133: bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
134: bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
135: } else if (!bdrv->bdrv_read) {
1.1.1.5 root 136: /* add synchronous IO emulation layer */
137: bdrv->bdrv_read = bdrv_read_em;
138: bdrv->bdrv_write = bdrv_write_em;
139: }
1.1.1.14 root 140:
141: if (!bdrv->bdrv_aio_flush)
142: bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
143:
1.1 root 144: bdrv->next = first_drv;
145: first_drv = bdrv;
146: }
147:
148: /* create a new block device (by default it is empty) */
149: BlockDriverState *bdrv_new(const char *device_name)
150: {
151: BlockDriverState **pbs, *bs;
152:
153: bs = qemu_mallocz(sizeof(BlockDriverState));
154: pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
155: if (device_name[0] != '\0') {
156: /* insert at the end */
157: pbs = &bdrv_first;
158: while (*pbs != NULL)
159: pbs = &(*pbs)->next;
160: *pbs = bs;
161: }
162: return bs;
163: }
164:
165: BlockDriver *bdrv_find_format(const char *format_name)
166: {
167: BlockDriver *drv1;
168: for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
169: if (!strcmp(drv1->format_name, format_name))
170: return drv1;
171: }
172: return NULL;
173: }
174:
1.1.1.14 root 175: static int bdrv_is_whitelisted(BlockDriver *drv)
176: {
177: static const char *whitelist[] = {
178: CONFIG_BDRV_WHITELIST
179: };
180: const char **p;
181:
182: if (!whitelist[0])
183: return 1; /* no whitelist, anything goes */
184:
185: for (p = whitelist; *p; p++) {
186: if (!strcmp(drv->format_name, *p)) {
187: return 1;
188: }
189: }
190: return 0;
191: }
192:
193: BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
194: {
195: BlockDriver *drv = bdrv_find_format(format_name);
196: return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
197: }
198:
1.1.1.13 root 199: int bdrv_create(BlockDriver *drv, const char* filename,
200: QEMUOptionParameter *options)
1.1 root 201: {
202: if (!drv->bdrv_create)
203: return -ENOTSUP;
1.1.1.13 root 204:
205: return drv->bdrv_create(filename, options);
1.1 root 206: }
207:
208: #ifdef _WIN32
1.1.1.2 root 209: void get_tmp_filename(char *filename, int size)
1.1 root 210: {
1.1.1.5 root 211: char temp_dir[MAX_PATH];
1.1.1.6 root 212:
1.1.1.5 root 213: GetTempPath(MAX_PATH, temp_dir);
214: GetTempFileName(temp_dir, "qem", 0, filename);
1.1 root 215: }
216: #else
1.1.1.2 root 217: void get_tmp_filename(char *filename, int size)
1.1 root 218: {
219: int fd;
1.1.1.7 root 220: const char *tmpdir;
1.1 root 221: /* XXX: race condition possible */
1.1.1.7 root 222: tmpdir = getenv("TMPDIR");
223: if (!tmpdir)
224: tmpdir = "/tmp";
225: snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
1.1 root 226: fd = mkstemp(filename);
227: close(fd);
228: }
229: #endif
230:
1.1.1.5 root 231: #ifdef _WIN32
232: static int is_windows_drive_prefix(const char *filename)
233: {
234: return (((filename[0] >= 'a' && filename[0] <= 'z') ||
235: (filename[0] >= 'A' && filename[0] <= 'Z')) &&
236: filename[1] == ':');
237: }
1.1.1.6 root 238:
1.1.1.13 root 239: int is_windows_drive(const char *filename)
1.1.1.5 root 240: {
1.1.1.6 root 241: if (is_windows_drive_prefix(filename) &&
1.1.1.5 root 242: filename[2] == '\0')
243: return 1;
244: if (strstart(filename, "\\\\.\\", NULL) ||
245: strstart(filename, "//./", NULL))
246: return 1;
247: return 0;
248: }
249: #endif
250:
251: static BlockDriver *find_protocol(const char *filename)
252: {
253: BlockDriver *drv1;
254: char protocol[128];
255: int len;
256: const char *p;
257:
258: #ifdef _WIN32
259: if (is_windows_drive(filename) ||
260: is_windows_drive_prefix(filename))
1.1.1.13 root 261: return bdrv_find_format("raw");
1.1.1.5 root 262: #endif
263: p = strchr(filename, ':');
264: if (!p)
1.1.1.13 root 265: return bdrv_find_format("raw");
1.1.1.5 root 266: len = p - filename;
267: if (len > sizeof(protocol) - 1)
268: len = sizeof(protocol) - 1;
269: memcpy(protocol, filename, len);
270: protocol[len] = '\0';
271: for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
1.1.1.6 root 272: if (drv1->protocol_name &&
1.1.1.5 root 273: !strcmp(drv1->protocol_name, protocol))
274: return drv1;
275: }
276: return NULL;
277: }
278:
1.1.1.13 root 279: /*
280: * Detect host devices. By convention, /dev/cdrom[N] is always
281: * recognized as a host CDROM.
282: */
283: static BlockDriver *find_hdev_driver(const char *filename)
284: {
285: int score_max = 0, score;
286: BlockDriver *drv = NULL, *d;
287:
288: for (d = first_drv; d; d = d->next) {
289: if (d->bdrv_probe_device) {
290: score = d->bdrv_probe_device(filename);
291: if (score > score_max) {
292: score_max = score;
293: drv = d;
294: }
295: }
296: }
297:
298: return drv;
299: }
300:
1.1 root 301: static BlockDriver *find_image_format(const char *filename)
302: {
1.1.1.5 root 303: int ret, score, score_max;
1.1 root 304: BlockDriver *drv1, *drv;
1.1.1.5 root 305: uint8_t buf[2048];
306: BlockDriverState *bs;
1.1.1.6 root 307:
1.1.1.5 root 308: drv = find_protocol(filename);
309: /* no need to test disk image formats for vvfat */
1.1.1.13 root 310: if (drv && strcmp(drv->format_name, "vvfat") == 0)
1.1.1.5 root 311: return drv;
312:
313: ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
314: if (ret < 0)
315: return NULL;
316: ret = bdrv_pread(bs, 0, buf, sizeof(buf));
317: bdrv_delete(bs);
318: if (ret < 0) {
319: return NULL;
320: }
321:
1.1 root 322: score_max = 0;
323: for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
1.1.1.5 root 324: if (drv1->bdrv_probe) {
325: score = drv1->bdrv_probe(buf, ret, filename);
326: if (score > score_max) {
327: score_max = score;
328: drv = drv1;
329: }
1.1 root 330: }
331: }
332: return drv;
333: }
334:
1.1.1.5 root 335: int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
1.1 root 336: {
1.1.1.5 root 337: BlockDriverState *bs;
338: int ret;
339:
340: bs = bdrv_new("");
341: ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
342: if (ret < 0) {
343: bdrv_delete(bs);
344: return ret;
1.1.1.2 root 345: }
1.1.1.7 root 346: bs->growable = 1;
1.1.1.5 root 347: *pbs = bs;
348: return 0;
349: }
350:
351: int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
352: {
353: return bdrv_open2(bs, filename, flags, NULL);
1.1 root 354: }
355:
1.1.1.5 root 356: int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
1.1 root 357: BlockDriver *drv)
358: {
1.1.1.14 root 359: int ret, open_flags, try_rw;
1.1.1.6 root 360: char tmp_filename[PATH_MAX];
361: char backing_filename[PATH_MAX];
362:
1.1 root 363: bs->is_temporary = 0;
364: bs->encrypted = 0;
1.1.1.8 root 365: bs->valid_key = 0;
1.1.1.13 root 366: /* buffer_alignment defaulted to 512, drivers can change this value */
367: bs->buffer_alignment = 512;
1.1 root 368:
1.1.1.5 root 369: if (flags & BDRV_O_SNAPSHOT) {
1.1 root 370: BlockDriverState *bs1;
371: int64_t total_size;
1.1.1.7 root 372: int is_protocol = 0;
1.1.1.13 root 373: BlockDriver *bdrv_qcow2;
374: QEMUOptionParameter *options;
1.1.1.6 root 375:
1.1 root 376: /* if snapshot, we create a temporary backing file and open it
377: instead of opening 'filename' directly */
378:
379: /* if there is a backing file, use it */
380: bs1 = bdrv_new("");
1.1.1.13 root 381: ret = bdrv_open2(bs1, filename, 0, drv);
1.1.1.8 root 382: if (ret < 0) {
1.1 root 383: bdrv_delete(bs1);
1.1.1.8 root 384: return ret;
1.1 root 385: }
1.1.1.14 root 386: total_size = bdrv_getlength(bs1) >> BDRV_SECTOR_BITS;
1.1.1.7 root 387:
388: if (bs1->drv && bs1->drv->protocol_name)
389: is_protocol = 1;
390:
1.1 root 391: bdrv_delete(bs1);
1.1.1.6 root 392:
1.1 root 393: get_tmp_filename(tmp_filename, sizeof(tmp_filename));
1.1.1.7 root 394:
395: /* Real path is meaningless for protocols */
396: if (is_protocol)
397: snprintf(backing_filename, sizeof(backing_filename),
398: "%s", filename);
399: else
400: realpath(filename, backing_filename);
401:
1.1.1.13 root 402: bdrv_qcow2 = bdrv_find_format("qcow2");
403: options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
404:
405: set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size * 512);
406: set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
407: if (drv) {
408: set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
409: drv->format_name);
410: }
411:
412: ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
1.1.1.8 root 413: if (ret < 0) {
414: return ret;
1.1 root 415: }
1.1.1.13 root 416:
1.1 root 417: filename = tmp_filename;
1.1.1.13 root 418: drv = bdrv_qcow2;
1.1 root 419: bs->is_temporary = 1;
420: }
421:
422: pstrcpy(bs->filename, sizeof(bs->filename), filename);
1.1.1.5 root 423: if (flags & BDRV_O_FILE) {
424: drv = find_protocol(filename);
1.1.1.8 root 425: } else if (!drv) {
1.1.1.13 root 426: drv = find_hdev_driver(filename);
427: if (!drv) {
428: drv = find_image_format(filename);
429: }
1.1.1.8 root 430: }
431: if (!drv) {
432: ret = -ENOENT;
433: goto unlink_and_fail;
1.1 root 434: }
435: bs->drv = drv;
436: bs->opaque = qemu_mallocz(drv->instance_size);
1.1.1.14 root 437:
438: /*
439: * Yes, BDRV_O_NOCACHE aka O_DIRECT means we have to present a
440: * write cache to the guest. We do need the fdatasync to flush
441: * out transactions for block allocations, and we maybe have a
442: * volatile write cache in our backing device to deal with.
443: */
444: if (flags & (BDRV_O_CACHE_WB|BDRV_O_NOCACHE))
445: bs->enable_write_cache = 1;
446:
1.1.1.5 root 447: /* Note: for compatibility, we open disk image files as RDWR, and
448: RDONLY as fallback */
1.1.1.14 root 449: try_rw = !bs->read_only || bs->is_temporary;
1.1.1.5 root 450: if (!(flags & BDRV_O_FILE))
1.1.1.14 root 451: open_flags = (try_rw ? BDRV_O_RDWR : 0) |
452: (flags & (BDRV_O_CACHE_MASK|BDRV_O_NATIVE_AIO));
1.1.1.5 root 453: else
454: open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
1.1.1.17! root 455:
! 456: bs->open_flags = open_flags;
1.1.1.14 root 457: if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv))
458: ret = -ENOTSUP;
459: else
460: ret = drv->bdrv_open(bs, filename, open_flags);
1.1.1.7 root 461: if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
462: ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
1.1.1.5 root 463: bs->read_only = 1;
464: }
1.1 root 465: if (ret < 0) {
466: qemu_free(bs->opaque);
1.1.1.5 root 467: bs->opaque = NULL;
468: bs->drv = NULL;
1.1.1.8 root 469: unlink_and_fail:
470: if (bs->is_temporary)
471: unlink(filename);
1.1.1.5 root 472: return ret;
473: }
474: if (drv->bdrv_getlength) {
1.1.1.14 root 475: bs->total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1.1 root 476: }
477: #ifndef _WIN32
478: if (bs->is_temporary) {
479: unlink(filename);
480: }
481: #endif
1.1.1.5 root 482: if (bs->backing_file[0] != '\0') {
1.1 root 483: /* if there is a backing file, use it */
1.1.1.13 root 484: BlockDriver *back_drv = NULL;
1.1 root 485: bs->backing_hd = bdrv_new("");
1.1.1.14 root 486: /* pass on read_only property to the backing_hd */
487: bs->backing_hd->read_only = bs->read_only;
1.1.1.5 root 488: path_combine(backing_filename, sizeof(backing_filename),
489: filename, bs->backing_file);
1.1.1.13 root 490: if (bs->backing_format[0] != '\0')
491: back_drv = bdrv_find_format(bs->backing_format);
492: ret = bdrv_open2(bs->backing_hd, backing_filename, open_flags,
493: back_drv);
1.1.1.8 root 494: if (ret < 0) {
495: bdrv_close(bs);
496: return ret;
497: }
1.1 root 498: }
499:
1.1.1.13 root 500: if (!bdrv_key_required(bs)) {
501: /* call the change callback */
502: bs->media_changed = 1;
503: if (bs->change_cb)
504: bs->change_cb(bs->change_opaque);
505: }
1.1 root 506: return 0;
507: }
508:
509: void bdrv_close(BlockDriverState *bs)
510: {
1.1.1.5 root 511: if (bs->drv) {
1.1 root 512: if (bs->backing_hd)
513: bdrv_delete(bs->backing_hd);
514: bs->drv->bdrv_close(bs);
515: qemu_free(bs->opaque);
516: #ifdef _WIN32
517: if (bs->is_temporary) {
518: unlink(bs->filename);
519: }
520: #endif
521: bs->opaque = NULL;
522: bs->drv = NULL;
523:
524: /* call the change callback */
1.1.1.5 root 525: bs->media_changed = 1;
1.1 root 526: if (bs->change_cb)
527: bs->change_cb(bs->change_opaque);
528: }
529: }
530:
531: void bdrv_delete(BlockDriverState *bs)
532: {
1.1.1.7 root 533: BlockDriverState **pbs;
534:
535: pbs = &bdrv_first;
536: while (*pbs != bs && *pbs != NULL)
537: pbs = &(*pbs)->next;
538: if (*pbs == bs)
539: *pbs = bs->next;
540:
1.1 root 541: bdrv_close(bs);
542: qemu_free(bs);
543: }
544:
1.1.1.13 root 545: /*
546: * Run consistency checks on an image
547: *
548: * Returns the number of errors or -errno when an internal error occurs
549: */
550: int bdrv_check(BlockDriverState *bs)
551: {
552: if (bs->drv->bdrv_check == NULL) {
553: return -ENOTSUP;
554: }
555:
556: return bs->drv->bdrv_check(bs);
557: }
558:
1.1 root 559: /* commit COW file into the raw image */
560: int bdrv_commit(BlockDriverState *bs)
561: {
1.1.1.5 root 562: BlockDriver *drv = bs->drv;
563: int64_t i, total_sectors;
1.1 root 564: int n, j;
565: unsigned char sector[512];
566:
1.1.1.5 root 567: if (!drv)
568: return -ENOMEDIUM;
1.1 root 569:
570: if (bs->read_only) {
571: return -EACCES;
572: }
573:
574: if (!bs->backing_hd) {
575: return -ENOTSUP;
576: }
577:
1.1.1.14 root 578: total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1.1.1.5 root 579: for (i = 0; i < total_sectors;) {
580: if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
1.1 root 581: for(j = 0; j < n; j++) {
582: if (bdrv_read(bs, i, sector, 1) != 0) {
583: return -EIO;
584: }
585:
586: if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
587: return -EIO;
588: }
589: i++;
590: }
591: } else {
592: i += n;
593: }
594: }
1.1.1.2 root 595:
1.1.1.5 root 596: if (drv->bdrv_make_empty)
597: return drv->bdrv_make_empty(bs);
1.1.1.2 root 598:
1.1 root 599: return 0;
600: }
601:
1.1.1.7 root 602: static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
603: size_t size)
604: {
605: int64_t len;
606:
607: if (!bdrv_is_inserted(bs))
608: return -ENOMEDIUM;
609:
610: if (bs->growable)
611: return 0;
612:
613: len = bdrv_getlength(bs);
614:
1.1.1.11 root 615: if (offset < 0)
616: return -EIO;
617:
618: if ((offset > len) || (len - offset < size))
1.1.1.7 root 619: return -EIO;
620:
621: return 0;
622: }
623:
624: static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
625: int nb_sectors)
626: {
1.1.1.13 root 627: return bdrv_check_byte_request(bs, sector_num * 512, nb_sectors * 512);
1.1.1.7 root 628: }
629:
1.1.1.5 root 630: /* return < 0 if error. See bdrv_write() for the return codes */
1.1.1.6 root 631: int bdrv_read(BlockDriverState *bs, int64_t sector_num,
1.1 root 632: uint8_t *buf, int nb_sectors)
633: {
634: BlockDriver *drv = bs->drv;
635:
1.1.1.5 root 636: if (!drv)
637: return -ENOMEDIUM;
1.1.1.7 root 638: if (bdrv_check_request(bs, sector_num, nb_sectors))
639: return -EIO;
1.1 root 640:
1.1.1.13 root 641: return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
1.1 root 642: }
643:
1.1.1.14 root 644: static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
645: int nb_sectors, int dirty)
646: {
647: int64_t start, end;
648: unsigned long val, idx, bit;
649:
650: start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
651: end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
652:
653: for (; start <= end; start++) {
654: idx = start / (sizeof(unsigned long) * 8);
655: bit = start % (sizeof(unsigned long) * 8);
656: val = bs->dirty_bitmap[idx];
657: if (dirty) {
658: val |= 1 << bit;
659: } else {
660: val &= ~(1 << bit);
661: }
662: bs->dirty_bitmap[idx] = val;
663: }
664: }
665:
1.1.1.6 root 666: /* Return < 0 if error. Important errors are:
1.1.1.5 root 667: -EIO generic I/O error (may happen for all errors)
668: -ENOMEDIUM No media inserted.
669: -EINVAL Invalid sector number or nb_sectors
670: -EACCES Trying to write a read-only device
671: */
1.1.1.6 root 672: int bdrv_write(BlockDriverState *bs, int64_t sector_num,
1.1 root 673: const uint8_t *buf, int nb_sectors)
674: {
1.1.1.5 root 675: BlockDriver *drv = bs->drv;
676: if (!bs->drv)
677: return -ENOMEDIUM;
1.1 root 678: if (bs->read_only)
1.1.1.5 root 679: return -EACCES;
1.1.1.7 root 680: if (bdrv_check_request(bs, sector_num, nb_sectors))
681: return -EIO;
682:
1.1.1.14 root 683: if (bs->dirty_bitmap) {
684: set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
685: }
686:
1.1.1.7 root 687: return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
1.1 root 688: }
689:
1.1.1.13 root 690: int bdrv_pread(BlockDriverState *bs, int64_t offset,
691: void *buf, int count1)
1.1.1.5 root 692: {
1.1.1.14 root 693: uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1.1.1.5 root 694: int len, nb_sectors, count;
695: int64_t sector_num;
1.1.1.15 root 696: int ret;
1.1.1.5 root 697:
698: count = count1;
699: /* first read to align to sector start */
1.1.1.14 root 700: len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1.1.1.5 root 701: if (len > count)
702: len = count;
1.1.1.14 root 703: sector_num = offset >> BDRV_SECTOR_BITS;
1.1.1.5 root 704: if (len > 0) {
1.1.1.15 root 705: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
706: return ret;
1.1.1.14 root 707: memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
1.1.1.5 root 708: count -= len;
709: if (count == 0)
710: return count1;
711: sector_num++;
712: buf += len;
713: }
714:
715: /* read the sectors "in place" */
1.1.1.14 root 716: nb_sectors = count >> BDRV_SECTOR_BITS;
1.1.1.5 root 717: if (nb_sectors > 0) {
1.1.1.15 root 718: if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
719: return ret;
1.1.1.5 root 720: sector_num += nb_sectors;
1.1.1.14 root 721: len = nb_sectors << BDRV_SECTOR_BITS;
1.1.1.5 root 722: buf += len;
723: count -= len;
724: }
725:
726: /* add data from the last sector */
727: if (count > 0) {
1.1.1.15 root 728: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
729: return ret;
1.1.1.5 root 730: memcpy(buf, tmp_buf, count);
731: }
732: return count1;
733: }
734:
1.1.1.13 root 735: int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
736: const void *buf, int count1)
1.1.1.5 root 737: {
1.1.1.14 root 738: uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1.1.1.5 root 739: int len, nb_sectors, count;
740: int64_t sector_num;
1.1.1.15 root 741: int ret;
1.1.1.5 root 742:
743: count = count1;
744: /* first write to align to sector start */
1.1.1.14 root 745: len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1.1.1.5 root 746: if (len > count)
747: len = count;
1.1.1.14 root 748: sector_num = offset >> BDRV_SECTOR_BITS;
1.1.1.5 root 749: if (len > 0) {
1.1.1.15 root 750: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
751: return ret;
1.1.1.14 root 752: memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1.1.1.15 root 753: if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
754: return ret;
1.1.1.5 root 755: count -= len;
756: if (count == 0)
757: return count1;
758: sector_num++;
759: buf += len;
760: }
761:
762: /* write the sectors "in place" */
1.1.1.14 root 763: nb_sectors = count >> BDRV_SECTOR_BITS;
1.1.1.5 root 764: if (nb_sectors > 0) {
1.1.1.15 root 765: if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
766: return ret;
1.1.1.5 root 767: sector_num += nb_sectors;
1.1.1.14 root 768: len = nb_sectors << BDRV_SECTOR_BITS;
1.1.1.5 root 769: buf += len;
770: count -= len;
771: }
772:
773: /* add data from the last sector */
774: if (count > 0) {
1.1.1.15 root 775: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
776: return ret;
1.1.1.5 root 777: memcpy(tmp_buf, buf, count);
1.1.1.15 root 778: if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
779: return ret;
1.1.1.5 root 780: }
781: return count1;
782: }
783:
1.1.1.17! root 784: /*
! 785: * Writes to the file and ensures that no writes are reordered across this
! 786: * request (acts as a barrier)
! 787: *
! 788: * Returns 0 on success, -errno in error cases.
! 789: */
! 790: int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
! 791: const void *buf, int count)
! 792: {
! 793: int ret;
! 794:
! 795: ret = bdrv_pwrite(bs, offset, buf, count);
! 796: if (ret < 0) {
! 797: return ret;
! 798: }
! 799:
! 800: /* No flush needed for cache=writethrough, it uses O_DSYNC */
! 801: if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
! 802: bdrv_flush(bs);
! 803: }
! 804:
! 805: return 0;
! 806: }
! 807:
! 808: /*
! 809: * Writes to the file and ensures that no writes are reordered across this
! 810: * request (acts as a barrier)
! 811: *
! 812: * Returns 0 on success, -errno in error cases.
! 813: */
! 814: int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
! 815: const uint8_t *buf, int nb_sectors)
! 816: {
! 817: return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
! 818: buf, BDRV_SECTOR_SIZE * nb_sectors);
! 819: }
! 820:
1.1.1.5 root 821: /**
822: * Truncate file to 'offset' bytes (needed only for file protocols)
823: */
824: int bdrv_truncate(BlockDriverState *bs, int64_t offset)
825: {
826: BlockDriver *drv = bs->drv;
827: if (!drv)
828: return -ENOMEDIUM;
829: if (!drv->bdrv_truncate)
830: return -ENOTSUP;
1.1.1.14 root 831: if (bs->read_only)
832: return -EACCES;
1.1.1.5 root 833: return drv->bdrv_truncate(bs, offset);
834: }
835:
836: /**
837: * Length of a file in bytes. Return < 0 if error or unknown.
838: */
839: int64_t bdrv_getlength(BlockDriverState *bs)
840: {
841: BlockDriver *drv = bs->drv;
842: if (!drv)
843: return -ENOMEDIUM;
844: if (!drv->bdrv_getlength) {
845: /* legacy mode */
1.1.1.14 root 846: return bs->total_sectors * BDRV_SECTOR_SIZE;
1.1.1.5 root 847: }
848: return drv->bdrv_getlength(bs);
849: }
850:
851: /* return 0 as number of sectors if no device present or error */
1.1.1.6 root 852: void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1.1 root 853: {
1.1.1.5 root 854: int64_t length;
855: length = bdrv_getlength(bs);
856: if (length < 0)
857: length = 0;
858: else
1.1.1.14 root 859: length = length >> BDRV_SECTOR_BITS;
1.1.1.5 root 860: *nb_sectors_ptr = length;
1.1 root 861: }
862:
1.1.1.7 root 863: struct partition {
864: uint8_t boot_ind; /* 0x80 - active */
865: uint8_t head; /* starting head */
866: uint8_t sector; /* starting sector */
867: uint8_t cyl; /* starting cylinder */
868: uint8_t sys_ind; /* What partition type */
869: uint8_t end_head; /* end head */
870: uint8_t end_sector; /* end sector */
871: uint8_t end_cyl; /* end cylinder */
872: uint32_t start_sect; /* starting sector counting from 0 */
873: uint32_t nr_sects; /* nr of sectors in partition */
874: } __attribute__((packed));
875:
876: /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
877: static int guess_disk_lchs(BlockDriverState *bs,
878: int *pcylinders, int *pheads, int *psectors)
879: {
880: uint8_t buf[512];
881: int ret, i, heads, sectors, cylinders;
882: struct partition *p;
883: uint32_t nr_sects;
884: uint64_t nb_sectors;
885:
886: bdrv_get_geometry(bs, &nb_sectors);
887:
888: ret = bdrv_read(bs, 0, buf, 1);
889: if (ret < 0)
890: return -1;
891: /* test msdos magic */
892: if (buf[510] != 0x55 || buf[511] != 0xaa)
893: return -1;
894: for(i = 0; i < 4; i++) {
895: p = ((struct partition *)(buf + 0x1be)) + i;
896: nr_sects = le32_to_cpu(p->nr_sects);
897: if (nr_sects && p->end_head) {
898: /* We make the assumption that the partition terminates on
899: a cylinder boundary */
900: heads = p->end_head + 1;
901: sectors = p->end_sector & 63;
902: if (sectors == 0)
903: continue;
904: cylinders = nb_sectors / (heads * sectors);
905: if (cylinders < 1 || cylinders > 16383)
906: continue;
907: *pheads = heads;
908: *psectors = sectors;
909: *pcylinders = cylinders;
910: #if 0
911: printf("guessed geometry: LCHS=%d %d %d\n",
912: cylinders, heads, sectors);
913: #endif
914: return 0;
915: }
916: }
917: return -1;
918: }
919:
920: void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1.1 root 921: {
1.1.1.7 root 922: int translation, lba_detected = 0;
923: int cylinders, heads, secs;
924: uint64_t nb_sectors;
925:
926: /* if a geometry hint is available, use it */
927: bdrv_get_geometry(bs, &nb_sectors);
928: bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
929: translation = bdrv_get_translation_hint(bs);
930: if (cylinders != 0) {
931: *pcyls = cylinders;
932: *pheads = heads;
933: *psecs = secs;
934: } else {
935: if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
936: if (heads > 16) {
937: /* if heads > 16, it means that a BIOS LBA
938: translation was active, so the default
939: hardware geometry is OK */
940: lba_detected = 1;
941: goto default_geometry;
942: } else {
943: *pcyls = cylinders;
944: *pheads = heads;
945: *psecs = secs;
946: /* disable any translation to be in sync with
947: the logical geometry */
948: if (translation == BIOS_ATA_TRANSLATION_AUTO) {
949: bdrv_set_translation_hint(bs,
950: BIOS_ATA_TRANSLATION_NONE);
951: }
952: }
953: } else {
954: default_geometry:
955: /* if no geometry, use a standard physical disk geometry */
956: cylinders = nb_sectors / (16 * 63);
957:
958: if (cylinders > 16383)
959: cylinders = 16383;
960: else if (cylinders < 2)
961: cylinders = 2;
962: *pcyls = cylinders;
963: *pheads = 16;
964: *psecs = 63;
965: if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
966: if ((*pcyls * *pheads) <= 131072) {
967: bdrv_set_translation_hint(bs,
968: BIOS_ATA_TRANSLATION_LARGE);
969: } else {
970: bdrv_set_translation_hint(bs,
971: BIOS_ATA_TRANSLATION_LBA);
972: }
973: }
974: }
975: bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
976: }
1.1 root 977: }
978:
1.1.1.6 root 979: void bdrv_set_geometry_hint(BlockDriverState *bs,
1.1 root 980: int cyls, int heads, int secs)
981: {
982: bs->cyls = cyls;
983: bs->heads = heads;
984: bs->secs = secs;
985: }
986:
987: void bdrv_set_type_hint(BlockDriverState *bs, int type)
988: {
989: bs->type = type;
990: bs->removable = ((type == BDRV_TYPE_CDROM ||
991: type == BDRV_TYPE_FLOPPY));
992: }
993:
994: void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
995: {
996: bs->translation = translation;
997: }
998:
1.1.1.6 root 999: void bdrv_get_geometry_hint(BlockDriverState *bs,
1.1 root 1000: int *pcyls, int *pheads, int *psecs)
1001: {
1002: *pcyls = bs->cyls;
1003: *pheads = bs->heads;
1004: *psecs = bs->secs;
1005: }
1006:
1007: int bdrv_get_type_hint(BlockDriverState *bs)
1008: {
1009: return bs->type;
1010: }
1011:
1012: int bdrv_get_translation_hint(BlockDriverState *bs)
1013: {
1014: return bs->translation;
1015: }
1016:
1017: int bdrv_is_removable(BlockDriverState *bs)
1018: {
1019: return bs->removable;
1020: }
1021:
1022: int bdrv_is_read_only(BlockDriverState *bs)
1023: {
1024: return bs->read_only;
1025: }
1026:
1.1.1.14 root 1027: int bdrv_set_read_only(BlockDriverState *bs, int read_only)
1028: {
1029: int ret = bs->read_only;
1030: bs->read_only = read_only;
1031: return ret;
1032: }
1033:
1.1.1.6 root 1034: int bdrv_is_sg(BlockDriverState *bs)
1035: {
1036: return bs->sg;
1037: }
1038:
1.1.1.14 root 1039: int bdrv_enable_write_cache(BlockDriverState *bs)
1040: {
1041: return bs->enable_write_cache;
1042: }
1043:
1.1.1.5 root 1044: /* XXX: no longer used */
1.1.1.6 root 1045: void bdrv_set_change_cb(BlockDriverState *bs,
1.1 root 1046: void (*change_cb)(void *opaque), void *opaque)
1047: {
1048: bs->change_cb = change_cb;
1049: bs->change_opaque = opaque;
1050: }
1051:
1052: int bdrv_is_encrypted(BlockDriverState *bs)
1053: {
1054: if (bs->backing_hd && bs->backing_hd->encrypted)
1055: return 1;
1056: return bs->encrypted;
1057: }
1058:
1.1.1.8 root 1059: int bdrv_key_required(BlockDriverState *bs)
1060: {
1061: BlockDriverState *backing_hd = bs->backing_hd;
1062:
1063: if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1064: return 1;
1065: return (bs->encrypted && !bs->valid_key);
1066: }
1067:
1.1 root 1068: int bdrv_set_key(BlockDriverState *bs, const char *key)
1069: {
1070: int ret;
1071: if (bs->backing_hd && bs->backing_hd->encrypted) {
1072: ret = bdrv_set_key(bs->backing_hd, key);
1073: if (ret < 0)
1074: return ret;
1075: if (!bs->encrypted)
1076: return 0;
1077: }
1078: if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
1079: return -1;
1.1.1.8 root 1080: ret = bs->drv->bdrv_set_key(bs, key);
1.1.1.13 root 1081: if (ret < 0) {
1082: bs->valid_key = 0;
1083: } else if (!bs->valid_key) {
1084: bs->valid_key = 1;
1085: /* call the change callback now, we skipped it on open */
1086: bs->media_changed = 1;
1087: if (bs->change_cb)
1088: bs->change_cb(bs->change_opaque);
1089: }
1.1.1.8 root 1090: return ret;
1.1 root 1091: }
1092:
1093: void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1094: {
1.1.1.5 root 1095: if (!bs->drv) {
1.1 root 1096: buf[0] = '\0';
1097: } else {
1098: pstrcpy(buf, buf_size, bs->drv->format_name);
1099: }
1100: }
1101:
1.1.1.6 root 1102: void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1.1 root 1103: void *opaque)
1104: {
1105: BlockDriver *drv;
1106:
1107: for (drv = first_drv; drv != NULL; drv = drv->next) {
1108: it(opaque, drv->format_name);
1109: }
1110: }
1111:
1112: BlockDriverState *bdrv_find(const char *name)
1113: {
1114: BlockDriverState *bs;
1115:
1116: for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1117: if (!strcmp(name, bs->device_name))
1118: return bs;
1119: }
1120: return NULL;
1121: }
1122:
1.1.1.8 root 1123: void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1.1 root 1124: {
1125: BlockDriverState *bs;
1126:
1127: for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1.1.1.8 root 1128: it(opaque, bs);
1.1 root 1129: }
1130: }
1131:
1132: const char *bdrv_get_device_name(BlockDriverState *bs)
1133: {
1134: return bs->device_name;
1135: }
1136:
1.1.1.4 root 1137: void bdrv_flush(BlockDriverState *bs)
1138: {
1.1.1.13 root 1139: if (!bs->drv)
1140: return;
1.1.1.4 root 1141: if (bs->drv->bdrv_flush)
1142: bs->drv->bdrv_flush(bs);
1143: if (bs->backing_hd)
1144: bdrv_flush(bs->backing_hd);
1145: }
1146:
1.1.1.7 root 1147: void bdrv_flush_all(void)
1148: {
1149: BlockDriverState *bs;
1150:
1151: for (bs = bdrv_first; bs != NULL; bs = bs->next)
1152: if (bs->drv && !bdrv_is_read_only(bs) &&
1153: (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
1154: bdrv_flush(bs);
1155: }
1156:
1157: /*
1158: * Returns true iff the specified sector is present in the disk image. Drivers
1159: * not implementing the functionality are assumed to not support backing files,
1160: * hence all their sectors are reported as allocated.
1161: *
1162: * 'pnum' is set to the number of sectors (including and immediately following
1163: * the specified sector) that are known to be in the same
1164: * allocated/unallocated state.
1165: *
1166: * 'nb_sectors' is the max value 'pnum' should be set to.
1167: */
1168: int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1169: int *pnum)
1170: {
1171: int64_t n;
1172: if (!bs->drv->bdrv_is_allocated) {
1173: if (sector_num >= bs->total_sectors) {
1174: *pnum = 0;
1175: return 0;
1176: }
1177: n = bs->total_sectors - sector_num;
1178: *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1179: return 1;
1180: }
1181: return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1182: }
1183:
1.1.1.14 root 1184: static void bdrv_print_dict(QObject *obj, void *opaque)
1.1 root 1185: {
1.1.1.14 root 1186: QDict *bs_dict;
1187: Monitor *mon = opaque;
1188:
1189: bs_dict = qobject_to_qdict(obj);
1190:
1191: monitor_printf(mon, "%s: type=%s removable=%d",
1192: qdict_get_str(bs_dict, "device"),
1193: qdict_get_str(bs_dict, "type"),
1194: qdict_get_bool(bs_dict, "removable"));
1195:
1196: if (qdict_get_bool(bs_dict, "removable")) {
1197: monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
1198: }
1199:
1200: if (qdict_haskey(bs_dict, "inserted")) {
1201: QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
1202:
1203: monitor_printf(mon, " file=");
1204: monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1205: if (qdict_haskey(qdict, "backing_file")) {
1206: monitor_printf(mon, " backing_file=");
1207: monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1208: }
1209: monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1210: qdict_get_bool(qdict, "ro"),
1211: qdict_get_str(qdict, "drv"),
1212: qdict_get_bool(qdict, "encrypted"));
1213: } else {
1214: monitor_printf(mon, " [not inserted]");
1215: }
1216:
1217: monitor_printf(mon, "\n");
1218: }
1219:
1220: void bdrv_info_print(Monitor *mon, const QObject *data)
1221: {
1222: qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1223: }
1224:
1225: /**
1226: * bdrv_info(): Block devices information
1227: *
1228: * Each block device information is stored in a QDict and the
1229: * returned QObject is a QList of all devices.
1230: *
1231: * The QDict contains the following:
1232: *
1233: * - "device": device name
1234: * - "type": device type
1235: * - "removable": true if the device is removable, false otherwise
1236: * - "locked": true if the device is locked, false otherwise
1237: * - "inserted": only present if the device is inserted, it is a QDict
1238: * containing the following:
1239: * - "file": device file name
1240: * - "ro": true if read-only, false otherwise
1241: * - "drv": driver format name
1242: * - "backing_file": backing file name if one is used
1243: * - "encrypted": true if encrypted, false otherwise
1244: *
1245: * Example:
1246: *
1247: * [ { "device": "ide0-hd0", "type": "hd", "removable": false, "locked": false,
1248: * "inserted": { "file": "/tmp/foobar", "ro": false, "drv": "qcow2" } },
1249: * { "device": "floppy0", "type": "floppy", "removable": true,
1250: * "locked": false } ]
1251: */
1252: void bdrv_info(Monitor *mon, QObject **ret_data)
1253: {
1254: QList *bs_list;
1.1 root 1255: BlockDriverState *bs;
1256:
1.1.1.14 root 1257: bs_list = qlist_new();
1258:
1.1 root 1259: for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1.1.1.14 root 1260: QObject *bs_obj;
1261: const char *type = "unknown";
1262:
1.1 root 1263: switch(bs->type) {
1264: case BDRV_TYPE_HD:
1.1.1.14 root 1265: type = "hd";
1.1 root 1266: break;
1267: case BDRV_TYPE_CDROM:
1.1.1.14 root 1268: type = "cdrom";
1.1 root 1269: break;
1270: case BDRV_TYPE_FLOPPY:
1.1.1.14 root 1271: type = "floppy";
1.1 root 1272: break;
1273: }
1.1.1.14 root 1274:
1275: bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, "
1276: "'removable': %i, 'locked': %i }",
1277: bs->device_name, type, bs->removable,
1278: bs->locked);
1279: assert(bs_obj != NULL);
1280:
1.1.1.5 root 1281: if (bs->drv) {
1.1.1.14 root 1282: QObject *obj;
1283: QDict *bs_dict = qobject_to_qdict(bs_obj);
1284:
1285: obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1286: "'encrypted': %i }",
1287: bs->filename, bs->read_only,
1288: bs->drv->format_name,
1289: bdrv_is_encrypted(bs));
1290: assert(obj != NULL);
1.1.1.5 root 1291: if (bs->backing_file[0] != '\0') {
1.1.1.14 root 1292: QDict *qdict = qobject_to_qdict(obj);
1293: qdict_put(qdict, "backing_file",
1294: qstring_from_str(bs->backing_file));
1.1.1.13 root 1295: }
1.1.1.14 root 1296:
1297: qdict_put_obj(bs_dict, "inserted", obj);
1.1 root 1298: }
1.1.1.14 root 1299: qlist_append_obj(bs_list, bs_obj);
1.1 root 1300: }
1.1.1.14 root 1301:
1302: *ret_data = QOBJECT(bs_list);
1303: }
1304:
1305: static void bdrv_stats_iter(QObject *data, void *opaque)
1306: {
1307: QDict *qdict;
1308: Monitor *mon = opaque;
1309:
1310: qdict = qobject_to_qdict(data);
1311: monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
1312:
1313: qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1314: monitor_printf(mon, " rd_bytes=%" PRId64
1315: " wr_bytes=%" PRId64
1316: " rd_operations=%" PRId64
1317: " wr_operations=%" PRId64
1318: "\n",
1319: qdict_get_int(qdict, "rd_bytes"),
1320: qdict_get_int(qdict, "wr_bytes"),
1321: qdict_get_int(qdict, "rd_operations"),
1322: qdict_get_int(qdict, "wr_operations"));
1323: }
1324:
1325: void bdrv_stats_print(Monitor *mon, const QObject *data)
1326: {
1327: qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
1.1 root 1328: }
1329:
1.1.1.14 root 1330: /**
1331: * bdrv_info_stats(): show block device statistics
1332: *
1333: * Each device statistic information is stored in a QDict and
1334: * the returned QObject is a QList of all devices.
1335: *
1336: * The QDict contains the following:
1337: *
1338: * - "device": device name
1339: * - "stats": A QDict with the statistics information, it contains:
1340: * - "rd_bytes": bytes read
1341: * - "wr_bytes": bytes written
1342: * - "rd_operations": read operations
1343: * - "wr_operations": write operations
1344: *
1345: * Example:
1346: *
1347: * [ { "device": "ide0-hd0",
1348: * "stats": { "rd_bytes": 512,
1349: * "wr_bytes": 0,
1350: * "rd_operations": 1,
1351: * "wr_operations": 0 } },
1352: * { "device": "ide1-cd0",
1353: * "stats": { "rd_bytes": 0,
1354: * "wr_bytes": 0,
1355: * "rd_operations": 0,
1356: * "wr_operations": 0 } } ]
1357: */
1358: void bdrv_info_stats(Monitor *mon, QObject **ret_data)
1.1.1.6 root 1359: {
1.1.1.14 root 1360: QObject *obj;
1361: QList *devices;
1.1.1.6 root 1362: BlockDriverState *bs;
1363:
1.1.1.14 root 1364: devices = qlist_new();
1365:
1.1.1.6 root 1366: for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1.1.1.14 root 1367: obj = qobject_from_jsonf("{ 'device': %s, 'stats': {"
1368: "'rd_bytes': %" PRId64 ","
1369: "'wr_bytes': %" PRId64 ","
1370: "'rd_operations': %" PRId64 ","
1371: "'wr_operations': %" PRId64
1372: "} }",
1373: bs->device_name,
1374: bs->rd_bytes, bs->wr_bytes,
1375: bs->rd_ops, bs->wr_ops);
1376: assert(obj != NULL);
1377: qlist_append_obj(devices, obj);
1.1.1.6 root 1378: }
1.1.1.14 root 1379:
1380: *ret_data = QOBJECT(devices);
1.1.1.6 root 1381: }
1382:
1.1.1.8 root 1383: const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1384: {
1385: if (bs->backing_hd && bs->backing_hd->encrypted)
1386: return bs->backing_file;
1387: else if (bs->encrypted)
1388: return bs->filename;
1389: else
1390: return NULL;
1391: }
1392:
1.1.1.6 root 1393: void bdrv_get_backing_filename(BlockDriverState *bs,
1.1.1.5 root 1394: char *filename, int filename_size)
1395: {
1396: if (!bs->backing_hd) {
1397: pstrcpy(filename, filename_size, "");
1398: } else {
1399: pstrcpy(filename, filename_size, bs->backing_file);
1400: }
1401: }
1402:
1.1.1.6 root 1403: int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1.1.1.5 root 1404: const uint8_t *buf, int nb_sectors)
1405: {
1406: BlockDriver *drv = bs->drv;
1407: if (!drv)
1408: return -ENOMEDIUM;
1409: if (!drv->bdrv_write_compressed)
1410: return -ENOTSUP;
1.1.1.11 root 1411: if (bdrv_check_request(bs, sector_num, nb_sectors))
1412: return -EIO;
1.1.1.14 root 1413:
1414: if (bs->dirty_bitmap) {
1415: set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1416: }
1417:
1.1.1.5 root 1418: return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1419: }
1.1.1.6 root 1420:
1.1.1.5 root 1421: int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1422: {
1423: BlockDriver *drv = bs->drv;
1424: if (!drv)
1425: return -ENOMEDIUM;
1426: if (!drv->bdrv_get_info)
1427: return -ENOTSUP;
1428: memset(bdi, 0, sizeof(*bdi));
1429: return drv->bdrv_get_info(bs, bdi);
1430: }
1431:
1.1.1.13 root 1432: int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1433: int64_t pos, int size)
1.1.1.9 root 1434: {
1435: BlockDriver *drv = bs->drv;
1436: if (!drv)
1437: return -ENOMEDIUM;
1.1.1.13 root 1438: if (!drv->bdrv_save_vmstate)
1.1.1.9 root 1439: return -ENOTSUP;
1.1.1.13 root 1440: return drv->bdrv_save_vmstate(bs, buf, pos, size);
1.1.1.9 root 1441: }
1442:
1.1.1.13 root 1443: int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1444: int64_t pos, int size)
1.1.1.9 root 1445: {
1446: BlockDriver *drv = bs->drv;
1447: if (!drv)
1448: return -ENOMEDIUM;
1.1.1.13 root 1449: if (!drv->bdrv_load_vmstate)
1.1.1.9 root 1450: return -ENOTSUP;
1.1.1.13 root 1451: return drv->bdrv_load_vmstate(bs, buf, pos, size);
1.1.1.9 root 1452: }
1453:
1.1 root 1454: /**************************************************************/
1.1.1.5 root 1455: /* handling of snapshots */
1.1 root 1456:
1.1.1.6 root 1457: int bdrv_snapshot_create(BlockDriverState *bs,
1.1.1.5 root 1458: QEMUSnapshotInfo *sn_info)
1459: {
1460: BlockDriver *drv = bs->drv;
1461: if (!drv)
1462: return -ENOMEDIUM;
1463: if (!drv->bdrv_snapshot_create)
1464: return -ENOTSUP;
1465: return drv->bdrv_snapshot_create(bs, sn_info);
1466: }
1.1 root 1467:
1.1.1.6 root 1468: int bdrv_snapshot_goto(BlockDriverState *bs,
1.1.1.5 root 1469: const char *snapshot_id)
1.1 root 1470: {
1.1.1.5 root 1471: BlockDriver *drv = bs->drv;
1472: if (!drv)
1473: return -ENOMEDIUM;
1474: if (!drv->bdrv_snapshot_goto)
1475: return -ENOTSUP;
1476: return drv->bdrv_snapshot_goto(bs, snapshot_id);
1.1 root 1477: }
1478:
1.1.1.5 root 1479: int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1.1 root 1480: {
1.1.1.5 root 1481: BlockDriver *drv = bs->drv;
1482: if (!drv)
1483: return -ENOMEDIUM;
1484: if (!drv->bdrv_snapshot_delete)
1485: return -ENOTSUP;
1486: return drv->bdrv_snapshot_delete(bs, snapshot_id);
1487: }
1.1 root 1488:
1.1.1.6 root 1489: int bdrv_snapshot_list(BlockDriverState *bs,
1.1.1.5 root 1490: QEMUSnapshotInfo **psn_info)
1491: {
1492: BlockDriver *drv = bs->drv;
1493: if (!drv)
1494: return -ENOMEDIUM;
1495: if (!drv->bdrv_snapshot_list)
1496: return -ENOTSUP;
1497: return drv->bdrv_snapshot_list(bs, psn_info);
1498: }
1499:
1500: #define NB_SUFFIXES 4
1501:
1502: char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1503: {
1504: static const char suffixes[NB_SUFFIXES] = "KMGT";
1505: int64_t base;
1506: int i;
1507:
1508: if (size <= 999) {
1509: snprintf(buf, buf_size, "%" PRId64, size);
1510: } else {
1511: base = 1024;
1512: for(i = 0; i < NB_SUFFIXES; i++) {
1513: if (size < (10 * base)) {
1.1.1.6 root 1514: snprintf(buf, buf_size, "%0.1f%c",
1.1.1.5 root 1515: (double)size / base,
1516: suffixes[i]);
1517: break;
1518: } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1.1.1.6 root 1519: snprintf(buf, buf_size, "%" PRId64 "%c",
1.1.1.5 root 1520: ((size + (base >> 1)) / base),
1521: suffixes[i]);
1522: break;
1523: }
1524: base = base * 1024;
1525: }
1.1 root 1526: }
1.1.1.5 root 1527: return buf;
1528: }
1529:
1530: char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1531: {
1532: char buf1[128], date_buf[128], clock_buf[128];
1533: #ifdef _WIN32
1534: struct tm *ptm;
1.1.1.2 root 1535: #else
1.1.1.5 root 1536: struct tm tm;
1.1.1.2 root 1537: #endif
1.1.1.5 root 1538: time_t ti;
1539: int64_t secs;
1540:
1541: if (!sn) {
1.1.1.6 root 1542: snprintf(buf, buf_size,
1543: "%-10s%-20s%7s%20s%15s",
1.1.1.5 root 1544: "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1545: } else {
1546: ti = sn->date_sec;
1.1 root 1547: #ifdef _WIN32
1.1.1.5 root 1548: ptm = localtime(&ti);
1549: strftime(date_buf, sizeof(date_buf),
1550: "%Y-%m-%d %H:%M:%S", ptm);
1551: #else
1552: localtime_r(&ti, &tm);
1553: strftime(date_buf, sizeof(date_buf),
1554: "%Y-%m-%d %H:%M:%S", &tm);
1.1 root 1555: #endif
1.1.1.5 root 1556: secs = sn->vm_clock_nsec / 1000000000;
1557: snprintf(clock_buf, sizeof(clock_buf),
1558: "%02d:%02d:%02d.%03d",
1559: (int)(secs / 3600),
1560: (int)((secs / 60) % 60),
1.1.1.6 root 1561: (int)(secs % 60),
1.1.1.5 root 1562: (int)((sn->vm_clock_nsec / 1000000) % 1000));
1563: snprintf(buf, buf_size,
1.1.1.6 root 1564: "%-10s%-20s%7s%20s%15s",
1.1.1.5 root 1565: sn->id_str, sn->name,
1566: get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1567: date_buf,
1568: clock_buf);
1569: }
1570: return buf;
1.1 root 1571: }
1572:
1573:
1.1.1.5 root 1574: /**************************************************************/
1575: /* async I/Os */
1576:
1.1.1.7 root 1577: BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1.1.1.13 root 1578: QEMUIOVector *qiov, int nb_sectors,
1.1.1.7 root 1579: BlockDriverCompletionFunc *cb, void *opaque)
1580: {
1.1.1.5 root 1581: BlockDriver *drv = bs->drv;
1.1.1.6 root 1582: BlockDriverAIOCB *ret;
1.1.1.5 root 1583:
1584: if (!drv)
1585: return NULL;
1.1.1.7 root 1586: if (bdrv_check_request(bs, sector_num, nb_sectors))
1587: return NULL;
1.1.1.5 root 1588:
1.1.1.13 root 1589: ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1590: cb, opaque);
1.1.1.6 root 1591:
1592: if (ret) {
1593: /* Update stats even though technically transfer has not happened. */
1.1.1.14 root 1594: bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1.1.1.6 root 1595: bs->rd_ops ++;
1596: }
1597:
1598: return ret;
1.1 root 1599: }
1600:
1.1.1.13 root 1601: BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
1602: QEMUIOVector *qiov, int nb_sectors,
1603: BlockDriverCompletionFunc *cb, void *opaque)
1.1 root 1604: {
1.1.1.5 root 1605: BlockDriver *drv = bs->drv;
1.1.1.6 root 1606: BlockDriverAIOCB *ret;
1.1 root 1607:
1.1.1.5 root 1608: if (!drv)
1609: return NULL;
1610: if (bs->read_only)
1611: return NULL;
1.1.1.7 root 1612: if (bdrv_check_request(bs, sector_num, nb_sectors))
1613: return NULL;
1.1.1.4 root 1614:
1.1.1.14 root 1615: if (bs->dirty_bitmap) {
1616: set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1617: }
1618:
1.1.1.13 root 1619: ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
1620: cb, opaque);
1.1.1.6 root 1621:
1622: if (ret) {
1623: /* Update stats even though technically transfer has not happened. */
1.1.1.14 root 1624: bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1.1.1.6 root 1625: bs->wr_ops ++;
1626: }
1627:
1628: return ret;
1.1.1.5 root 1629: }
1630:
1.1.1.14 root 1631:
1632: typedef struct MultiwriteCB {
1633: int error;
1634: int num_requests;
1635: int num_callbacks;
1636: struct {
1637: BlockDriverCompletionFunc *cb;
1638: void *opaque;
1639: QEMUIOVector *free_qiov;
1640: void *free_buf;
1641: } callbacks[];
1642: } MultiwriteCB;
1643:
1644: static void multiwrite_user_cb(MultiwriteCB *mcb)
1645: {
1646: int i;
1647:
1648: for (i = 0; i < mcb->num_callbacks; i++) {
1649: mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
1.1.1.16 root 1650: if (mcb->callbacks[i].free_qiov) {
1651: qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
1652: }
1.1.1.14 root 1653: qemu_free(mcb->callbacks[i].free_qiov);
1.1.1.15 root 1654: qemu_vfree(mcb->callbacks[i].free_buf);
1.1.1.14 root 1655: }
1656: }
1657:
1658: static void multiwrite_cb(void *opaque, int ret)
1659: {
1660: MultiwriteCB *mcb = opaque;
1661:
1.1.1.16 root 1662: if (ret < 0 && !mcb->error) {
1.1.1.14 root 1663: mcb->error = ret;
1664: }
1665:
1666: mcb->num_requests--;
1667: if (mcb->num_requests == 0) {
1.1.1.17! root 1668: multiwrite_user_cb(mcb);
1.1.1.14 root 1669: qemu_free(mcb);
1670: }
1671: }
1672:
1673: static int multiwrite_req_compare(const void *a, const void *b)
1674: {
1.1.1.17! root 1675: const BlockRequest *req1 = a, *req2 = b;
! 1676:
! 1677: /*
! 1678: * Note that we can't simply subtract req2->sector from req1->sector
! 1679: * here as that could overflow the return value.
! 1680: */
! 1681: if (req1->sector > req2->sector) {
! 1682: return 1;
! 1683: } else if (req1->sector < req2->sector) {
! 1684: return -1;
! 1685: } else {
! 1686: return 0;
! 1687: }
1.1.1.14 root 1688: }
1689:
1690: /*
1691: * Takes a bunch of requests and tries to merge them. Returns the number of
1692: * requests that remain after merging.
1693: */
1694: static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
1695: int num_reqs, MultiwriteCB *mcb)
1696: {
1697: int i, outidx;
1698:
1699: // Sort requests by start sector
1700: qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
1701:
1702: // Check if adjacent requests touch the same clusters. If so, combine them,
1703: // filling up gaps with zero sectors.
1704: outidx = 0;
1705: for (i = 1; i < num_reqs; i++) {
1706: int merge = 0;
1707: int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
1708:
1709: // This handles the cases that are valid for all block drivers, namely
1710: // exactly sequential writes and overlapping writes.
1711: if (reqs[i].sector <= oldreq_last) {
1712: merge = 1;
1713: }
1714:
1715: // The block driver may decide that it makes sense to combine requests
1716: // even if there is a gap of some sectors between them. In this case,
1717: // the gap is filled with zeros (therefore only applicable for yet
1718: // unused space in format like qcow2).
1719: if (!merge && bs->drv->bdrv_merge_requests) {
1720: merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
1721: }
1722:
1.1.1.16 root 1723: if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
1724: merge = 0;
1725: }
1726:
1.1.1.14 root 1727: if (merge) {
1728: size_t size;
1729: QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
1730: qemu_iovec_init(qiov,
1731: reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
1732:
1733: // Add the first request to the merged one. If the requests are
1734: // overlapping, drop the last sectors of the first request.
1735: size = (reqs[i].sector - reqs[outidx].sector) << 9;
1736: qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
1737:
1738: // We might need to add some zeros between the two requests
1739: if (reqs[i].sector > oldreq_last) {
1740: size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
1741: uint8_t *buf = qemu_blockalign(bs, zero_bytes);
1742: memset(buf, 0, zero_bytes);
1743: qemu_iovec_add(qiov, buf, zero_bytes);
1744: mcb->callbacks[i].free_buf = buf;
1745: }
1746:
1747: // Add the second request
1748: qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
1749:
1.1.1.17! root 1750: reqs[outidx].nb_sectors = qiov->size >> 9;
1.1.1.14 root 1751: reqs[outidx].qiov = qiov;
1752:
1753: mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
1754: } else {
1755: outidx++;
1756: reqs[outidx].sector = reqs[i].sector;
1757: reqs[outidx].nb_sectors = reqs[i].nb_sectors;
1758: reqs[outidx].qiov = reqs[i].qiov;
1759: }
1760: }
1761:
1762: return outidx + 1;
1763: }
1764:
1765: /*
1766: * Submit multiple AIO write requests at once.
1767: *
1768: * On success, the function returns 0 and all requests in the reqs array have
1769: * been submitted. In error case this function returns -1, and any of the
1770: * requests may or may not be submitted yet. In particular, this means that the
1771: * callback will be called for some of the requests, for others it won't. The
1772: * caller must check the error field of the BlockRequest to wait for the right
1773: * callbacks (if error != 0, no callback will be called).
1774: *
1775: * The implementation may modify the contents of the reqs array, e.g. to merge
1776: * requests. However, the fields opaque and error are left unmodified as they
1777: * are used to signal failure for a single request to the caller.
1778: */
1779: int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
1780: {
1781: BlockDriverAIOCB *acb;
1782: MultiwriteCB *mcb;
1783: int i;
1784:
1785: if (num_reqs == 0) {
1786: return 0;
1787: }
1788:
1789: // Create MultiwriteCB structure
1790: mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
1791: mcb->num_requests = 0;
1792: mcb->num_callbacks = num_reqs;
1793:
1794: for (i = 0; i < num_reqs; i++) {
1795: mcb->callbacks[i].cb = reqs[i].cb;
1796: mcb->callbacks[i].opaque = reqs[i].opaque;
1797: }
1798:
1799: // Check for mergable requests
1800: num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
1801:
1.1.1.17! root 1802: /*
! 1803: * Run the aio requests. As soon as one request can't be submitted
! 1804: * successfully, fail all requests that are not yet submitted (we must
! 1805: * return failure for all requests anyway)
! 1806: *
! 1807: * num_requests cannot be set to the right value immediately: If
! 1808: * bdrv_aio_writev fails for some request, num_requests would be too high
! 1809: * and therefore multiwrite_cb() would never recognize the multiwrite
! 1810: * request as completed. We also cannot use the loop variable i to set it
! 1811: * when the first request fails because the callback may already have been
! 1812: * called for previously submitted requests. Thus, num_requests must be
! 1813: * incremented for each request that is submitted.
! 1814: *
! 1815: * The problem that callbacks may be called early also means that we need
! 1816: * to take care that num_requests doesn't become 0 before all requests are
! 1817: * submitted - multiwrite_cb() would consider the multiwrite request
! 1818: * completed. A dummy request that is "completed" by a manual call to
! 1819: * multiwrite_cb() takes care of this.
! 1820: */
! 1821: mcb->num_requests = 1;
! 1822:
1.1.1.14 root 1823: for (i = 0; i < num_reqs; i++) {
1.1.1.17! root 1824: mcb->num_requests++;
1.1.1.14 root 1825: acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
1826: reqs[i].nb_sectors, multiwrite_cb, mcb);
1827:
1828: if (acb == NULL) {
1829: // We can only fail the whole thing if no request has been
1830: // submitted yet. Otherwise we'll wait for the submitted AIOs to
1831: // complete and report the error in the callback.
1.1.1.17! root 1832: if (i == 0) {
1.1.1.14 root 1833: goto fail;
1834: } else {
1.1.1.16 root 1835: multiwrite_cb(mcb, -EIO);
1.1.1.14 root 1836: break;
1837: }
1838: }
1839: }
1840:
1.1.1.17! root 1841: /* Complete the dummy request */
! 1842: multiwrite_cb(mcb, 0);
! 1843:
1.1.1.14 root 1844: return 0;
1845:
1846: fail:
1.1.1.17! root 1847: for (i = 0; i < mcb->num_callbacks; i++) {
! 1848: reqs[i].error = -EIO;
! 1849: }
! 1850: qemu_free(mcb);
1.1.1.14 root 1851: return -1;
1852: }
1853:
1854: BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
1855: BlockDriverCompletionFunc *cb, void *opaque)
1856: {
1857: BlockDriver *drv = bs->drv;
1858:
1859: if (!drv)
1860: return NULL;
1861:
1862: /*
1863: * Note that unlike bdrv_flush the driver is reponsible for flushing a
1864: * backing image if it exists.
1865: */
1866: return drv->bdrv_aio_flush(bs, cb, opaque);
1867: }
1868:
1.1.1.5 root 1869: void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1.1.1.4 root 1870: {
1.1.1.10 root 1871: acb->pool->cancel(acb);
1.1.1.5 root 1872: }
1.1.1.4 root 1873:
1874:
1.1.1.5 root 1875: /**************************************************************/
1876: /* async block device emulation */
1.1.1.4 root 1877:
1.1.1.13 root 1878: typedef struct BlockDriverAIOCBSync {
1879: BlockDriverAIOCB common;
1880: QEMUBH *bh;
1881: int ret;
1882: /* vector translation state */
1883: QEMUIOVector *qiov;
1884: uint8_t *bounce;
1885: int is_write;
1886: } BlockDriverAIOCBSync;
1887:
1888: static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
1889: {
1890: BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1891: qemu_bh_delete(acb->bh);
1892: acb->bh = NULL;
1893: qemu_aio_release(acb);
1894: }
1895:
1896: static AIOPool bdrv_em_aio_pool = {
1897: .aiocb_size = sizeof(BlockDriverAIOCBSync),
1898: .cancel = bdrv_aio_cancel_em,
1899: };
1900:
1.1.1.5 root 1901: static void bdrv_aio_bh_cb(void *opaque)
1.1.1.4 root 1902: {
1.1.1.5 root 1903: BlockDriverAIOCBSync *acb = opaque;
1.1.1.13 root 1904:
1905: if (!acb->is_write)
1906: qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
1907: qemu_vfree(acb->bounce);
1.1.1.5 root 1908: acb->common.cb(acb->common.opaque, acb->ret);
1.1.1.13 root 1909: qemu_bh_delete(acb->bh);
1910: acb->bh = NULL;
1.1.1.5 root 1911: qemu_aio_release(acb);
1.1.1.4 root 1912: }
1913:
1.1.1.13 root 1914: static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
1915: int64_t sector_num,
1916: QEMUIOVector *qiov,
1917: int nb_sectors,
1918: BlockDriverCompletionFunc *cb,
1919: void *opaque,
1920: int is_write)
1921:
1.1 root 1922: {
1.1.1.5 root 1923: BlockDriverAIOCBSync *acb;
1.1 root 1924:
1.1.1.13 root 1925: acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
1926: acb->is_write = is_write;
1927: acb->qiov = qiov;
1928: acb->bounce = qemu_blockalign(bs, qiov->size);
1929:
1.1.1.5 root 1930: if (!acb->bh)
1931: acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1.1.1.13 root 1932:
1933: if (is_write) {
1934: qemu_iovec_to_buffer(acb->qiov, acb->bounce);
1935: acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
1936: } else {
1937: acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
1938: }
1939:
1.1.1.5 root 1940: qemu_bh_schedule(acb->bh);
1.1.1.13 root 1941:
1.1.1.5 root 1942: return &acb->common;
1943: }
1.1 root 1944:
1.1.1.13 root 1945: static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
1946: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1.1.1.5 root 1947: BlockDriverCompletionFunc *cb, void *opaque)
1948: {
1.1.1.13 root 1949: return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
1.1.1.5 root 1950: }
1951:
1.1.1.13 root 1952: static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
1953: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1954: BlockDriverCompletionFunc *cb, void *opaque)
1.1.1.5 root 1955: {
1.1.1.13 root 1956: return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
1.1 root 1957: }
1958:
1.1.1.14 root 1959: static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
1960: BlockDriverCompletionFunc *cb, void *opaque)
1961: {
1962: BlockDriverAIOCBSync *acb;
1963:
1964: acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
1965: acb->is_write = 1; /* don't bounce in the completion hadler */
1966: acb->qiov = NULL;
1967: acb->bounce = NULL;
1968: acb->ret = 0;
1969:
1970: if (!acb->bh)
1971: acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1972:
1973: bdrv_flush(bs);
1974: qemu_bh_schedule(acb->bh);
1975: return &acb->common;
1976: }
1977:
1.1.1.5 root 1978: /**************************************************************/
1979: /* sync block device emulation */
1980:
1981: static void bdrv_rw_em_cb(void *opaque, int ret)
1.1.1.4 root 1982: {
1.1.1.5 root 1983: *(int *)opaque = ret;
1.1.1.4 root 1984: }
1985:
1.1.1.5 root 1986: #define NOT_DONE 0x7fffffff
1987:
1.1.1.6 root 1988: static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1.1.1.5 root 1989: uint8_t *buf, int nb_sectors)
1990: {
1991: int async_ret;
1992: BlockDriverAIOCB *acb;
1.1.1.13 root 1993: struct iovec iov;
1994: QEMUIOVector qiov;
1.1.1.5 root 1995:
1.1.1.14 root 1996: async_context_push();
1997:
1.1.1.5 root 1998: async_ret = NOT_DONE;
1.1.1.13 root 1999: iov.iov_base = (void *)buf;
2000: iov.iov_len = nb_sectors * 512;
2001: qemu_iovec_init_external(&qiov, &iov, 1);
2002: acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2003: bdrv_rw_em_cb, &async_ret);
1.1.1.14 root 2004: if (acb == NULL) {
2005: async_ret = -1;
2006: goto fail;
2007: }
1.1.1.7 root 2008:
1.1.1.5 root 2009: while (async_ret == NOT_DONE) {
2010: qemu_aio_wait();
2011: }
1.1.1.7 root 2012:
1.1.1.14 root 2013:
2014: fail:
2015: async_context_pop();
1.1.1.5 root 2016: return async_ret;
2017: }
2018:
2019: static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2020: const uint8_t *buf, int nb_sectors)
2021: {
2022: int async_ret;
2023: BlockDriverAIOCB *acb;
1.1.1.13 root 2024: struct iovec iov;
2025: QEMUIOVector qiov;
1.1.1.5 root 2026:
1.1.1.14 root 2027: async_context_push();
2028:
1.1.1.5 root 2029: async_ret = NOT_DONE;
1.1.1.13 root 2030: iov.iov_base = (void *)buf;
2031: iov.iov_len = nb_sectors * 512;
2032: qemu_iovec_init_external(&qiov, &iov, 1);
2033: acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2034: bdrv_rw_em_cb, &async_ret);
1.1.1.14 root 2035: if (acb == NULL) {
2036: async_ret = -1;
2037: goto fail;
2038: }
1.1.1.5 root 2039: while (async_ret == NOT_DONE) {
2040: qemu_aio_wait();
2041: }
1.1.1.14 root 2042:
2043: fail:
2044: async_context_pop();
1.1.1.5 root 2045: return async_ret;
2046: }
1.1 root 2047:
2048: void bdrv_init(void)
2049: {
1.1.1.13 root 2050: module_call_init(MODULE_INIT_BLOCK);
1.1.1.10 root 2051: }
2052:
1.1.1.14 root 2053: void bdrv_init_with_whitelist(void)
2054: {
2055: use_bdrv_whitelist = 1;
2056: bdrv_init();
2057: }
2058:
1.1.1.13 root 2059: void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2060: BlockDriverCompletionFunc *cb, void *opaque)
1.1.1.5 root 2061: {
2062: BlockDriverAIOCB *acb;
2063:
1.1.1.10 root 2064: if (pool->free_aiocb) {
2065: acb = pool->free_aiocb;
2066: pool->free_aiocb = acb->next;
1.1.1.5 root 2067: } else {
1.1.1.10 root 2068: acb = qemu_mallocz(pool->aiocb_size);
2069: acb->pool = pool;
1.1.1.5 root 2070: }
2071: acb->bs = bs;
2072: acb->cb = cb;
2073: acb->opaque = opaque;
2074: return acb;
2075: }
2076:
2077: void qemu_aio_release(void *p)
2078: {
1.1.1.10 root 2079: BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2080: AIOPool *pool = acb->pool;
2081: acb->next = pool->free_aiocb;
2082: pool->free_aiocb = acb;
1.1.1.5 root 2083: }
2084:
2085: /**************************************************************/
2086: /* removable device support */
2087:
2088: /**
2089: * Return TRUE if the media is present
2090: */
2091: int bdrv_is_inserted(BlockDriverState *bs)
2092: {
2093: BlockDriver *drv = bs->drv;
2094: int ret;
2095: if (!drv)
2096: return 0;
2097: if (!drv->bdrv_is_inserted)
2098: return 1;
2099: ret = drv->bdrv_is_inserted(bs);
2100: return ret;
2101: }
2102:
2103: /**
2104: * Return TRUE if the media changed since the last call to this
1.1.1.6 root 2105: * function. It is currently only used for floppy disks
1.1.1.5 root 2106: */
2107: int bdrv_media_changed(BlockDriverState *bs)
2108: {
2109: BlockDriver *drv = bs->drv;
2110: int ret;
2111:
2112: if (!drv || !drv->bdrv_media_changed)
2113: ret = -ENOTSUP;
2114: else
2115: ret = drv->bdrv_media_changed(bs);
2116: if (ret == -ENOTSUP)
2117: ret = bs->media_changed;
2118: bs->media_changed = 0;
2119: return ret;
2120: }
2121:
2122: /**
2123: * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2124: */
1.1.1.13 root 2125: int bdrv_eject(BlockDriverState *bs, int eject_flag)
1.1.1.5 root 2126: {
2127: BlockDriver *drv = bs->drv;
2128: int ret;
2129:
1.1.1.13 root 2130: if (bs->locked) {
2131: return -EBUSY;
2132: }
2133:
1.1.1.5 root 2134: if (!drv || !drv->bdrv_eject) {
2135: ret = -ENOTSUP;
2136: } else {
2137: ret = drv->bdrv_eject(bs, eject_flag);
2138: }
2139: if (ret == -ENOTSUP) {
2140: if (eject_flag)
2141: bdrv_close(bs);
1.1.1.13 root 2142: ret = 0;
1.1.1.5 root 2143: }
1.1.1.13 root 2144:
2145: return ret;
1.1.1.5 root 2146: }
2147:
2148: int bdrv_is_locked(BlockDriverState *bs)
2149: {
2150: return bs->locked;
2151: }
2152:
2153: /**
2154: * Lock or unlock the media (if it is locked, the user won't be able
2155: * to eject it manually).
2156: */
2157: void bdrv_set_locked(BlockDriverState *bs, int locked)
2158: {
2159: BlockDriver *drv = bs->drv;
2160:
2161: bs->locked = locked;
2162: if (drv && drv->bdrv_set_locked) {
2163: drv->bdrv_set_locked(bs, locked);
2164: }
1.1 root 2165: }
1.1.1.6 root 2166:
2167: /* needed for generic scsi interface */
2168:
2169: int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2170: {
2171: BlockDriver *drv = bs->drv;
2172:
2173: if (drv && drv->bdrv_ioctl)
2174: return drv->bdrv_ioctl(bs, req, buf);
2175: return -ENOTSUP;
2176: }
1.1.1.13 root 2177:
2178: BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2179: unsigned long int req, void *buf,
2180: BlockDriverCompletionFunc *cb, void *opaque)
2181: {
2182: BlockDriver *drv = bs->drv;
2183:
2184: if (drv && drv->bdrv_aio_ioctl)
2185: return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2186: return NULL;
2187: }
2188:
1.1.1.14 root 2189:
2190:
1.1.1.13 root 2191: void *qemu_blockalign(BlockDriverState *bs, size_t size)
2192: {
2193: return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2194: }
1.1.1.14 root 2195:
2196: void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2197: {
2198: int64_t bitmap_size;
2199:
2200: if (enable) {
2201: if (!bs->dirty_bitmap) {
2202: bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2203: BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
2204: bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2205:
2206: bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2207: }
2208: } else {
2209: if (bs->dirty_bitmap) {
2210: qemu_free(bs->dirty_bitmap);
2211: bs->dirty_bitmap = NULL;
2212: }
2213: }
2214: }
2215:
2216: int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2217: {
2218: int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2219:
2220: if (bs->dirty_bitmap &&
2221: (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2222: return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2223: (1 << (chunk % (sizeof(unsigned long) * 8)));
2224: } else {
2225: return 0;
2226: }
2227: }
2228:
2229: void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2230: int nr_sectors)
2231: {
2232: set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2233: }
unix.superglobalmegacorp.com