1: /*
2: * QEMU System Emulator block driver
3: *
4: * Copyright (c) 2003 Fabrice Bellard
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 "config-host.h"
25: #include "qemu-common.h"
26: #include "trace.h"
27: #include "monitor.h"
28: #include "block_int.h"
29: #include "module.h"
30: #include "qemu-objects.h"
31:
32: #ifdef CONFIG_BSD
33: #include <sys/types.h>
34: #include <sys/stat.h>
35: #include <sys/ioctl.h>
36: #include <sys/queue.h>
37: #ifndef __DragonFly__
38: #include <sys/disk.h>
39: #endif
40: #endif
41:
42: #ifdef _WIN32
43: #include <windows.h>
44: #endif
45:
46: static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
47: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
48: BlockDriverCompletionFunc *cb, void *opaque);
49: static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
50: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
51: BlockDriverCompletionFunc *cb, void *opaque);
52: static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
53: BlockDriverCompletionFunc *cb, void *opaque);
54: static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
55: BlockDriverCompletionFunc *cb, void *opaque);
56: static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
57: uint8_t *buf, int nb_sectors);
58: static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
59: const uint8_t *buf, int nb_sectors);
60:
61: static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
62: QTAILQ_HEAD_INITIALIZER(bdrv_states);
63:
64: static QLIST_HEAD(, BlockDriver) bdrv_drivers =
65: QLIST_HEAD_INITIALIZER(bdrv_drivers);
66:
67: /* The device to use for VM snapshots */
68: static BlockDriverState *bs_snapshots;
69:
70: /* If non-zero, use only whitelisted block drivers */
71: static int use_bdrv_whitelist;
72:
73: #ifdef _WIN32
74: static int is_windows_drive_prefix(const char *filename)
75: {
76: return (((filename[0] >= 'a' && filename[0] <= 'z') ||
77: (filename[0] >= 'A' && filename[0] <= 'Z')) &&
78: filename[1] == ':');
79: }
80:
81: int is_windows_drive(const char *filename)
82: {
83: if (is_windows_drive_prefix(filename) &&
84: filename[2] == '\0')
85: return 1;
86: if (strstart(filename, "\\\\.\\", NULL) ||
87: strstart(filename, "//./", NULL))
88: return 1;
89: return 0;
90: }
91: #endif
92:
93: /* check if the path starts with "<protocol>:" */
94: static int path_has_protocol(const char *path)
95: {
96: #ifdef _WIN32
97: if (is_windows_drive(path) ||
98: is_windows_drive_prefix(path)) {
99: return 0;
100: }
101: #endif
102:
103: return strchr(path, ':') != NULL;
104: }
105:
106: int path_is_absolute(const char *path)
107: {
108: const char *p;
109: #ifdef _WIN32
110: /* specific case for names like: "\\.\d:" */
111: if (*path == '/' || *path == '\\')
112: return 1;
113: #endif
114: p = strchr(path, ':');
115: if (p)
116: p++;
117: else
118: p = path;
119: #ifdef _WIN32
120: return (*p == '/' || *p == '\\');
121: #else
122: return (*p == '/');
123: #endif
124: }
125:
126: /* if filename is absolute, just copy it to dest. Otherwise, build a
127: path to it by considering it is relative to base_path. URL are
128: supported. */
129: void path_combine(char *dest, int dest_size,
130: const char *base_path,
131: const char *filename)
132: {
133: const char *p, *p1;
134: int len;
135:
136: if (dest_size <= 0)
137: return;
138: if (path_is_absolute(filename)) {
139: pstrcpy(dest, dest_size, filename);
140: } else {
141: p = strchr(base_path, ':');
142: if (p)
143: p++;
144: else
145: p = base_path;
146: p1 = strrchr(base_path, '/');
147: #ifdef _WIN32
148: {
149: const char *p2;
150: p2 = strrchr(base_path, '\\');
151: if (!p1 || p2 > p1)
152: p1 = p2;
153: }
154: #endif
155: if (p1)
156: p1++;
157: else
158: p1 = base_path;
159: if (p1 > p)
160: p = p1;
161: len = p - base_path;
162: if (len > dest_size - 1)
163: len = dest_size - 1;
164: memcpy(dest, base_path, len);
165: dest[len] = '\0';
166: pstrcat(dest, dest_size, filename);
167: }
168: }
169:
170: void bdrv_register(BlockDriver *bdrv)
171: {
172: if (!bdrv->bdrv_aio_readv) {
173: /* add AIO emulation layer */
174: bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
175: bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
176: } else if (!bdrv->bdrv_read) {
177: /* add synchronous IO emulation layer */
178: bdrv->bdrv_read = bdrv_read_em;
179: bdrv->bdrv_write = bdrv_write_em;
180: }
181:
182: if (!bdrv->bdrv_aio_flush)
183: bdrv->bdrv_aio_flush = bdrv_aio_flush_em;
184:
185: QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
186: }
187:
188: /* create a new block device (by default it is empty) */
189: BlockDriverState *bdrv_new(const char *device_name)
190: {
191: BlockDriverState *bs;
192:
193: bs = qemu_mallocz(sizeof(BlockDriverState));
194: pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
195: if (device_name[0] != '\0') {
196: QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
197: }
198: return bs;
199: }
200:
201: BlockDriver *bdrv_find_format(const char *format_name)
202: {
203: BlockDriver *drv1;
204: QLIST_FOREACH(drv1, &bdrv_drivers, list) {
205: if (!strcmp(drv1->format_name, format_name)) {
206: return drv1;
207: }
208: }
209: return NULL;
210: }
211:
212: static int bdrv_is_whitelisted(BlockDriver *drv)
213: {
214: static const char *whitelist[] = {
215: CONFIG_BDRV_WHITELIST
216: };
217: const char **p;
218:
219: if (!whitelist[0])
220: return 1; /* no whitelist, anything goes */
221:
222: for (p = whitelist; *p; p++) {
223: if (!strcmp(drv->format_name, *p)) {
224: return 1;
225: }
226: }
227: return 0;
228: }
229:
230: BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
231: {
232: BlockDriver *drv = bdrv_find_format(format_name);
233: return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
234: }
235:
236: int bdrv_create(BlockDriver *drv, const char* filename,
237: QEMUOptionParameter *options)
238: {
239: if (!drv->bdrv_create)
240: return -ENOTSUP;
241:
242: return drv->bdrv_create(filename, options);
243: }
244:
245: int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
246: {
247: BlockDriver *drv;
248:
249: drv = bdrv_find_protocol(filename);
250: if (drv == NULL) {
251: return -ENOENT;
252: }
253:
254: return bdrv_create(drv, filename, options);
255: }
256:
257: #ifdef _WIN32
258: void get_tmp_filename(char *filename, int size)
259: {
260: char temp_dir[MAX_PATH];
261:
262: GetTempPath(MAX_PATH, temp_dir);
263: GetTempFileName(temp_dir, "qem", 0, filename);
264: }
265: #else
266: void get_tmp_filename(char *filename, int size)
267: {
268: int fd;
269: const char *tmpdir;
270: /* XXX: race condition possible */
271: tmpdir = getenv("TMPDIR");
272: if (!tmpdir)
273: tmpdir = "/tmp";
274: snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
275: fd = mkstemp(filename);
276: close(fd);
277: }
278: #endif
279:
280: /*
281: * Detect host devices. By convention, /dev/cdrom[N] is always
282: * recognized as a host CDROM.
283: */
284: static BlockDriver *find_hdev_driver(const char *filename)
285: {
286: int score_max = 0, score;
287: BlockDriver *drv = NULL, *d;
288:
289: QLIST_FOREACH(d, &bdrv_drivers, list) {
290: if (d->bdrv_probe_device) {
291: score = d->bdrv_probe_device(filename);
292: if (score > score_max) {
293: score_max = score;
294: drv = d;
295: }
296: }
297: }
298:
299: return drv;
300: }
301:
302: BlockDriver *bdrv_find_protocol(const char *filename)
303: {
304: BlockDriver *drv1;
305: char protocol[128];
306: int len;
307: const char *p;
308:
309: /* TODO Drivers without bdrv_file_open must be specified explicitly */
310:
311: /*
312: * XXX(hch): we really should not let host device detection
313: * override an explicit protocol specification, but moving this
314: * later breaks access to device names with colons in them.
315: * Thanks to the brain-dead persistent naming schemes on udev-
316: * based Linux systems those actually are quite common.
317: */
318: drv1 = find_hdev_driver(filename);
319: if (drv1) {
320: return drv1;
321: }
322:
323: if (!path_has_protocol(filename)) {
324: return bdrv_find_format("file");
325: }
326: p = strchr(filename, ':');
327: assert(p != NULL);
328: len = p - filename;
329: if (len > sizeof(protocol) - 1)
330: len = sizeof(protocol) - 1;
331: memcpy(protocol, filename, len);
332: protocol[len] = '\0';
333: QLIST_FOREACH(drv1, &bdrv_drivers, list) {
334: if (drv1->protocol_name &&
335: !strcmp(drv1->protocol_name, protocol)) {
336: return drv1;
337: }
338: }
339: return NULL;
340: }
341:
342: static int find_image_format(const char *filename, BlockDriver **pdrv)
343: {
344: int ret, score, score_max;
345: BlockDriver *drv1, *drv;
346: uint8_t buf[2048];
347: BlockDriverState *bs;
348:
349: ret = bdrv_file_open(&bs, filename, 0);
350: if (ret < 0) {
351: *pdrv = NULL;
352: return ret;
353: }
354:
355: /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
356: if (bs->sg || !bdrv_is_inserted(bs)) {
357: bdrv_delete(bs);
358: drv = bdrv_find_format("raw");
359: if (!drv) {
360: ret = -ENOENT;
361: }
362: *pdrv = drv;
363: return ret;
364: }
365:
366: ret = bdrv_pread(bs, 0, buf, sizeof(buf));
367: bdrv_delete(bs);
368: if (ret < 0) {
369: *pdrv = NULL;
370: return ret;
371: }
372:
373: score_max = 0;
374: drv = NULL;
375: QLIST_FOREACH(drv1, &bdrv_drivers, list) {
376: if (drv1->bdrv_probe) {
377: score = drv1->bdrv_probe(buf, ret, filename);
378: if (score > score_max) {
379: score_max = score;
380: drv = drv1;
381: }
382: }
383: }
384: if (!drv) {
385: ret = -ENOENT;
386: }
387: *pdrv = drv;
388: return ret;
389: }
390:
391: /**
392: * Set the current 'total_sectors' value
393: */
394: static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
395: {
396: BlockDriver *drv = bs->drv;
397:
398: /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
399: if (bs->sg)
400: return 0;
401:
402: /* query actual device if possible, otherwise just trust the hint */
403: if (drv->bdrv_getlength) {
404: int64_t length = drv->bdrv_getlength(bs);
405: if (length < 0) {
406: return length;
407: }
408: hint = length >> BDRV_SECTOR_BITS;
409: }
410:
411: bs->total_sectors = hint;
412: return 0;
413: }
414:
415: /*
416: * Common part for opening disk images and files
417: */
418: static int bdrv_open_common(BlockDriverState *bs, const char *filename,
419: int flags, BlockDriver *drv)
420: {
421: int ret, open_flags;
422:
423: assert(drv != NULL);
424:
425: bs->file = NULL;
426: bs->total_sectors = 0;
427: bs->encrypted = 0;
428: bs->valid_key = 0;
429: bs->open_flags = flags;
430: /* buffer_alignment defaulted to 512, drivers can change this value */
431: bs->buffer_alignment = 512;
432:
433: pstrcpy(bs->filename, sizeof(bs->filename), filename);
434:
435: if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
436: return -ENOTSUP;
437: }
438:
439: bs->drv = drv;
440: bs->opaque = qemu_mallocz(drv->instance_size);
441:
442: if (flags & BDRV_O_CACHE_WB)
443: bs->enable_write_cache = 1;
444:
445: /*
446: * Clear flags that are internal to the block layer before opening the
447: * image.
448: */
449: open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
450:
451: /*
452: * Snapshots should be writable.
453: */
454: if (bs->is_temporary) {
455: open_flags |= BDRV_O_RDWR;
456: }
457:
458: /* Open the image, either directly or using a protocol */
459: if (drv->bdrv_file_open) {
460: ret = drv->bdrv_file_open(bs, filename, open_flags);
461: } else {
462: ret = bdrv_file_open(&bs->file, filename, open_flags);
463: if (ret >= 0) {
464: ret = drv->bdrv_open(bs, open_flags);
465: }
466: }
467:
468: if (ret < 0) {
469: goto free_and_fail;
470: }
471:
472: bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
473:
474: ret = refresh_total_sectors(bs, bs->total_sectors);
475: if (ret < 0) {
476: goto free_and_fail;
477: }
478:
479: #ifndef _WIN32
480: if (bs->is_temporary) {
481: unlink(filename);
482: }
483: #endif
484: return 0;
485:
486: free_and_fail:
487: if (bs->file) {
488: bdrv_delete(bs->file);
489: bs->file = NULL;
490: }
491: qemu_free(bs->opaque);
492: bs->opaque = NULL;
493: bs->drv = NULL;
494: return ret;
495: }
496:
497: /*
498: * Opens a file using a protocol (file, host_device, nbd, ...)
499: */
500: int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
501: {
502: BlockDriverState *bs;
503: BlockDriver *drv;
504: int ret;
505:
506: drv = bdrv_find_protocol(filename);
507: if (!drv) {
508: return -ENOENT;
509: }
510:
511: bs = bdrv_new("");
512: ret = bdrv_open_common(bs, filename, flags, drv);
513: if (ret < 0) {
514: bdrv_delete(bs);
515: return ret;
516: }
517: bs->growable = 1;
518: *pbs = bs;
519: return 0;
520: }
521:
522: /*
523: * Opens a disk image (raw, qcow2, vmdk, ...)
524: */
525: int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
526: BlockDriver *drv)
527: {
528: int ret;
529:
530: if (flags & BDRV_O_SNAPSHOT) {
531: BlockDriverState *bs1;
532: int64_t total_size;
533: int is_protocol = 0;
534: BlockDriver *bdrv_qcow2;
535: QEMUOptionParameter *options;
536: char tmp_filename[PATH_MAX];
537: char backing_filename[PATH_MAX];
538:
539: /* if snapshot, we create a temporary backing file and open it
540: instead of opening 'filename' directly */
541:
542: /* if there is a backing file, use it */
543: bs1 = bdrv_new("");
544: ret = bdrv_open(bs1, filename, 0, drv);
545: if (ret < 0) {
546: bdrv_delete(bs1);
547: return ret;
548: }
549: total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
550:
551: if (bs1->drv && bs1->drv->protocol_name)
552: is_protocol = 1;
553:
554: bdrv_delete(bs1);
555:
556: get_tmp_filename(tmp_filename, sizeof(tmp_filename));
557:
558: /* Real path is meaningless for protocols */
559: if (is_protocol)
560: snprintf(backing_filename, sizeof(backing_filename),
561: "%s", filename);
562: else if (!realpath(filename, backing_filename))
563: return -errno;
564:
565: bdrv_qcow2 = bdrv_find_format("qcow2");
566: options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
567:
568: set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
569: set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
570: if (drv) {
571: set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
572: drv->format_name);
573: }
574:
575: ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
576: free_option_parameters(options);
577: if (ret < 0) {
578: return ret;
579: }
580:
581: filename = tmp_filename;
582: drv = bdrv_qcow2;
583: bs->is_temporary = 1;
584: }
585:
586: /* Find the right image format driver */
587: if (!drv) {
588: ret = find_image_format(filename, &drv);
589: }
590:
591: if (!drv) {
592: goto unlink_and_fail;
593: }
594:
595: /* Open the image */
596: ret = bdrv_open_common(bs, filename, flags, drv);
597: if (ret < 0) {
598: goto unlink_and_fail;
599: }
600:
601: /* If there is a backing file, use it */
602: if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
603: char backing_filename[PATH_MAX];
604: int back_flags;
605: BlockDriver *back_drv = NULL;
606:
607: bs->backing_hd = bdrv_new("");
608:
609: if (path_has_protocol(bs->backing_file)) {
610: pstrcpy(backing_filename, sizeof(backing_filename),
611: bs->backing_file);
612: } else {
613: path_combine(backing_filename, sizeof(backing_filename),
614: filename, bs->backing_file);
615: }
616:
617: if (bs->backing_format[0] != '\0') {
618: back_drv = bdrv_find_format(bs->backing_format);
619: }
620:
621: /* backing files always opened read-only */
622: back_flags =
623: flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
624:
625: ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
626: if (ret < 0) {
627: bdrv_close(bs);
628: return ret;
629: }
630: if (bs->is_temporary) {
631: bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
632: } else {
633: /* base image inherits from "parent" */
634: bs->backing_hd->keep_read_only = bs->keep_read_only;
635: }
636: }
637:
638: if (!bdrv_key_required(bs)) {
639: /* call the change callback */
640: bs->media_changed = 1;
641: if (bs->change_cb)
642: bs->change_cb(bs->change_opaque, CHANGE_MEDIA);
643: }
644:
645: return 0;
646:
647: unlink_and_fail:
648: if (bs->is_temporary) {
649: unlink(filename);
650: }
651: return ret;
652: }
653:
654: void bdrv_close(BlockDriverState *bs)
655: {
656: if (bs->drv) {
657: if (bs == bs_snapshots) {
658: bs_snapshots = NULL;
659: }
660: if (bs->backing_hd) {
661: bdrv_delete(bs->backing_hd);
662: bs->backing_hd = NULL;
663: }
664: bs->drv->bdrv_close(bs);
665: qemu_free(bs->opaque);
666: #ifdef _WIN32
667: if (bs->is_temporary) {
668: unlink(bs->filename);
669: }
670: #endif
671: bs->opaque = NULL;
672: bs->drv = NULL;
673:
674: if (bs->file != NULL) {
675: bdrv_close(bs->file);
676: }
677:
678: /* call the change callback */
679: bs->media_changed = 1;
680: if (bs->change_cb)
681: bs->change_cb(bs->change_opaque, CHANGE_MEDIA);
682: }
683: }
684:
685: void bdrv_close_all(void)
686: {
687: BlockDriverState *bs;
688:
689: QTAILQ_FOREACH(bs, &bdrv_states, list) {
690: bdrv_close(bs);
691: }
692: }
693:
694: /* make a BlockDriverState anonymous by removing from bdrv_state list.
695: Also, NULL terminate the device_name to prevent double remove */
696: void bdrv_make_anon(BlockDriverState *bs)
697: {
698: if (bs->device_name[0] != '\0') {
699: QTAILQ_REMOVE(&bdrv_states, bs, list);
700: }
701: bs->device_name[0] = '\0';
702: }
703:
704: void bdrv_delete(BlockDriverState *bs)
705: {
706: assert(!bs->peer);
707:
708: /* remove from list, if necessary */
709: bdrv_make_anon(bs);
710:
711: bdrv_close(bs);
712: if (bs->file != NULL) {
713: bdrv_delete(bs->file);
714: }
715:
716: assert(bs != bs_snapshots);
717: qemu_free(bs);
718: }
719:
720: int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
721: {
722: if (bs->peer) {
723: return -EBUSY;
724: }
725: bs->peer = qdev;
726: return 0;
727: }
728:
729: void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
730: {
731: assert(bs->peer == qdev);
732: bs->peer = NULL;
733: }
734:
735: DeviceState *bdrv_get_attached(BlockDriverState *bs)
736: {
737: return bs->peer;
738: }
739:
740: /*
741: * Run consistency checks on an image
742: *
743: * Returns 0 if the check could be completed (it doesn't mean that the image is
744: * free of errors) or -errno when an internal error occurred. The results of the
745: * check are stored in res.
746: */
747: int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
748: {
749: if (bs->drv->bdrv_check == NULL) {
750: return -ENOTSUP;
751: }
752:
753: memset(res, 0, sizeof(*res));
754: return bs->drv->bdrv_check(bs, res);
755: }
756:
757: #define COMMIT_BUF_SECTORS 2048
758:
759: /* commit COW file into the raw image */
760: int bdrv_commit(BlockDriverState *bs)
761: {
762: BlockDriver *drv = bs->drv;
763: BlockDriver *backing_drv;
764: int64_t sector, total_sectors;
765: int n, ro, open_flags;
766: int ret = 0, rw_ret = 0;
767: uint8_t *buf;
768: char filename[1024];
769: BlockDriverState *bs_rw, *bs_ro;
770:
771: if (!drv)
772: return -ENOMEDIUM;
773:
774: if (!bs->backing_hd) {
775: return -ENOTSUP;
776: }
777:
778: if (bs->backing_hd->keep_read_only) {
779: return -EACCES;
780: }
781:
782: backing_drv = bs->backing_hd->drv;
783: ro = bs->backing_hd->read_only;
784: strncpy(filename, bs->backing_hd->filename, sizeof(filename));
785: open_flags = bs->backing_hd->open_flags;
786:
787: if (ro) {
788: /* re-open as RW */
789: bdrv_delete(bs->backing_hd);
790: bs->backing_hd = NULL;
791: bs_rw = bdrv_new("");
792: rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR,
793: backing_drv);
794: if (rw_ret < 0) {
795: bdrv_delete(bs_rw);
796: /* try to re-open read-only */
797: bs_ro = bdrv_new("");
798: ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
799: backing_drv);
800: if (ret < 0) {
801: bdrv_delete(bs_ro);
802: /* drive not functional anymore */
803: bs->drv = NULL;
804: return ret;
805: }
806: bs->backing_hd = bs_ro;
807: return rw_ret;
808: }
809: bs->backing_hd = bs_rw;
810: }
811:
812: total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
813: buf = qemu_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
814:
815: for (sector = 0; sector < total_sectors; sector += n) {
816: if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
817:
818: if (bdrv_read(bs, sector, buf, n) != 0) {
819: ret = -EIO;
820: goto ro_cleanup;
821: }
822:
823: if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
824: ret = -EIO;
825: goto ro_cleanup;
826: }
827: }
828: }
829:
830: if (drv->bdrv_make_empty) {
831: ret = drv->bdrv_make_empty(bs);
832: bdrv_flush(bs);
833: }
834:
835: /*
836: * Make sure all data we wrote to the backing device is actually
837: * stable on disk.
838: */
839: if (bs->backing_hd)
840: bdrv_flush(bs->backing_hd);
841:
842: ro_cleanup:
843: qemu_free(buf);
844:
845: if (ro) {
846: /* re-open as RO */
847: bdrv_delete(bs->backing_hd);
848: bs->backing_hd = NULL;
849: bs_ro = bdrv_new("");
850: ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR,
851: backing_drv);
852: if (ret < 0) {
853: bdrv_delete(bs_ro);
854: /* drive not functional anymore */
855: bs->drv = NULL;
856: return ret;
857: }
858: bs->backing_hd = bs_ro;
859: bs->backing_hd->keep_read_only = 0;
860: }
861:
862: return ret;
863: }
864:
865: void bdrv_commit_all(void)
866: {
867: BlockDriverState *bs;
868:
869: QTAILQ_FOREACH(bs, &bdrv_states, list) {
870: bdrv_commit(bs);
871: }
872: }
873:
874: /*
875: * Return values:
876: * 0 - success
877: * -EINVAL - backing format specified, but no file
878: * -ENOSPC - can't update the backing file because no space is left in the
879: * image file header
880: * -ENOTSUP - format driver doesn't support changing the backing file
881: */
882: int bdrv_change_backing_file(BlockDriverState *bs,
883: const char *backing_file, const char *backing_fmt)
884: {
885: BlockDriver *drv = bs->drv;
886:
887: if (drv->bdrv_change_backing_file != NULL) {
888: return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
889: } else {
890: return -ENOTSUP;
891: }
892: }
893:
894: static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
895: size_t size)
896: {
897: int64_t len;
898:
899: if (!bdrv_is_inserted(bs))
900: return -ENOMEDIUM;
901:
902: if (bs->growable)
903: return 0;
904:
905: len = bdrv_getlength(bs);
906:
907: if (offset < 0)
908: return -EIO;
909:
910: if ((offset > len) || (len - offset < size))
911: return -EIO;
912:
913: return 0;
914: }
915:
916: static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
917: int nb_sectors)
918: {
919: return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
920: nb_sectors * BDRV_SECTOR_SIZE);
921: }
922:
923: /* return < 0 if error. See bdrv_write() for the return codes */
924: int bdrv_read(BlockDriverState *bs, int64_t sector_num,
925: uint8_t *buf, int nb_sectors)
926: {
927: BlockDriver *drv = bs->drv;
928:
929: if (!drv)
930: return -ENOMEDIUM;
931: if (bdrv_check_request(bs, sector_num, nb_sectors))
932: return -EIO;
933:
934: return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
935: }
936:
937: static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
938: int nb_sectors, int dirty)
939: {
940: int64_t start, end;
941: unsigned long val, idx, bit;
942:
943: start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
944: end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
945:
946: for (; start <= end; start++) {
947: idx = start / (sizeof(unsigned long) * 8);
948: bit = start % (sizeof(unsigned long) * 8);
949: val = bs->dirty_bitmap[idx];
950: if (dirty) {
951: if (!(val & (1UL << bit))) {
952: bs->dirty_count++;
953: val |= 1UL << bit;
954: }
955: } else {
956: if (val & (1UL << bit)) {
957: bs->dirty_count--;
958: val &= ~(1UL << bit);
959: }
960: }
961: bs->dirty_bitmap[idx] = val;
962: }
963: }
964:
965: /* Return < 0 if error. Important errors are:
966: -EIO generic I/O error (may happen for all errors)
967: -ENOMEDIUM No media inserted.
968: -EINVAL Invalid sector number or nb_sectors
969: -EACCES Trying to write a read-only device
970: */
971: int bdrv_write(BlockDriverState *bs, int64_t sector_num,
972: const uint8_t *buf, int nb_sectors)
973: {
974: BlockDriver *drv = bs->drv;
975: if (!bs->drv)
976: return -ENOMEDIUM;
977: if (bs->read_only)
978: return -EACCES;
979: if (bdrv_check_request(bs, sector_num, nb_sectors))
980: return -EIO;
981:
982: if (bs->dirty_bitmap) {
983: set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
984: }
985:
986: if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
987: bs->wr_highest_sector = sector_num + nb_sectors - 1;
988: }
989:
990: return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
991: }
992:
993: int bdrv_pread(BlockDriverState *bs, int64_t offset,
994: void *buf, int count1)
995: {
996: uint8_t tmp_buf[BDRV_SECTOR_SIZE];
997: int len, nb_sectors, count;
998: int64_t sector_num;
999: int ret;
1000:
1001: count = count1;
1002: /* first read to align to sector start */
1003: len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1004: if (len > count)
1005: len = count;
1006: sector_num = offset >> BDRV_SECTOR_BITS;
1007: if (len > 0) {
1008: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1009: return ret;
1010: memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
1011: count -= len;
1012: if (count == 0)
1013: return count1;
1014: sector_num++;
1015: buf += len;
1016: }
1017:
1018: /* read the sectors "in place" */
1019: nb_sectors = count >> BDRV_SECTOR_BITS;
1020: if (nb_sectors > 0) {
1021: if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1022: return ret;
1023: sector_num += nb_sectors;
1024: len = nb_sectors << BDRV_SECTOR_BITS;
1025: buf += len;
1026: count -= len;
1027: }
1028:
1029: /* add data from the last sector */
1030: if (count > 0) {
1031: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1032: return ret;
1033: memcpy(buf, tmp_buf, count);
1034: }
1035: return count1;
1036: }
1037:
1038: int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1039: const void *buf, int count1)
1040: {
1041: uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1042: int len, nb_sectors, count;
1043: int64_t sector_num;
1044: int ret;
1045:
1046: count = count1;
1047: /* first write to align to sector start */
1048: len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1049: if (len > count)
1050: len = count;
1051: sector_num = offset >> BDRV_SECTOR_BITS;
1052: if (len > 0) {
1053: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1054: return ret;
1055: memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1056: if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1057: return ret;
1058: count -= len;
1059: if (count == 0)
1060: return count1;
1061: sector_num++;
1062: buf += len;
1063: }
1064:
1065: /* write the sectors "in place" */
1066: nb_sectors = count >> BDRV_SECTOR_BITS;
1067: if (nb_sectors > 0) {
1068: if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1069: return ret;
1070: sector_num += nb_sectors;
1071: len = nb_sectors << BDRV_SECTOR_BITS;
1072: buf += len;
1073: count -= len;
1074: }
1075:
1076: /* add data from the last sector */
1077: if (count > 0) {
1078: if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1079: return ret;
1080: memcpy(tmp_buf, buf, count);
1081: if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1082: return ret;
1083: }
1084: return count1;
1085: }
1086:
1087: /*
1088: * Writes to the file and ensures that no writes are reordered across this
1089: * request (acts as a barrier)
1090: *
1091: * Returns 0 on success, -errno in error cases.
1092: */
1093: int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1094: const void *buf, int count)
1095: {
1096: int ret;
1097:
1098: ret = bdrv_pwrite(bs, offset, buf, count);
1099: if (ret < 0) {
1100: return ret;
1101: }
1102:
1103: /* No flush needed for cache=writethrough, it uses O_DSYNC */
1104: if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
1105: bdrv_flush(bs);
1106: }
1107:
1108: return 0;
1109: }
1110:
1111: /*
1112: * Writes to the file and ensures that no writes are reordered across this
1113: * request (acts as a barrier)
1114: *
1115: * Returns 0 on success, -errno in error cases.
1116: */
1117: int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
1118: const uint8_t *buf, int nb_sectors)
1119: {
1120: return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
1121: buf, BDRV_SECTOR_SIZE * nb_sectors);
1122: }
1123:
1124: /**
1125: * Truncate file to 'offset' bytes (needed only for file protocols)
1126: */
1127: int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1128: {
1129: BlockDriver *drv = bs->drv;
1130: int ret;
1131: if (!drv)
1132: return -ENOMEDIUM;
1133: if (!drv->bdrv_truncate)
1134: return -ENOTSUP;
1135: if (bs->read_only)
1136: return -EACCES;
1137: if (bdrv_in_use(bs))
1138: return -EBUSY;
1139: ret = drv->bdrv_truncate(bs, offset);
1140: if (ret == 0) {
1141: ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1142: if (bs->change_cb) {
1143: bs->change_cb(bs->change_opaque, CHANGE_SIZE);
1144: }
1145: }
1146: return ret;
1147: }
1148:
1149: /**
1150: * Length of a allocated file in bytes. Sparse files are counted by actual
1151: * allocated space. Return < 0 if error or unknown.
1152: */
1153: int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
1154: {
1155: BlockDriver *drv = bs->drv;
1156: if (!drv) {
1157: return -ENOMEDIUM;
1158: }
1159: if (drv->bdrv_get_allocated_file_size) {
1160: return drv->bdrv_get_allocated_file_size(bs);
1161: }
1162: if (bs->file) {
1163: return bdrv_get_allocated_file_size(bs->file);
1164: }
1165: return -ENOTSUP;
1166: }
1167:
1168: /**
1169: * Length of a file in bytes. Return < 0 if error or unknown.
1170: */
1171: int64_t bdrv_getlength(BlockDriverState *bs)
1172: {
1173: BlockDriver *drv = bs->drv;
1174: if (!drv)
1175: return -ENOMEDIUM;
1176:
1177: if (bs->growable || bs->removable) {
1178: if (drv->bdrv_getlength) {
1179: return drv->bdrv_getlength(bs);
1180: }
1181: }
1182: return bs->total_sectors * BDRV_SECTOR_SIZE;
1183: }
1184:
1185: /* return 0 as number of sectors if no device present or error */
1186: void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1187: {
1188: int64_t length;
1189: length = bdrv_getlength(bs);
1190: if (length < 0)
1191: length = 0;
1192: else
1193: length = length >> BDRV_SECTOR_BITS;
1194: *nb_sectors_ptr = length;
1195: }
1196:
1197: struct partition {
1198: uint8_t boot_ind; /* 0x80 - active */
1199: uint8_t head; /* starting head */
1200: uint8_t sector; /* starting sector */
1201: uint8_t cyl; /* starting cylinder */
1202: uint8_t sys_ind; /* What partition type */
1203: uint8_t end_head; /* end head */
1204: uint8_t end_sector; /* end sector */
1205: uint8_t end_cyl; /* end cylinder */
1206: uint32_t start_sect; /* starting sector counting from 0 */
1207: uint32_t nr_sects; /* nr of sectors in partition */
1208: } __attribute__((packed));
1209:
1210: /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1211: static int guess_disk_lchs(BlockDriverState *bs,
1212: int *pcylinders, int *pheads, int *psectors)
1213: {
1214: uint8_t buf[BDRV_SECTOR_SIZE];
1215: int ret, i, heads, sectors, cylinders;
1216: struct partition *p;
1217: uint32_t nr_sects;
1218: uint64_t nb_sectors;
1219:
1220: bdrv_get_geometry(bs, &nb_sectors);
1221:
1222: ret = bdrv_read(bs, 0, buf, 1);
1223: if (ret < 0)
1224: return -1;
1225: /* test msdos magic */
1226: if (buf[510] != 0x55 || buf[511] != 0xaa)
1227: return -1;
1228: for(i = 0; i < 4; i++) {
1229: p = ((struct partition *)(buf + 0x1be)) + i;
1230: nr_sects = le32_to_cpu(p->nr_sects);
1231: if (nr_sects && p->end_head) {
1232: /* We make the assumption that the partition terminates on
1233: a cylinder boundary */
1234: heads = p->end_head + 1;
1235: sectors = p->end_sector & 63;
1236: if (sectors == 0)
1237: continue;
1238: cylinders = nb_sectors / (heads * sectors);
1239: if (cylinders < 1 || cylinders > 16383)
1240: continue;
1241: *pheads = heads;
1242: *psectors = sectors;
1243: *pcylinders = cylinders;
1244: #if 0
1245: printf("guessed geometry: LCHS=%d %d %d\n",
1246: cylinders, heads, sectors);
1247: #endif
1248: return 0;
1249: }
1250: }
1251: return -1;
1252: }
1253:
1254: void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1255: {
1256: int translation, lba_detected = 0;
1257: int cylinders, heads, secs;
1258: uint64_t nb_sectors;
1259:
1260: /* if a geometry hint is available, use it */
1261: bdrv_get_geometry(bs, &nb_sectors);
1262: bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1263: translation = bdrv_get_translation_hint(bs);
1264: if (cylinders != 0) {
1265: *pcyls = cylinders;
1266: *pheads = heads;
1267: *psecs = secs;
1268: } else {
1269: if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1270: if (heads > 16) {
1271: /* if heads > 16, it means that a BIOS LBA
1272: translation was active, so the default
1273: hardware geometry is OK */
1274: lba_detected = 1;
1275: goto default_geometry;
1276: } else {
1277: *pcyls = cylinders;
1278: *pheads = heads;
1279: *psecs = secs;
1280: /* disable any translation to be in sync with
1281: the logical geometry */
1282: if (translation == BIOS_ATA_TRANSLATION_AUTO) {
1283: bdrv_set_translation_hint(bs,
1284: BIOS_ATA_TRANSLATION_NONE);
1285: }
1286: }
1287: } else {
1288: default_geometry:
1289: /* if no geometry, use a standard physical disk geometry */
1290: cylinders = nb_sectors / (16 * 63);
1291:
1292: if (cylinders > 16383)
1293: cylinders = 16383;
1294: else if (cylinders < 2)
1295: cylinders = 2;
1296: *pcyls = cylinders;
1297: *pheads = 16;
1298: *psecs = 63;
1299: if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
1300: if ((*pcyls * *pheads) <= 131072) {
1301: bdrv_set_translation_hint(bs,
1302: BIOS_ATA_TRANSLATION_LARGE);
1303: } else {
1304: bdrv_set_translation_hint(bs,
1305: BIOS_ATA_TRANSLATION_LBA);
1306: }
1307: }
1308: }
1309: bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1310: }
1311: }
1312:
1313: void bdrv_set_geometry_hint(BlockDriverState *bs,
1314: int cyls, int heads, int secs)
1315: {
1316: bs->cyls = cyls;
1317: bs->heads = heads;
1318: bs->secs = secs;
1319: }
1320:
1321: void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1322: {
1323: bs->translation = translation;
1324: }
1325:
1326: void bdrv_get_geometry_hint(BlockDriverState *bs,
1327: int *pcyls, int *pheads, int *psecs)
1328: {
1329: *pcyls = bs->cyls;
1330: *pheads = bs->heads;
1331: *psecs = bs->secs;
1332: }
1333:
1334: /* Recognize floppy formats */
1335: typedef struct FDFormat {
1336: FDriveType drive;
1337: uint8_t last_sect;
1338: uint8_t max_track;
1339: uint8_t max_head;
1340: } FDFormat;
1341:
1342: static const FDFormat fd_formats[] = {
1343: /* First entry is default format */
1344: /* 1.44 MB 3"1/2 floppy disks */
1345: { FDRIVE_DRV_144, 18, 80, 1, },
1346: { FDRIVE_DRV_144, 20, 80, 1, },
1347: { FDRIVE_DRV_144, 21, 80, 1, },
1348: { FDRIVE_DRV_144, 21, 82, 1, },
1349: { FDRIVE_DRV_144, 21, 83, 1, },
1350: { FDRIVE_DRV_144, 22, 80, 1, },
1351: { FDRIVE_DRV_144, 23, 80, 1, },
1352: { FDRIVE_DRV_144, 24, 80, 1, },
1353: /* 2.88 MB 3"1/2 floppy disks */
1354: { FDRIVE_DRV_288, 36, 80, 1, },
1355: { FDRIVE_DRV_288, 39, 80, 1, },
1356: { FDRIVE_DRV_288, 40, 80, 1, },
1357: { FDRIVE_DRV_288, 44, 80, 1, },
1358: { FDRIVE_DRV_288, 48, 80, 1, },
1359: /* 720 kB 3"1/2 floppy disks */
1360: { FDRIVE_DRV_144, 9, 80, 1, },
1361: { FDRIVE_DRV_144, 10, 80, 1, },
1362: { FDRIVE_DRV_144, 10, 82, 1, },
1363: { FDRIVE_DRV_144, 10, 83, 1, },
1364: { FDRIVE_DRV_144, 13, 80, 1, },
1365: { FDRIVE_DRV_144, 14, 80, 1, },
1366: /* 1.2 MB 5"1/4 floppy disks */
1367: { FDRIVE_DRV_120, 15, 80, 1, },
1368: { FDRIVE_DRV_120, 18, 80, 1, },
1369: { FDRIVE_DRV_120, 18, 82, 1, },
1370: { FDRIVE_DRV_120, 18, 83, 1, },
1371: { FDRIVE_DRV_120, 20, 80, 1, },
1372: /* 720 kB 5"1/4 floppy disks */
1373: { FDRIVE_DRV_120, 9, 80, 1, },
1374: { FDRIVE_DRV_120, 11, 80, 1, },
1375: /* 360 kB 5"1/4 floppy disks */
1376: { FDRIVE_DRV_120, 9, 40, 1, },
1377: { FDRIVE_DRV_120, 9, 40, 0, },
1378: { FDRIVE_DRV_120, 10, 41, 1, },
1379: { FDRIVE_DRV_120, 10, 42, 1, },
1380: /* 320 kB 5"1/4 floppy disks */
1381: { FDRIVE_DRV_120, 8, 40, 1, },
1382: { FDRIVE_DRV_120, 8, 40, 0, },
1383: /* 360 kB must match 5"1/4 better than 3"1/2... */
1384: { FDRIVE_DRV_144, 9, 80, 0, },
1385: /* end */
1386: { FDRIVE_DRV_NONE, -1, -1, 0, },
1387: };
1388:
1389: void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
1390: int *max_track, int *last_sect,
1391: FDriveType drive_in, FDriveType *drive)
1392: {
1393: const FDFormat *parse;
1394: uint64_t nb_sectors, size;
1395: int i, first_match, match;
1396:
1397: bdrv_get_geometry_hint(bs, nb_heads, max_track, last_sect);
1398: if (*nb_heads != 0 && *max_track != 0 && *last_sect != 0) {
1399: /* User defined disk */
1400: } else {
1401: bdrv_get_geometry(bs, &nb_sectors);
1402: match = -1;
1403: first_match = -1;
1404: for (i = 0; ; i++) {
1405: parse = &fd_formats[i];
1406: if (parse->drive == FDRIVE_DRV_NONE) {
1407: break;
1408: }
1409: if (drive_in == parse->drive ||
1410: drive_in == FDRIVE_DRV_NONE) {
1411: size = (parse->max_head + 1) * parse->max_track *
1412: parse->last_sect;
1413: if (nb_sectors == size) {
1414: match = i;
1415: break;
1416: }
1417: if (first_match == -1) {
1418: first_match = i;
1419: }
1420: }
1421: }
1422: if (match == -1) {
1423: if (first_match == -1) {
1424: match = 1;
1425: } else {
1426: match = first_match;
1427: }
1428: parse = &fd_formats[match];
1429: }
1430: *nb_heads = parse->max_head + 1;
1431: *max_track = parse->max_track;
1432: *last_sect = parse->last_sect;
1433: *drive = parse->drive;
1434: }
1435: }
1436:
1437: int bdrv_get_translation_hint(BlockDriverState *bs)
1438: {
1439: return bs->translation;
1440: }
1441:
1442: void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1443: BlockErrorAction on_write_error)
1444: {
1445: bs->on_read_error = on_read_error;
1446: bs->on_write_error = on_write_error;
1447: }
1448:
1449: BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1450: {
1451: return is_read ? bs->on_read_error : bs->on_write_error;
1452: }
1453:
1454: void bdrv_set_removable(BlockDriverState *bs, int removable)
1455: {
1456: bs->removable = removable;
1457: if (removable && bs == bs_snapshots) {
1458: bs_snapshots = NULL;
1459: }
1460: }
1461:
1462: int bdrv_is_removable(BlockDriverState *bs)
1463: {
1464: return bs->removable;
1465: }
1466:
1467: int bdrv_is_read_only(BlockDriverState *bs)
1468: {
1469: return bs->read_only;
1470: }
1471:
1472: int bdrv_is_sg(BlockDriverState *bs)
1473: {
1474: return bs->sg;
1475: }
1476:
1477: int bdrv_enable_write_cache(BlockDriverState *bs)
1478: {
1479: return bs->enable_write_cache;
1480: }
1481:
1482: /* XXX: no longer used */
1483: void bdrv_set_change_cb(BlockDriverState *bs,
1484: void (*change_cb)(void *opaque, int reason),
1485: void *opaque)
1486: {
1487: bs->change_cb = change_cb;
1488: bs->change_opaque = opaque;
1489: }
1490:
1491: int bdrv_is_encrypted(BlockDriverState *bs)
1492: {
1493: if (bs->backing_hd && bs->backing_hd->encrypted)
1494: return 1;
1495: return bs->encrypted;
1496: }
1497:
1498: int bdrv_key_required(BlockDriverState *bs)
1499: {
1500: BlockDriverState *backing_hd = bs->backing_hd;
1501:
1502: if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
1503: return 1;
1504: return (bs->encrypted && !bs->valid_key);
1505: }
1506:
1507: int bdrv_set_key(BlockDriverState *bs, const char *key)
1508: {
1509: int ret;
1510: if (bs->backing_hd && bs->backing_hd->encrypted) {
1511: ret = bdrv_set_key(bs->backing_hd, key);
1512: if (ret < 0)
1513: return ret;
1514: if (!bs->encrypted)
1515: return 0;
1516: }
1517: if (!bs->encrypted) {
1518: return -EINVAL;
1519: } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1520: return -ENOMEDIUM;
1521: }
1522: ret = bs->drv->bdrv_set_key(bs, key);
1523: if (ret < 0) {
1524: bs->valid_key = 0;
1525: } else if (!bs->valid_key) {
1526: bs->valid_key = 1;
1527: /* call the change callback now, we skipped it on open */
1528: bs->media_changed = 1;
1529: if (bs->change_cb)
1530: bs->change_cb(bs->change_opaque, CHANGE_MEDIA);
1531: }
1532: return ret;
1533: }
1534:
1535: void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1536: {
1537: if (!bs->drv) {
1538: buf[0] = '\0';
1539: } else {
1540: pstrcpy(buf, buf_size, bs->drv->format_name);
1541: }
1542: }
1543:
1544: void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1545: void *opaque)
1546: {
1547: BlockDriver *drv;
1548:
1549: QLIST_FOREACH(drv, &bdrv_drivers, list) {
1550: it(opaque, drv->format_name);
1551: }
1552: }
1553:
1554: BlockDriverState *bdrv_find(const char *name)
1555: {
1556: BlockDriverState *bs;
1557:
1558: QTAILQ_FOREACH(bs, &bdrv_states, list) {
1559: if (!strcmp(name, bs->device_name)) {
1560: return bs;
1561: }
1562: }
1563: return NULL;
1564: }
1565:
1566: BlockDriverState *bdrv_next(BlockDriverState *bs)
1567: {
1568: if (!bs) {
1569: return QTAILQ_FIRST(&bdrv_states);
1570: }
1571: return QTAILQ_NEXT(bs, list);
1572: }
1573:
1574: void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1575: {
1576: BlockDriverState *bs;
1577:
1578: QTAILQ_FOREACH(bs, &bdrv_states, list) {
1579: it(opaque, bs);
1580: }
1581: }
1582:
1583: const char *bdrv_get_device_name(BlockDriverState *bs)
1584: {
1585: return bs->device_name;
1586: }
1587:
1588: int bdrv_flush(BlockDriverState *bs)
1589: {
1590: if (bs->open_flags & BDRV_O_NO_FLUSH) {
1591: return 0;
1592: }
1593:
1594: if (bs->drv && bs->drv->bdrv_flush) {
1595: return bs->drv->bdrv_flush(bs);
1596: }
1597:
1598: /*
1599: * Some block drivers always operate in either writethrough or unsafe mode
1600: * and don't support bdrv_flush therefore. Usually qemu doesn't know how
1601: * the server works (because the behaviour is hardcoded or depends on
1602: * server-side configuration), so we can't ensure that everything is safe
1603: * on disk. Returning an error doesn't work because that would break guests
1604: * even if the server operates in writethrough mode.
1605: *
1606: * Let's hope the user knows what he's doing.
1607: */
1608: return 0;
1609: }
1610:
1611: void bdrv_flush_all(void)
1612: {
1613: BlockDriverState *bs;
1614:
1615: QTAILQ_FOREACH(bs, &bdrv_states, list) {
1616: if (bs->drv && !bdrv_is_read_only(bs) &&
1617: (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
1618: bdrv_flush(bs);
1619: }
1620: }
1621: }
1622:
1623: int bdrv_has_zero_init(BlockDriverState *bs)
1624: {
1625: assert(bs->drv);
1626:
1627: if (bs->drv->bdrv_has_zero_init) {
1628: return bs->drv->bdrv_has_zero_init(bs);
1629: }
1630:
1631: return 1;
1632: }
1633:
1634: int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
1635: {
1636: if (!bs->drv) {
1637: return -ENOMEDIUM;
1638: }
1639: if (!bs->drv->bdrv_discard) {
1640: return 0;
1641: }
1642: return bs->drv->bdrv_discard(bs, sector_num, nb_sectors);
1643: }
1644:
1645: /*
1646: * Returns true iff the specified sector is present in the disk image. Drivers
1647: * not implementing the functionality are assumed to not support backing files,
1648: * hence all their sectors are reported as allocated.
1649: *
1650: * 'pnum' is set to the number of sectors (including and immediately following
1651: * the specified sector) that are known to be in the same
1652: * allocated/unallocated state.
1653: *
1654: * 'nb_sectors' is the max value 'pnum' should be set to.
1655: */
1656: int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1657: int *pnum)
1658: {
1659: int64_t n;
1660: if (!bs->drv->bdrv_is_allocated) {
1661: if (sector_num >= bs->total_sectors) {
1662: *pnum = 0;
1663: return 0;
1664: }
1665: n = bs->total_sectors - sector_num;
1666: *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1667: return 1;
1668: }
1669: return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1670: }
1671:
1672: void bdrv_mon_event(const BlockDriverState *bdrv,
1673: BlockMonEventAction action, int is_read)
1674: {
1675: QObject *data;
1676: const char *action_str;
1677:
1678: switch (action) {
1679: case BDRV_ACTION_REPORT:
1680: action_str = "report";
1681: break;
1682: case BDRV_ACTION_IGNORE:
1683: action_str = "ignore";
1684: break;
1685: case BDRV_ACTION_STOP:
1686: action_str = "stop";
1687: break;
1688: default:
1689: abort();
1690: }
1691:
1692: data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1693: bdrv->device_name,
1694: action_str,
1695: is_read ? "read" : "write");
1696: monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data);
1697:
1698: qobject_decref(data);
1699: }
1700:
1701: static void bdrv_print_dict(QObject *obj, void *opaque)
1702: {
1703: QDict *bs_dict;
1704: Monitor *mon = opaque;
1705:
1706: bs_dict = qobject_to_qdict(obj);
1707:
1708: monitor_printf(mon, "%s: removable=%d",
1709: qdict_get_str(bs_dict, "device"),
1710: qdict_get_bool(bs_dict, "removable"));
1711:
1712: if (qdict_get_bool(bs_dict, "removable")) {
1713: monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked"));
1714: }
1715:
1716: if (qdict_haskey(bs_dict, "inserted")) {
1717: QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted"));
1718:
1719: monitor_printf(mon, " file=");
1720: monitor_print_filename(mon, qdict_get_str(qdict, "file"));
1721: if (qdict_haskey(qdict, "backing_file")) {
1722: monitor_printf(mon, " backing_file=");
1723: monitor_print_filename(mon, qdict_get_str(qdict, "backing_file"));
1724: }
1725: monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
1726: qdict_get_bool(qdict, "ro"),
1727: qdict_get_str(qdict, "drv"),
1728: qdict_get_bool(qdict, "encrypted"));
1729: } else {
1730: monitor_printf(mon, " [not inserted]");
1731: }
1732:
1733: monitor_printf(mon, "\n");
1734: }
1735:
1736: void bdrv_info_print(Monitor *mon, const QObject *data)
1737: {
1738: qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon);
1739: }
1740:
1741: void bdrv_info(Monitor *mon, QObject **ret_data)
1742: {
1743: QList *bs_list;
1744: BlockDriverState *bs;
1745:
1746: bs_list = qlist_new();
1747:
1748: QTAILQ_FOREACH(bs, &bdrv_states, list) {
1749: QObject *bs_obj;
1750:
1751: bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': 'unknown', "
1752: "'removable': %i, 'locked': %i }",
1753: bs->device_name, bs->removable,
1754: bs->locked);
1755:
1756: if (bs->drv) {
1757: QObject *obj;
1758: QDict *bs_dict = qobject_to_qdict(bs_obj);
1759:
1760: obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, "
1761: "'encrypted': %i }",
1762: bs->filename, bs->read_only,
1763: bs->drv->format_name,
1764: bdrv_is_encrypted(bs));
1765: if (bs->backing_file[0] != '\0') {
1766: QDict *qdict = qobject_to_qdict(obj);
1767: qdict_put(qdict, "backing_file",
1768: qstring_from_str(bs->backing_file));
1769: }
1770:
1771: qdict_put_obj(bs_dict, "inserted", obj);
1772: }
1773: qlist_append_obj(bs_list, bs_obj);
1774: }
1775:
1776: *ret_data = QOBJECT(bs_list);
1777: }
1778:
1779: static void bdrv_stats_iter(QObject *data, void *opaque)
1780: {
1781: QDict *qdict;
1782: Monitor *mon = opaque;
1783:
1784: qdict = qobject_to_qdict(data);
1785: monitor_printf(mon, "%s:", qdict_get_str(qdict, "device"));
1786:
1787: qdict = qobject_to_qdict(qdict_get(qdict, "stats"));
1788: monitor_printf(mon, " rd_bytes=%" PRId64
1789: " wr_bytes=%" PRId64
1790: " rd_operations=%" PRId64
1791: " wr_operations=%" PRId64
1792: "\n",
1793: qdict_get_int(qdict, "rd_bytes"),
1794: qdict_get_int(qdict, "wr_bytes"),
1795: qdict_get_int(qdict, "rd_operations"),
1796: qdict_get_int(qdict, "wr_operations"));
1797: }
1798:
1799: void bdrv_stats_print(Monitor *mon, const QObject *data)
1800: {
1801: qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon);
1802: }
1803:
1804: static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1805: {
1806: QObject *res;
1807: QDict *dict;
1808:
1809: res = qobject_from_jsonf("{ 'stats': {"
1810: "'rd_bytes': %" PRId64 ","
1811: "'wr_bytes': %" PRId64 ","
1812: "'rd_operations': %" PRId64 ","
1813: "'wr_operations': %" PRId64 ","
1814: "'wr_highest_offset': %" PRId64
1815: "} }",
1816: bs->rd_bytes, bs->wr_bytes,
1817: bs->rd_ops, bs->wr_ops,
1818: bs->wr_highest_sector *
1819: (uint64_t)BDRV_SECTOR_SIZE);
1820: dict = qobject_to_qdict(res);
1821:
1822: if (*bs->device_name) {
1823: qdict_put(dict, "device", qstring_from_str(bs->device_name));
1824: }
1825:
1826: if (bs->file) {
1827: QObject *parent = bdrv_info_stats_bs(bs->file);
1828: qdict_put_obj(dict, "parent", parent);
1829: }
1830:
1831: return res;
1832: }
1833:
1834: void bdrv_info_stats(Monitor *mon, QObject **ret_data)
1835: {
1836: QObject *obj;
1837: QList *devices;
1838: BlockDriverState *bs;
1839:
1840: devices = qlist_new();
1841:
1842: QTAILQ_FOREACH(bs, &bdrv_states, list) {
1843: obj = bdrv_info_stats_bs(bs);
1844: qlist_append_obj(devices, obj);
1845: }
1846:
1847: *ret_data = QOBJECT(devices);
1848: }
1849:
1850: const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1851: {
1852: if (bs->backing_hd && bs->backing_hd->encrypted)
1853: return bs->backing_file;
1854: else if (bs->encrypted)
1855: return bs->filename;
1856: else
1857: return NULL;
1858: }
1859:
1860: void bdrv_get_backing_filename(BlockDriverState *bs,
1861: char *filename, int filename_size)
1862: {
1863: if (!bs->backing_file) {
1864: pstrcpy(filename, filename_size, "");
1865: } else {
1866: pstrcpy(filename, filename_size, bs->backing_file);
1867: }
1868: }
1869:
1870: int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1871: const uint8_t *buf, int nb_sectors)
1872: {
1873: BlockDriver *drv = bs->drv;
1874: if (!drv)
1875: return -ENOMEDIUM;
1876: if (!drv->bdrv_write_compressed)
1877: return -ENOTSUP;
1878: if (bdrv_check_request(bs, sector_num, nb_sectors))
1879: return -EIO;
1880:
1881: if (bs->dirty_bitmap) {
1882: set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1883: }
1884:
1885: return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1886: }
1887:
1888: int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1889: {
1890: BlockDriver *drv = bs->drv;
1891: if (!drv)
1892: return -ENOMEDIUM;
1893: if (!drv->bdrv_get_info)
1894: return -ENOTSUP;
1895: memset(bdi, 0, sizeof(*bdi));
1896: return drv->bdrv_get_info(bs, bdi);
1897: }
1898:
1899: int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1900: int64_t pos, int size)
1901: {
1902: BlockDriver *drv = bs->drv;
1903: if (!drv)
1904: return -ENOMEDIUM;
1905: if (drv->bdrv_save_vmstate)
1906: return drv->bdrv_save_vmstate(bs, buf, pos, size);
1907: if (bs->file)
1908: return bdrv_save_vmstate(bs->file, buf, pos, size);
1909: return -ENOTSUP;
1910: }
1911:
1912: int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1913: int64_t pos, int size)
1914: {
1915: BlockDriver *drv = bs->drv;
1916: if (!drv)
1917: return -ENOMEDIUM;
1918: if (drv->bdrv_load_vmstate)
1919: return drv->bdrv_load_vmstate(bs, buf, pos, size);
1920: if (bs->file)
1921: return bdrv_load_vmstate(bs->file, buf, pos, size);
1922: return -ENOTSUP;
1923: }
1924:
1925: void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
1926: {
1927: BlockDriver *drv = bs->drv;
1928:
1929: if (!drv || !drv->bdrv_debug_event) {
1930: return;
1931: }
1932:
1933: return drv->bdrv_debug_event(bs, event);
1934:
1935: }
1936:
1937: /**************************************************************/
1938: /* handling of snapshots */
1939:
1940: int bdrv_can_snapshot(BlockDriverState *bs)
1941: {
1942: BlockDriver *drv = bs->drv;
1943: if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1944: return 0;
1945: }
1946:
1947: if (!drv->bdrv_snapshot_create) {
1948: if (bs->file != NULL) {
1949: return bdrv_can_snapshot(bs->file);
1950: }
1951: return 0;
1952: }
1953:
1954: return 1;
1955: }
1956:
1957: int bdrv_is_snapshot(BlockDriverState *bs)
1958: {
1959: return !!(bs->open_flags & BDRV_O_SNAPSHOT);
1960: }
1961:
1962: BlockDriverState *bdrv_snapshots(void)
1963: {
1964: BlockDriverState *bs;
1965:
1966: if (bs_snapshots) {
1967: return bs_snapshots;
1968: }
1969:
1970: bs = NULL;
1971: while ((bs = bdrv_next(bs))) {
1972: if (bdrv_can_snapshot(bs)) {
1973: bs_snapshots = bs;
1974: return bs;
1975: }
1976: }
1977: return NULL;
1978: }
1979:
1980: int bdrv_snapshot_create(BlockDriverState *bs,
1981: QEMUSnapshotInfo *sn_info)
1982: {
1983: BlockDriver *drv = bs->drv;
1984: if (!drv)
1985: return -ENOMEDIUM;
1986: if (drv->bdrv_snapshot_create)
1987: return drv->bdrv_snapshot_create(bs, sn_info);
1988: if (bs->file)
1989: return bdrv_snapshot_create(bs->file, sn_info);
1990: return -ENOTSUP;
1991: }
1992:
1993: int bdrv_snapshot_goto(BlockDriverState *bs,
1994: const char *snapshot_id)
1995: {
1996: BlockDriver *drv = bs->drv;
1997: int ret, open_ret;
1998:
1999: if (!drv)
2000: return -ENOMEDIUM;
2001: if (drv->bdrv_snapshot_goto)
2002: return drv->bdrv_snapshot_goto(bs, snapshot_id);
2003:
2004: if (bs->file) {
2005: drv->bdrv_close(bs);
2006: ret = bdrv_snapshot_goto(bs->file, snapshot_id);
2007: open_ret = drv->bdrv_open(bs, bs->open_flags);
2008: if (open_ret < 0) {
2009: bdrv_delete(bs->file);
2010: bs->drv = NULL;
2011: return open_ret;
2012: }
2013: return ret;
2014: }
2015:
2016: return -ENOTSUP;
2017: }
2018:
2019: int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
2020: {
2021: BlockDriver *drv = bs->drv;
2022: if (!drv)
2023: return -ENOMEDIUM;
2024: if (drv->bdrv_snapshot_delete)
2025: return drv->bdrv_snapshot_delete(bs, snapshot_id);
2026: if (bs->file)
2027: return bdrv_snapshot_delete(bs->file, snapshot_id);
2028: return -ENOTSUP;
2029: }
2030:
2031: int bdrv_snapshot_list(BlockDriverState *bs,
2032: QEMUSnapshotInfo **psn_info)
2033: {
2034: BlockDriver *drv = bs->drv;
2035: if (!drv)
2036: return -ENOMEDIUM;
2037: if (drv->bdrv_snapshot_list)
2038: return drv->bdrv_snapshot_list(bs, psn_info);
2039: if (bs->file)
2040: return bdrv_snapshot_list(bs->file, psn_info);
2041: return -ENOTSUP;
2042: }
2043:
2044: int bdrv_snapshot_load_tmp(BlockDriverState *bs,
2045: const char *snapshot_name)
2046: {
2047: BlockDriver *drv = bs->drv;
2048: if (!drv) {
2049: return -ENOMEDIUM;
2050: }
2051: if (!bs->read_only) {
2052: return -EINVAL;
2053: }
2054: if (drv->bdrv_snapshot_load_tmp) {
2055: return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
2056: }
2057: return -ENOTSUP;
2058: }
2059:
2060: #define NB_SUFFIXES 4
2061:
2062: char *get_human_readable_size(char *buf, int buf_size, int64_t size)
2063: {
2064: static const char suffixes[NB_SUFFIXES] = "KMGT";
2065: int64_t base;
2066: int i;
2067:
2068: if (size <= 999) {
2069: snprintf(buf, buf_size, "%" PRId64, size);
2070: } else {
2071: base = 1024;
2072: for(i = 0; i < NB_SUFFIXES; i++) {
2073: if (size < (10 * base)) {
2074: snprintf(buf, buf_size, "%0.1f%c",
2075: (double)size / base,
2076: suffixes[i]);
2077: break;
2078: } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
2079: snprintf(buf, buf_size, "%" PRId64 "%c",
2080: ((size + (base >> 1)) / base),
2081: suffixes[i]);
2082: break;
2083: }
2084: base = base * 1024;
2085: }
2086: }
2087: return buf;
2088: }
2089:
2090: char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
2091: {
2092: char buf1[128], date_buf[128], clock_buf[128];
2093: #ifdef _WIN32
2094: struct tm *ptm;
2095: #else
2096: struct tm tm;
2097: #endif
2098: time_t ti;
2099: int64_t secs;
2100:
2101: if (!sn) {
2102: snprintf(buf, buf_size,
2103: "%-10s%-20s%7s%20s%15s",
2104: "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2105: } else {
2106: ti = sn->date_sec;
2107: #ifdef _WIN32
2108: ptm = localtime(&ti);
2109: strftime(date_buf, sizeof(date_buf),
2110: "%Y-%m-%d %H:%M:%S", ptm);
2111: #else
2112: localtime_r(&ti, &tm);
2113: strftime(date_buf, sizeof(date_buf),
2114: "%Y-%m-%d %H:%M:%S", &tm);
2115: #endif
2116: secs = sn->vm_clock_nsec / 1000000000;
2117: snprintf(clock_buf, sizeof(clock_buf),
2118: "%02d:%02d:%02d.%03d",
2119: (int)(secs / 3600),
2120: (int)((secs / 60) % 60),
2121: (int)(secs % 60),
2122: (int)((sn->vm_clock_nsec / 1000000) % 1000));
2123: snprintf(buf, buf_size,
2124: "%-10s%-20s%7s%20s%15s",
2125: sn->id_str, sn->name,
2126: get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
2127: date_buf,
2128: clock_buf);
2129: }
2130: return buf;
2131: }
2132:
2133:
2134: /**************************************************************/
2135: /* async I/Os */
2136:
2137: BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
2138: QEMUIOVector *qiov, int nb_sectors,
2139: BlockDriverCompletionFunc *cb, void *opaque)
2140: {
2141: BlockDriver *drv = bs->drv;
2142: BlockDriverAIOCB *ret;
2143:
2144: trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
2145:
2146: if (!drv)
2147: return NULL;
2148: if (bdrv_check_request(bs, sector_num, nb_sectors))
2149: return NULL;
2150:
2151: ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
2152: cb, opaque);
2153:
2154: if (ret) {
2155: /* Update stats even though technically transfer has not happened. */
2156: bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2157: bs->rd_ops ++;
2158: }
2159:
2160: return ret;
2161: }
2162:
2163: typedef struct BlockCompleteData {
2164: BlockDriverCompletionFunc *cb;
2165: void *opaque;
2166: BlockDriverState *bs;
2167: int64_t sector_num;
2168: int nb_sectors;
2169: } BlockCompleteData;
2170:
2171: static void block_complete_cb(void *opaque, int ret)
2172: {
2173: BlockCompleteData *b = opaque;
2174:
2175: if (b->bs->dirty_bitmap) {
2176: set_dirty_bitmap(b->bs, b->sector_num, b->nb_sectors, 1);
2177: }
2178: b->cb(b->opaque, ret);
2179: qemu_free(b);
2180: }
2181:
2182: static BlockCompleteData *blk_dirty_cb_alloc(BlockDriverState *bs,
2183: int64_t sector_num,
2184: int nb_sectors,
2185: BlockDriverCompletionFunc *cb,
2186: void *opaque)
2187: {
2188: BlockCompleteData *blkdata = qemu_mallocz(sizeof(BlockCompleteData));
2189:
2190: blkdata->bs = bs;
2191: blkdata->cb = cb;
2192: blkdata->opaque = opaque;
2193: blkdata->sector_num = sector_num;
2194: blkdata->nb_sectors = nb_sectors;
2195:
2196: return blkdata;
2197: }
2198:
2199: BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2200: QEMUIOVector *qiov, int nb_sectors,
2201: BlockDriverCompletionFunc *cb, void *opaque)
2202: {
2203: BlockDriver *drv = bs->drv;
2204: BlockDriverAIOCB *ret;
2205: BlockCompleteData *blk_cb_data;
2206:
2207: trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
2208:
2209: if (!drv)
2210: return NULL;
2211: if (bs->read_only)
2212: return NULL;
2213: if (bdrv_check_request(bs, sector_num, nb_sectors))
2214: return NULL;
2215:
2216: if (bs->dirty_bitmap) {
2217: blk_cb_data = blk_dirty_cb_alloc(bs, sector_num, nb_sectors, cb,
2218: opaque);
2219: cb = &block_complete_cb;
2220: opaque = blk_cb_data;
2221: }
2222:
2223: ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2224: cb, opaque);
2225:
2226: if (ret) {
2227: /* Update stats even though technically transfer has not happened. */
2228: bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2229: bs->wr_ops ++;
2230: if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2231: bs->wr_highest_sector = sector_num + nb_sectors - 1;
2232: }
2233: }
2234:
2235: return ret;
2236: }
2237:
2238:
2239: typedef struct MultiwriteCB {
2240: int error;
2241: int num_requests;
2242: int num_callbacks;
2243: struct {
2244: BlockDriverCompletionFunc *cb;
2245: void *opaque;
2246: QEMUIOVector *free_qiov;
2247: void *free_buf;
2248: } callbacks[];
2249: } MultiwriteCB;
2250:
2251: static void multiwrite_user_cb(MultiwriteCB *mcb)
2252: {
2253: int i;
2254:
2255: for (i = 0; i < mcb->num_callbacks; i++) {
2256: mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
2257: if (mcb->callbacks[i].free_qiov) {
2258: qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
2259: }
2260: qemu_free(mcb->callbacks[i].free_qiov);
2261: qemu_vfree(mcb->callbacks[i].free_buf);
2262: }
2263: }
2264:
2265: static void multiwrite_cb(void *opaque, int ret)
2266: {
2267: MultiwriteCB *mcb = opaque;
2268:
2269: trace_multiwrite_cb(mcb, ret);
2270:
2271: if (ret < 0 && !mcb->error) {
2272: mcb->error = ret;
2273: }
2274:
2275: mcb->num_requests--;
2276: if (mcb->num_requests == 0) {
2277: multiwrite_user_cb(mcb);
2278: qemu_free(mcb);
2279: }
2280: }
2281:
2282: static int multiwrite_req_compare(const void *a, const void *b)
2283: {
2284: const BlockRequest *req1 = a, *req2 = b;
2285:
2286: /*
2287: * Note that we can't simply subtract req2->sector from req1->sector
2288: * here as that could overflow the return value.
2289: */
2290: if (req1->sector > req2->sector) {
2291: return 1;
2292: } else if (req1->sector < req2->sector) {
2293: return -1;
2294: } else {
2295: return 0;
2296: }
2297: }
2298:
2299: /*
2300: * Takes a bunch of requests and tries to merge them. Returns the number of
2301: * requests that remain after merging.
2302: */
2303: static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2304: int num_reqs, MultiwriteCB *mcb)
2305: {
2306: int i, outidx;
2307:
2308: // Sort requests by start sector
2309: qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
2310:
2311: // Check if adjacent requests touch the same clusters. If so, combine them,
2312: // filling up gaps with zero sectors.
2313: outidx = 0;
2314: for (i = 1; i < num_reqs; i++) {
2315: int merge = 0;
2316: int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
2317:
2318: // This handles the cases that are valid for all block drivers, namely
2319: // exactly sequential writes and overlapping writes.
2320: if (reqs[i].sector <= oldreq_last) {
2321: merge = 1;
2322: }
2323:
2324: // The block driver may decide that it makes sense to combine requests
2325: // even if there is a gap of some sectors between them. In this case,
2326: // the gap is filled with zeros (therefore only applicable for yet
2327: // unused space in format like qcow2).
2328: if (!merge && bs->drv->bdrv_merge_requests) {
2329: merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2330: }
2331:
2332: if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
2333: merge = 0;
2334: }
2335:
2336: if (merge) {
2337: size_t size;
2338: QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov));
2339: qemu_iovec_init(qiov,
2340: reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
2341:
2342: // Add the first request to the merged one. If the requests are
2343: // overlapping, drop the last sectors of the first request.
2344: size = (reqs[i].sector - reqs[outidx].sector) << 9;
2345: qemu_iovec_concat(qiov, reqs[outidx].qiov, size);
2346:
2347: // We might need to add some zeros between the two requests
2348: if (reqs[i].sector > oldreq_last) {
2349: size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9;
2350: uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2351: memset(buf, 0, zero_bytes);
2352: qemu_iovec_add(qiov, buf, zero_bytes);
2353: mcb->callbacks[i].free_buf = buf;
2354: }
2355:
2356: // Add the second request
2357: qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size);
2358:
2359: reqs[outidx].nb_sectors = qiov->size >> 9;
2360: reqs[outidx].qiov = qiov;
2361:
2362: mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
2363: } else {
2364: outidx++;
2365: reqs[outidx].sector = reqs[i].sector;
2366: reqs[outidx].nb_sectors = reqs[i].nb_sectors;
2367: reqs[outidx].qiov = reqs[i].qiov;
2368: }
2369: }
2370:
2371: return outidx + 1;
2372: }
2373:
2374: /*
2375: * Submit multiple AIO write requests at once.
2376: *
2377: * On success, the function returns 0 and all requests in the reqs array have
2378: * been submitted. In error case this function returns -1, and any of the
2379: * requests may or may not be submitted yet. In particular, this means that the
2380: * callback will be called for some of the requests, for others it won't. The
2381: * caller must check the error field of the BlockRequest to wait for the right
2382: * callbacks (if error != 0, no callback will be called).
2383: *
2384: * The implementation may modify the contents of the reqs array, e.g. to merge
2385: * requests. However, the fields opaque and error are left unmodified as they
2386: * are used to signal failure for a single request to the caller.
2387: */
2388: int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2389: {
2390: BlockDriverAIOCB *acb;
2391: MultiwriteCB *mcb;
2392: int i;
2393:
2394: /* don't submit writes if we don't have a medium */
2395: if (bs->drv == NULL) {
2396: for (i = 0; i < num_reqs; i++) {
2397: reqs[i].error = -ENOMEDIUM;
2398: }
2399: return -1;
2400: }
2401:
2402: if (num_reqs == 0) {
2403: return 0;
2404: }
2405:
2406: // Create MultiwriteCB structure
2407: mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
2408: mcb->num_requests = 0;
2409: mcb->num_callbacks = num_reqs;
2410:
2411: for (i = 0; i < num_reqs; i++) {
2412: mcb->callbacks[i].cb = reqs[i].cb;
2413: mcb->callbacks[i].opaque = reqs[i].opaque;
2414: }
2415:
2416: // Check for mergable requests
2417: num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2418:
2419: trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
2420:
2421: /*
2422: * Run the aio requests. As soon as one request can't be submitted
2423: * successfully, fail all requests that are not yet submitted (we must
2424: * return failure for all requests anyway)
2425: *
2426: * num_requests cannot be set to the right value immediately: If
2427: * bdrv_aio_writev fails for some request, num_requests would be too high
2428: * and therefore multiwrite_cb() would never recognize the multiwrite
2429: * request as completed. We also cannot use the loop variable i to set it
2430: * when the first request fails because the callback may already have been
2431: * called for previously submitted requests. Thus, num_requests must be
2432: * incremented for each request that is submitted.
2433: *
2434: * The problem that callbacks may be called early also means that we need
2435: * to take care that num_requests doesn't become 0 before all requests are
2436: * submitted - multiwrite_cb() would consider the multiwrite request
2437: * completed. A dummy request that is "completed" by a manual call to
2438: * multiwrite_cb() takes care of this.
2439: */
2440: mcb->num_requests = 1;
2441:
2442: // Run the aio requests
2443: for (i = 0; i < num_reqs; i++) {
2444: mcb->num_requests++;
2445: acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2446: reqs[i].nb_sectors, multiwrite_cb, mcb);
2447:
2448: if (acb == NULL) {
2449: // We can only fail the whole thing if no request has been
2450: // submitted yet. Otherwise we'll wait for the submitted AIOs to
2451: // complete and report the error in the callback.
2452: if (i == 0) {
2453: trace_bdrv_aio_multiwrite_earlyfail(mcb);
2454: goto fail;
2455: } else {
2456: trace_bdrv_aio_multiwrite_latefail(mcb, i);
2457: multiwrite_cb(mcb, -EIO);
2458: break;
2459: }
2460: }
2461: }
2462:
2463: /* Complete the dummy request */
2464: multiwrite_cb(mcb, 0);
2465:
2466: return 0;
2467:
2468: fail:
2469: for (i = 0; i < mcb->num_callbacks; i++) {
2470: reqs[i].error = -EIO;
2471: }
2472: qemu_free(mcb);
2473: return -1;
2474: }
2475:
2476: BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2477: BlockDriverCompletionFunc *cb, void *opaque)
2478: {
2479: BlockDriver *drv = bs->drv;
2480:
2481: trace_bdrv_aio_flush(bs, opaque);
2482:
2483: if (bs->open_flags & BDRV_O_NO_FLUSH) {
2484: return bdrv_aio_noop_em(bs, cb, opaque);
2485: }
2486:
2487: if (!drv)
2488: return NULL;
2489: return drv->bdrv_aio_flush(bs, cb, opaque);
2490: }
2491:
2492: void bdrv_aio_cancel(BlockDriverAIOCB *acb)
2493: {
2494: acb->pool->cancel(acb);
2495: }
2496:
2497:
2498: /**************************************************************/
2499: /* async block device emulation */
2500:
2501: typedef struct BlockDriverAIOCBSync {
2502: BlockDriverAIOCB common;
2503: QEMUBH *bh;
2504: int ret;
2505: /* vector translation state */
2506: QEMUIOVector *qiov;
2507: uint8_t *bounce;
2508: int is_write;
2509: } BlockDriverAIOCBSync;
2510:
2511: static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
2512: {
2513: BlockDriverAIOCBSync *acb =
2514: container_of(blockacb, BlockDriverAIOCBSync, common);
2515: qemu_bh_delete(acb->bh);
2516: acb->bh = NULL;
2517: qemu_aio_release(acb);
2518: }
2519:
2520: static AIOPool bdrv_em_aio_pool = {
2521: .aiocb_size = sizeof(BlockDriverAIOCBSync),
2522: .cancel = bdrv_aio_cancel_em,
2523: };
2524:
2525: static void bdrv_aio_bh_cb(void *opaque)
2526: {
2527: BlockDriverAIOCBSync *acb = opaque;
2528:
2529: if (!acb->is_write)
2530: qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
2531: qemu_vfree(acb->bounce);
2532: acb->common.cb(acb->common.opaque, acb->ret);
2533: qemu_bh_delete(acb->bh);
2534: acb->bh = NULL;
2535: qemu_aio_release(acb);
2536: }
2537:
2538: static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2539: int64_t sector_num,
2540: QEMUIOVector *qiov,
2541: int nb_sectors,
2542: BlockDriverCompletionFunc *cb,
2543: void *opaque,
2544: int is_write)
2545:
2546: {
2547: BlockDriverAIOCBSync *acb;
2548:
2549: acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2550: acb->is_write = is_write;
2551: acb->qiov = qiov;
2552: acb->bounce = qemu_blockalign(bs, qiov->size);
2553:
2554: if (!acb->bh)
2555: acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2556:
2557: if (is_write) {
2558: qemu_iovec_to_buffer(acb->qiov, acb->bounce);
2559: acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2560: } else {
2561: acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2562: }
2563:
2564: qemu_bh_schedule(acb->bh);
2565:
2566: return &acb->common;
2567: }
2568:
2569: static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2570: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2571: BlockDriverCompletionFunc *cb, void *opaque)
2572: {
2573: return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2574: }
2575:
2576: static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2577: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
2578: BlockDriverCompletionFunc *cb, void *opaque)
2579: {
2580: return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2581: }
2582:
2583: static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2584: BlockDriverCompletionFunc *cb, void *opaque)
2585: {
2586: BlockDriverAIOCBSync *acb;
2587:
2588: acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2589: acb->is_write = 1; /* don't bounce in the completion hadler */
2590: acb->qiov = NULL;
2591: acb->bounce = NULL;
2592: acb->ret = 0;
2593:
2594: if (!acb->bh)
2595: acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2596:
2597: bdrv_flush(bs);
2598: qemu_bh_schedule(acb->bh);
2599: return &acb->common;
2600: }
2601:
2602: static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2603: BlockDriverCompletionFunc *cb, void *opaque)
2604: {
2605: BlockDriverAIOCBSync *acb;
2606:
2607: acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2608: acb->is_write = 1; /* don't bounce in the completion handler */
2609: acb->qiov = NULL;
2610: acb->bounce = NULL;
2611: acb->ret = 0;
2612:
2613: if (!acb->bh) {
2614: acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
2615: }
2616:
2617: qemu_bh_schedule(acb->bh);
2618: return &acb->common;
2619: }
2620:
2621: /**************************************************************/
2622: /* sync block device emulation */
2623:
2624: static void bdrv_rw_em_cb(void *opaque, int ret)
2625: {
2626: *(int *)opaque = ret;
2627: }
2628:
2629: #define NOT_DONE 0x7fffffff
2630:
2631: static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2632: uint8_t *buf, int nb_sectors)
2633: {
2634: int async_ret;
2635: BlockDriverAIOCB *acb;
2636: struct iovec iov;
2637: QEMUIOVector qiov;
2638:
2639: async_context_push();
2640:
2641: async_ret = NOT_DONE;
2642: iov.iov_base = (void *)buf;
2643: iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2644: qemu_iovec_init_external(&qiov, &iov, 1);
2645: acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2646: bdrv_rw_em_cb, &async_ret);
2647: if (acb == NULL) {
2648: async_ret = -1;
2649: goto fail;
2650: }
2651:
2652: while (async_ret == NOT_DONE) {
2653: qemu_aio_wait();
2654: }
2655:
2656:
2657: fail:
2658: async_context_pop();
2659: return async_ret;
2660: }
2661:
2662: static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2663: const uint8_t *buf, int nb_sectors)
2664: {
2665: int async_ret;
2666: BlockDriverAIOCB *acb;
2667: struct iovec iov;
2668: QEMUIOVector qiov;
2669:
2670: async_context_push();
2671:
2672: async_ret = NOT_DONE;
2673: iov.iov_base = (void *)buf;
2674: iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2675: qemu_iovec_init_external(&qiov, &iov, 1);
2676: acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2677: bdrv_rw_em_cb, &async_ret);
2678: if (acb == NULL) {
2679: async_ret = -1;
2680: goto fail;
2681: }
2682: while (async_ret == NOT_DONE) {
2683: qemu_aio_wait();
2684: }
2685:
2686: fail:
2687: async_context_pop();
2688: return async_ret;
2689: }
2690:
2691: void bdrv_init(void)
2692: {
2693: module_call_init(MODULE_INIT_BLOCK);
2694: }
2695:
2696: void bdrv_init_with_whitelist(void)
2697: {
2698: use_bdrv_whitelist = 1;
2699: bdrv_init();
2700: }
2701:
2702: void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2703: BlockDriverCompletionFunc *cb, void *opaque)
2704: {
2705: BlockDriverAIOCB *acb;
2706:
2707: if (pool->free_aiocb) {
2708: acb = pool->free_aiocb;
2709: pool->free_aiocb = acb->next;
2710: } else {
2711: acb = qemu_mallocz(pool->aiocb_size);
2712: acb->pool = pool;
2713: }
2714: acb->bs = bs;
2715: acb->cb = cb;
2716: acb->opaque = opaque;
2717: return acb;
2718: }
2719:
2720: void qemu_aio_release(void *p)
2721: {
2722: BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
2723: AIOPool *pool = acb->pool;
2724: acb->next = pool->free_aiocb;
2725: pool->free_aiocb = acb;
2726: }
2727:
2728: /**************************************************************/
2729: /* removable device support */
2730:
2731: /**
2732: * Return TRUE if the media is present
2733: */
2734: int bdrv_is_inserted(BlockDriverState *bs)
2735: {
2736: BlockDriver *drv = bs->drv;
2737: int ret;
2738: if (!drv)
2739: return 0;
2740: if (!drv->bdrv_is_inserted)
2741: return !bs->tray_open;
2742: ret = drv->bdrv_is_inserted(bs);
2743: return ret;
2744: }
2745:
2746: /**
2747: * Return TRUE if the media changed since the last call to this
2748: * function. It is currently only used for floppy disks
2749: */
2750: int bdrv_media_changed(BlockDriverState *bs)
2751: {
2752: BlockDriver *drv = bs->drv;
2753: int ret;
2754:
2755: if (!drv || !drv->bdrv_media_changed)
2756: ret = -ENOTSUP;
2757: else
2758: ret = drv->bdrv_media_changed(bs);
2759: if (ret == -ENOTSUP)
2760: ret = bs->media_changed;
2761: bs->media_changed = 0;
2762: return ret;
2763: }
2764:
2765: /**
2766: * If eject_flag is TRUE, eject the media. Otherwise, close the tray
2767: */
2768: int bdrv_eject(BlockDriverState *bs, int eject_flag)
2769: {
2770: BlockDriver *drv = bs->drv;
2771: int ret;
2772:
2773: if (bs->locked) {
2774: return -EBUSY;
2775: }
2776:
2777: if (!drv || !drv->bdrv_eject) {
2778: ret = -ENOTSUP;
2779: } else {
2780: ret = drv->bdrv_eject(bs, eject_flag);
2781: }
2782: if (ret == -ENOTSUP) {
2783: ret = 0;
2784: }
2785: if (ret >= 0) {
2786: bs->tray_open = eject_flag;
2787: }
2788:
2789: return ret;
2790: }
2791:
2792: int bdrv_is_locked(BlockDriverState *bs)
2793: {
2794: return bs->locked;
2795: }
2796:
2797: /**
2798: * Lock or unlock the media (if it is locked, the user won't be able
2799: * to eject it manually).
2800: */
2801: void bdrv_set_locked(BlockDriverState *bs, int locked)
2802: {
2803: BlockDriver *drv = bs->drv;
2804:
2805: trace_bdrv_set_locked(bs, locked);
2806:
2807: bs->locked = locked;
2808: if (drv && drv->bdrv_set_locked) {
2809: drv->bdrv_set_locked(bs, locked);
2810: }
2811: }
2812:
2813: /* needed for generic scsi interface */
2814:
2815: int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2816: {
2817: BlockDriver *drv = bs->drv;
2818:
2819: if (drv && drv->bdrv_ioctl)
2820: return drv->bdrv_ioctl(bs, req, buf);
2821: return -ENOTSUP;
2822: }
2823:
2824: BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2825: unsigned long int req, void *buf,
2826: BlockDriverCompletionFunc *cb, void *opaque)
2827: {
2828: BlockDriver *drv = bs->drv;
2829:
2830: if (drv && drv->bdrv_aio_ioctl)
2831: return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2832: return NULL;
2833: }
2834:
2835:
2836:
2837: void *qemu_blockalign(BlockDriverState *bs, size_t size)
2838: {
2839: return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2840: }
2841:
2842: void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2843: {
2844: int64_t bitmap_size;
2845:
2846: bs->dirty_count = 0;
2847: if (enable) {
2848: if (!bs->dirty_bitmap) {
2849: bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2850: BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
2851: bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
2852:
2853: bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2854: }
2855: } else {
2856: if (bs->dirty_bitmap) {
2857: qemu_free(bs->dirty_bitmap);
2858: bs->dirty_bitmap = NULL;
2859: }
2860: }
2861: }
2862:
2863: int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2864: {
2865: int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
2866:
2867: if (bs->dirty_bitmap &&
2868: (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2869: return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2870: (1UL << (chunk % (sizeof(unsigned long) * 8))));
2871: } else {
2872: return 0;
2873: }
2874: }
2875:
2876: void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2877: int nr_sectors)
2878: {
2879: set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2880: }
2881:
2882: int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2883: {
2884: return bs->dirty_count;
2885: }
2886:
2887: void bdrv_set_in_use(BlockDriverState *bs, int in_use)
2888: {
2889: assert(bs->in_use != in_use);
2890: bs->in_use = in_use;
2891: }
2892:
2893: int bdrv_in_use(BlockDriverState *bs)
2894: {
2895: return bs->in_use;
2896: }
2897:
2898: int bdrv_img_create(const char *filename, const char *fmt,
2899: const char *base_filename, const char *base_fmt,
2900: char *options, uint64_t img_size, int flags)
2901: {
2902: QEMUOptionParameter *param = NULL, *create_options = NULL;
2903: QEMUOptionParameter *backing_fmt, *backing_file, *size;
2904: BlockDriverState *bs = NULL;
2905: BlockDriver *drv, *proto_drv;
2906: BlockDriver *backing_drv = NULL;
2907: int ret = 0;
2908:
2909: /* Find driver and parse its options */
2910: drv = bdrv_find_format(fmt);
2911: if (!drv) {
2912: error_report("Unknown file format '%s'", fmt);
2913: ret = -EINVAL;
2914: goto out;
2915: }
2916:
2917: proto_drv = bdrv_find_protocol(filename);
2918: if (!proto_drv) {
2919: error_report("Unknown protocol '%s'", filename);
2920: ret = -EINVAL;
2921: goto out;
2922: }
2923:
2924: create_options = append_option_parameters(create_options,
2925: drv->create_options);
2926: create_options = append_option_parameters(create_options,
2927: proto_drv->create_options);
2928:
2929: /* Create parameter list with default values */
2930: param = parse_option_parameters("", create_options, param);
2931:
2932: set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
2933:
2934: /* Parse -o options */
2935: if (options) {
2936: param = parse_option_parameters(options, create_options, param);
2937: if (param == NULL) {
2938: error_report("Invalid options for file format '%s'.", fmt);
2939: ret = -EINVAL;
2940: goto out;
2941: }
2942: }
2943:
2944: if (base_filename) {
2945: if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
2946: base_filename)) {
2947: error_report("Backing file not supported for file format '%s'",
2948: fmt);
2949: ret = -EINVAL;
2950: goto out;
2951: }
2952: }
2953:
2954: if (base_fmt) {
2955: if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
2956: error_report("Backing file format not supported for file "
2957: "format '%s'", fmt);
2958: ret = -EINVAL;
2959: goto out;
2960: }
2961: }
2962:
2963: backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
2964: if (backing_file && backing_file->value.s) {
2965: if (!strcmp(filename, backing_file->value.s)) {
2966: error_report("Error: Trying to create an image with the "
2967: "same filename as the backing file");
2968: ret = -EINVAL;
2969: goto out;
2970: }
2971: }
2972:
2973: backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
2974: if (backing_fmt && backing_fmt->value.s) {
2975: backing_drv = bdrv_find_format(backing_fmt->value.s);
2976: if (!backing_drv) {
2977: error_report("Unknown backing file format '%s'",
2978: backing_fmt->value.s);
2979: ret = -EINVAL;
2980: goto out;
2981: }
2982: }
2983:
2984: // The size for the image must always be specified, with one exception:
2985: // If we are using a backing file, we can obtain the size from there
2986: size = get_option_parameter(param, BLOCK_OPT_SIZE);
2987: if (size && size->value.n == -1) {
2988: if (backing_file && backing_file->value.s) {
2989: uint64_t size;
2990: char buf[32];
2991:
2992: bs = bdrv_new("");
2993:
2994: ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv);
2995: if (ret < 0) {
2996: error_report("Could not open '%s'", backing_file->value.s);
2997: goto out;
2998: }
2999: bdrv_get_geometry(bs, &size);
3000: size *= 512;
3001:
3002: snprintf(buf, sizeof(buf), "%" PRId64, size);
3003: set_option_parameter(param, BLOCK_OPT_SIZE, buf);
3004: } else {
3005: error_report("Image creation needs a size parameter");
3006: ret = -EINVAL;
3007: goto out;
3008: }
3009: }
3010:
3011: printf("Formatting '%s', fmt=%s ", filename, fmt);
3012: print_option_parameters(param);
3013: puts("");
3014:
3015: ret = bdrv_create(drv, filename, param);
3016:
3017: if (ret < 0) {
3018: if (ret == -ENOTSUP) {
3019: error_report("Formatting or formatting option not supported for "
3020: "file format '%s'", fmt);
3021: } else if (ret == -EFBIG) {
3022: error_report("The image size is too large for file format '%s'",
3023: fmt);
3024: } else {
3025: error_report("%s: error while creating %s: %s", filename, fmt,
3026: strerror(-ret));
3027: }
3028: }
3029:
3030: out:
3031: free_option_parameters(create_options);
3032: free_option_parameters(param);
3033:
3034: if (bs) {
3035: bdrv_delete(bs);
3036: }
3037:
3038: return ret;
3039: }
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to block.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu