Annotation of qemu/block.c, revision 1.1.1.22

1.1       root        1: /*
                      2:  * QEMU System Emulator block driver
1.1.1.6   root        3:  *
1.1       root        4:  * Copyright (c) 2003 Fabrice Bellard
1.1.1.6   root        5:  *
1.1       root        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:  */
1.1.1.7   root       24: #include "config-host.h"
1.1.1.6   root       25: #include "qemu-common.h"
1.1.1.19  root       26: #include "trace.h"
1.1.1.13  root       27: #include "monitor.h"
1.1       root       28: #include "block_int.h"
1.1.1.13  root       29: #include "module.h"
1.1.1.22! root       30: #include "qjson.h"
        !            31: #include "qemu-coroutine.h"
        !            32: #include "qmp-commands.h"
1.1       root       33: 
1.1.1.14  root       34: #ifdef CONFIG_BSD
1.1       root       35: #include <sys/types.h>
                     36: #include <sys/stat.h>
                     37: #include <sys/ioctl.h>
1.1.1.14  root       38: #include <sys/queue.h>
1.1.1.13  root       39: #ifndef __DragonFly__
1.1       root       40: #include <sys/disk.h>
                     41: #endif
1.1.1.13  root       42: #endif
                     43: 
                     44: #ifdef _WIN32
                     45: #include <windows.h>
                     46: #endif
1.1       root       47: 
1.1.1.22! root       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);
1.1.1.13  root       51: static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
                     52:         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1.1.1.5   root       53:         BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.13  root       54: static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
                     55:         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1.1.1.5   root       56:         BlockDriverCompletionFunc *cb, void *opaque);
1.1.1.22! root       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);
1.1.1.3   root       75: 
1.1.1.18  root       76: static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
                     77:     QTAILQ_HEAD_INITIALIZER(bdrv_states);
1.1.1.7   root       78: 
1.1.1.18  root       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;
1.1       root       84: 
1.1.1.14  root       85: /* If non-zero, use only whitelisted block drivers */
                     86: static int use_bdrv_whitelist;
                     87: 
1.1.1.19  root       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: 
1.1.1.5   root      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
1.1.1.2   root      139: }
                    140: 
1.1.1.5   root      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;
1.1.1.2   root      168:         }
1.1.1.5   root      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);
1.1.1.2   root      182:     }
                    183: }
                    184: 
1.1.1.13  root      185: void bdrv_register(BlockDriver *bdrv)
1.1       root      186: {
1.1.1.22! root      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:         }
1.1.1.5   root      200:     }
1.1.1.14  root      201: 
1.1.1.18  root      202:     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
1.1       root      203: }
                    204: 
                    205: /* create a new block device (by default it is empty) */
                    206: BlockDriverState *bdrv_new(const char *device_name)
                    207: {
1.1.1.18  root      208:     BlockDriverState *bs;
1.1       root      209: 
1.1.1.22! root      210:     bs = g_malloc0(sizeof(BlockDriverState));
1.1       root      211:     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
                    212:     if (device_name[0] != '\0') {
1.1.1.18  root      213:         QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
1.1       root      214:     }
1.1.1.22! root      215:     bdrv_iostatus_disable(bs);
1.1       root      216:     return bs;
                    217: }
                    218: 
                    219: BlockDriver *bdrv_find_format(const char *format_name)
                    220: {
                    221:     BlockDriver *drv1;
1.1.1.18  root      222:     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
                    223:         if (!strcmp(drv1->format_name, format_name)) {
1.1       root      224:             return drv1;
1.1.1.18  root      225:         }
1.1       root      226:     }
                    227:     return NULL;
                    228: }
                    229: 
1.1.1.14  root      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: 
1.1.1.13  root      254: int bdrv_create(BlockDriver *drv, const char* filename,
                    255:     QEMUOptionParameter *options)
1.1       root      256: {
                    257:     if (!drv->bdrv_create)
                    258:         return -ENOTSUP;
1.1.1.13  root      259: 
                    260:     return drv->bdrv_create(filename, options);
1.1       root      261: }
                    262: 
1.1.1.18  root      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) {
1.1.1.19  root      269:         return -ENOENT;
1.1.1.18  root      270:     }
                    271: 
                    272:     return bdrv_create(drv, filename, options);
                    273: }
                    274: 
1.1       root      275: #ifdef _WIN32
1.1.1.2   root      276: void get_tmp_filename(char *filename, int size)
1.1       root      277: {
1.1.1.5   root      278:     char temp_dir[MAX_PATH];
1.1.1.6   root      279: 
1.1.1.5   root      280:     GetTempPath(MAX_PATH, temp_dir);
                    281:     GetTempFileName(temp_dir, "qem", 0, filename);
1.1       root      282: }
                    283: #else
1.1.1.2   root      284: void get_tmp_filename(char *filename, int size)
1.1       root      285: {
                    286:     int fd;
1.1.1.7   root      287:     const char *tmpdir;
1.1       root      288:     /* XXX: race condition possible */
1.1.1.7   root      289:     tmpdir = getenv("TMPDIR");
                    290:     if (!tmpdir)
                    291:         tmpdir = "/tmp";
                    292:     snprintf(filename, size, "%s/vl.XXXXXX", tmpdir);
1.1       root      293:     fd = mkstemp(filename);
                    294:     close(fd);
                    295: }
                    296: #endif
                    297: 
1.1.1.13  root      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: 
1.1.1.18  root      307:     QLIST_FOREACH(d, &bdrv_drivers, list) {
1.1.1.13  root      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: 
1.1.1.18  root      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: 
1.1.1.19  root      341:     if (!path_has_protocol(filename)) {
1.1.1.18  root      342:         return bdrv_find_format("file");
                    343:     }
1.1.1.19  root      344:     p = strchr(filename, ':');
                    345:     assert(p != NULL);
1.1.1.18  root      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)
1.1       root      361: {
1.1.1.5   root      362:     int ret, score, score_max;
1.1       root      363:     BlockDriver *drv1, *drv;
1.1.1.5   root      364:     uint8_t buf[2048];
                    365:     BlockDriverState *bs;
1.1.1.6   root      366: 
1.1.1.18  root      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:     }
1.1.1.5   root      383: 
                    384:     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
                    385:     bdrv_delete(bs);
                    386:     if (ret < 0) {
1.1.1.18  root      387:         *pdrv = NULL;
                    388:         return ret;
1.1.1.5   root      389:     }
                    390: 
1.1       root      391:     score_max = 0;
1.1.1.18  root      392:     drv = NULL;
                    393:     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
1.1.1.5   root      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:             }
1.1       root      400:         }
                    401:     }
1.1.1.18  root      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: 
1.1.1.22! root      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: 
1.1.1.18  root      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: 
1.1.1.22! root      470:     trace_bdrv_open_common(bs, filename, flags, drv->format_name);
        !           471: 
1.1.1.18  root      472:     bs->file = NULL;
                    473:     bs->total_sectors = 0;
                    474:     bs->encrypted = 0;
                    475:     bs->valid_key = 0;
