block/export/export.c

   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 }