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 blk_set_dev_ops(blk
, NULL
, NULL
);
199 aio_context_release(ctx
);
207 void blk_exp_ref(BlockExport
*exp
)
209 assert(qatomic_read(&exp
->refcount
) > 0);
210 qatomic_inc(&exp
->refcount
);
213 /* Runs in the main thread */
214 static void blk_exp_delete_bh(void *opaque
)
216 BlockExport
*exp
= opaque
;
217 AioContext
*aio_context
= exp
->ctx
;
219 aio_context_acquire(aio_context
);
221 assert(exp
->refcount
== 0);
222 QLIST_REMOVE(exp
, next
);
223 exp
->drv
->delete(exp
);
224 blk_set_dev_ops(exp
->blk
, NULL
, NULL
);
226 qapi_event_send_block_export_deleted(exp
->id
);
230 aio_context_release(aio_context
);
233 void blk_exp_unref(BlockExport
*exp
)
235 assert(qatomic_read(&exp
->refcount
) > 0);
236 if (qatomic_fetch_dec(&exp
->refcount
) == 1) {
237 /* Touch the block_exports list only in the main thread */
238 aio_bh_schedule_oneshot(qemu_get_aio_context(), blk_exp_delete_bh
,
244 * Drops the user reference to the export and requests that all client
245 * connections and other internally held references start to shut down. When
246 * the function returns, there may still be active references while the export
247 * is in the process of shutting down.
249 * Acquires exp->ctx internally. Callers must *not* hold the lock.
251 void blk_exp_request_shutdown(BlockExport
*exp
)
253 AioContext
*aio_context
= exp
->ctx
;
255 aio_context_acquire(aio_context
);
258 * If the user doesn't own the export any more, it is already shutting
259 * down. We must not call .request_shutdown and decrease the refcount a
262 if (!exp
->user_owned
) {
266 exp
->drv
->request_shutdown(exp
);
268 assert(exp
->user_owned
);
269 exp
->user_owned
= false;
273 aio_context_release(aio_context
);
277 * Returns whether a block export of the given type exists.
278 * type == BLOCK_EXPORT_TYPE__MAX checks for an export of any type.
280 static bool blk_exp_has_type(BlockExportType type
)
284 if (type
== BLOCK_EXPORT_TYPE__MAX
) {
285 return !QLIST_EMPTY(&block_exports
);
288 QLIST_FOREACH(exp
, &block_exports
, next
) {
289 if (exp
->drv
->type
== type
) {
297 /* type == BLOCK_EXPORT_TYPE__MAX for all types */
298 void blk_exp_close_all_type(BlockExportType type
)
300 BlockExport
*exp
, *next
;
302 assert(in_aio_context_home_thread(qemu_get_aio_context()));
304 QLIST_FOREACH_SAFE(exp
, &block_exports
, next
, next
) {
305 if (type
!= BLOCK_EXPORT_TYPE__MAX
&& exp
->drv
->type
!= type
) {
308 blk_exp_request_shutdown(exp
);
311 AIO_WAIT_WHILE_UNLOCKED(NULL
, blk_exp_has_type(type
));
314 void blk_exp_close_all(void)
316 blk_exp_close_all_type(BLOCK_EXPORT_TYPE__MAX
);
319 void qmp_block_export_add(BlockExportOptions
*export
, Error
**errp
)
321 blk_exp_add(export
, errp
);
324 void qmp_block_export_del(const char *id
,
325 bool has_mode
, BlockExportRemoveMode mode
,
331 exp
= blk_exp_find(id
);
333 error_setg(errp
, "Export '%s' is not found", id
);
336 if (!exp
->user_owned
) {
337 error_setg(errp
, "Export '%s' is already shutting down", id
);
342 mode
= BLOCK_EXPORT_REMOVE_MODE_SAFE
;
344 if (mode
== BLOCK_EXPORT_REMOVE_MODE_SAFE
&&
345 qatomic_read(&exp
->refcount
) > 1) {
346 error_setg(errp
, "export '%s' still in use", exp
->id
);
347 error_append_hint(errp
, "Use mode='hard' to force client "
352 blk_exp_request_shutdown(exp
);
355 BlockExportInfoList
*qmp_query_block_exports(Error
**errp
)
357 BlockExportInfoList
*head
= NULL
, **tail
= &head
;
360 QLIST_FOREACH(exp
, &block_exports
, next
) {
361 BlockExportInfo
*info
= g_new(BlockExportInfo
, 1);
362 *info
= (BlockExportInfo
) {
363 .id
= g_strdup(exp
->id
),
364 .type
= exp
->drv
->type
,
365 .node_name
= g_strdup(bdrv_get_node_name(blk_bs(exp
->blk
))),
366 .shutting_down
= !exp
->user_owned
,
369 QAPI_LIST_APPEND(tail
, info
);