Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu.git] / block / raw_bsd.c
1 /* BlockDriver implementation for "raw"
2 *
3 * Copyright (C) 2010, 2013, Red Hat, Inc.
4 * Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>
5 * Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>
6 *
7 * Author:
8 * Laszlo Ersek <lersek@redhat.com>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to
12 * deal in the Software without restriction, including without limitation the
13 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
14 * sell copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
26 * IN THE SOFTWARE.
27 */
28
29 #include "block/block_int.h"
30 #include "qemu/option.h"
31
32 static QEMUOptionParameter raw_create_options[] = {
33 {
34 .name = BLOCK_OPT_SIZE,
35 .type = OPT_SIZE,
36 .help = "Virtual disk size"
37 },
38 { 0 }
39 };
40
41 static int raw_reopen_prepare(BDRVReopenState *reopen_state,
42 BlockReopenQueue *queue, Error **errp)
43 {
44 return 0;
45 }
46
47 static int coroutine_fn raw_co_readv(BlockDriverState *bs, int64_t sector_num,
48 int nb_sectors, QEMUIOVector *qiov)
49 {
50 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
51 return bdrv_co_readv(bs->file, sector_num, nb_sectors, qiov);
52 }
53
54 static int coroutine_fn raw_co_writev(BlockDriverState *bs, int64_t sector_num,
55 int nb_sectors, QEMUIOVector *qiov)
56 {
57 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
58 return bdrv_co_writev(bs->file, sector_num, nb_sectors, qiov);
59 }
60
61 static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
62 int64_t sector_num,
63 int nb_sectors, int *pnum)
64 {
65 *pnum = nb_sectors;
66 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |
67 (sector_num << BDRV_SECTOR_BITS);
68 }
69
70 static int coroutine_fn raw_co_write_zeroes(BlockDriverState *bs,
71 int64_t sector_num, int nb_sectors,
72 BdrvRequestFlags flags)
73 {
74 return bdrv_co_write_zeroes(bs->file, sector_num, nb_sectors, flags);
75 }
76
77 static int coroutine_fn raw_co_discard(BlockDriverState *bs,
78 int64_t sector_num, int nb_sectors)
79 {
80 return bdrv_co_discard(bs->file, sector_num, nb_sectors);
81 }
82
83 static int64_t raw_getlength(BlockDriverState *bs)
84 {
85 return bdrv_getlength(bs->file);
86 }
87
88 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
89 {
90 return bdrv_get_info(bs->file, bdi);
91 }
92
93 static int raw_refresh_limits(BlockDriverState *bs)
94 {
95 bs->bl = bs->file->bl;
96 return 0;
97 }
98
99 static int raw_truncate(BlockDriverState *bs, int64_t offset)
100 {
101 return bdrv_truncate(bs->file, offset);
102 }
103
104 static int raw_is_inserted(BlockDriverState *bs)
105 {
106 return bdrv_is_inserted(bs->file);
107 }
108
109 static int raw_media_changed(BlockDriverState *bs)
110 {
111 return bdrv_media_changed(bs->file);
112 }
113
114 static void raw_eject(BlockDriverState *bs, bool eject_flag)
115 {
116 bdrv_eject(bs->file, eject_flag);
117 }
118
119 static void raw_lock_medium(BlockDriverState *bs, bool locked)
120 {
121 bdrv_lock_medium(bs->file, locked);
122 }
123
124 static int raw_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
125 {
126 return bdrv_ioctl(bs->file, req, buf);
127 }
128
129 static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState *bs,
130 unsigned long int req, void *buf,
131 BlockDriverCompletionFunc *cb,
132 void *opaque)
133 {
134 return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque);
135 }
136
137 static int raw_has_zero_init(BlockDriverState *bs)
138 {
139 return bdrv_has_zero_init(bs->file);
140 }
141
142 static int raw_create(const char *filename, QEMUOptionParameter *options,
143 Error **errp)
144 {
145 Error *local_err = NULL;
146 int ret;
147
148 ret = bdrv_create_file(filename, options, &local_err);
149 if (local_err) {
150 error_propagate(errp, local_err);
151 }
152 return ret;
153 }
154
155 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
156 Error **errp)
157 {
158 bs->sg = bs->file->sg;
159 return 0;
160 }
161
162 static void raw_close(BlockDriverState *bs)
163 {
164 }
165
166 static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
167 {
168 /* smallest possible positive score so that raw is used if and only if no
169 * other block driver works
170 */
171 return 1;
172 }
173
174 static BlockDriver bdrv_raw = {
175 .format_name = "raw",
176 .bdrv_probe = &raw_probe,
177 .bdrv_reopen_prepare = &raw_reopen_prepare,
178 .bdrv_open = &raw_open,
179 .bdrv_close = &raw_close,
180 .bdrv_create = &raw_create,
181 .bdrv_co_readv = &raw_co_readv,
182 .bdrv_co_writev = &raw_co_writev,
183 .bdrv_co_write_zeroes = &raw_co_write_zeroes,
184 .bdrv_co_discard = &raw_co_discard,
185 .bdrv_co_get_block_status = &raw_co_get_block_status,
186 .bdrv_truncate = &raw_truncate,
187 .bdrv_getlength = &raw_getlength,
188 .has_variable_length = true,
189 .bdrv_get_info = &raw_get_info,
190 .bdrv_refresh_limits = &raw_refresh_limits,
191 .bdrv_is_inserted = &raw_is_inserted,
192 .bdrv_media_changed = &raw_media_changed,
193 .bdrv_eject = &raw_eject,
194 .bdrv_lock_medium = &raw_lock_medium,
195 .bdrv_ioctl = &raw_ioctl,
196 .bdrv_aio_ioctl = &raw_aio_ioctl,
197 .create_options = &raw_create_options[0],
198 .bdrv_has_zero_init = &raw_has_zero_init
199 };
200
201 static void bdrv_raw_init(void)
202 {
203 bdrv_register(&bdrv_raw);
204 }
205
206 block_init(bdrv_raw_init);