File:  [Qemu by Fabrice Bellard] / qemu / block.c
Revision 1.1.1.17 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:16:35 2018 UTC (2 years, 2 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu0125, HEAD
qemu 0.12.5

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

unix.superglobalmegacorp.com