File:  [Qemu by Fabrice Bellard] / qemu / block.c
Revision 1.1.1.22 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:17:20 2018 UTC (2 years, 5 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu1001, HEAD
qemu 1.0.1

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

unix.superglobalmegacorp.com