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 "qemu-common.h" 25 #ifndef QEMU_IMG 26 #include "console.h" 27 #endif 28 #include "block_int.h" 29 30 #ifdef _BSD 31 #include <sys/types.h> 32 #include <sys/stat.h> 33 #include <sys/ioctl.h> 34 #include <sys/queue.h> 35 #include <sys/disk.h> 36 #endif 37 38 #define SECTOR_BITS 9 39 #define SECTOR_SIZE (1 << SECTOR_BITS) 40 41 typedef struct BlockDriverAIOCBSync { 42 BlockDriverAIOCB common; 43 QEMUBH *bh; 44 int ret; 45 } BlockDriverAIOCBSync; 46 47 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs, 48 int64_t sector_num, uint8_t *buf, int nb_sectors, 49 BlockDriverCompletionFunc *cb, void *opaque); 50 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs, 51 int64_t sector_num, const uint8_t *buf, int nb_sectors, 52 BlockDriverCompletionFunc *cb, void *opaque); 53 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb); 54 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 55 uint8_t *buf, int nb_sectors); 56 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num, 57 const uint8_t *buf, int nb_sectors); 58 59 BlockDriverState *bdrv_first; 60 static BlockDriver *first_drv; 61 62 int path_is_absolute(const char *path) 63 { 64 const char *p; 65 #ifdef _WIN32 66 /* specific case for names like: "\\.\d:" */ 67 if (*path == '/' || *path == '\\') 68 return 1; 69 #endif 70 p = strchr(path, ':'); 71 if (p) 72 p++; 73 else 74 p = path; 75 #ifdef _WIN32 76 return (*p == '/' || *p == '\\'); 77 #else 78 return (*p == '/'); 79 #endif 80 } 81 82 /* if filename is absolute, just copy it to dest. Otherwise, build a 83 path to it by considering it is relative to base_path. URL are 84 supported. */ 85 void path_combine(char *dest, int dest_size, 86 const char *base_path, 87 const char *filename) 88 { 89 const char *p, *p1; 90 int len; 91 92 if (dest_size <= 0) 93 return; 94 if (path_is_absolute(filename)) { 95 pstrcpy(dest, dest_size, filename); 96 } else { 97 p = strchr(base_path, ':'); 98 if (p) 99 p++; 100 else 101 p = base_path; 102 p1 = strrchr(base_path, '/'); 103 #ifdef _WIN32 104 { 105 const char *p2; 106 p2 = strrchr(base_path, '\\'); 107 if (!p1 || p2 > p1) 108 p1 = p2; 109 } 110 #endif 111 if (p1) 112 p1++; 113 else 114 p1 = base_path; 115 if (p1 > p) 116 p = p1; 117 len = p - base_path; 118 if (len > dest_size - 1) 119 len = dest_size - 1; 120 memcpy(dest, base_path, len); 121 dest[len] = '\0'; 122 pstrcat(dest, dest_size, filename); 123 } 124 } 125 126 127 static void bdrv_register(BlockDriver *bdrv) 128 { 129 if (!bdrv->bdrv_aio_read) { 130 /* add AIO emulation layer */ 131 bdrv->bdrv_aio_read = bdrv_aio_read_em; 132 bdrv->bdrv_aio_write = bdrv_aio_write_em; 133 bdrv->bdrv_aio_cancel = bdrv_aio_cancel_em; 134 bdrv->aiocb_size = sizeof(BlockDriverAIOCBSync); 135 } else if (!bdrv->bdrv_read && !bdrv->bdrv_pread) { 136 /* add synchronous IO emulation layer */ 137 bdrv->bdrv_read = bdrv_read_em; 138 bdrv->bdrv_write = bdrv_write_em; 139 } 140 bdrv->next = first_drv; 141 first_drv = bdrv; 142 } 143 144 /* create a new block device (by default it is empty) */ 145 BlockDriverState *bdrv_new(const char *device_name) 146 { 147 BlockDriverState **pbs, *bs; 148 149 bs = qemu_mallocz(sizeof(BlockDriverState)); 150 if(!bs) 151 return NULL; 152 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); 153 if (device_name[0] != '\0') { 154 /* insert at the end */ 155 pbs = &bdrv_first; 156 while (*pbs != NULL) 157 pbs = &(*pbs)->next; 158 *pbs = bs; 159 } 160 return bs; 161 } 162 163 BlockDriver *bdrv_find_format(const char *format_name) 164 { 165 BlockDriver *drv1; 166 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) { 167 if (!strcmp(drv1->format_name, format_name)) 168 return drv1; 169 } 170 return NULL; 171 } 172 173 int bdrv_create(BlockDriver *drv, 174 const char *filename, int64_t size_in_sectors, 175 const char *backing_file, int flags) 176 { 177 if (!drv->bdrv_create) 178 return -ENOTSUP; 179 return drv->bdrv_create(filename, size_in_sectors, backing_file, flags); 180 } 181 182 #ifdef _WIN32 183 void get_tmp_filename(char *filename, int size) 184 { 185 char temp_dir[MAX_PATH]; 186 187 GetTempPath(MAX_PATH, temp_dir); 188 GetTempFileName(temp_dir, "qem", 0, filename); 189 } 190 #else 191 void get_tmp_filename(char *filename, int size) 192 { 193 int fd; 194 /* XXX: race condition possible */ 195 pstrcpy(filename, size, "/tmp/vl.XXXXXX"); 196 fd = mkstemp(filename); 197 close(fd); 198 } 199 #endif 200 201 #ifdef _WIN32 202 static int is_windows_drive_prefix(const char *filename) 203 { 204 return (((filename[0] >= 'a' && filename[0] <= 'z') || 205 (filename[0] >= 'A' && filename[0] <= 'Z')) && 206 filename[1] == ':'); 207 } 208 209 static int is_windows_drive(const char *filename) 210 { 211 if (is_windows_drive_prefix(filename) && 212 filename[2] == '\0') 213 return 1; 214 if (strstart(filename, "\\\\.\\", NULL) || 215 strstart(filename, "//./", NULL)) 216 return 1; 217 return 0; 218 } 219 #endif 220 221 static BlockDriver *find_protocol(const char *filename) 222 { 223 BlockDriver *drv1; 224 char protocol[128]; 225 int len; 226 const char *p; 227 228 #ifdef _WIN32 229 if (is_windows_drive(filename) || 230 is_windows_drive_prefix(filename)) 231 return &bdrv_raw; 232 #endif 233 p = strchr(filename, ':'); 234 if (!p) 235 return &bdrv_raw; 236 len = p - filename; 237 if (len > sizeof(protocol) - 1) 238 len = sizeof(protocol) - 1; 239 memcpy(protocol, filename, len); 240 protocol[len] = '\0'; 241 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) { 242 if (drv1->protocol_name && 243 !strcmp(drv1->protocol_name, protocol)) 244 return drv1; 245 } 246 return NULL; 247 } 248 249 /* XXX: force raw format if block or character device ? It would 250 simplify the BSD case */ 251 static BlockDriver *find_image_format(const char *filename) 252 { 253 int ret, score, score_max; 254 BlockDriver *drv1, *drv; 255 uint8_t buf[2048]; 256 BlockDriverState *bs; 257 258 /* detect host devices. By convention, /dev/cdrom[N] is always 259 recognized as a host CDROM */ 260 if (strstart(filename, "/dev/cdrom", NULL)) 261 return &bdrv_host_device; 262 #ifdef _WIN32 263 if (is_windows_drive(filename)) 264 return &bdrv_host_device; 265 #else 266 { 267 struct stat st; 268 if (stat(filename, &st) >= 0 && 269 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) { 270 return &bdrv_host_device; 271 } 272 } 273 #endif 274 275 drv = find_protocol(filename); 276 /* no need to test disk image formats for vvfat */ 277 if (drv == &bdrv_vvfat) 278 return drv; 279 280 ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY); 281 if (ret < 0) 282 return NULL; 283 ret = bdrv_pread(bs, 0, buf, sizeof(buf)); 284 bdrv_delete(bs); 285 if (ret < 0) { 286 return NULL; 287 } 288 289 score_max = 0; 290 for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) { 291 if (drv1->bdrv_probe) { 292 score = drv1->bdrv_probe(buf, ret, filename); 293 if (score > score_max) { 294 score_max = score; 295 drv = drv1; 296 } 297 } 298 } 299 return drv; 300 } 301 302 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags) 303 { 304 BlockDriverState *bs; 305 int ret; 306 307 bs = bdrv_new(""); 308 if (!bs) 309 return -ENOMEM; 310 ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL); 311 if (ret < 0) { 312 bdrv_delete(bs); 313 return ret; 314 } 315 *pbs = bs; 316 return 0; 317 } 318 319 int bdrv_open(BlockDriverState *bs, const char *filename, int flags) 320 { 321 return bdrv_open2(bs, filename, flags, NULL); 322 } 323 324 int bdrv_open2(BlockDriverState *bs, const char *filename, int flags, 325 BlockDriver *drv) 326 { 327 int ret, open_flags; 328 char tmp_filename[PATH_MAX]; 329 char backing_filename[PATH_MAX]; 330 331 bs->read_only = 0; 332 bs->is_temporary = 0; 333 bs->encrypted = 0; 334 335 if (flags & BDRV_O_SNAPSHOT) { 336 BlockDriverState *bs1; 337 int64_t total_size; 338 339 /* if snapshot, we create a temporary backing file and open it 340 instead of opening 'filename' directly */ 341 342 /* if there is a backing file, use it */ 343 bs1 = bdrv_new(""); 344 if (!bs1) { 345 return -ENOMEM; 346 } 347 if (bdrv_open(bs1, filename, 0) < 0) { 348 bdrv_delete(bs1); 349 return -1; 350 } 351 total_size = bdrv_getlength(bs1) >> SECTOR_BITS; 352 bdrv_delete(bs1); 353 354 get_tmp_filename(tmp_filename, sizeof(tmp_filename)); 355 realpath(filename, backing_filename); 356 if (bdrv_create(&bdrv_qcow2, tmp_filename, 357 total_size, backing_filename, 0) < 0) { 358 return -1; 359 } 360 filename = tmp_filename; 361 bs->is_temporary = 1; 362 } 363 364 pstrcpy(bs->filename, sizeof(bs->filename), filename); 365 if (flags & BDRV_O_FILE) { 366 drv = find_protocol(filename); 367 if (!drv) 368 return -ENOENT; 369 } else { 370 if (!drv) { 371 drv = find_image_format(filename); 372 if (!drv) 373 return -1; 374 } 375 } 376 bs->drv = drv; 377 bs->opaque = qemu_mallocz(drv->instance_size); 378 if (bs->opaque == NULL && drv->instance_size > 0) 379 return -1; 380 /* Note: for compatibility, we open disk image files as RDWR, and 381 RDONLY as fallback */ 382 if (!(flags & BDRV_O_FILE)) 383 open_flags = BDRV_O_RDWR; 384 else 385 open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT); 386 ret = drv->bdrv_open(bs, filename, open_flags); 387 if (ret == -EACCES && !(flags & BDRV_O_FILE)) { 388 ret = drv->bdrv_open(bs, filename, BDRV_O_RDONLY); 389 bs->read_only = 1; 390 } 391 if (ret < 0) { 392 qemu_free(bs->opaque); 393 bs->opaque = NULL; 394 bs->drv = NULL; 395 return ret; 396 } 397 if (drv->bdrv_getlength) { 398 bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS; 399 } 400 #ifndef _WIN32 401 if (bs->is_temporary) { 402 unlink(filename); 403 } 404 #endif 405 if (bs->backing_file[0] != '\0') { 406 /* if there is a backing file, use it */ 407 bs->backing_hd = bdrv_new(""); 408 if (!bs->backing_hd) { 409 fail: 410 bdrv_close(bs); 411 return -ENOMEM; 412 } 413 path_combine(backing_filename, sizeof(backing_filename), 414 filename, bs->backing_file); 415 if (bdrv_open(bs->backing_hd, backing_filename, 0) < 0) 416 goto fail; 417 } 418 419 /* call the change callback */ 420 bs->media_changed = 1; 421 if (bs->change_cb) 422 bs->change_cb(bs->change_opaque); 423 424 return 0; 425 } 426 427 void bdrv_close(BlockDriverState *bs) 428 { 429 if (bs->drv) { 430 if (bs->backing_hd) 431 bdrv_delete(bs->backing_hd); 432 bs->drv->bdrv_close(bs); 433 qemu_free(bs->opaque); 434 #ifdef _WIN32 435 if (bs->is_temporary) { 436 unlink(bs->filename); 437 } 438 #endif 439 bs->opaque = NULL; 440 bs->drv = NULL; 441 442 /* call the change callback */ 443 bs->media_changed = 1; 444 if (bs->change_cb) 445 bs->change_cb(bs->change_opaque); 446 } 447 } 448 449 void bdrv_delete(BlockDriverState *bs) 450 { 451 /* XXX: remove the driver list */ 452 bdrv_close(bs); 453 qemu_free(bs); 454 } 455 456 /* commit COW file into the raw image */ 457 int bdrv_commit(BlockDriverState *bs) 458 { 459 BlockDriver *drv = bs->drv; 460 int64_t i, total_sectors; 461 int n, j; 462 unsigned char sector[512]; 463 464 if (!drv) 465 return -ENOMEDIUM; 466 467 if (bs->read_only) { 468 return -EACCES; 469 } 470 471 if (!bs->backing_hd) { 472 return -ENOTSUP; 473 } 474 475 total_sectors = bdrv_getlength(bs) >> SECTOR_BITS; 476 for (i = 0; i < total_sectors;) { 477 if (drv->bdrv_is_allocated(bs, i, 65536, &n)) { 478 for(j = 0; j < n; j++) { 479 if (bdrv_read(bs, i, sector, 1) != 0) { 480 return -EIO; 481 } 482 483 if (bdrv_write(bs->backing_hd, i, sector, 1) != 0) { 484 return -EIO; 485 } 486 i++; 487 } 488 } else { 489 i += n; 490 } 491 } 492 493 if (drv->bdrv_make_empty) 494 return drv->bdrv_make_empty(bs); 495 496 return 0; 497 } 498 499 /* return < 0 if error. See bdrv_write() for the return codes */ 500 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 501 uint8_t *buf, int nb_sectors) 502 { 503 BlockDriver *drv = bs->drv; 504 505 if (!drv) 506 return -ENOMEDIUM; 507 508 if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { 509 memcpy(buf, bs->boot_sector_data, 512); 510 sector_num++; 511 nb_sectors--; 512 buf += 512; 513 if (nb_sectors == 0) 514 return 0; 515 } 516 if (drv->bdrv_pread) { 517 int ret, len; 518 len = nb_sectors * 512; 519 ret = drv->bdrv_pread(bs, sector_num * 512, buf, len); 520 if (ret < 0) 521 return ret; 522 else if (ret != len) 523 return -EINVAL; 524 else { 525 bs->rd_bytes += (unsigned) len; 526 bs->rd_ops ++; 527 return 0; 528 } 529 } else { 530 return drv->bdrv_read(bs, sector_num, buf, nb_sectors); 531 } 532 } 533 534 /* Return < 0 if error. Important errors are: 535 -EIO generic I/O error (may happen for all errors) 536 -ENOMEDIUM No media inserted. 537 -EINVAL Invalid sector number or nb_sectors 538 -EACCES Trying to write a read-only device 539 */ 540 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 541 const uint8_t *buf, int nb_sectors) 542 { 543 BlockDriver *drv = bs->drv; 544 if (!bs->drv) 545 return -ENOMEDIUM; 546 if (bs->read_only) 547 return -EACCES; 548 if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { 549 memcpy(bs->boot_sector_data, buf, 512); 550 } 551 if (drv->bdrv_pwrite) { 552 int ret, len; 553 len = nb_sectors * 512; 554 ret = drv->bdrv_pwrite(bs, sector_num * 512, buf, len); 555 if (ret < 0) 556 return ret; 557 else if (ret != len) 558 return -EIO; 559 else { 560 bs->wr_bytes += (unsigned) len; 561 bs->wr_ops ++; 562 return 0; 563 } 564 } else { 565 return drv->bdrv_write(bs, sector_num, buf, nb_sectors); 566 } 567 } 568 569 static int bdrv_pread_em(BlockDriverState *bs, int64_t offset, 570 uint8_t *buf, int count1) 571 { 572 uint8_t tmp_buf[SECTOR_SIZE]; 573 int len, nb_sectors, count; 574 int64_t sector_num; 575 576 count = count1; 577 /* first read to align to sector start */ 578 len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1); 579 if (len > count) 580 len = count; 581 sector_num = offset >> SECTOR_BITS; 582 if (len > 0) { 583 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0) 584 return -EIO; 585 memcpy(buf, tmp_buf + (offset & (SECTOR_SIZE - 1)), len); 586 count -= len; 587 if (count == 0) 588 return count1; 589 sector_num++; 590 buf += len; 591 } 592 593 /* read the sectors "in place" */ 594 nb_sectors = count >> SECTOR_BITS; 595 if (nb_sectors > 0) { 596 if (bdrv_read(bs, sector_num, buf, nb_sectors) < 0) 597 return -EIO; 598 sector_num += nb_sectors; 599 len = nb_sectors << SECTOR_BITS; 600 buf += len; 601 count -= len; 602 } 603 604 /* add data from the last sector */ 605 if (count > 0) { 606 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0) 607 return -EIO; 608 memcpy(buf, tmp_buf, count); 609 } 610 return count1; 611 } 612 613 static int bdrv_pwrite_em(BlockDriverState *bs, int64_t offset, 614 const uint8_t *buf, int count1) 615 { 616 uint8_t tmp_buf[SECTOR_SIZE]; 617 int len, nb_sectors, count; 618 int64_t sector_num; 619 620 count = count1; 621 /* first write to align to sector start */ 622 len = (SECTOR_SIZE - offset) & (SECTOR_SIZE - 1); 623 if (len > count) 624 len = count; 625 sector_num = offset >> SECTOR_BITS; 626 if (len > 0) { 627 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0) 628 return -EIO; 629 memcpy(tmp_buf + (offset & (SECTOR_SIZE - 1)), buf, len); 630 if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0) 631 return -EIO; 632 count -= len; 633 if (count == 0) 634 return count1; 635 sector_num++; 636 buf += len; 637 } 638 639 /* write the sectors "in place" */ 640 nb_sectors = count >> SECTOR_BITS; 641 if (nb_sectors > 0) { 642 if (bdrv_write(bs, sector_num, buf, nb_sectors) < 0) 643 return -EIO; 644 sector_num += nb_sectors; 645 len = nb_sectors << SECTOR_BITS; 646 buf += len; 647 count -= len; 648 } 649 650 /* add data from the last sector */ 651 if (count > 0) { 652 if (bdrv_read(bs, sector_num, tmp_buf, 1) < 0) 653 return -EIO; 654 memcpy(tmp_buf, buf, count); 655 if (bdrv_write(bs, sector_num, tmp_buf, 1) < 0) 656 return -EIO; 657 } 658 return count1; 659 } 660 661 /** 662 * Read with byte offsets (needed only for file protocols) 663 */ 664 int bdrv_pread(BlockDriverState *bs, int64_t offset, 665 void *buf1, int count1) 666 { 667 BlockDriver *drv = bs->drv; 668 669 if (!drv) 670 return -ENOMEDIUM; 671 if (!drv->bdrv_pread) 672 return bdrv_pread_em(bs, offset, buf1, count1); 673 return drv->bdrv_pread(bs, offset, buf1, count1); 674 } 675 676 /** 677 * Write with byte offsets (needed only for file protocols) 678 */ 679 int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 680 const void *buf1, int count1) 681 { 682 BlockDriver *drv = bs->drv; 683 684 if (!drv) 685 return -ENOMEDIUM; 686 if (!drv->bdrv_pwrite) 687 return bdrv_pwrite_em(bs, offset, buf1, count1); 688 return drv->bdrv_pwrite(bs, offset, buf1, count1); 689 } 690 691 /** 692 * Truncate file to 'offset' bytes (needed only for file protocols) 693 */ 694 int bdrv_truncate(BlockDriverState *bs, int64_t offset) 695 { 696 BlockDriver *drv = bs->drv; 697 if (!drv) 698 return -ENOMEDIUM; 699 if (!drv->bdrv_truncate) 700 return -ENOTSUP; 701 return drv->bdrv_truncate(bs, offset); 702 } 703 704 /** 705 * Length of a file in bytes. Return < 0 if error or unknown. 706 */ 707 int64_t bdrv_getlength(BlockDriverState *bs) 708 { 709 BlockDriver *drv = bs->drv; 710 if (!drv) 711 return -ENOMEDIUM; 712 if (!drv->bdrv_getlength) { 713 /* legacy mode */ 714 return bs->total_sectors * SECTOR_SIZE; 715 } 716 return drv->bdrv_getlength(bs); 717 } 718 719 /* return 0 as number of sectors if no device present or error */ 720 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr) 721 { 722 int64_t length; 723 length = bdrv_getlength(bs); 724 if (length < 0) 725 length = 0; 726 else 727 length = length >> SECTOR_BITS; 728 *nb_sectors_ptr = length; 729 } 730 731 /* force a given boot sector. */ 732 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size) 733 { 734 bs->boot_sector_enabled = 1; 735 if (size > 512) 736 size = 512; 737 memcpy(bs->boot_sector_data, data, size); 738 memset(bs->boot_sector_data + size, 0, 512 - size); 739 } 740 741 void bdrv_set_geometry_hint(BlockDriverState *bs, 742 int cyls, int heads, int secs) 743 { 744 bs->cyls = cyls; 745 bs->heads = heads; 746 bs->secs = secs; 747 } 748 749 void bdrv_set_type_hint(BlockDriverState *bs, int type) 750 { 751 bs->type = type; 752 bs->removable = ((type == BDRV_TYPE_CDROM || 753 type == BDRV_TYPE_FLOPPY)); 754 } 755 756 void bdrv_set_translation_hint(BlockDriverState *bs, int translation) 757 { 758 bs->translation = translation; 759 } 760 761 void bdrv_get_geometry_hint(BlockDriverState *bs, 762 int *pcyls, int *pheads, int *psecs) 763 { 764 *pcyls = bs->cyls; 765 *pheads = bs->heads; 766 *psecs = bs->secs; 767 } 768 769 int bdrv_get_type_hint(BlockDriverState *bs) 770 { 771 return bs->type; 772 } 773 774 int bdrv_get_translation_hint(BlockDriverState *bs) 775 { 776 return bs->translation; 777 } 778 779 int bdrv_is_removable(BlockDriverState *bs) 780 { 781 return bs->removable; 782 } 783 784 int bdrv_is_read_only(BlockDriverState *bs) 785 { 786 return bs->read_only; 787 } 788 789 /* XXX: no longer used */ 790 void bdrv_set_change_cb(BlockDriverState *bs, 791 void (*change_cb)(void *opaque), void *opaque) 792 { 793 bs->change_cb = change_cb; 794 bs->change_opaque = opaque; 795 } 796 797 int bdrv_is_encrypted(BlockDriverState *bs) 798 { 799 if (bs->backing_hd && bs->backing_hd->encrypted) 800 return 1; 801 return bs->encrypted; 802 } 803 804 int bdrv_set_key(BlockDriverState *bs, const char *key) 805 { 806 int ret; 807 if (bs->backing_hd && bs->backing_hd->encrypted) { 808 ret = bdrv_set_key(bs->backing_hd, key); 809 if (ret < 0) 810 return ret; 811 if (!bs->encrypted) 812 return 0; 813 } 814 if (!bs->encrypted || !bs->drv || !bs->drv->bdrv_set_key) 815 return -1; 816 return bs->drv->bdrv_set_key(bs, key); 817 } 818 819 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size) 820 { 821 if (!bs->drv) { 822 buf[0] = '\0'; 823 } else { 824 pstrcpy(buf, buf_size, bs->drv->format_name); 825 } 826 } 827 828 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 829 void *opaque) 830 { 831 BlockDriver *drv; 832 833 for (drv = first_drv; drv != NULL; drv = drv->next) { 834 it(opaque, drv->format_name); 835 } 836 } 837 838 BlockDriverState *bdrv_find(const char *name) 839 { 840 BlockDriverState *bs; 841 842 for (bs = bdrv_first; bs != NULL; bs = bs->next) { 843 if (!strcmp(name, bs->device_name)) 844 return bs; 845 } 846 return NULL; 847 } 848 849 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque) 850 { 851 BlockDriverState *bs; 852 853 for (bs = bdrv_first; bs != NULL; bs = bs->next) { 854 it(opaque, bs->device_name); 855 } 856 } 857 858 const char *bdrv_get_device_name(BlockDriverState *bs) 859 { 860 return bs->device_name; 861 } 862 863 void bdrv_flush(BlockDriverState *bs) 864 { 865 if (bs->drv->bdrv_flush) 866 bs->drv->bdrv_flush(bs); 867 if (bs->backing_hd) 868 bdrv_flush(bs->backing_hd); 869 } 870 871 #ifndef QEMU_IMG 872 void bdrv_info(void) 873 { 874 BlockDriverState *bs; 875 876 for (bs = bdrv_first; bs != NULL; bs = bs->next) { 877 term_printf("%s:", bs->device_name); 878 term_printf(" type="); 879 switch(bs->type) { 880 case BDRV_TYPE_HD: 881 term_printf("hd"); 882 break; 883 case BDRV_TYPE_CDROM: 884 term_printf("cdrom"); 885 break; 886 case BDRV_TYPE_FLOPPY: 887 term_printf("floppy"); 888 break; 889 } 890 term_printf(" removable=%d", bs->removable); 891 if (bs->removable) { 892 term_printf(" locked=%d", bs->locked); 893 } 894 if (bs->drv) { 895 term_printf(" file="); 896 term_print_filename(bs->filename); 897 if (bs->backing_file[0] != '\0') { 898 term_printf(" backing_file="); 899 term_print_filename(bs->backing_file); 900 } 901 term_printf(" ro=%d", bs->read_only); 902 term_printf(" drv=%s", bs->drv->format_name); 903 if (bs->encrypted) 904 term_printf(" encrypted"); 905 } else { 906 term_printf(" [not inserted]"); 907 } 908 term_printf("\n"); 909 } 910 } 911 912 /* The "info blockstats" command. */ 913 void bdrv_info_stats (void) 914 { 915 BlockDriverState *bs; 916 917 for (bs = bdrv_first; bs != NULL; bs = bs->next) { 918 term_printf ("%s:" 919 " rd_bytes=%" PRIu64 920 " wr_bytes=%" PRIu64 921 " rd_operations=%" PRIu64 922 " wr_operations=%" PRIu64 923 "\n", 924 bs->device_name, 925 bs->rd_bytes, bs->wr_bytes, 926 bs->rd_ops, bs->wr_ops); 927 } 928 } 929 #endif 930 931 void bdrv_get_backing_filename(BlockDriverState *bs, 932 char *filename, int filename_size) 933 { 934 if (!bs->backing_hd) { 935 pstrcpy(filename, filename_size, ""); 936 } else { 937 pstrcpy(filename, filename_size, bs->backing_file); 938 } 939 } 940 941 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 942 const uint8_t *buf, int nb_sectors) 943 { 944 BlockDriver *drv = bs->drv; 945 if (!drv) 946 return -ENOMEDIUM; 947 if (!drv->bdrv_write_compressed) 948 return -ENOTSUP; 949 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); 950 } 951 952 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 953 { 954 BlockDriver *drv = bs->drv; 955 if (!drv) 956 return -ENOMEDIUM; 957 if (!drv->bdrv_get_info) 958 return -ENOTSUP; 959 memset(bdi, 0, sizeof(*bdi)); 960 return drv->bdrv_get_info(bs, bdi); 961 } 962 963 /**************************************************************/ 964 /* handling of snapshots */ 965 966 int bdrv_snapshot_create(BlockDriverState *bs, 967 QEMUSnapshotInfo *sn_info) 968 { 969 BlockDriver *drv = bs->drv; 970 if (!drv) 971 return -ENOMEDIUM; 972 if (!drv->bdrv_snapshot_create) 973 return -ENOTSUP; 974 return drv->bdrv_snapshot_create(bs, sn_info); 975 } 976 977 int bdrv_snapshot_goto(BlockDriverState *bs, 978 const char *snapshot_id) 979 { 980 BlockDriver *drv = bs->drv; 981 if (!drv) 982 return -ENOMEDIUM; 983 if (!drv->bdrv_snapshot_goto) 984 return -ENOTSUP; 985 return drv->bdrv_snapshot_goto(bs, snapshot_id); 986 } 987 988 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id) 989 { 990 BlockDriver *drv = bs->drv; 991 if (!drv) 992 return -ENOMEDIUM; 993 if (!drv->bdrv_snapshot_delete) 994 return -ENOTSUP; 995 return drv->bdrv_snapshot_delete(bs, snapshot_id); 996 } 997 998 int bdrv_snapshot_list(BlockDriverState *bs, 999 QEMUSnapshotInfo **psn_info) 1000 { 1001 BlockDriver *drv = bs->drv; 1002 if (!drv) 1003 return -ENOMEDIUM; 1004 if (!drv->bdrv_snapshot_list) 1005 return -ENOTSUP; 1006 return drv->bdrv_snapshot_list(bs, psn_info); 1007 } 1008 1009 #define NB_SUFFIXES 4 1010 1011 char *get_human_readable_size(char *buf, int buf_size, int64_t size) 1012 { 1013 static const char suffixes[NB_SUFFIXES] = "KMGT"; 1014 int64_t base; 1015 int i; 1016 1017 if (size <= 999) { 1018 snprintf(buf, buf_size, "%" PRId64, size); 1019 } else { 1020 base = 1024; 1021 for(i = 0; i < NB_SUFFIXES; i++) { 1022 if (size < (10 * base)) { 1023 snprintf(buf, buf_size, "%0.1f%c", 1024 (double)size / base, 1025 suffixes[i]); 1026 break; 1027 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 1028 snprintf(buf, buf_size, "%" PRId64 "%c", 1029 ((size + (base >> 1)) / base), 1030 suffixes[i]); 1031 break; 1032 } 1033 base = base * 1024; 1034 } 1035 } 1036 return buf; 1037 } 1038 1039 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn) 1040 { 1041 char buf1[128], date_buf[128], clock_buf[128]; 1042 #ifdef _WIN32 1043 struct tm *ptm; 1044 #else 1045 struct tm tm; 1046 #endif 1047 time_t ti; 1048 int64_t secs; 1049 1050 if (!sn) { 1051 snprintf(buf, buf_size, 1052 "%-10s%-20s%7s%20s%15s", 1053 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 1054 } else { 1055 ti = sn->date_sec; 1056 #ifdef _WIN32 1057 ptm = localtime(&ti); 1058 strftime(date_buf, sizeof(date_buf), 1059 "%Y-%m-%d %H:%M:%S", ptm); 1060 #else 1061 localtime_r(&ti, &tm); 1062 strftime(date_buf, sizeof(date_buf), 1063 "%Y-%m-%d %H:%M:%S", &tm); 1064 #endif 1065 secs = sn->vm_clock_nsec / 1000000000; 1066 snprintf(clock_buf, sizeof(clock_buf), 1067 "%02d:%02d:%02d.%03d", 1068 (int)(secs / 3600), 1069 (int)((secs / 60) % 60), 1070 (int)(secs % 60), 1071 (int)((sn->vm_clock_nsec / 1000000) % 1000)); 1072 snprintf(buf, buf_size, 1073 "%-10s%-20s%7s%20s%15s", 1074 sn->id_str, sn->name, 1075 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size), 1076 date_buf, 1077 clock_buf); 1078 } 1079 return buf; 1080 } 1081 1082 1083 /**************************************************************/ 1084 /* async I/Os */ 1085 1086 BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num, 1087 uint8_t *buf, int nb_sectors, 1088 BlockDriverCompletionFunc *cb, void *opaque) 1089 { 1090 BlockDriver *drv = bs->drv; 1091 BlockDriverAIOCB *ret; 1092 1093 if (!drv) 1094 return NULL; 1095 1096 /* XXX: we assume that nb_sectors == 0 is suppored by the async read */ 1097 if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { 1098 memcpy(buf, bs->boot_sector_data, 512); 1099 sector_num++; 1100 nb_sectors--; 1101 buf += 512; 1102 } 1103 1104 ret = drv->bdrv_aio_read(bs, sector_num, buf, nb_sectors, cb, opaque); 1105 1106 if (ret) { 1107 /* Update stats even though technically transfer has not happened. */ 1108 bs->rd_bytes += (unsigned) nb_sectors * SECTOR_SIZE; 1109 bs->rd_ops ++; 1110 } 1111 1112 return ret; 1113 } 1114 1115 BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num, 1116 const uint8_t *buf, int nb_sectors, 1117 BlockDriverCompletionFunc *cb, void *opaque) 1118 { 1119 BlockDriver *drv = bs->drv; 1120 BlockDriverAIOCB *ret; 1121 1122 if (!drv) 1123 return NULL; 1124 if (bs->read_only) 1125 return NULL; 1126 if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) { 1127 memcpy(bs->boot_sector_data, buf, 512); 1128 } 1129 1130 ret = drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque); 1131 1132 if (ret) { 1133 /* Update stats even though technically transfer has not happened. */ 1134 bs->wr_bytes += (unsigned) nb_sectors * SECTOR_SIZE; 1135 bs->wr_ops ++; 1136 } 1137 1138 return ret; 1139 } 1140 1141 void bdrv_aio_cancel(BlockDriverAIOCB *acb) 1142 { 1143 BlockDriver *drv = acb->bs->drv; 1144 1145 drv->bdrv_aio_cancel(acb); 1146 } 1147 1148 1149 /**************************************************************/ 1150 /* async block device emulation */ 1151 1152 #ifdef QEMU_IMG 1153 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs, 1154 int64_t sector_num, uint8_t *buf, int nb_sectors, 1155 BlockDriverCompletionFunc *cb, void *opaque) 1156 { 1157 int ret; 1158 ret = bdrv_read(bs, sector_num, buf, nb_sectors); 1159 cb(opaque, ret); 1160 return NULL; 1161 } 1162 1163 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs, 1164 int64_t sector_num, const uint8_t *buf, int nb_sectors, 1165 BlockDriverCompletionFunc *cb, void *opaque) 1166 { 1167 int ret; 1168 ret = bdrv_write(bs, sector_num, buf, nb_sectors); 1169 cb(opaque, ret); 1170 return NULL; 1171 } 1172 1173 static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb) 1174 { 1175 } 1176 #else 1177 static void bdrv_aio_bh_cb(void *opaque) 1178 { 1179 BlockDriverAIOCBSync *acb = opaque; 1180 acb->common.cb(acb->common.opaque, acb->ret); 1181 qemu_aio_release(acb); 1182 } 1183 1184 static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs, 1185 int64_t sector_num, uint8_t *buf, int nb_sectors, 1186 BlockDriverCompletionFunc *cb, void *opaque) 1187 { 1188 BlockDriverAIOCBSync *acb; 1189 int ret; 1190 1191 acb = qemu_aio_get(bs, cb, opaque); 1192 if (!acb->bh) 1193 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 1194 ret = bdrv_read(bs, sector_num, buf, nb_sectors); 1195 acb->ret = ret; 1196 qemu_bh_schedule(acb->bh); 1197 return &acb->common; 1198 } 1199 1200 static BlockDriverAIOCB *bdrv_aio_write_em(BlockDriverState *bs, 1201 int64_t sector_num, const uint8_t *buf, int nb_sectors, 1202 BlockDriverCompletionFunc *cb, void *opaque) 1203 { 1204 BlockDriverAIOCBSync *acb; 1205 int ret; 1206 1207 acb = qemu_aio_get(bs, cb, opaque); 1208 if (!acb->bh) 1209 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 1210 ret = bdrv_write(bs, sector_num, buf, nb_sectors); 1211 acb->ret = ret; 1212 qemu_bh_schedule(acb->bh); 1213 return &acb->common; 1214 } 1215 1216 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb) 1217 { 1218 BlockDriverAIOCBSync *acb = (BlockDriverAIOCBSync *)blockacb; 1219 qemu_bh_cancel(acb->bh); 1220 qemu_aio_release(acb); 1221 } 1222 #endif /* !QEMU_IMG */ 1223 1224 /**************************************************************/ 1225 /* sync block device emulation */ 1226 1227 static void bdrv_rw_em_cb(void *opaque, int ret) 1228 { 1229 *(int *)opaque = ret; 1230 } 1231 1232 #define NOT_DONE 0x7fffffff 1233 1234 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 1235 uint8_t *buf, int nb_sectors) 1236 { 1237 int async_ret; 1238 BlockDriverAIOCB *acb; 1239 1240 async_ret = NOT_DONE; 1241 qemu_aio_wait_start(); 1242 acb = bdrv_aio_read(bs, sector_num, buf, nb_sectors, 1243 bdrv_rw_em_cb, &async_ret); 1244 if (acb == NULL) { 1245 qemu_aio_wait_end(); 1246 return -1; 1247 } 1248 while (async_ret == NOT_DONE) { 1249 qemu_aio_wait(); 1250 } 1251 qemu_aio_wait_end(); 1252 return async_ret; 1253 } 1254 1255 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num, 1256 const uint8_t *buf, int nb_sectors) 1257 { 1258 int async_ret; 1259 BlockDriverAIOCB *acb; 1260 1261 async_ret = NOT_DONE; 1262 qemu_aio_wait_start(); 1263 acb = bdrv_aio_write(bs, sector_num, buf, nb_sectors, 1264 bdrv_rw_em_cb, &async_ret); 1265 if (acb == NULL) { 1266 qemu_aio_wait_end(); 1267 return -1; 1268 } 1269 while (async_ret == NOT_DONE) { 1270 qemu_aio_wait(); 1271 } 1272 qemu_aio_wait_end(); 1273 return async_ret; 1274 } 1275 1276 void bdrv_init(void) 1277 { 1278 bdrv_register(&bdrv_raw); 1279 bdrv_register(&bdrv_host_device); 1280 #ifndef _WIN32 1281 bdrv_register(&bdrv_cow); 1282 #endif 1283 bdrv_register(&bdrv_qcow); 1284 bdrv_register(&bdrv_vmdk); 1285 bdrv_register(&bdrv_cloop); 1286 bdrv_register(&bdrv_dmg); 1287 bdrv_register(&bdrv_bochs); 1288 bdrv_register(&bdrv_vpc); 1289 bdrv_register(&bdrv_vvfat); 1290 bdrv_register(&bdrv_qcow2); 1291 bdrv_register(&bdrv_parallels); 1292 } 1293 1294 void *qemu_aio_get(BlockDriverState *bs, BlockDriverCompletionFunc *cb, 1295 void *opaque) 1296 { 1297 BlockDriver *drv; 1298 BlockDriverAIOCB *acb; 1299 1300 drv = bs->drv; 1301 if (drv->free_aiocb) { 1302 acb = drv->free_aiocb; 1303 drv->free_aiocb = acb->next; 1304 } else { 1305 acb = qemu_mallocz(drv->aiocb_size); 1306 if (!acb) 1307 return NULL; 1308 } 1309 acb->bs = bs; 1310 acb->cb = cb; 1311 acb->opaque = opaque; 1312 return acb; 1313 } 1314 1315 void qemu_aio_release(void *p) 1316 { 1317 BlockDriverAIOCB *acb = p; 1318 BlockDriver *drv = acb->bs->drv; 1319 acb->next = drv->free_aiocb; 1320 drv->free_aiocb = acb; 1321 } 1322 1323 /**************************************************************/ 1324 /* removable device support */ 1325 1326 /** 1327 * Return TRUE if the media is present 1328 */ 1329 int bdrv_is_inserted(BlockDriverState *bs) 1330 { 1331 BlockDriver *drv = bs->drv; 1332 int ret; 1333 if (!drv) 1334 return 0; 1335 if (!drv->bdrv_is_inserted) 1336 return 1; 1337 ret = drv->bdrv_is_inserted(bs); 1338 return ret; 1339 } 1340 1341 /** 1342 * Return TRUE if the media changed since the last call to this 1343 * function. It is currently only used for floppy disks 1344 */ 1345 int bdrv_media_changed(BlockDriverState *bs) 1346 { 1347 BlockDriver *drv = bs->drv; 1348 int ret; 1349 1350 if (!drv || !drv->bdrv_media_changed) 1351 ret = -ENOTSUP; 1352 else 1353 ret = drv->bdrv_media_changed(bs); 1354 if (ret == -ENOTSUP) 1355 ret = bs->media_changed; 1356 bs->media_changed = 0; 1357 return ret; 1358 } 1359 1360 /** 1361 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 1362 */ 1363 void bdrv_eject(BlockDriverState *bs, int eject_flag) 1364 { 1365 BlockDriver *drv = bs->drv; 1366 int ret; 1367 1368 if (!drv || !drv->bdrv_eject) { 1369 ret = -ENOTSUP; 1370 } else { 1371 ret = drv->bdrv_eject(bs, eject_flag); 1372 } 1373 if (ret == -ENOTSUP) { 1374 if (eject_flag) 1375 bdrv_close(bs); 1376 } 1377 } 1378 1379 int bdrv_is_locked(BlockDriverState *bs) 1380 { 1381 return bs->locked; 1382 } 1383 1384 /** 1385 * Lock or unlock the media (if it is locked, the user won't be able 1386 * to eject it manually). 1387 */ 1388 void bdrv_set_locked(BlockDriverState *bs, int locked) 1389 { 1390 BlockDriver *drv = bs->drv; 1391 1392 bs->locked = locked; 1393 if (drv && drv->bdrv_set_locked) { 1394 drv->bdrv_set_locked(bs, locked); 1395 } 1396 } 1397