1.1.1.22! root      476:     bs->sg = 0;
1.1.1.18  root      477:     bs->open_flags = flags;
1.1.1.22! root      478:     bs->growable = 0;
1.1.1.18  root      479:     bs->buffer_alignment = 512;
                    480: 
                    481:     pstrcpy(bs->filename, sizeof(bs->filename), filename);
1.1.1.22! root      482:     bs->backing_file[0] = '\0';
1.1.1.18  root      483: 
                    484:     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
                    485:         return -ENOTSUP;
                    486:     }
                    487: 
                    488:     bs->drv = drv;
1.1.1.22! root      489:     bs->opaque = g_malloc0(drv->instance_size);
1.1.1.18  root      490: 
1.1.1.22! root      491:     bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
1.1.1.18  root      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:     /*
1.1.1.21  root      500:      * Snapshots should be writable.
1.1.1.18  root      501:      */
                    502:     if (bs->is_temporary) {
                    503:         open_flags |= BDRV_O_RDWR;
                    504:     }
                    505: 
1.1.1.22! root      506:     bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
        !           507: 
1.1.1.18  root      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:     }
1.1.1.22! root      539:     g_free(bs->opaque);
1.1.1.18  root      540:     bs->opaque = NULL;
                    541:     bs->drv = NULL;
                    542:     return ret;
1.1       root      543: }
                    544: 
1.1.1.18  root      545: /*
                    546:  * Opens a file using a protocol (file, host_device, nbd, ...)
                    547:  */
1.1.1.5   root      548: int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
1.1       root      549: {
1.1.1.5   root      550:     BlockDriverState *bs;
1.1.1.18  root      551:     BlockDriver *drv;
1.1.1.5   root      552:     int ret;
                    553: 
1.1.1.18  root      554:     drv = bdrv_find_protocol(filename);
                    555:     if (!drv) {
                    556:         return -ENOENT;
                    557:     }
                    558: 
1.1.1.5   root      559:     bs = bdrv_new("");
1.1.1.18  root      560:     ret = bdrv_open_common(bs, filename, flags, drv);
1.1.1.5   root      561:     if (ret < 0) {
                    562:         bdrv_delete(bs);
                    563:         return ret;
1.1.1.2   root      564:     }
1.1.1.7   root      565:     bs->growable = 1;
1.1.1.5   root      566:     *pbs = bs;
                    567:     return 0;
                    568: }
                    569: 
1.1.1.18  root      570: /*
                    571:  * Opens a disk image (raw, qcow2, vmdk, ...)
                    572:  */
                    573: int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
                    574:               BlockDriver *drv)
1.1       root      575: {
1.1.1.18  root      576:     int ret;
1.1.1.22! root      577:     char tmp_filename[PATH_MAX];
1.1       root      578: 
1.1.1.5   root      579:     if (flags & BDRV_O_SNAPSHOT) {
1.1       root      580:         BlockDriverState *bs1;
                    581:         int64_t total_size;
1.1.1.7   root      582:         int is_protocol = 0;
1.1.1.13  root      583:         BlockDriver *bdrv_qcow2;
                    584:         QEMUOptionParameter *options;
1.1.1.18  root      585:         char backing_filename[PATH_MAX];
1.1.1.6   root      586: 
1.1       root      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("");
1.1.1.18  root      592:         ret = bdrv_open(bs1, filename, 0, drv);
1.1.1.8   root      593:         if (ret < 0) {
1.1       root      594:             bdrv_delete(bs1);
1.1.1.8   root      595:             return ret;
1.1       root      596:         }
1.1.1.18  root      597:         total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
1.1.1.7   root      598: 
                    599:         if (bs1->drv && bs1->drv->protocol_name)
                    600:             is_protocol = 1;
                    601: 
1.1       root      602:         bdrv_delete(bs1);
1.1.1.6   root      603: 
1.1       root      604:         get_tmp_filename(tmp_filename, sizeof(tmp_filename));
1.1.1.7   root      605: 
                    606:         /* Real path is meaningless for protocols */
                    607:         if (is_protocol)
                    608:             snprintf(backing_filename, sizeof(backing_filename),
                    609:                      "%s", filename);
1.1.1.18  root      610:         else if (!realpath(filename, backing_filename))
                    611:             return -errno;
1.1.1.7   root      612: 
1.1.1.13  root      613:         bdrv_qcow2 = bdrv_find_format("qcow2");
                    614:         options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
                    615: 
1.1.1.18  root      616:         set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
1.1.1.13  root      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);
1.1.1.18  root      624:         free_option_parameters(options);
1.1.1.8   root      625:         if (ret < 0) {
                    626:             return ret;
1.1       root      627:         }
1.1.1.13  root      628: 
1.1       root      629:         filename = tmp_filename;
1.1.1.13  root      630:         drv = bdrv_qcow2;
1.1       root      631:         bs->is_temporary = 1;
                    632:     }
                    633: 
1.1.1.18  root      634:     /* Find the right image format driver */
                    635:     if (!drv) {
                    636:         ret = find_image_format(filename, &drv);
1.1.1.8   root      637:     }
1.1.1.18  root      638: 
1.1.1.8   root      639:     if (!drv) {
                    640:         goto unlink_and_fail;
1.1       root      641:     }
1.1.1.14  root      642: 
1.1.1.18  root      643:     /* Open the image */
                    644:     ret = bdrv_open_common(bs, filename, flags, drv);
1.1       root      645:     if (ret < 0) {
1.1.1.18  root      646:         goto unlink_and_fail;
1.1       root      647:     }
1.1.1.18  root      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;
1.1.1.13  root      653:         BlockDriver *back_drv = NULL;
1.1.1.18  root      654: 
1.1       root      655:         bs->backing_hd = bdrv_new("");
1.1.1.19  root      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') {
1.1.1.13  root      666:             back_drv = bdrv_find_format(bs->backing_format);
1.1.1.19  root      667:         }
1.1.1.18  root      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);
1.1.1.8   root      674:         if (ret < 0) {
                    675:             bdrv_close(bs);
                    676:             return ret;
                    677:         }
1.1.1.18  root      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:         }
1.1       root      684:     }
                    685: 
1.1.1.13  root      686:     if (!bdrv_key_required(bs)) {
1.1.1.22! root      687:         bdrv_dev_change_media_cb(bs, true);
1.1.1.13  root      688:     }
1.1.1.18  root      689: 
1.1       root      690:     return 0;
1.1.1.18  root      691: 
                    692: unlink_and_fail:
                    693:     if (bs->is_temporary) {
                    694:         unlink(filename);
                    695:     }
                    696:     return ret;
