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