?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Refactor aio callback allocation to use an aiocb pool (Avi Kivity)
[qemu-kvm/fedora.git] / block.c
blob1aa3de573b0659fbf5066f3cb2e4ea0bb7498f04
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 #ifdef _BSD
26 /* include native header before sys-queue.h */
27 #include <sys/queue.h>
28 #endif
29
30 #include "qemu-common.h"
31 #include "console.h"
32 #include "block_int.h"
33
34 #ifdef _BSD
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/ioctl.h>
38 #include <sys/disk.h>
39 #endif
40
41 #define SECTOR_BITS 9
42 #define SECTOR_SIZE (1 << SECTOR_BITS)
43
44 typedef struct BlockDriverAIOCBSync {
45 BlockDriverAIOCB common;
46 QEMUBH *bh;
47 int ret;
48 } BlockDriverAIOCBSync;
49
50 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
51 int64_t sector_num, uint8_t *buf, int nb_sectors,
52 BlockDriverCompletionFunc *cb, void *opaque);
53 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
54 int64_t sector_num, const uint8_t *buf, int nb_sectors,
55 BlockDriverCompletionFunc *cb, void *opaque);
56 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);
57 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
58 uint8_t *buf, int nb_sectors);
59 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
60 const uint8_t *buf, int nb_sectors);
61
62 BlockDriverState *bdrv_first;
63
64 static BlockDriver *first_drv;
65
66 int path_is_absolute(const char *path)
67 {
68 const char *p;
69 #ifdef _WIN32
70 /* specific case for names like: "\\.\d:" */
71 if (*path == '/' || *path == '\\')
72 return 1;
73 #endif
74 p = strchr(path, ':');
75 if (p)
76 p++;
77 else
78 p = path;
79 #ifdef _WIN32
80 return (*p == '/' || *p == '\\');
81 #else
82 return (*p == '/');
83 #endif
84 }
85
86 /* if filename is absolute, just copy it to dest. Otherwise, build a
87 path to it by considering it is relative to base_path. URL are
88 supported. */
89 void path_combine(char *dest, int dest_size,
90 const char *base_path,
91 const char *filename)
92 {
93 const char *p, *p1;
94 int len;
95
96 if (dest_size <= 0)
97 return;
98 if (path_is_absolute(filename)) {
99 pstrcpy(dest, dest_size, filename);
100 } else {
101 p = strchr(base_path, ':');
102 if (p)
103 p++;
104 else
105 p = base_path;
106 p1 = strrchr(base_path, '/');
107 #ifdef _WIN32
108 {
109 const char *p2;
110 p2 = strrchr(base_path, '\\');
111 if (!p1 || p2 > p1)
112 p1 = p2;
113 }
114 #endif
115 if (p1)
116 p1++;
117 else
118 p1 = base_path;
119 if (p1 > p)
120 p = p1;
121 len = p - base_path;
122 if (len > dest_size - 1)
123 len = dest_size - 1;
124 memcpy(dest, base_path, len);
125 dest[len] = '\0';
126 pstrcat(dest, dest_size, filename);
127 }
128 }
129
130
131 static void bdrv_register(BlockDriver *bdrv)
132 {
133 if (!bdrv->bdrv_aio_read) {
134 /* add AIO emulation layer */
135 bdrv->bdrv_aio_read = bdrv_aio_read_em;
136 bdrv->bdrv_aio_write = bdrv_aio_write_em;
137 bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em;
138 bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync);
139 } else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) {
140 /* add synchronous IO emulation layer */
141 bdrv->bdrv_read = bdrv_read_em;
142 bdrv->bdrv_write = bdrv_write_em;
143 }
144 aio_pool_init(&bdrv->aio_pool, bdrv->aiocb_size, bdrv->bdrv_aio_cancel);
145 bdrv->next = first_drv;
146 first_drv = bdrv;
147 }
148
149 /* create a new block device (by default it is empty) */
150 BlockDriverState *bdrv_new(const char *device_name)
151 {
152 BlockDriverState **pbs, *bs;
153
154 bs = qemu_mallocz(sizeof(BlockDriverState));
155 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
156 if (device_name[0] != '\0') {
157 /* insert at the end */
158 pbs = &bdrv_first;
159 while (*pbs != NULL)
160 pbs = &(*pbs)->next;
161 *pbs = bs;
162 }
163 return bs;
164 }
165
166 BlockDriver *bdrv_find_format(const char *format_name)
167 {
168 BlockDriver *drv1;
169 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
170 if (!strcmp(drv1->format_name, format_name))
171 return drv1;
172 }
173 return NULL;
174 }
175
176 int bdrv_create(BlockDriver *drv,
177 const char *filename, int64_t size_in_sectors,
178 const char *backing_file, int flags)
179 {
180 if (!drv->bdrv_create)
181 return -ENOTSUP;
182 return drv->bdrv_create(filename, size_in_sectors, backing_file, flags);
183 }
184
185 #ifdef _WIN32
186 void get_tmp_filename(char *filename, int size)
187 {
188 char temp_dir[MAX_PATH];
189
190 GetTempPath(MAX_PATH, temp_dir);
191 GetTempFileName(temp_dir, "qem", 0, filename);
192 }
193 #else
194 void get_tmp_filename(char *filename, int size)
195 {
196 int fd;
197 const char *tmpdir;
198 /* XXX: race condition possible */
199 tmpdir = getenv("TMPDIR");
200 if (!tmpdir)
201 tmpdir = "/tmp";
202 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
203 fd = mkstemp(filename);
204 close(fd);
205 }
206 #endif
207
208 #ifdef _WIN32
209 static int is_windows_drive_prefix(const char *filename)
210 {
211 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
212 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
213 filename[1] == ':');
214 }
215
216 static int is_windows_drive(const char *filename)
217 {
218 if (is_windows_drive_prefix(filename) &&
219 filename[2] == '\0')
220 return 1;
221 if (strstart(filename, "\\\\.\\", NULL) ||
222 strstart(filename, "//./", NULL))
223 return 1;
224 return 0;
225 }
226 #endif
227
228 static BlockDriver *find_protocol(const char *filename)
229 {
230 BlockDriver *drv1;
231 char protocol[128];
232 int len;
233 const char *p;
234
235 #ifdef _WIN32
236 if (is_windows_drive(filename) ||
237 is_windows_drive_prefix(filename))
238 return &bdrv_raw;
239 #endif
240 p = strchr(filename, ':');
241 if (!p)
242 return &bdrv_raw;
243 len = p - filename;
244 if (len > sizeof(protocol) - 1)
245 len = sizeof(protocol) - 1;
246 memcpy(protocol, filename, len);
247 protocol[len] = '\0';
248 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
249 if (drv1->protocol_name &&
250 !strcmp(drv1->protocol_name, protocol))
251 return drv1;
252 }
253 return NULL;
254 }
255
256 /* XXX: force raw format if block or character device ? It would
257 simplify the BSD case */
258 static BlockDriver *find_image_format(const char *filename)
259 {
260 int ret, score, score_max;
261 BlockDriver *drv1, *drv;
262 uint8_t buf[2048];
263 BlockDriverState *bs;
264
265 /* detect host devices. By convention, /dev/cdrom[N] is always
266 recognized as a host CDROM */
267 if (strstart(filename, "/dev/cdrom", NULL))
268 return &bdrv_host_device;
269 #ifdef _WIN32
270 if (is_windows_drive(filename))
271 return &bdrv_host_device;
272 #else
273 {
274 struct stat st;
275 if (stat(filename, &st) >= 0 &&
276 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
277 return &bdrv_host_device;
278 }
279 }
280 #endif
281
282 drv = find_protocol(filename);
283 /* no need to test disk image formats for vvfat */
284 if (drv == &bdrv_vvfat)
285 return drv;
286
287 ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);
288 if (ret < 0)
289 return NULL;
290 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
291 bdrv_delete(bs);
292 if (ret < 0) {
293 return NULL;
294 }
295
296 score_max = 0;
297 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {
298 if (drv1->bdrv_probe) {
299 score = drv1->bdrv_probe(buf, ret, filename);
300 if (score > score_max) {
301 score_max = score;
302 drv = drv1;
303 }
304 }
305 }
306 return drv;
307 }
308
309 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
310 {
311 BlockDriverState *bs;
312 int ret;
313
314 bs = bdrv_new("");
315 ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
316 if (ret < 0) {
317 bdrv_delete(bs);
318 return ret;
319 }
320 bs->growable = 1;
321 *pbs = bs;
322 return 0;
323 }
324
325 int bdrv_open(BlockDriverState *bs, const char *filename, int flags)
326 {
327 return bdrv_open2(bs, filename, flags, NULL);
328 }
329
330 int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
331 BlockDriver *drv)
332 {
333 int ret, open_flags;
334 char tmp_filename[PATH_MAX];
335 char backing_filename[PATH_MAX];
336
337 bs->read_only = 0;
338 bs->is_temporary = 0;
339 bs->encrypted = 0;
340 bs->valid_key = 0;
341
342 if (flags & BDRV_O_SNAPSHOT) {
343 BlockDriverState *bs1;
344 int64_t total_size;
345 int is_protocol = 0;
346
347 /* if snapshot, we create a temporary backing file and open it
348 instead of opening 'filename' directly */
349
350 /* if there is a backing file, use it */
351 bs1 = bdrv_new("");
352 ret = bdrv_open(bs1, filename, 0);
353 if (ret < 0) {
354 bdrv_delete(bs1);
355 return ret;
356 }
357 total_size = bdrv_getlength(bs1) >> SECTOR_BITS;
358
359 if (bs1->drv && bs1->drv->protocol_name)
360 is_protocol = 1;
361
362 bdrv_delete(bs1);
363
364 get_tmp_filename(tmp_filename, sizeof(tmp_filename));
365
366 /* Real path is meaningless for protocols */
367 if (is_protocol)
368 snprintf(backing_filename, sizeof(backing_filename),
369 "%s", filename);
370 else
371 realpath(filename, backing_filename);
372
373 ret = bdrv_create(&bdrv_qcow2, tmp_filename,
374 total_size, backing_filename, 0);
375 if (ret < 0) {
376 return ret;
377 }
378 filename = tmp_filename;
379 bs->is_temporary = 1;
380 }
381
382 pstrcpy(bs->filename, sizeof(bs->filename), filename);
383 if (flags & BDRV_O_FILE) {
384 drv = find_protocol(filename);
385 } else if (!drv) {
386 drv = find_image_format(filename);
387 }
388 if (!drv) {
389 ret = -ENOENT;
390 goto unlink_and_fail;
391 }
392 bs->drv = drv;
393 bs->opaque = qemu_mallocz(drv->instance_size);
394 /* Note: for compatibility, we open disk image files as RDWR, and
395 RDONLY as fallback */
396 if (!(flags & BDRV_O_FILE))
397 open_flags = BDRV_O_RDWR | (flags & BDRV_O_CACHE_MASK);
398 else
399 open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
400 ret = drv->bdrv_open(bs, filename, open_flags);
401 if ((ret == -EACCES || ret == -EPERM) && !(flags & BDRV_O_FILE)) {
402 ret = drv->bdrv_open(bs, filename, open_flags & ~BDRV_O_RDWR);
403 bs->read_only = 1;
404 }
405 if (ret < 0) {
406 qemu_free(bs->opaque);
407 bs->opaque = NULL;
408 bs->drv = NULL;
409 unlink_and_fail:
410 if (bs->is_temporary)
411 unlink(filename);
412 return ret;
413 }
414 if (drv->bdrv_getlength) {
415 bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
416 }
417 #ifndef _WIN32
418 if (bs->is_temporary) {
419 unlink(filename);
420 }
421 #endif
422 if (bs->backing_file[0] != '\0') {
423 /* if there is a backing file, use it */
424 bs->backing_hd = bdrv_new("");
425 path_combine(backing_filename, sizeof(backing_filename),
426 filename, bs->backing_file);
427 ret = bdrv_open(bs->backing_hd, backing_filename, open_flags);
428 if (ret < 0) {
429 bdrv_close(bs);
430 return ret;
431 }
432 }
433
434 /* call the change callback */
435 bs->media_changed = 1;
436 if (bs->change_cb)
437 bs->change_cb(bs->change_opaque);
438
439 return 0;
440 }
441
442 void bdrv_close(BlockDriverState *bs)
443 {
444 if (bs->drv) {
445 if (bs->backing_hd)
446 bdrv_delete(bs->backing_hd);
447 bs->drv->bdrv_close(bs);
448 qemu_free(bs->opaque);
449 #ifdef _WIN32
450 if (bs->is_temporary) {
451 unlink(bs->filename);
452 }
453 #endif
454 bs->opaque = NULL;
455 bs->drv = NULL;
456
457 /* call the change callback */
458 bs->media_changed = 1;
459 if (bs->change_cb)
460 bs->change_cb(bs->change_opaque);
461 }
462 }
463
464 void bdrv_delete(BlockDriverState *bs)
465 {
466 BlockDriverState **pbs;
467
468 pbs = &bdrv_first;
469 while (*pbs != bs && *pbs != NULL)
470 pbs = &(*pbs)->next;
471 if (*pbs == bs)
472 *pbs = bs->next;
473
474 bdrv_close(bs);
475 qemu_free(bs);
476 }
477
478 /* commit COW file into the raw image */
479 int bdrv_commit(BlockDriverState *bs)
480 {
481 BlockDriver *drv = bs->drv;
482 int64_t i, total_sectors;
483 int n, j;
484 unsigned char sector[512];
485
486 if (!drv)
487 return -ENOMEDIUM;
488
489 if (bs->read_only) {
490 return -EACCES;
491 }
492
493 if (!bs->backing_hd) {
494 return -ENOTSUP;
495 }
496
497 total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
498 for (i = 0; i < total_sectors;) {
499 if (drv->bdrv_is_allocated(bs, i, 65536, &n)) {
500 for(j = 0; j < n; j++) {
501 if (bdrv_read(bs, i, sector, 1) != 0) {
502 return -EIO;
503 }
504
505 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) {
506 return -EIO;
507 }
508 i++;
509 }
510 } else {
511 i += n;
512 }
513 }
514
515 if (drv->bdrv_make_empty)
516 return drv->bdrv_make_empty(bs);
517
518 return 0;
519 }
520
521 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
522 size_t size)
523 {
524 int64_t len;
525
526 if (!bdrv_is_inserted(bs))
527 return -ENOMEDIUM;
528
529 if (bs->growable)
530 return 0;
531
532 len = bdrv_getlength(bs);
533
534 if ((offset + size) > len)
535 return -EIO;
536
537 return 0;
538 }
539
540 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
541 int nb_sectors)
542 {
543 int64_t offset;
544
545 /* Deal with byte accesses */
546 if (sector_num < 0)
547 offset = -sector_num;
548 else
549 offset = sector_num * 512;
550
551 return bdrv_check_byte_request(bs, offset, nb_sectors * 512);
552 }
553
554 /* return < 0 if error. See bdrv_write() for the return codes */
555 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
556 uint8_t *buf, int nb_sectors)
557 {
558 BlockDriver *drv = bs->drv;
559
560 if (!drv)
561 return -ENOMEDIUM;
562 if (bdrv_check_request(bs, sector_num, nb_sectors))
563 return -EIO;
564
565 if (drv->bdrv_pread) {
566 int ret, len;
567 len = nb_sectors * 512;
568 ret = drv->bdrv_pread(bs, sector_num * 512, buf, len);
569 if (ret < 0)
570 return ret;
571 else if (ret != len)
572 return -EINVAL;
573 else {
574 bs->rd_bytes += (unsigned) len;
575 bs->rd_ops ++;
576 return 0;
577 }
578 } else {
579 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
580 }
581 }
582
583 /* Return < 0 if error. Important errors are:
584 -EIO generic I/O error (may happen for all errors)
585 -ENOMEDIUM No media inserted.
586 -EINVAL Invalid sector number or nb_sectors
587 -EACCES Trying to write a read-only device
588 */
589 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
590 const uint8_t *buf, int nb_sectors)
591 {
592 BlockDriver *drv = bs->drv;
593 if (!bs->drv)
594 return -ENOMEDIUM;
595 if (bs->read_only)
596 return -EACCES;
597 if (bdrv_check_request(bs, sector_num, nb_sectors))
598 return -EIO;
599
600 if (drv->bdrv_pwrite) {
601 int ret, len, count = 0;
602 len = nb_sectors * 512;
603 do {
604 ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len - count);
605 if (ret < 0) {
606 printf("bdrv_write ret=%d\n", ret);
607 return ret;
608 }
609 count += ret;
610 buf += ret;
611 } while (count != len);
612 bs->wr_bytes += (unsigned) len;
613 bs->wr_ops ++;
614 return 0;
615 }
616 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
617 }
618
619 static int bdrv_pread_em(BlockDriverState *bs, int64_t offset,
620 uint8_t *buf, int count1)
621 {
622 uint8_t tmp_buf[SECTOR_SIZE];
623 int len, nb_sectors, count;
624 int64_t sector_num;
625
626 count = count1;
627 /* first read to align to sector start */
628 len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
629 if (len > count)
630 len = count;
631 sector_num = offset >> SECTOR_BITS;
632 if (len > 0) {
633 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
634 return -EIO;
635 memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len);
636 count -= len;
637 if (count == 0)
638 return count1;
639 sector_num++;
640 buf += len;
641 }
642
643 /* read the sectors "in place" */
644 nb_sectors = count >> SECTOR_BITS;
645 if (nb_sectors > 0) {
646 if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0)
647 return -EIO;
648 sector_num += nb_sectors;
649 len = nb_sectors << SECTOR_BITS;
650 buf += len;
651 count -= len;
652 }
653
654 /* add data from the last sector */
655 if (count > 0) {
656 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
657 return -EIO;
658 memcpy(buf, tmp_buf, count);
659 }
660 return count1;
661 }
662
663 static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset,
664 const uint8_t *buf, int count1)
665 {
666 uint8_t tmp_buf[SECTOR_SIZE];
667 int len, nb_sectors, count;
668 int64_t sector_num;
669
670 count = count1;
671 /* first write to align to sector start */
672 len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1);
673 if (len > count)
674 len = count;
675 sector_num = offset >> SECTOR_BITS;
676 if (len > 0) {
677 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
678 return -EIO;
679 memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len);
680 if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
681 return -EIO;
682 count -= len;
683 if (count == 0)
684 return count1;
685 sector_num++;
686 buf += len;
687 }
688
689 /* write the sectors "in place" */
690 nb_sectors = count >> SECTOR_BITS;
691 if (nb_sectors > 0) {
692 if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0)
693 return -EIO;
694 sector_num += nb_sectors;
695 len = nb_sectors << SECTOR_BITS;
696 buf += len;
697 count -= len;
698 }
699
700 /* add data from the last sector */
701 if (count > 0) {
702 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0)
703 return -EIO;
704 memcpy(tmp_buf, buf, count);
705 if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0)
706 return -EIO;
707 }
708 return count1;
709 }
710
711 /**
712 * Read with byte offsets (needed only for file protocols)
713 */
714 int bdrv_pread(BlockDriverState *bs, int64_t offset,
715 void *buf1, int count1)
716 {
717 BlockDriver *drv = bs->drv;
718
719 if (!drv)
720 return -ENOMEDIUM;
721 if (bdrv_check_byte_request(bs, offset, count1))
722 return -EIO;
723
724 if (!drv->bdrv_pread)
725 return bdrv_pread_em(bs, offset, buf1, count1);
726 return drv->bdrv_pread(bs, offset, buf1, count1);
727 }
728
729 /**
730 * Write with byte offsets (needed only for file protocols)
731 */
732 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
733 const void *buf1, int count1)
734 {
735 BlockDriver *drv = bs->drv;
736
737 if (!drv)
738 return -ENOMEDIUM;
739 if (bdrv_check_byte_request(bs, offset, count1))
740 return -EIO;
741
742 if (!drv->bdrv_pwrite)
743 return bdrv_pwrite_em(bs, offset, buf1, count1);
744 return drv->bdrv_pwrite(bs, offset, buf1, count1);
745 }
746
747 /**
748 * Truncate file to 'offset' bytes (needed only for file protocols)
749 */
750 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
751 {
752 BlockDriver *drv = bs->drv;
753 if (!drv)
754 return -ENOMEDIUM;
755 if (!drv->bdrv_truncate)
756 return -ENOTSUP;
757 return drv->bdrv_truncate(bs, offset);
758 }
759
760 /**
761 * Length of a file in bytes. Return < 0 if error or unknown.
762 */
763 int64_t bdrv_getlength(BlockDriverState *bs)
764 {
765 BlockDriver *drv = bs->drv;
766 if (!drv)
767 return -ENOMEDIUM;
768 if (!drv->bdrv_getlength) {
769 /* legacy mode */
770 return bs->total_sectors * SECTOR_SIZE;
771 }
772 return drv->bdrv_getlength(bs);
773 }
774
775 /* return 0 as number of sectors if no device present or error */
776 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
777 {
778 int64_t length;
779 length = bdrv_getlength(bs);
780 if (length < 0)
781 length = 0;
782 else
783 length = length >> SECTOR_BITS;
784 *nb_sectors_ptr = length;
785 }
786
787 struct partition {
788 uint8_t boot_ind; /* 0x80 - active */
789 uint8_t head; /* starting head */
790 uint8_t sector; /* starting sector */
791 uint8_t cyl; /* starting cylinder */
792 uint8_t sys_ind; /* What partition type */
793 uint8_t end_head; /* end head */
794 uint8_t end_sector; /* end sector */
795 uint8_t end_cyl; /* end cylinder */
796 uint32_t start_sect; /* starting sector counting from 0 */
797 uint32_t nr_sects; /* nr of sectors in partition */
798 } __attribute__((packed));
799
800 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
801 static int guess_disk_lchs(BlockDriverState *bs,
802 int *pcylinders, int *pheads, int *psectors)
803 {
804 uint8_t buf[512];
805 int ret, i, heads, sectors, cylinders;
806 struct partition *p;
807 uint32_t nr_sects;
808 uint64_t nb_sectors;
809
810 bdrv_get_geometry(bs, &nb_sectors);
811
812 ret = bdrv_read(bs, 0, buf, 1);
813 if (ret < 0)
814 return -1;
815 /* test msdos magic */
816 if (buf[510] != 0x55 || buf[511] != 0xaa)
817 return -1;
818 for(i = 0; i < 4; i++) {
819 p = ((struct partition *)(buf + 0x1be)) + i;
820 nr_sects = le32_to_cpu(p->nr_sects);
821 if (nr_sects && p->end_head) {
822 /* We make the assumption that the partition terminates on
823 a cylinder boundary */
824 heads = p->end_head + 1;
825 sectors = p->end_sector & 63;
826 if (sectors == 0)
827 continue;
828 cylinders = nb_sectors / (heads * sectors);
829 if (cylinders < 1 || cylinders > 16383)
830 continue;
831 *pheads = heads;
832 *psectors = sectors;
833 *pcylinders = cylinders;
834 #if 0
835 printf("guessed geometry: LCHS=%d %d %d\n",
836 cylinders, heads, sectors);
837 #endif
838 return 0;
839 }
840 }
841 return -1;
842 }
843
844 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
845 {
846 int translation, lba_detected = 0;
847 int cylinders, heads, secs;
848 uint64_t nb_sectors;
849
850 /* if a geometry hint is available, use it */
851 bdrv_get_geometry(bs, &nb_sectors);
852 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
853 translation = bdrv_get_translation_hint(bs);
854 if (cylinders != 0) {
855 *pcyls = cylinders;
856 *pheads = heads;
857 *psecs = secs;
858 } else {
859 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
860 if (heads > 16) {
861 /* if heads > 16, it means that a BIOS LBA
862 translation was active, so the default
863 hardware geometry is OK */
864 lba_detected = 1;
865 goto default_geometry;
866 } else {
867 *pcyls = cylinders;
868 *pheads = heads;
869 *psecs = secs;
870 /* disable any translation to be in sync with
871 the logical geometry */
872 if (translation == BIOS_ATA_TRANSLATION_AUTO) {
873 bdrv_set_translation_hint(bs,
874 BIOS_ATA_TRANSLATION_NONE);
875 }
876 }
877 } else {
878 default_geometry:
879 /* if no geometry, use a standard physical disk geometry */
880 cylinders = nb_sectors / (16 * 63);
881
882 if (cylinders > 16383)
883 cylinders = 16383;
884 else if (cylinders < 2)
885 cylinders = 2;
886 *pcyls = cylinders;
887 *pheads = 16;
888 *psecs = 63;
889 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
890 if ((*pcyls * *pheads) <= 131072) {
891 bdrv_set_translation_hint(bs,
892 BIOS_ATA_TRANSLATION_LARGE);
893 } else {
894 bdrv_set_translation_hint(bs,
895 BIOS_ATA_TRANSLATION_LBA);
896 }
897 }
898 }
899 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
900 }
901 }
902
903 void bdrv_set_geometry_hint(BlockDriverState *bs,
904 int cyls, int heads, int secs)
905 {
906 bs->cyls = cyls;
907 bs->heads = heads;
908 bs->secs = secs;
909 }
910
911 void bdrv_set_type_hint(BlockDriverState *bs, int type)
912 {
913 bs->type = type;
914 bs->removable = ((type == BDRV_TYPE_CDROM ||
915 type == BDRV_TYPE_FLOPPY));
916 }
917
918 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
919 {
920 bs->translation = translation;
921 }
922
923 void bdrv_get_geometry_hint(BlockDriverState *bs,
924 int *pcyls, int *pheads, int *psecs)
925 {
926 *pcyls = bs->cyls;
927 *pheads = bs->heads;
928 *psecs = bs->secs;
929 }
930
931 int bdrv_get_type_hint(BlockDriverState *bs)
932 {
933 return bs->type;
934 }
935
936 int bdrv_get_translation_hint(BlockDriverState *bs)
937 {
938 return bs->translation;
939 }
940
941 int bdrv_is_removable(BlockDriverState *bs)
942 {
943 return bs->removable;
944 }
945
946 int bdrv_is_read_only(BlockDriverState *bs)
947 {
948 return bs->read_only;
949 }
950
951 int bdrv_is_sg(BlockDriverState *bs)
952 {
953 return bs->sg;
954 }
955
956 /* XXX: no longer used */
957 void bdrv_set_change_cb(BlockDriverState *bs,
958 void (*change_cb)(void *opaque), void *opaque)
959 {
960 bs->change_cb = change_cb;
961 bs->change_opaque = opaque;
962 }
963
964 int bdrv_is_encrypted(BlockDriverState *bs)
965 {
966 if (bs->backing_hd && bs->backing_hd->encrypted)
967 return 1;
968 return bs->encrypted;
969 }
970
971 int bdrv_key_required(BlockDriverState *bs)
972 {
973 BlockDriverState *backing_hd = bs->backing_hd;
974
975 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
976 return 1;
977 return (bs->encrypted && !bs->valid_key);
978 }
979
980 int bdrv_set_key(BlockDriverState *bs, const char *key)
981 {
982 int ret;
983 if (bs->backing_hd && bs->backing_hd->encrypted) {
984 ret = bdrv_set_key(bs->backing_hd, key);
985 if (ret < 0)
986 return ret;
987 if (!bs->encrypted)
988 return 0;
989 }
990 if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key)
991 return -1;
992 ret = bs->drv->bdrv_set_key(bs, key);
993 bs->valid_key = (ret == 0);
994 return ret;
995 }
996
997 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
998 {
999 if (!bs->drv) {
1000 buf[0] = '\0';
1001 } else {
1002 pstrcpy(buf, buf_size, bs->drv->format_name);
1003 }
1004 }
1005
1006 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1007 void *opaque)
1008 {
1009 BlockDriver *drv;
1010
1011 for (drv = first_drv; drv != NULL; drv = drv->next) {
1012 it(opaque, drv->format_name);
1013 }
1014 }
1015
1016 BlockDriverState *bdrv_find(const char *name)
1017 {
1018 BlockDriverState *bs;
1019
1020 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1021 if (!strcmp(name, bs->device_name))
1022 return bs;
1023 }
1024 return NULL;
1025 }
1026
1027 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1028 {
1029 BlockDriverState *bs;
1030
1031 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1032 it(opaque, bs);
1033 }
1034 }
1035
1036 const char *bdrv_get_device_name(BlockDriverState *bs)
1037 {
1038 return bs->device_name;
1039 }
1040
1041 void bdrv_flush(BlockDriverState *bs)
1042 {
1043 if (bs->drv->bdrv_flush)
1044 bs->drv->bdrv_flush(bs);
1045 if (bs->backing_hd)
1046 bdrv_flush(bs->backing_hd);
1047 }
1048
1049 void bdrv_flush_all(void)
1050 {
1051 BlockDriverState *bs;
1052
1053 for (bs = bdrv_first; bs != NULL; bs = bs->next)
1054 if (bs->drv && !bdrv_is_read_only(bs) &&
1055 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs)))
1056 bdrv_flush(bs);
1057 }
1058
1059 /*
1060 * Returns true iff the specified sector is present in the disk image. Drivers
1061 * not implementing the functionality are assumed to not support backing files,
1062 * hence all their sectors are reported as allocated.
1063 *
1064 * 'pnum' is set to the number of sectors (including and immediately following
1065 * the specified sector) that are known to be in the same
1066 * allocated/unallocated state.
1067 *
1068 * 'nb_sectors' is the max value 'pnum' should be set to.
1069 */
1070 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1071 int *pnum)
1072 {
1073 int64_t n;
1074 if (!bs->drv->bdrv_is_allocated) {
1075 if (sector_num >= bs->total_sectors) {
1076 *pnum = 0;
1077 return 0;
1078 }
1079 n = bs->total_sectors - sector_num;
1080 *pnum = (n < nb_sectors) ? (n) : (nb_sectors);
1081 return 1;
1082 }
1083 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1084 }
1085
1086 void bdrv_info(void)
1087 {
1088 BlockDriverState *bs;
1089
1090 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1091 term_printf("%s:", bs->device_name);
1092 term_printf(" type=");
1093 switch(bs->type) {
1094 case BDRV_TYPE_HD:
1095 term_printf("hd");
1096 break;
1097 case BDRV_TYPE_CDROM:
1098 term_printf("cdrom");
1099 break;
1100 case BDRV_TYPE_FLOPPY:
1101 term_printf("floppy");
1102 break;
1103 }
1104 term_printf(" removable=%d", bs->removable);
1105 if (bs->removable) {
1106 term_printf(" locked=%d", bs->locked);
1107 }
1108 if (bs->drv) {
1109 term_printf(" file=");
1110 term_print_filename(bs->filename);
1111 if (bs->backing_file[0] != '\0') {
1112 term_printf(" backing_file=");
1113 term_print_filename(bs->backing_file);
1114 }
1115 term_printf(" ro=%d", bs->read_only);
1116 term_printf(" drv=%s", bs->drv->format_name);
1117 term_printf(" encrypted=%d", bdrv_is_encrypted(bs));
1118 } else {
1119 term_printf(" [not inserted]");
1120 }
1121 term_printf("\n");
1122 }
1123 }
1124
1125 /* The "info blockstats" command. */
1126 void bdrv_info_stats (void)
1127 {
1128 BlockDriverState *bs;
1129
1130 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
1131 term_printf ("%s:"
1132 " rd_bytes=%" PRIu64
1133 " wr_bytes=%" PRIu64
1134 " rd_operations=%" PRIu64
1135 " wr_operations=%" PRIu64
1136 "\n",
1137 bs->device_name,
1138 bs->rd_bytes, bs->wr_bytes,
1139 bs->rd_ops, bs->wr_ops);
1140 }
1141 }
1142
1143 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1144 {
1145 if (bs->backing_hd && bs->backing_hd->encrypted)
1146 return bs->backing_file;
1147 else if (bs->encrypted)
1148 return bs->filename;
1149 else
1150 return NULL;
1151 }
1152
1153 void bdrv_get_backing_filename(BlockDriverState *bs,
1154 char *filename, int filename_size)
1155 {
1156 if (!bs->backing_hd) {
1157 pstrcpy(filename, filename_size, "");
1158 } else {
1159 pstrcpy(filename, filename_size, bs->backing_file);
1160 }
1161 }
1162
1163 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1164 const uint8_t *buf, int nb_sectors)
1165 {
1166 BlockDriver *drv = bs->drv;
1167 if (!drv)
1168 return -ENOMEDIUM;
1169 if (!drv->bdrv_write_compressed)
1170 return -ENOTSUP;
1171 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1172 }
1173
1174 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1175 {
1176 BlockDriver *drv = bs->drv;
1177 if (!drv)
1178 return -ENOMEDIUM;
1179 if (!drv->bdrv_get_info)
1180 return -ENOTSUP;
1181 memset(bdi, 0, sizeof(*bdi));
1182 return drv->bdrv_get_info(bs, bdi);
1183 }
1184
1185 int bdrv_put_buffer(BlockDriverState *bs, const uint8_t *buf, int64_t pos, int size)
1186 {
1187 BlockDriver *drv = bs->drv;
1188 if (!drv)
1189 return -ENOMEDIUM;
1190 if (!drv->bdrv_put_buffer)
1191 return -ENOTSUP;
1192 return drv->bdrv_put_buffer(bs, buf, pos, size);
1193 }
1194
1195 int bdrv_get_buffer(BlockDriverState *bs, uint8_t *buf, int64_t pos, int size)
1196 {
1197 BlockDriver *drv = bs->drv;
1198 if (!drv)
1199 return -ENOMEDIUM;
1200 if (!drv->bdrv_get_buffer)
1201 return -ENOTSUP;
1202 return drv->bdrv_get_buffer(bs, buf, pos, size);
1203 }
1204
1205 /**************************************************************/
1206 /* handling of snapshots */
1207
1208 int bdrv_snapshot_create(BlockDriverState *bs,
1209 QEMUSnapshotInfo *sn_info)
1210 {
1211 BlockDriver *drv = bs->drv;
1212 if (!drv)
1213 return -ENOMEDIUM;
1214 if (!drv->bdrv_snapshot_create)
1215 return -ENOTSUP;
1216 return drv->bdrv_snapshot_create(bs, sn_info);
1217 }
1218
1219 int bdrv_snapshot_goto(BlockDriverState *bs,
1220 const char *snapshot_id)
1221 {
1222 BlockDriver *drv = bs->drv;
1223 if (!drv)
1224 return -ENOMEDIUM;
1225 if (!drv->bdrv_snapshot_goto)
1226 return -ENOTSUP;
1227 return drv->bdrv_snapshot_goto(bs, snapshot_id);
1228 }
1229
1230 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1231 {
1232 BlockDriver *drv = bs->drv;
1233 if (!drv)
1234 return -ENOMEDIUM;
1235 if (!drv->bdrv_snapshot_delete)
1236 return -ENOTSUP;
1237 return drv->bdrv_snapshot_delete(bs, snapshot_id);
1238 }
1239
1240 int bdrv_snapshot_list(BlockDriverState *bs,
1241 QEMUSnapshotInfo **psn_info)
1242 {
1243 BlockDriver *drv = bs->drv;
1244 if (!drv)
1245 return -ENOMEDIUM;
1246 if (!drv->bdrv_snapshot_list)
1247 return -ENOTSUP;
1248 return drv->bdrv_snapshot_list(bs, psn_info);
1249 }
1250
1251 #define NB_SUFFIXES 4
1252
1253 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
1254 {
1255 static const char suffixes[NB_SUFFIXES] = "KMGT";
1256 int64_t base;
1257 int i;
1258
1259 if (size <= 999) {
1260 snprintf(buf, buf_size, "%" PRId64, size);
1261 } else {
1262 base = 1024;
1263 for(i = 0; i < NB_SUFFIXES; i++) {
1264 if (size < (10 * base)) {
1265 snprintf(buf, buf_size, "%0.1f%c",
1266 (double)size / base,
1267 suffixes[i]);
1268 break;
1269 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1270 snprintf(buf, buf_size, "%" PRId64 "%c",
1271 ((size + (base >> 1)) / base),
1272 suffixes[i]);
1273 break;
1274 }
1275 base = base * 1024;
1276 }
1277 }
1278 return buf;
1279 }
1280
1281 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
1282 {
1283 char buf1[128], date_buf[128], clock_buf[128];
1284 #ifdef _WIN32
1285 struct tm *ptm;
1286 #else
1287 struct tm tm;
1288 #endif
1289 time_t ti;
1290 int64_t secs;
1291
1292 if (!sn) {
1293 snprintf(buf, buf_size,
1294 "%-10s%-20s%7s%20s%15s",
1295 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
1296 } else {
1297 ti = sn->date_sec;
1298 #ifdef _WIN32
1299 ptm = localtime(&ti);
1300 strftime(date_buf, sizeof(date_buf),
1301 "%Y-%m-%d %H:%M:%S", ptm);
1302 #else
1303 localtime_r(&ti, &tm);
1304 strftime(date_buf, sizeof(date_buf),
1305 "%Y-%m-%d %H:%M:%S", &tm);
1306 #endif
1307 secs = sn->vm_clock_nsec / 1000000000;
1308 snprintf(clock_buf, sizeof(clock_buf),
1309 "%02d:%02d:%02d.%03d",
1310 (int)(secs / 3600),
1311 (int)((secs / 60) % 60),
1312 (int)(secs % 60),
1313 (int)((sn->vm_clock_nsec / 1000000) % 1000));
1314 snprintf(buf, buf_size,
1315 "%-10s%-20s%7s%20s%15s",
1316 sn->id_str, sn->name,
1317 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
1318 date_buf,
1319 clock_buf);
1320 }
1321 return buf;
1322 }
1323
1324
1325 /**************************************************************/
1326 /* async I/Os */
1327
1328 typedef struct VectorTranslationState {
1329 QEMUIOVector *iov;
1330 uint8_t *bounce;
1331 int is_write;
1332 BlockDriverAIOCB *aiocb;
1333 BlockDriverAIOCB *this_aiocb;
1334 } VectorTranslationState;
1335
1336 static void bdrv_aio_rw_vector_cb(void *opaque, int ret)
1337 {
1338 VectorTranslationState *s = opaque;
1339
1340 if (!s->is_write) {
1341 qemu_iovec_from_buffer(s->iov, s->bounce, s->iov->size);
1342 }
1343 qemu_vfree(s->bounce);
1344 s->this_aiocb->cb(s->this_aiocb->opaque, ret);
1345 qemu_aio_release(s->this_aiocb);
1346 }
1347
1348 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
1349 int64_t sector_num,
1350 QEMUIOVector *iov,
1351 int nb_sectors,
1352 BlockDriverCompletionFunc *cb,
1353 void *opaque,
1354 int is_write)
1355
1356 {
1357 VectorTranslationState *s = qemu_mallocz(sizeof(*s));
1358 BlockDriverAIOCB *aiocb = qemu_aio_get(bs, cb, opaque);
1359
1360 s->this_aiocb = aiocb;
1361 s->iov = iov;
1362 s->bounce = qemu_memalign(512, nb_sectors * 512);
1363 s->is_write = is_write;
1364 if (is_write) {
1365 qemu_iovec_to_buffer(s->iov, s->bounce);
1366 s->aiocb = bdrv_aio_write(bs, sector_num, s->bounce, nb_sectors,
1367 bdrv_aio_rw_vector_cb, s);
1368 } else {
1369 s->aiocb = bdrv_aio_read(bs, sector_num, s->bounce, nb_sectors,
1370 bdrv_aio_rw_vector_cb, s);
1371 }
1372 return aiocb;
1373 }
1374
1375 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1376 QEMUIOVector *iov, int nb_sectors,
1377 BlockDriverCompletionFunc *cb, void *opaque)
1378 {
1379 if (bdrv_check_request(bs, sector_num, nb_sectors))
1380 return NULL;
1381
1382 return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
1383 cb, opaque, 0);
1384 }
1385
1386 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
1387 QEMUIOVector *iov, int nb_sectors,
1388 BlockDriverCompletionFunc *cb, void *opaque)
1389 {
1390 if (bdrv_check_request(bs, sector_num, nb_sectors))
1391 return NULL;
1392
1393 return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
1394 cb, opaque, 1);
1395 }
1396
1397 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
1398 uint8_t *buf, int nb_sectors,
1399 BlockDriverCompletionFunc *cb, void *opaque)
1400 {
1401 BlockDriver *drv = bs->drv;
1402 BlockDriverAIOCB *ret;
1403
1404 if (!drv)
1405 return NULL;
1406 if (bdrv_check_request(bs, sector_num, nb_sectors))
1407 return NULL;
1408
1409 ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque);
1410
1411 if (ret) {
1412 /* Update stats even though technically transfer has not happened. */
1413 bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1414 bs->rd_ops ++;
1415 }
1416
1417 return ret;
1418 }
1419
1420 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
1421 const uint8_t *buf, int nb_sectors,
1422 BlockDriverCompletionFunc *cb, void *opaque)
1423 {
1424 BlockDriver *drv = bs->drv;
1425 BlockDriverAIOCB *ret;
1426
1427 if (!drv)
1428 return NULL;
1429 if (bs->read_only)
1430 return NULL;
1431 if (bdrv_check_request(bs, sector_num, nb_sectors))
1432 return NULL;
1433
1434 ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);
1435
1436 if (ret) {
1437 /* Update stats even though technically transfer has not happened. */
1438 bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE;
1439 bs->wr_ops ++;
1440 }
1441
1442 return ret;
1443 }
1444
1445 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1446 {
1447 if (acb->cb == bdrv_aio_rw_vector_cb) {
1448 VectorTranslationState *s = acb->opaque;
1449 acb = s->aiocb;
1450 }
1451
1452 acb->pool->cancel(acb);
1453 }
1454
1455
1456 /**************************************************************/
1457 /* async block device emulation */
1458
1459 static void bdrv_aio_bh_cb(void *opaque)
1460 {
1461 BlockDriverAIOCBSync *acb = opaque;
1462 acb->common.cb(acb->common.opaque, acb->ret);
1463 qemu_aio_release(acb);
1464 }
1465
1466 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
1467 int64_t sector_num, uint8_t *buf, int nb_sectors,
1468 BlockDriverCompletionFunc *cb, void *opaque)
1469 {
1470 BlockDriverAIOCBSync *acb;
1471 int ret;
1472
1473 acb = qemu_aio_get(bs, cb, opaque);
1474 if (!acb->bh)
1475 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1476 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
1477 acb->ret = ret;
1478 qemu_bh_schedule(acb->bh);
1479 return &acb->common;
1480 }
1481
1482 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs,
1483 int64_t sector_num, const uint8_t *buf, int nb_sectors,
1484 BlockDriverCompletionFunc *cb, void *opaque)
1485 {
1486 BlockDriverAIOCBSync *acb;
1487 int ret;
1488
1489 acb = qemu_aio_get(bs, cb, opaque);
1490 if (!acb->bh)
1491 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1492 ret = bdrv_write(bs, sector_num, buf, nb_sectors);
1493 acb->ret = ret;
1494 qemu_bh_schedule(acb->bh);
1495 return &acb->common;
1496 }
1497
1498 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
1499 {
1500 BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb;
1501 qemu_bh_cancel(acb->bh);
1502 qemu_aio_release(acb);
1503 }
1504
1505 /**************************************************************/
1506 /* sync block device emulation */
1507
1508 static void bdrv_rw_em_cb(void *opaque, int ret)
1509 {
1510 *(int *)opaque = ret;
1511 }
1512
1513 #define NOT_DONE 0x7fffffff
1514
1515 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
1516 uint8_t *buf, int nb_sectors)
1517 {
1518 int async_ret;
1519 BlockDriverAIOCB *acb;
1520
1521 async_ret = NOT_DONE;
1522 acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors,
1523 bdrv_rw_em_cb, &async_ret);
1524 if (acb == NULL)
1525 return -1;
1526
1527 while (async_ret == NOT_DONE) {
1528 qemu_aio_wait();
1529 }
1530
1531 return async_ret;
1532 }
1533
1534 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
1535 const uint8_t *buf, int nb_sectors)
1536 {
1537 int async_ret;
1538 BlockDriverAIOCB *acb;
1539
1540 async_ret = NOT_DONE;
1541 acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors,
1542 bdrv_rw_em_cb, &async_ret);
1543 if (acb == NULL)
1544 return -1;
1545 while (async_ret == NOT_DONE) {
1546 qemu_aio_wait();
1547 }
1548 return async_ret;
1549 }
1550
1551 void bdrv_init(void)
1552 {
1553 bdrv_register(&bdrv_raw);
1554 bdrv_register(&bdrv_host_device);
1555 #ifndef _WIN32
1556 bdrv_register(&bdrv_cow);
1557 #endif
1558 bdrv_register(&bdrv_qcow);
1559 bdrv_register(&bdrv_vmdk);
1560 bdrv_register(&bdrv_cloop);
1561 bdrv_register(&bdrv_dmg);
1562 bdrv_register(&bdrv_bochs);
1563 bdrv_register(&bdrv_vpc);
1564 bdrv_register(&bdrv_vvfat);
1565 bdrv_register(&bdrv_qcow2);
1566 bdrv_register(&bdrv_parallels);
1567 bdrv_register(&bdrv_nbd);
1568 }
1569
1570 void aio_pool_init(AIOPool *pool, int aiocb_size,
1571 void (*cancel)(BlockDriverAIOCB *acb))
1572 {
1573 pool->aiocb_size = aiocb_size;
1574 pool->cancel = cancel;
1575 pool->free_aiocb = NULL;
1576 }
1577
1578 void *qemu_aio_get_pool(AIOPool *pool, BlockDriverState *bs,
1579 BlockDriverCompletionFunc *cb, void *opaque)
1580 {
1581 BlockDriverAIOCB *acb;
1582
1583 if (pool->free_aiocb) {
1584 acb = pool->free_aiocb;
1585 pool->free_aiocb = acb->next;
1586 } else {
1587 acb = qemu_mallocz(pool->aiocb_size);
1588 acb->pool = pool;
1589 }
1590 acb->bs = bs;
1591 acb->cb = cb;
1592 acb->opaque = opaque;
1593 return acb;
1594 }
1595
1596 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb,
1597 void *opaque)
1598 {
1599 return qemu_aio_get_pool(&bs->drv->aio_pool, bs, cb, opaque);
1600 }
1601
1602 void qemu_aio_release(void *p)
1603 {
1604 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
1605 AIOPool *pool = acb->pool;
1606 acb->next = pool->free_aiocb;
1607 pool->free_aiocb = acb;
1608 }
1609
1610 /**************************************************************/
1611 /* removable device support */
1612
1613 /**
1614 * Return TRUE if the media is present
1615 */
1616 int bdrv_is_inserted(BlockDriverState *bs)
1617 {
1618 BlockDriver *drv = bs->drv;
1619 int ret;
1620 if (!drv)
1621 return 0;
1622 if (!drv->bdrv_is_inserted)
1623 return 1;
1624 ret = drv->bdrv_is_inserted(bs);
1625 return ret;
1626 }
1627
1628 /**
1629 * Return TRUE if the media changed since the last call to this
1630 * function. It is currently only used for floppy disks
1631 */
1632 int bdrv_media_changed(BlockDriverState *bs)
1633 {
1634 BlockDriver *drv = bs->drv;
1635 int ret;
1636
1637 if (!drv || !drv->bdrv_media_changed)
1638 ret = -ENOTSUP;
1639 else
1640 ret = drv->bdrv_media_changed(bs);
1641 if (ret == -ENOTSUP)
1642 ret = bs->media_changed;
1643 bs->media_changed = 0;
1644 return ret;
1645 }
1646
1647 /**
1648 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
1649 */
1650 void bdrv_eject(BlockDriverState *bs, int eject_flag)
1651 {
1652 BlockDriver *drv = bs->drv;
1653 int ret;
1654
1655 if (!drv || !drv->bdrv_eject) {
1656 ret = -ENOTSUP;
1657 } else {
1658 ret = drv->bdrv_eject(bs, eject_flag);
1659 }
1660 if (ret == -ENOTSUP) {
1661 if (eject_flag)
1662 bdrv_close(bs);
1663 }
1664 }
1665
1666 int bdrv_is_locked(BlockDriverState *bs)
1667 {
1668 return bs->locked;
1669 }
1670
1671 /**
1672 * Lock or unlock the media (if it is locked, the user won't be able
1673 * to eject it manually).
1674 */
1675 void bdrv_set_locked(BlockDriverState *bs, int locked)
1676 {
1677 BlockDriver *drv = bs->drv;
1678
1679 bs->locked = locked;
1680 if (drv && drv->bdrv_set_locked) {
1681 drv->bdrv_set_locked(bs, locked);
1682 }
1683 }
1684
1685 /* needed for generic scsi interface */
1686
1687 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1688 {
1689 BlockDriver *drv = bs->drv;
1690
1691 if (drv && drv->bdrv_ioctl)
1692 return drv->bdrv_ioctl(bs, req, buf);
1693 return -ENOTSUP;
1694 }
Patches shipped by Fedora