xref: /qemu/block/export/export.c (revision 372b69f5) 
1 /*
2  * Common block export infrastructure
3  *
4  * Copyright (c) 2012, 2020 Red Hat, Inc.
5  *
6  * Authors:
7  * Paolo Bonzini <pbonzini@redhat.com>
8  * Kevin Wolf <kwolf@redhat.com>
9  *
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.
12  */
13 
14 #include "qemu/osdep.h"
15 
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"
25 #include "qemu/id.h"
26 #ifdef CONFIG_VHOST_USER_BLK_SERVER
27 #include "vhost-user-blk-server.h"
28 #endif
29 #ifdef CONFIG_VDUSE_BLK_EXPORT
30 #include "vduse-blk.h"
31 #endif
32 
33 static const BlockExportDriver *blk_exp_drivers[] = {
34     &blk_exp_nbd,
35 #ifdef CONFIG_VHOST_USER_BLK_SERVER
36     &blk_exp_vhost_user_blk,
37 #endif
38 #ifdef CONFIG_FUSE
39     &blk_exp_fuse,
40 #endif
41 #ifdef CONFIG_VDUSE_BLK_EXPORT
42     &blk_exp_vduse_blk,
43 #endif
44 };
45 
46 /* Only accessed from the main thread */
47 static QLIST_HEAD(, BlockExport) block_exports =
48     QLIST_HEAD_INITIALIZER(block_exports);
49 
50 BlockExport *blk_exp_find(const char *id)
51 {
52     BlockExport *exp;
53 
54     QLIST_FOREACH(exp, &block_exports, next) {
55         if (strcmp(id, exp->id) == 0) {
56             return exp;
57         }
58     }
59 
60     return NULL;
61 }
62 
63 static const BlockExportDriver *blk_exp_find_driver(BlockExportType type)
64 {
65     int i;
66 
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];
70         }
71     }
72     return NULL;
73 }
74 
75 BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
76 {
77     bool fixed_iothread = export->has_fixed_iothread && export->fixed_iothread;
78     const BlockExportDriver *drv;
79     BlockExport *exp = NULL;
80     BlockDriverState *bs;
81     BlockBackend *blk = NULL;
82     AioContext *ctx;
83     uint64_t perm;
84     int ret;
85 
86     GLOBAL_STATE_CODE();
87 
88     if (!id_wellformed(export->id)) {
89         error_setg(errp, "Invalid block export id");
90         return NULL;
91     }
92     if (blk_exp_find(export->id)) {
93         error_setg(errp, "Block export id '%s' is already in use", export->id);
94         return NULL;
95     }
96 
97     drv = blk_exp_find_driver(export->type);
98     if (!drv) {
99         error_setg(errp, "No driver found for the requested export type");
100         return NULL;
101     }
102 
103     bs = bdrv_lookup_bs(NULL, export->node_name, errp);
104     if (!bs) {
105         return NULL;
106     }
107 
108     if (!export->has_writable) {
109         export->writable = false;
110     }
111     if (bdrv_is_read_only(bs) && export->writable) {
112         error_setg(errp, "Cannot export read-only node as writable");
113         return NULL;
114     }
115 
116     ctx = bdrv_get_aio_context(bs);
117     aio_context_acquire(ctx);
118 
119     if (export->iothread) {
120         IOThread *iothread;
121         AioContext *new_ctx;
122         Error **set_context_errp;
123 
124         iothread = iothread_by_id(export->iothread);
125         if (!iothread) {
126             error_setg(errp, "iothread \"%s\" not found", export->iothread);
127             goto fail;
128         }
129 
130         new_ctx = iothread_get_aio_context(iothread);
131 
132         /* Ignore errors with fixed-iothread=false */
133         set_context_errp = fixed_iothread ? errp : NULL;
134         ret = bdrv_try_change_aio_context(bs, new_ctx, NULL, set_context_errp);
135         if (ret == 0) {
136             aio_context_release(ctx);
137             aio_context_acquire(new_ctx);
138             ctx = new_ctx;
139         } else if (fixed_iothread) {
140             goto fail;
141         }
142     }
143 
144     /*
145      * Block exports are used for non-shared storage migration. Make sure
146      * that BDRV_O_INACTIVE is cleared and the image is ready for write
147      * access since the export could be available before migration handover.
148      * ctx was acquired in the caller.
149      */
150     bdrv_graph_rdlock_main_loop();
151     bdrv_activate(bs, NULL);
152     bdrv_graph_rdunlock_main_loop();
153 
154     perm = BLK_PERM_CONSISTENT_READ;
155     if (export->writable) {
156         perm |= BLK_PERM_WRITE;
157     }
158 
159     blk = blk_new(ctx, perm, BLK_PERM_ALL);
160 
161     if (!fixed_iothread) {
162         blk_set_allow_aio_context_change(blk, true);
163     }
164 
165     ret = blk_insert_bs(blk, bs, errp);
166     if (ret < 0) {
167         goto fail;
168     }
169 
170     if (!export->has_writethrough) {
171         export->writethrough = false;
172     }
173     blk_set_enable_write_cache(blk, !export->writethrough);
174 
175     assert(drv->instance_size >= sizeof(BlockExport));
176     exp = g_malloc0(drv->instance_size);
177     *exp = (BlockExport) {
178         .drv        = drv,
179         .refcount   = 1,
180         .user_owned = true,
181         .id         = g_strdup(export->id),
182         .ctx        = ctx,
183         .blk        = blk,
184     };
185 
186     ret = drv->create(exp, export, errp);
187     if (ret < 0) {
188         goto fail;
189     }
190 
191     assert(exp->blk != NULL);
192 
193     QLIST_INSERT_HEAD(&block_exports, exp, next);
194 
195     aio_context_release(ctx);
196     return exp;
197 
198 fail:
199     if (blk) {
200         blk_set_dev_ops(blk, NULL, NULL);
201         blk_unref(blk);
202     }
203     aio_context_release(ctx);
204     if (exp) {
205         g_free(exp->id);
206         g_free(exp);
207     }
208     return NULL;
209 }
210 
211 void blk_exp_ref(BlockExport *exp)
212 {
213     assert(qatomic_read(&exp->refcount) > 0);
214     qatomic_inc(&exp->refcount);
215 }
216 
217 /* Runs in the main thread */
218 static void blk_exp_delete_bh(void *opaque)
219 {
220     BlockExport *exp = opaque;
221     AioContext *aio_context = exp->ctx;
222 
223     aio_context_acquire(aio_context);
224 
225     assert(exp->refcount == 0);
226     QLIST_REMOVE(exp, next);
227     exp->drv->delete(exp);
228     blk_set_dev_ops(exp->blk, NULL, NULL);
229     blk_unref(exp->blk);
230     qapi_event_send_block_export_deleted(exp->id);
231     g_free(exp->id);
232     g_free(exp);
233 
234     aio_context_release(aio_context);
235 }
236 
237 void blk_exp_unref(BlockExport *exp)
238 {
239     assert(qatomic_read(&exp->refcount) > 0);
240     if (qatomic_fetch_dec(&exp->refcount) == 1) {
241         /* Touch the block_exports list only in the main thread */
242         aio_bh_schedule_oneshot(qemu_get_aio_context(), blk_exp_delete_bh,
243                                 exp);
244     }
245 }
246 
247 /*
248  * Drops the user reference to the export and requests that all client
249  * connections and other internally held references start to shut down. When
250  * the function returns, there may still be active references while the export
251  * is in the process of shutting down.
252  *
253  * Acquires exp->ctx internally. Callers must *not* hold the lock.
254  */
255 void blk_exp_request_shutdown(BlockExport *exp)
256 {
257     AioContext *aio_context = exp->ctx;
258 
259     aio_context_acquire(aio_context);
260 
261     /*
262      * If the user doesn't own the export any more, it is already shutting
263      * down. We must not call .request_shutdown and decrease the refcount a
264      * second time.
265      */
266     if (!exp->user_owned) {
267         goto out;
268     }
269 
270     exp->drv->request_shutdown(exp);
271 
272     assert(exp->user_owned);
273     exp->user_owned = false;
274     blk_exp_unref(exp);
275 
276 out:
277     aio_context_release(aio_context);
278 }
279 
280 /*
281  * Returns whether a block export of the given type exists.
282  * type == BLOCK_EXPORT_TYPE__MAX checks for an export of any type.
283  */
284 static bool blk_exp_has_type(BlockExportType type)
285 {
286     BlockExport *exp;
287 
288     if (type == BLOCK_EXPORT_TYPE__MAX) {
289         return !QLIST_EMPTY(&block_exports);
290     }
291 
292     QLIST_FOREACH(exp, &block_exports, next) {
293         if (exp->drv->type == type) {
294             return true;
295         }
296     }
297 
298     return false;
299 }
300 
301 /* type == BLOCK_EXPORT_TYPE__MAX for all types */
302 void blk_exp_close_all_type(BlockExportType type)
303 {
304     BlockExport *exp, *next;
305 
306     assert(in_aio_context_home_thread(qemu_get_aio_context()));
307 
308     QLIST_FOREACH_SAFE(exp, &block_exports, next, next) {
309         if (type != BLOCK_EXPORT_TYPE__MAX && exp->drv->type != type) {
310             continue;
311         }
312         blk_exp_request_shutdown(exp);
313     }
314 
315     AIO_WAIT_WHILE_UNLOCKED(NULL, blk_exp_has_type(type));
316 }
317 
318 void blk_exp_close_all(void)
319 {
320     blk_exp_close_all_type(BLOCK_EXPORT_TYPE__MAX);
321 }
322 
323 void qmp_block_export_add(BlockExportOptions *export, Error **errp)
324 {
325     blk_exp_add(export, errp);
326 }
327 
328 void qmp_block_export_del(const char *id,
329                           bool has_mode, BlockExportRemoveMode mode,
330                           Error **errp)
331 {
332     ERRP_GUARD();
333     BlockExport *exp;
334 
335     exp = blk_exp_find(id);
336     if (exp == NULL) {
337         error_setg(errp, "Export '%s' is not found", id);
338         return;
339     }
340     if (!exp->user_owned) {
341         error_setg(errp, "Export '%s' is already shutting down", id);
342         return;
343     }
344 
345     if (!has_mode) {
346         mode = BLOCK_EXPORT_REMOVE_MODE_SAFE;
347     }
348     if (mode == BLOCK_EXPORT_REMOVE_MODE_SAFE &&
349         qatomic_read(&exp->refcount) > 1) {
350         error_setg(errp, "export '%s' still in use", exp->id);
351         error_append_hint(errp, "Use mode='hard' to force client "
352                           "disconnect\n");
353         return;
354     }
355 
356     blk_exp_request_shutdown(exp);
357 }
358 
359 BlockExportInfoList *qmp_query_block_exports(Error **errp)
360 {
361     BlockExportInfoList *head = NULL, **tail = &head;
362     BlockExport *exp;
363 
364     QLIST_FOREACH(exp, &block_exports, next) {
365         BlockExportInfo *info = g_new(BlockExportInfo, 1);
366         *info = (BlockExportInfo) {
367             .id             = g_strdup(exp->id),
368             .type           = exp->drv->type,
369             .node_name      = g_strdup(bdrv_get_node_name(blk_bs(exp->blk))),
370             .shutting_down  = !exp->user_owned,
371         };
372 
373         QAPI_LIST_APPEND(tail, info);
374     }
375 
376     return head;
377 }
378