1.1       root      697: }
                    698: 
                    699: void bdrv_close(BlockDriverState *bs)
                    700: {
1.1.1.5   root      701:     if (bs->drv) {
1.1.1.18  root      702:         if (bs == bs_snapshots) {
                    703:             bs_snapshots = NULL;
                    704:         }
                    705:         if (bs->backing_hd) {
1.1       root      706:             bdrv_delete(bs->backing_hd);
1.1.1.18  root      707:             bs->backing_hd = NULL;
                    708:         }
1.1       root      709:         bs->drv->bdrv_close(bs);
1.1.1.22! root      710:         g_free(bs->opaque);
1.1       root      711: #ifdef _WIN32
                    712:         if (bs->is_temporary) {
                    713:             unlink(bs->filename);
                    714:         }
                    715: #endif
                    716:         bs->opaque = NULL;
                    717:         bs->drv = NULL;
                    718: 
1.1.1.18  root      719:         if (bs->file != NULL) {
                    720:             bdrv_close(bs->file);
                    721:         }
                    722: 
1.1.1.22! root      723:         bdrv_dev_change_media_cb(bs, false);
1.1       root      724:     }
                    725: }
                    726: 
1.1.1.18  root      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: 
1.1.1.20  root      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: 
1.1       root      746: void bdrv_delete(BlockDriverState *bs)
                    747: {
1.1.1.22! root      748:     assert(!bs->dev);
1.1.1.7   root      749: 
1.1.1.18  root      750:     /* remove from list, if necessary */
1.1.1.20  root      751:     bdrv_make_anon(bs);
1.1.1.7   root      752: 
1.1       root      753:     bdrv_close(bs);
1.1.1.18  root      754:     if (bs->file != NULL) {
                    755:         bdrv_delete(bs->file);
                    756:     }
                    757: 
                    758:     assert(bs != bs_snapshots);
1.1.1.22! root      759:     g_free(bs);
1.1       root      760: }
                    761: 
1.1.1.22! root      762: int bdrv_attach_dev(BlockDriverState *bs, void *dev)
        !           763: /* TODO change to DeviceState *dev when all users are qdevified */
1.1.1.18  root      764: {
1.1.1.22! root      765:     if (bs->dev) {
1.1.1.18  root      766:         return -EBUSY;
                    767:     }
1.1.1.22! root      768:     bs->dev = dev;
        !           769:     bdrv_iostatus_reset(bs);
1.1.1.18  root      770:     return 0;
                    771: }
                    772: 
1.1.1.22! root      773: /* TODO qdevified devices don't use this, remove when devices are qdevified */
        !           774: void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
1.1.1.18  root      775: {
1.1.1.22! root      776:     if (bdrv_attach_dev(bs, dev) < 0) {
        !           777:         abort();
        !           778:     }
1.1.1.18  root      779: }
                    780: 
1.1.1.22! root      781: void bdrv_detach_dev(BlockDriverState *bs, void *dev)
        !           782: /* TODO change to DeviceState *dev when all users are qdevified */
1.1.1.18  root      783: {
1.1.1.22! root      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;
1.1.1.18  root      847: }
                    848: 
1.1.1.13  root      849: /*
                    850:  * Run consistency checks on an image
                    851:  *
1.1.1.18  root      852:  * Returns 0 if the check could be completed (it doesn't mean that the image is
1.1.1.21  root      853:  * free of errors) or -errno when an internal error occurred. The results of the
1.1.1.18  root      854:  * check are stored in res.
1.1.1.13  root      855:  */
1.1.1.18  root      856: int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
1.1.1.13  root      857: {
                    858:     if (bs->drv->bdrv_check == NULL) {
                    859:         return -ENOTSUP;
                    860:     }
                    861: 
1.1.1.18  root      862:     memset(res, 0, sizeof(*res));
                    863:     return bs->drv->bdrv_check(bs, res);
1.1.1.13  root      864: }
                    865: 
1.1.1.19  root      866: #define COMMIT_BUF_SECTORS 2048
                    867: 
1.1       root      868: /* commit COW file into the raw image */
                    869: int bdrv_commit(BlockDriverState *bs)
                    870: {
1.1.1.5   root      871:     BlockDriver *drv = bs->drv;
1.1.1.18  root      872:     BlockDriver *backing_drv;
1.1.1.19  root      873:     int64_t sector, total_sectors;
                    874:     int n, ro, open_flags;
1.1.1.18  root      875:     int ret = 0, rw_ret = 0;
1.1.1.19  root      876:     uint8_t *buf;
1.1.1.18  root      877:     char filename[1024];
                    878:     BlockDriverState *bs_rw, *bs_ro;
1.1       root      879: 
1.1.1.5   root      880:     if (!drv)
                    881:         return -ENOMEDIUM;
1.1.1.18  root      882:     
                    883:     if (!bs->backing_hd) {
                    884:         return -ENOTSUP;
                    885:     }
1.1       root      886: 
1.1.1.18  root      887:     if (bs->backing_hd->keep_read_only) {
                    888:         return -EACCES;
1.1       root      889:     }
                    890: 
1.1.1.18  root      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;
1.1       root      919:     }
                    920: 
1.1.1.14  root      921:     total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1.1.1.22! root      922:     buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
1.1       root      923: 
1.1.1.19  root      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:             }
1.1       root      936:         }
                    937:     }
1.1.1.2   root      938: 
1.1.1.18  root      939:     if (drv->bdrv_make_empty) {
                    940:         ret = drv->bdrv_make_empty(bs);
                    941:         bdrv_flush(bs);
                    942:     }
1.1.1.2   root      943: 
1.1.1.18  root      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:
1.1.1.22! root      952:     g_free(buf);
1.1.1.18  root      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:     }
1.1       root     1001: }
                   1002: 
1.1.1.7   root     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: 
1.1.1.11  root     1016:     if (offset < 0)
                   1017:         return -EIO;
                   1018: 
                   1019:     if ((offset > len) || (len - offset < size))
1.1.1.7   root     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: {
1.1.1.18  root     1028:     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
                   1029:                                    nb_sectors * BDRV_SECTOR_SIZE);
1.1.1.7   root     1030: }
                   1031: 
1.1.1.22! root     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: 
1.1.1.5   root     1090: /* return < 0 if error. See bdrv_write() for the return codes */
1.1.1.6   root     1091: int bdrv_read(BlockDriverState *bs, int64_t sector_num,
1.1       root     1092:               uint8_t *buf, int nb_sectors)
                   1093: {
1.1.1.22! root     1094:     return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
1.1       root     1095: }
                   1096: 
1.1.1.14  root     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) {
1.1.1.19  root     1111:             if (!(val & (1UL << bit))) {
1.1.1.18  root     1112:                 bs->dirty_count++;
1.1.1.19  root     1113:                 val |= 1UL << bit;
1.1.1.18  root     1114:             }
1.1.1.14  root     1115:         } else {
1.1.1.19  root     1116:             if (val & (1UL << bit)) {
1.1.1.18  root     1117:                 bs->dirty_count--;
1.1.1.19  root     1118:                 val &= ~(1UL << bit);
1.1.1.18  root     1119:             }
1.1.1.14  root     1120:         }
                   1121:         bs->dirty_bitmap[idx] = val;
                   1122:     }
                   1123: }
                   1124: 
1.1.1.6   root     1125: /* Return < 0 if error. Important errors are:
1.1.1.5   root     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: */
1.1.1.6   root     1131: int bdrv_write(BlockDriverState *bs, int64_t sector_num,
1.1       root     1132:                const uint8_t *buf, int nb_sectors)
                   1133: {
1.1.1.22! root     1134:     return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
1.1       root     1135: }
                   1136: 
