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