blob: 124a9ebf65cd6830ca691c0642a1a57960436354 [file] [log] [blame]
bellardfc01f7e2003-06-30 10:03:06 +00001/*
2 * QEMU System Emulator block driver
ths5fafdf22007-09-16 21:08:06 +00003 *
bellardfc01f7e2003-06-30 10:03:06 +00004 * Copyright (c) 2003 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellardfc01f7e2003-06-30 10:03:06 +00006 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
blueswir13990d092008-12-05 17:53:21 +000024#include "config-host.h"
pbrookfaf07962007-11-11 02:51:17 +000025#include "qemu-common.h"
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010026#include "trace.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010027#include "monitor/monitor.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010028#include "block/block_int.h"
29#include "block/blockjob.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/module.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010031#include "qapi/qmp/qjson.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010032#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010033#include "qemu/notify.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010034#include "block/coroutine.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030035#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/timer.h"
bellardfc01f7e2003-06-30 10:03:06 +000037
Juan Quintela71e72a12009-07-27 16:12:56 +020038#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000039#include <sys/types.h>
40#include <sys/stat.h>
41#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000042#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000043#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000044#include <sys/disk.h>
45#endif
blueswir1c5e97232009-03-07 20:06:23 +000046#endif
bellard7674e7b2005-04-26 21:59:26 +000047
aliguori49dc7682009-03-08 16:26:59 +000048#ifdef _WIN32
49#include <windows.h>
50#endif
51
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010052#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
53
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000054typedef enum {
55 BDRV_REQ_COPY_ON_READ = 0x1,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +000056 BDRV_REQ_ZERO_WRITE = 0x2,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000057} BdrvRequestFlags;
58
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020059static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
aliguorif141eaf2009-04-07 18:43:24 +000060static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
61 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
aliguoric87c0672009-04-07 18:43:20 +000062 BlockDriverCompletionFunc *cb, void *opaque);
aliguorif141eaf2009-04-07 18:43:24 +000063static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
64 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +000065 BlockDriverCompletionFunc *cb, void *opaque);
Kevin Wolff9f05dc2011-07-15 13:50:26 +020066static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
67 int64_t sector_num, int nb_sectors,
68 QEMUIOVector *iov);
69static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
70 int64_t sector_num, int nb_sectors,
71 QEMUIOVector *iov);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +010072static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000073 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
74 BdrvRequestFlags flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010075static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +000076 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
77 BdrvRequestFlags flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010078static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
79 int64_t sector_num,
80 QEMUIOVector *qiov,
81 int nb_sectors,
82 BlockDriverCompletionFunc *cb,
83 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +010084 bool is_write);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010085static void coroutine_fn bdrv_co_do_rw(void *opaque);
Kevin Wolf621f0582012-03-20 15:12:58 +010086static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
87 int64_t sector_num, int nb_sectors);
bellardec530c82006-04-25 22:36:06 +000088
Zhi Yong Wu98f90db2011-11-08 13:00:14 +080089static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
90 bool is_write, double elapsed_time, uint64_t *wait);
91static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
92 double elapsed_time, uint64_t *wait);
93static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
94 bool is_write, int64_t *wait);
95
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +010096static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
97 QTAILQ_HEAD_INITIALIZER(bdrv_states);
blueswir17ee930d2008-09-17 19:04:14 +000098
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010099static QLIST_HEAD(, BlockDriver) bdrv_drivers =
100 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +0000101
Markus Armbrusterf9092b12010-06-25 10:33:39 +0200102/* The device to use for VM snapshots */
103static BlockDriverState *bs_snapshots;
104
Markus Armbrustereb852012009-10-27 18:41:44 +0100105/* If non-zero, use only whitelisted block drivers */
106static int use_bdrv_whitelist;
107
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000108#ifdef _WIN32
109static int is_windows_drive_prefix(const char *filename)
110{
111 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
112 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
113 filename[1] == ':');
114}
115
116int is_windows_drive(const char *filename)
117{
118 if (is_windows_drive_prefix(filename) &&
119 filename[2] == '\0')
120 return 1;
121 if (strstart(filename, "\\\\.\\", NULL) ||
122 strstart(filename, "//./", NULL))
123 return 1;
124 return 0;
125}
126#endif
127
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800128/* throttling disk I/O limits */
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800129void bdrv_io_limits_disable(BlockDriverState *bs)
130{
131 bs->io_limits_enabled = false;
132
133 while (qemu_co_queue_next(&bs->throttled_reqs));
134
135 if (bs->block_timer) {
136 qemu_del_timer(bs->block_timer);
137 qemu_free_timer(bs->block_timer);
138 bs->block_timer = NULL;
139 }
140
141 bs->slice_start = 0;
142 bs->slice_end = 0;
143 bs->slice_time = 0;
144 memset(&bs->io_base, 0, sizeof(bs->io_base));
145}
146
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800147static void bdrv_block_timer(void *opaque)
148{
149 BlockDriverState *bs = opaque;
150
151 qemu_co_queue_next(&bs->throttled_reqs);
152}
153
154void bdrv_io_limits_enable(BlockDriverState *bs)
155{
156 qemu_co_queue_init(&bs->throttled_reqs);
157 bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800158 bs->io_limits_enabled = true;
159}
160
161bool bdrv_io_limits_enabled(BlockDriverState *bs)
162{
163 BlockIOLimit *io_limits = &bs->io_limits;
164 return io_limits->bps[BLOCK_IO_LIMIT_READ]
165 || io_limits->bps[BLOCK_IO_LIMIT_WRITE]
166 || io_limits->bps[BLOCK_IO_LIMIT_TOTAL]
167 || io_limits->iops[BLOCK_IO_LIMIT_READ]
168 || io_limits->iops[BLOCK_IO_LIMIT_WRITE]
169 || io_limits->iops[BLOCK_IO_LIMIT_TOTAL];
170}
171
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800172static void bdrv_io_limits_intercept(BlockDriverState *bs,
173 bool is_write, int nb_sectors)
174{
175 int64_t wait_time = -1;
176
177 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
178 qemu_co_queue_wait(&bs->throttled_reqs);
179 }
180
181 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
182 * throttled requests will not be dequeued until the current request is
183 * allowed to be serviced. So if the current request still exceeds the
184 * limits, it will be inserted to the head. All requests followed it will
185 * be still in throttled_reqs queue.
186 */
187
188 while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {
189 qemu_mod_timer(bs->block_timer,
190 wait_time + qemu_get_clock_ns(vm_clock));
191 qemu_co_queue_wait_insert_head(&bs->throttled_reqs);
192 }
193
194 qemu_co_queue_next(&bs->throttled_reqs);
195}
196
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000197/* check if the path starts with "<protocol>:" */
198static int path_has_protocol(const char *path)
199{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200200 const char *p;
201
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000202#ifdef _WIN32
203 if (is_windows_drive(path) ||
204 is_windows_drive_prefix(path)) {
205 return 0;
206 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200207 p = path + strcspn(path, ":/\\");
208#else
209 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000210#endif
211
Paolo Bonzini947995c2012-05-08 16:51:48 +0200212 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000213}
214
bellard83f64092006-08-01 16:21:11 +0000215int path_is_absolute(const char *path)
216{
bellard21664422007-01-07 18:22:37 +0000217#ifdef _WIN32
218 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200219 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000220 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200221 }
222 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000223#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200224 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000225#endif
bellard83f64092006-08-01 16:21:11 +0000226}
227
228/* if filename is absolute, just copy it to dest. Otherwise, build a
229 path to it by considering it is relative to base_path. URL are
230 supported. */
231void path_combine(char *dest, int dest_size,
232 const char *base_path,
233 const char *filename)
234{
235 const char *p, *p1;
236 int len;
237
238 if (dest_size <= 0)
239 return;
240 if (path_is_absolute(filename)) {
241 pstrcpy(dest, dest_size, filename);
242 } else {
243 p = strchr(base_path, ':');
244 if (p)
245 p++;
246 else
247 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000248 p1 = strrchr(base_path, '/');
249#ifdef _WIN32
250 {
251 const char *p2;
252 p2 = strrchr(base_path, '\\');
253 if (!p1 || p2 > p1)
254 p1 = p2;
255 }
256#endif
bellard83f64092006-08-01 16:21:11 +0000257 if (p1)
258 p1++;
259 else
260 p1 = base_path;
261 if (p1 > p)
262 p = p1;
263 len = p - base_path;
264 if (len > dest_size - 1)
265 len = dest_size - 1;
266 memcpy(dest, base_path, len);
267 dest[len] = '\0';
268 pstrcat(dest, dest_size, filename);
269 }
270}
271
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200272void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
273{
274 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
275 pstrcpy(dest, sz, bs->backing_file);
276 } else {
277 path_combine(dest, sz, bs->filename, bs->backing_file);
278 }
279}
280
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500281void bdrv_register(BlockDriver *bdrv)
bellardea2384d2004-08-01 21:59:26 +0000282{
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +0100283 /* Block drivers without coroutine functions need emulation */
284 if (!bdrv->bdrv_co_readv) {
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200285 bdrv->bdrv_co_readv = bdrv_co_readv_em;
286 bdrv->bdrv_co_writev = bdrv_co_writev_em;
287
Stefan Hajnoczif8c35c12011-10-13 21:09:31 +0100288 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
289 * the block driver lacks aio we need to emulate that too.
290 */
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200291 if (!bdrv->bdrv_aio_readv) {
292 /* add AIO emulation layer */
293 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
294 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200295 }
bellard83f64092006-08-01 16:21:11 +0000296 }
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200297
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100298 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000299}
bellardb3380822004-03-14 21:38:54 +0000300
301/* create a new block device (by default it is empty) */
302BlockDriverState *bdrv_new(const char *device_name)
bellardfc01f7e2003-06-30 10:03:06 +0000303{
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100304 BlockDriverState *bs;
bellardb3380822004-03-14 21:38:54 +0000305
Anthony Liguori7267c092011-08-20 22:09:37 -0500306 bs = g_malloc0(sizeof(BlockDriverState));
bellardb3380822004-03-14 21:38:54 +0000307 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellardea2384d2004-08-01 21:59:26 +0000308 if (device_name[0] != '\0') {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100309 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
bellardea2384d2004-08-01 21:59:26 +0000310 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300311 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200312 notifier_list_init(&bs->close_notifiers);
313
bellardb3380822004-03-14 21:38:54 +0000314 return bs;
315}
316
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200317void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
318{
319 notifier_list_add(&bs->close_notifiers, notify);
320}
321
bellardea2384d2004-08-01 21:59:26 +0000322BlockDriver *bdrv_find_format(const char *format_name)
323{
324 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100325 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
326 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000327 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100328 }
bellardea2384d2004-08-01 21:59:26 +0000329 }
330 return NULL;
331}
332
Markus Armbrustereb852012009-10-27 18:41:44 +0100333static int bdrv_is_whitelisted(BlockDriver *drv)
334{
335 static const char *whitelist[] = {
336 CONFIG_BDRV_WHITELIST
337 };
338 const char **p;
339
340 if (!whitelist[0])
341 return 1; /* no whitelist, anything goes */
342
343 for (p = whitelist; *p; p++) {
344 if (!strcmp(drv->format_name, *p)) {
345 return 1;
346 }
347 }
348 return 0;
349}
350
351BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
352{
353 BlockDriver *drv = bdrv_find_format(format_name);
354 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
355}
356
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800357typedef struct CreateCo {
358 BlockDriver *drv;
359 char *filename;
360 QEMUOptionParameter *options;
361 int ret;
362} CreateCo;
363
364static void coroutine_fn bdrv_create_co_entry(void *opaque)
365{
366 CreateCo *cco = opaque;
367 assert(cco->drv);
368
369 cco->ret = cco->drv->bdrv_create(cco->filename, cco->options);
370}
371
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200372int bdrv_create(BlockDriver *drv, const char* filename,
373 QEMUOptionParameter *options)
bellardea2384d2004-08-01 21:59:26 +0000374{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800375 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200376
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800377 Coroutine *co;
378 CreateCo cco = {
379 .drv = drv,
380 .filename = g_strdup(filename),
381 .options = options,
382 .ret = NOT_DONE,
383 };
384
385 if (!drv->bdrv_create) {
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300386 ret = -ENOTSUP;
387 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800388 }
389
390 if (qemu_in_coroutine()) {
391 /* Fast-path if already in coroutine context */
392 bdrv_create_co_entry(&cco);
393 } else {
394 co = qemu_coroutine_create(bdrv_create_co_entry);
395 qemu_coroutine_enter(co, &cco);
396 while (cco.ret == NOT_DONE) {
397 qemu_aio_wait();
398 }
399 }
400
401 ret = cco.ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800402
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300403out:
404 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800405 return ret;
bellardea2384d2004-08-01 21:59:26 +0000406}
407
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200408int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
409{
410 BlockDriver *drv;
411
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900412 drv = bdrv_find_protocol(filename);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200413 if (drv == NULL) {
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000414 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200415 }
416
417 return bdrv_create(drv, filename, options);
418}
419
Jim Meyeringeba25052012-05-28 09:27:54 +0200420/*
421 * Create a uniquely-named empty temporary file.
422 * Return 0 upon success, otherwise a negative errno value.
423 */
424int get_tmp_filename(char *filename, int size)
425{
bellardd5249392004-08-03 21:14:23 +0000426#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000427 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200428 /* GetTempFileName requires that its output buffer (4th param)
429 have length MAX_PATH or greater. */
430 assert(size >= MAX_PATH);
431 return (GetTempPath(MAX_PATH, temp_dir)
432 && GetTempFileName(temp_dir, "qem", 0, filename)
433 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000434#else
bellardea2384d2004-08-01 21:59:26 +0000435 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000436 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000437 tmpdir = getenv("TMPDIR");
438 if (!tmpdir)
439 tmpdir = "/tmp";
Jim Meyeringeba25052012-05-28 09:27:54 +0200440 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
441 return -EOVERFLOW;
442 }
bellardea2384d2004-08-01 21:59:26 +0000443 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800444 if (fd < 0) {
445 return -errno;
446 }
447 if (close(fd) != 0) {
448 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200449 return -errno;
450 }
451 return 0;
bellardd5249392004-08-03 21:14:23 +0000452#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200453}
bellardea2384d2004-08-01 21:59:26 +0000454
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200455/*
456 * Detect host devices. By convention, /dev/cdrom[N] is always
457 * recognized as a host CDROM.
458 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200459static BlockDriver *find_hdev_driver(const char *filename)
460{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200461 int score_max = 0, score;
462 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200463
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100464 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200465 if (d->bdrv_probe_device) {
466 score = d->bdrv_probe_device(filename);
467 if (score > score_max) {
468 score_max = score;
469 drv = d;
470 }
471 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200472 }
473
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200474 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200475}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200476
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900477BlockDriver *bdrv_find_protocol(const char *filename)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200478{
479 BlockDriver *drv1;
480 char protocol[128];
481 int len;
482 const char *p;
483
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200484 /* TODO Drivers without bdrv_file_open must be specified explicitly */
485
Christoph Hellwig39508e72010-06-23 12:25:17 +0200486 /*
487 * XXX(hch): we really should not let host device detection
488 * override an explicit protocol specification, but moving this
489 * later breaks access to device names with colons in them.
490 * Thanks to the brain-dead persistent naming schemes on udev-
491 * based Linux systems those actually are quite common.
492 */
493 drv1 = find_hdev_driver(filename);
494 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200495 return drv1;
496 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200497
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000498 if (!path_has_protocol(filename)) {
Christoph Hellwig39508e72010-06-23 12:25:17 +0200499 return bdrv_find_format("file");
500 }
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000501 p = strchr(filename, ':');
502 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200503 len = p - filename;
504 if (len > sizeof(protocol) - 1)
505 len = sizeof(protocol) - 1;
506 memcpy(protocol, filename, len);
507 protocol[len] = '\0';
508 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
509 if (drv1->protocol_name &&
510 !strcmp(drv1->protocol_name, protocol)) {
511 return drv1;
512 }
513 }
514 return NULL;
515}
516
Kevin Wolff500a6d2012-11-12 17:35:27 +0100517static int find_image_format(BlockDriverState *bs, const char *filename,
518 BlockDriver **pdrv)
bellardea2384d2004-08-01 21:59:26 +0000519{
Kevin Wolff500a6d2012-11-12 17:35:27 +0100520 int score, score_max;
bellardea2384d2004-08-01 21:59:26 +0000521 BlockDriver *drv1, *drv;
bellard83f64092006-08-01 16:21:11 +0000522 uint8_t buf[2048];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100523 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700524
Kevin Wolf08a00552010-06-01 18:37:31 +0200525 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Paolo Bonzini8e895592013-01-10 15:39:27 +0100526 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200527 drv = bdrv_find_format("raw");
528 if (!drv) {
529 ret = -ENOENT;
530 }
531 *pdrv = drv;
532 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700533 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700534
bellard83f64092006-08-01 16:21:11 +0000535 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000536 if (ret < 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200537 *pdrv = NULL;
538 return ret;
bellard83f64092006-08-01 16:21:11 +0000539 }
540
bellardea2384d2004-08-01 21:59:26 +0000541 score_max = 0;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200542 drv = NULL;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100543 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
bellard83f64092006-08-01 16:21:11 +0000544 if (drv1->bdrv_probe) {
545 score = drv1->bdrv_probe(buf, ret, filename);
546 if (score > score_max) {
547 score_max = score;
548 drv = drv1;
549 }
bellardea2384d2004-08-01 21:59:26 +0000550 }
551 }
Stefan Weilc98ac352010-07-21 21:51:51 +0200552 if (!drv) {
553 ret = -ENOENT;
554 }
555 *pdrv = drv;
556 return ret;
bellardea2384d2004-08-01 21:59:26 +0000557}
558
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100559/**
560 * Set the current 'total_sectors' value
561 */
562static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
563{
564 BlockDriver *drv = bs->drv;
565
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700566 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
567 if (bs->sg)
568 return 0;
569
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100570 /* query actual device if possible, otherwise just trust the hint */
571 if (drv->bdrv_getlength) {
572 int64_t length = drv->bdrv_getlength(bs);
573 if (length < 0) {
574 return length;
575 }
576 hint = length >> BDRV_SECTOR_BITS;
577 }
578
579 bs->total_sectors = hint;
580 return 0;
581}
582
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100583/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100584 * Set open flags for a given discard mode
585 *
586 * Return 0 on success, -1 if the discard mode was invalid.
587 */
588int bdrv_parse_discard_flags(const char *mode, int *flags)
589{
590 *flags &= ~BDRV_O_UNMAP;
591
592 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
593 /* do nothing */
594 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
595 *flags |= BDRV_O_UNMAP;
596 } else {
597 return -1;
598 }
599
600 return 0;
601}
602
603/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100604 * Set open flags for a given cache mode
605 *
606 * Return 0 on success, -1 if the cache mode was invalid.
607 */
608int bdrv_parse_cache_flags(const char *mode, int *flags)
609{
610 *flags &= ~BDRV_O_CACHE_MASK;
611
612 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
613 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100614 } else if (!strcmp(mode, "directsync")) {
615 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100616 } else if (!strcmp(mode, "writeback")) {
617 *flags |= BDRV_O_CACHE_WB;
618 } else if (!strcmp(mode, "unsafe")) {
619 *flags |= BDRV_O_CACHE_WB;
620 *flags |= BDRV_O_NO_FLUSH;
621 } else if (!strcmp(mode, "writethrough")) {
622 /* this is the default */
623 } else {
624 return -1;
625 }
626
627 return 0;
628}
629
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000630/**
631 * The copy-on-read flag is actually a reference count so multiple users may
632 * use the feature without worrying about clobbering its previous state.
633 * Copy-on-read stays enabled until all users have called to disable it.
634 */
635void bdrv_enable_copy_on_read(BlockDriverState *bs)
636{
637 bs->copy_on_read++;
638}
639
640void bdrv_disable_copy_on_read(BlockDriverState *bs)
641{
642 assert(bs->copy_on_read > 0);
643 bs->copy_on_read--;
644}
645
Kevin Wolf7b272452012-11-12 17:05:39 +0100646static int bdrv_open_flags(BlockDriverState *bs, int flags)
647{
648 int open_flags = flags | BDRV_O_CACHE_WB;
649
650 /*
651 * Clear flags that are internal to the block layer before opening the
652 * image.
653 */
654 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
655
656 /*
657 * Snapshots should be writable.
658 */
659 if (bs->is_temporary) {
660 open_flags |= BDRV_O_RDWR;
661 }
662
663 return open_flags;
664}
665
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200666/*
Kevin Wolf57915332010-04-14 15:24:50 +0200667 * Common part for opening disk images and files
668 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100669static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
670 const char *filename,
Kevin Wolf57915332010-04-14 15:24:50 +0200671 int flags, BlockDriver *drv)
672{
673 int ret, open_flags;
674
675 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200676 assert(bs->file == NULL);
Kevin Wolf57915332010-04-14 15:24:50 +0200677
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100678 trace_bdrv_open_common(bs, filename, flags, drv->format_name);
679
Kevin Wolf57915332010-04-14 15:24:50 +0200680 bs->open_flags = flags;
Kevin Wolf57915332010-04-14 15:24:50 +0200681 bs->buffer_alignment = 512;
682
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000683 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
684 if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {
685 bdrv_enable_copy_on_read(bs);
686 }
687
Kevin Wolf57915332010-04-14 15:24:50 +0200688 pstrcpy(bs->filename, sizeof(bs->filename), filename);
689
690 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
691 return -ENOTSUP;
692 }
693
694 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500695 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200696
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100697 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Kevin Wolf7b272452012-11-12 17:05:39 +0100698 open_flags = bdrv_open_flags(bs, flags);
Kevin Wolf57915332010-04-14 15:24:50 +0200699
Jeff Codybe028ad2012-09-20 15:13:17 -0400700 bs->read_only = !(open_flags & BDRV_O_RDWR);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100701
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200702 /* Open the image, either directly or using a protocol */
703 if (drv->bdrv_file_open) {
Kevin Wolff500a6d2012-11-12 17:35:27 +0100704 if (file != NULL) {
705 bdrv_swap(file, bs);
706 ret = 0;
707 } else {
708 ret = drv->bdrv_file_open(bs, filename, open_flags);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200709 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100710 } else {
711 assert(file != NULL);
712 bs->file = file;
713 ret = drv->bdrv_open(bs, open_flags);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200714 }
715
Kevin Wolf57915332010-04-14 15:24:50 +0200716 if (ret < 0) {
717 goto free_and_fail;
718 }
719
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100720 ret = refresh_total_sectors(bs, bs->total_sectors);
721 if (ret < 0) {
722 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200723 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100724
Kevin Wolf57915332010-04-14 15:24:50 +0200725#ifndef _WIN32
726 if (bs->is_temporary) {
727 unlink(filename);
728 }
729#endif
730 return 0;
731
732free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +0100733 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -0500734 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +0200735 bs->opaque = NULL;
736 bs->drv = NULL;
737 return ret;
738}
739
740/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200741 * Opens a file using a protocol (file, host_device, nbd, ...)
742 */
bellard83f64092006-08-01 16:21:11 +0000743int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
bellardb3380822004-03-14 21:38:54 +0000744{
bellard83f64092006-08-01 16:21:11 +0000745 BlockDriverState *bs;
Christoph Hellwig6db95602010-04-05 16:53:57 +0200746 BlockDriver *drv;
bellard83f64092006-08-01 16:21:11 +0000747 int ret;
748
MORITA Kazutakab50cbab2010-05-26 11:35:36 +0900749 drv = bdrv_find_protocol(filename);
Christoph Hellwig6db95602010-04-05 16:53:57 +0200750 if (!drv) {
751 return -ENOENT;
752 }
753
bellard83f64092006-08-01 16:21:11 +0000754 bs = bdrv_new("");
Kevin Wolff500a6d2012-11-12 17:35:27 +0100755 ret = bdrv_open_common(bs, NULL, filename, flags, drv);
bellard83f64092006-08-01 16:21:11 +0000756 if (ret < 0) {
757 bdrv_delete(bs);
758 return ret;
bellard3b0d4f62005-10-30 18:30:10 +0000759 }
aliguori71d07702009-03-03 17:37:16 +0000760 bs->growable = 1;
bellard83f64092006-08-01 16:21:11 +0000761 *pbs = bs;
762 return 0;
bellardea2384d2004-08-01 21:59:26 +0000763}
bellardfc01f7e2003-06-30 10:03:06 +0000764
Paolo Bonzini9156df12012-10-18 16:49:17 +0200765int bdrv_open_backing_file(BlockDriverState *bs)
766{
767 char backing_filename[PATH_MAX];
768 int back_flags, ret;
769 BlockDriver *back_drv = NULL;
770
771 if (bs->backing_hd != NULL) {
772 return 0;
773 }
774
775 bs->open_flags &= ~BDRV_O_NO_BACKING;
776 if (bs->backing_file[0] == '\0') {
777 return 0;
778 }
779
780 bs->backing_hd = bdrv_new("");
781 bdrv_get_full_backing_filename(bs, backing_filename,
782 sizeof(backing_filename));
783
784 if (bs->backing_format[0] != '\0') {
785 back_drv = bdrv_find_format(bs->backing_format);
786 }
787
788 /* backing files always opened read-only */
789 back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT);
790
791 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
792 if (ret < 0) {
793 bdrv_delete(bs->backing_hd);
794 bs->backing_hd = NULL;
795 bs->open_flags |= BDRV_O_NO_BACKING;
796 return ret;
797 }
798 return 0;
799}
800
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200801/*
802 * Opens a disk image (raw, qcow2, vmdk, ...)
803 */
Kevin Wolfd6e90982010-03-31 14:40:27 +0200804int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
805 BlockDriver *drv)
bellardea2384d2004-08-01 21:59:26 +0000806{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200807 int ret;
Stefan Weil89c9bc32012-11-22 07:25:48 +0100808 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
809 char tmp_filename[PATH_MAX + 1];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100810 BlockDriverState *file = NULL;
bellard712e7872005-04-28 21:09:32 +0000811
bellard83f64092006-08-01 16:21:11 +0000812 if (flags & BDRV_O_SNAPSHOT) {
bellardea2384d2004-08-01 21:59:26 +0000813 BlockDriverState *bs1;
814 int64_t total_size;
aliguori7c96d462008-09-12 17:54:13 +0000815 int is_protocol = 0;
Kevin Wolf91a073a2009-05-27 14:48:06 +0200816 BlockDriver *bdrv_qcow2;
817 QEMUOptionParameter *options;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200818 char backing_filename[PATH_MAX];
ths3b46e622007-09-17 08:09:54 +0000819
bellardea2384d2004-08-01 21:59:26 +0000820 /* if snapshot, we create a temporary backing file and open it
821 instead of opening 'filename' directly */
822
823 /* if there is a backing file, use it */
824 bs1 = bdrv_new("");
Kevin Wolfd6e90982010-03-31 14:40:27 +0200825 ret = bdrv_open(bs1, filename, 0, drv);
aliguori51d7c002009-03-05 23:00:29 +0000826 if (ret < 0) {
bellardea2384d2004-08-01 21:59:26 +0000827 bdrv_delete(bs1);
aliguori51d7c002009-03-05 23:00:29 +0000828 return ret;
bellardea2384d2004-08-01 21:59:26 +0000829 }
Jes Sorensen3e829902010-05-27 16:20:30 +0200830 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
aliguori7c96d462008-09-12 17:54:13 +0000831
832 if (bs1->drv && bs1->drv->protocol_name)
833 is_protocol = 1;
834
bellardea2384d2004-08-01 21:59:26 +0000835 bdrv_delete(bs1);
ths3b46e622007-09-17 08:09:54 +0000836
Jim Meyeringeba25052012-05-28 09:27:54 +0200837 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
838 if (ret < 0) {
839 return ret;
840 }
aliguori7c96d462008-09-12 17:54:13 +0000841
842 /* Real path is meaningless for protocols */
843 if (is_protocol)
844 snprintf(backing_filename, sizeof(backing_filename),
845 "%s", filename);
Kirill A. Shutemov114cdfa2009-12-25 18:19:22 +0000846 else if (!realpath(filename, backing_filename))
847 return -errno;
aliguori7c96d462008-09-12 17:54:13 +0000848
Kevin Wolf91a073a2009-05-27 14:48:06 +0200849 bdrv_qcow2 = bdrv_find_format("qcow2");
850 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
851
Jes Sorensen3e829902010-05-27 16:20:30 +0200852 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
Kevin Wolf91a073a2009-05-27 14:48:06 +0200853 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
854 if (drv) {
855 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
856 drv->format_name);
857 }
858
859 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
Jan Kiszkad7487682010-04-29 18:24:50 +0200860 free_option_parameters(options);
aliguori51d7c002009-03-05 23:00:29 +0000861 if (ret < 0) {
862 return ret;
bellardea2384d2004-08-01 21:59:26 +0000863 }
Kevin Wolf91a073a2009-05-27 14:48:06 +0200864
bellardea2384d2004-08-01 21:59:26 +0000865 filename = tmp_filename;
Kevin Wolf91a073a2009-05-27 14:48:06 +0200866 drv = bdrv_qcow2;
bellardea2384d2004-08-01 21:59:26 +0000867 bs->is_temporary = 1;
868 }
bellard712e7872005-04-28 21:09:32 +0000869
Kevin Wolff500a6d2012-11-12 17:35:27 +0100870 /* Open image file without format layer */
Jeff Codybe028ad2012-09-20 15:13:17 -0400871 if (flags & BDRV_O_RDWR) {
872 flags |= BDRV_O_ALLOW_RDWR;
873 }
874
Kevin Wolff500a6d2012-11-12 17:35:27 +0100875 ret = bdrv_file_open(&file, filename, bdrv_open_flags(bs, flags));
876 if (ret < 0) {
877 return ret;
878 }
879
880 /* Find the right image format driver */
881 if (!drv) {
882 ret = find_image_format(file, filename, &drv);
883 }
884
885 if (!drv) {
886 goto unlink_and_fail;
887 }
888
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200889 /* Open the image */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100890 ret = bdrv_open_common(bs, file, filename, flags, drv);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200891 if (ret < 0) {
Christoph Hellwig69873072010-01-20 18:13:25 +0100892 goto unlink_and_fail;
893 }
894
Kevin Wolff500a6d2012-11-12 17:35:27 +0100895 if (bs->file != file) {
896 bdrv_delete(file);
897 file = NULL;
898 }
899
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200900 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +0200901 if ((flags & BDRV_O_NO_BACKING) == 0) {
902 ret = bdrv_open_backing_file(bs);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200903 if (ret < 0) {
904 bdrv_close(bs);
905 return ret;
906 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200907 }
908
909 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +0200910 bdrv_dev_change_media_cb(bs, true);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200911 }
912
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800913 /* throttling disk I/O limits */
914 if (bs->io_limits_enabled) {
915 bdrv_io_limits_enable(bs);
916 }
917
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200918 return 0;
919
920unlink_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +0100921 if (file != NULL) {
922 bdrv_delete(file);
923 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200924 if (bs->is_temporary) {
925 unlink(filename);
926 }
927 return ret;
928}
929
Jeff Codye971aa12012-09-20 15:13:19 -0400930typedef struct BlockReopenQueueEntry {
931 bool prepared;
932 BDRVReopenState state;
933 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
934} BlockReopenQueueEntry;
935
936/*
937 * Adds a BlockDriverState to a simple queue for an atomic, transactional
938 * reopen of multiple devices.
939 *
940 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
941 * already performed, or alternatively may be NULL a new BlockReopenQueue will
942 * be created and initialized. This newly created BlockReopenQueue should be
943 * passed back in for subsequent calls that are intended to be of the same
944 * atomic 'set'.
945 *
946 * bs is the BlockDriverState to add to the reopen queue.
947 *
948 * flags contains the open flags for the associated bs
949 *
950 * returns a pointer to bs_queue, which is either the newly allocated
951 * bs_queue, or the existing bs_queue being used.
952 *
953 */
954BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
955 BlockDriverState *bs, int flags)
956{
957 assert(bs != NULL);
958
959 BlockReopenQueueEntry *bs_entry;
960 if (bs_queue == NULL) {
961 bs_queue = g_new0(BlockReopenQueue, 1);
962 QSIMPLEQ_INIT(bs_queue);
963 }
964
965 if (bs->file) {
966 bdrv_reopen_queue(bs_queue, bs->file, flags);
967 }
968
969 bs_entry = g_new0(BlockReopenQueueEntry, 1);
970 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
971
972 bs_entry->state.bs = bs;
973 bs_entry->state.flags = flags;
974
975 return bs_queue;
976}
977
978/*
979 * Reopen multiple BlockDriverStates atomically & transactionally.
980 *
981 * The queue passed in (bs_queue) must have been built up previous
982 * via bdrv_reopen_queue().
983 *
984 * Reopens all BDS specified in the queue, with the appropriate
985 * flags. All devices are prepared for reopen, and failure of any
986 * device will cause all device changes to be abandonded, and intermediate
987 * data cleaned up.
988 *
989 * If all devices prepare successfully, then the changes are committed
990 * to all devices.
991 *
992 */
993int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
994{
995 int ret = -1;
996 BlockReopenQueueEntry *bs_entry, *next;
997 Error *local_err = NULL;
998
999 assert(bs_queue != NULL);
1000
1001 bdrv_drain_all();
1002
1003 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1004 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1005 error_propagate(errp, local_err);
1006 goto cleanup;
1007 }
1008 bs_entry->prepared = true;
1009 }
1010
1011 /* If we reach this point, we have success and just need to apply the
1012 * changes
1013 */
1014 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1015 bdrv_reopen_commit(&bs_entry->state);
1016 }
1017
1018 ret = 0;
1019
1020cleanup:
1021 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1022 if (ret && bs_entry->prepared) {
1023 bdrv_reopen_abort(&bs_entry->state);
1024 }
1025 g_free(bs_entry);
1026 }
1027 g_free(bs_queue);
1028 return ret;
1029}
1030
1031
1032/* Reopen a single BlockDriverState with the specified flags. */
1033int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1034{
1035 int ret = -1;
1036 Error *local_err = NULL;
1037 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1038
1039 ret = bdrv_reopen_multiple(queue, &local_err);
1040 if (local_err != NULL) {
1041 error_propagate(errp, local_err);
1042 }
1043 return ret;
1044}
1045
1046
1047/*
1048 * Prepares a BlockDriverState for reopen. All changes are staged in the
1049 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1050 * the block driver layer .bdrv_reopen_prepare()
1051 *
1052 * bs is the BlockDriverState to reopen
1053 * flags are the new open flags
1054 * queue is the reopen queue
1055 *
1056 * Returns 0 on success, non-zero on error. On error errp will be set
1057 * as well.
1058 *
1059 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1060 * It is the responsibility of the caller to then call the abort() or
1061 * commit() for any other BDS that have been left in a prepare() state
1062 *
1063 */
1064int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1065 Error **errp)
1066{
1067 int ret = -1;
1068 Error *local_err = NULL;
1069 BlockDriver *drv;
1070
1071 assert(reopen_state != NULL);
1072 assert(reopen_state->bs->drv != NULL);
1073 drv = reopen_state->bs->drv;
1074
1075 /* if we are to stay read-only, do not allow permission change
1076 * to r/w */
1077 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1078 reopen_state->flags & BDRV_O_RDWR) {
1079 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1080 reopen_state->bs->device_name);
1081 goto error;
1082 }
1083
1084
1085 ret = bdrv_flush(reopen_state->bs);
1086 if (ret) {
1087 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1088 strerror(-ret));
1089 goto error;
1090 }
1091
1092 if (drv->bdrv_reopen_prepare) {
1093 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1094 if (ret) {
1095 if (local_err != NULL) {
1096 error_propagate(errp, local_err);
1097 } else {
1098 error_set(errp, QERR_OPEN_FILE_FAILED,
1099 reopen_state->bs->filename);
1100 }
1101 goto error;
1102 }
1103 } else {
1104 /* It is currently mandatory to have a bdrv_reopen_prepare()
1105 * handler for each supported drv. */
1106 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1107 drv->format_name, reopen_state->bs->device_name,
1108 "reopening of file");
1109 ret = -1;
1110 goto error;
1111 }
1112
1113 ret = 0;
1114
1115error:
1116 return ret;
1117}
1118
1119/*
1120 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1121 * makes them final by swapping the staging BlockDriverState contents into
1122 * the active BlockDriverState contents.
1123 */
1124void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1125{
1126 BlockDriver *drv;
1127
1128 assert(reopen_state != NULL);
1129 drv = reopen_state->bs->drv;
1130 assert(drv != NULL);
1131
1132 /* If there are any driver level actions to take */
1133 if (drv->bdrv_reopen_commit) {
1134 drv->bdrv_reopen_commit(reopen_state);
1135 }
1136
1137 /* set BDS specific flags now */
1138 reopen_state->bs->open_flags = reopen_state->flags;
1139 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1140 BDRV_O_CACHE_WB);
1141 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1142}
1143
1144/*
1145 * Abort the reopen, and delete and free the staged changes in
1146 * reopen_state
1147 */
1148void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1149{
1150 BlockDriver *drv;
1151
1152 assert(reopen_state != NULL);
1153 drv = reopen_state->bs->drv;
1154 assert(drv != NULL);
1155
1156 if (drv->bdrv_reopen_abort) {
1157 drv->bdrv_reopen_abort(reopen_state);
1158 }
1159}
1160
1161
bellardfc01f7e2003-06-30 10:03:06 +00001162void bdrv_close(BlockDriverState *bs)
1163{
Liu Yuan80ccf932012-04-20 17:10:56 +08001164 bdrv_flush(bs);
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001165 if (bs->job) {
1166 block_job_cancel_sync(bs->job);
1167 }
1168 bdrv_drain_all();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001169 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001170
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001171 if (bs->drv) {
Markus Armbrusterf9092b12010-06-25 10:33:39 +02001172 if (bs == bs_snapshots) {
1173 bs_snapshots = NULL;
1174 }
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001175 if (bs->backing_hd) {
bellardea2384d2004-08-01 21:59:26 +00001176 bdrv_delete(bs->backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001177 bs->backing_hd = NULL;
1178 }
bellardea2384d2004-08-01 21:59:26 +00001179 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001180 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001181#ifdef _WIN32
1182 if (bs->is_temporary) {
1183 unlink(bs->filename);
1184 }
bellard67b915a2004-03-31 23:37:16 +00001185#endif
bellardea2384d2004-08-01 21:59:26 +00001186 bs->opaque = NULL;
1187 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001188 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001189 bs->backing_file[0] = '\0';
1190 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001191 bs->total_sectors = 0;
1192 bs->encrypted = 0;
1193 bs->valid_key = 0;
1194 bs->sg = 0;
1195 bs->growable = 0;
bellardb3380822004-03-14 21:38:54 +00001196
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001197 if (bs->file != NULL) {
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001198 bdrv_delete(bs->file);
1199 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001200 }
bellardb3380822004-03-14 21:38:54 +00001201 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001202
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001203 bdrv_dev_change_media_cb(bs, false);
1204
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001205 /*throttling disk I/O limits*/
1206 if (bs->io_limits_enabled) {
1207 bdrv_io_limits_disable(bs);
1208 }
bellardb3380822004-03-14 21:38:54 +00001209}
1210
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001211void bdrv_close_all(void)
1212{
1213 BlockDriverState *bs;
1214
1215 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1216 bdrv_close(bs);
1217 }
1218}
1219
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001220/*
1221 * Wait for pending requests to complete across all BlockDriverStates
1222 *
1223 * This function does not flush data to disk, use bdrv_flush_all() for that
1224 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001225 *
1226 * Note that completion of an asynchronous I/O operation can trigger any
1227 * number of other I/O operations on other devices---for example a coroutine
1228 * can be arbitrarily complex and a constant flow of I/O can come until the
1229 * coroutine is complete. Because of this, it is not possible to have a
1230 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001231 */
1232void bdrv_drain_all(void)
1233{
1234 BlockDriverState *bs;
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001235 bool busy;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001236
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001237 do {
1238 busy = qemu_aio_wait();
1239
1240 /* FIXME: We do not have timer support here, so this is effectively
1241 * a busy wait.
1242 */
1243 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1244 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
1245 qemu_co_queue_restart_all(&bs->throttled_reqs);
1246 busy = true;
1247 }
1248 }
1249 } while (busy);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001250
1251 /* If requests are still pending there is a bug somewhere */
1252 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1253 assert(QLIST_EMPTY(&bs->tracked_requests));
1254 assert(qemu_co_queue_empty(&bs->throttled_reqs));
1255 }
1256}
1257
Ryan Harperd22b2f42011-03-29 20:51:47 -05001258/* make a BlockDriverState anonymous by removing from bdrv_state list.
1259 Also, NULL terminate the device_name to prevent double remove */
1260void bdrv_make_anon(BlockDriverState *bs)
1261{
1262 if (bs->device_name[0] != '\0') {
1263 QTAILQ_REMOVE(&bdrv_states, bs, list);
1264 }
1265 bs->device_name[0] = '\0';
1266}
1267
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001268static void bdrv_rebind(BlockDriverState *bs)
1269{
1270 if (bs->drv && bs->drv->bdrv_rebind) {
1271 bs->drv->bdrv_rebind(bs);
1272 }
1273}
1274
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001275static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1276 BlockDriverState *bs_src)
1277{
1278 /* move some fields that need to stay attached to the device */
1279 bs_dest->open_flags = bs_src->open_flags;
1280
1281 /* dev info */
1282 bs_dest->dev_ops = bs_src->dev_ops;
1283 bs_dest->dev_opaque = bs_src->dev_opaque;
1284 bs_dest->dev = bs_src->dev;
1285 bs_dest->buffer_alignment = bs_src->buffer_alignment;
1286 bs_dest->copy_on_read = bs_src->copy_on_read;
1287
1288 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1289
1290 /* i/o timing parameters */
1291 bs_dest->slice_time = bs_src->slice_time;
1292 bs_dest->slice_start = bs_src->slice_start;
1293 bs_dest->slice_end = bs_src->slice_end;
1294 bs_dest->io_limits = bs_src->io_limits;
1295 bs_dest->io_base = bs_src->io_base;
1296 bs_dest->throttled_reqs = bs_src->throttled_reqs;
1297 bs_dest->block_timer = bs_src->block_timer;
1298 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1299
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001300 /* r/w error */
1301 bs_dest->on_read_error = bs_src->on_read_error;
1302 bs_dest->on_write_error = bs_src->on_write_error;
1303
1304 /* i/o status */
1305 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1306 bs_dest->iostatus = bs_src->iostatus;
1307
1308 /* dirty bitmap */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001309 bs_dest->dirty_bitmap = bs_src->dirty_bitmap;
1310
1311 /* job */
1312 bs_dest->in_use = bs_src->in_use;
1313 bs_dest->job = bs_src->job;
1314
1315 /* keep the same entry in bdrv_states */
1316 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1317 bs_src->device_name);
1318 bs_dest->list = bs_src->list;
1319}
1320
1321/*
1322 * Swap bs contents for two image chains while they are live,
1323 * while keeping required fields on the BlockDriverState that is
1324 * actually attached to a device.
1325 *
1326 * This will modify the BlockDriverState fields, and swap contents
1327 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1328 *
1329 * bs_new is required to be anonymous.
1330 *
1331 * This function does not create any image files.
1332 */
1333void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1334{
1335 BlockDriverState tmp;
1336
1337 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1338 assert(bs_new->device_name[0] == '\0');
1339 assert(bs_new->dirty_bitmap == NULL);
1340 assert(bs_new->job == NULL);
1341 assert(bs_new->dev == NULL);
1342 assert(bs_new->in_use == 0);
1343 assert(bs_new->io_limits_enabled == false);
1344 assert(bs_new->block_timer == NULL);
1345
1346 tmp = *bs_new;
1347 *bs_new = *bs_old;
1348 *bs_old = tmp;
1349
1350 /* there are some fields that should not be swapped, move them back */
1351 bdrv_move_feature_fields(&tmp, bs_old);
1352 bdrv_move_feature_fields(bs_old, bs_new);
1353 bdrv_move_feature_fields(bs_new, &tmp);
1354
1355 /* bs_new shouldn't be in bdrv_states even after the swap! */
1356 assert(bs_new->device_name[0] == '\0');
1357
1358 /* Check a few fields that should remain attached to the device */
1359 assert(bs_new->dev == NULL);
1360 assert(bs_new->job == NULL);
1361 assert(bs_new->in_use == 0);
1362 assert(bs_new->io_limits_enabled == false);
1363 assert(bs_new->block_timer == NULL);
1364
1365 bdrv_rebind(bs_new);
1366 bdrv_rebind(bs_old);
1367}
1368
Jeff Cody8802d1f2012-02-28 15:54:06 -05001369/*
1370 * Add new bs contents at the top of an image chain while the chain is
1371 * live, while keeping required fields on the top layer.
1372 *
1373 * This will modify the BlockDriverState fields, and swap contents
1374 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1375 *
Jeff Codyf6801b82012-03-27 16:30:19 -04001376 * bs_new is required to be anonymous.
1377 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05001378 * This function does not create any image files.
1379 */
1380void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1381{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001382 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05001383
1384 /* The contents of 'tmp' will become bs_top, as we are
1385 * swapping bs_new and bs_top contents. */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001386 bs_top->backing_hd = bs_new;
1387 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1388 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1389 bs_new->filename);
1390 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1391 bs_new->drv ? bs_new->drv->format_name : "");
Jeff Cody8802d1f2012-02-28 15:54:06 -05001392}
1393
bellardb3380822004-03-14 21:38:54 +00001394void bdrv_delete(BlockDriverState *bs)
1395{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001396 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02001397 assert(!bs->job);
1398 assert(!bs->in_use);
Markus Armbruster18846de2010-06-29 16:58:30 +02001399
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01001400 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05001401 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00001402
bellardb3380822004-03-14 21:38:54 +00001403 bdrv_close(bs);
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001404
Markus Armbrusterf9092b12010-06-25 10:33:39 +02001405 assert(bs != bs_snapshots);
Anthony Liguori7267c092011-08-20 22:09:37 -05001406 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00001407}
1408
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001409int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1410/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02001411{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001412 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02001413 return -EBUSY;
1414 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001415 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03001416 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02001417 return 0;
1418}
1419
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001420/* TODO qdevified devices don't use this, remove when devices are qdevified */
1421void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02001422{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001423 if (bdrv_attach_dev(bs, dev) < 0) {
1424 abort();
1425 }
1426}
1427
1428void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1429/* TODO change to DeviceState *dev when all users are qdevified */
1430{
1431 assert(bs->dev == dev);
1432 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02001433 bs->dev_ops = NULL;
1434 bs->dev_opaque = NULL;
Markus Armbruster29e05f22011-09-06 18:58:57 +02001435 bs->buffer_alignment = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02001436}
1437
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001438/* TODO change to return DeviceState * when all users are qdevified */
1439void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02001440{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02001441 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02001442}
1443
Markus Armbruster0e49de52011-08-03 15:07:41 +02001444void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1445 void *opaque)
1446{
1447 bs->dev_ops = ops;
1448 bs->dev_opaque = opaque;
Markus Armbruster2c6942f2011-09-06 18:58:51 +02001449 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
1450 bs_snapshots = NULL;
1451 }
Markus Armbruster0e49de52011-08-03 15:07:41 +02001452}
1453
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001454void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1455 enum MonitorEvent ev,
1456 BlockErrorAction action, bool is_read)
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001457{
1458 QObject *data;
1459 const char *action_str;
1460
1461 switch (action) {
1462 case BDRV_ACTION_REPORT:
1463 action_str = "report";
1464 break;
1465 case BDRV_ACTION_IGNORE:
1466 action_str = "ignore";
1467 break;
1468 case BDRV_ACTION_STOP:
1469 action_str = "stop";
1470 break;
1471 default:
1472 abort();
1473 }
1474
1475 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1476 bdrv->device_name,
1477 action_str,
1478 is_read ? "read" : "write");
Paolo Bonzini32c81a42012-09-28 17:22:58 +02001479 monitor_protocol_event(ev, data);
Luiz Capitulino329c0a42012-01-25 16:59:43 -02001480
1481 qobject_decref(data);
1482}
1483
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001484static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1485{
1486 QObject *data;
1487
1488 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1489 bdrv_get_device_name(bs), ejected);
1490 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1491
1492 qobject_decref(data);
1493}
1494
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001495static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02001496{
Markus Armbruster145feb12011-08-03 15:07:42 +02001497 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001498 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001499 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02001500 if (tray_was_closed) {
1501 /* tray open */
1502 bdrv_emit_qmp_eject_event(bs, true);
1503 }
1504 if (load) {
1505 /* tray close */
1506 bdrv_emit_qmp_eject_event(bs, false);
1507 }
Markus Armbruster145feb12011-08-03 15:07:42 +02001508 }
1509}
1510
Markus Armbruster2c6942f2011-09-06 18:58:51 +02001511bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1512{
1513 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1514}
1515
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01001516void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1517{
1518 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1519 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1520 }
1521}
1522
Markus Armbrustere4def802011-09-06 18:58:53 +02001523bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1524{
1525 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1526 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1527 }
1528 return false;
1529}
1530
Markus Armbruster145feb12011-08-03 15:07:42 +02001531static void bdrv_dev_resize_cb(BlockDriverState *bs)
1532{
1533 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1534 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02001535 }
1536}
1537
Markus Armbrusterf1076392011-09-06 18:58:46 +02001538bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1539{
1540 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1541 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1542 }
1543 return false;
1544}
1545
aliguorie97fc192009-04-21 23:11:50 +00001546/*
1547 * Run consistency checks on an image
1548 *
Kevin Wolfe076f332010-06-29 11:43:13 +02001549 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02001550 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02001551 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00001552 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02001553int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00001554{
1555 if (bs->drv->bdrv_check == NULL) {
1556 return -ENOTSUP;
1557 }
1558
Kevin Wolfe076f332010-06-29 11:43:13 +02001559 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02001560 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00001561}
1562
Kevin Wolf8a426612010-07-16 17:17:01 +02001563#define COMMIT_BUF_SECTORS 2048
1564
bellard33e39632003-07-06 17:15:21 +00001565/* commit COW file into the raw image */
1566int bdrv_commit(BlockDriverState *bs)
1567{
bellard19cb3732006-08-19 11:45:59 +00001568 BlockDriver *drv = bs->drv;
Kevin Wolf8a426612010-07-16 17:17:01 +02001569 int64_t sector, total_sectors;
1570 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04001571 int ret = 0;
Kevin Wolf8a426612010-07-16 17:17:01 +02001572 uint8_t *buf;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02001573 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00001574
bellard19cb3732006-08-19 11:45:59 +00001575 if (!drv)
1576 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001577
1578 if (!bs->backing_hd) {
1579 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00001580 }
1581
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00001582 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1583 return -EBUSY;
1584 }
1585
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001586 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02001587 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1588 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001589 open_flags = bs->backing_hd->open_flags;
1590
1591 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04001592 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
1593 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001594 }
bellard33e39632003-07-06 17:15:21 +00001595 }
bellardea2384d2004-08-01 21:59:26 +00001596
Jan Kiszka6ea44302009-11-30 18:21:19 +01001597 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05001598 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00001599
Kevin Wolf8a426612010-07-16 17:17:01 +02001600 for (sector = 0; sector < total_sectors; sector += n) {
Stefan Hajnoczi05c4af52011-11-14 12:44:18 +00001601 if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
Kevin Wolf8a426612010-07-16 17:17:01 +02001602
1603 if (bdrv_read(bs, sector, buf, n) != 0) {
1604 ret = -EIO;
1605 goto ro_cleanup;
1606 }
1607
1608 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1609 ret = -EIO;
1610 goto ro_cleanup;
1611 }
bellardea2384d2004-08-01 21:59:26 +00001612 }
1613 }
bellard95389c82005-12-18 18:28:15 +00001614
Christoph Hellwig1d449522010-01-17 12:32:30 +01001615 if (drv->bdrv_make_empty) {
1616 ret = drv->bdrv_make_empty(bs);
1617 bdrv_flush(bs);
1618 }
bellard95389c82005-12-18 18:28:15 +00001619
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01001620 /*
1621 * Make sure all data we wrote to the backing device is actually
1622 * stable on disk.
1623 */
1624 if (bs->backing_hd)
1625 bdrv_flush(bs->backing_hd);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001626
1627ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05001628 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001629
1630 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04001631 /* ignoring error return here */
1632 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02001633 }
1634
Christoph Hellwig1d449522010-01-17 12:32:30 +01001635 return ret;
bellard33e39632003-07-06 17:15:21 +00001636}
1637
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001638int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001639{
1640 BlockDriverState *bs;
1641
1642 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Jeff Cody272d2d82013-02-26 09:55:48 -05001643 if (bs->drv && bs->backing_hd) {
1644 int ret = bdrv_commit(bs);
1645 if (ret < 0) {
1646 return ret;
1647 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001648 }
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001649 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00001650 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02001651}
1652
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001653struct BdrvTrackedRequest {
1654 BlockDriverState *bs;
1655 int64_t sector_num;
1656 int nb_sectors;
1657 bool is_write;
1658 QLIST_ENTRY(BdrvTrackedRequest) list;
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00001659 Coroutine *co; /* owner, used for deadlock detection */
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001660 CoQueue wait_queue; /* coroutines blocked on this request */
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001661};
1662
1663/**
1664 * Remove an active request from the tracked requests list
1665 *
1666 * This function should be called when a tracked request is completing.
1667 */
1668static void tracked_request_end(BdrvTrackedRequest *req)
1669{
1670 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001671 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001672}
1673
1674/**
1675 * Add an active request to the tracked requests list
1676 */
1677static void tracked_request_begin(BdrvTrackedRequest *req,
1678 BlockDriverState *bs,
1679 int64_t sector_num,
1680 int nb_sectors, bool is_write)
1681{
1682 *req = (BdrvTrackedRequest){
1683 .bs = bs,
1684 .sector_num = sector_num,
1685 .nb_sectors = nb_sectors,
1686 .is_write = is_write,
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00001687 .co = qemu_coroutine_self(),
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001688 };
1689
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001690 qemu_co_queue_init(&req->wait_queue);
1691
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00001692 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
1693}
1694
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001695/**
1696 * Round a region to cluster boundaries
1697 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01001698void bdrv_round_to_clusters(BlockDriverState *bs,
1699 int64_t sector_num, int nb_sectors,
1700 int64_t *cluster_sector_num,
1701 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001702{
1703 BlockDriverInfo bdi;
1704
1705 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
1706 *cluster_sector_num = sector_num;
1707 *cluster_nb_sectors = nb_sectors;
1708 } else {
1709 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
1710 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
1711 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
1712 nb_sectors, c);
1713 }
1714}
1715
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001716static bool tracked_request_overlaps(BdrvTrackedRequest *req,
1717 int64_t sector_num, int nb_sectors) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001718 /* aaaa bbbb */
1719 if (sector_num >= req->sector_num + req->nb_sectors) {
1720 return false;
1721 }
1722 /* bbbb aaaa */
1723 if (req->sector_num >= sector_num + nb_sectors) {
1724 return false;
1725 }
1726 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001727}
1728
1729static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
1730 int64_t sector_num, int nb_sectors)
1731{
1732 BdrvTrackedRequest *req;
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001733 int64_t cluster_sector_num;
1734 int cluster_nb_sectors;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001735 bool retry;
1736
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001737 /* If we touch the same cluster it counts as an overlap. This guarantees
1738 * that allocating writes will be serialized and not race with each other
1739 * for the same cluster. For example, in copy-on-read it ensures that the
1740 * CoR read and write operations are atomic and guest writes cannot
1741 * interleave between them.
1742 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01001743 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
1744 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001745
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001746 do {
1747 retry = false;
1748 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00001749 if (tracked_request_overlaps(req, cluster_sector_num,
1750 cluster_nb_sectors)) {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00001751 /* Hitting this means there was a reentrant request, for
1752 * example, a block driver issuing nested requests. This must
1753 * never happen since it means deadlock.
1754 */
1755 assert(qemu_coroutine_self() != req->co);
1756
Stefan Hajnoczif4658282011-11-17 13:40:29 +00001757 qemu_co_queue_wait(&req->wait_queue);
1758 retry = true;
1759 break;
1760 }
1761 }
1762 } while (retry);
1763}
1764
Kevin Wolf756e6732010-01-12 12:55:17 +01001765/*
1766 * Return values:
1767 * 0 - success
1768 * -EINVAL - backing format specified, but no file
1769 * -ENOSPC - can't update the backing file because no space is left in the
1770 * image file header
1771 * -ENOTSUP - format driver doesn't support changing the backing file
1772 */
1773int bdrv_change_backing_file(BlockDriverState *bs,
1774 const char *backing_file, const char *backing_fmt)
1775{
1776 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02001777 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01001778
Paolo Bonzini5f377792012-04-12 14:01:01 +02001779 /* Backing file format doesn't make sense without a backing file */
1780 if (backing_fmt && !backing_file) {
1781 return -EINVAL;
1782 }
1783
Kevin Wolf756e6732010-01-12 12:55:17 +01001784 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02001785 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01001786 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02001787 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01001788 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02001789
1790 if (ret == 0) {
1791 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
1792 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
1793 }
1794 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01001795}
1796
Jeff Cody6ebdcee2012-09-27 13:29:12 -04001797/*
1798 * Finds the image layer in the chain that has 'bs' as its backing file.
1799 *
1800 * active is the current topmost image.
1801 *
1802 * Returns NULL if bs is not found in active's image chain,
1803 * or if active == bs.
1804 */
1805BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
1806 BlockDriverState *bs)
1807{
1808 BlockDriverState *overlay = NULL;
1809 BlockDriverState *intermediate;
1810
1811 assert(active != NULL);
1812 assert(bs != NULL);
1813
1814 /* if bs is the same as active, then by definition it has no overlay
1815 */
1816 if (active == bs) {
1817 return NULL;
1818 }
1819
1820 intermediate = active;
1821 while (intermediate->backing_hd) {
1822 if (intermediate->backing_hd == bs) {
1823 overlay = intermediate;
1824 break;
1825 }
1826 intermediate = intermediate->backing_hd;
1827 }
1828
1829 return overlay;
1830}
1831
1832typedef struct BlkIntermediateStates {
1833 BlockDriverState *bs;
1834 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
1835} BlkIntermediateStates;
1836
1837
1838/*
1839 * Drops images above 'base' up to and including 'top', and sets the image
1840 * above 'top' to have base as its backing file.
1841 *
1842 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1843 * information in 'bs' can be properly updated.
1844 *
1845 * E.g., this will convert the following chain:
1846 * bottom <- base <- intermediate <- top <- active
1847 *
1848 * to
1849 *
1850 * bottom <- base <- active
1851 *
1852 * It is allowed for bottom==base, in which case it converts:
1853 *
1854 * base <- intermediate <- top <- active
1855 *
1856 * to
1857 *
1858 * base <- active
1859 *
1860 * Error conditions:
1861 * if active == top, that is considered an error
1862 *
1863 */
1864int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
1865 BlockDriverState *base)
1866{
1867 BlockDriverState *intermediate;
1868 BlockDriverState *base_bs = NULL;
1869 BlockDriverState *new_top_bs = NULL;
1870 BlkIntermediateStates *intermediate_state, *next;
1871 int ret = -EIO;
1872
1873 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
1874 QSIMPLEQ_INIT(&states_to_delete);
1875
1876 if (!top->drv || !base->drv) {
1877 goto exit;
1878 }
1879
1880 new_top_bs = bdrv_find_overlay(active, top);
1881
1882 if (new_top_bs == NULL) {
1883 /* we could not find the image above 'top', this is an error */
1884 goto exit;
1885 }
1886
1887 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1888 * to do, no intermediate images */
1889 if (new_top_bs->backing_hd == base) {
1890 ret = 0;
1891 goto exit;
1892 }
1893
1894 intermediate = top;
1895
1896 /* now we will go down through the list, and add each BDS we find
1897 * into our deletion queue, until we hit the 'base'
1898 */
1899 while (intermediate) {
1900 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
1901 intermediate_state->bs = intermediate;
1902 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
1903
1904 if (intermediate->backing_hd == base) {
1905 base_bs = intermediate->backing_hd;
1906 break;
1907 }
1908 intermediate = intermediate->backing_hd;
1909 }
1910 if (base_bs == NULL) {
1911 /* something went wrong, we did not end at the base. safely
1912 * unravel everything, and exit with error */
1913 goto exit;
1914 }
1915
1916 /* success - we can delete the intermediate states, and link top->base */
1917 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
1918 base_bs->drv ? base_bs->drv->format_name : "");
1919 if (ret) {
1920 goto exit;
1921 }
1922 new_top_bs->backing_hd = base_bs;
1923
1924
1925 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
1926 /* so that bdrv_close() does not recursively close the chain */
1927 intermediate_state->bs->backing_hd = NULL;
1928 bdrv_delete(intermediate_state->bs);
1929 }
1930 ret = 0;
1931
1932exit:
1933 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
1934 g_free(intermediate_state);
1935 }
1936 return ret;
1937}
1938
1939
aliguori71d07702009-03-03 17:37:16 +00001940static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
1941 size_t size)
1942{
1943 int64_t len;
1944
1945 if (!bdrv_is_inserted(bs))
1946 return -ENOMEDIUM;
1947
1948 if (bs->growable)
1949 return 0;
1950
1951 len = bdrv_getlength(bs);
1952
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02001953 if (offset < 0)
1954 return -EIO;
1955
1956 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00001957 return -EIO;
1958
1959 return 0;
1960}
1961
1962static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
1963 int nb_sectors)
1964{
Jes Sorenseneb5a3162010-05-27 16:20:31 +02001965 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
1966 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00001967}
1968
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01001969typedef struct RwCo {
1970 BlockDriverState *bs;
1971 int64_t sector_num;
1972 int nb_sectors;
1973 QEMUIOVector *qiov;
1974 bool is_write;
1975 int ret;
1976} RwCo;
1977
1978static void coroutine_fn bdrv_rw_co_entry(void *opaque)
1979{
1980 RwCo *rwco = opaque;
1981
1982 if (!rwco->is_write) {
1983 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00001984 rwco->nb_sectors, rwco->qiov, 0);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01001985 } else {
1986 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00001987 rwco->nb_sectors, rwco->qiov, 0);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01001988 }
1989}
1990
1991/*
1992 * Process a synchronous request using coroutines
1993 */
1994static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
1995 int nb_sectors, bool is_write)
1996{
1997 QEMUIOVector qiov;
1998 struct iovec iov = {
1999 .iov_base = (void *)buf,
2000 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2001 };
2002 Coroutine *co;
2003 RwCo rwco = {
2004 .bs = bs,
2005 .sector_num = sector_num,
2006 .nb_sectors = nb_sectors,
2007 .qiov = &qiov,
2008 .is_write = is_write,
2009 .ret = NOT_DONE,
2010 };
2011
2012 qemu_iovec_init_external(&qiov, &iov, 1);
2013
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002014 /**
2015 * In sync call context, when the vcpu is blocked, this throttling timer
2016 * will not fire; so the I/O throttling function has to be disabled here
2017 * if it has been enabled.
2018 */
2019 if (bs->io_limits_enabled) {
2020 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2021 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2022 bdrv_io_limits_disable(bs);
2023 }
2024
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002025 if (qemu_in_coroutine()) {
2026 /* Fast-path if already in coroutine context */
2027 bdrv_rw_co_entry(&rwco);
2028 } else {
2029 co = qemu_coroutine_create(bdrv_rw_co_entry);
2030 qemu_coroutine_enter(co, &rwco);
2031 while (rwco.ret == NOT_DONE) {
2032 qemu_aio_wait();
2033 }
2034 }
2035 return rwco.ret;
2036}
2037
bellard19cb3732006-08-19 11:45:59 +00002038/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002039int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002040 uint8_t *buf, int nb_sectors)
2041{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002042 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
bellardfc01f7e2003-06-30 10:03:06 +00002043}
2044
Markus Armbruster07d27a42012-06-29 17:34:29 +02002045/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2046int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2047 uint8_t *buf, int nb_sectors)
2048{
2049 bool enabled;
2050 int ret;
2051
2052 enabled = bs->io_limits_enabled;
2053 bs->io_limits_enabled = false;
2054 ret = bdrv_read(bs, 0, buf, 1);
2055 bs->io_limits_enabled = enabled;
2056 return ret;
2057}
2058
ths5fafdf22007-09-16 21:08:06 +00002059/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002060 -EIO generic I/O error (may happen for all errors)
2061 -ENOMEDIUM No media inserted.
2062 -EINVAL Invalid sector number or nb_sectors
2063 -EACCES Trying to write a read-only device
2064*/
ths5fafdf22007-09-16 21:08:06 +00002065int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002066 const uint8_t *buf, int nb_sectors)
2067{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002068 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
bellard83f64092006-08-01 16:21:11 +00002069}
2070
aliguorieda578e2009-03-12 19:57:16 +00002071int bdrv_pread(BlockDriverState *bs, int64_t offset,
2072 void *buf, int count1)
bellard83f64092006-08-01 16:21:11 +00002073{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002074 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002075 int len, nb_sectors, count;
2076 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002077 int ret;
bellard83f64092006-08-01 16:21:11 +00002078
2079 count = count1;
2080 /* first read to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002081 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002082 if (len > count)
2083 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002084 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002085 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002086 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2087 return ret;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002088 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
bellard83f64092006-08-01 16:21:11 +00002089 count -= len;
2090 if (count == 0)
2091 return count1;
2092 sector_num++;
2093 buf += len;
2094 }
2095
2096 /* read the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002097 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002098 if (nb_sectors > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002099 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2100 return ret;
bellard83f64092006-08-01 16:21:11 +00002101 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002102 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002103 buf += len;
2104 count -= len;
2105 }
2106
2107 /* add data from the last sector */
2108 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002109 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2110 return ret;
bellard83f64092006-08-01 16:21:11 +00002111 memcpy(buf, tmp_buf, count);
2112 }
2113 return count1;
2114}
2115
aliguorieda578e2009-03-12 19:57:16 +00002116int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2117 const void *buf, int count1)
bellard83f64092006-08-01 16:21:11 +00002118{
Jan Kiszka6ea44302009-11-30 18:21:19 +01002119 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
bellard83f64092006-08-01 16:21:11 +00002120 int len, nb_sectors, count;
2121 int64_t sector_num;
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002122 int ret;
bellard83f64092006-08-01 16:21:11 +00002123
2124 count = count1;
2125 /* first write to align to sector start */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002126 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
bellard83f64092006-08-01 16:21:11 +00002127 if (len > count)
2128 len = count;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002129 sector_num = offset >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002130 if (len > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002131 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2132 return ret;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002133 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002134 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2135 return ret;
bellard83f64092006-08-01 16:21:11 +00002136 count -= len;
2137 if (count == 0)
2138 return count1;
2139 sector_num++;
2140 buf += len;
2141 }
2142
2143 /* write the sectors "in place" */
Jan Kiszka6ea44302009-11-30 18:21:19 +01002144 nb_sectors = count >> BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002145 if (nb_sectors > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002146 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
2147 return ret;
bellard83f64092006-08-01 16:21:11 +00002148 sector_num += nb_sectors;
Jan Kiszka6ea44302009-11-30 18:21:19 +01002149 len = nb_sectors << BDRV_SECTOR_BITS;
bellard83f64092006-08-01 16:21:11 +00002150 buf += len;
2151 count -= len;
2152 }
2153
2154 /* add data from the last sector */
2155 if (count > 0) {
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002156 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2157 return ret;
bellard83f64092006-08-01 16:21:11 +00002158 memcpy(tmp_buf, buf, count);
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002159 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2160 return ret;
bellard83f64092006-08-01 16:21:11 +00002161 }
2162 return count1;
2163}
bellard83f64092006-08-01 16:21:11 +00002164
Kevin Wolff08145f2010-06-16 16:38:15 +02002165/*
2166 * Writes to the file and ensures that no writes are reordered across this
2167 * request (acts as a barrier)
2168 *
2169 * Returns 0 on success, -errno in error cases.
2170 */
2171int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2172 const void *buf, int count)
2173{
2174 int ret;
2175
2176 ret = bdrv_pwrite(bs, offset, buf, count);
2177 if (ret < 0) {
2178 return ret;
2179 }
2180
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002181 /* No flush needed for cache modes that already do it */
2182 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002183 bdrv_flush(bs);
2184 }
2185
2186 return 0;
2187}
2188
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002189static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002190 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2191{
2192 /* Perform I/O through a temporary buffer so that users who scribble over
2193 * their read buffer while the operation is in progress do not end up
2194 * modifying the image file. This is critical for zero-copy guest I/O
2195 * where anything might happen inside guest memory.
2196 */
2197 void *bounce_buffer;
2198
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002199 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002200 struct iovec iov;
2201 QEMUIOVector bounce_qiov;
2202 int64_t cluster_sector_num;
2203 int cluster_nb_sectors;
2204 size_t skip_bytes;
2205 int ret;
2206
2207 /* Cover entire cluster so no additional backing file I/O is required when
2208 * allocating cluster in the image file.
2209 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002210 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2211 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002212
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002213 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2214 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002215
2216 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2217 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2218 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2219
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002220 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2221 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002222 if (ret < 0) {
2223 goto err;
2224 }
2225
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002226 if (drv->bdrv_co_write_zeroes &&
2227 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002228 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2229 cluster_nb_sectors);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002230 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002231 /* This does not change the data on the disk, it is not necessary
2232 * to flush even in cache=writethrough mode.
2233 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002234 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002235 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002236 }
2237
Stefan Hajnocziab185922011-11-17 13:40:31 +00002238 if (ret < 0) {
2239 /* It might be okay to ignore write errors for guest requests. If this
2240 * is a deliberate copy-on-read then we don't want to ignore the error.
2241 * Simply report it in all cases.
2242 */
2243 goto err;
2244 }
2245
2246 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04002247 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2248 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002249
2250err:
2251 qemu_vfree(bounce_buffer);
2252 return ret;
2253}
2254
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002255/*
2256 * Handle a read request in coroutine context
2257 */
2258static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002259 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2260 BdrvRequestFlags flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02002261{
2262 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002263 BdrvTrackedRequest req;
2264 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002265
Kevin Wolfda1fa912011-07-14 17:27:13 +02002266 if (!drv) {
2267 return -ENOMEDIUM;
2268 }
2269 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2270 return -EIO;
2271 }
2272
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08002273 /* throttling disk read I/O */
2274 if (bs->io_limits_enabled) {
2275 bdrv_io_limits_intercept(bs, false, nb_sectors);
2276 }
2277
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002278 if (bs->copy_on_read) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002279 flags |= BDRV_REQ_COPY_ON_READ;
2280 }
2281 if (flags & BDRV_REQ_COPY_ON_READ) {
2282 bs->copy_on_read_in_flight++;
2283 }
2284
2285 if (bs->copy_on_read_in_flight) {
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002286 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2287 }
2288
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002289 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002290
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002291 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00002292 int pnum;
2293
2294 ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum);
2295 if (ret < 0) {
2296 goto out;
2297 }
2298
2299 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002300 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002301 goto out;
2302 }
2303 }
2304
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002305 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00002306
2307out:
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002308 tracked_request_end(&req);
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002309
2310 if (flags & BDRV_REQ_COPY_ON_READ) {
2311 bs->copy_on_read_in_flight--;
2312 }
2313
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002314 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002315}
2316
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002317int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02002318 int nb_sectors, QEMUIOVector *qiov)
2319{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002320 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02002321
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002322 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
2323}
2324
2325int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
2326 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2327{
2328 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
2329
2330 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
2331 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002332}
2333
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002334static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
2335 int64_t sector_num, int nb_sectors)
2336{
2337 BlockDriver *drv = bs->drv;
2338 QEMUIOVector qiov;
2339 struct iovec iov;
2340 int ret;
2341
Kevin Wolf621f0582012-03-20 15:12:58 +01002342 /* TODO Emulate only part of misaligned requests instead of letting block
2343 * drivers return -ENOTSUP and emulate everything */
2344
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002345 /* First try the efficient write zeroes operation */
2346 if (drv->bdrv_co_write_zeroes) {
Kevin Wolf621f0582012-03-20 15:12:58 +01002347 ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2348 if (ret != -ENOTSUP) {
2349 return ret;
2350 }
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002351 }
2352
2353 /* Fall back to bounce buffer if write zeroes is unsupported */
2354 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2355 iov.iov_base = qemu_blockalign(bs, iov.iov_len);
2356 memset(iov.iov_base, 0, iov.iov_len);
2357 qemu_iovec_init_external(&qiov, &iov, 1);
2358
2359 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
2360
2361 qemu_vfree(iov.iov_base);
2362 return ret;
2363}
2364
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002365/*
2366 * Handle a write request in coroutine context
2367 */
2368static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002369 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2370 BdrvRequestFlags flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002371{
2372 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002373 BdrvTrackedRequest req;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002374 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002375
2376 if (!bs->drv) {
2377 return -ENOMEDIUM;
2378 }
2379 if (bs->read_only) {
2380 return -EACCES;
2381 }
2382 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2383 return -EIO;
2384 }
2385
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08002386 /* throttling disk write I/O */
2387 if (bs->io_limits_enabled) {
2388 bdrv_io_limits_intercept(bs, true, nb_sectors);
2389 }
2390
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002391 if (bs->copy_on_read_in_flight) {
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002392 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2393 }
2394
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002395 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
2396
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002397 if (flags & BDRV_REQ_ZERO_WRITE) {
2398 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors);
2399 } else {
2400 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
2401 }
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002402
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002403 if (ret == 0 && !bs->enable_write_cache) {
2404 ret = bdrv_co_flush(bs);
2405 }
2406
Kevin Wolfda1fa912011-07-14 17:27:13 +02002407 if (bs->dirty_bitmap) {
Paolo Bonzini1755da12012-10-18 16:49:18 +02002408 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02002409 }
2410
2411 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2412 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2413 }
2414
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002415 tracked_request_end(&req);
2416
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01002417 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02002418}
2419
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002420int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
2421 int nb_sectors, QEMUIOVector *qiov)
2422{
2423 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
2424
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00002425 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
2426}
2427
2428int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
2429 int64_t sector_num, int nb_sectors)
2430{
2431 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2432
2433 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
2434 BDRV_REQ_ZERO_WRITE);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01002435}
2436
bellard83f64092006-08-01 16:21:11 +00002437/**
bellard83f64092006-08-01 16:21:11 +00002438 * Truncate file to 'offset' bytes (needed only for file protocols)
2439 */
2440int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2441{
2442 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002443 int ret;
bellard83f64092006-08-01 16:21:11 +00002444 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002445 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00002446 if (!drv->bdrv_truncate)
2447 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02002448 if (bs->read_only)
2449 return -EACCES;
Marcelo Tosatti85916752011-01-26 12:12:35 -02002450 if (bdrv_in_use(bs))
2451 return -EBUSY;
Peter Lieven9a665b22013-02-18 13:48:31 +01002452
2453 /* There better not be any in-flight IOs when we truncate the device. */
2454 bdrv_drain_all();
2455
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002456 ret = drv->bdrv_truncate(bs, offset);
2457 if (ret == 0) {
2458 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02002459 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002460 }
2461 return ret;
bellard83f64092006-08-01 16:21:11 +00002462}
2463
2464/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002465 * Length of a allocated file in bytes. Sparse files are counted by actual
2466 * allocated space. Return < 0 if error or unknown.
2467 */
2468int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2469{
2470 BlockDriver *drv = bs->drv;
2471 if (!drv) {
2472 return -ENOMEDIUM;
2473 }
2474 if (drv->bdrv_get_allocated_file_size) {
2475 return drv->bdrv_get_allocated_file_size(bs);
2476 }
2477 if (bs->file) {
2478 return bdrv_get_allocated_file_size(bs->file);
2479 }
2480 return -ENOTSUP;
2481}
2482
2483/**
bellard83f64092006-08-01 16:21:11 +00002484 * Length of a file in bytes. Return < 0 if error or unknown.
2485 */
2486int64_t bdrv_getlength(BlockDriverState *bs)
2487{
2488 BlockDriver *drv = bs->drv;
2489 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002490 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002491
Markus Armbruster2c6942f2011-09-06 18:58:51 +02002492 if (bs->growable || bdrv_dev_has_removable_media(bs)) {
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002493 if (drv->bdrv_getlength) {
2494 return drv->bdrv_getlength(bs);
2495 }
bellard83f64092006-08-01 16:21:11 +00002496 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002497 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00002498}
2499
bellard19cb3732006-08-19 11:45:59 +00002500/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00002501void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00002502{
bellard19cb3732006-08-19 11:45:59 +00002503 int64_t length;
2504 length = bdrv_getlength(bs);
2505 if (length < 0)
2506 length = 0;
2507 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01002508 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00002509 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00002510}
bellardcf989512004-02-16 21:56:36 +00002511
Zhi Yong Wu0563e192011-11-03 16:57:25 +08002512/* throttling disk io limits */
2513void bdrv_set_io_limits(BlockDriverState *bs,
2514 BlockIOLimit *io_limits)
2515{
2516 bs->io_limits = *io_limits;
2517 bs->io_limits_enabled = bdrv_io_limits_enabled(bs);
2518}
2519
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02002520void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2521 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002522{
2523 bs->on_read_error = on_read_error;
2524 bs->on_write_error = on_write_error;
2525}
2526
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02002527BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02002528{
2529 return is_read ? bs->on_read_error : bs->on_write_error;
2530}
2531
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002532BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2533{
2534 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2535
2536 switch (on_err) {
2537 case BLOCKDEV_ON_ERROR_ENOSPC:
2538 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
2539 case BLOCKDEV_ON_ERROR_STOP:
2540 return BDRV_ACTION_STOP;
2541 case BLOCKDEV_ON_ERROR_REPORT:
2542 return BDRV_ACTION_REPORT;
2543 case BLOCKDEV_ON_ERROR_IGNORE:
2544 return BDRV_ACTION_IGNORE;
2545 default:
2546 abort();
2547 }
2548}
2549
2550/* This is done by device models because, while the block layer knows
2551 * about the error, it does not know whether an operation comes from
2552 * the device or the block layer (from a job, for example).
2553 */
2554void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2555 bool is_read, int error)
2556{
2557 assert(error >= 0);
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002558 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02002559 if (action == BDRV_ACTION_STOP) {
2560 vm_stop(RUN_STATE_IO_ERROR);
2561 bdrv_iostatus_set_err(bs, error);
2562 }
2563}
2564
bellardb3380822004-03-14 21:38:54 +00002565int bdrv_is_read_only(BlockDriverState *bs)
2566{
2567 return bs->read_only;
2568}
2569
ths985a03b2007-12-24 16:10:43 +00002570int bdrv_is_sg(BlockDriverState *bs)
2571{
2572 return bs->sg;
2573}
2574
Christoph Hellwige900a7b2009-09-04 19:01:15 +02002575int bdrv_enable_write_cache(BlockDriverState *bs)
2576{
2577 return bs->enable_write_cache;
2578}
2579
Paolo Bonzini425b0142012-06-06 00:04:52 +02002580void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2581{
2582 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04002583
2584 /* so a reopen() will preserve wce */
2585 if (wce) {
2586 bs->open_flags |= BDRV_O_CACHE_WB;
2587 } else {
2588 bs->open_flags &= ~BDRV_O_CACHE_WB;
2589 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02002590}
2591
bellardea2384d2004-08-01 21:59:26 +00002592int bdrv_is_encrypted(BlockDriverState *bs)
2593{
2594 if (bs->backing_hd && bs->backing_hd->encrypted)
2595 return 1;
2596 return bs->encrypted;
2597}
2598
aliguoric0f4ce72009-03-05 23:01:01 +00002599int bdrv_key_required(BlockDriverState *bs)
2600{
2601 BlockDriverState *backing_hd = bs->backing_hd;
2602
2603 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2604 return 1;
2605 return (bs->encrypted && !bs->valid_key);
2606}
2607
bellardea2384d2004-08-01 21:59:26 +00002608int bdrv_set_key(BlockDriverState *bs, const char *key)
2609{
2610 int ret;
2611 if (bs->backing_hd && bs->backing_hd->encrypted) {
2612 ret = bdrv_set_key(bs->backing_hd, key);
2613 if (ret < 0)
2614 return ret;
2615 if (!bs->encrypted)
2616 return 0;
2617 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02002618 if (!bs->encrypted) {
2619 return -EINVAL;
2620 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2621 return -ENOMEDIUM;
2622 }
aliguoric0f4ce72009-03-05 23:01:01 +00002623 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00002624 if (ret < 0) {
2625 bs->valid_key = 0;
2626 } else if (!bs->valid_key) {
2627 bs->valid_key = 1;
2628 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002629 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00002630 }
aliguoric0f4ce72009-03-05 23:01:01 +00002631 return ret;
bellardea2384d2004-08-01 21:59:26 +00002632}
2633
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002634const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00002635{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002636 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00002637}
2638
ths5fafdf22007-09-16 21:08:06 +00002639void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00002640 void *opaque)
2641{
2642 BlockDriver *drv;
2643
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01002644 QLIST_FOREACH(drv, &bdrv_drivers, list) {
bellardea2384d2004-08-01 21:59:26 +00002645 it(opaque, drv->format_name);
2646 }
2647}
2648
bellardb3380822004-03-14 21:38:54 +00002649BlockDriverState *bdrv_find(const char *name)
2650{
2651 BlockDriverState *bs;
2652
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002653 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2654 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00002655 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002656 }
bellardb3380822004-03-14 21:38:54 +00002657 }
2658 return NULL;
2659}
2660
Markus Armbruster2f399b02010-06-02 18:55:20 +02002661BlockDriverState *bdrv_next(BlockDriverState *bs)
2662{
2663 if (!bs) {
2664 return QTAILQ_FIRST(&bdrv_states);
2665 }
2666 return QTAILQ_NEXT(bs, list);
2667}
2668
aliguori51de9762009-03-05 23:00:43 +00002669void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00002670{
2671 BlockDriverState *bs;
2672
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002673 QTAILQ_FOREACH(bs, &bdrv_states, list) {
aliguori51de9762009-03-05 23:00:43 +00002674 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00002675 }
2676}
2677
bellardea2384d2004-08-01 21:59:26 +00002678const char *bdrv_get_device_name(BlockDriverState *bs)
2679{
2680 return bs->device_name;
2681}
2682
Markus Armbrusterc8433282012-06-05 16:49:24 +02002683int bdrv_get_flags(BlockDriverState *bs)
2684{
2685 return bs->open_flags;
2686}
2687
aliguoric6ca28d2008-10-06 13:55:43 +00002688void bdrv_flush_all(void)
2689{
2690 BlockDriverState *bs;
2691
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002692 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01002693 bdrv_flush(bs);
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002694 }
aliguoric6ca28d2008-10-06 13:55:43 +00002695}
2696
Kevin Wolff2feebb2010-04-14 17:30:35 +02002697int bdrv_has_zero_init(BlockDriverState *bs)
2698{
2699 assert(bs->drv);
2700
Kevin Wolf336c1c12010-07-28 11:26:29 +02002701 if (bs->drv->bdrv_has_zero_init) {
2702 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02002703 }
2704
2705 return 1;
2706}
2707
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00002708typedef struct BdrvCoIsAllocatedData {
2709 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01002710 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00002711 int64_t sector_num;
2712 int nb_sectors;
2713 int *pnum;
2714 int ret;
2715 bool done;
2716} BdrvCoIsAllocatedData;
2717
thsf58c7b32008-06-05 21:53:49 +00002718/*
2719 * Returns true iff the specified sector is present in the disk image. Drivers
2720 * not implementing the functionality are assumed to not support backing files,
2721 * hence all their sectors are reported as allocated.
2722 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00002723 * If 'sector_num' is beyond the end of the disk image the return value is 0
2724 * and 'pnum' is set to 0.
2725 *
thsf58c7b32008-06-05 21:53:49 +00002726 * 'pnum' is set to the number of sectors (including and immediately following
2727 * the specified sector) that are known to be in the same
2728 * allocated/unallocated state.
2729 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00002730 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2731 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00002732 */
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00002733int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
2734 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00002735{
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00002736 int64_t n;
2737
2738 if (sector_num >= bs->total_sectors) {
2739 *pnum = 0;
2740 return 0;
2741 }
2742
2743 n = bs->total_sectors - sector_num;
2744 if (n < nb_sectors) {
2745 nb_sectors = n;
2746 }
2747
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00002748 if (!bs->drv->bdrv_co_is_allocated) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00002749 *pnum = nb_sectors;
thsf58c7b32008-06-05 21:53:49 +00002750 return 1;
2751 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00002752
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00002753 return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum);
2754}
2755
2756/* Coroutine wrapper for bdrv_is_allocated() */
2757static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque)
2758{
2759 BdrvCoIsAllocatedData *data = opaque;
2760 BlockDriverState *bs = data->bs;
2761
2762 data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors,
2763 data->pnum);
2764 data->done = true;
2765}
2766
2767/*
2768 * Synchronous wrapper around bdrv_co_is_allocated().
2769 *
2770 * See bdrv_co_is_allocated() for details.
2771 */
2772int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2773 int *pnum)
2774{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00002775 Coroutine *co;
2776 BdrvCoIsAllocatedData data = {
2777 .bs = bs,
2778 .sector_num = sector_num,
2779 .nb_sectors = nb_sectors,
2780 .pnum = pnum,
2781 .done = false,
2782 };
2783
2784 co = qemu_coroutine_create(bdrv_is_allocated_co_entry);
2785 qemu_coroutine_enter(co, &data);
2786 while (!data.done) {
2787 qemu_aio_wait();
2788 }
2789 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00002790}
2791
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02002792/*
2793 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2794 *
2795 * Return true if the given sector is allocated in any image between
2796 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2797 * sector is allocated in any image of the chain. Return false otherwise.
2798 *
2799 * 'pnum' is set to the number of sectors (including and immediately following
2800 * the specified sector) that are known to be in the same
2801 * allocated/unallocated state.
2802 *
2803 */
2804int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
2805 BlockDriverState *base,
2806 int64_t sector_num,
2807 int nb_sectors, int *pnum)
2808{
2809 BlockDriverState *intermediate;
2810 int ret, n = nb_sectors;
2811
2812 intermediate = top;
2813 while (intermediate && intermediate != base) {
2814 int pnum_inter;
2815 ret = bdrv_co_is_allocated(intermediate, sector_num, nb_sectors,
2816 &pnum_inter);
2817 if (ret < 0) {
2818 return ret;
2819 } else if (ret) {
2820 *pnum = pnum_inter;
2821 return 1;
2822 }
2823
2824 /*
2825 * [sector_num, nb_sectors] is unallocated on top but intermediate
2826 * might have
2827 *
2828 * [sector_num+x, nr_sectors] allocated.
2829 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08002830 if (n > pnum_inter &&
2831 (intermediate == top ||
2832 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02002833 n = pnum_inter;
2834 }
2835
2836 intermediate = intermediate->backing_hd;
2837 }
2838
2839 *pnum = n;
2840 return 0;
2841}
2842
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01002843/* Coroutine wrapper for bdrv_is_allocated_above() */
2844static void coroutine_fn bdrv_is_allocated_above_co_entry(void *opaque)
2845{
2846 BdrvCoIsAllocatedData *data = opaque;
2847 BlockDriverState *top = data->bs;
2848 BlockDriverState *base = data->base;
2849
2850 data->ret = bdrv_co_is_allocated_above(top, base, data->sector_num,
2851 data->nb_sectors, data->pnum);
2852 data->done = true;
2853}
2854
2855/*
2856 * Synchronous wrapper around bdrv_co_is_allocated_above().
2857 *
2858 * See bdrv_co_is_allocated_above() for details.
2859 */
2860int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
2861 int64_t sector_num, int nb_sectors, int *pnum)
2862{
2863 Coroutine *co;
2864 BdrvCoIsAllocatedData data = {
2865 .bs = top,
2866 .base = base,
2867 .sector_num = sector_num,
2868 .nb_sectors = nb_sectors,
2869 .pnum = pnum,
2870 .done = false,
2871 };
2872
2873 co = qemu_coroutine_create(bdrv_is_allocated_above_co_entry);
2874 qemu_coroutine_enter(co, &data);
2875 while (!data.done) {
2876 qemu_aio_wait();
2877 }
2878 return data.ret;
2879}
2880
Paolo Bonziniac84ada2012-10-18 16:49:15 +02002881BlockInfo *bdrv_query_info(BlockDriverState *bs)
2882{
2883 BlockInfo *info = g_malloc0(sizeof(*info));
2884 info->device = g_strdup(bs->device_name);
2885 info->type = g_strdup("unknown");
2886 info->locked = bdrv_dev_is_medium_locked(bs);
2887 info->removable = bdrv_dev_has_removable_media(bs);
2888
2889 if (bdrv_dev_has_removable_media(bs)) {
2890 info->has_tray_open = true;
2891 info->tray_open = bdrv_dev_is_tray_open(bs);
2892 }
2893
2894 if (bdrv_iostatus_is_enabled(bs)) {
2895 info->has_io_status = true;
2896 info->io_status = bs->iostatus;
2897 }
2898
Paolo Bonzinib9a9b3a2012-08-01 15:23:44 +02002899 if (bs->dirty_bitmap) {
2900 info->has_dirty = true;
2901 info->dirty = g_malloc0(sizeof(*info->dirty));
Paolo Bonziniacc906c2013-01-21 17:09:44 +01002902 info->dirty->count = bdrv_get_dirty_count(bs) * BDRV_SECTOR_SIZE;
Paolo Bonzini50717e92013-01-21 17:09:45 +01002903 info->dirty->granularity =
2904 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bs->dirty_bitmap));
Paolo Bonzinib9a9b3a2012-08-01 15:23:44 +02002905 }
2906
Paolo Bonziniac84ada2012-10-18 16:49:15 +02002907 if (bs->drv) {
2908 info->has_inserted = true;
2909 info->inserted = g_malloc0(sizeof(*info->inserted));
2910 info->inserted->file = g_strdup(bs->filename);
2911 info->inserted->ro = bs->read_only;
2912 info->inserted->drv = g_strdup(bs->drv->format_name);
2913 info->inserted->encrypted = bs->encrypted;
2914 info->inserted->encryption_key_missing = bdrv_key_required(bs);
2915
2916 if (bs->backing_file[0]) {
2917 info->inserted->has_backing_file = true;
2918 info->inserted->backing_file = g_strdup(bs->backing_file);
2919 }
2920
2921 info->inserted->backing_file_depth = bdrv_get_backing_file_depth(bs);
2922
2923 if (bs->io_limits_enabled) {
2924 info->inserted->bps =
2925 bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
2926 info->inserted->bps_rd =
2927 bs->io_limits.bps[BLOCK_IO_LIMIT_READ];
2928 info->inserted->bps_wr =
2929 bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];
2930 info->inserted->iops =
2931 bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
2932 info->inserted->iops_rd =
2933 bs->io_limits.iops[BLOCK_IO_LIMIT_READ];
2934 info->inserted->iops_wr =
2935 bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];
2936 }
2937 }
2938 return info;
2939}
2940
Luiz Capitulinob2023812011-09-21 17:16:47 -03002941BlockInfoList *qmp_query_block(Error **errp)
bellardb3380822004-03-14 21:38:54 +00002942{
Paolo Bonziniac84ada2012-10-18 16:49:15 +02002943 BlockInfoList *head = NULL, **p_next = &head;
bellardb3380822004-03-14 21:38:54 +00002944 BlockDriverState *bs;
2945
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002946 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Luiz Capitulinob2023812011-09-21 17:16:47 -03002947 BlockInfoList *info = g_malloc0(sizeof(*info));
Paolo Bonziniac84ada2012-10-18 16:49:15 +02002948 info->value = bdrv_query_info(bs);
Luiz Capitulinod15e5462009-12-10 17:16:06 -02002949
Paolo Bonziniac84ada2012-10-18 16:49:15 +02002950 *p_next = info;
2951 p_next = &info->next;
bellardb3380822004-03-14 21:38:54 +00002952 }
Luiz Capitulinod15e5462009-12-10 17:16:06 -02002953
Luiz Capitulinob2023812011-09-21 17:16:47 -03002954 return head;
bellardb3380822004-03-14 21:38:54 +00002955}
thsa36e69d2007-12-02 05:18:19 +00002956
Paolo Bonzini9887b612012-10-18 16:49:16 +02002957BlockStats *bdrv_query_stats(const BlockDriverState *bs)
thsa36e69d2007-12-02 05:18:19 +00002958{
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002959 BlockStats *s;
Luiz Capitulino218a5362009-12-10 17:16:07 -02002960
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002961 s = g_malloc0(sizeof(*s));
Luiz Capitulino218a5362009-12-10 17:16:07 -02002962
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002963 if (bs->device_name[0]) {
2964 s->has_device = true;
2965 s->device = g_strdup(bs->device_name);
Kevin Wolf294cc352010-04-28 14:34:01 +02002966 }
2967
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002968 s->stats = g_malloc0(sizeof(*s->stats));
2969 s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];
2970 s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];
2971 s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];
2972 s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];
2973 s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;
2974 s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];
2975 s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];
2976 s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];
2977 s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];
2978
Kevin Wolf294cc352010-04-28 14:34:01 +02002979 if (bs->file) {
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002980 s->has_parent = true;
Paolo Bonzini9887b612012-10-18 16:49:16 +02002981 s->parent = bdrv_query_stats(bs->file);
Kevin Wolf294cc352010-04-28 14:34:01 +02002982 }
2983
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002984 return s;
Kevin Wolf294cc352010-04-28 14:34:01 +02002985}
2986
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002987BlockStatsList *qmp_query_blockstats(Error **errp)
Luiz Capitulino218a5362009-12-10 17:16:07 -02002988{
Paolo Bonzini9887b612012-10-18 16:49:16 +02002989 BlockStatsList *head = NULL, **p_next = &head;
thsa36e69d2007-12-02 05:18:19 +00002990 BlockDriverState *bs;
2991
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002992 QTAILQ_FOREACH(bs, &bdrv_states, list) {
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002993 BlockStatsList *info = g_malloc0(sizeof(*info));
Paolo Bonzini9887b612012-10-18 16:49:16 +02002994 info->value = bdrv_query_stats(bs);
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002995
Paolo Bonzini9887b612012-10-18 16:49:16 +02002996 *p_next = info;
2997 p_next = &info->next;
thsa36e69d2007-12-02 05:18:19 +00002998 }
Luiz Capitulino218a5362009-12-10 17:16:07 -02002999
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03003000 return head;
thsa36e69d2007-12-02 05:18:19 +00003001}
bellardea2384d2004-08-01 21:59:26 +00003002
aliguori045df332009-03-05 23:00:48 +00003003const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3004{
3005 if (bs->backing_hd && bs->backing_hd->encrypted)
3006 return bs->backing_file;
3007 else if (bs->encrypted)
3008 return bs->filename;
3009 else
3010 return NULL;
3011}
3012
ths5fafdf22007-09-16 21:08:06 +00003013void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00003014 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00003015{
Kevin Wolf3574c602011-10-26 11:02:11 +02003016 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00003017}
3018
ths5fafdf22007-09-16 21:08:06 +00003019int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00003020 const uint8_t *buf, int nb_sectors)
3021{
3022 BlockDriver *drv = bs->drv;
3023 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003024 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003025 if (!drv->bdrv_write_compressed)
3026 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02003027 if (bdrv_check_request(bs, sector_num, nb_sectors))
3028 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003029
Paolo Bonzini1755da12012-10-18 16:49:18 +02003030 assert(!bs->dirty_bitmap);
Jan Kiszkaa55eb922009-11-30 18:21:19 +01003031
bellardfaea38e2006-08-05 21:31:00 +00003032 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
3033}
ths3b46e622007-09-17 08:09:54 +00003034
bellardfaea38e2006-08-05 21:31:00 +00003035int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3036{
3037 BlockDriver *drv = bs->drv;
3038 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003039 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003040 if (!drv->bdrv_get_info)
3041 return -ENOTSUP;
3042 memset(bdi, 0, sizeof(*bdi));
3043 return drv->bdrv_get_info(bs, bdi);
3044}
3045
Christoph Hellwig45566e92009-07-10 23:11:57 +02003046int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
3047 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003048{
3049 BlockDriver *drv = bs->drv;
3050 if (!drv)
3051 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003052 if (drv->bdrv_save_vmstate)
3053 return drv->bdrv_save_vmstate(bs, buf, pos, size);
3054 if (bs->file)
3055 return bdrv_save_vmstate(bs->file, buf, pos, size);
3056 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003057}
3058
Christoph Hellwig45566e92009-07-10 23:11:57 +02003059int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
3060 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00003061{
3062 BlockDriver *drv = bs->drv;
3063 if (!drv)
3064 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003065 if (drv->bdrv_load_vmstate)
3066 return drv->bdrv_load_vmstate(bs, buf, pos, size);
3067 if (bs->file)
3068 return bdrv_load_vmstate(bs->file, buf, pos, size);
3069 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00003070}
3071
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003072void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3073{
3074 BlockDriver *drv = bs->drv;
3075
3076 if (!drv || !drv->bdrv_debug_event) {
3077 return;
3078 }
3079
Blue Swirl0ed8b6f2012-07-08 06:56:53 +00003080 drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003081}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003082
Kevin Wolf41c695c2012-12-06 14:32:58 +01003083int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3084 const char *tag)
3085{
3086 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3087 bs = bs->file;
3088 }
3089
3090 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3091 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3092 }
3093
3094 return -ENOTSUP;
3095}
3096
3097int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3098{
3099 while (bs && bs->drv && !bs->drv->bdrv_debug_resume) {
3100 bs = bs->file;
3101 }
3102
3103 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3104 return bs->drv->bdrv_debug_resume(bs, tag);
3105 }
3106
3107 return -ENOTSUP;
3108}
3109
3110bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3111{
3112 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3113 bs = bs->file;
3114 }
3115
3116 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3117 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3118 }
3119
3120 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003121}
3122
bellardfaea38e2006-08-05 21:31:00 +00003123/**************************************************************/
3124/* handling of snapshots */
3125
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03003126int bdrv_can_snapshot(BlockDriverState *bs)
3127{
3128 BlockDriver *drv = bs->drv;
Markus Armbruster07b70bf2011-08-03 15:08:11 +02003129 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Miguel Di Ciurcio Filhofeeee5a2010-06-08 10:40:55 -03003130 return 0;
3131 }
3132
3133 if (!drv->bdrv_snapshot_create) {
3134 if (bs->file != NULL) {
3135 return bdrv_can_snapshot(bs->file);
3136 }
3137 return 0;
3138 }
3139
3140 return 1;
3141}
3142
Blue Swirl199630b2010-07-25 20:49:34 +00003143int bdrv_is_snapshot(BlockDriverState *bs)
3144{
3145 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3146}
3147
Markus Armbrusterf9092b12010-06-25 10:33:39 +02003148BlockDriverState *bdrv_snapshots(void)
3149{
3150 BlockDriverState *bs;
3151
Markus Armbruster3ac906f2010-07-01 09:30:38 +02003152 if (bs_snapshots) {
Markus Armbrusterf9092b12010-06-25 10:33:39 +02003153 return bs_snapshots;
Markus Armbruster3ac906f2010-07-01 09:30:38 +02003154 }
Markus Armbrusterf9092b12010-06-25 10:33:39 +02003155
3156 bs = NULL;
3157 while ((bs = bdrv_next(bs))) {
3158 if (bdrv_can_snapshot(bs)) {
Markus Armbruster3ac906f2010-07-01 09:30:38 +02003159 bs_snapshots = bs;
3160 return bs;
Markus Armbrusterf9092b12010-06-25 10:33:39 +02003161 }
3162 }
3163 return NULL;
Markus Armbrusterf9092b12010-06-25 10:33:39 +02003164}
3165
ths5fafdf22007-09-16 21:08:06 +00003166int bdrv_snapshot_create(BlockDriverState *bs,
bellardfaea38e2006-08-05 21:31:00 +00003167 QEMUSnapshotInfo *sn_info)
3168{
3169 BlockDriver *drv = bs->drv;
3170 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003171 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003172 if (drv->bdrv_snapshot_create)
3173 return drv->bdrv_snapshot_create(bs, sn_info);
3174 if (bs->file)
3175 return bdrv_snapshot_create(bs->file, sn_info);
3176 return -ENOTSUP;
bellardfaea38e2006-08-05 21:31:00 +00003177}
3178
ths5fafdf22007-09-16 21:08:06 +00003179int bdrv_snapshot_goto(BlockDriverState *bs,
bellardfaea38e2006-08-05 21:31:00 +00003180 const char *snapshot_id)
3181{
3182 BlockDriver *drv = bs->drv;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003183 int ret, open_ret;
3184
bellardfaea38e2006-08-05 21:31:00 +00003185 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003186 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003187 if (drv->bdrv_snapshot_goto)
3188 return drv->bdrv_snapshot_goto(bs, snapshot_id);
3189
3190 if (bs->file) {
3191 drv->bdrv_close(bs);
3192 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
3193 open_ret = drv->bdrv_open(bs, bs->open_flags);
3194 if (open_ret < 0) {
3195 bdrv_delete(bs->file);
3196 bs->drv = NULL;
3197 return open_ret;
3198 }
3199 return ret;
3200 }
3201
3202 return -ENOTSUP;
bellardfaea38e2006-08-05 21:31:00 +00003203}
3204
3205int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
3206{
3207 BlockDriver *drv = bs->drv;
3208 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003209 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003210 if (drv->bdrv_snapshot_delete)
3211 return drv->bdrv_snapshot_delete(bs, snapshot_id);
3212 if (bs->file)
3213 return bdrv_snapshot_delete(bs->file, snapshot_id);
3214 return -ENOTSUP;
bellardfaea38e2006-08-05 21:31:00 +00003215}
3216
ths5fafdf22007-09-16 21:08:06 +00003217int bdrv_snapshot_list(BlockDriverState *bs,
bellardfaea38e2006-08-05 21:31:00 +00003218 QEMUSnapshotInfo **psn_info)
3219{
3220 BlockDriver *drv = bs->drv;
3221 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003222 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09003223 if (drv->bdrv_snapshot_list)
3224 return drv->bdrv_snapshot_list(bs, psn_info);
3225 if (bs->file)
3226 return bdrv_snapshot_list(bs->file, psn_info);
3227 return -ENOTSUP;
bellardfaea38e2006-08-05 21:31:00 +00003228}
3229
edison51ef6722010-09-21 19:58:41 -07003230int bdrv_snapshot_load_tmp(BlockDriverState *bs,
3231 const char *snapshot_name)
3232{
3233 BlockDriver *drv = bs->drv;
3234 if (!drv) {
3235 return -ENOMEDIUM;
3236 }
3237 if (!bs->read_only) {
3238 return -EINVAL;
3239 }
3240 if (drv->bdrv_snapshot_load_tmp) {
3241 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
3242 }
3243 return -ENOTSUP;
3244}
3245
Jeff Codyb1b1d782012-10-16 15:49:09 -04003246/* backing_file can either be relative, or absolute, or a protocol. If it is
3247 * relative, it must be relative to the chain. So, passing in bs->filename
3248 * from a BDS as backing_file should not be done, as that may be relative to
3249 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003250BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3251 const char *backing_file)
3252{
Jeff Codyb1b1d782012-10-16 15:49:09 -04003253 char *filename_full = NULL;
3254 char *backing_file_full = NULL;
3255 char *filename_tmp = NULL;
3256 int is_protocol = 0;
3257 BlockDriverState *curr_bs = NULL;
3258 BlockDriverState *retval = NULL;
3259
3260 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003261 return NULL;
3262 }
3263
Jeff Codyb1b1d782012-10-16 15:49:09 -04003264 filename_full = g_malloc(PATH_MAX);
3265 backing_file_full = g_malloc(PATH_MAX);
3266 filename_tmp = g_malloc(PATH_MAX);
3267
3268 is_protocol = path_has_protocol(backing_file);
3269
3270 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3271
3272 /* If either of the filename paths is actually a protocol, then
3273 * compare unmodified paths; otherwise make paths relative */
3274 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3275 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3276 retval = curr_bs->backing_hd;
3277 break;
3278 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003279 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003280 /* If not an absolute filename path, make it relative to the current
3281 * image's filename path */
3282 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3283 backing_file);
3284
3285 /* We are going to compare absolute pathnames */
3286 if (!realpath(filename_tmp, filename_full)) {
3287 continue;
3288 }
3289
3290 /* We need to make sure the backing filename we are comparing against
3291 * is relative to the current image filename (or absolute) */
3292 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3293 curr_bs->backing_file);
3294
3295 if (!realpath(filename_tmp, backing_file_full)) {
3296 continue;
3297 }
3298
3299 if (strcmp(backing_file_full, filename_full) == 0) {
3300 retval = curr_bs->backing_hd;
3301 break;
3302 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003303 }
3304 }
3305
Jeff Codyb1b1d782012-10-16 15:49:09 -04003306 g_free(filename_full);
3307 g_free(backing_file_full);
3308 g_free(filename_tmp);
3309 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003310}
3311
Benoît Canetf198fd12012-08-02 10:22:47 +02003312int bdrv_get_backing_file_depth(BlockDriverState *bs)
3313{
3314 if (!bs->drv) {
3315 return 0;
3316 }
3317
3318 if (!bs->backing_hd) {
3319 return 0;
3320 }
3321
3322 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3323}
3324
Jeff Cody79fac562012-09-27 13:29:15 -04003325BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3326{
3327 BlockDriverState *curr_bs = NULL;
3328
3329 if (!bs) {
3330 return NULL;
3331 }
3332
3333 curr_bs = bs;
3334
3335 while (curr_bs->backing_hd) {
3336 curr_bs = curr_bs->backing_hd;
3337 }
3338 return curr_bs;
3339}
3340
bellardfaea38e2006-08-05 21:31:00 +00003341#define NB_SUFFIXES 4
3342
3343char *get_human_readable_size(char *buf, int buf_size, int64_t size)
3344{
3345 static const char suffixes[NB_SUFFIXES] = "KMGT";
3346 int64_t base;
3347 int i;
3348
3349 if (size <= 999) {
3350 snprintf(buf, buf_size, "%" PRId64, size);
3351 } else {
3352 base = 1024;
3353 for(i = 0; i < NB_SUFFIXES; i++) {
3354 if (size < (10 * base)) {
ths5fafdf22007-09-16 21:08:06 +00003355 snprintf(buf, buf_size, "%0.1f%c",
bellardfaea38e2006-08-05 21:31:00 +00003356 (double)size / base,
3357 suffixes[i]);
3358 break;
3359 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
ths5fafdf22007-09-16 21:08:06 +00003360 snprintf(buf, buf_size, "%" PRId64 "%c",
bellardfaea38e2006-08-05 21:31:00 +00003361 ((size + (base >> 1)) / base),
3362 suffixes[i]);
3363 break;
3364 }
3365 base = base * 1024;
3366 }
3367 }
3368 return buf;
3369}
3370
3371char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
3372{
3373 char buf1[128], date_buf[128], clock_buf[128];
3374 struct tm tm;
3375 time_t ti;
3376 int64_t secs;
3377
3378 if (!sn) {
ths5fafdf22007-09-16 21:08:06 +00003379 snprintf(buf, buf_size,
3380 "%-10s%-20s%7s%20s%15s",
bellardfaea38e2006-08-05 21:31:00 +00003381 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3382 } else {
3383 ti = sn->date_sec;
3384 localtime_r(&ti, &tm);
3385 strftime(date_buf, sizeof(date_buf),
3386 "%Y-%m-%d %H:%M:%S", &tm);
3387 secs = sn->vm_clock_nsec / 1000000000;
3388 snprintf(clock_buf, sizeof(clock_buf),
3389 "%02d:%02d:%02d.%03d",
3390 (int)(secs / 3600),
3391 (int)((secs / 60) % 60),
ths5fafdf22007-09-16 21:08:06 +00003392 (int)(secs % 60),
bellardfaea38e2006-08-05 21:31:00 +00003393 (int)((sn->vm_clock_nsec / 1000000) % 1000));
3394 snprintf(buf, buf_size,
ths5fafdf22007-09-16 21:08:06 +00003395 "%-10s%-20s%7s%20s%15s",
bellardfaea38e2006-08-05 21:31:00 +00003396 sn->id_str, sn->name,
3397 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
3398 date_buf,
3399 clock_buf);
3400 }
3401 return buf;
3402}
3403
bellard83f64092006-08-01 16:21:11 +00003404/**************************************************************/
3405/* async I/Os */
3406
aliguori3b69e4b2009-01-22 16:59:24 +00003407BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00003408 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00003409 BlockDriverCompletionFunc *cb, void *opaque)
3410{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01003411 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
3412
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003413 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003414 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00003415}
3416
aliguorif141eaf2009-04-07 18:43:24 +00003417BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
3418 QEMUIOVector *qiov, int nb_sectors,
3419 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00003420{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01003421 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
3422
Stefan Hajnoczi1a6e1152011-10-13 13:08:25 +01003423 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003424 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00003425}
3426
Kevin Wolf40b4f532009-09-09 17:53:37 +02003427
3428typedef struct MultiwriteCB {
3429 int error;
3430 int num_requests;
3431 int num_callbacks;
3432 struct {
3433 BlockDriverCompletionFunc *cb;
3434 void *opaque;
3435 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003436 } callbacks[];
3437} MultiwriteCB;
3438
3439static void multiwrite_user_cb(MultiwriteCB *mcb)
3440{
3441 int i;
3442
3443 for (i = 0; i < mcb->num_callbacks; i++) {
3444 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01003445 if (mcb->callbacks[i].free_qiov) {
3446 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
3447 }
Anthony Liguori7267c092011-08-20 22:09:37 -05003448 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003449 }
3450}
3451
3452static void multiwrite_cb(void *opaque, int ret)
3453{
3454 MultiwriteCB *mcb = opaque;
3455
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01003456 trace_multiwrite_cb(mcb, ret);
3457
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02003458 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02003459 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003460 }
3461
3462 mcb->num_requests--;
3463 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02003464 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05003465 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003466 }
3467}
3468
3469static int multiwrite_req_compare(const void *a, const void *b)
3470{
Christoph Hellwig77be4362010-05-19 20:53:10 +02003471 const BlockRequest *req1 = a, *req2 = b;
3472
3473 /*
3474 * Note that we can't simply subtract req2->sector from req1->sector
3475 * here as that could overflow the return value.
3476 */
3477 if (req1->sector > req2->sector) {
3478 return 1;
3479 } else if (req1->sector < req2->sector) {
3480 return -1;
3481 } else {
3482 return 0;
3483 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02003484}
3485
3486/*
3487 * Takes a bunch of requests and tries to merge them. Returns the number of
3488 * requests that remain after merging.
3489 */
3490static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
3491 int num_reqs, MultiwriteCB *mcb)
3492{
3493 int i, outidx;
3494
3495 // Sort requests by start sector
3496 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
3497
3498 // Check if adjacent requests touch the same clusters. If so, combine them,
3499 // filling up gaps with zero sectors.
3500 outidx = 0;
3501 for (i = 1; i < num_reqs; i++) {
3502 int merge = 0;
3503 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
3504
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01003505 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02003506 if (reqs[i].sector <= oldreq_last) {
3507 merge = 1;
3508 }
3509
Christoph Hellwige2a305f2010-01-26 14:49:08 +01003510 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
3511 merge = 0;
3512 }
3513
Kevin Wolf40b4f532009-09-09 17:53:37 +02003514 if (merge) {
3515 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05003516 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02003517 qemu_iovec_init(qiov,
3518 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
3519
3520 // Add the first request to the merged one. If the requests are
3521 // overlapping, drop the last sectors of the first request.
3522 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04003523 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003524
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01003525 // We should need to add any zeros between the two requests
3526 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003527
3528 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04003529 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003530
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02003531 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003532 reqs[outidx].qiov = qiov;
3533
3534 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
3535 } else {
3536 outidx++;
3537 reqs[outidx].sector = reqs[i].sector;
3538 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
3539 reqs[outidx].qiov = reqs[i].qiov;
3540 }
3541 }
3542
3543 return outidx + 1;
3544}
3545
3546/*
3547 * Submit multiple AIO write requests at once.
3548 *
3549 * On success, the function returns 0 and all requests in the reqs array have
3550 * been submitted. In error case this function returns -1, and any of the
3551 * requests may or may not be submitted yet. In particular, this means that the
3552 * callback will be called for some of the requests, for others it won't. The
3553 * caller must check the error field of the BlockRequest to wait for the right
3554 * callbacks (if error != 0, no callback will be called).
3555 *
3556 * The implementation may modify the contents of the reqs array, e.g. to merge
3557 * requests. However, the fields opaque and error are left unmodified as they
3558 * are used to signal failure for a single request to the caller.
3559 */
3560int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3561{
Kevin Wolf40b4f532009-09-09 17:53:37 +02003562 MultiwriteCB *mcb;
3563 int i;
3564
Ryan Harper301db7c2011-03-07 10:01:04 -06003565 /* don't submit writes if we don't have a medium */
3566 if (bs->drv == NULL) {
3567 for (i = 0; i < num_reqs; i++) {
3568 reqs[i].error = -ENOMEDIUM;
3569 }
3570 return -1;
3571 }
3572
Kevin Wolf40b4f532009-09-09 17:53:37 +02003573 if (num_reqs == 0) {
3574 return 0;
3575 }
3576
3577 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05003578 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02003579 mcb->num_requests = 0;
3580 mcb->num_callbacks = num_reqs;
3581
3582 for (i = 0; i < num_reqs; i++) {
3583 mcb->callbacks[i].cb = reqs[i].cb;
3584 mcb->callbacks[i].opaque = reqs[i].opaque;
3585 }
3586
3587 // Check for mergable requests
3588 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3589
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01003590 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3591
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01003592 /* Run the aio requests. */
3593 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003594 for (i = 0; i < num_reqs; i++) {
Paolo Bonziniad54ae82011-11-30 09:12:30 +01003595 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
Kevin Wolf40b4f532009-09-09 17:53:37 +02003596 reqs[i].nb_sectors, multiwrite_cb, mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02003597 }
3598
3599 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02003600}
3601
bellard83f64092006-08-01 16:21:11 +00003602void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00003603{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003604 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00003605}
3606
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08003607/* block I/O throttling */
3608static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
3609 bool is_write, double elapsed_time, uint64_t *wait)
3610{
3611 uint64_t bps_limit = 0;
3612 double bytes_limit, bytes_base, bytes_res;
3613 double slice_time, wait_time;
3614
3615 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3616 bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
3617 } else if (bs->io_limits.bps[is_write]) {
3618 bps_limit = bs->io_limits.bps[is_write];
3619 } else {
3620 if (wait) {
3621 *wait = 0;
3622 }
3623
3624 return false;
3625 }
3626
3627 slice_time = bs->slice_end - bs->slice_start;
3628 slice_time /= (NANOSECONDS_PER_SECOND);
3629 bytes_limit = bps_limit * slice_time;
3630 bytes_base = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write];
3631 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3632 bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write];
3633 }
3634
3635 /* bytes_base: the bytes of data which have been read/written; and
3636 * it is obtained from the history statistic info.
3637 * bytes_res: the remaining bytes of data which need to be read/written.
3638 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3639 * the total time for completing reading/writting all data.
3640 */
3641 bytes_res = (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
3642
3643 if (bytes_base + bytes_res <= bytes_limit) {
3644 if (wait) {
3645 *wait = 0;
3646 }
3647
3648 return false;
3649 }
3650
3651 /* Calc approx time to dispatch */
3652 wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time;
3653
3654 /* When the I/O rate at runtime exceeds the limits,
3655 * bs->slice_end need to be extended in order that the current statistic
3656 * info can be kept until the timer fire, so it is increased and tuned
3657 * based on the result of experiment.
3658 */
3659 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3660 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3661 if (wait) {
3662 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3663 }
3664
3665 return true;
3666}
3667
3668static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
3669 double elapsed_time, uint64_t *wait)
3670{
3671 uint64_t iops_limit = 0;
3672 double ios_limit, ios_base;
3673 double slice_time, wait_time;
3674
3675 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3676 iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
3677 } else if (bs->io_limits.iops[is_write]) {
3678 iops_limit = bs->io_limits.iops[is_write];
3679 } else {
3680 if (wait) {
3681 *wait = 0;
3682 }
3683
3684 return false;
3685 }
3686
3687 slice_time = bs->slice_end - bs->slice_start;
3688 slice_time /= (NANOSECONDS_PER_SECOND);
3689 ios_limit = iops_limit * slice_time;
3690 ios_base = bs->nr_ops[is_write] - bs->io_base.ios[is_write];
3691 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3692 ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write];
3693 }
3694
3695 if (ios_base + 1 <= ios_limit) {
3696 if (wait) {
3697 *wait = 0;
3698 }
3699
3700 return false;
3701 }
3702
3703 /* Calc approx time to dispatch */
3704 wait_time = (ios_base + 1) / iops_limit;
3705 if (wait_time > elapsed_time) {
3706 wait_time = wait_time - elapsed_time;
3707 } else {
3708 wait_time = 0;
3709 }
3710
3711 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3712 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3713 if (wait) {
3714 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3715 }
3716
3717 return true;
3718}
3719
3720static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
3721 bool is_write, int64_t *wait)
3722{
3723 int64_t now, max_wait;
3724 uint64_t bps_wait = 0, iops_wait = 0;
3725 double elapsed_time;
3726 int bps_ret, iops_ret;
3727
3728 now = qemu_get_clock_ns(vm_clock);
3729 if ((bs->slice_start < now)
3730 && (bs->slice_end > now)) {
3731 bs->slice_end = now + bs->slice_time;
3732 } else {
3733 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
3734 bs->slice_start = now;
3735 bs->slice_end = now + bs->slice_time;
3736
3737 bs->io_base.bytes[is_write] = bs->nr_bytes[is_write];
3738 bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write];
3739
3740 bs->io_base.ios[is_write] = bs->nr_ops[is_write];
3741 bs->io_base.ios[!is_write] = bs->nr_ops[!is_write];
3742 }
3743
3744 elapsed_time = now - bs->slice_start;
3745 elapsed_time /= (NANOSECONDS_PER_SECOND);
3746
3747 bps_ret = bdrv_exceed_bps_limits(bs, nb_sectors,
3748 is_write, elapsed_time, &bps_wait);
3749 iops_ret = bdrv_exceed_iops_limits(bs, is_write,
3750 elapsed_time, &iops_wait);
3751 if (bps_ret || iops_ret) {
3752 max_wait = bps_wait > iops_wait ? bps_wait : iops_wait;
3753 if (wait) {
3754 *wait = max_wait;
3755 }
3756
3757 now = qemu_get_clock_ns(vm_clock);
3758 if (bs->slice_end < now + max_wait) {
3759 bs->slice_end = now + max_wait;
3760 }
3761
3762 return true;
3763 }
3764
3765 if (wait) {
3766 *wait = 0;
3767 }
3768
3769 return false;
3770}
pbrookce1a14d2006-08-07 02:38:06 +00003771
bellard83f64092006-08-01 16:21:11 +00003772/**************************************************************/
3773/* async block device emulation */
3774
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003775typedef struct BlockDriverAIOCBSync {
3776 BlockDriverAIOCB common;
3777 QEMUBH *bh;
3778 int ret;
3779 /* vector translation state */
3780 QEMUIOVector *qiov;
3781 uint8_t *bounce;
3782 int is_write;
3783} BlockDriverAIOCBSync;
3784
3785static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3786{
Kevin Wolfb666d232010-05-05 11:44:39 +02003787 BlockDriverAIOCBSync *acb =
3788 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03003789 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03003790 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003791 qemu_aio_release(acb);
3792}
3793
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003794static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02003795 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3796 .cancel = bdrv_aio_cancel_em,
3797};
3798
bellard83f64092006-08-01 16:21:11 +00003799static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00003800{
pbrookce1a14d2006-08-07 02:38:06 +00003801 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00003802
aliguorif141eaf2009-04-07 18:43:24 +00003803 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04003804 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00003805 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00003806 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03003807 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03003808 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00003809 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00003810}
bellardbeac80c2006-06-26 20:08:57 +00003811
aliguorif141eaf2009-04-07 18:43:24 +00003812static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3813 int64_t sector_num,
3814 QEMUIOVector *qiov,
3815 int nb_sectors,
3816 BlockDriverCompletionFunc *cb,
3817 void *opaque,
3818 int is_write)
3819
bellardea2384d2004-08-01 21:59:26 +00003820{
pbrookce1a14d2006-08-07 02:38:06 +00003821 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00003822
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003823 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00003824 acb->is_write = is_write;
3825 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00003826 acb->bounce = qemu_blockalign(bs, qiov->size);
Paolo Bonzini3f3aace2011-11-14 17:50:54 +01003827 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00003828
3829 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04003830 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01003831 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00003832 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01003833 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00003834 }
3835
pbrookce1a14d2006-08-07 02:38:06 +00003836 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00003837
pbrookce1a14d2006-08-07 02:38:06 +00003838 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00003839}
3840
aliguorif141eaf2009-04-07 18:43:24 +00003841static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3842 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00003843 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00003844{
aliguorif141eaf2009-04-07 18:43:24 +00003845 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00003846}
3847
aliguorif141eaf2009-04-07 18:43:24 +00003848static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3849 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3850 BlockDriverCompletionFunc *cb, void *opaque)
3851{
3852 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3853}
3854
Kevin Wolf68485422011-06-30 10:05:46 +02003855
3856typedef struct BlockDriverAIOCBCoroutine {
3857 BlockDriverAIOCB common;
3858 BlockRequest req;
3859 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003860 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02003861 QEMUBH* bh;
3862} BlockDriverAIOCBCoroutine;
3863
3864static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3865{
Kevin Wolfd318aea2012-11-13 16:35:08 +01003866 BlockDriverAIOCBCoroutine *acb =
3867 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
3868 bool done = false;
3869
3870 acb->done = &done;
3871 while (!done) {
3872 qemu_aio_wait();
3873 }
Kevin Wolf68485422011-06-30 10:05:46 +02003874}
3875
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003876static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02003877 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
3878 .cancel = bdrv_aio_co_cancel_em,
3879};
3880
Paolo Bonzini35246a62011-10-14 10:41:29 +02003881static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02003882{
3883 BlockDriverAIOCBCoroutine *acb = opaque;
3884
3885 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01003886
3887 if (acb->done) {
3888 *acb->done = true;
3889 }
3890
Kevin Wolf68485422011-06-30 10:05:46 +02003891 qemu_bh_delete(acb->bh);
3892 qemu_aio_release(acb);
3893}
3894
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003895/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3896static void coroutine_fn bdrv_co_do_rw(void *opaque)
3897{
3898 BlockDriverAIOCBCoroutine *acb = opaque;
3899 BlockDriverState *bs = acb->common.bs;
3900
3901 if (!acb->is_write) {
3902 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003903 acb->req.nb_sectors, acb->req.qiov, 0);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003904 } else {
3905 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003906 acb->req.nb_sectors, acb->req.qiov, 0);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003907 }
3908
Paolo Bonzini35246a62011-10-14 10:41:29 +02003909 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01003910 qemu_bh_schedule(acb->bh);
3911}
3912
Kevin Wolf68485422011-06-30 10:05:46 +02003913static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
3914 int64_t sector_num,
3915 QEMUIOVector *qiov,
3916 int nb_sectors,
3917 BlockDriverCompletionFunc *cb,
3918 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003919 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02003920{
3921 Coroutine *co;
3922 BlockDriverAIOCBCoroutine *acb;
3923
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003924 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02003925 acb->req.sector = sector_num;
3926 acb->req.nb_sectors = nb_sectors;
3927 acb->req.qiov = qiov;
3928 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003929 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02003930
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01003931 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02003932 qemu_coroutine_enter(co, acb);
3933
3934 return &acb->common;
3935}
3936
Paolo Bonzini07f07612011-10-17 12:32:12 +02003937static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003938{
Paolo Bonzini07f07612011-10-17 12:32:12 +02003939 BlockDriverAIOCBCoroutine *acb = opaque;
3940 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003941
Paolo Bonzini07f07612011-10-17 12:32:12 +02003942 acb->req.error = bdrv_co_flush(bs);
3943 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003944 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02003945}
3946
Paolo Bonzini07f07612011-10-17 12:32:12 +02003947BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02003948 BlockDriverCompletionFunc *cb, void *opaque)
3949{
Paolo Bonzini07f07612011-10-17 12:32:12 +02003950 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02003951
Paolo Bonzini07f07612011-10-17 12:32:12 +02003952 Coroutine *co;
3953 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02003954
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003955 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01003956 acb->done = NULL;
3957
Paolo Bonzini07f07612011-10-17 12:32:12 +02003958 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
3959 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02003960
Alexander Graf016f5cf2010-05-26 17:51:49 +02003961 return &acb->common;
3962}
3963
Paolo Bonzini4265d622011-10-17 12:32:14 +02003964static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
3965{
3966 BlockDriverAIOCBCoroutine *acb = opaque;
3967 BlockDriverState *bs = acb->common.bs;
3968
3969 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
3970 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3971 qemu_bh_schedule(acb->bh);
3972}
3973
3974BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
3975 int64_t sector_num, int nb_sectors,
3976 BlockDriverCompletionFunc *cb, void *opaque)
3977{
3978 Coroutine *co;
3979 BlockDriverAIOCBCoroutine *acb;
3980
3981 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
3982
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01003983 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02003984 acb->req.sector = sector_num;
3985 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01003986 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02003987 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
3988 qemu_coroutine_enter(co, acb);
3989
3990 return &acb->common;
3991}
3992
bellardea2384d2004-08-01 21:59:26 +00003993void bdrv_init(void)
3994{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003995 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00003996}
pbrookce1a14d2006-08-07 02:38:06 +00003997
Markus Armbrustereb852012009-10-27 18:41:44 +01003998void bdrv_init_with_whitelist(void)
3999{
4000 use_bdrv_whitelist = 1;
4001 bdrv_init();
4002}
4003
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004004void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004005 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00004006{
pbrookce1a14d2006-08-07 02:38:06 +00004007 BlockDriverAIOCB *acb;
4008
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004009 acb = g_slice_alloc(aiocb_info->aiocb_size);
4010 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00004011 acb->bs = bs;
4012 acb->cb = cb;
4013 acb->opaque = opaque;
4014 return acb;
4015}
4016
4017void qemu_aio_release(void *p)
4018{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01004019 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004020 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004021}
bellard19cb3732006-08-19 11:45:59 +00004022
4023/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004024/* Coroutine block device emulation */
4025
4026typedef struct CoroutineIOCompletion {
4027 Coroutine *coroutine;
4028 int ret;
4029} CoroutineIOCompletion;
4030
4031static void bdrv_co_io_em_complete(void *opaque, int ret)
4032{
4033 CoroutineIOCompletion *co = opaque;
4034
4035 co->ret = ret;
4036 qemu_coroutine_enter(co->coroutine, NULL);
4037}
4038
4039static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4040 int nb_sectors, QEMUIOVector *iov,
4041 bool is_write)
4042{
4043 CoroutineIOCompletion co = {
4044 .coroutine = qemu_coroutine_self(),
4045 };
4046 BlockDriverAIOCB *acb;
4047
4048 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004049 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4050 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004051 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004052 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4053 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004054 }
4055
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004056 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004057 if (!acb) {
4058 return -EIO;
4059 }
4060 qemu_coroutine_yield();
4061
4062 return co.ret;
4063}
4064
4065static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4066 int64_t sector_num, int nb_sectors,
4067 QEMUIOVector *iov)
4068{
4069 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4070}
4071
4072static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4073 int64_t sector_num, int nb_sectors,
4074 QEMUIOVector *iov)
4075{
4076 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4077}
4078
Paolo Bonzini07f07612011-10-17 12:32:12 +02004079static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004080{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004081 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004082
Paolo Bonzini07f07612011-10-17 12:32:12 +02004083 rwco->ret = bdrv_co_flush(rwco->bs);
4084}
4085
4086int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4087{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004088 int ret;
4089
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004090 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004091 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004092 }
4093
Kevin Wolfca716362011-11-10 18:13:59 +01004094 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004095 if (bs->drv->bdrv_co_flush_to_os) {
4096 ret = bs->drv->bdrv_co_flush_to_os(bs);
4097 if (ret < 0) {
4098 return ret;
4099 }
4100 }
4101
Kevin Wolfca716362011-11-10 18:13:59 +01004102 /* But don't actually force it to the disk with cache=unsafe */
4103 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004104 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004105 }
4106
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004107 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004108 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004109 } else if (bs->drv->bdrv_aio_flush) {
4110 BlockDriverAIOCB *acb;
4111 CoroutineIOCompletion co = {
4112 .coroutine = qemu_coroutine_self(),
4113 };
4114
4115 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4116 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004117 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004118 } else {
4119 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004120 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004121 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004122 } else {
4123 /*
4124 * Some block drivers always operate in either writethrough or unsafe
4125 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4126 * know how the server works (because the behaviour is hardcoded or
4127 * depends on server-side configuration), so we can't ensure that
4128 * everything is safe on disk. Returning an error doesn't work because
4129 * that would break guests even if the server operates in writethrough
4130 * mode.
4131 *
4132 * Let's hope the user knows what he's doing.
4133 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004134 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004135 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004136 if (ret < 0) {
4137 return ret;
4138 }
4139
4140 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4141 * in the case of cache=unsafe, so there are no useless flushes.
4142 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004143flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004144 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004145}
4146
Anthony Liguori0f154232011-11-14 15:09:45 -06004147void bdrv_invalidate_cache(BlockDriverState *bs)
4148{
4149 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
4150 bs->drv->bdrv_invalidate_cache(bs);
4151 }
4152}
4153
4154void bdrv_invalidate_cache_all(void)
4155{
4156 BlockDriverState *bs;
4157
4158 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4159 bdrv_invalidate_cache(bs);
4160 }
4161}
4162
Benoît Canet07789262012-03-23 08:36:49 +01004163void bdrv_clear_incoming_migration_all(void)
4164{
4165 BlockDriverState *bs;
4166
4167 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4168 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4169 }
4170}
4171
Paolo Bonzini07f07612011-10-17 12:32:12 +02004172int bdrv_flush(BlockDriverState *bs)
4173{
4174 Coroutine *co;
4175 RwCo rwco = {
4176 .bs = bs,
4177 .ret = NOT_DONE,
4178 };
4179
4180 if (qemu_in_coroutine()) {
4181 /* Fast-path if already in coroutine context */
4182 bdrv_flush_co_entry(&rwco);
4183 } else {
4184 co = qemu_coroutine_create(bdrv_flush_co_entry);
4185 qemu_coroutine_enter(co, &rwco);
4186 while (rwco.ret == NOT_DONE) {
4187 qemu_aio_wait();
4188 }
4189 }
4190
4191 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004192}
4193
Paolo Bonzini4265d622011-10-17 12:32:14 +02004194static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4195{
4196 RwCo *rwco = opaque;
4197
4198 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4199}
4200
4201int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4202 int nb_sectors)
4203{
4204 if (!bs->drv) {
4205 return -ENOMEDIUM;
4206 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4207 return -EIO;
4208 } else if (bs->read_only) {
4209 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004210 }
4211
4212 if (bs->dirty_bitmap) {
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004213 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004214 }
4215
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01004216 /* Do nothing if disabled. */
4217 if (!(bs->open_flags & BDRV_O_UNMAP)) {
4218 return 0;
4219 }
4220
Paolo Bonzinidf702c92013-01-14 16:26:58 +01004221 if (bs->drv->bdrv_co_discard) {
Paolo Bonzini4265d622011-10-17 12:32:14 +02004222 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
4223 } else if (bs->drv->bdrv_aio_discard) {
4224 BlockDriverAIOCB *acb;
4225 CoroutineIOCompletion co = {
4226 .coroutine = qemu_coroutine_self(),
4227 };
4228
4229 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4230 bdrv_co_io_em_complete, &co);
4231 if (acb == NULL) {
4232 return -EIO;
4233 } else {
4234 qemu_coroutine_yield();
4235 return co.ret;
4236 }
Paolo Bonzini4265d622011-10-17 12:32:14 +02004237 } else {
4238 return 0;
4239 }
4240}
4241
4242int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
4243{
4244 Coroutine *co;
4245 RwCo rwco = {
4246 .bs = bs,
4247 .sector_num = sector_num,
4248 .nb_sectors = nb_sectors,
4249 .ret = NOT_DONE,
4250 };
4251
4252 if (qemu_in_coroutine()) {
4253 /* Fast-path if already in coroutine context */
4254 bdrv_discard_co_entry(&rwco);
4255 } else {
4256 co = qemu_coroutine_create(bdrv_discard_co_entry);
4257 qemu_coroutine_enter(co, &rwco);
4258 while (rwco.ret == NOT_DONE) {
4259 qemu_aio_wait();
4260 }
4261 }
4262
4263 return rwco.ret;
4264}
4265
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004266/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00004267/* removable device support */
4268
4269/**
4270 * Return TRUE if the media is present
4271 */
4272int bdrv_is_inserted(BlockDriverState *bs)
4273{
4274 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004275
bellard19cb3732006-08-19 11:45:59 +00004276 if (!drv)
4277 return 0;
4278 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02004279 return 1;
4280 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00004281}
4282
4283/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004284 * Return whether the media changed since the last call to this
4285 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00004286 */
4287int bdrv_media_changed(BlockDriverState *bs)
4288{
4289 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004290
Markus Armbruster8e49ca42011-08-03 15:08:08 +02004291 if (drv && drv->bdrv_media_changed) {
4292 return drv->bdrv_media_changed(bs);
4293 }
4294 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00004295}
4296
4297/**
4298 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4299 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02004300void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00004301{
4302 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00004303
Markus Armbruster822e1cd2011-07-20 18:23:42 +02004304 if (drv && drv->bdrv_eject) {
4305 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00004306 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02004307
4308 if (bs->device_name[0] != '\0') {
4309 bdrv_emit_qmp_eject_event(bs, eject_flag);
4310 }
bellard19cb3732006-08-19 11:45:59 +00004311}
4312
bellard19cb3732006-08-19 11:45:59 +00004313/**
4314 * Lock or unlock the media (if it is locked, the user won't be able
4315 * to eject it manually).
4316 */
Markus Armbruster025e8492011-09-06 18:58:47 +02004317void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00004318{
4319 BlockDriver *drv = bs->drv;
4320
Markus Armbruster025e8492011-09-06 18:58:47 +02004321 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01004322
Markus Armbruster025e8492011-09-06 18:58:47 +02004323 if (drv && drv->bdrv_lock_medium) {
4324 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00004325 }
4326}
ths985a03b2007-12-24 16:10:43 +00004327
4328/* needed for generic scsi interface */
4329
4330int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4331{
4332 BlockDriver *drv = bs->drv;
4333
4334 if (drv && drv->bdrv_ioctl)
4335 return drv->bdrv_ioctl(bs, req, buf);
4336 return -ENOTSUP;
4337}
aliguori7d780662009-03-12 19:57:08 +00004338
aliguori221f7152009-03-28 17:28:41 +00004339BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
4340 unsigned long int req, void *buf,
4341 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00004342{
aliguori221f7152009-03-28 17:28:41 +00004343 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00004344
aliguori221f7152009-03-28 17:28:41 +00004345 if (drv && drv->bdrv_aio_ioctl)
4346 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
4347 return NULL;
aliguori7d780662009-03-12 19:57:08 +00004348}
aliguorie268ca52009-04-22 20:20:00 +00004349
Markus Armbruster7b6f9302011-09-06 18:58:56 +02004350void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
4351{
4352 bs->buffer_alignment = align;
4353}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004354
aliguorie268ca52009-04-22 20:20:00 +00004355void *qemu_blockalign(BlockDriverState *bs, size_t size)
4356{
4357 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
4358}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004359
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01004360/*
4361 * Check if all memory in this vector is sector aligned.
4362 */
4363bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
4364{
4365 int i;
4366
4367 for (i = 0; i < qiov->niov; i++) {
4368 if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
4369 return false;
4370 }
4371 }
4372
4373 return true;
4374}
4375
Paolo Bonzini50717e92013-01-21 17:09:45 +01004376void bdrv_set_dirty_tracking(BlockDriverState *bs, int granularity)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004377{
4378 int64_t bitmap_size;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004379
Paolo Bonzini50717e92013-01-21 17:09:45 +01004380 assert((granularity & (granularity - 1)) == 0);
4381
4382 if (granularity) {
4383 granularity >>= BDRV_SECTOR_BITS;
4384 assert(!bs->dirty_bitmap);
4385 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
4386 bs->dirty_bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004387 } else {
Jan Kiszkac6d22832009-11-30 18:21:20 +01004388 if (bs->dirty_bitmap) {
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004389 hbitmap_free(bs->dirty_bitmap);
Jan Kiszkac6d22832009-11-30 18:21:20 +01004390 bs->dirty_bitmap = NULL;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004391 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004392 }
4393}
4394
4395int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
4396{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004397 if (bs->dirty_bitmap) {
4398 return hbitmap_get(bs->dirty_bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004399 } else {
4400 return 0;
4401 }
4402}
4403
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004404void bdrv_dirty_iter_init(BlockDriverState *bs, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02004405{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004406 hbitmap_iter_init(hbi, bs->dirty_bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02004407}
4408
4409void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
4410 int nr_sectors)
4411{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004412 hbitmap_set(bs->dirty_bitmap, cur_sector, nr_sectors);
Paolo Bonzini1755da12012-10-18 16:49:18 +02004413}
4414
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004415void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
4416 int nr_sectors)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004417{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004418 hbitmap_reset(bs->dirty_bitmap, cur_sector, nr_sectors);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02004419}
Liran Schouraaa0eb72010-01-26 10:31:48 +02004420
4421int64_t bdrv_get_dirty_count(BlockDriverState *bs)
4422{
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004423 if (bs->dirty_bitmap) {
Paolo Bonziniacc906c2013-01-21 17:09:44 +01004424 return hbitmap_count(bs->dirty_bitmap);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01004425 } else {
4426 return 0;
4427 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02004428}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004429
Marcelo Tosattidb593f22011-01-26 12:12:34 -02004430void bdrv_set_in_use(BlockDriverState *bs, int in_use)
4431{
4432 assert(bs->in_use != in_use);
4433 bs->in_use = in_use;
4434}
4435
4436int bdrv_in_use(BlockDriverState *bs)
4437{
4438 return bs->in_use;
4439}
4440
Luiz Capitulino28a72822011-09-26 17:43:50 -03004441void bdrv_iostatus_enable(BlockDriverState *bs)
4442{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004443 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004444 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004445}
4446
4447/* The I/O status is only enabled if the drive explicitly
4448 * enables it _and_ the VM is configured to stop on errors */
4449bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
4450{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004451 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02004452 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
4453 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
4454 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03004455}
4456
4457void bdrv_iostatus_disable(BlockDriverState *bs)
4458{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03004459 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004460}
4461
4462void bdrv_iostatus_reset(BlockDriverState *bs)
4463{
4464 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004465 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02004466 if (bs->job) {
4467 block_job_iostatus_reset(bs->job);
4468 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03004469 }
4470}
4471
Luiz Capitulino28a72822011-09-26 17:43:50 -03004472void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
4473{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02004474 assert(bdrv_iostatus_is_enabled(bs));
4475 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03004476 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
4477 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03004478 }
4479}
4480
Christoph Hellwiga597e792011-08-25 08:26:01 +02004481void
4482bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
4483 enum BlockAcctType type)
4484{
4485 assert(type < BDRV_MAX_IOTYPE);
4486
4487 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02004488 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02004489 cookie->type = type;
4490}
4491
4492void
4493bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
4494{
4495 assert(cookie->type < BDRV_MAX_IOTYPE);
4496
4497 bs->nr_bytes[cookie->type] += cookie->bytes;
4498 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02004499 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02004500}
4501
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004502void bdrv_img_create(const char *filename, const char *fmt,
4503 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004504 char *options, uint64_t img_size, int flags,
4505 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004506{
4507 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfd2208942011-06-01 14:03:31 +02004508 QEMUOptionParameter *backing_fmt, *backing_file, *size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004509 BlockDriverState *bs = NULL;
4510 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00004511 BlockDriver *backing_drv = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004512 int ret = 0;
4513
4514 /* Find driver and parse its options */
4515 drv = bdrv_find_format(fmt);
4516 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004517 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004518 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004519 }
4520
4521 proto_drv = bdrv_find_protocol(filename);
4522 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004523 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02004524 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004525 }
4526
4527 create_options = append_option_parameters(create_options,
4528 drv->create_options);
4529 create_options = append_option_parameters(create_options,
4530 proto_drv->create_options);
4531
4532 /* Create parameter list with default values */
4533 param = parse_option_parameters("", create_options, param);
4534
4535 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
4536
4537 /* Parse -o options */
4538 if (options) {
4539 param = parse_option_parameters(options, create_options, param);
4540 if (param == NULL) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004541 error_setg(errp, "Invalid options for file format '%s'.", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004542 goto out;
4543 }
4544 }
4545
4546 if (base_filename) {
4547 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
4548 base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004549 error_setg(errp, "Backing file not supported for file format '%s'",
4550 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004551 goto out;
4552 }
4553 }
4554
4555 if (base_fmt) {
4556 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004557 error_setg(errp, "Backing file format not supported for file "
4558 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004559 goto out;
4560 }
4561 }
4562
Jes Sorensen792da932010-12-16 13:52:17 +01004563 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
4564 if (backing_file && backing_file->value.s) {
4565 if (!strcmp(filename, backing_file->value.s)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004566 error_setg(errp, "Error: Trying to create an image with the "
4567 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01004568 goto out;
4569 }
4570 }
4571
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004572 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
4573 if (backing_fmt && backing_fmt->value.s) {
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00004574 backing_drv = bdrv_find_format(backing_fmt->value.s);
4575 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004576 error_setg(errp, "Unknown backing file format '%s'",
4577 backing_fmt->value.s);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004578 goto out;
4579 }
4580 }
4581
4582 // The size for the image must always be specified, with one exception:
4583 // If we are using a backing file, we can obtain the size from there
Kevin Wolfd2208942011-06-01 14:03:31 +02004584 size = get_option_parameter(param, BLOCK_OPT_SIZE);
4585 if (size && size->value.n == -1) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004586 if (backing_file && backing_file->value.s) {
4587 uint64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004588 char buf[32];
Paolo Bonzini63090da2012-04-12 14:01:03 +02004589 int back_flags;
4590
4591 /* backing files always opened read-only */
4592 back_flags =
4593 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004594
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004595 bs = bdrv_new("");
4596
Paolo Bonzini63090da2012-04-12 14:01:03 +02004597 ret = bdrv_open(bs, backing_file->value.s, back_flags, backing_drv);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004598 if (ret < 0) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004599 error_setg_errno(errp, -ret, "Could not open '%s'",
4600 backing_file->value.s);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004601 goto out;
4602 }
4603 bdrv_get_geometry(bs, &size);
4604 size *= 512;
4605
4606 snprintf(buf, sizeof(buf), "%" PRId64, size);
4607 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4608 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004609 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004610 goto out;
4611 }
4612 }
4613
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01004614 if (!quiet) {
4615 printf("Formatting '%s', fmt=%s ", filename, fmt);
4616 print_option_parameters(param);
4617 puts("");
4618 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004619 ret = bdrv_create(drv, filename, param);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004620 if (ret < 0) {
4621 if (ret == -ENOTSUP) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004622 error_setg(errp,"Formatting or formatting option not supported for "
4623 "file format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004624 } else if (ret == -EFBIG) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004625 error_setg(errp, "The image size is too large for file format '%s'",
4626 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004627 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02004628 error_setg(errp, "%s: error while creating %s: %s", filename, fmt,
4629 strerror(-ret));
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004630 }
4631 }
4632
4633out:
4634 free_option_parameters(create_options);
4635 free_option_parameters(param);
4636
4637 if (bs) {
4638 bdrv_delete(bs);
4639 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01004640}