1.1.1.13  root     1137: int bdrv_pread(BlockDriverState *bs, int64_t offset,
                   1138:                void *buf, int count1)
1.1.1.5   root     1139: {
1.1.1.14  root     1140:     uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1.1.1.5   root     1141:     int len, nb_sectors, count;
                   1142:     int64_t sector_num;
1.1.1.15  root     1143:     int ret;
1.1.1.5   root     1144: 
                   1145:     count = count1;
                   1146:     /* first read to align to sector start */
1.1.1.14  root     1147:     len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1.1.1.5   root     1148:     if (len > count)
                   1149:         len = count;
1.1.1.14  root     1150:     sector_num = offset >> BDRV_SECTOR_BITS;
1.1.1.5   root     1151:     if (len > 0) {
1.1.1.15  root     1152:         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
                   1153:             return ret;
1.1.1.14  root     1154:         memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
1.1.1.5   root     1155:         count -= len;
                   1156:         if (count == 0)
                   1157:             return count1;
                   1158:         sector_num++;
                   1159:         buf += len;
                   1160:     }
                   1161: 
                   1162:     /* read the sectors "in place" */
1.1.1.14  root     1163:     nb_sectors = count >> BDRV_SECTOR_BITS;
1.1.1.5   root     1164:     if (nb_sectors > 0) {
1.1.1.15  root     1165:         if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
                   1166:             return ret;
1.1.1.5   root     1167:         sector_num += nb_sectors;
1.1.1.14  root     1168:         len = nb_sectors << BDRV_SECTOR_BITS;
1.1.1.5   root     1169:         buf += len;
                   1170:         count -= len;
                   1171:     }
                   1172: 
                   1173:     /* add data from the last sector */
                   1174:     if (count > 0) {
1.1.1.15  root     1175:         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
                   1176:             return ret;
1.1.1.5   root     1177:         memcpy(buf, tmp_buf, count);
                   1178:     }
                   1179:     return count1;
                   1180: }
                   1181: 
1.1.1.13  root     1182: int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                   1183:                 const void *buf, int count1)
1.1.1.5   root     1184: {
1.1.1.14  root     1185:     uint8_t tmp_buf[BDRV_SECTOR_SIZE];
1.1.1.5   root     1186:     int len, nb_sectors, count;
                   1187:     int64_t sector_num;
1.1.1.15  root     1188:     int ret;
1.1.1.5   root     1189: 
                   1190:     count = count1;
                   1191:     /* first write to align to sector start */
1.1.1.14  root     1192:     len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
1.1.1.5   root     1193:     if (len > count)
                   1194:         len = count;
1.1.1.14  root     1195:     sector_num = offset >> BDRV_SECTOR_BITS;
1.1.1.5   root     1196:     if (len > 0) {
1.1.1.15  root     1197:         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
                   1198:             return ret;
1.1.1.14  root     1199:         memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
1.1.1.15  root     1200:         if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
                   1201:             return ret;
1.1.1.5   root     1202:         count -= len;
                   1203:         if (count == 0)
                   1204:             return count1;
                   1205:         sector_num++;
                   1206:         buf += len;
                   1207:     }
                   1208: 
                   1209:     /* write the sectors "in place" */
1.1.1.14  root     1210:     nb_sectors = count >> BDRV_SECTOR_BITS;
1.1.1.5   root     1211:     if (nb_sectors > 0) {
1.1.1.15  root     1212:         if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
                   1213:             return ret;
1.1.1.5   root     1214:         sector_num += nb_sectors;
1.1.1.14  root     1215:         len = nb_sectors << BDRV_SECTOR_BITS;
1.1.1.5   root     1216:         buf += len;
                   1217:         count -= len;
                   1218:     }
                   1219: 
                   1220:     /* add data from the last sector */
                   1221:     if (count > 0) {
1.1.1.15  root     1222:         if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
                   1223:             return ret;
1.1.1.5   root     1224:         memcpy(tmp_buf, buf, count);
1.1.1.15  root     1225:         if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
                   1226:             return ret;
1.1.1.5   root     1227:     }
                   1228:     return count1;
                   1229: }
                   1230: 
1.1.1.17  root     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: 
1.1.1.22! root     1247:     /* No flush needed for cache modes that use O_DSYNC */
        !          1248:     if ((bs->open_flags & BDRV_O_CACHE_WB) != 0) {
1.1.1.17  root     1249:         bdrv_flush(bs);
                   1250:     }
                   1251: 
                   1252:     return 0;
                   1253: }
                   1254: 
                   1255: /*
1.1.1.22! root     1256:  * Handle a read request in coroutine context
1.1.1.17  root     1257:  */
1.1.1.22! root     1258: static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
        !          1259:     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
1.1.1.17  root     1260: {
1.1.1.22! root     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);
1.1.1.17  root     1319: }
                   1320: 
1.1.1.5   root     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;
1.1.1.18  root     1327:     int ret;
1.1.1.5   root     1328:     if (!drv)
                   1329:         return -ENOMEDIUM;
                   1330:     if (!drv->bdrv_truncate)
                   1331:         return -ENOTSUP;
1.1.1.14  root     1332:     if (bs->read_only)
                   1333:         return -EACCES;
1.1.1.19  root     1334:     if (bdrv_in_use(bs))
                   1335:         return -EBUSY;
1.1.1.18  root     1336:     ret = drv->bdrv_truncate(bs, offset);
                   1337:     if (ret == 0) {
                   1338:         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1.1.1.22! root     1339:         bdrv_dev_resize_cb(bs);
1.1.1.18  root     1340:     }
                   1341:     return ret;
1.1.1.5   root     1342: }
                   1343: 
                   1344: /**
1.1.1.21  root     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: /**
1.1.1.5   root     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;
1.1.1.18  root     1371: 
1.1.1.22! root     1372:     if (bs->growable || bdrv_dev_has_removable_media(bs)) {
1.1.1.21  root     1373:         if (drv->bdrv_getlength) {
                   1374:             return drv->bdrv_getlength(bs);
                   1375:         }
1.1.1.5   root     1376:     }
1.1.1.21  root     1377:     return bs->total_sectors * BDRV_SECTOR_SIZE;
1.1.1.5   root     1378: }
                   1379: 
                   1380: /* return 0 as number of sectors if no device present or error */
1.1.1.6   root     1381: void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1.1       root     1382: {
1.1.1.5   root     1383:     int64_t length;
                   1384:     length = bdrv_getlength(bs);
                   1385:     if (length < 0)
                   1386:         length = 0;
                   1387:     else
1.1.1.14  root     1388:         length = length >> BDRV_SECTOR_BITS;
1.1.1.5   root     1389:     *nb_sectors_ptr = length;
1.1       root     1390: }
                   1391: 
