Annotation of qemu/block.c, revision 1.1.1.21

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

unix.superglobalmegacorp.com