block/raw.c

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