Statistics
| Branch: | Revision:

root / block / raw.c @ bb8bf76f

History | View | Annotate | Download (3.9 kB)

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 int raw_flush(BlockDriverState *bs)
43
{
44
    return 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_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
69
{
70
    return bdrv_discard(bs->file, sector_num, nb_sectors);
71
}
72

    
73
static int raw_is_inserted(BlockDriverState *bs)
74
{
75
    return bdrv_is_inserted(bs->file);
76
}
77

    
78
static int raw_eject(BlockDriverState *bs, int eject_flag)
79
{
80
    return bdrv_eject(bs->file, eject_flag);
81
}
82

    
83
static int raw_set_locked(BlockDriverState *bs, int locked)
84
{
85
    bdrv_set_locked(bs->file, locked);
86
    return 0;
87
}
88

    
89
static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
90
{
91
   return bdrv_ioctl(bs->file, req, buf);
92
}
93

    
94
static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs,
95
        unsigned long int req, void *buf,
96
        BlockDriverCompletionFunc *cb, void *opaque)
97
{
98
   return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque);
99
}
100

    
101
static int raw_create(const char *filename, QEMUOptionParameter *options)
102
{
103
    return bdrv_create_file(filename, options);
104
}
105

    
106
static QEMUOptionParameter raw_create_options[] = {
107
    {
108
        .name = BLOCK_OPT_SIZE,
109
        .type = OPT_SIZE,
110
        .help = "Virtual disk size"
111
    },
112
    { NULL }
113
};
114

    
115
static int raw_has_zero_init(BlockDriverState *bs)
116
{
117
    return bdrv_has_zero_init(bs->file);
118
}
119

    
120
static BlockDriver bdrv_raw = {
121
    .format_name        = "raw",
122

    
123
    /* It's really 0, but we need to make qemu_malloc() happy */
124
    .instance_size      = 1,
125

    
126
    .bdrv_open          = raw_open,
127
    .bdrv_close         = raw_close,
128
    .bdrv_read          = raw_read,
129
    .bdrv_write         = raw_write,
130
    .bdrv_flush         = raw_flush,
131
    .bdrv_probe         = raw_probe,
132
    .bdrv_getlength     = raw_getlength,
133
    .bdrv_truncate      = raw_truncate,
134

    
135
    .bdrv_aio_readv     = raw_aio_readv,
136
    .bdrv_aio_writev    = raw_aio_writev,
137
    .bdrv_aio_flush     = raw_aio_flush,
138
    .bdrv_discard       = raw_discard,
139

    
140
    .bdrv_is_inserted   = raw_is_inserted,
141
    .bdrv_eject         = raw_eject,
142
    .bdrv_set_locked    = raw_set_locked,
143
    .bdrv_ioctl         = raw_ioctl,
144
    .bdrv_aio_ioctl     = raw_aio_ioctl,
145

    
146
    .bdrv_create        = raw_create,
147
    .create_options     = raw_create_options,
148
    .bdrv_has_zero_init = raw_has_zero_init,
149
};
150

    
151
static void bdrv_raw_init(void)
152
{
153
    bdrv_register(&bdrv_raw);
154
}
155

    
156
block_init(bdrv_raw_init);