blob: 17ee08810598ab51627e77189fab6b198ed8b487 [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 */
Peter Maydelld38ea872016-01-29 17:50:05 +000024#include "qemu/osdep.h"
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010025#include "trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010026#include "block/block_int.h"
27#include "block/blockjob.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010028#include "qemu/error-report.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010029#include "qemu/module.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010030#include "qapi/qmp/qerror.h"
Kevin Wolf91a097e2015-05-08 17:49:53 +020031#include "qapi/qmp/qbool.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010032#include "qapi/qmp/qjson.h"
Markus Armbrusterbfb197e2014-10-07 13:59:11 +020033#include "sysemu/block-backend.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010034#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010035#include "qemu/notify.h"
Daniel P. Berrange10817bf2015-09-01 14:48:02 +010036#include "qemu/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010037#include "block/qapi.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030038#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010039#include "qemu/timer.h"
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +020040#include "qapi-event.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020041#include "qemu/cutils.h"
42#include "qemu/id.h"
bellardfc01f7e2003-06-30 10:03:06 +000043
Juan Quintela71e72a12009-07-27 16:12:56 +020044#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000045#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000046#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000047#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000048#include <sys/disk.h>
49#endif
blueswir1c5e97232009-03-07 20:06:23 +000050#endif
bellard7674e7b2005-04-26 21:59:26 +000051
aliguori49dc7682009-03-08 16:26:59 +000052#ifdef _WIN32
53#include <windows.h>
54#endif
55
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010056#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
57
Benoît Canetdc364f42014-01-23 21:31:32 +010058static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
59 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
60
Max Reitz2c1d04e2016-01-29 16:36:11 +010061static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
62 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
63
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010064static QLIST_HEAD(, BlockDriver) bdrv_drivers =
65 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000066
Kevin Wolff3930ed2015-04-08 13:43:47 +020067static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
68 const char *reference, QDict *options, int flags,
69 BlockDriverState *parent,
Max Reitzce343772015-08-26 19:47:50 +020070 const BdrvChildRole *child_role, Error **errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +020071
Markus Armbrustereb852012009-10-27 18:41:44 +010072/* If non-zero, use only whitelisted block drivers */
73static int use_bdrv_whitelist;
74
Max Reitz64dff522016-01-29 16:36:10 +010075static void bdrv_close(BlockDriverState *bs);
76
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +000077#ifdef _WIN32
78static int is_windows_drive_prefix(const char *filename)
79{
80 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
81 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
82 filename[1] == ':');
83}
84
85int is_windows_drive(const char *filename)
86{
87 if (is_windows_drive_prefix(filename) &&
88 filename[2] == '\0')
89 return 1;
90 if (strstart(filename, "\\\\.\\", NULL) ||
91 strstart(filename, "//./", NULL))
92 return 1;
93 return 0;
94}
95#endif
96
Kevin Wolf339064d2013-11-28 10:23:32 +010097size_t bdrv_opt_mem_align(BlockDriverState *bs)
98{
99 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300100 /* page size or 4k (hdd sector size) should be on the safe side */
101 return MAX(4096, getpagesize());
Kevin Wolf339064d2013-11-28 10:23:32 +0100102 }
103
104 return bs->bl.opt_mem_alignment;
105}
106
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300107size_t bdrv_min_mem_align(BlockDriverState *bs)
108{
109 if (!bs || !bs->drv) {
Denis V. Lunev459b4e62015-05-12 17:30:56 +0300110 /* page size or 4k (hdd sector size) should be on the safe side */
111 return MAX(4096, getpagesize());
Denis V. Lunev4196d2f2015-05-12 17:30:55 +0300112 }
113
114 return bs->bl.min_mem_alignment;
115}
116
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000117/* check if the path starts with "<protocol>:" */
Max Reitz5c984152014-12-03 14:57:22 +0100118int path_has_protocol(const char *path)
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000119{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200120 const char *p;
121
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000122#ifdef _WIN32
123 if (is_windows_drive(path) ||
124 is_windows_drive_prefix(path)) {
125 return 0;
126 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200127 p = path + strcspn(path, ":/\\");
128#else
129 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000130#endif
131
Paolo Bonzini947995c2012-05-08 16:51:48 +0200132 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000133}
134
bellard83f64092006-08-01 16:21:11 +0000135int path_is_absolute(const char *path)
136{
bellard21664422007-01-07 18:22:37 +0000137#ifdef _WIN32
138 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200139 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000140 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200141 }
142 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000143#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200144 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000145#endif
bellard83f64092006-08-01 16:21:11 +0000146}
147
148/* if filename is absolute, just copy it to dest. Otherwise, build a
149 path to it by considering it is relative to base_path. URL are
150 supported. */
151void path_combine(char *dest, int dest_size,
152 const char *base_path,
153 const char *filename)
154{
155 const char *p, *p1;
156 int len;
157
158 if (dest_size <= 0)
159 return;
160 if (path_is_absolute(filename)) {
161 pstrcpy(dest, dest_size, filename);
162 } else {
163 p = strchr(base_path, ':');
164 if (p)
165 p++;
166 else
167 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000168 p1 = strrchr(base_path, '/');
169#ifdef _WIN32
170 {
171 const char *p2;
172 p2 = strrchr(base_path, '\\');
173 if (!p1 || p2 > p1)
174 p1 = p2;
175 }
176#endif
bellard83f64092006-08-01 16:21:11 +0000177 if (p1)
178 p1++;
179 else
180 p1 = base_path;
181 if (p1 > p)
182 p = p1;
183 len = p - base_path;
184 if (len > dest_size - 1)
185 len = dest_size - 1;
186 memcpy(dest, base_path, len);
187 dest[len] = '\0';
188 pstrcat(dest, dest_size, filename);
189 }
190}
191
Max Reitz0a828552014-11-26 17:20:25 +0100192void bdrv_get_full_backing_filename_from_filename(const char *backed,
193 const char *backing,
Max Reitz9f074292014-11-26 17:20:26 +0100194 char *dest, size_t sz,
195 Error **errp)
Max Reitz0a828552014-11-26 17:20:25 +0100196{
Max Reitz9f074292014-11-26 17:20:26 +0100197 if (backing[0] == '\0' || path_has_protocol(backing) ||
198 path_is_absolute(backing))
199 {
Max Reitz0a828552014-11-26 17:20:25 +0100200 pstrcpy(dest, sz, backing);
Max Reitz9f074292014-11-26 17:20:26 +0100201 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
202 error_setg(errp, "Cannot use relative backing file names for '%s'",
203 backed);
Max Reitz0a828552014-11-26 17:20:25 +0100204 } else {
205 path_combine(dest, sz, backed, backing);
206 }
207}
208
Max Reitz9f074292014-11-26 17:20:26 +0100209void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
210 Error **errp)
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200211{
Max Reitz9f074292014-11-26 17:20:26 +0100212 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
213
214 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
215 dest, sz, errp);
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200216}
217
Stefan Hajnoczi0eb72172015-04-28 14:27:51 +0100218void bdrv_register(BlockDriver *bdrv)
219{
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100220 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000221}
bellardb3380822004-03-14 21:38:54 +0000222
Markus Armbruster7f06d472014-10-07 13:59:12 +0200223BlockDriverState *bdrv_new_root(void)
bellardfc01f7e2003-06-30 10:03:06 +0000224{
Max Reitz9aaf28c2016-03-16 19:54:45 +0100225 return bdrv_new();
Markus Armbrustere4e99862014-10-07 13:59:03 +0200226}
227
228BlockDriverState *bdrv_new(void)
229{
230 BlockDriverState *bs;
231 int i;
232
Markus Armbruster5839e532014-08-19 10:31:08 +0200233 bs = g_new0(BlockDriverState, 1);
Fam Zhenge4654d22013-11-13 18:29:43 +0800234 QLIST_INIT(&bs->dirty_bitmaps);
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800235 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
236 QLIST_INIT(&bs->op_blockers[i]);
237 }
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200238 notifier_with_return_list_init(&bs->before_write_notifiers);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800239 bs->refcnt = 1;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +0200240 bs->aio_context = qemu_get_aio_context();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200241
Max Reitz2c1d04e2016-01-29 16:36:11 +0100242 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
243
bellardb3380822004-03-14 21:38:54 +0000244 return bs;
245}
246
bellardea2384d2004-08-01 21:59:26 +0000247BlockDriver *bdrv_find_format(const char *format_name)
248{
249 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100250 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
251 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000252 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100253 }
bellardea2384d2004-08-01 21:59:26 +0000254 }
255 return NULL;
256}
257
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800258static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100259{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800260 static const char *whitelist_rw[] = {
261 CONFIG_BDRV_RW_WHITELIST
262 };
263 static const char *whitelist_ro[] = {
264 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100265 };
266 const char **p;
267
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800268 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100269 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800270 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100271
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800272 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100273 if (!strcmp(drv->format_name, *p)) {
274 return 1;
275 }
276 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800277 if (read_only) {
278 for (p = whitelist_ro; *p; p++) {
279 if (!strcmp(drv->format_name, *p)) {
280 return 1;
281 }
282 }
283 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100284 return 0;
285}
286
Daniel P. Berrangee6ff69b2016-03-21 14:11:48 +0000287bool bdrv_uses_whitelist(void)
288{
289 return use_bdrv_whitelist;
290}
291
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800292typedef struct CreateCo {
293 BlockDriver *drv;
294 char *filename;
Chunyan Liu83d05212014-06-05 17:20:51 +0800295 QemuOpts *opts;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800296 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200297 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800298} CreateCo;
299
300static void coroutine_fn bdrv_create_co_entry(void *opaque)
301{
Max Reitzcc84d902013-09-06 17:14:26 +0200302 Error *local_err = NULL;
303 int ret;
304
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800305 CreateCo *cco = opaque;
306 assert(cco->drv);
307
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800308 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100309 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200310 error_propagate(&cco->err, local_err);
311 }
312 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800313}
314
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200315int bdrv_create(BlockDriver *drv, const char* filename,
Chunyan Liu83d05212014-06-05 17:20:51 +0800316 QemuOpts *opts, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000317{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800318 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200319
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800320 Coroutine *co;
321 CreateCo cco = {
322 .drv = drv,
323 .filename = g_strdup(filename),
Chunyan Liu83d05212014-06-05 17:20:51 +0800324 .opts = opts,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800325 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200326 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800327 };
328
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800329 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200330 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300331 ret = -ENOTSUP;
332 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800333 }
334
335 if (qemu_in_coroutine()) {
336 /* Fast-path if already in coroutine context */
337 bdrv_create_co_entry(&cco);
338 } else {
339 co = qemu_coroutine_create(bdrv_create_co_entry);
340 qemu_coroutine_enter(co, &cco);
341 while (cco.ret == NOT_DONE) {
Paolo Bonzinib47ec2c2014-07-07 15:18:01 +0200342 aio_poll(qemu_get_aio_context(), true);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800343 }
344 }
345
346 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200347 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100348 if (cco.err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200349 error_propagate(errp, cco.err);
350 } else {
351 error_setg_errno(errp, -ret, "Could not create image");
352 }
353 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800354
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300355out:
356 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800357 return ret;
bellardea2384d2004-08-01 21:59:26 +0000358}
359
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800360int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200361{
362 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200363 Error *local_err = NULL;
364 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200365
Max Reitzb65a5e12015-02-05 13:58:12 -0500366 drv = bdrv_find_protocol(filename, true, errp);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200367 if (drv == NULL) {
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000368 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200369 }
370
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800371 ret = bdrv_create(drv, filename, opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100372 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200373 error_propagate(errp, local_err);
374 }
375 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200376}
377
Ekaterina Tumanova892b7de2015-02-16 12:47:54 +0100378/**
379 * Try to get @bs's logical and physical block size.
380 * On success, store them in @bsz struct and return 0.
381 * On failure return -errno.
382 * @bs must not be empty.
383 */
384int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
385{
386 BlockDriver *drv = bs->drv;
387
388 if (drv && drv->bdrv_probe_blocksizes) {
389 return drv->bdrv_probe_blocksizes(bs, bsz);
390 }
391
392 return -ENOTSUP;
393}
394
395/**
396 * Try to get @bs's geometry (cyls, heads, sectors).
397 * On success, store them in @geo struct and return 0.
398 * On failure return -errno.
399 * @bs must not be empty.
400 */
401int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
402{
403 BlockDriver *drv = bs->drv;
404
405 if (drv && drv->bdrv_probe_geometry) {
406 return drv->bdrv_probe_geometry(bs, geo);
407 }
408
409 return -ENOTSUP;
410}
411
Jim Meyeringeba25052012-05-28 09:27:54 +0200412/*
413 * Create a uniquely-named empty temporary file.
414 * Return 0 upon success, otherwise a negative errno value.
415 */
416int get_tmp_filename(char *filename, int size)
417{
bellardd5249392004-08-03 21:14:23 +0000418#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000419 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200420 /* GetTempFileName requires that its output buffer (4th param)
421 have length MAX_PATH or greater. */
422 assert(size >= MAX_PATH);
423 return (GetTempPath(MAX_PATH, temp_dir)
424 && GetTempFileName(temp_dir, "qem", 0, filename)
425 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000426#else
bellardea2384d2004-08-01 21:59:26 +0000427 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000428 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000429 tmpdir = getenv("TMPDIR");
Amit Shah69bef792014-02-26 15:12:37 +0530430 if (!tmpdir) {
431 tmpdir = "/var/tmp";
432 }
Jim Meyeringeba25052012-05-28 09:27:54 +0200433 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
434 return -EOVERFLOW;
435 }
bellardea2384d2004-08-01 21:59:26 +0000436 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800437 if (fd < 0) {
438 return -errno;
439 }
440 if (close(fd) != 0) {
441 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200442 return -errno;
443 }
444 return 0;
bellardd5249392004-08-03 21:14:23 +0000445#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200446}
bellardea2384d2004-08-01 21:59:26 +0000447
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200448/*
449 * Detect host devices. By convention, /dev/cdrom[N] is always
450 * recognized as a host CDROM.
451 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200452static BlockDriver *find_hdev_driver(const char *filename)
453{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200454 int score_max = 0, score;
455 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200456
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100457 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200458 if (d->bdrv_probe_device) {
459 score = d->bdrv_probe_device(filename);
460 if (score > score_max) {
461 score_max = score;
462 drv = d;
463 }
464 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200465 }
466
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200467 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200468}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200469
Kevin Wolf98289622013-07-10 15:47:39 +0200470BlockDriver *bdrv_find_protocol(const char *filename,
Max Reitzb65a5e12015-02-05 13:58:12 -0500471 bool allow_protocol_prefix,
472 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200473{
474 BlockDriver *drv1;
475 char protocol[128];
476 int len;
477 const char *p;
478
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200479 /* TODO Drivers without bdrv_file_open must be specified explicitly */
480
Christoph Hellwig39508e72010-06-23 12:25:17 +0200481 /*
482 * XXX(hch): we really should not let host device detection
483 * override an explicit protocol specification, but moving this
484 * later breaks access to device names with colons in them.
485 * Thanks to the brain-dead persistent naming schemes on udev-
486 * based Linux systems those actually are quite common.
487 */
488 drv1 = find_hdev_driver(filename);
489 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200490 return drv1;
491 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200492
Kevin Wolf98289622013-07-10 15:47:39 +0200493 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Max Reitzef810432014-12-02 18:32:42 +0100494 return &bdrv_file;
Christoph Hellwig39508e72010-06-23 12:25:17 +0200495 }
Kevin Wolf98289622013-07-10 15:47:39 +0200496
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000497 p = strchr(filename, ':');
498 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200499 len = p - filename;
500 if (len > sizeof(protocol) - 1)
501 len = sizeof(protocol) - 1;
502 memcpy(protocol, filename, len);
503 protocol[len] = '\0';
504 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
505 if (drv1->protocol_name &&
506 !strcmp(drv1->protocol_name, protocol)) {
507 return drv1;
508 }
509 }
Max Reitzb65a5e12015-02-05 13:58:12 -0500510
511 error_setg(errp, "Unknown protocol '%s'", protocol);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200512 return NULL;
513}
514
Markus Armbrusterc6684242014-11-20 16:27:10 +0100515/*
516 * Guess image format by probing its contents.
517 * This is not a good idea when your image is raw (CVE-2008-2004), but
518 * we do it anyway for backward compatibility.
519 *
520 * @buf contains the image's first @buf_size bytes.
Kevin Wolf7cddd372014-11-20 16:27:11 +0100521 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
522 * but can be smaller if the image file is smaller)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100523 * @filename is its filename.
524 *
525 * For all block drivers, call the bdrv_probe() method to get its
526 * probing score.
527 * Return the first block driver with the highest probing score.
528 */
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100529BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
530 const char *filename)
Markus Armbrusterc6684242014-11-20 16:27:10 +0100531{
532 int score_max = 0, score;
533 BlockDriver *drv = NULL, *d;
534
535 QLIST_FOREACH(d, &bdrv_drivers, list) {
536 if (d->bdrv_probe) {
537 score = d->bdrv_probe(buf, buf_size, filename);
538 if (score > score_max) {
539 score_max = score;
540 drv = d;
541 }
542 }
543 }
544
545 return drv;
546}
547
Kevin Wolff500a6d2012-11-12 17:35:27 +0100548static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200549 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000550{
Markus Armbrusterc6684242014-11-20 16:27:10 +0100551 BlockDriver *drv;
Kevin Wolf7cddd372014-11-20 16:27:11 +0100552 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100553 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700554
Kevin Wolf08a00552010-06-01 18:37:31 +0200555 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300556 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Max Reitzef810432014-12-02 18:32:42 +0100557 *pdrv = &bdrv_raw;
Stefan Weilc98ac352010-07-21 21:51:51 +0200558 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700559 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700560
bellard83f64092006-08-01 16:21:11 +0000561 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000562 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200563 error_setg_errno(errp, -ret, "Could not read image for determining its "
564 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200565 *pdrv = NULL;
566 return ret;
bellard83f64092006-08-01 16:21:11 +0000567 }
568
Markus Armbrusterc6684242014-11-20 16:27:10 +0100569 drv = bdrv_probe_all(buf, ret, filename);
Stefan Weilc98ac352010-07-21 21:51:51 +0200570 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200571 error_setg(errp, "Could not determine image format: No compatible "
572 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200573 ret = -ENOENT;
574 }
575 *pdrv = drv;
576 return ret;
bellardea2384d2004-08-01 21:59:26 +0000577}
578
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100579/**
580 * Set the current 'total_sectors' value
Markus Armbruster65a9bb22014-06-26 13:23:17 +0200581 * Return 0 on success, -errno on error.
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100582 */
583static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
584{
585 BlockDriver *drv = bs->drv;
586
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700587 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +0300588 if (bdrv_is_sg(bs))
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700589 return 0;
590
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100591 /* query actual device if possible, otherwise just trust the hint */
592 if (drv->bdrv_getlength) {
593 int64_t length = drv->bdrv_getlength(bs);
594 if (length < 0) {
595 return length;
596 }
Fam Zheng7e382002013-11-06 19:48:06 +0800597 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100598 }
599
600 bs->total_sectors = hint;
601 return 0;
602}
603
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100604/**
Kevin Wolfcddff5b2015-11-16 16:43:27 +0100605 * Combines a QDict of new block driver @options with any missing options taken
606 * from @old_options, so that leaving out an option defaults to its old value.
607 */
608static void bdrv_join_options(BlockDriverState *bs, QDict *options,
609 QDict *old_options)
610{
611 if (bs->drv && bs->drv->bdrv_join_options) {
612 bs->drv->bdrv_join_options(options, old_options);
613 } else {
614 qdict_join(options, old_options, false);
615 }
616}
617
618/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100619 * Set open flags for a given discard mode
620 *
621 * Return 0 on success, -1 if the discard mode was invalid.
622 */
623int bdrv_parse_discard_flags(const char *mode, int *flags)
624{
625 *flags &= ~BDRV_O_UNMAP;
626
627 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
628 /* do nothing */
629 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
630 *flags |= BDRV_O_UNMAP;
631 } else {
632 return -1;
633 }
634
635 return 0;
636}
637
638/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100639 * Set open flags for a given cache mode
640 *
641 * Return 0 on success, -1 if the cache mode was invalid.
642 */
Kevin Wolf53e8ae02016-03-18 15:36:58 +0100643int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100644{
645 *flags &= ~BDRV_O_CACHE_MASK;
646
647 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +0100648 *writethrough = false;
649 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100650 } else if (!strcmp(mode, "directsync")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +0100651 *writethrough = true;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100652 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100653 } else if (!strcmp(mode, "writeback")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +0100654 *writethrough = false;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100655 } else if (!strcmp(mode, "unsafe")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +0100656 *writethrough = false;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100657 *flags |= BDRV_O_NO_FLUSH;
658 } else if (!strcmp(mode, "writethrough")) {
Kevin Wolf53e8ae02016-03-18 15:36:58 +0100659 *writethrough = true;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100660 } else {
661 return -1;
662 }
663
664 return 0;
665}
666
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200667/*
Kevin Wolf73176be2016-03-07 13:02:15 +0100668 * Returns the options and flags that a temporary snapshot should get, based on
669 * the originally requested flags (the originally requested image will have
670 * flags like a backing file)
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200671 */
Kevin Wolf73176be2016-03-07 13:02:15 +0100672static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
673 int parent_flags, QDict *parent_options)
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200674{
Kevin Wolf73176be2016-03-07 13:02:15 +0100675 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
676
677 /* For temporary files, unconditional cache=unsafe is fine */
Kevin Wolf73176be2016-03-07 13:02:15 +0100678 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
679 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200680}
681
682/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200683 * Returns the options and flags that bs->file should get if a protocol driver
684 * is expected, based on the given options and flags for the parent BDS
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200685 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200686static void bdrv_inherited_options(int *child_flags, QDict *child_options,
687 int parent_flags, QDict *parent_options)
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200688{
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200689 int flags = parent_flags;
690
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200691 /* Enable protocol handling, disable format probing for bs->file */
692 flags |= BDRV_O_PROTOCOL;
693
Kevin Wolf91a097e2015-05-08 17:49:53 +0200694 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
695 * the parent. */
696 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
697 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
698
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200699 /* Our block drivers take care to send flushes and respect unmap policy,
Kevin Wolf91a097e2015-05-08 17:49:53 +0200700 * so we can default to enable both on lower layers regardless of the
701 * corresponding parent options. */
Kevin Wolf91a097e2015-05-08 17:49:53 +0200702 flags |= BDRV_O_UNMAP;
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200703
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200704 /* Clear flags that only apply to the top layer */
Daniel P. Berrangeabb06c52016-03-21 14:11:42 +0000705 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
706 BDRV_O_NO_IO);
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200707
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200708 *child_flags = flags;
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200709}
710
Kevin Wolff3930ed2015-04-08 13:43:47 +0200711const BdrvChildRole child_file = {
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200712 .inherit_options = bdrv_inherited_options,
Kevin Wolff3930ed2015-04-08 13:43:47 +0200713};
714
715/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200716 * Returns the options and flags that bs->file should get if the use of formats
717 * (and not only protocols) is permitted for it, based on the given options and
718 * flags for the parent BDS
Kevin Wolff3930ed2015-04-08 13:43:47 +0200719 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200720static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
721 int parent_flags, QDict *parent_options)
Kevin Wolff3930ed2015-04-08 13:43:47 +0200722{
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200723 child_file.inherit_options(child_flags, child_options,
724 parent_flags, parent_options);
725
Daniel P. Berrangeabb06c52016-03-21 14:11:42 +0000726 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
Kevin Wolff3930ed2015-04-08 13:43:47 +0200727}
728
729const BdrvChildRole child_format = {
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200730 .inherit_options = bdrv_inherited_fmt_options,
Kevin Wolff3930ed2015-04-08 13:43:47 +0200731};
732
Kevin Wolf317fc442014-04-25 13:27:34 +0200733/*
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200734 * Returns the options and flags that bs->backing should get, based on the
735 * given options and flags for the parent BDS
Kevin Wolf317fc442014-04-25 13:27:34 +0200736 */
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200737static void bdrv_backing_options(int *child_flags, QDict *child_options,
738 int parent_flags, QDict *parent_options)
Kevin Wolf317fc442014-04-25 13:27:34 +0200739{
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200740 int flags = parent_flags;
741
Kevin Wolfb8816a42016-03-04 14:52:32 +0100742 /* The cache mode is inherited unmodified for backing files; except WCE,
743 * which is only applied on the top level (BlockBackend) */
Kevin Wolf91a097e2015-05-08 17:49:53 +0200744 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
745 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
746
Kevin Wolf317fc442014-04-25 13:27:34 +0200747 /* backing files always opened read-only */
748 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
749
750 /* snapshot=on is handled on the top layer */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200751 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
Kevin Wolf317fc442014-04-25 13:27:34 +0200752
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200753 *child_flags = flags;
Kevin Wolf317fc442014-04-25 13:27:34 +0200754}
755
Kevin Wolff3930ed2015-04-08 13:43:47 +0200756static const BdrvChildRole child_backing = {
Kevin Wolf8e2160e2015-04-29 17:29:39 +0200757 .inherit_options = bdrv_backing_options,
Kevin Wolff3930ed2015-04-08 13:43:47 +0200758};
759
Kevin Wolf7b272452012-11-12 17:05:39 +0100760static int bdrv_open_flags(BlockDriverState *bs, int flags)
761{
Kevin Wolf61de4c62016-03-18 17:46:45 +0100762 int open_flags = flags;
Kevin Wolf7b272452012-11-12 17:05:39 +0100763
764 /*
765 * Clear flags that are internal to the block layer before opening the
766 * image.
767 */
Kevin Wolf20cca272014-06-04 14:33:27 +0200768 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
Kevin Wolf7b272452012-11-12 17:05:39 +0100769
770 /*
771 * Snapshots should be writable.
772 */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200773 if (flags & BDRV_O_TEMPORARY) {
Kevin Wolf7b272452012-11-12 17:05:39 +0100774 open_flags |= BDRV_O_RDWR;
775 }
776
777 return open_flags;
778}
779
Kevin Wolf91a097e2015-05-08 17:49:53 +0200780static void update_flags_from_options(int *flags, QemuOpts *opts)
781{
782 *flags &= ~BDRV_O_CACHE_MASK;
783
Kevin Wolf91a097e2015-05-08 17:49:53 +0200784 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
785 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
786 *flags |= BDRV_O_NO_FLUSH;
787 }
788
789 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
790 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
791 *flags |= BDRV_O_NOCACHE;
792 }
793}
794
795static void update_options_from_flags(QDict *options, int flags)
796{
Kevin Wolf91a097e2015-05-08 17:49:53 +0200797 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
798 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
799 qbool_from_bool(flags & BDRV_O_NOCACHE));
800 }
801 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
802 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
803 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
804 }
805}
806
Kevin Wolf636ea372014-01-24 14:11:52 +0100807static void bdrv_assign_node_name(BlockDriverState *bs,
808 const char *node_name,
809 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +0100810{
Jeff Cody15489c72015-10-12 19:36:50 -0400811 char *gen_node_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100812
Jeff Cody15489c72015-10-12 19:36:50 -0400813 if (!node_name) {
814 node_name = gen_node_name = id_generate(ID_BLOCK);
815 } else if (!id_wellformed(node_name)) {
816 /*
817 * Check for empty string or invalid characters, but not if it is
818 * generated (generated names use characters not available to the user)
819 */
Kevin Wolf9aebf3b2014-09-25 09:54:02 +0200820 error_setg(errp, "Invalid node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100821 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100822 }
823
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100824 /* takes care of avoiding namespaces collisions */
Markus Armbruster7f06d472014-10-07 13:59:12 +0200825 if (blk_by_name(node_name)) {
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100826 error_setg(errp, "node-name=%s is conflicting with a device id",
827 node_name);
Jeff Cody15489c72015-10-12 19:36:50 -0400828 goto out;
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100829 }
830
Benoît Canet6913c0c2014-01-23 21:31:33 +0100831 /* takes care of avoiding duplicates node names */
832 if (bdrv_find_node(node_name)) {
833 error_setg(errp, "Duplicate node name");
Jeff Cody15489c72015-10-12 19:36:50 -0400834 goto out;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100835 }
836
837 /* copy node name into the bs and insert it into the graph list */
838 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
839 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Jeff Cody15489c72015-10-12 19:36:50 -0400840out:
841 g_free(gen_node_name);
Benoît Canet6913c0c2014-01-23 21:31:33 +0100842}
843
Kevin Wolf18edf282015-04-07 17:12:56 +0200844static QemuOptsList bdrv_runtime_opts = {
845 .name = "bdrv_common",
846 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
847 .desc = {
848 {
849 .name = "node-name",
850 .type = QEMU_OPT_STRING,
851 .help = "Node name of the block device node",
852 },
Kevin Wolf62392eb2015-04-24 16:38:02 +0200853 {
854 .name = "driver",
855 .type = QEMU_OPT_STRING,
856 .help = "Block driver to use for the node",
857 },
Kevin Wolf91a097e2015-05-08 17:49:53 +0200858 {
Kevin Wolf91a097e2015-05-08 17:49:53 +0200859 .name = BDRV_OPT_CACHE_DIRECT,
860 .type = QEMU_OPT_BOOL,
861 .help = "Bypass software writeback cache on the host",
862 },
863 {
864 .name = BDRV_OPT_CACHE_NO_FLUSH,
865 .type = QEMU_OPT_BOOL,
866 .help = "Ignore flush requests",
867 },
Kevin Wolf18edf282015-04-07 17:12:56 +0200868 { /* end of list */ }
869 },
870};
871
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200872/*
Kevin Wolf57915332010-04-14 15:24:50 +0200873 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100874 *
875 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200876 */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200877static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100878 QDict *options, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200879{
880 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200881 const char *filename;
Kevin Wolf62392eb2015-04-24 16:38:02 +0200882 const char *driver_name = NULL;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100883 const char *node_name = NULL;
Kevin Wolf18edf282015-04-07 17:12:56 +0200884 QemuOpts *opts;
Kevin Wolf62392eb2015-04-24 16:38:02 +0200885 BlockDriver *drv;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200886 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200887
Paolo Bonzini64058752012-05-08 16:51:49 +0200888 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100889 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200890
Kevin Wolf62392eb2015-04-24 16:38:02 +0200891 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
892 qemu_opts_absorb_qdict(opts, options, &local_err);
893 if (local_err) {
894 error_propagate(errp, local_err);
895 ret = -EINVAL;
896 goto fail_opts;
897 }
898
899 driver_name = qemu_opt_get(opts, "driver");
900 drv = bdrv_find_format(driver_name);
901 assert(drv != NULL);
902
Kevin Wolf45673672013-04-22 17:48:40 +0200903 if (file != NULL) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200904 filename = file->bs->filename;
Kevin Wolf45673672013-04-22 17:48:40 +0200905 } else {
906 filename = qdict_get_try_str(options, "filename");
907 }
908
Kevin Wolf765003d2014-02-03 14:49:42 +0100909 if (drv->bdrv_needs_filename && !filename) {
910 error_setg(errp, "The '%s' block driver requires a file name",
911 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +0200912 ret = -EINVAL;
913 goto fail_opts;
914 }
915
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100916 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
917 drv->format_name);
Kevin Wolf62392eb2015-04-24 16:38:02 +0200918
Kevin Wolf18edf282015-04-07 17:12:56 +0200919 node_name = qemu_opt_get(opts, "node-name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100920 bdrv_assign_node_name(bs, node_name, &local_err);
Markus Armbruster0fb63952014-04-25 16:50:31 +0200921 if (local_err) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100922 error_propagate(errp, local_err);
Kevin Wolf18edf282015-04-07 17:12:56 +0200923 ret = -EINVAL;
924 goto fail_opts;
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100925 }
926
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100927 bs->request_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800928 bs->zero_beyond_eof = true;
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100929 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800930
931 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200932 error_setg(errp,
933 !bs->read_only && bdrv_is_whitelisted(drv, true)
934 ? "Driver '%s' can only be used for read-only devices"
935 : "Driver '%s' is not whitelisted",
936 drv->format_name);
Kevin Wolf18edf282015-04-07 17:12:56 +0200937 ret = -ENOTSUP;
938 goto fail_opts;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800939 }
Kevin Wolf57915332010-04-14 15:24:50 +0200940
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000941 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100942 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200943 if (!bs->read_only) {
944 bdrv_enable_copy_on_read(bs);
945 } else {
946 error_setg(errp, "Can't use copy-on-read on read-only device");
Kevin Wolf18edf282015-04-07 17:12:56 +0200947 ret = -EINVAL;
948 goto fail_opts;
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200949 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000950 }
951
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100952 if (filename != NULL) {
953 pstrcpy(bs->filename, sizeof(bs->filename), filename);
954 } else {
955 bs->filename[0] = '\0';
956 }
Max Reitz91af7012014-07-18 20:24:56 +0200957 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
Kevin Wolf57915332010-04-14 15:24:50 +0200958
Kevin Wolf57915332010-04-14 15:24:50 +0200959 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500960 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200961
Kevin Wolf91a097e2015-05-08 17:49:53 +0200962 /* Apply cache mode options */
963 update_flags_from_options(&bs->open_flags, opts);
Kevin Wolf73ac4512016-03-14 15:46:03 +0100964
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200965 /* Open the image, either directly or using a protocol */
Kevin Wolf82dc8b42016-01-11 19:07:50 +0100966 open_flags = bdrv_open_flags(bs, bs->open_flags);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200967 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100968 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +0200969 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200970 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100971 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200972 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200973 error_setg(errp, "Can't use '%s' as a block driver for the "
974 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200975 ret = -EINVAL;
976 goto free_and_fail;
977 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100978 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200979 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200980 }
981
Kevin Wolf57915332010-04-14 15:24:50 +0200982 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100983 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200984 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800985 } else if (bs->filename[0]) {
986 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200987 } else {
988 error_setg_errno(errp, -ret, "Could not open image");
989 }
Kevin Wolf57915332010-04-14 15:24:50 +0200990 goto free_and_fail;
991 }
992
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100993 ret = refresh_total_sectors(bs, bs->total_sectors);
994 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200995 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100996 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200997 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100998
Kevin Wolf3baca892014-07-16 17:48:16 +0200999 bdrv_refresh_limits(bs, &local_err);
1000 if (local_err) {
1001 error_propagate(errp, local_err);
1002 ret = -EINVAL;
1003 goto free_and_fail;
1004 }
1005
Paolo Bonzinic25f53b2011-11-29 12:42:20 +01001006 assert(bdrv_opt_mem_align(bs) != 0);
Denis V. Lunev4196d2f2015-05-12 17:30:55 +03001007 assert(bdrv_min_mem_align(bs) != 0);
Dimitris Aragiorgisb192af82015-06-23 13:44:56 +03001008 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
Kevin Wolf18edf282015-04-07 17:12:56 +02001009
1010 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001011 return 0;
1012
1013free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001014 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -05001015 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +02001016 bs->opaque = NULL;
1017 bs->drv = NULL;
Kevin Wolf18edf282015-04-07 17:12:56 +02001018fail_opts:
1019 qemu_opts_del(opts);
Kevin Wolf57915332010-04-14 15:24:50 +02001020 return ret;
1021}
1022
Kevin Wolf5e5c4f62014-05-26 11:45:08 +02001023static QDict *parse_json_filename(const char *filename, Error **errp)
1024{
1025 QObject *options_obj;
1026 QDict *options;
1027 int ret;
1028
1029 ret = strstart(filename, "json:", &filename);
1030 assert(ret);
1031
1032 options_obj = qobject_from_json(filename);
1033 if (!options_obj) {
1034 error_setg(errp, "Could not parse the JSON options");
1035 return NULL;
1036 }
1037
1038 if (qobject_type(options_obj) != QTYPE_QDICT) {
1039 qobject_decref(options_obj);
1040 error_setg(errp, "Invalid JSON object given");
1041 return NULL;
1042 }
1043
1044 options = qobject_to_qdict(options_obj);
1045 qdict_flatten(options);
1046
1047 return options;
1048}
1049
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001050static void parse_json_protocol(QDict *options, const char **pfilename,
1051 Error **errp)
1052{
1053 QDict *json_options;
1054 Error *local_err = NULL;
1055
1056 /* Parse json: pseudo-protocol */
1057 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1058 return;
1059 }
1060
1061 json_options = parse_json_filename(*pfilename, &local_err);
1062 if (local_err) {
1063 error_propagate(errp, local_err);
1064 return;
1065 }
1066
1067 /* Options given in the filename have lower priority than options
1068 * specified directly */
1069 qdict_join(options, json_options, false);
1070 QDECREF(json_options);
1071 *pfilename = NULL;
1072}
1073
Kevin Wolf57915332010-04-14 15:24:50 +02001074/*
Kevin Wolff54120f2014-05-26 11:09:59 +02001075 * Fills in default options for opening images and converts the legacy
1076 * filename/flags pair to option QDict entries.
Max Reitz53a29512015-03-19 14:53:16 -04001077 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1078 * block driver has been specified explicitly.
Kevin Wolff54120f2014-05-26 11:09:59 +02001079 */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001080static int bdrv_fill_options(QDict **options, const char *filename,
Max Reitz053e1572015-08-26 19:47:51 +02001081 int *flags, Error **errp)
Kevin Wolff54120f2014-05-26 11:09:59 +02001082{
1083 const char *drvname;
Max Reitz53a29512015-03-19 14:53:16 -04001084 bool protocol = *flags & BDRV_O_PROTOCOL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001085 bool parse_filename = false;
Max Reitz053e1572015-08-26 19:47:51 +02001086 BlockDriver *drv = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001087 Error *local_err = NULL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001088
Max Reitz53a29512015-03-19 14:53:16 -04001089 drvname = qdict_get_try_str(*options, "driver");
Max Reitz053e1572015-08-26 19:47:51 +02001090 if (drvname) {
1091 drv = bdrv_find_format(drvname);
1092 if (!drv) {
1093 error_setg(errp, "Unknown driver '%s'", drvname);
1094 return -ENOENT;
1095 }
1096 /* If the user has explicitly specified the driver, this choice should
1097 * override the BDRV_O_PROTOCOL flag */
1098 protocol = drv->bdrv_file_open;
Max Reitz53a29512015-03-19 14:53:16 -04001099 }
1100
1101 if (protocol) {
1102 *flags |= BDRV_O_PROTOCOL;
1103 } else {
1104 *flags &= ~BDRV_O_PROTOCOL;
1105 }
1106
Kevin Wolf91a097e2015-05-08 17:49:53 +02001107 /* Translate cache options from flags into options */
1108 update_options_from_flags(*options, *flags);
1109
Kevin Wolff54120f2014-05-26 11:09:59 +02001110 /* Fetch the file name from the options QDict if necessary */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001111 if (protocol && filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001112 if (!qdict_haskey(*options, "filename")) {
1113 qdict_put(*options, "filename", qstring_from_str(filename));
1114 parse_filename = true;
1115 } else {
1116 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1117 "the same time");
1118 return -EINVAL;
1119 }
1120 }
1121
1122 /* Find the right block driver */
1123 filename = qdict_get_try_str(*options, "filename");
Kevin Wolff54120f2014-05-26 11:09:59 +02001124
Max Reitz053e1572015-08-26 19:47:51 +02001125 if (!drvname && protocol) {
1126 if (filename) {
1127 drv = bdrv_find_protocol(filename, parse_filename, errp);
1128 if (!drv) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001129 return -EINVAL;
1130 }
Max Reitz053e1572015-08-26 19:47:51 +02001131
1132 drvname = drv->format_name;
1133 qdict_put(*options, "driver", qstring_from_str(drvname));
1134 } else {
1135 error_setg(errp, "Must specify either driver or file");
1136 return -EINVAL;
Kevin Wolff54120f2014-05-26 11:09:59 +02001137 }
1138 }
1139
Kevin Wolf17b005f2014-05-27 10:50:29 +02001140 assert(drv || !protocol);
Kevin Wolff54120f2014-05-26 11:09:59 +02001141
1142 /* Driver-specific filename parsing */
Kevin Wolf17b005f2014-05-27 10:50:29 +02001143 if (drv && drv->bdrv_parse_filename && parse_filename) {
Kevin Wolff54120f2014-05-26 11:09:59 +02001144 drv->bdrv_parse_filename(filename, *options, &local_err);
1145 if (local_err) {
1146 error_propagate(errp, local_err);
1147 return -EINVAL;
1148 }
1149
1150 if (!drv->bdrv_needs_filename) {
1151 qdict_del(*options, "filename");
1152 }
1153 }
1154
1155 return 0;
1156}
1157
Kevin Wolff21d96d2016-03-08 13:47:46 +01001158BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
1159 const char *child_name,
1160 const BdrvChildRole *child_role)
Kevin Wolfdf581792015-06-15 11:53:47 +02001161{
1162 BdrvChild *child = g_new(BdrvChild, 1);
1163 *child = (BdrvChild) {
1164 .bs = child_bs,
Kevin Wolf260fecf2015-04-27 13:46:22 +02001165 .name = g_strdup(child_name),
Kevin Wolfdf581792015-06-15 11:53:47 +02001166 .role = child_role,
1167 };
1168
Kevin Wolfd42a8a92015-09-17 13:18:23 +02001169 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001170
1171 return child;
Kevin Wolfdf581792015-06-15 11:53:47 +02001172}
1173
Wen Congyang98292c62016-05-10 15:36:38 +08001174BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1175 BlockDriverState *child_bs,
1176 const char *child_name,
1177 const BdrvChildRole *child_role)
Kevin Wolff21d96d2016-03-08 13:47:46 +01001178{
1179 BdrvChild *child = bdrv_root_attach_child(child_bs, child_name, child_role);
1180 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1181 return child;
1182}
1183
Kevin Wolf3f09bfb2015-09-15 11:58:23 +02001184static void bdrv_detach_child(BdrvChild *child)
Kevin Wolf33a60402015-06-15 13:51:04 +02001185{
Kevin Wolff21d96d2016-03-08 13:47:46 +01001186 if (child->next.le_prev) {
1187 QLIST_REMOVE(child, next);
1188 child->next.le_prev = NULL;
1189 }
Kevin Wolfd42a8a92015-09-17 13:18:23 +02001190 QLIST_REMOVE(child, next_parent);
Kevin Wolf260fecf2015-04-27 13:46:22 +02001191 g_free(child->name);
Kevin Wolf33a60402015-06-15 13:51:04 +02001192 g_free(child);
1193}
1194
Kevin Wolff21d96d2016-03-08 13:47:46 +01001195void bdrv_root_unref_child(BdrvChild *child)
Kevin Wolf33a60402015-06-15 13:51:04 +02001196{
Kevin Wolf779020c2015-10-13 14:09:44 +02001197 BlockDriverState *child_bs;
1198
Kevin Wolff21d96d2016-03-08 13:47:46 +01001199 child_bs = child->bs;
1200 bdrv_detach_child(child);
1201 bdrv_unref(child_bs);
1202}
1203
1204void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1205{
Kevin Wolf779020c2015-10-13 14:09:44 +02001206 if (child == NULL) {
1207 return;
1208 }
Kevin Wolf33a60402015-06-15 13:51:04 +02001209
1210 if (child->bs->inherits_from == parent) {
1211 child->bs->inherits_from = NULL;
1212 }
1213
Kevin Wolff21d96d2016-03-08 13:47:46 +01001214 bdrv_root_unref_child(child);
Kevin Wolf33a60402015-06-15 13:51:04 +02001215}
1216
Kevin Wolf5c8cab42016-02-24 15:13:35 +01001217
1218static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
1219{
1220 BdrvChild *c;
1221 QLIST_FOREACH(c, &bs->parents, next_parent) {
1222 if (c->role->change_media) {
1223 c->role->change_media(c, load);
1224 }
1225 }
1226}
1227
1228static void bdrv_parent_cb_resize(BlockDriverState *bs)
1229{
1230 BdrvChild *c;
1231 QLIST_FOREACH(c, &bs->parents, next_parent) {
1232 if (c->role->resize) {
1233 c->role->resize(c);
1234 }
1235 }
1236}
1237
Kevin Wolf5db15a52015-09-14 15:33:33 +02001238/*
1239 * Sets the backing file link of a BDS. A new reference is created; callers
1240 * which don't need their own reference any more must call bdrv_unref().
1241 */
Fam Zheng8d24cce2014-05-23 21:29:45 +08001242void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1243{
Kevin Wolf5db15a52015-09-14 15:33:33 +02001244 if (backing_hd) {
1245 bdrv_ref(backing_hd);
1246 }
Fam Zheng8d24cce2014-05-23 21:29:45 +08001247
Kevin Wolf760e0062015-06-17 14:55:21 +02001248 if (bs->backing) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001249 assert(bs->backing_blocker);
Kevin Wolf760e0062015-06-17 14:55:21 +02001250 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
Kevin Wolf5db15a52015-09-14 15:33:33 +02001251 bdrv_unref_child(bs, bs->backing);
Fam Zheng826b6ca2014-05-23 21:29:47 +08001252 } else if (backing_hd) {
1253 error_setg(&bs->backing_blocker,
Alberto Garcia81e5f782015-04-08 12:29:19 +03001254 "node is used as backing hd of '%s'",
1255 bdrv_get_device_or_node_name(bs));
Fam Zheng826b6ca2014-05-23 21:29:47 +08001256 }
1257
Fam Zheng8d24cce2014-05-23 21:29:45 +08001258 if (!backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001259 error_free(bs->backing_blocker);
1260 bs->backing_blocker = NULL;
Kevin Wolf760e0062015-06-17 14:55:21 +02001261 bs->backing = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001262 goto out;
1263 }
Kevin Wolf260fecf2015-04-27 13:46:22 +02001264 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001265 bs->open_flags &= ~BDRV_O_NO_BACKING;
1266 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1267 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1268 backing_hd->drv ? backing_hd->drv->format_name : "");
Fam Zheng826b6ca2014-05-23 21:29:47 +08001269
Kevin Wolf760e0062015-06-17 14:55:21 +02001270 bdrv_op_block_all(backing_hd, bs->backing_blocker);
Fam Zheng826b6ca2014-05-23 21:29:47 +08001271 /* Otherwise we won't be able to commit due to check in bdrv_commit */
Kevin Wolf760e0062015-06-17 14:55:21 +02001272 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
Fam Zheng826b6ca2014-05-23 21:29:47 +08001273 bs->backing_blocker);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001274out:
Kevin Wolf3baca892014-07-16 17:48:16 +02001275 bdrv_refresh_limits(bs, NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001276}
1277
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001278/*
1279 * Opens the backing file for a BlockDriverState if not yet open
1280 *
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001281 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1282 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1283 * itself, all options starting with "${bdref_key}." are considered part of the
1284 * BlockdevRef.
1285 *
1286 * TODO Can this be unified with bdrv_open_image()?
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001287 */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001288int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1289 const char *bdref_key, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001290{
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001291 char *backing_filename = g_malloc0(PATH_MAX);
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001292 char *bdref_key_dot;
1293 const char *reference = NULL;
Kevin Wolf317fc442014-04-25 13:27:34 +02001294 int ret = 0;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001295 BlockDriverState *backing_hd;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001296 QDict *options;
1297 QDict *tmp_parent_options = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001298 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001299
Kevin Wolf760e0062015-06-17 14:55:21 +02001300 if (bs->backing != NULL) {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001301 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001302 }
1303
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001304 /* NULL means an empty set of options */
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001305 if (parent_options == NULL) {
1306 tmp_parent_options = qdict_new();
1307 parent_options = tmp_parent_options;
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001308 }
1309
Paolo Bonzini9156df12012-10-18 16:49:17 +02001310 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001311
1312 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1313 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1314 g_free(bdref_key_dot);
1315
1316 reference = qdict_get_try_str(parent_options, bdref_key);
1317 if (reference || qdict_haskey(options, "file.filename")) {
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001318 backing_filename[0] = '\0';
1319 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001320 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001321 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001322 } else {
Max Reitz9f074292014-11-26 17:20:26 +01001323 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1324 &local_err);
1325 if (local_err) {
1326 ret = -EINVAL;
1327 error_propagate(errp, local_err);
1328 QDECREF(options);
1329 goto free_exit;
1330 }
Paolo Bonzini9156df12012-10-18 16:49:17 +02001331 }
1332
Kevin Wolf8ee79e72014-06-04 15:09:35 +02001333 if (!bs->drv || !bs->drv->supports_backing) {
1334 ret = -EINVAL;
1335 error_setg(errp, "Driver doesn't support backing files");
1336 QDECREF(options);
1337 goto free_exit;
1338 }
1339
Kevin Wolfc5f6e492014-11-25 18:12:42 +01001340 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1341 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
Paolo Bonzini9156df12012-10-18 16:49:17 +02001342 }
1343
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001344 backing_hd = NULL;
Kevin Wolff3930ed2015-04-08 13:43:47 +02001345 ret = bdrv_open_inherit(&backing_hd,
1346 *backing_filename ? backing_filename : NULL,
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001347 reference, options, 0, bs, &child_backing,
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001348 errp);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001349 if (ret < 0) {
Paolo Bonzini9156df12012-10-18 16:49:17 +02001350 bs->open_flags |= BDRV_O_NO_BACKING;
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001351 error_prepend(errp, "Could not open backing file: ");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001352 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001353 }
Kevin Wolfdf581792015-06-15 11:53:47 +02001354
Kevin Wolf5db15a52015-09-14 15:33:33 +02001355 /* Hook up the backing file link; drop our reference, bs owns the
1356 * backing_hd reference now */
Fam Zheng8d24cce2014-05-23 21:29:45 +08001357 bdrv_set_backing_hd(bs, backing_hd);
Kevin Wolf5db15a52015-09-14 15:33:33 +02001358 bdrv_unref(backing_hd);
Peter Feinerd80ac652014-01-08 19:43:25 +00001359
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001360 qdict_del(parent_options, bdref_key);
1361
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001362free_exit:
1363 g_free(backing_filename);
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001364 QDECREF(tmp_parent_options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001365 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001366}
1367
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001368/*
Max Reitzda557aa2013-12-20 19:28:11 +01001369 * Opens a disk image whose options are given as BlockdevRef in another block
1370 * device's options.
1371 *
Max Reitzda557aa2013-12-20 19:28:11 +01001372 * If allow_none is true, no image will be opened if filename is false and no
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001373 * BlockdevRef is given. NULL will be returned, but errp remains unset.
Max Reitzda557aa2013-12-20 19:28:11 +01001374 *
1375 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1376 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1377 * itself, all options starting with "${bdref_key}." are considered part of the
1378 * BlockdevRef.
1379 *
1380 * The BlockdevRef will be removed from the options QDict.
1381 */
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001382BdrvChild *bdrv_open_child(const char *filename,
1383 QDict *options, const char *bdref_key,
1384 BlockDriverState* parent,
1385 const BdrvChildRole *child_role,
1386 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01001387{
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001388 BdrvChild *c = NULL;
1389 BlockDriverState *bs;
Max Reitzda557aa2013-12-20 19:28:11 +01001390 QDict *image_options;
1391 int ret;
1392 char *bdref_key_dot;
1393 const char *reference;
1394
Kevin Wolfdf581792015-06-15 11:53:47 +02001395 assert(child_role != NULL);
Max Reitzf67503e2014-02-18 18:33:05 +01001396
Max Reitzda557aa2013-12-20 19:28:11 +01001397 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1398 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1399 g_free(bdref_key_dot);
1400
1401 reference = qdict_get_try_str(options, bdref_key);
1402 if (!filename && !reference && !qdict_size(image_options)) {
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001403 if (!allow_none) {
Max Reitzda557aa2013-12-20 19:28:11 +01001404 error_setg(errp, "A block device must be specified for \"%s\"",
1405 bdref_key);
Max Reitzda557aa2013-12-20 19:28:11 +01001406 }
Markus Armbrusterb20e61e2014-05-28 11:16:57 +02001407 QDECREF(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01001408 goto done;
1409 }
1410
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001411 bs = NULL;
1412 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
Max Reitzce343772015-08-26 19:47:50 +02001413 parent, child_role, errp);
Kevin Wolfdf581792015-06-15 11:53:47 +02001414 if (ret < 0) {
1415 goto done;
1416 }
1417
Kevin Wolf260fecf2015-04-27 13:46:22 +02001418 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
Max Reitzda557aa2013-12-20 19:28:11 +01001419
1420done:
1421 qdict_del(options, bdref_key);
Kevin Wolfb4b059f2015-06-15 13:24:19 +02001422 return c;
1423}
1424
Max Reitz66836182016-05-17 16:41:27 +02001425static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
1426 int flags,
1427 QDict *snapshot_options,
1428 Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02001429{
1430 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001431 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001432 int64_t total_size;
Chunyan Liu83d05212014-06-05 17:20:51 +08001433 QemuOpts *opts = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001434 BlockDriverState *bs_snapshot;
Fam Zhengc2e0dbb2015-07-06 12:24:44 +08001435 Error *local_err = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001436 int ret;
1437
1438 /* if snapshot, we create a temporary backing file and open it
1439 instead of opening 'filename' directly */
1440
1441 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02001442 total_size = bdrv_getlength(bs);
1443 if (total_size < 0) {
1444 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001445 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02001446 }
Kevin Wolfb9988752014-04-03 12:09:34 +02001447
1448 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001449 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001450 if (ret < 0) {
1451 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001452 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001453 }
1454
Max Reitzef810432014-12-02 18:32:42 +01001455 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001456 &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01001457 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001458 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
Chunyan Liu83d05212014-06-05 17:20:51 +08001459 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02001460 if (ret < 0) {
Markus Armbrustere43bfd92015-12-18 16:35:15 +01001461 error_prepend(errp, "Could not create temporary overlay '%s': ",
1462 tmp_filename);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001463 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001464 }
1465
Kevin Wolf73176be2016-03-07 13:02:15 +01001466 /* Prepare options QDict for the temporary file */
Kevin Wolfb9988752014-04-03 12:09:34 +02001467 qdict_put(snapshot_options, "file.driver",
1468 qstring_from_str("file"));
1469 qdict_put(snapshot_options, "file.filename",
1470 qstring_from_str(tmp_filename));
Max Reitze6641712015-08-26 19:47:48 +02001471 qdict_put(snapshot_options, "driver",
1472 qstring_from_str("qcow2"));
Kevin Wolfb9988752014-04-03 12:09:34 +02001473
Max Reitz506f8702016-05-17 16:41:26 +02001474 bs_snapshot = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001475 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
Max Reitz6ebf9aa2015-08-26 19:47:49 +02001476 flags, &local_err);
Kevin Wolf73176be2016-03-07 13:02:15 +01001477 snapshot_options = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001478 if (ret < 0) {
1479 error_propagate(errp, local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001480 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001481 }
1482
Max Reitz66836182016-05-17 16:41:27 +02001483 /* bdrv_append() consumes a strong reference to bs_snapshot (i.e. it will
1484 * call bdrv_unref() on it), so in order to be able to return one, we have
1485 * to increase bs_snapshot's refcount here */
1486 bdrv_ref(bs_snapshot);
Kevin Wolfb9988752014-04-03 12:09:34 +02001487 bdrv_append(bs_snapshot, bs);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001488
Max Reitz66836182016-05-17 16:41:27 +02001489 g_free(tmp_filename);
1490 return bs_snapshot;
1491
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001492out:
Kevin Wolf73176be2016-03-07 13:02:15 +01001493 QDECREF(snapshot_options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001494 g_free(tmp_filename);
Max Reitz66836182016-05-17 16:41:27 +02001495 return NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001496}
1497
Max Reitzda557aa2013-12-20 19:28:11 +01001498/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001499 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001500 *
1501 * options is a QDict of options to pass to the block drivers, or NULL for an
1502 * empty set of options. The reference to the QDict belongs to the block layer
1503 * after the call (even on failure), so if the caller intends to reuse the
1504 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01001505 *
1506 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1507 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01001508 *
1509 * The reference parameter may be used to specify an existing block device which
1510 * should be opened. If specified, neither options nor a filename may be given,
1511 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001512 */
Kevin Wolff3930ed2015-04-08 13:43:47 +02001513static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1514 const char *reference, QDict *options, int flags,
1515 BlockDriverState *parent,
Max Reitzce343772015-08-26 19:47:50 +02001516 const BdrvChildRole *child_role, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001517{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001518 int ret;
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001519 BdrvChild *file = NULL;
1520 BlockDriverState *bs;
Max Reitzce343772015-08-26 19:47:50 +02001521 BlockDriver *drv = NULL;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001522 const char *drvname;
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02001523 const char *backing;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001524 Error *local_err = NULL;
Kevin Wolf73176be2016-03-07 13:02:15 +01001525 QDict *snapshot_options = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001526 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00001527
Max Reitzf67503e2014-02-18 18:33:05 +01001528 assert(pbs);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001529 assert(!child_role || !flags);
1530 assert(!child_role == !parent);
Max Reitzf67503e2014-02-18 18:33:05 +01001531
Max Reitzddf56362014-02-18 18:33:06 +01001532 if (reference) {
1533 bool options_non_empty = options ? qdict_size(options) : false;
1534 QDECREF(options);
1535
1536 if (*pbs) {
1537 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1538 "another block device");
1539 return -EINVAL;
1540 }
1541
1542 if (filename || options_non_empty) {
1543 error_setg(errp, "Cannot reference an existing block device with "
1544 "additional options or a new filename");
1545 return -EINVAL;
1546 }
1547
1548 bs = bdrv_lookup_bs(reference, reference, errp);
1549 if (!bs) {
1550 return -ENODEV;
1551 }
Kevin Wolf76b22322016-04-04 17:11:13 +02001552
Max Reitzddf56362014-02-18 18:33:06 +01001553 bdrv_ref(bs);
1554 *pbs = bs;
1555 return 0;
1556 }
1557
Max Reitzf67503e2014-02-18 18:33:05 +01001558 if (*pbs) {
1559 bs = *pbs;
1560 } else {
Markus Armbrustere4e99862014-10-07 13:59:03 +02001561 bs = bdrv_new();
Max Reitzf67503e2014-02-18 18:33:05 +01001562 }
1563
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001564 /* NULL means an empty set of options */
1565 if (options == NULL) {
1566 options = qdict_new();
1567 }
1568
Kevin Wolf145f5982015-05-08 16:15:03 +02001569 /* json: syntax counts as explicit options, as if in the QDict */
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001570 parse_json_protocol(options, &filename, &local_err);
1571 if (local_err) {
1572 ret = -EINVAL;
1573 goto fail;
1574 }
1575
Kevin Wolf145f5982015-05-08 16:15:03 +02001576 bs->explicit_options = qdict_clone_shallow(options);
1577
Kevin Wolff3930ed2015-04-08 13:43:47 +02001578 if (child_role) {
Kevin Wolfbddcec32015-04-09 18:47:50 +02001579 bs->inherits_from = parent;
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001580 child_role->inherit_options(&flags, options,
1581 parent->open_flags, parent->options);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001582 }
1583
Kevin Wolfde3b53f2015-10-29 15:24:41 +01001584 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
Kevin Wolf462f5bc2014-05-26 11:39:55 +02001585 if (local_err) {
1586 goto fail;
1587 }
1588
Kevin Wolf62392eb2015-04-24 16:38:02 +02001589 bs->open_flags = flags;
1590 bs->options = options;
1591 options = qdict_clone_shallow(options);
1592
Kevin Wolf76c591b2014-06-04 14:19:44 +02001593 /* Find the right image format driver */
Kevin Wolf76c591b2014-06-04 14:19:44 +02001594 drvname = qdict_get_try_str(options, "driver");
1595 if (drvname) {
1596 drv = bdrv_find_format(drvname);
Kevin Wolf76c591b2014-06-04 14:19:44 +02001597 if (!drv) {
1598 error_setg(errp, "Unknown driver: '%s'", drvname);
1599 ret = -EINVAL;
1600 goto fail;
1601 }
1602 }
1603
1604 assert(drvname || !(flags & BDRV_O_PROTOCOL));
Kevin Wolf76c591b2014-06-04 14:19:44 +02001605
Alberto Garcia3e8c2e52015-10-26 14:27:15 +02001606 backing = qdict_get_try_str(options, "backing");
1607 if (backing && *backing == '\0') {
1608 flags |= BDRV_O_NO_BACKING;
1609 qdict_del(options, "backing");
1610 }
1611
Kevin Wolff4788ad2014-06-03 16:44:19 +02001612 /* Open image file without format layer */
1613 if ((flags & BDRV_O_PROTOCOL) == 0) {
1614 if (flags & BDRV_O_RDWR) {
1615 flags |= BDRV_O_ALLOW_RDWR;
1616 }
1617 if (flags & BDRV_O_SNAPSHOT) {
Kevin Wolf73176be2016-03-07 13:02:15 +01001618 snapshot_options = qdict_new();
1619 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
1620 flags, options);
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001621 bdrv_backing_options(&flags, options, flags, options);
Kevin Wolff4788ad2014-06-03 16:44:19 +02001622 }
1623
Kevin Wolff3930ed2015-04-08 13:43:47 +02001624 bs->open_flags = flags;
Kevin Wolf1fdd6932015-06-15 14:11:51 +02001625
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001626 file = bdrv_open_child(filename, options, "file", bs,
1627 &child_file, true, &local_err);
Kevin Wolf1fdd6932015-06-15 14:11:51 +02001628 if (local_err) {
1629 ret = -EINVAL;
Max Reitz5469a2a2014-02-18 18:33:10 +01001630 goto fail;
1631 }
1632 }
1633
Kevin Wolf76c591b2014-06-04 14:19:44 +02001634 /* Image format probing */
Kevin Wolf38f3ef52014-11-20 16:27:12 +01001635 bs->probed = !drv;
Kevin Wolf76c591b2014-06-04 14:19:44 +02001636 if (!drv && file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001637 ret = find_image_format(file->bs, filename, &drv, &local_err);
Kevin Wolf17b005f2014-05-27 10:50:29 +02001638 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001639 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01001640 }
Kevin Wolf62392eb2015-04-24 16:38:02 +02001641 /*
1642 * This option update would logically belong in bdrv_fill_options(),
1643 * but we first need to open bs->file for the probing to work, while
1644 * opening bs->file already requires the (mostly) final set of options
1645 * so that cache mode etc. can be inherited.
1646 *
1647 * Adding the driver later is somewhat ugly, but it's not an option
1648 * that would ever be inherited, so it's correct. We just need to make
1649 * sure to update both bs->options (which has the full effective
1650 * options for bs) and options (which has file.* already removed).
1651 */
1652 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1653 qdict_put(options, "driver", qstring_from_str(drv->format_name));
Kevin Wolf76c591b2014-06-04 14:19:44 +02001654 } else if (!drv) {
Kevin Wolf17b005f2014-05-27 10:50:29 +02001655 error_setg(errp, "Must specify either driver or file");
1656 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001657 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001658 }
1659
Max Reitz53a29512015-03-19 14:53:16 -04001660 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1661 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1662 /* file must be NULL if a protocol BDS is about to be created
1663 * (the inverse results in an error message from bdrv_open_common()) */
1664 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1665
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001666 /* Open the image */
Kevin Wolf82dc8b42016-01-11 19:07:50 +01001667 ret = bdrv_open_common(bs, file, options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001668 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001669 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01001670 }
1671
Max Reitz2a05cbe2013-12-20 19:28:10 +01001672 if (file && (bs->file != file)) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001673 bdrv_unref_child(bs, file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001674 file = NULL;
1675 }
1676
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001677 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001678 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolfd9b7b052015-01-16 18:23:41 +01001679 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001680 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001681 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001682 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001683 }
1684
Max Reitz91af7012014-07-18 20:24:56 +02001685 bdrv_refresh_filename(bs);
1686
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001687 /* Check if any unknown options were used */
Max Reitz5acd9d82014-02-18 18:33:11 +01001688 if (options && (qdict_size(options) != 0)) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001689 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01001690 if (flags & BDRV_O_PROTOCOL) {
1691 error_setg(errp, "Block protocol '%s' doesn't support the option "
1692 "'%s'", drv->format_name, entry->key);
1693 } else {
Max Reitzd0e46a52016-03-16 19:54:34 +01001694 error_setg(errp,
1695 "Block format '%s' does not support the option '%s'",
1696 drv->format_name, entry->key);
Max Reitz5acd9d82014-02-18 18:33:11 +01001697 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001698
1699 ret = -EINVAL;
1700 goto close_and_fail;
1701 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001702
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001703 if (!bdrv_key_required(bs)) {
Kevin Wolf5c8cab42016-02-24 15:13:35 +01001704 bdrv_parent_cb_change_media(bs, true);
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001705 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1706 && !runstate_check(RUN_STATE_INMIGRATE)
1707 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1708 error_setg(errp,
1709 "Guest must be stopped for opening of encrypted image");
1710 ret = -EBUSY;
1711 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001712 }
1713
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001714 QDECREF(options);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02001715
1716 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1717 * temporary snapshot afterwards. */
1718 if (snapshot_flags) {
Max Reitz66836182016-05-17 16:41:27 +02001719 BlockDriverState *snapshot_bs;
1720 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
1721 snapshot_options, &local_err);
Kevin Wolf73176be2016-03-07 13:02:15 +01001722 snapshot_options = NULL;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02001723 if (local_err) {
Max Reitz66836182016-05-17 16:41:27 +02001724 ret = -EINVAL;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02001725 goto close_and_fail;
1726 }
Max Reitz66836182016-05-17 16:41:27 +02001727 if (!*pbs) {
1728 /* We are not going to return bs but the overlay on top of it
1729 * (snapshot_bs); thus, we have to drop the strong reference to bs
1730 * (which we obtained by calling bdrv_new()). bs will not be
1731 * deleted, though, because the overlay still has a reference to it.
1732 */
1733 bdrv_unref(bs);
1734 bs = snapshot_bs;
1735 } else {
1736 /* We are not going to return snapshot_bs, so we have to drop the
1737 * strong reference to it (which was returned by
1738 * bdrv_append_temp_snapshot()). snapshot_bs will not be deleted,
1739 * though, because bdrv_append_temp_snapshot() made all parental
1740 * references to bs (*pbs) point to snapshot_bs.
1741 * In fact, if *pbs was not NULL, we are not going to return any new
1742 * BDS. But we do not need to decrement bs's refcount here as is
1743 * done above, because with a non-NULL *pbs this function never even
1744 * had a strong reference to bs. */
1745 bdrv_unref(snapshot_bs);
1746 }
1747 }
1748
1749 if (!*pbs) {
1750 *pbs = bs;
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02001751 }
1752
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001753 return 0;
1754
Kevin Wolf8bfea152014-04-11 19:16:36 +02001755fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001756 if (file != NULL) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02001757 bdrv_unref_child(bs, file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001758 }
Kevin Wolf73176be2016-03-07 13:02:15 +01001759 QDECREF(snapshot_options);
Kevin Wolf145f5982015-05-08 16:15:03 +02001760 QDECREF(bs->explicit_options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001761 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001762 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001763 bs->options = NULL;
Max Reitzf67503e2014-02-18 18:33:05 +01001764 if (!*pbs) {
1765 /* If *pbs is NULL, a new BDS has been created in this function and
1766 needs to be freed now. Otherwise, it does not need to be closed,
1767 since it has not really been opened yet. */
1768 bdrv_unref(bs);
1769 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001770 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001771 error_propagate(errp, local_err);
1772 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001773 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001774
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001775close_and_fail:
Max Reitzf67503e2014-02-18 18:33:05 +01001776 /* See fail path, but now the BDS has to be always closed */
1777 if (*pbs) {
1778 bdrv_close(bs);
1779 } else {
1780 bdrv_unref(bs);
1781 }
Kevin Wolf73176be2016-03-07 13:02:15 +01001782 QDECREF(snapshot_options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001783 QDECREF(options);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001784 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001785 error_propagate(errp, local_err);
1786 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001787 return ret;
1788}
1789
Kevin Wolff3930ed2015-04-08 13:43:47 +02001790int bdrv_open(BlockDriverState **pbs, const char *filename,
Max Reitz6ebf9aa2015-08-26 19:47:49 +02001791 const char *reference, QDict *options, int flags, Error **errp)
Kevin Wolff3930ed2015-04-08 13:43:47 +02001792{
1793 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
Max Reitzce343772015-08-26 19:47:50 +02001794 NULL, errp);
Kevin Wolff3930ed2015-04-08 13:43:47 +02001795}
1796
Jeff Codye971aa12012-09-20 15:13:19 -04001797typedef struct BlockReopenQueueEntry {
1798 bool prepared;
1799 BDRVReopenState state;
1800 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1801} BlockReopenQueueEntry;
1802
1803/*
1804 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1805 * reopen of multiple devices.
1806 *
1807 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1808 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1809 * be created and initialized. This newly created BlockReopenQueue should be
1810 * passed back in for subsequent calls that are intended to be of the same
1811 * atomic 'set'.
1812 *
1813 * bs is the BlockDriverState to add to the reopen queue.
1814 *
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001815 * options contains the changed options for the associated bs
1816 * (the BlockReopenQueue takes ownership)
1817 *
Jeff Codye971aa12012-09-20 15:13:19 -04001818 * flags contains the open flags for the associated bs
1819 *
1820 * returns a pointer to bs_queue, which is either the newly allocated
1821 * bs_queue, or the existing bs_queue being used.
1822 *
1823 */
Kevin Wolf28518102015-05-08 17:07:31 +02001824static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1825 BlockDriverState *bs,
1826 QDict *options,
1827 int flags,
1828 const BdrvChildRole *role,
1829 QDict *parent_options,
1830 int parent_flags)
Jeff Codye971aa12012-09-20 15:13:19 -04001831{
1832 assert(bs != NULL);
1833
1834 BlockReopenQueueEntry *bs_entry;
Kevin Wolf67251a32015-04-09 18:54:04 +02001835 BdrvChild *child;
Kevin Wolf145f5982015-05-08 16:15:03 +02001836 QDict *old_options, *explicit_options;
Kevin Wolf67251a32015-04-09 18:54:04 +02001837
Jeff Codye971aa12012-09-20 15:13:19 -04001838 if (bs_queue == NULL) {
1839 bs_queue = g_new0(BlockReopenQueue, 1);
1840 QSIMPLEQ_INIT(bs_queue);
1841 }
1842
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001843 if (!options) {
1844 options = qdict_new();
1845 }
1846
Kevin Wolf28518102015-05-08 17:07:31 +02001847 /*
1848 * Precedence of options:
1849 * 1. Explicitly passed in options (highest)
Kevin Wolf91a097e2015-05-08 17:49:53 +02001850 * 2. Set in flags (only for top level)
Kevin Wolf145f5982015-05-08 16:15:03 +02001851 * 3. Retained from explicitly set options of bs
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001852 * 4. Inherited from parent node
Kevin Wolf28518102015-05-08 17:07:31 +02001853 * 5. Retained from effective options of bs
1854 */
1855
Kevin Wolf91a097e2015-05-08 17:49:53 +02001856 if (!parent_options) {
1857 /*
1858 * Any setting represented by flags is always updated. If the
1859 * corresponding QDict option is set, it takes precedence. Otherwise
1860 * the flag is translated into a QDict option. The old setting of bs is
1861 * not considered.
1862 */
1863 update_options_from_flags(options, flags);
1864 }
1865
Kevin Wolf145f5982015-05-08 16:15:03 +02001866 /* Old explicitly set values (don't overwrite by inherited value) */
1867 old_options = qdict_clone_shallow(bs->explicit_options);
1868 bdrv_join_options(bs, options, old_options);
1869 QDECREF(old_options);
1870
1871 explicit_options = qdict_clone_shallow(options);
1872
Kevin Wolf28518102015-05-08 17:07:31 +02001873 /* Inherit from parent node */
1874 if (parent_options) {
1875 assert(!flags);
Kevin Wolf8e2160e2015-04-29 17:29:39 +02001876 role->inherit_options(&flags, options, parent_flags, parent_options);
Kevin Wolf28518102015-05-08 17:07:31 +02001877 }
1878
1879 /* Old values are used for options that aren't set yet */
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001880 old_options = qdict_clone_shallow(bs->options);
Kevin Wolfcddff5b2015-11-16 16:43:27 +01001881 bdrv_join_options(bs, options, old_options);
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001882 QDECREF(old_options);
1883
Kevin Wolff1f25a22014-04-25 19:04:55 +02001884 /* bdrv_open() masks this flag out */
1885 flags &= ~BDRV_O_PROTOCOL;
1886
Kevin Wolf67251a32015-04-09 18:54:04 +02001887 QLIST_FOREACH(child, &bs->children, next) {
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02001888 QDict *new_child_options;
1889 char *child_key_dot;
Kevin Wolf67251a32015-04-09 18:54:04 +02001890
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02001891 /* reopen can only change the options of block devices that were
1892 * implicitly created and inherited options. For other (referenced)
1893 * block devices, a syntax like "backing.foo" results in an error. */
Kevin Wolf67251a32015-04-09 18:54:04 +02001894 if (child->bs->inherits_from != bs) {
1895 continue;
1896 }
1897
Kevin Wolf4c9dfe52015-05-08 15:14:15 +02001898 child_key_dot = g_strdup_printf("%s.", child->name);
1899 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
1900 g_free(child_key_dot);
1901
Kevin Wolf28518102015-05-08 17:07:31 +02001902 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1903 child->role, options, flags);
Jeff Codye971aa12012-09-20 15:13:19 -04001904 }
1905
1906 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1907 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1908
1909 bs_entry->state.bs = bs;
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001910 bs_entry->state.options = options;
Kevin Wolf145f5982015-05-08 16:15:03 +02001911 bs_entry->state.explicit_options = explicit_options;
Jeff Codye971aa12012-09-20 15:13:19 -04001912 bs_entry->state.flags = flags;
1913
1914 return bs_queue;
1915}
1916
Kevin Wolf28518102015-05-08 17:07:31 +02001917BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1918 BlockDriverState *bs,
1919 QDict *options, int flags)
1920{
1921 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
1922 NULL, NULL, 0);
1923}
1924
Jeff Codye971aa12012-09-20 15:13:19 -04001925/*
1926 * Reopen multiple BlockDriverStates atomically & transactionally.
1927 *
1928 * The queue passed in (bs_queue) must have been built up previous
1929 * via bdrv_reopen_queue().
1930 *
1931 * Reopens all BDS specified in the queue, with the appropriate
1932 * flags. All devices are prepared for reopen, and failure of any
1933 * device will cause all device changes to be abandonded, and intermediate
1934 * data cleaned up.
1935 *
1936 * If all devices prepare successfully, then the changes are committed
1937 * to all devices.
1938 *
1939 */
1940int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1941{
1942 int ret = -1;
1943 BlockReopenQueueEntry *bs_entry, *next;
1944 Error *local_err = NULL;
1945
1946 assert(bs_queue != NULL);
1947
1948 bdrv_drain_all();
1949
1950 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1951 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1952 error_propagate(errp, local_err);
1953 goto cleanup;
1954 }
1955 bs_entry->prepared = true;
1956 }
1957
1958 /* If we reach this point, we have success and just need to apply the
1959 * changes
1960 */
1961 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1962 bdrv_reopen_commit(&bs_entry->state);
1963 }
1964
1965 ret = 0;
1966
1967cleanup:
1968 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1969 if (ret && bs_entry->prepared) {
1970 bdrv_reopen_abort(&bs_entry->state);
Kevin Wolf145f5982015-05-08 16:15:03 +02001971 } else if (ret) {
1972 QDECREF(bs_entry->state.explicit_options);
Jeff Codye971aa12012-09-20 15:13:19 -04001973 }
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001974 QDECREF(bs_entry->state.options);
Jeff Codye971aa12012-09-20 15:13:19 -04001975 g_free(bs_entry);
1976 }
1977 g_free(bs_queue);
1978 return ret;
1979}
1980
1981
1982/* Reopen a single BlockDriverState with the specified flags. */
1983int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1984{
1985 int ret = -1;
1986 Error *local_err = NULL;
Kevin Wolf4d2cb092015-04-10 17:50:50 +02001987 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
Jeff Codye971aa12012-09-20 15:13:19 -04001988
1989 ret = bdrv_reopen_multiple(queue, &local_err);
1990 if (local_err != NULL) {
1991 error_propagate(errp, local_err);
1992 }
1993 return ret;
1994}
1995
1996
1997/*
1998 * Prepares a BlockDriverState for reopen. All changes are staged in the
1999 * 'opaque' field of the BDRVReopenState, which is used and allocated by
2000 * the block driver layer .bdrv_reopen_prepare()
2001 *
2002 * bs is the BlockDriverState to reopen
2003 * flags are the new open flags
2004 * queue is the reopen queue
2005 *
2006 * Returns 0 on success, non-zero on error. On error errp will be set
2007 * as well.
2008 *
2009 * On failure, bdrv_reopen_abort() will be called to clean up any data.
2010 * It is the responsibility of the caller to then call the abort() or
2011 * commit() for any other BDS that have been left in a prepare() state
2012 *
2013 */
2014int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
2015 Error **errp)
2016{
2017 int ret = -1;
2018 Error *local_err = NULL;
2019 BlockDriver *drv;
Kevin Wolfccf9dc02015-05-08 17:24:56 +02002020 QemuOpts *opts;
2021 const char *value;
Jeff Codye971aa12012-09-20 15:13:19 -04002022
2023 assert(reopen_state != NULL);
2024 assert(reopen_state->bs->drv != NULL);
2025 drv = reopen_state->bs->drv;
2026
Kevin Wolfccf9dc02015-05-08 17:24:56 +02002027 /* Process generic block layer options */
2028 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
2029 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
2030 if (local_err) {
2031 error_propagate(errp, local_err);
2032 ret = -EINVAL;
2033 goto error;
2034 }
2035
Kevin Wolf91a097e2015-05-08 17:49:53 +02002036 update_flags_from_options(&reopen_state->flags, opts);
2037
Kevin Wolfccf9dc02015-05-08 17:24:56 +02002038 /* node-name and driver must be unchanged. Put them back into the QDict, so
2039 * that they are checked at the end of this function. */
2040 value = qemu_opt_get(opts, "node-name");
2041 if (value) {
2042 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2043 }
2044
2045 value = qemu_opt_get(opts, "driver");
2046 if (value) {
2047 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2048 }
2049
Jeff Codye971aa12012-09-20 15:13:19 -04002050 /* if we are to stay read-only, do not allow permission change
2051 * to r/w */
2052 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2053 reopen_state->flags & BDRV_O_RDWR) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03002054 error_setg(errp, "Node '%s' is read only",
2055 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04002056 goto error;
2057 }
2058
2059
2060 ret = bdrv_flush(reopen_state->bs);
2061 if (ret) {
Eric Blake455b0fd2015-11-10 23:51:20 -07002062 error_setg_errno(errp, -ret, "Error flushing drive");
Jeff Codye971aa12012-09-20 15:13:19 -04002063 goto error;
2064 }
2065
2066 if (drv->bdrv_reopen_prepare) {
2067 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2068 if (ret) {
2069 if (local_err != NULL) {
2070 error_propagate(errp, local_err);
2071 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04002072 error_setg(errp, "failed while preparing to reopen image '%s'",
2073 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04002074 }
2075 goto error;
2076 }
2077 } else {
2078 /* It is currently mandatory to have a bdrv_reopen_prepare()
2079 * handler for each supported drv. */
Alberto Garcia81e5f782015-04-08 12:29:19 +03002080 error_setg(errp, "Block format '%s' used by node '%s' "
2081 "does not support reopening files", drv->format_name,
2082 bdrv_get_device_or_node_name(reopen_state->bs));
Jeff Codye971aa12012-09-20 15:13:19 -04002083 ret = -1;
2084 goto error;
2085 }
2086
Kevin Wolf4d2cb092015-04-10 17:50:50 +02002087 /* Options that are not handled are only okay if they are unchanged
2088 * compared to the old state. It is expected that some options are only
2089 * used for the initial open, but not reopen (e.g. filename) */
2090 if (qdict_size(reopen_state->options)) {
2091 const QDictEntry *entry = qdict_first(reopen_state->options);
2092
2093 do {
2094 QString *new_obj = qobject_to_qstring(entry->value);
2095 const char *new = qstring_get_str(new_obj);
2096 const char *old = qdict_get_try_str(reopen_state->bs->options,
2097 entry->key);
2098
2099 if (!old || strcmp(new, old)) {
2100 error_setg(errp, "Cannot change the option '%s'", entry->key);
2101 ret = -EINVAL;
2102 goto error;
2103 }
2104 } while ((entry = qdict_next(reopen_state->options, entry)));
2105 }
2106
Jeff Codye971aa12012-09-20 15:13:19 -04002107 ret = 0;
2108
2109error:
Kevin Wolfccf9dc02015-05-08 17:24:56 +02002110 qemu_opts_del(opts);
Jeff Codye971aa12012-09-20 15:13:19 -04002111 return ret;
2112}
2113
2114/*
2115 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2116 * makes them final by swapping the staging BlockDriverState contents into
2117 * the active BlockDriverState contents.
2118 */
2119void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2120{
2121 BlockDriver *drv;
2122
2123 assert(reopen_state != NULL);
2124 drv = reopen_state->bs->drv;
2125 assert(drv != NULL);
2126
2127 /* If there are any driver level actions to take */
2128 if (drv->bdrv_reopen_commit) {
2129 drv->bdrv_reopen_commit(reopen_state);
2130 }
2131
2132 /* set BDS specific flags now */
Kevin Wolf145f5982015-05-08 16:15:03 +02002133 QDECREF(reopen_state->bs->explicit_options);
2134
2135 reopen_state->bs->explicit_options = reopen_state->explicit_options;
Jeff Codye971aa12012-09-20 15:13:19 -04002136 reopen_state->bs->open_flags = reopen_state->flags;
Jeff Codye971aa12012-09-20 15:13:19 -04002137 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01002138
Kevin Wolf3baca892014-07-16 17:48:16 +02002139 bdrv_refresh_limits(reopen_state->bs, NULL);
Jeff Codye971aa12012-09-20 15:13:19 -04002140}
2141
2142/*
2143 * Abort the reopen, and delete and free the staged changes in
2144 * reopen_state
2145 */
2146void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2147{
2148 BlockDriver *drv;
2149
2150 assert(reopen_state != NULL);
2151 drv = reopen_state->bs->drv;
2152 assert(drv != NULL);
2153
2154 if (drv->bdrv_reopen_abort) {
2155 drv->bdrv_reopen_abort(reopen_state);
2156 }
Kevin Wolf145f5982015-05-08 16:15:03 +02002157
2158 QDECREF(reopen_state->explicit_options);
Jeff Codye971aa12012-09-20 15:13:19 -04002159}
2160
2161
Max Reitz64dff522016-01-29 16:36:10 +01002162static void bdrv_close(BlockDriverState *bs)
bellardfc01f7e2003-06-30 10:03:06 +00002163{
Max Reitz33384422014-06-20 21:57:33 +02002164 BdrvAioNotifier *ban, *ban_next;
2165
Max Reitzca9bd242016-01-29 16:36:14 +01002166 assert(!bs->job);
Alberto Garcia99b7e772015-09-25 16:41:44 +03002167
Paolo Bonzinifc272912015-12-23 11:48:24 +01002168 bdrv_drained_begin(bs); /* complete I/O */
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02002169 bdrv_flush(bs);
Fam Zheng53ec73e2015-05-29 18:53:14 +08002170 bdrv_drain(bs); /* in case flush left pending I/O */
Paolo Bonzinifc272912015-12-23 11:48:24 +01002171
Max Reitzc5acdc92016-01-29 16:36:01 +01002172 bdrv_release_named_dirty_bitmaps(bs);
2173 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2174
Kevin Wolf5c8cab42016-02-24 15:13:35 +01002175 bdrv_parent_cb_change_media(bs, false);
Max Reitzb4d02822015-10-19 17:53:15 +02002176
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02002177 if (bs->drv) {
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002178 BdrvChild *child, *next;
2179
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02002180 bs->drv->bdrv_close(bs);
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02002181 bs->drv = NULL;
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02002182
Kevin Wolf5db15a52015-09-14 15:33:33 +02002183 bdrv_set_backing_hd(bs, NULL);
Kevin Wolf9a7dedb2015-06-16 10:58:20 +02002184
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02002185 if (bs->file != NULL) {
2186 bdrv_unref_child(bs, bs->file);
2187 bs->file = NULL;
2188 }
2189
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002190 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
Kevin Wolf33a60402015-06-15 13:51:04 +02002191 /* TODO Remove bdrv_unref() from drivers' close function and use
2192 * bdrv_unref_child() here */
Kevin Wolfbddcec32015-04-09 18:47:50 +02002193 if (child->bs->inherits_from == bs) {
2194 child->bs->inherits_from = NULL;
2195 }
Kevin Wolf33a60402015-06-15 13:51:04 +02002196 bdrv_detach_child(child);
Kevin Wolf6e93e7c2015-04-08 13:49:41 +02002197 }
2198
Anthony Liguori7267c092011-08-20 22:09:37 -05002199 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00002200 bs->opaque = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00002201 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02002202 bs->backing_file[0] = '\0';
2203 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02002204 bs->total_sectors = 0;
2205 bs->encrypted = 0;
2206 bs->valid_key = 0;
2207 bs->sg = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08002208 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01002209 QDECREF(bs->options);
Kevin Wolf145f5982015-05-08 16:15:03 +02002210 QDECREF(bs->explicit_options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01002211 bs->options = NULL;
Max Reitz91af7012014-07-18 20:24:56 +02002212 QDECREF(bs->full_open_options);
2213 bs->full_open_options = NULL;
bellardb3380822004-03-14 21:38:54 +00002214 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08002215
Max Reitz33384422014-06-20 21:57:33 +02002216 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2217 g_free(ban);
2218 }
2219 QLIST_INIT(&bs->aio_notifiers);
Paolo Bonzinifc272912015-12-23 11:48:24 +01002220 bdrv_drained_end(bs);
bellardb3380822004-03-14 21:38:54 +00002221}
2222
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09002223void bdrv_close_all(void)
2224{
2225 BlockDriverState *bs;
Max Reitzca9bd242016-01-29 16:36:14 +01002226 AioContext *aio_context;
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09002227
Max Reitzca9bd242016-01-29 16:36:14 +01002228 /* Drop references from requests still in flight, such as canceled block
2229 * jobs whose AIO context has not been polled yet */
2230 bdrv_drain_all();
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002231
Max Reitzca9bd242016-01-29 16:36:14 +01002232 blk_remove_all_bs();
2233 blockdev_close_all_bdrv_states();
2234
2235 /* Cancel all block jobs */
2236 while (!QTAILQ_EMPTY(&all_bdrv_states)) {
2237 QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) {
2238 aio_context = bdrv_get_aio_context(bs);
2239
2240 aio_context_acquire(aio_context);
2241 if (bs->job) {
2242 block_job_cancel_sync(bs->job);
2243 aio_context_release(aio_context);
2244 break;
2245 }
2246 aio_context_release(aio_context);
2247 }
2248
2249 /* All the remaining BlockDriverStates are referenced directly or
2250 * indirectly from block jobs, so there needs to be at least one BDS
2251 * directly used by a block job */
2252 assert(bs);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09002253 }
2254}
2255
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002256static void change_parent_backing_link(BlockDriverState *from,
2257 BlockDriverState *to)
2258{
2259 BdrvChild *c, *next;
2260
2261 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2262 assert(c->role != &child_backing);
2263 c->bs = to;
2264 QLIST_REMOVE(c, next_parent);
2265 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2266 bdrv_ref(to);
2267 bdrv_unref(from);
2268 }
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002269}
2270
Jeff Cody8802d1f2012-02-28 15:54:06 -05002271/*
2272 * Add new bs contents at the top of an image chain while the chain is
2273 * live, while keeping required fields on the top layer.
2274 *
2275 * This will modify the BlockDriverState fields, and swap contents
2276 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2277 *
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002278 * bs_new must not be attached to a BlockBackend.
Jeff Codyf6801b82012-03-27 16:30:19 -04002279 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05002280 * This function does not create any image files.
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002281 *
2282 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2283 * that's what the callers commonly need. bs_new will be referenced by the old
2284 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2285 * reference of its own, it must call bdrv_ref().
Jeff Cody8802d1f2012-02-28 15:54:06 -05002286 */
2287void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2288{
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002289 assert(!bdrv_requests_pending(bs_top));
2290 assert(!bdrv_requests_pending(bs_new));
Jeff Cody8802d1f2012-02-28 15:54:06 -05002291
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002292 bdrv_ref(bs_top);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002293
Kevin Wolf27ccdd52016-03-21 12:56:44 +01002294 change_parent_backing_link(bs_top, bs_new);
Kevin Wolfdd62f1c2015-06-18 14:09:57 +02002295 bdrv_set_backing_hd(bs_new, bs_top);
2296 bdrv_unref(bs_top);
2297
2298 /* bs_new is now referenced by its new parents, we don't need the
2299 * additional reference any more. */
2300 bdrv_unref(bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002301}
2302
Kevin Wolf3f09bfb2015-09-15 11:58:23 +02002303void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2304{
2305 assert(!bdrv_requests_pending(old));
2306 assert(!bdrv_requests_pending(new));
2307
2308 bdrv_ref(old);
2309
Kevin Wolf3f09bfb2015-09-15 11:58:23 +02002310 change_parent_backing_link(old, new);
2311
2312 /* Change backing files if a previously independent node is added to the
2313 * chain. For active commit, we replace top by its own (indirect) backing
2314 * file and don't do anything here so we don't build a loop. */
2315 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2316 bdrv_set_backing_hd(new, backing_bs(old));
2317 bdrv_set_backing_hd(old, NULL);
2318 }
2319
2320 bdrv_unref(old);
2321}
2322
Fam Zheng4f6fd342013-08-23 09:14:47 +08002323static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00002324{
Paolo Bonzini3e914652012-03-30 13:17:11 +02002325 assert(!bs->job);
Fam Zheng3718d8a2014-05-23 21:29:43 +08002326 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08002327 assert(!bs->refcnt);
Markus Armbruster18846de2010-06-29 16:58:30 +02002328
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02002329 bdrv_close(bs);
2330
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002331 /* remove from list, if necessary */
Kevin Wolf63eaaae2016-03-18 10:46:57 +01002332 if (bs->node_name[0] != '\0') {
2333 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2334 }
Max Reitz2c1d04e2016-01-29 16:36:11 +01002335 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2336
Anthony Liguori7267c092011-08-20 22:09:37 -05002337 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00002338}
2339
aliguorie97fc192009-04-21 23:11:50 +00002340/*
2341 * Run consistency checks on an image
2342 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002343 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002344 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002345 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002346 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002347int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002348{
Max Reitz908bcd52014-08-07 22:47:55 +02002349 if (bs->drv == NULL) {
2350 return -ENOMEDIUM;
2351 }
aliguorie97fc192009-04-21 23:11:50 +00002352 if (bs->drv->bdrv_check == NULL) {
2353 return -ENOTSUP;
2354 }
2355
Kevin Wolfe076f332010-06-29 11:43:13 +02002356 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002357 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002358}
2359
Kevin Wolf8a426612010-07-16 17:17:01 +02002360#define COMMIT_BUF_SECTORS 2048
2361
bellard33e39632003-07-06 17:15:21 +00002362/* commit COW file into the raw image */
2363int bdrv_commit(BlockDriverState *bs)
2364{
bellard19cb3732006-08-19 11:45:59 +00002365 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002366 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002367 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002368 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002369 uint8_t *buf = NULL;
bellard33e39632003-07-06 17:15:21 +00002370
bellard19cb3732006-08-19 11:45:59 +00002371 if (!drv)
2372 return -ENOMEDIUM;
Liu Yuan6bb45152014-09-01 13:35:21 +08002373
Kevin Wolf760e0062015-06-17 14:55:21 +02002374 if (!bs->backing) {
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002375 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002376 }
2377
Fam Zhengbb000212014-09-11 13:14:00 +08002378 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
Kevin Wolf760e0062015-06-17 14:55:21 +02002379 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002380 return -EBUSY;
2381 }
2382
Kevin Wolf760e0062015-06-17 14:55:21 +02002383 ro = bs->backing->bs->read_only;
2384 open_flags = bs->backing->bs->open_flags;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002385
2386 if (ro) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002387 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002388 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002389 }
bellard33e39632003-07-06 17:15:21 +00002390 }
bellardea2384d2004-08-01 21:59:26 +00002391
Jeff Cody72706ea2014-01-24 09:02:35 -05002392 length = bdrv_getlength(bs);
2393 if (length < 0) {
2394 ret = length;
2395 goto ro_cleanup;
2396 }
2397
Kevin Wolf760e0062015-06-17 14:55:21 +02002398 backing_length = bdrv_getlength(bs->backing->bs);
Jeff Cody72706ea2014-01-24 09:02:35 -05002399 if (backing_length < 0) {
2400 ret = backing_length;
2401 goto ro_cleanup;
2402 }
2403
2404 /* If our top snapshot is larger than the backing file image,
2405 * grow the backing file image if possible. If not possible,
2406 * we must return an error */
2407 if (length > backing_length) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002408 ret = bdrv_truncate(bs->backing->bs, length);
Jeff Cody72706ea2014-01-24 09:02:35 -05002409 if (ret < 0) {
2410 goto ro_cleanup;
2411 }
2412 }
2413
2414 total_sectors = length >> BDRV_SECTOR_BITS;
Kevin Wolf857d4f42014-05-20 13:16:51 +02002415
2416 /* qemu_try_blockalign() for bs will choose an alignment that works for
Kevin Wolf760e0062015-06-17 14:55:21 +02002417 * bs->backing->bs as well, so no need to compare the alignment manually. */
Kevin Wolf857d4f42014-05-20 13:16:51 +02002418 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2419 if (buf == NULL) {
2420 ret = -ENOMEM;
2421 goto ro_cleanup;
2422 }
bellardea2384d2004-08-01 21:59:26 +00002423
Kevin Wolf8a426612010-07-16 17:17:01 +02002424 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002425 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2426 if (ret < 0) {
2427 goto ro_cleanup;
2428 }
2429 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002430 ret = bdrv_read(bs, sector, buf, n);
2431 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002432 goto ro_cleanup;
2433 }
2434
Kevin Wolf760e0062015-06-17 14:55:21 +02002435 ret = bdrv_write(bs->backing->bs, sector, buf, n);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002436 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002437 goto ro_cleanup;
2438 }
bellardea2384d2004-08-01 21:59:26 +00002439 }
2440 }
bellard95389c82005-12-18 18:28:15 +00002441
Christoph Hellwig1d449522010-01-17 12:32:30 +01002442 if (drv->bdrv_make_empty) {
2443 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002444 if (ret < 0) {
2445 goto ro_cleanup;
2446 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002447 bdrv_flush(bs);
2448 }
bellard95389c82005-12-18 18:28:15 +00002449
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002450 /*
2451 * Make sure all data we wrote to the backing device is actually
2452 * stable on disk.
2453 */
Kevin Wolf760e0062015-06-17 14:55:21 +02002454 if (bs->backing) {
2455 bdrv_flush(bs->backing->bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002456 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002457
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002458 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002459ro_cleanup:
Kevin Wolf857d4f42014-05-20 13:16:51 +02002460 qemu_vfree(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002461
2462 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002463 /* ignoring error return here */
Kevin Wolf760e0062015-06-17 14:55:21 +02002464 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002465 }
2466
Christoph Hellwig1d449522010-01-17 12:32:30 +01002467 return ret;
bellard33e39632003-07-06 17:15:21 +00002468}
2469
Kevin Wolf756e6732010-01-12 12:55:17 +01002470/*
2471 * Return values:
2472 * 0 - success
2473 * -EINVAL - backing format specified, but no file
2474 * -ENOSPC - can't update the backing file because no space is left in the
2475 * image file header
2476 * -ENOTSUP - format driver doesn't support changing the backing file
2477 */
2478int bdrv_change_backing_file(BlockDriverState *bs,
2479 const char *backing_file, const char *backing_fmt)
2480{
2481 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002482 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002483
Paolo Bonzini5f377792012-04-12 14:01:01 +02002484 /* Backing file format doesn't make sense without a backing file */
2485 if (backing_fmt && !backing_file) {
2486 return -EINVAL;
2487 }
2488
Kevin Wolf756e6732010-01-12 12:55:17 +01002489 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002490 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002491 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002492 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002493 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002494
2495 if (ret == 0) {
2496 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2497 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2498 }
2499 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002500}
2501
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002502/*
2503 * Finds the image layer in the chain that has 'bs' as its backing file.
2504 *
2505 * active is the current topmost image.
2506 *
2507 * Returns NULL if bs is not found in active's image chain,
2508 * or if active == bs.
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002509 *
2510 * Returns the bottommost base image if bs == NULL.
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002511 */
2512BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2513 BlockDriverState *bs)
2514{
Kevin Wolf760e0062015-06-17 14:55:21 +02002515 while (active && bs != backing_bs(active)) {
2516 active = backing_bs(active);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002517 }
2518
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002519 return active;
2520}
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002521
Jeff Cody4caf0fc2014-06-25 15:35:26 -04002522/* Given a BDS, searches for the base layer. */
2523BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2524{
2525 return bdrv_find_overlay(bs, NULL);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002526}
2527
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002528/*
2529 * Drops images above 'base' up to and including 'top', and sets the image
2530 * above 'top' to have base as its backing file.
2531 *
2532 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2533 * information in 'bs' can be properly updated.
2534 *
2535 * E.g., this will convert the following chain:
2536 * bottom <- base <- intermediate <- top <- active
2537 *
2538 * to
2539 *
2540 * bottom <- base <- active
2541 *
2542 * It is allowed for bottom==base, in which case it converts:
2543 *
2544 * base <- intermediate <- top <- active
2545 *
2546 * to
2547 *
2548 * base <- active
2549 *
Jeff Cody54e26902014-06-25 15:40:10 -04002550 * If backing_file_str is non-NULL, it will be used when modifying top's
2551 * overlay image metadata.
2552 *
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002553 * Error conditions:
2554 * if active == top, that is considered an error
2555 *
2556 */
2557int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
Jeff Cody54e26902014-06-25 15:40:10 -04002558 BlockDriverState *base, const char *backing_file_str)
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002559{
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002560 BlockDriverState *new_top_bs = NULL;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002561 int ret = -EIO;
2562
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002563 if (!top->drv || !base->drv) {
2564 goto exit;
2565 }
2566
2567 new_top_bs = bdrv_find_overlay(active, top);
2568
2569 if (new_top_bs == NULL) {
2570 /* we could not find the image above 'top', this is an error */
2571 goto exit;
2572 }
2573
Kevin Wolf760e0062015-06-17 14:55:21 +02002574 /* special case of new_top_bs->backing->bs already pointing to base - nothing
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002575 * to do, no intermediate images */
Kevin Wolf760e0062015-06-17 14:55:21 +02002576 if (backing_bs(new_top_bs) == base) {
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002577 ret = 0;
2578 goto exit;
2579 }
2580
Kevin Wolf5db15a52015-09-14 15:33:33 +02002581 /* Make sure that base is in the backing chain of top */
2582 if (!bdrv_chain_contains(top, base)) {
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002583 goto exit;
2584 }
2585
2586 /* success - we can delete the intermediate states, and link top->base */
Kevin Wolf5db15a52015-09-14 15:33:33 +02002587 backing_file_str = backing_file_str ? backing_file_str : base->filename;
Jeff Cody54e26902014-06-25 15:40:10 -04002588 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
Kevin Wolf5db15a52015-09-14 15:33:33 +02002589 base->drv ? base->drv->format_name : "");
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002590 if (ret) {
2591 goto exit;
2592 }
Kevin Wolf5db15a52015-09-14 15:33:33 +02002593 bdrv_set_backing_hd(new_top_bs, base);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002594
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002595 ret = 0;
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002596exit:
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002597 return ret;
2598}
2599
bellard83f64092006-08-01 16:21:11 +00002600/**
bellard83f64092006-08-01 16:21:11 +00002601 * Truncate file to 'offset' bytes (needed only for file protocols)
2602 */
2603int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2604{
2605 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002606 int ret;
bellard83f64092006-08-01 16:21:11 +00002607 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002608 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00002609 if (!drv->bdrv_truncate)
2610 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02002611 if (bs->read_only)
2612 return -EACCES;
Jeff Cody9c75e162014-06-25 16:55:30 -04002613
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002614 ret = drv->bdrv_truncate(bs, offset);
2615 if (ret == 0) {
2616 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
John Snowce1ffea2015-04-17 19:50:03 -04002617 bdrv_dirty_bitmap_truncate(bs);
Kevin Wolf5c8cab42016-02-24 15:13:35 +01002618 bdrv_parent_cb_resize(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002619 }
2620 return ret;
bellard83f64092006-08-01 16:21:11 +00002621}
2622
2623/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002624 * Length of a allocated file in bytes. Sparse files are counted by actual
2625 * allocated space. Return < 0 if error or unknown.
2626 */
2627int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2628{
2629 BlockDriver *drv = bs->drv;
2630 if (!drv) {
2631 return -ENOMEDIUM;
2632 }
2633 if (drv->bdrv_get_allocated_file_size) {
2634 return drv->bdrv_get_allocated_file_size(bs);
2635 }
2636 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02002637 return bdrv_get_allocated_file_size(bs->file->bs);
Fam Zheng4a1d5e12011-07-12 19:56:39 +08002638 }
2639 return -ENOTSUP;
2640}
2641
2642/**
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002643 * Return number of sectors on success, -errno on error.
bellard83f64092006-08-01 16:21:11 +00002644 */
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002645int64_t bdrv_nb_sectors(BlockDriverState *bs)
bellard83f64092006-08-01 16:21:11 +00002646{
2647 BlockDriver *drv = bs->drv;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002648
bellard83f64092006-08-01 16:21:11 +00002649 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00002650 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01002651
Kevin Wolfb94a2612013-10-29 12:18:58 +01002652 if (drv->has_variable_length) {
2653 int ret = refresh_total_sectors(bs, bs->total_sectors);
2654 if (ret < 0) {
2655 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01002656 }
bellard83f64092006-08-01 16:21:11 +00002657 }
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002658 return bs->total_sectors;
2659}
2660
2661/**
2662 * Return length in bytes on success, -errno on error.
2663 * The length is always a multiple of BDRV_SECTOR_SIZE.
2664 */
2665int64_t bdrv_getlength(BlockDriverState *bs)
2666{
2667 int64_t ret = bdrv_nb_sectors(bs);
2668
Fam Zheng4a9c9ea2015-05-15 16:36:05 +08002669 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002670 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00002671}
2672
bellard19cb3732006-08-19 11:45:59 +00002673/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00002674void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00002675{
Markus Armbruster65a9bb22014-06-26 13:23:17 +02002676 int64_t nb_sectors = bdrv_nb_sectors(bs);
2677
2678 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
bellardfc01f7e2003-06-30 10:03:06 +00002679}
bellardcf989512004-02-16 21:56:36 +00002680
bellardb3380822004-03-14 21:38:54 +00002681int bdrv_is_read_only(BlockDriverState *bs)
2682{
2683 return bs->read_only;
2684}
2685
ths985a03b2007-12-24 16:10:43 +00002686int bdrv_is_sg(BlockDriverState *bs)
2687{
2688 return bs->sg;
2689}
2690
bellardea2384d2004-08-01 21:59:26 +00002691int bdrv_is_encrypted(BlockDriverState *bs)
2692{
Kevin Wolf760e0062015-06-17 14:55:21 +02002693 if (bs->backing && bs->backing->bs->encrypted) {
bellardea2384d2004-08-01 21:59:26 +00002694 return 1;
Kevin Wolf760e0062015-06-17 14:55:21 +02002695 }
bellardea2384d2004-08-01 21:59:26 +00002696 return bs->encrypted;
2697}
2698
aliguoric0f4ce72009-03-05 23:01:01 +00002699int bdrv_key_required(BlockDriverState *bs)
2700{
Kevin Wolf760e0062015-06-17 14:55:21 +02002701 BdrvChild *backing = bs->backing;
aliguoric0f4ce72009-03-05 23:01:01 +00002702
Kevin Wolf760e0062015-06-17 14:55:21 +02002703 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
aliguoric0f4ce72009-03-05 23:01:01 +00002704 return 1;
Kevin Wolf760e0062015-06-17 14:55:21 +02002705 }
aliguoric0f4ce72009-03-05 23:01:01 +00002706 return (bs->encrypted && !bs->valid_key);
2707}
2708
bellardea2384d2004-08-01 21:59:26 +00002709int bdrv_set_key(BlockDriverState *bs, const char *key)
2710{
2711 int ret;
Kevin Wolf760e0062015-06-17 14:55:21 +02002712 if (bs->backing && bs->backing->bs->encrypted) {
2713 ret = bdrv_set_key(bs->backing->bs, key);
bellardea2384d2004-08-01 21:59:26 +00002714 if (ret < 0)
2715 return ret;
2716 if (!bs->encrypted)
2717 return 0;
2718 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02002719 if (!bs->encrypted) {
2720 return -EINVAL;
2721 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2722 return -ENOMEDIUM;
2723 }
aliguoric0f4ce72009-03-05 23:01:01 +00002724 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00002725 if (ret < 0) {
2726 bs->valid_key = 0;
2727 } else if (!bs->valid_key) {
Kevin Wolf5c8cab42016-02-24 15:13:35 +01002728 /* call the change callback now, we skipped it on open */
aliguoribb5fc202009-03-05 23:01:15 +00002729 bs->valid_key = 1;
Kevin Wolf5c8cab42016-02-24 15:13:35 +01002730 bdrv_parent_cb_change_media(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00002731 }
aliguoric0f4ce72009-03-05 23:01:01 +00002732 return ret;
bellardea2384d2004-08-01 21:59:26 +00002733}
2734
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002735/*
2736 * Provide an encryption key for @bs.
2737 * If @key is non-null:
2738 * If @bs is not encrypted, fail.
2739 * Else if the key is invalid, fail.
2740 * Else set @bs's key to @key, replacing the existing key, if any.
2741 * If @key is null:
2742 * If @bs is encrypted and still lacks a key, fail.
2743 * Else do nothing.
2744 * On failure, store an error object through @errp if non-null.
2745 */
2746void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2747{
2748 if (key) {
2749 if (!bdrv_is_encrypted(bs)) {
Alberto Garcia81e5f782015-04-08 12:29:19 +03002750 error_setg(errp, "Node '%s' is not encrypted",
2751 bdrv_get_device_or_node_name(bs));
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002752 } else if (bdrv_set_key(bs, key) < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002753 error_setg(errp, QERR_INVALID_PASSWORD);
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002754 }
2755 } else {
2756 if (bdrv_key_required(bs)) {
Markus Armbrusterb1ca6392015-01-29 10:37:01 +01002757 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2758 "'%s' (%s) is encrypted",
Alberto Garcia81e5f782015-04-08 12:29:19 +03002759 bdrv_get_device_or_node_name(bs),
Markus Armbruster4d2855a2015-01-29 10:37:00 +01002760 bdrv_get_encrypted_filename(bs));
2761 }
2762 }
2763}
2764
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002765const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00002766{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02002767 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00002768}
2769
Stefan Hajnocziada42402014-08-27 12:08:55 +01002770static int qsort_strcmp(const void *a, const void *b)
2771{
2772 return strcmp(a, b);
2773}
2774
ths5fafdf22007-09-16 21:08:06 +00002775void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00002776 void *opaque)
2777{
2778 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04002779 int count = 0;
Stefan Hajnocziada42402014-08-27 12:08:55 +01002780 int i;
Jeff Codye855e4f2014-04-28 18:29:54 -04002781 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00002782
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01002783 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04002784 if (drv->format_name) {
2785 bool found = false;
2786 int i = count;
2787 while (formats && i && !found) {
2788 found = !strcmp(formats[--i], drv->format_name);
2789 }
2790
2791 if (!found) {
Markus Armbruster5839e532014-08-19 10:31:08 +02002792 formats = g_renew(const char *, formats, count + 1);
Jeff Codye855e4f2014-04-28 18:29:54 -04002793 formats[count++] = drv->format_name;
Jeff Codye855e4f2014-04-28 18:29:54 -04002794 }
2795 }
bellardea2384d2004-08-01 21:59:26 +00002796 }
Stefan Hajnocziada42402014-08-27 12:08:55 +01002797
2798 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2799
2800 for (i = 0; i < count; i++) {
2801 it(opaque, formats[i]);
2802 }
2803
Jeff Codye855e4f2014-04-28 18:29:54 -04002804 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00002805}
2806
Benoît Canetdc364f42014-01-23 21:31:32 +01002807/* This function is to find a node in the bs graph */
2808BlockDriverState *bdrv_find_node(const char *node_name)
2809{
2810 BlockDriverState *bs;
2811
2812 assert(node_name);
2813
2814 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2815 if (!strcmp(node_name, bs->node_name)) {
2816 return bs;
2817 }
2818 }
2819 return NULL;
2820}
2821
Benoît Canetc13163f2014-01-23 21:31:34 +01002822/* Put this QMP function here so it can access the static graph_bdrv_states. */
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002823BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
Benoît Canetc13163f2014-01-23 21:31:34 +01002824{
2825 BlockDeviceInfoList *list, *entry;
2826 BlockDriverState *bs;
2827
2828 list = NULL;
2829 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
Kevin Wolfc83f9fb2016-03-03 11:37:48 +01002830 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002831 if (!info) {
2832 qapi_free_BlockDeviceInfoList(list);
2833 return NULL;
2834 }
Benoît Canetc13163f2014-01-23 21:31:34 +01002835 entry = g_malloc0(sizeof(*entry));
Alberto Garciad5a8ee62015-04-17 14:52:43 +03002836 entry->value = info;
Benoît Canetc13163f2014-01-23 21:31:34 +01002837 entry->next = list;
2838 list = entry;
2839 }
2840
2841 return list;
2842}
2843
Benoît Canet12d3ba82014-01-23 21:31:35 +01002844BlockDriverState *bdrv_lookup_bs(const char *device,
2845 const char *node_name,
2846 Error **errp)
2847{
Markus Armbruster7f06d472014-10-07 13:59:12 +02002848 BlockBackend *blk;
2849 BlockDriverState *bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002850
Benoît Canet12d3ba82014-01-23 21:31:35 +01002851 if (device) {
Markus Armbruster7f06d472014-10-07 13:59:12 +02002852 blk = blk_by_name(device);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002853
Markus Armbruster7f06d472014-10-07 13:59:12 +02002854 if (blk) {
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02002855 bs = blk_bs(blk);
2856 if (!bs) {
Max Reitz5433c242015-10-19 17:53:29 +02002857 error_setg(errp, "Device '%s' has no medium", device);
Max Reitz5433c242015-10-19 17:53:29 +02002858 }
2859
Alberto Garcia9f4ed6f2015-10-26 16:46:49 +02002860 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002861 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01002862 }
2863
Benoît Canetdd67fa52014-02-12 17:15:06 +01002864 if (node_name) {
2865 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01002866
Benoît Canetdd67fa52014-02-12 17:15:06 +01002867 if (bs) {
2868 return bs;
2869 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01002870 }
2871
Benoît Canetdd67fa52014-02-12 17:15:06 +01002872 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2873 device ? device : "",
2874 node_name ? node_name : "");
2875 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01002876}
2877
Jeff Cody5a6684d2014-06-25 15:40:09 -04002878/* If 'base' is in the same chain as 'top', return true. Otherwise,
2879 * return false. If either argument is NULL, return false. */
2880bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2881{
2882 while (top && top != base) {
Kevin Wolf760e0062015-06-17 14:55:21 +02002883 top = backing_bs(top);
Jeff Cody5a6684d2014-06-25 15:40:09 -04002884 }
2885
2886 return top != NULL;
2887}
2888
Fam Zheng04df7652014-10-31 11:32:54 +08002889BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2890{
2891 if (!bs) {
2892 return QTAILQ_FIRST(&graph_bdrv_states);
2893 }
2894 return QTAILQ_NEXT(bs, node_list);
2895}
2896
Fam Zheng20a9e772014-10-31 11:32:55 +08002897const char *bdrv_get_node_name(const BlockDriverState *bs)
2898{
2899 return bs->node_name;
2900}
2901
Kevin Wolf1f0c4612016-03-22 18:38:44 +01002902const char *bdrv_get_parent_name(const BlockDriverState *bs)
Kevin Wolf4c265bf2016-02-26 10:22:16 +01002903{
2904 BdrvChild *c;
2905 const char *name;
2906
2907 /* If multiple parents have a name, just pick the first one. */
2908 QLIST_FOREACH(c, &bs->parents, next_parent) {
2909 if (c->role->get_name) {
2910 name = c->role->get_name(c);
2911 if (name && *name) {
2912 return name;
2913 }
2914 }
2915 }
2916
2917 return NULL;
2918}
2919
Markus Armbruster7f06d472014-10-07 13:59:12 +02002920/* TODO check what callers really want: bs->node_name or blk_name() */
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02002921const char *bdrv_get_device_name(const BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00002922{
Kevin Wolf4c265bf2016-02-26 10:22:16 +01002923 return bdrv_get_parent_name(bs) ?: "";
bellardea2384d2004-08-01 21:59:26 +00002924}
2925
Alberto Garcia9b2aa842015-04-08 12:29:18 +03002926/* This can be used to identify nodes that might not have a device
2927 * name associated. Since node and device names live in the same
2928 * namespace, the result is unambiguous. The exception is if both are
2929 * absent, then this returns an empty (non-null) string. */
2930const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2931{
Kevin Wolf4c265bf2016-02-26 10:22:16 +01002932 return bdrv_get_parent_name(bs) ?: bs->node_name;
Alberto Garcia9b2aa842015-04-08 12:29:18 +03002933}
2934
Markus Armbrusterc8433282012-06-05 16:49:24 +02002935int bdrv_get_flags(BlockDriverState *bs)
2936{
2937 return bs->open_flags;
2938}
2939
Peter Lieven3ac21622013-06-28 12:47:42 +02002940int bdrv_has_zero_init_1(BlockDriverState *bs)
2941{
2942 return 1;
2943}
2944
Kevin Wolff2feebb2010-04-14 17:30:35 +02002945int bdrv_has_zero_init(BlockDriverState *bs)
2946{
2947 assert(bs->drv);
2948
Paolo Bonzini11212d82013-09-04 19:00:27 +02002949 /* If BS is a copy on write image, it is initialized to
2950 the contents of the base image, which may not be zeroes. */
Kevin Wolf760e0062015-06-17 14:55:21 +02002951 if (bs->backing) {
Paolo Bonzini11212d82013-09-04 19:00:27 +02002952 return 0;
2953 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02002954 if (bs->drv->bdrv_has_zero_init) {
2955 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02002956 }
2957
Peter Lieven3ac21622013-06-28 12:47:42 +02002958 /* safe default */
2959 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02002960}
2961
Peter Lieven4ce78692013-10-24 12:06:54 +02002962bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2963{
2964 BlockDriverInfo bdi;
2965
Kevin Wolf760e0062015-06-17 14:55:21 +02002966 if (bs->backing) {
Peter Lieven4ce78692013-10-24 12:06:54 +02002967 return false;
2968 }
2969
2970 if (bdrv_get_info(bs, &bdi) == 0) {
2971 return bdi.unallocated_blocks_are_zero;
2972 }
2973
2974 return false;
2975}
2976
2977bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2978{
2979 BlockDriverInfo bdi;
2980
Kevin Wolf760e0062015-06-17 14:55:21 +02002981 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
Peter Lieven4ce78692013-10-24 12:06:54 +02002982 return false;
2983 }
2984
2985 if (bdrv_get_info(bs, &bdi) == 0) {
2986 return bdi.can_write_zeroes_with_unmap;
2987 }
2988
2989 return false;
2990}
2991
aliguori045df332009-03-05 23:00:48 +00002992const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2993{
Kevin Wolf760e0062015-06-17 14:55:21 +02002994 if (bs->backing && bs->backing->bs->encrypted)
aliguori045df332009-03-05 23:00:48 +00002995 return bs->backing_file;
2996 else if (bs->encrypted)
2997 return bs->filename;
2998 else
2999 return NULL;
3000}
3001
ths5fafdf22007-09-16 21:08:06 +00003002void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00003003 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00003004{
Kevin Wolf3574c602011-10-26 11:02:11 +02003005 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00003006}
3007
bellardfaea38e2006-08-05 21:31:00 +00003008int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3009{
3010 BlockDriver *drv = bs->drv;
3011 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003012 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00003013 if (!drv->bdrv_get_info)
3014 return -ENOTSUP;
3015 memset(bdi, 0, sizeof(*bdi));
3016 return drv->bdrv_get_info(bs, bdi);
3017}
3018
Max Reitzeae041f2013-10-09 10:46:16 +02003019ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3020{
3021 BlockDriver *drv = bs->drv;
3022 if (drv && drv->bdrv_get_specific_info) {
3023 return drv->bdrv_get_specific_info(bs);
3024 }
3025 return NULL;
3026}
3027
Eric Blakea31939e2015-11-18 01:52:54 -07003028void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003029{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003030 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003031 return;
3032 }
3033
Kevin Wolfbf736fe2013-06-05 15:17:55 +02003034 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01003035}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003036
Kevin Wolf41c695c2012-12-06 14:32:58 +01003037int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3038 const char *tag)
3039{
3040 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003041 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01003042 }
3043
3044 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3045 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3046 }
3047
3048 return -ENOTSUP;
3049}
3050
Fam Zheng4cc70e92013-11-20 10:01:54 +08003051int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3052{
3053 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003054 bs = bs->file ? bs->file->bs : NULL;
Fam Zheng4cc70e92013-11-20 10:01:54 +08003055 }
3056
3057 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3058 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3059 }
3060
3061 return -ENOTSUP;
3062}
3063
Kevin Wolf41c695c2012-12-06 14:32:58 +01003064int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3065{
Max Reitz938789e2014-03-10 23:44:08 +01003066 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003067 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01003068 }
3069
3070 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3071 return bs->drv->bdrv_debug_resume(bs, tag);
3072 }
3073
3074 return -ENOTSUP;
3075}
3076
3077bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3078{
3079 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003080 bs = bs->file ? bs->file->bs : NULL;
Kevin Wolf41c695c2012-12-06 14:32:58 +01003081 }
3082
3083 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3084 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3085 }
3086
3087 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01003088}
3089
Blue Swirl199630b2010-07-25 20:49:34 +00003090int bdrv_is_snapshot(BlockDriverState *bs)
3091{
3092 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3093}
3094
Jeff Codyb1b1d782012-10-16 15:49:09 -04003095/* backing_file can either be relative, or absolute, or a protocol. If it is
3096 * relative, it must be relative to the chain. So, passing in bs->filename
3097 * from a BDS as backing_file should not be done, as that may be relative to
3098 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003099BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3100 const char *backing_file)
3101{
Jeff Codyb1b1d782012-10-16 15:49:09 -04003102 char *filename_full = NULL;
3103 char *backing_file_full = NULL;
3104 char *filename_tmp = NULL;
3105 int is_protocol = 0;
3106 BlockDriverState *curr_bs = NULL;
3107 BlockDriverState *retval = NULL;
3108
3109 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003110 return NULL;
3111 }
3112
Jeff Codyb1b1d782012-10-16 15:49:09 -04003113 filename_full = g_malloc(PATH_MAX);
3114 backing_file_full = g_malloc(PATH_MAX);
3115 filename_tmp = g_malloc(PATH_MAX);
3116
3117 is_protocol = path_has_protocol(backing_file);
3118
Kevin Wolf760e0062015-06-17 14:55:21 +02003119 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003120
3121 /* If either of the filename paths is actually a protocol, then
3122 * compare unmodified paths; otherwise make paths relative */
3123 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3124 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
Kevin Wolf760e0062015-06-17 14:55:21 +02003125 retval = curr_bs->backing->bs;
Jeff Codyb1b1d782012-10-16 15:49:09 -04003126 break;
3127 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003128 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04003129 /* If not an absolute filename path, make it relative to the current
3130 * image's filename path */
3131 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3132 backing_file);
3133
3134 /* We are going to compare absolute pathnames */
3135 if (!realpath(filename_tmp, filename_full)) {
3136 continue;
3137 }
3138
3139 /* We need to make sure the backing filename we are comparing against
3140 * is relative to the current image filename (or absolute) */
3141 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3142 curr_bs->backing_file);
3143
3144 if (!realpath(filename_tmp, backing_file_full)) {
3145 continue;
3146 }
3147
3148 if (strcmp(backing_file_full, filename_full) == 0) {
Kevin Wolf760e0062015-06-17 14:55:21 +02003149 retval = curr_bs->backing->bs;
Jeff Codyb1b1d782012-10-16 15:49:09 -04003150 break;
3151 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003152 }
3153 }
3154
Jeff Codyb1b1d782012-10-16 15:49:09 -04003155 g_free(filename_full);
3156 g_free(backing_file_full);
3157 g_free(filename_tmp);
3158 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00003159}
3160
Benoît Canetf198fd12012-08-02 10:22:47 +02003161int bdrv_get_backing_file_depth(BlockDriverState *bs)
3162{
3163 if (!bs->drv) {
3164 return 0;
3165 }
3166
Kevin Wolf760e0062015-06-17 14:55:21 +02003167 if (!bs->backing) {
Benoît Canetf198fd12012-08-02 10:22:47 +02003168 return 0;
3169 }
3170
Kevin Wolf760e0062015-06-17 14:55:21 +02003171 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
Benoît Canetf198fd12012-08-02 10:22:47 +02003172}
3173
bellardea2384d2004-08-01 21:59:26 +00003174void bdrv_init(void)
3175{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05003176 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00003177}
pbrookce1a14d2006-08-07 02:38:06 +00003178
Markus Armbrustereb852012009-10-27 18:41:44 +01003179void bdrv_init_with_whitelist(void)
3180{
3181 use_bdrv_whitelist = 1;
3182 bdrv_init();
3183}
3184
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003185void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06003186{
Fam Zheng0d1c5c92016-05-11 10:45:33 +08003187 BdrvChild *child;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003188 Error *local_err = NULL;
3189 int ret;
3190
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003191 if (!bs->drv) {
3192 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06003193 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003194
Kevin Wolf04c01a52016-01-13 15:56:06 +01003195 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
Alexey Kardashevskiy7ea2d262014-10-09 13:50:46 +11003196 return;
3197 }
Kevin Wolf04c01a52016-01-13 15:56:06 +01003198 bs->open_flags &= ~BDRV_O_INACTIVE;
Alexey Kardashevskiy7ea2d262014-10-09 13:50:46 +11003199
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003200 if (bs->drv->bdrv_invalidate_cache) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003201 bs->drv->bdrv_invalidate_cache(bs, &local_err);
Fam Zheng0d1c5c92016-05-11 10:45:33 +08003202 if (local_err) {
3203 bs->open_flags |= BDRV_O_INACTIVE;
3204 error_propagate(errp, local_err);
3205 return;
3206 }
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003207 }
Fam Zheng0d1c5c92016-05-11 10:45:33 +08003208
3209 QLIST_FOREACH(child, &bs->children, next) {
3210 bdrv_invalidate_cache(child->bs, &local_err);
3211 if (local_err) {
3212 bs->open_flags |= BDRV_O_INACTIVE;
3213 error_propagate(errp, local_err);
3214 return;
3215 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01003216 }
3217
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003218 ret = refresh_total_sectors(bs, bs->total_sectors);
3219 if (ret < 0) {
Kevin Wolf04c01a52016-01-13 15:56:06 +01003220 bs->open_flags |= BDRV_O_INACTIVE;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003221 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3222 return;
3223 }
Anthony Liguori0f154232011-11-14 15:09:45 -06003224}
3225
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003226void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06003227{
Kevin Wolf7c8eece2016-03-22 18:58:50 +01003228 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003229 Error *local_err = NULL;
Kevin Wolf88be7b42016-05-20 18:49:07 +02003230 BdrvNextIterator it;
Anthony Liguori0f154232011-11-14 15:09:45 -06003231
Kevin Wolf88be7b42016-05-20 18:49:07 +02003232 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003233 AioContext *aio_context = bdrv_get_aio_context(bs);
3234
3235 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003236 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003237 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01003238 if (local_err) {
3239 error_propagate(errp, local_err);
3240 return;
3241 }
Anthony Liguori0f154232011-11-14 15:09:45 -06003242 }
3243}
3244
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003245static int bdrv_inactivate_recurse(BlockDriverState *bs,
3246 bool setting_flag)
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003247{
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003248 BdrvChild *child;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003249 int ret;
3250
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003251 if (!setting_flag && bs->drv->bdrv_inactivate) {
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003252 ret = bs->drv->bdrv_inactivate(bs);
3253 if (ret < 0) {
3254 return ret;
3255 }
3256 }
3257
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003258 QLIST_FOREACH(child, &bs->children, next) {
3259 ret = bdrv_inactivate_recurse(child->bs, setting_flag);
3260 if (ret < 0) {
3261 return ret;
3262 }
3263 }
3264
3265 if (setting_flag) {
3266 bs->open_flags |= BDRV_O_INACTIVE;
3267 }
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003268 return 0;
3269}
3270
3271int bdrv_inactivate_all(void)
3272{
Max Reitz79720af2016-03-16 19:54:44 +01003273 BlockDriverState *bs = NULL;
Kevin Wolf88be7b42016-05-20 18:49:07 +02003274 BdrvNextIterator it;
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003275 int ret = 0;
3276 int pass;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003277
Kevin Wolf88be7b42016-05-20 18:49:07 +02003278 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003279 aio_context_acquire(bdrv_get_aio_context(bs));
3280 }
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003281
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003282 /* We do two passes of inactivation. The first pass calls to drivers'
3283 * .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
3284 * the second pass sets the BDRV_O_INACTIVE flag so that no further write
3285 * is allowed. */
3286 for (pass = 0; pass < 2; pass++) {
Kevin Wolf88be7b42016-05-20 18:49:07 +02003287 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003288 ret = bdrv_inactivate_recurse(bs, pass);
3289 if (ret < 0) {
3290 goto out;
3291 }
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003292 }
3293 }
3294
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003295out:
Kevin Wolf88be7b42016-05-20 18:49:07 +02003296 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Fam Zhengaad0b7a2016-05-11 10:45:35 +08003297 aio_context_release(bdrv_get_aio_context(bs));
3298 }
3299
3300 return ret;
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01003301}
3302
Kevin Wolff9f05dc2011-07-15 13:50:26 +02003303/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00003304/* removable device support */
3305
3306/**
3307 * Return TRUE if the media is present
3308 */
Max Reitze031f752015-10-19 17:53:11 +02003309bool bdrv_is_inserted(BlockDriverState *bs)
bellard19cb3732006-08-19 11:45:59 +00003310{
3311 BlockDriver *drv = bs->drv;
Max Reitz28d7a782015-10-19 17:53:13 +02003312 BdrvChild *child;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02003313
Max Reitze031f752015-10-19 17:53:11 +02003314 if (!drv) {
3315 return false;
3316 }
Max Reitz28d7a782015-10-19 17:53:13 +02003317 if (drv->bdrv_is_inserted) {
3318 return drv->bdrv_is_inserted(bs);
Max Reitze031f752015-10-19 17:53:11 +02003319 }
Max Reitz28d7a782015-10-19 17:53:13 +02003320 QLIST_FOREACH(child, &bs->children, next) {
3321 if (!bdrv_is_inserted(child->bs)) {
3322 return false;
3323 }
3324 }
3325 return true;
bellard19cb3732006-08-19 11:45:59 +00003326}
3327
3328/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02003329 * Return whether the media changed since the last call to this
3330 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00003331 */
3332int bdrv_media_changed(BlockDriverState *bs)
3333{
3334 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00003335
Markus Armbruster8e49ca42011-08-03 15:08:08 +02003336 if (drv && drv->bdrv_media_changed) {
3337 return drv->bdrv_media_changed(bs);
3338 }
3339 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00003340}
3341
3342/**
3343 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3344 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02003345void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00003346{
3347 BlockDriver *drv = bs->drv;
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003348 const char *device_name;
bellard19cb3732006-08-19 11:45:59 +00003349
Markus Armbruster822e1cd2011-07-20 18:23:42 +02003350 if (drv && drv->bdrv_eject) {
3351 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00003352 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02003353
Markus Armbrusterbfb197e2014-10-07 13:59:11 +02003354 device_name = bdrv_get_device_name(bs);
3355 if (device_name[0] != '\0') {
3356 qapi_event_send_device_tray_moved(device_name,
Wenchao Xiaa5ee7bd2014-06-18 08:43:44 +02003357 eject_flag, &error_abort);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02003358 }
bellard19cb3732006-08-19 11:45:59 +00003359}
3360
bellard19cb3732006-08-19 11:45:59 +00003361/**
3362 * Lock or unlock the media (if it is locked, the user won't be able
3363 * to eject it manually).
3364 */
Markus Armbruster025e8492011-09-06 18:58:47 +02003365void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00003366{
3367 BlockDriver *drv = bs->drv;
3368
Markus Armbruster025e8492011-09-06 18:58:47 +02003369 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01003370
Markus Armbruster025e8492011-09-06 18:58:47 +02003371 if (drv && drv->bdrv_lock_medium) {
3372 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00003373 }
3374}
ths985a03b2007-12-24 16:10:43 +00003375
Fam Zheng9fcb0252013-08-23 09:14:46 +08003376/* Get a reference to bs */
3377void bdrv_ref(BlockDriverState *bs)
3378{
3379 bs->refcnt++;
3380}
3381
3382/* Release a previously grabbed reference to bs.
3383 * If after releasing, reference count is zero, the BlockDriverState is
3384 * deleted. */
3385void bdrv_unref(BlockDriverState *bs)
3386{
Jeff Cody9a4d5ca2014-07-23 17:22:57 -04003387 if (!bs) {
3388 return;
3389 }
Fam Zheng9fcb0252013-08-23 09:14:46 +08003390 assert(bs->refcnt > 0);
3391 if (--bs->refcnt == 0) {
3392 bdrv_delete(bs);
3393 }
3394}
3395
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003396struct BdrvOpBlocker {
3397 Error *reason;
3398 QLIST_ENTRY(BdrvOpBlocker) list;
3399};
3400
3401bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3402{
3403 BdrvOpBlocker *blocker;
3404 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3405 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3406 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3407 if (errp) {
Markus Armbrustere43bfd92015-12-18 16:35:15 +01003408 *errp = error_copy(blocker->reason);
3409 error_prepend(errp, "Node '%s' is busy: ",
3410 bdrv_get_device_or_node_name(bs));
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003411 }
3412 return true;
3413 }
3414 return false;
3415}
3416
3417void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3418{
3419 BdrvOpBlocker *blocker;
3420 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3421
Markus Armbruster5839e532014-08-19 10:31:08 +02003422 blocker = g_new0(BdrvOpBlocker, 1);
Fam Zhengfbe40ff2014-05-23 21:29:42 +08003423 blocker->reason = reason;
3424 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3425}
3426
3427void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3428{
3429 BdrvOpBlocker *blocker, *next;
3430 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3431 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3432 if (blocker->reason == reason) {
3433 QLIST_REMOVE(blocker, list);
3434 g_free(blocker);
3435 }
3436 }
3437}
3438
3439void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3440{
3441 int i;
3442 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3443 bdrv_op_block(bs, i, reason);
3444 }
3445}
3446
3447void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3448{
3449 int i;
3450 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3451 bdrv_op_unblock(bs, i, reason);
3452 }
3453}
3454
3455bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3456{
3457 int i;
3458
3459 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3460 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3461 return false;
3462 }
3463 }
3464 return true;
3465}
3466
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003467void bdrv_img_create(const char *filename, const char *fmt,
3468 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003469 char *options, uint64_t img_size, int flags,
3470 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003471{
Chunyan Liu83d05212014-06-05 17:20:51 +08003472 QemuOptsList *create_opts = NULL;
3473 QemuOpts *opts = NULL;
3474 const char *backing_fmt, *backing_file;
3475 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003476 BlockDriver *drv, *proto_drv;
Max Reitzcc84d902013-09-06 17:14:26 +02003477 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003478 int ret = 0;
3479
3480 /* Find driver and parse its options */
3481 drv = bdrv_find_format(fmt);
3482 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003483 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003484 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003485 }
3486
Max Reitzb65a5e12015-02-05 13:58:12 -05003487 proto_drv = bdrv_find_protocol(filename, true, errp);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003488 if (!proto_drv) {
Luiz Capitulinod92ada22012-11-30 10:52:09 -02003489 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003490 }
3491
Max Reitzc6149722014-12-02 18:32:45 +01003492 if (!drv->create_opts) {
3493 error_setg(errp, "Format driver '%s' does not support image creation",
3494 drv->format_name);
3495 return;
3496 }
3497
3498 if (!proto_drv->create_opts) {
3499 error_setg(errp, "Protocol driver '%s' does not support image creation",
3500 proto_drv->format_name);
3501 return;
3502 }
3503
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003504 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3505 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003506
3507 /* Create parameter list with default values */
Chunyan Liu83d05212014-06-05 17:20:51 +08003508 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
Markus Armbruster39101f22015-02-12 16:46:36 +01003509 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003510
3511 /* Parse -o options */
3512 if (options) {
Markus Armbrusterdc523cd342015-02-12 18:37:11 +01003513 qemu_opts_do_parse(opts, options, NULL, &local_err);
3514 if (local_err) {
3515 error_report_err(local_err);
3516 local_err = NULL;
Chunyan Liu83d05212014-06-05 17:20:51 +08003517 error_setg(errp, "Invalid options for file format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003518 goto out;
3519 }
3520 }
3521
3522 if (base_filename) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01003523 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01003524 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003525 error_setg(errp, "Backing file not supported for file format '%s'",
3526 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003527 goto out;
3528 }
3529 }
3530
3531 if (base_fmt) {
Markus Armbrusterf43e47d2015-02-12 17:52:20 +01003532 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
Markus Armbruster6be41942015-02-12 17:49:02 +01003533 if (local_err) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003534 error_setg(errp, "Backing file format not supported for file "
3535 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003536 goto out;
3537 }
3538 }
3539
Chunyan Liu83d05212014-06-05 17:20:51 +08003540 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3541 if (backing_file) {
3542 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003543 error_setg(errp, "Error: Trying to create an image with the "
3544 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01003545 goto out;
3546 }
3547 }
3548
Chunyan Liu83d05212014-06-05 17:20:51 +08003549 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003550
3551 // The size for the image must always be specified, with one exception:
3552 // If we are using a backing file, we can obtain the size from there
Chunyan Liu83d05212014-06-05 17:20:51 +08003553 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3554 if (size == -1) {
3555 if (backing_file) {
Max Reitz66f6b812013-12-03 14:57:52 +01003556 BlockDriverState *bs;
Max Reitz29168012014-11-26 17:20:27 +01003557 char *full_backing = g_new0(char, PATH_MAX);
Markus Armbruster52bf1e72014-06-26 13:23:25 +02003558 int64_t size;
Paolo Bonzini63090da2012-04-12 14:01:03 +02003559 int back_flags;
Max Reitze6641712015-08-26 19:47:48 +02003560 QDict *backing_options = NULL;
Paolo Bonzini63090da2012-04-12 14:01:03 +02003561
Max Reitz29168012014-11-26 17:20:27 +01003562 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3563 full_backing, PATH_MAX,
3564 &local_err);
3565 if (local_err) {
3566 g_free(full_backing);
3567 goto out;
3568 }
3569
Paolo Bonzini63090da2012-04-12 14:01:03 +02003570 /* backing files always opened read-only */
Kevin Wolf61de4c62016-03-18 17:46:45 +01003571 back_flags = flags;
Kevin Wolfbfd18d12016-03-04 14:28:01 +01003572 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003573
Max Reitze6641712015-08-26 19:47:48 +02003574 if (backing_fmt) {
3575 backing_options = qdict_new();
3576 qdict_put(backing_options, "driver",
3577 qstring_from_str(backing_fmt));
3578 }
3579
Max Reitzf67503e2014-02-18 18:33:05 +01003580 bs = NULL;
Max Reitze6641712015-08-26 19:47:48 +02003581 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
Max Reitz6ebf9aa2015-08-26 19:47:49 +02003582 back_flags, &local_err);
Max Reitz29168012014-11-26 17:20:27 +01003583 g_free(full_backing);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003584 if (ret < 0) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003585 goto out;
3586 }
Markus Armbruster52bf1e72014-06-26 13:23:25 +02003587 size = bdrv_getlength(bs);
3588 if (size < 0) {
3589 error_setg_errno(errp, -size, "Could not get size of '%s'",
3590 backing_file);
3591 bdrv_unref(bs);
3592 goto out;
3593 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003594
Markus Armbruster39101f22015-02-12 16:46:36 +01003595 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
Max Reitz66f6b812013-12-03 14:57:52 +01003596
3597 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003598 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02003599 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003600 goto out;
3601 }
3602 }
3603
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003604 if (!quiet) {
Kővágó, Zoltánfe646692015-07-07 16:42:10 +02003605 printf("Formatting '%s', fmt=%s ", filename, fmt);
Fam Zheng43c5d8f2014-12-09 15:38:04 +08003606 qemu_opts_print(opts, " ");
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01003607 puts("");
3608 }
Chunyan Liu83d05212014-06-05 17:20:51 +08003609
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003610 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08003611
Max Reitzcc84d902013-09-06 17:14:26 +02003612 if (ret == -EFBIG) {
3613 /* This is generally a better message than whatever the driver would
3614 * deliver (especially because of the cluster_size_hint), since that
3615 * is most probably not much different from "image too large". */
3616 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08003617 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02003618 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003619 }
Max Reitzcc84d902013-09-06 17:14:26 +02003620 error_setg(errp, "The image size is too large for file format '%s'"
3621 "%s", fmt, cluster_size_hint);
3622 error_free(local_err);
3623 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003624 }
3625
3626out:
Chunyan Liu83d05212014-06-05 17:20:51 +08003627 qemu_opts_del(opts);
3628 qemu_opts_free(create_opts);
Markus Armbruster84d18f02014-01-30 15:07:28 +01003629 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +02003630 error_propagate(errp, local_err);
3631 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01003632}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01003633
3634AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3635{
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003636 return bs->aio_context;
3637}
3638
3639void bdrv_detach_aio_context(BlockDriverState *bs)
3640{
Max Reitz33384422014-06-20 21:57:33 +02003641 BdrvAioNotifier *baf;
Max Reitzb97511c2016-05-17 13:38:04 +02003642 BdrvChild *child;
Max Reitz33384422014-06-20 21:57:33 +02003643
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003644 if (!bs->drv) {
3645 return;
3646 }
3647
Max Reitz33384422014-06-20 21:57:33 +02003648 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3649 baf->detach_aio_context(baf->opaque);
3650 }
3651
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003652 if (bs->drv->bdrv_detach_aio_context) {
3653 bs->drv->bdrv_detach_aio_context(bs);
3654 }
Max Reitzb97511c2016-05-17 13:38:04 +02003655 QLIST_FOREACH(child, &bs->children, next) {
3656 bdrv_detach_aio_context(child->bs);
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003657 }
3658
3659 bs->aio_context = NULL;
3660}
3661
3662void bdrv_attach_aio_context(BlockDriverState *bs,
3663 AioContext *new_context)
3664{
Max Reitz33384422014-06-20 21:57:33 +02003665 BdrvAioNotifier *ban;
Max Reitzb97511c2016-05-17 13:38:04 +02003666 BdrvChild *child;
Max Reitz33384422014-06-20 21:57:33 +02003667
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003668 if (!bs->drv) {
3669 return;
3670 }
3671
3672 bs->aio_context = new_context;
3673
Max Reitzb97511c2016-05-17 13:38:04 +02003674 QLIST_FOREACH(child, &bs->children, next) {
3675 bdrv_attach_aio_context(child->bs, new_context);
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003676 }
3677 if (bs->drv->bdrv_attach_aio_context) {
3678 bs->drv->bdrv_attach_aio_context(bs, new_context);
3679 }
Max Reitz33384422014-06-20 21:57:33 +02003680
3681 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3682 ban->attached_aio_context(new_context, ban->opaque);
3683 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003684}
3685
3686void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3687{
Fam Zheng53ec73e2015-05-29 18:53:14 +08003688 bdrv_drain(bs); /* ensure there are no in-flight requests */
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02003689
3690 bdrv_detach_aio_context(bs);
3691
3692 /* This function executes in the old AioContext so acquire the new one in
3693 * case it runs in a different thread.
3694 */
3695 aio_context_acquire(new_context);
3696 bdrv_attach_aio_context(bs, new_context);
3697 aio_context_release(new_context);
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01003698}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003699
Max Reitz33384422014-06-20 21:57:33 +02003700void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3701 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3702 void (*detach_aio_context)(void *opaque), void *opaque)
3703{
3704 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3705 *ban = (BdrvAioNotifier){
3706 .attached_aio_context = attached_aio_context,
3707 .detach_aio_context = detach_aio_context,
3708 .opaque = opaque
3709 };
3710
3711 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3712}
3713
3714void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3715 void (*attached_aio_context)(AioContext *,
3716 void *),
3717 void (*detach_aio_context)(void *),
3718 void *opaque)
3719{
3720 BdrvAioNotifier *ban, *ban_next;
3721
3722 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3723 if (ban->attached_aio_context == attached_aio_context &&
3724 ban->detach_aio_context == detach_aio_context &&
3725 ban->opaque == opaque)
3726 {
3727 QLIST_REMOVE(ban, list);
3728 g_free(ban);
3729
3730 return;
3731 }
3732 }
3733
3734 abort();
3735}
3736
Max Reitz77485432014-10-27 11:12:50 +01003737int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
Max Reitz8b139762015-07-27 17:51:32 +02003738 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
Max Reitz6f176b42013-09-03 10:09:50 +02003739{
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003740 if (!bs->drv->bdrv_amend_options) {
Max Reitz6f176b42013-09-03 10:09:50 +02003741 return -ENOTSUP;
3742 }
Max Reitz8b139762015-07-27 17:51:32 +02003743 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
Max Reitz6f176b42013-09-03 10:09:50 +02003744}
Benoît Canetf6186f42013-10-02 14:33:48 +02003745
Benoît Canetb5042a32014-03-03 19:11:34 +01003746/* This function will be called by the bdrv_recurse_is_first_non_filter method
3747 * of block filter and by bdrv_is_first_non_filter.
3748 * It is used to test if the given bs is the candidate or recurse more in the
3749 * node graph.
Benoît Canet212a5a82014-01-23 21:31:36 +01003750 */
Benoît Canet212a5a82014-01-23 21:31:36 +01003751bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3752 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02003753{
Benoît Canetb5042a32014-03-03 19:11:34 +01003754 /* return false if basic checks fails */
3755 if (!bs || !bs->drv) {
3756 return false;
3757 }
3758
3759 /* the code reached a non block filter driver -> check if the bs is
3760 * the same as the candidate. It's the recursion termination condition.
3761 */
3762 if (!bs->drv->is_filter) {
3763 return bs == candidate;
3764 }
3765 /* Down this path the driver is a block filter driver */
3766
3767 /* If the block filter recursion method is defined use it to recurse down
3768 * the node graph.
3769 */
3770 if (bs->drv->bdrv_recurse_is_first_non_filter) {
Benoît Canet212a5a82014-01-23 21:31:36 +01003771 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
3772 }
3773
Benoît Canetb5042a32014-03-03 19:11:34 +01003774 /* the driver is a block filter but don't allow to recurse -> return false
3775 */
3776 return false;
Benoît Canet212a5a82014-01-23 21:31:36 +01003777}
3778
3779/* This function checks if the candidate is the first non filter bs down it's
3780 * bs chain. Since we don't have pointers to parents it explore all bs chains
3781 * from the top. Some filters can choose not to pass down the recursion.
3782 */
3783bool bdrv_is_first_non_filter(BlockDriverState *candidate)
3784{
Kevin Wolf7c8eece2016-03-22 18:58:50 +01003785 BlockDriverState *bs;
Kevin Wolf88be7b42016-05-20 18:49:07 +02003786 BdrvNextIterator it;
Benoît Canet212a5a82014-01-23 21:31:36 +01003787
3788 /* walk down the bs forest recursively */
Kevin Wolf88be7b42016-05-20 18:49:07 +02003789 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Benoît Canet212a5a82014-01-23 21:31:36 +01003790 bool perm;
3791
Benoît Canetb5042a32014-03-03 19:11:34 +01003792 /* try to recurse in this top level bs */
Kevin Wolfe6dc8a12014-02-04 11:45:31 +01003793 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
Benoît Canet212a5a82014-01-23 21:31:36 +01003794
3795 /* candidate is the first non filter */
3796 if (perm) {
3797 return true;
3798 }
3799 }
3800
3801 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02003802}
Benoît Canet09158f02014-06-27 18:25:25 +02003803
Wen Congyange12f3782015-07-17 10:12:22 +08003804BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
3805 const char *node_name, Error **errp)
Benoît Canet09158f02014-06-27 18:25:25 +02003806{
3807 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01003808 AioContext *aio_context;
3809
Benoît Canet09158f02014-06-27 18:25:25 +02003810 if (!to_replace_bs) {
3811 error_setg(errp, "Node name '%s' not found", node_name);
3812 return NULL;
3813 }
3814
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01003815 aio_context = bdrv_get_aio_context(to_replace_bs);
3816 aio_context_acquire(aio_context);
3817
Benoît Canet09158f02014-06-27 18:25:25 +02003818 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01003819 to_replace_bs = NULL;
3820 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02003821 }
3822
3823 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3824 * most non filter in order to prevent data corruption.
3825 * Another benefit is that this tests exclude backing files which are
3826 * blocked by the backing blockers.
3827 */
Wen Congyange12f3782015-07-17 10:12:22 +08003828 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
Benoît Canet09158f02014-06-27 18:25:25 +02003829 error_setg(errp, "Only top most non filter can be replaced");
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01003830 to_replace_bs = NULL;
3831 goto out;
Benoît Canet09158f02014-06-27 18:25:25 +02003832 }
3833
Stefan Hajnoczi5a7e7a02014-10-21 12:03:58 +01003834out:
3835 aio_context_release(aio_context);
Benoît Canet09158f02014-06-27 18:25:25 +02003836 return to_replace_bs;
3837}
Ming Lei448ad912014-07-04 18:04:33 +08003838
Max Reitz91af7012014-07-18 20:24:56 +02003839static bool append_open_options(QDict *d, BlockDriverState *bs)
3840{
3841 const QDictEntry *entry;
Kevin Wolf9e700c12015-04-24 15:20:28 +02003842 QemuOptDesc *desc;
Kevin Wolf260fecf2015-04-27 13:46:22 +02003843 BdrvChild *child;
Max Reitz91af7012014-07-18 20:24:56 +02003844 bool found_any = false;
Kevin Wolf260fecf2015-04-27 13:46:22 +02003845 const char *p;
Max Reitz91af7012014-07-18 20:24:56 +02003846
3847 for (entry = qdict_first(bs->options); entry;
3848 entry = qdict_next(bs->options, entry))
3849 {
Kevin Wolf260fecf2015-04-27 13:46:22 +02003850 /* Exclude options for children */
3851 QLIST_FOREACH(child, &bs->children, next) {
3852 if (strstart(qdict_entry_key(entry), child->name, &p)
3853 && (!*p || *p == '.'))
3854 {
3855 break;
3856 }
3857 }
3858 if (child) {
Kevin Wolf9e700c12015-04-24 15:20:28 +02003859 continue;
Max Reitz91af7012014-07-18 20:24:56 +02003860 }
Kevin Wolf9e700c12015-04-24 15:20:28 +02003861
3862 /* And exclude all non-driver-specific options */
3863 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
3864 if (!strcmp(qdict_entry_key(entry), desc->name)) {
3865 break;
3866 }
3867 }
3868 if (desc->name) {
3869 continue;
3870 }
3871
3872 qobject_incref(qdict_entry_value(entry));
3873 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
3874 found_any = true;
Max Reitz91af7012014-07-18 20:24:56 +02003875 }
3876
3877 return found_any;
3878}
3879
3880/* Updates the following BDS fields:
3881 * - exact_filename: A filename which may be used for opening a block device
3882 * which (mostly) equals the given BDS (even without any
3883 * other options; so reading and writing must return the same
3884 * results, but caching etc. may be different)
3885 * - full_open_options: Options which, when given when opening a block device
3886 * (without a filename), result in a BDS (mostly)
3887 * equalling the given one
3888 * - filename: If exact_filename is set, it is copied here. Otherwise,
3889 * full_open_options is converted to a JSON object, prefixed with
3890 * "json:" (for use through the JSON pseudo protocol) and put here.
3891 */
3892void bdrv_refresh_filename(BlockDriverState *bs)
3893{
3894 BlockDriver *drv = bs->drv;
3895 QDict *opts;
3896
3897 if (!drv) {
3898 return;
3899 }
3900
3901 /* This BDS's file name will most probably depend on its file's name, so
3902 * refresh that first */
3903 if (bs->file) {
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003904 bdrv_refresh_filename(bs->file->bs);
Max Reitz91af7012014-07-18 20:24:56 +02003905 }
3906
3907 if (drv->bdrv_refresh_filename) {
3908 /* Obsolete information is of no use here, so drop the old file name
3909 * information before refreshing it */
3910 bs->exact_filename[0] = '\0';
3911 if (bs->full_open_options) {
3912 QDECREF(bs->full_open_options);
3913 bs->full_open_options = NULL;
3914 }
3915
Kevin Wolf4cdd01d2015-04-27 13:50:54 +02003916 opts = qdict_new();
3917 append_open_options(opts, bs);
3918 drv->bdrv_refresh_filename(bs, opts);
3919 QDECREF(opts);
Max Reitz91af7012014-07-18 20:24:56 +02003920 } else if (bs->file) {
3921 /* Try to reconstruct valid information from the underlying file */
3922 bool has_open_options;
3923
3924 bs->exact_filename[0] = '\0';
3925 if (bs->full_open_options) {
3926 QDECREF(bs->full_open_options);
3927 bs->full_open_options = NULL;
3928 }
3929
3930 opts = qdict_new();
3931 has_open_options = append_open_options(opts, bs);
3932
3933 /* If no specific options have been given for this BDS, the filename of
3934 * the underlying file should suffice for this one as well */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003935 if (bs->file->bs->exact_filename[0] && !has_open_options) {
3936 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
Max Reitz91af7012014-07-18 20:24:56 +02003937 }
3938 /* Reconstructing the full options QDict is simple for most format block
3939 * drivers, as long as the full options are known for the underlying
3940 * file BDS. The full options QDict of that file BDS should somehow
3941 * contain a representation of the filename, therefore the following
3942 * suffices without querying the (exact_)filename of this BDS. */
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003943 if (bs->file->bs->full_open_options) {
Max Reitz91af7012014-07-18 20:24:56 +02003944 qdict_put_obj(opts, "driver",
3945 QOBJECT(qstring_from_str(drv->format_name)));
Kevin Wolf9a4f4c32015-06-16 14:19:22 +02003946 QINCREF(bs->file->bs->full_open_options);
3947 qdict_put_obj(opts, "file",
3948 QOBJECT(bs->file->bs->full_open_options));
Max Reitz91af7012014-07-18 20:24:56 +02003949
3950 bs->full_open_options = opts;
3951 } else {
3952 QDECREF(opts);
3953 }
3954 } else if (!bs->full_open_options && qdict_size(bs->options)) {
3955 /* There is no underlying file BDS (at least referenced by BDS.file),
3956 * so the full options QDict should be equal to the options given
3957 * specifically for this block device when it was opened (plus the
3958 * driver specification).
3959 * Because those options don't change, there is no need to update
3960 * full_open_options when it's already set. */
3961
3962 opts = qdict_new();
3963 append_open_options(opts, bs);
3964 qdict_put_obj(opts, "driver",
3965 QOBJECT(qstring_from_str(drv->format_name)));
3966
3967 if (bs->exact_filename[0]) {
3968 /* This may not work for all block protocol drivers (some may
3969 * require this filename to be parsed), but we have to find some
3970 * default solution here, so just include it. If some block driver
3971 * does not support pure options without any filename at all or
3972 * needs some special format of the options QDict, it needs to
3973 * implement the driver-specific bdrv_refresh_filename() function.
3974 */
3975 qdict_put_obj(opts, "filename",
3976 QOBJECT(qstring_from_str(bs->exact_filename)));
3977 }
3978
3979 bs->full_open_options = opts;
3980 }
3981
3982 if (bs->exact_filename[0]) {
3983 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
3984 } else if (bs->full_open_options) {
3985 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
3986 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
3987 qstring_get_str(json));
3988 QDECREF(json);
3989 }
3990}
Wen Congyange06018a2016-05-10 15:36:37 +08003991
3992/*
3993 * Hot add/remove a BDS's child. So the user can take a child offline when
3994 * it is broken and take a new child online
3995 */
3996void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
3997 Error **errp)
3998{
3999
4000 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
4001 error_setg(errp, "The node %s does not support adding a child",
4002 bdrv_get_device_or_node_name(parent_bs));
4003 return;
4004 }
4005
4006 if (!QLIST_EMPTY(&child_bs->parents)) {
4007 error_setg(errp, "The node %s already has a parent",
4008 child_bs->node_name);
4009 return;
4010 }
4011
4012 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
4013}
4014
4015void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
4016{
4017 BdrvChild *tmp;
4018
4019 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
4020 error_setg(errp, "The node %s does not support removing a child",
4021 bdrv_get_device_or_node_name(parent_bs));
4022 return;
4023 }
4024
4025 QLIST_FOREACH(tmp, &parent_bs->children, next) {
4026 if (tmp == child) {
4027 break;
4028 }
4029 }
4030
4031 if (!tmp) {
4032 error_setg(errp, "The node %s does not have a child named %s",
4033 bdrv_get_device_or_node_name(parent_bs),
4034 bdrv_get_device_or_node_name(child->bs));
4035 return;
4036 }
4037
4038 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
4039}