2 * Common block export infrastructure
4 * Copyright (c) 2012, 2020 Red Hat, Inc.
7 * Paolo Bonzini <pbonzini@redhat.com>
8 * Kevin Wolf <kwolf@redhat.com>
10 * This work is licensed under the terms of the GNU GPL, version 2 or
11 * later. See the COPYING file in the top-level directory.
14 #include "qemu/osdep.h"
16 #include "block/block.h"
17 #include "sysemu/block-backend.h"
18 #include "sysemu/iothread.h"
19 #include "block/export.h"
20 #include "block/fuse.h"
21 #include "block/nbd.h"
22 #include "qapi/error.h"
23 #include "qapi/qapi-commands-block-export.h"
24 #include "qapi/qapi-events-block-export.h"
26 #ifdef CONFIG_VHOST_USER_BLK_SERVER
27 #include "vhost-user-blk-server.h"
29 #ifdef CONFIG_VDUSE_BLK_EXPORT
30 #include "vduse-blk.h"
33 static const BlockExportDriver
*blk_exp_drivers
[] = {
35 #ifdef CONFIG_VHOST_USER_BLK_SERVER
36 &blk_exp_vhost_user_blk
,
41 #ifdef CONFIG_VDUSE_BLK_EXPORT
46 /* Only accessed from the main thread */
47 static QLIST_HEAD(, BlockExport
) block_exports
=
48 QLIST_HEAD_INITIALIZER(block_exports
);
50 BlockExport
*blk_exp_find(const char *id
)
54 QLIST_FOREACH(exp
, &block_exports
, next
) {
55 if (strcmp(id
, exp
->id
) == 0) {
63 static const BlockExportDriver
*blk_exp_find_driver(BlockExportType type
)
67 for (i
= 0; i
< ARRAY_SIZE(blk_exp_drivers
); i
++) {
68 if (blk_exp_drivers
[i
]->type
== type
) {
69 return blk_exp_drivers
[i
];
75 BlockExport
*blk_exp_add(BlockExportOptions
*export
, Error
**errp
)
77 bool fixed_iothread
= export
->has_fixed_iothread
&& export
->fixed_iothread
;
78 const BlockExportDriver
*drv
;
79 BlockExport
*exp
= NULL
;
81 BlockBackend
*blk
= NULL
;
86 if (!id_wellformed(export
->id
)) {
87 error_setg(errp
, "Invalid block export id");
90 if (blk_exp_find(export
->id
)) {
91 error_setg(errp
, "Block export id '%s' is already in use", export
->id
);
95 drv
= blk_exp_find_driver(export
->type
);
97 error_setg(errp
, "No driver found for the requested export type");
101 bs
= bdrv_lookup_bs(NULL
, export
->node_name
, errp
);
106 if (!export
->has_writable
) {
107 export
->writable
= false;
109 if (bdrv_is_read_only(bs
) && export
->writable
) {
110 error_setg(errp
, "Cannot export read-only node as writable");
114 ctx
= bdrv_get_aio_context(bs
);
115 aio_context_acquire(ctx
);
117 if (export
->iothread
) {
120 Error
**set_context_errp
;
122 iothread
= iothread_by_id(export
->iothread
);
124 error_setg(errp
, "iothread \"%s\" not found", export
->iothread
);
128 new_ctx
= iothread_get_aio_context(iothread
);
130 /* Ignore errors with fixed-iothread=false */
131 set_context_errp
= fixed_iothread
? errp
: NULL
;
132 ret
= bdrv_try_change_aio_context(bs
, new_ctx
, NULL
, set_context_errp
);
134 aio_context_release(ctx
);
135 aio_context_acquire(new_ctx
);
137 } else if (fixed_iothread
) {
143 * Block exports are used for non-shared storage migration. Make sure
144 * that BDRV_O_INACTIVE is cleared and the image is ready for write
145 * access since the export could be available before migration handover.
146 * ctx was acquired in the caller.
148 bdrv_activate(bs
, NULL
);
150 perm
= BLK_PERM_CONSISTENT_READ
;
151 if (export
->writable
) {
152 perm
|= BLK_PERM_WRITE
;
155 blk
= blk_new(ctx
, perm
, BLK_PERM_ALL
);
157 if (!fixed_iothread
) {
158 blk_set_allow_aio_context_change(blk
, true);
161 ret
= blk_insert_bs(blk
, bs
, errp
);
166 if (!export
->has_writethrough
) {
167 export
->writethrough
= false;
169 blk_set_enable_write_cache(blk
, !export
->writethrough
);
171 assert(drv
->instance_size
>= sizeof(BlockExport
));
172 exp
= g_malloc0(drv
->instance_size
);
173 *exp
= (BlockExport
) {
177 .id
= g_strdup(export
->id
),
182 ret
= drv
->create(exp
, export
, errp
);
187 assert(exp
->blk
!= NULL
);
189 QLIST_INSERT_HEAD(&block_exports
, exp
, next
);
191 aio_context_release(ctx
);
196 aio_context_release(ctx
);
204 /* Callers must hold exp->ctx lock */
205 void blk_exp_ref(BlockExport
*exp
)
207 assert(exp
->refcount
> 0);
211 /* Runs in the main thread */
212 static void blk_exp_delete_bh(void *opaque
)
214 BlockExport
*exp
= opaque
;
215 AioContext
*aio_context
= exp
->ctx
;
217 aio_context_acquire(aio_context
);
219 assert(exp
->refcount
== 0);
220 QLIST_REMOVE(exp
, next
);
221 exp
->drv
->delete(exp
);
223 qapi_event_send_block_export_deleted(exp
->id
);
227 aio_context_release(aio_context
);
230 /* Callers must hold exp->ctx lock */
231 void blk_exp_unref(BlockExport
*exp
)
233 assert(exp
->refcount
> 0);
234 if (--exp
->refcount
== 0) {
235 /* Touch the block_exports list only in the main thread */
236 aio_bh_schedule_oneshot(qemu_get_aio_context(), blk_exp_delete_bh
,
242 * Drops the user reference to the export and requests that all client
243 * connections and other internally held references start to shut down. When
244 * the function returns, there may still be active references while the export
245 * is in the process of shutting down.
247 * Acquires exp->ctx internally. Callers must *not* hold the lock.
249 void blk_exp_request_shutdown(BlockExport
*exp
)
251 AioContext
*aio_context
= exp
->ctx
;
253 aio_context_acquire(aio_context
);
256 * If the user doesn't own the export any more, it is already shutting
257 * down. We must not call .request_shutdown and decrease the refcount a
260 if (!exp
->user_owned
) {
264 exp
->drv
->request_shutdown(exp
);
266 assert(exp
->user_owned
);
267 exp
->user_owned
= false;
271 aio_context_release(aio_context
);
275 * Returns whether a block export of the given type exists.
276 * type == BLOCK_EXPORT_TYPE__MAX checks for an export of any type.
278 static bool blk_exp_has_type(BlockExportType type
)
282 if (type
== BLOCK_EXPORT_TYPE__MAX
) {
283 return !QLIST_EMPTY(&block_exports
);
286 QLIST_FOREACH(exp
, &block_exports
, next
) {
287 if (exp
->drv
->type
== type
) {
295 /* type == BLOCK_EXPORT_TYPE__MAX for all types */
296 void blk_exp_close_all_type(BlockExportType type
)
298 BlockExport
*exp
, *next
;
300 assert(in_aio_context_home_thread(qemu_get_aio_context()));
302 QLIST_FOREACH_SAFE(exp
, &block_exports
, next
, next
) {
303 if (type
!= BLOCK_EXPORT_TYPE__MAX
&& exp
->drv
->type
!= type
) {
306 blk_exp_request_shutdown(exp
);
309 AIO_WAIT_WHILE(NULL
, blk_exp_has_type(type
));
312 void blk_exp_close_all(void)
314 blk_exp_close_all_type(BLOCK_EXPORT_TYPE__MAX
);
317 void qmp_block_export_add(BlockExportOptions
*export
, Error
**errp
)
319 blk_exp_add(export
, errp
);
322 void qmp_block_export_del(const char *id
,
323 bool has_mode
, BlockExportRemoveMode mode
,
329 exp
= blk_exp_find(id
);
331 error_setg(errp
, "Export '%s' is not found", id
);
334 if (!exp
->user_owned
) {
335 error_setg(errp
, "Export '%s' is already shutting down", id
);
340 mode
= BLOCK_EXPORT_REMOVE_MODE_SAFE
;
342 if (mode
== BLOCK_EXPORT_REMOVE_MODE_SAFE
&& exp
->refcount
> 1) {
343 error_setg(errp
, "export '%s' still in use", exp
->id
);
344 error_append_hint(errp
, "Use mode='hard' to force client "
349 blk_exp_request_shutdown(exp
);
352 BlockExportInfoList
*qmp_query_block_exports(Error
**errp
)
354 BlockExportInfoList
*head
= NULL
, **tail
= &head
;
357 QLIST_FOREACH(exp
, &block_exports
, next
) {
358 BlockExportInfo
*info
= g_new(BlockExportInfo
, 1);
359 *info
= (BlockExportInfo
) {
360 .id
= g_strdup(exp
->id
),
361 .type
= exp
->drv
->type
,
362 .node_name
= g_strdup(bdrv_get_node_name(blk_bs(exp
->blk
))),
363 .shutting_down
= !exp
->user_owned
,
366 QAPI_LIST_APPEND(tail
, info
);