1.1.1.7   root     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 */
1.1.1.22! root     1403: } QEMU_PACKED;
1.1.1.7   root     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: {
1.1.1.18  root     1409:     uint8_t buf[BDRV_SECTOR_SIZE];
1.1.1.7   root     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)
1.1       root     1450: {
1.1.1.7   root     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:     }
1.1       root     1506: }
                   1507: 
1.1.1.6   root     1508: void bdrv_set_geometry_hint(BlockDriverState *bs,
1.1       root     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: 
1.1.1.6   root     1521: void bdrv_get_geometry_hint(BlockDriverState *bs,
1.1       root     1522:                             int *pcyls, int *pheads, int *psecs)
                   1523: {
                   1524:     *pcyls = bs->cyls;
                   1525:     *pheads = bs->heads;
                   1526:     *psecs = bs->secs;
                   1527: }
                   1528: 
1.1.1.21  root     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:     }
1.1       root     1630: }
                   1631: 
                   1632: int bdrv_get_translation_hint(BlockDriverState *bs)
                   1633: {
                   1634:     return bs->translation;
                   1635: }
                   1636: 
1.1.1.18  root     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: 
1.1       root     1649: int bdrv_is_read_only(BlockDriverState *bs)
                   1650: {
                   1651:     return bs->read_only;
                   1652: }
                   1653: 
1.1.1.6   root     1654: int bdrv_is_sg(BlockDriverState *bs)
                   1655: {
                   1656:     return bs->sg;
                   1657: }
                   1658: 
1.1.1.14  root     1659: int bdrv_enable_write_cache(BlockDriverState *bs)
                   1660: {
                   1661:     return bs->enable_write_cache;
                   1662: }
                   1663: 
1.1       root     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: 
1.1.1.8   root     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: 
1.1       root     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:     }
1.1.1.18  root     1690:     if (!bs->encrypted) {
                   1691:         return -EINVAL;
                   1692:     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
                   1693:         return -ENOMEDIUM;
                   1694:     }
1.1.1.8   root     1695:     ret = bs->drv->bdrv_set_key(bs, key);
1.1.1.13  root     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 */
1.1.1.22! root     1701:         bdrv_dev_change_media_cb(bs, true);
1.1.1.13  root     1702:     }
1.1.1.8   root     1703:     return ret;
1.1       root     1704: }
                   1705: 
                   1706: void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
                   1707: {
1.1.1.5   root     1708:     if (!bs->drv) {
1.1       root     1709:         buf[0] = '\0';
                   1710:     } else {
                   1711:         pstrcpy(buf, buf_size, bs->drv->format_name);
                   1712:     }
                   1713: }
                   1714: 
1.1.1.6   root     1715: void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
1.1       root     1716:                          void *opaque)
                   1717: {
                   1718:     BlockDriver *drv;
                   1719: 
1.1.1.18  root     1720:     QLIST_FOREACH(drv, &bdrv_drivers, list) {
1.1       root     1721:         it(opaque, drv->format_name);
                   1722:     }
                   1723: }
                   1724: 
                   1725: BlockDriverState *bdrv_find(const char *name)
                   1726: {
                   1727:     BlockDriverState *bs;
                   1728: 
1.1.1.18  root     1729:     QTAILQ_FOREACH(bs, &bdrv_states, list) {
                   1730:         if (!strcmp(name, bs->device_name)) {
1.1       root     1731:             return bs;
1.1.1.18  root     1732:         }
1.1       root     1733:     }
                   1734:     return NULL;
                   1735: }
                   1736: 
1.1.1.18  root     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: 
1.1.1.8   root     1745: void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1.1       root     1746: {
                   1747:     BlockDriverState *bs;
                   1748: 
1.1.1.18  root     1749:     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1.1.1.8   root     1750:         it(opaque, bs);
1.1       root     1751:     }
                   1752: }
                   1753: 
                   1754: const char *bdrv_get_device_name(BlockDriverState *bs)
                   1755: {
                   1756:     return bs->device_name;
                   1757: }
                   1758: 
1.1.1.7   root     1759: void bdrv_flush_all(void)
                   1760: {
                   1761:     BlockDriverState *bs;
                   1762: 
1.1.1.18  root     1763:     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1.1.1.22! root     1764:         if (!bdrv_is_read_only(bs) && bdrv_is_inserted(bs)) {
1.1.1.7   root     1765:             bdrv_flush(bs);
1.1.1.18  root     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;
1.1.1.7   root     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: 
1.1.1.18  root     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: 
1.1.1.22! root     1837: BlockInfoList *qmp_query_block(Error **errp)
1.1.1.14  root     1838: {
1.1.1.22! root     1839:     BlockInfoList *head = NULL, *cur_item = NULL;
1.1       root     1840:     BlockDriverState *bs;
                   1841: 
1.1.1.18  root     1842:     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1.1.1.22! root     1843:         BlockInfoList *info = g_malloc0(sizeof(*info));
1.1.1.14  root     1844: 
1.1.1.22! root     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:         }
1.1.1.14  root     1860: 
1.1.1.5   root     1861:         if (bs->drv) {
1.1.1.22! root     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);
1.1.1.13  root     1871:             }
1.1.1.22! root     1872:         }
1.1.1.14  root     1873: 
1.1.1.22! root     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;
1.1       root     1880:         }
                   1881:     }
1.1.1.14  root     1882: 
1.1.1.22! root     1883:     return head;
1.1.1.14  root     1884: }
                   1885: 
1.1.1.22! root     1886: /* Consider exposing this as a full fledged QMP command */
        !          1887: static BlockStats *qmp_query_blockstat(const BlockDriverState *bs, Error **errp)
1.1.1.14  root     1888: {
1.1.1.22! root     1889:     BlockStats *s;
1.1.1.18  root     1890: 
1.1.1.22! root     1891:     s = g_malloc0(sizeof(*s));
1.1.1.18  root     1892: 
1.1.1.22! root     1893:     if (bs->device_name[0]) {
        !          1894:         s->has_device = true;
        !          1895:         s->device = g_strdup(bs->device_name);
1.1.1.18  root     1896:     }
                   1897: 
1.1.1.22! root     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: 
1.1.1.18  root     1909:     if (bs->file) {
1.1.1.22! root     1910:         s->has_parent = true;
        !          1911:         s->parent = qmp_query_blockstat(bs->file, NULL);
1.1.1.18  root     1912:     }
                   1913: 
1.1.1.22! root     1914:     return s;
1.1.1.18  root     1915: }
                   1916: 
1.1.1.22! root     1917: BlockStatsList *qmp_query_blockstats(Error **errp)
1.1.1.6   root     1918: {
1.1.1.22! root     1919:     BlockStatsList *head = NULL, *cur_item = NULL;
1.1.1.6   root     1920:     BlockDriverState *bs;
                   1921: 
1.1.1.18  root     1922:     QTAILQ_FOREACH(bs, &bdrv_states, list) {
1.1.1.22! root     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:         }
1.1.1.6   root     1933:     }
1.1.1.14  root     1934: 
1.1.1.22! root     1935:     return head;
1.1.1.6   root     1936: }
                   1937: 
