Return to raw.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / block

Annotation of qemu/block/raw.c, revision 1.1

1.1     ! root        1: 
        !             2: #include "qemu-common.h"
        !             3: #include "block_int.h"
        !             4: #include "module.h"
        !             5: 
        !             6: static int raw_open(BlockDriverState *bs, int flags)
        !             7: {
        !             8:     bs->sg = bs->file->sg;
        !             9:     return 0;
        !            10: }
        !            11: 
        !            12: static int raw_read(BlockDriverState *bs, int64_t sector_num,
        !            13:                     uint8_t *buf, int nb_sectors)
        !            14: {
        !            15:     return bdrv_read(bs->file, sector_num, buf, nb_sectors);
        !            16: }
        !            17: 
        !            18: static int raw_write(BlockDriverState *bs, int64_t sector_num,
        !            19:                      const uint8_t *buf, int nb_sectors)
        !            20: {
        !            21:     return bdrv_write(bs->file, sector_num, buf, nb_sectors);
        !            22: }
        !            23: 
        !            24: static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
        !            25:     int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        !            26:     BlockDriverCompletionFunc *cb, void *opaque)
        !            27: {
        !            28:     return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque);
        !            29: }
        !            30: 
        !            31: static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs,
        !            32:     int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        !            33:     BlockDriverCompletionFunc *cb, void *opaque)
        !            34: {
        !            35:     return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque);
        !            36: }
        !            37: 
        !            38: static void raw_close(BlockDriverState *bs)
        !            39: {
        !            40: }
        !            41: 
        !            42: static void raw_flush(BlockDriverState *bs)
        !            43: {
        !            44:     bdrv_flush(bs->file);
        !            45: }
        !            46: 
        !            47: static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs,
        !            48:     BlockDriverCompletionFunc *cb, void *opaque)
        !            49: {
        !            50:     return bdrv_aio_flush(bs->file, cb, opaque);
        !            51: }
        !            52: 
        !            53: static int64_t raw_getlength(BlockDriverState *bs)
        !            54: {
        !            55:     return bdrv_getlength(bs->file);
        !            56: }
        !            57: 
        !            58: static int raw_truncate(BlockDriverState *bs, int64_t offset)
        !            59: {
        !            60:     return bdrv_truncate(bs->file, offset);
        !            61: }
        !            62: 
        !            63: static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
        !            64: {
        !            65:    return 1; /* everything can be opened as raw image */
        !            66: }
        !            67: 
        !            68: static int raw_is_inserted(BlockDriverState *bs)
        !            69: {
        !            70:     return bdrv_is_inserted(bs->file);
        !            71: }
        !            72: 
        !            73: static int raw_eject(BlockDriverState *bs, int eject_flag)
        !            74: {
        !            75:     return bdrv_eject(bs->file, eject_flag);
        !            76: }
        !            77: 
        !            78: static int raw_set_locked(BlockDriverState *bs, int locked)
        !            79: {
        !            80:     bdrv_set_locked(bs->file, locked);
        !            81:     return 0;
        !            82: }
        !            83: 
        !            84: static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
        !            85: {
        !            86:    return bdrv_ioctl(bs->file, req, buf);
        !            87: }
        !            88: 
        !            89: static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs,
        !            90:         unsigned long int req, void *buf,
        !            91:         BlockDriverCompletionFunc *cb, void *opaque)
        !            92: {
        !            93:    return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque);
        !            94: }
        !            95: 
        !            96: static int raw_create(const char *filename, QEMUOptionParameter *options)
        !            97: {
        !            98:     return bdrv_create_file(filename, options);
        !            99: }
        !           100: 
        !           101: static QEMUOptionParameter raw_create_options[] = {
        !           102:     {
        !           103:         .name = BLOCK_OPT_SIZE,
        !           104:         .type = OPT_SIZE,
        !           105:         .help = "Virtual disk size"
        !           106:     },
        !           107:     { NULL }
        !           108: };
        !           109: 
        !           110: static int raw_has_zero_init(BlockDriverState *bs)
        !           111: {
        !           112:     return bdrv_has_zero_init(bs->file);
        !           113: }
        !           114: 
        !           115: static BlockDriver bdrv_raw = {
        !           116:     .format_name        = "raw",
        !           117: 
        !           118:     /* It's really 0, but we need to make qemu_malloc() happy */
        !           119:     .instance_size      = 1,
        !           120: 
        !           121:     .bdrv_open          = raw_open,
        !           122:     .bdrv_close         = raw_close,
        !           123:     .bdrv_read          = raw_read,
        !           124:     .bdrv_write         = raw_write,
        !           125:     .bdrv_flush         = raw_flush,
        !           126:     .bdrv_probe         = raw_probe,
        !           127:     .bdrv_getlength     = raw_getlength,
        !           128:     .bdrv_truncate      = raw_truncate,
        !           129: 
        !           130:     .bdrv_aio_readv     = raw_aio_readv,
        !           131:     .bdrv_aio_writev    = raw_aio_writev,
        !           132:     .bdrv_aio_flush     = raw_aio_flush,
        !           133: 
        !           134:     .bdrv_is_inserted   = raw_is_inserted,
        !           135:     .bdrv_eject         = raw_eject,
        !           136:     .bdrv_set_locked    = raw_set_locked,
        !           137:     .bdrv_ioctl         = raw_ioctl,
        !           138:     .bdrv_aio_ioctl     = raw_aio_ioctl,
        !           139: 
        !           140:     .bdrv_create        = raw_create,
        !           141:     .create_options     = raw_create_options,
        !           142:     .bdrv_has_zero_init = raw_has_zero_init,
        !           143: };
        !           144: 
        !           145: static void bdrv_raw_init(void)
        !           146: {
        !           147:     bdrv_register(&bdrv_raw);
        !           148: }
        !           149: 
        !           150: block_init(bdrv_raw_init);

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.