File:  [Qemu by Fabrice Bellard] / qemu / block.c
Revision 1.1.1.15 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 17:57:40 2018 UTC (19 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu0123, HEAD
qemu 0.12.3

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

unix.superglobalmegacorp.com