1.1.1.8   root     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: 
1.1.1.6   root     1948: void bdrv_get_backing_filename(BlockDriverState *bs,
1.1.1.5   root     1949:                                char *filename, int filename_size)
                   1950: {
1.1.1.22! root     1951:     pstrcpy(filename, filename_size, bs->backing_file);
1.1.1.5   root     1952: }
                   1953: 
1.1.1.6   root     1954: int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1.1.1.5   root     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;
1.1.1.11  root     1962:     if (bdrv_check_request(bs, sector_num, nb_sectors))
                   1963:         return -EIO;
1.1.1.14  root     1964: 
                   1965:     if (bs->dirty_bitmap) {
                   1966:         set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
                   1967:     }
                   1968: 
1.1.1.5   root     1969:     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
                   1970: }
1.1.1.6   root     1971: 
1.1.1.5   root     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: 
1.1.1.13  root     1983: int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                   1984:                       int64_t pos, int size)
1.1.1.9   root     1985: {
                   1986:     BlockDriver *drv = bs->drv;
                   1987:     if (!drv)
                   1988:         return -ENOMEDIUM;
1.1.1.18  root     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;
1.1.1.9   root     1994: }
                   1995: 
1.1.1.13  root     1996: int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                   1997:                       int64_t pos, int size)
1.1.1.9   root     1998: {
                   1999:     BlockDriver *drv = bs->drv;
                   2000:     if (!drv)
                   2001:         return -ENOMEDIUM;
1.1.1.18  root     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: 
1.1.1.9   root     2019: }
                   2020: 
1.1       root     2021: /**************************************************************/
1.1.1.5   root     2022: /* handling of snapshots */
1.1       root     2023: 
1.1.1.18  root     2024: int bdrv_can_snapshot(BlockDriverState *bs)
                   2025: {
                   2026:     BlockDriver *drv = bs->drv;
1.1.1.22! root     2027:     if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
1.1.1.18  root     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: 
1.1.1.6   root     2064: int bdrv_snapshot_create(BlockDriverState *bs,
1.1.1.5   root     2065:                          QEMUSnapshotInfo *sn_info)
                   2066: {
                   2067:     BlockDriver *drv = bs->drv;
                   2068:     if (!drv)
                   2069:         return -ENOMEDIUM;
1.1.1.18  root     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;
1.1.1.5   root     2075: }
1.1       root     2076: 
1.1.1.6   root     2077: int bdrv_snapshot_goto(BlockDriverState *bs,
1.1.1.5   root     2078:                        const char *snapshot_id)
1.1       root     2079: {
1.1.1.5   root     2080:     BlockDriver *drv = bs->drv;
1.1.1.18  root     2081:     int ret, open_ret;
                   2082: 
1.1.1.5   root     2083:     if (!drv)
                   2084:         return -ENOMEDIUM;
1.1.1.18  root     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;
1.1       root     2101: }
                   2102: 
1.1.1.5   root     2103: int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1.1       root     2104: {
1.1.1.5   root     2105:     BlockDriver *drv = bs->drv;
                   2106:     if (!drv)
                   2107:         return -ENOMEDIUM;
1.1.1.18  root     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;
1.1.1.5   root     2113: }
1.1       root     2114: 
1.1.1.6   root     2115: int bdrv_snapshot_list(BlockDriverState *bs,
1.1.1.5   root     2116:                        QEMUSnapshotInfo **psn_info)
                   2117: {
                   2118:     BlockDriver *drv = bs->drv;
                   2119:     if (!drv)
                   2120:         return -ENOMEDIUM;
1.1.1.18  root     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;
1.1.1.5   root     2126: }
                   2127: 
1.1.1.19  root     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: 
1.1.1.5   root     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)) {
1.1.1.6   root     2158:                 snprintf(buf, buf_size, "%0.1f%c",
1.1.1.5   root     2159:                          (double)size / base,
                   2160:                          suffixes[i]);
                   2161:                 break;
                   2162:             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1.1.1.6   root     2163:                 snprintf(buf, buf_size, "%" PRId64 "%c",
1.1.1.5   root     2164:                          ((size + (base >> 1)) / base),
                   2165:                          suffixes[i]);
                   2166:                 break;
                   2167:             }
                   2168:             base = base * 1024;
                   2169:         }
1.1       root     2170:     }
1.1.1.5   root     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;
1.1.1.2   root     2179: #else
1.1.1.5   root     2180:     struct tm tm;
1.1.1.2   root     2181: #endif
1.1.1.5   root     2182:     time_t ti;
                   2183:     int64_t secs;
                   2184: 
                   2185:     if (!sn) {
1.1.1.6   root     2186:         snprintf(buf, buf_size,
                   2187:                  "%-10s%-20s%7s%20s%15s",
1.1.1.5   root     2188:                  "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
                   2189:     } else {
                   2190:         ti = sn->date_sec;
1.1       root     2191: #ifdef _WIN32
1.1.1.5   root     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);
1.1       root     2199: #endif
1.1.1.5   root     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),
1.1.1.6   root     2205:                  (int)(secs % 60),
1.1.1.5   root     2206:                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
                   2207:         snprintf(buf, buf_size,
1.1.1.6   root     2208:                  "%-10s%-20s%7s%20s%15s",
1.1.1.5   root     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;
1.1       root     2215: }
                   2216: 
1.1.1.5   root     2217: /**************************************************************/
                   2218: /* async I/Os */
                   2219: 
1.1.1.7   root     2220: BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1.1.1.13  root     2221:                                  QEMUIOVector *qiov, int nb_sectors,
1.1.1.7   root     2222:                                  BlockDriverCompletionFunc *cb, void *opaque)
                   2223: {
1.1.1.19  root     2224:     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
                   2225: 
1.1.1.22! root     2226:     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
        !          2227:                                  cb, opaque, false);
1.1.1.19  root     2228: }
                   2229: 
1.1.1.13  root     2230: BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
                   2231:                                   QEMUIOVector *qiov, int nb_sectors,
                   2232:                                   BlockDriverCompletionFunc *cb, void *opaque)
1.1       root     2233: {
1.1.1.19  root     2234:     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
1.1       root     2235: 
1.1.1.22! root     2236:     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
        !          2237:                                  cb, opaque, true);
1.1.1.5   root     2238: }
                   2239: 
1.1.1.14  root     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);
1.1.1.16  root     2259:         if (mcb->callbacks[i].free_qiov) {
                   2260:             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
                   2261:         }
