Annotation of qemu/block.c, revision 1.1.1.17

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

unix.superglobalmegacorp.com