]>
Commit | Line | Data |
---|---|---|
84a12e66 CH |
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); |