1.1.1.22! root     2262:         g_free(mcb->callbacks[i].free_qiov);
1.1.1.15  root     2263:         qemu_vfree(mcb->callbacks[i].free_buf);
1.1.1.14  root     2264:     }
                   2265: }
                   2266: 
                   2267: static void multiwrite_cb(void *opaque, int ret)
                   2268: {
                   2269:     MultiwriteCB *mcb = opaque;
                   2270: 
1.1.1.19  root     2271:     trace_multiwrite_cb(mcb, ret);
                   2272: 
1.1.1.16  root     2273:     if (ret < 0 && !mcb->error) {
1.1.1.14  root     2274:         mcb->error = ret;
                   2275:     }
                   2276: 
                   2277:     mcb->num_requests--;
                   2278:     if (mcb->num_requests == 0) {
1.1.1.17  root     2279:         multiwrite_user_cb(mcb);
1.1.1.22! root     2280:         g_free(mcb);
1.1.1.14  root     2281:     }
                   2282: }
                   2283: 
                   2284: static int multiwrite_req_compare(const void *a, const void *b)
                   2285: {
1.1.1.17  root     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:     }
1.1.1.14  root     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: 
1.1.1.16  root     2334:         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
                   2335:             merge = 0;
                   2336:         }
                   2337: 
1.1.1.14  root     2338:         if (merge) {
                   2339:             size_t size;
1.1.1.22! root     2340:             QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
1.1.1.14  root     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: 
1.1.1.17  root     2361:             reqs[outidx].nb_sectors = qiov->size >> 9;
1.1.1.14  root     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: 
1.1.1.20  root     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: 
1.1.1.14  root     2404:     if (num_reqs == 0) {
                   2405:         return 0;
                   2406:     }
                   2407: 
                   2408:     // Create MultiwriteCB structure
1.1.1.22! root     2409:     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
1.1.1.14  root     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: 
1.1.1.19  root     2421:     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
                   2422: 
1.1.1.17  root     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: 
1.1.1.19  root     2444:     // Run the aio requests
1.1.1.14  root     2445:     for (i = 0; i < num_reqs; i++) {
1.1.1.17  root     2446:         mcb->num_requests++;
1.1.1.14  root     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.
1.1.1.17  root     2454:             if (i == 0) {
1.1.1.19  root     2455:                 trace_bdrv_aio_multiwrite_earlyfail(mcb);
1.1.1.14  root     2456:                 goto fail;
                   2457:             } else {
1.1.1.19  root     2458:                 trace_bdrv_aio_multiwrite_latefail(mcb, i);
1.1.1.16  root     2459:                 multiwrite_cb(mcb, -EIO);
1.1.1.14  root     2460:                 break;
                   2461:             }
                   2462:         }
                   2463:     }
                   2464: 
1.1.1.17  root     2465:     /* Complete the dummy request */
                   2466:     multiwrite_cb(mcb, 0);
                   2467: 
1.1.1.14  root     2468:     return 0;
                   2469: 
                   2470: fail:
1.1.1.17  root     2471:     for (i = 0; i < mcb->num_callbacks; i++) {
                   2472:         reqs[i].error = -EIO;
                   2473:     }
1.1.1.22! root     2474:     g_free(mcb);
1.1.1.14  root     2475:     return -1;
                   2476: }
                   2477: 
1.1.1.5   root     2478: void bdrv_aio_cancel(BlockDriverAIOCB *acb)
1.1.1.4   root     2479: {
1.1.1.10  root     2480:     acb->pool->cancel(acb);
1.1.1.5   root     2481: }
1.1.1.4   root     2482: 
                   2483: 
1.1.1.5   root     2484: /**************************************************************/
                   2485: /* async block device emulation */
1.1.1.4   root     2486: 
1.1.1.13  root     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: {
1.1.1.18  root     2499:     BlockDriverAIOCBSync *acb =
                   2500:         container_of(blockacb, BlockDriverAIOCBSync, common);
1.1.1.13  root     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: 
1.1.1.5   root     2511: static void bdrv_aio_bh_cb(void *opaque)
1.1.1.4   root     2512: {
1.1.1.5   root     2513:     BlockDriverAIOCBSync *acb = opaque;
1.1.1.13  root     2514: 
                   2515:     if (!acb->is_write)
                   2516:         qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size);
                   2517:     qemu_vfree(acb->bounce);
1.1.1.5   root     2518:     acb->common.cb(acb->common.opaque, acb->ret);
1.1.1.13  root     2519:     qemu_bh_delete(acb->bh);
                   2520:     acb->bh = NULL;
1.1.1.5   root     2521:     qemu_aio_release(acb);
1.1.1.4   root     2522: }
                   2523: 
1.1.1.13  root     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: 
1.1       root     2532: {
1.1.1.5   root     2533:     BlockDriverAIOCBSync *acb;
1.1       root     2534: 
1.1.1.13  root     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: 
1.1.1.5   root     2540:     if (!acb->bh)
                   2541:         acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
1.1.1.13  root     2542: 
                   2543:     if (is_write) {
                   2544:         qemu_iovec_to_buffer(acb->qiov, acb->bounce);
1.1.1.22! root     2545:         acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
1.1.1.13  root     2546:     } else {
1.1.1.22! root     2547:         acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
1.1.1.13  root     2548:     }
                   2549: 
1.1.1.5   root     2550:     qemu_bh_schedule(acb->bh);
1.1.1.13  root     2551: 
1.1.1.5   root     2552:     return &acb->common;
                   2553: }
1.1       root     2554: 
1.1.1.13  root     2555: static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
                   2556:         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1.1.1.5   root     2557:         BlockDriverCompletionFunc *cb, void *opaque)
                   2558: {
1.1.1.13  root     2559:     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
1.1.1.5   root     2560: }
                   2561: 
1.1.1.13  root     2562: static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
                   2563:         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
                   2564:         BlockDriverCompletionFunc *cb, void *opaque)
1.1.1.5   root     2565: {
1.1.1.13  root     2566:     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
1.1       root     2567: }
                   2568: 
1.1.1.22! root     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)
1.1.1.14  root     2578: {
1.1.1.22! root     2579:     qemu_aio_flush();
        !          2580: }
1.1.1.14  root     2581: 
1.1.1.22! root     2582: static AIOPool bdrv_em_co_aio_pool = {
        !          2583:     .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
        !          2584:     .cancel             = bdrv_aio_co_cancel_em,
        !          2585: };
1.1.1.14  root     2586: 
1.1.1.22! root     2587: static void bdrv_co_em_bh(void *opaque)
        !          2588: {
        !          2589:     BlockDriverAIOCBCoroutine *acb = opaque;
1.1.1.14  root     2590: 
1.1.1.22! root     2591:     acb->common.cb(acb->common.opaque, acb->req.error);
        !          2592:     qemu_bh_delete(acb->bh);
        !          2593:     qemu_aio_release(acb);
1.1.1.14  root     2594: }
                   2595: 
1.1.1.22! root     2596: /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
        !          2597: static void coroutine_fn bdrv_co_do_rw(void *opaque)
1.1.1.18  root     2598: {
1.1.1.22! root     2599:     BlockDriverAIOCBCoroutine *acb = opaque;
        !          2600:     BlockDriverState *bs = acb->common.bs;
1.1.1.18  root     2601: 
1.1.1.22! root     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);
1.1.1.18  root     2608:     }
                   2609: 
1.1.1.22! root     2610:     acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
1.1.1.18  root     2611:     qemu_bh_schedule(acb->bh);
                   2612: }
                   2613: 
1.1.1.22! root     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;
1.1.1.5   root     2630: 
1.1.1.22! root     2631:     co = qemu_coroutine_create(bdrv_co_do_rw);
        !          2632:     qemu_coroutine_enter(co, acb);
        !          2633: 
        !          2634:     return &acb->common;
1.1.1.4   root     2635: }
                   2636: 
1.1.1.22! root     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: }
1.1.1.5   root     2646: 
1.1.1.22! root     2647: BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
        !          2648:         BlockDriverCompletionFunc *cb, void *opaque)
1.1.1.5   root     2649: {
1.1.1.22! root     2650:     trace_bdrv_aio_flush(bs, opaque);
1.1.1.5   root     2651: 
1.1.1.22! root     2652:     Coroutine *co;
        !          2653:     BlockDriverAIOCBCoroutine *acb;
1.1.1.14  root     2654: 
1.1.1.22! root     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);
1.1.1.7   root     2658: 
1.1.1.22! root     2659:     return &acb->common;
        !          2660: }
1.1.1.7   root     2661: 
1.1.1.22! root     2662: static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
        !          2663: {
        !          2664:     BlockDriverAIOCBCoroutine *acb = opaque;
        !          2665:     BlockDriverState *bs = acb->common.bs;
1.1.1.14  root     2666: 
1.1.1.22! root     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);
1.1.1.5   root     2670: }
                   2671: 
1.1.1.22! root     2672: BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
        !          2673:         int64_t sector_num, int nb_sectors,
        !          2674:         BlockDriverCompletionFunc *cb, void *opaque)
1.1.1.5   root     2675: {
1.1.1.22! root     2676:     Coroutine *co;
        !          2677:     BlockDriverAIOCBCoroutine *acb;
1.1.1.5   root     2678: 
1.1.1.22! root     2679:     trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
1.1.1.14  root     2680: 
1.1.1.22! root     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);
1.1.1.14  root     2686: 
1.1.1.22! root     2687:     return &acb->common;
1.1.1.5   root     2688: }
1.1       root     2689: 
                   2690: void bdrv_init(void)
                   2691: {
1.1.1.13  root     2692:     module_call_init(MODULE_INIT_BLOCK);
1.1.1.10  root     2693: }
                   2694: 
1.1.1.14  root     2695: void bdrv_init_with_whitelist(void)
                   2696: {
                   2697:     use_bdrv_whitelist = 1;
                   2698:     bdrv_init();
                   2699: }
                   2700: 
1.1.1.13  root     2701: void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
                   2702:                    BlockDriverCompletionFunc *cb, void *opaque)
1.1.1.5   root     2703: {
                   2704:     BlockDriverAIOCB *acb;
                   2705: 
1.1.1.10  root     2706:     if (pool->free_aiocb) {
                   2707:         acb = pool->free_aiocb;
                   2708:         pool->free_aiocb = acb->next;
1.1.1.5   root     2709:     } else {
1.1.1.22! root     2710:         acb = g_malloc0(pool->aiocb_size);
1.1.1.10  root     2711:         acb->pool = pool;
1.1.1.5   root     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: {
1.1.1.10  root     2721:     BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p;
                   2722:     AIOPool *pool = acb->pool;
                   2723:     acb->next = pool->free_aiocb;
                   2724:     pool->free_aiocb = acb;
1.1.1.5   root     2725: }
                   2726: 
                   2727: /**************************************************************/
1.1.1.22! root     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: /**************************************************************/
1.1.1.5   root     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;
1.1.1.22! root     2950: 
1.1.1.5   root     2951:     if (!drv)
                   2952:         return 0;
                   2953:     if (!drv->bdrv_is_inserted)
1.1.1.22! root     2954:         return 1;
        !          2955:     return drv->bdrv_is_inserted(bs);
1.1.1.5   root     2956: }
                   2957: 
                   2958: /**
1.1.1.22! root     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.
1.1.1.5   root     2961:  */
                   2962: int bdrv_media_changed(BlockDriverState *bs)
                   2963: {
                   2964:     BlockDriver *drv = bs->drv;
                   2965: 
1.1.1.22! root     2966:     if (drv && drv->bdrv_media_changed) {
        !          2967:         return drv->bdrv_media_changed(bs);
        !          2968:     }
        !          2969:     return -ENOTSUP;
1.1.1.5   root     2970: }
                   2971: 
                   2972: /**
                   2973:  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
                   2974:  */
1.1.1.22! root     2975: void bdrv_eject(BlockDriverState *bs, int eject_flag)
1.1.1.5   root     2976: {
                   2977:     BlockDriver *drv = bs->drv;
                   2978: 
1.1.1.22! root     2979:     if (drv && drv->bdrv_eject) {
        !          2980:         drv->bdrv_eject(bs, eject_flag);
1.1.1.13  root     2981:     }
1.1.1.5   root     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:  */
1.1.1.22! root     2988: void bdrv_lock_medium(BlockDriverState *bs, bool locked)
1.1.1.5   root     2989: {
                   2990:     BlockDriver *drv = bs->drv;
                   2991: 
1.1.1.22! root     2992:     trace_bdrv_lock_medium(bs, locked);
1.1.1.21  root     2993: 
1.1.1.22! root     2994:     if (drv && drv->bdrv_lock_medium) {
        !          2995:         drv->bdrv_lock_medium(bs, locked);
1.1.1.5   root     2996:     }
1.1       root     2997: }
1.1.1.6   root     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: }
1.1.1.13  root     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: 
1.1.1.22! root     3021: void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
        !          3022: {
        !          3023:     bs->buffer_alignment = align;
        !          3024: }
1.1.1.14  root     3025: 
1.1.1.13  root     3026: void *qemu_blockalign(BlockDriverState *bs, size_t size)
                   3027: {
                   3028:     return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
                   3029: }
1.1.1.14  root     3030: 
                   3031: void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
                   3032: {
                   3033:     int64_t bitmap_size;
                   3034: 
1.1.1.18  root     3035:     bs->dirty_count = 0;
1.1.1.14  root     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: 
1.1.1.22! root     3042:             bs->dirty_bitmap = g_malloc0(bitmap_size);
1.1.1.14  root     3043:         }
                   3044:     } else {
                   3045:         if (bs->dirty_bitmap) {
1.1.1.22! root     3046:             g_free(bs->dirty_bitmap);
1.1.1.14  root     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)) {
1.1.1.19  root     3058:         return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
                   3059:             (1UL << (chunk % (sizeof(unsigned long) * 8))));
1.1.1.14  root     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: }
1.1.1.18  root     3070: 
                   3071: int64_t bdrv_get_dirty_count(BlockDriverState *bs)
                   3072: {
                   3073:     return bs->dirty_count;
                   3074: }
1.1.1.19  root     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: 
1.1.1.22! root     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: 
1.1.1.19  root     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;
1.1.1.21  root     3154:     QEMUOptionParameter *backing_fmt, *backing_file, *size;
1.1.1.19  root     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
1.1.1.21  root     3237:     size = get_option_parameter(param, BLOCK_OPT_SIZE);
                   3238:     if (size && size->value.n == -1) {
1.1.1.19  root     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