1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2017 Intel Corporation. All rights reserved. 3 * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. 4 */ 5 6 #include "spdk/stdinc.h" 7 8 #include "spdk/bdev.h" 9 #include "spdk/env.h" 10 #include "spdk/thread.h" 11 #include "spdk/json.h" 12 #include "spdk/string.h" 13 #include "spdk/likely.h" 14 15 #include "spdk/bdev_module.h" 16 #include "spdk/log.h" 17 18 #include "bdev_null.h" 19 20 struct null_bdev { 21 struct spdk_bdev bdev; 22 TAILQ_ENTRY(null_bdev) tailq; 23 }; 24 25 struct null_io_channel { 26 struct spdk_poller *poller; 27 TAILQ_HEAD(, spdk_bdev_io) io; 28 }; 29 30 static TAILQ_HEAD(, null_bdev) g_null_bdev_head = TAILQ_HEAD_INITIALIZER(g_null_bdev_head); 31 static void *g_null_read_buf; 32 33 static int bdev_null_initialize(void); 34 static void bdev_null_finish(void); 35 36 static struct spdk_bdev_module null_if = { 37 .name = "null", 38 .module_init = bdev_null_initialize, 39 .module_fini = bdev_null_finish, 40 .async_fini = true, 41 }; 42 43 SPDK_BDEV_MODULE_REGISTER(null, &null_if) 44 45 static int 46 bdev_null_destruct(void *ctx) 47 { 48 struct null_bdev *bdev = ctx; 49 50 TAILQ_REMOVE(&g_null_bdev_head, bdev, tailq); 51 free(bdev->bdev.name); 52 free(bdev); 53 54 return 0; 55 } 56 57 static bool 58 bdev_null_abort_io(struct null_io_channel *ch, struct spdk_bdev_io *bio_to_abort) 59 { 60 struct spdk_bdev_io *bdev_io; 61 62 TAILQ_FOREACH(bdev_io, &ch->io, module_link) { 63 if (bdev_io == bio_to_abort) { 64 TAILQ_REMOVE(&ch->io, bio_to_abort, module_link); 65 spdk_bdev_io_complete(bio_to_abort, SPDK_BDEV_IO_STATUS_ABORTED); 66 return true; 67 } 68 } 69 70 return false; 71 } 72 73 static void 74 bdev_null_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io) 75 { 76 struct null_io_channel *ch = spdk_io_channel_get_ctx(_ch); 77 struct spdk_bdev *bdev = bdev_io->bdev; 78 struct spdk_dif_ctx dif_ctx; 79 struct spdk_dif_error err_blk; 80 int rc; 81 struct spdk_dif_ctx_init_ext_opts dif_opts; 82 83 if (SPDK_DIF_DISABLE != bdev->dif_type && 84 (SPDK_BDEV_IO_TYPE_READ == bdev_io->type || 85 SPDK_BDEV_IO_TYPE_WRITE == bdev_io->type)) { 86 dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format); 87 dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16; 88 rc = spdk_dif_ctx_init(&dif_ctx, 89 bdev->blocklen, 90 bdev->md_len, 91 bdev->md_interleave, 92 bdev->dif_is_head_of_md, 93 bdev->dif_type, 94 bdev->dif_check_flags, 95 bdev_io->u.bdev.offset_blocks & 0xFFFFFFFF, 96 0xFFFF, 0, 0, 0, &dif_opts); 97 if (0 != rc) { 98 SPDK_ERRLOG("Failed to initialize DIF context, error %d\n", rc); 99 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 100 return; 101 } 102 } 103 104 switch (bdev_io->type) { 105 case SPDK_BDEV_IO_TYPE_READ: 106 if (bdev_io->u.bdev.iovs[0].iov_base == NULL) { 107 assert(bdev_io->u.bdev.iovcnt == 1); 108 if (spdk_likely(bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen <= 109 SPDK_BDEV_LARGE_BUF_MAX_SIZE)) { 110 bdev_io->u.bdev.iovs[0].iov_base = g_null_read_buf; 111 bdev_io->u.bdev.iovs[0].iov_len = bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen; 112 } else { 113 SPDK_ERRLOG("Overflow occurred. Read I/O size %" PRIu64 " was larger than permitted %d\n", 114 bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen, 115 SPDK_BDEV_LARGE_BUF_MAX_SIZE); 116 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 117 return; 118 } 119 } 120 if (SPDK_DIF_DISABLE != bdev->dif_type) { 121 rc = spdk_dif_generate(bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, 122 bdev_io->u.bdev.num_blocks, &dif_ctx); 123 if (0 != rc) { 124 SPDK_ERRLOG("IO DIF generation failed: lba %" PRIu64 ", num_block %" PRIu64 "\n", 125 bdev_io->u.bdev.offset_blocks, 126 bdev_io->u.bdev.num_blocks); 127 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 128 return; 129 } 130 } 131 TAILQ_INSERT_TAIL(&ch->io, bdev_io, module_link); 132 break; 133 case SPDK_BDEV_IO_TYPE_WRITE: 134 if (SPDK_DIF_DISABLE != bdev->dif_type) { 135 rc = spdk_dif_verify(bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, 136 bdev_io->u.bdev.num_blocks, &dif_ctx, &err_blk); 137 if (0 != rc) { 138 SPDK_ERRLOG("IO DIF verification failed: lba %" PRIu64 ", num_blocks %" PRIu64 ", " 139 "err_type %u, expected %lu, actual %lu, err_offset %u\n", 140 bdev_io->u.bdev.offset_blocks, 141 bdev_io->u.bdev.num_blocks, 142 err_blk.err_type, 143 err_blk.expected, 144 err_blk.actual, 145 err_blk.err_offset); 146 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 147 return; 148 } 149 } 150 TAILQ_INSERT_TAIL(&ch->io, bdev_io, module_link); 151 break; 152 case SPDK_BDEV_IO_TYPE_WRITE_ZEROES: 153 case SPDK_BDEV_IO_TYPE_RESET: 154 TAILQ_INSERT_TAIL(&ch->io, bdev_io, module_link); 155 break; 156 case SPDK_BDEV_IO_TYPE_ABORT: 157 if (bdev_null_abort_io(ch, bdev_io->u.abort.bio_to_abort)) { 158 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS); 159 } else { 160 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 161 } 162 break; 163 case SPDK_BDEV_IO_TYPE_FLUSH: 164 case SPDK_BDEV_IO_TYPE_UNMAP: 165 default: 166 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED); 167 break; 168 } 169 } 170 171 static bool 172 bdev_null_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type) 173 { 174 switch (io_type) { 175 case SPDK_BDEV_IO_TYPE_READ: 176 case SPDK_BDEV_IO_TYPE_WRITE: 177 case SPDK_BDEV_IO_TYPE_WRITE_ZEROES: 178 case SPDK_BDEV_IO_TYPE_RESET: 179 case SPDK_BDEV_IO_TYPE_ABORT: 180 return true; 181 case SPDK_BDEV_IO_TYPE_FLUSH: 182 case SPDK_BDEV_IO_TYPE_UNMAP: 183 default: 184 return false; 185 } 186 } 187 188 static struct spdk_io_channel * 189 bdev_null_get_io_channel(void *ctx) 190 { 191 return spdk_get_io_channel(&g_null_bdev_head); 192 } 193 194 static void 195 bdev_null_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w) 196 { 197 spdk_json_write_object_begin(w); 198 199 spdk_json_write_named_string(w, "method", "bdev_null_create"); 200 201 spdk_json_write_named_object_begin(w, "params"); 202 spdk_json_write_named_string(w, "name", bdev->name); 203 spdk_json_write_named_uint64(w, "num_blocks", bdev->blockcnt); 204 spdk_json_write_named_uint32(w, "block_size", bdev->blocklen); 205 spdk_json_write_named_uint32(w, "physical_block_size", bdev->phys_blocklen); 206 spdk_json_write_named_uint32(w, "md_size", bdev->md_len); 207 spdk_json_write_named_uint32(w, "dif_type", bdev->dif_type); 208 spdk_json_write_named_bool(w, "dif_is_head_of_md", bdev->dif_is_head_of_md); 209 spdk_json_write_named_uuid(w, "uuid", &bdev->uuid); 210 spdk_json_write_object_end(w); 211 212 spdk_json_write_object_end(w); 213 } 214 215 static const struct spdk_bdev_fn_table null_fn_table = { 216 .destruct = bdev_null_destruct, 217 .submit_request = bdev_null_submit_request, 218 .io_type_supported = bdev_null_io_type_supported, 219 .get_io_channel = bdev_null_get_io_channel, 220 .write_config_json = bdev_null_write_config_json, 221 }; 222 223 int 224 bdev_null_create(struct spdk_bdev **bdev, const struct spdk_null_bdev_opts *opts) 225 { 226 struct null_bdev *null_disk; 227 uint32_t data_block_size; 228 int rc; 229 230 if (!opts) { 231 SPDK_ERRLOG("No options provided for Null bdev.\n"); 232 return -EINVAL; 233 } 234 235 if (opts->md_interleave) { 236 if (opts->block_size < opts->md_size) { 237 SPDK_ERRLOG("Interleaved metadata size can not be greater than block size.\n"); 238 return -EINVAL; 239 } 240 data_block_size = opts->block_size - opts->md_size; 241 } else { 242 if (opts->md_size != 0) { 243 SPDK_ERRLOG("Metadata in separate buffer is not supported\n"); 244 return -ENOTSUP; 245 } 246 data_block_size = opts->block_size; 247 } 248 249 if (data_block_size % 512 != 0) { 250 SPDK_ERRLOG("Data block size %u is not a multiple of 512.\n", opts->block_size); 251 return -EINVAL; 252 } 253 254 if (opts->num_blocks == 0) { 255 SPDK_ERRLOG("Disk must be more than 0 blocks\n"); 256 return -EINVAL; 257 } 258 259 null_disk = calloc(1, sizeof(*null_disk)); 260 if (!null_disk) { 261 SPDK_ERRLOG("could not allocate null_bdev\n"); 262 return -ENOMEM; 263 } 264 265 null_disk->bdev.name = strdup(opts->name); 266 if (!null_disk->bdev.name) { 267 free(null_disk); 268 return -ENOMEM; 269 } 270 null_disk->bdev.product_name = "Null disk"; 271 272 null_disk->bdev.write_cache = 0; 273 null_disk->bdev.blocklen = opts->block_size; 274 null_disk->bdev.phys_blocklen = opts->physical_block_size; 275 null_disk->bdev.blockcnt = opts->num_blocks; 276 null_disk->bdev.md_len = opts->md_size; 277 null_disk->bdev.md_interleave = opts->md_interleave; 278 null_disk->bdev.dif_type = opts->dif_type; 279 null_disk->bdev.dif_is_head_of_md = opts->dif_is_head_of_md; 280 /* Current block device layer API does not propagate 281 * any DIF related information from user. So, we can 282 * not generate or verify Application Tag. 283 */ 284 switch (opts->dif_type) { 285 case SPDK_DIF_TYPE1: 286 case SPDK_DIF_TYPE2: 287 null_disk->bdev.dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK | 288 SPDK_DIF_FLAGS_REFTAG_CHECK; 289 break; 290 case SPDK_DIF_TYPE3: 291 null_disk->bdev.dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK; 292 break; 293 case SPDK_DIF_DISABLE: 294 break; 295 } 296 297 null_disk->bdev.uuid = *opts->uuid; 298 null_disk->bdev.ctxt = null_disk; 299 null_disk->bdev.fn_table = &null_fn_table; 300 null_disk->bdev.module = &null_if; 301 302 rc = spdk_bdev_register(&null_disk->bdev); 303 if (rc) { 304 free(null_disk->bdev.name); 305 free(null_disk); 306 return rc; 307 } 308 309 *bdev = &(null_disk->bdev); 310 311 TAILQ_INSERT_TAIL(&g_null_bdev_head, null_disk, tailq); 312 313 return rc; 314 } 315 316 void 317 bdev_null_delete(const char *bdev_name, spdk_delete_null_complete cb_fn, void *cb_arg) 318 { 319 int rc; 320 321 rc = spdk_bdev_unregister_by_name(bdev_name, &null_if, cb_fn, cb_arg); 322 if (rc != 0) { 323 cb_fn(cb_arg, rc); 324 } 325 } 326 327 static int 328 null_io_poll(void *arg) 329 { 330 struct null_io_channel *ch = arg; 331 TAILQ_HEAD(, spdk_bdev_io) io; 332 struct spdk_bdev_io *bdev_io; 333 334 TAILQ_INIT(&io); 335 TAILQ_SWAP(&ch->io, &io, spdk_bdev_io, module_link); 336 337 if (TAILQ_EMPTY(&io)) { 338 return SPDK_POLLER_IDLE; 339 } 340 341 while (!TAILQ_EMPTY(&io)) { 342 bdev_io = TAILQ_FIRST(&io); 343 TAILQ_REMOVE(&io, bdev_io, module_link); 344 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS); 345 } 346 347 return SPDK_POLLER_BUSY; 348 } 349 350 static int 351 null_bdev_create_cb(void *io_device, void *ctx_buf) 352 { 353 struct null_io_channel *ch = ctx_buf; 354 355 TAILQ_INIT(&ch->io); 356 ch->poller = SPDK_POLLER_REGISTER(null_io_poll, ch, 0); 357 358 return 0; 359 } 360 361 static void 362 null_bdev_destroy_cb(void *io_device, void *ctx_buf) 363 { 364 struct null_io_channel *ch = ctx_buf; 365 366 spdk_poller_unregister(&ch->poller); 367 } 368 369 static int 370 bdev_null_initialize(void) 371 { 372 /* 373 * This will be used if upper layer expects us to allocate the read buffer. 374 * Instead of using a real rbuf from the bdev pool, just always point to 375 * this same zeroed buffer. 376 */ 377 g_null_read_buf = spdk_zmalloc(SPDK_BDEV_LARGE_BUF_MAX_SIZE, 0, NULL, 378 SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_DMA); 379 if (g_null_read_buf == NULL) { 380 return -1; 381 } 382 383 /* 384 * We need to pick some unique address as our "io device" - so just use the 385 * address of the global tailq. 386 */ 387 spdk_io_device_register(&g_null_bdev_head, null_bdev_create_cb, null_bdev_destroy_cb, 388 sizeof(struct null_io_channel), "null_bdev"); 389 390 return 0; 391 } 392 393 static void 394 dummy_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *ctx) 395 { 396 } 397 398 int 399 bdev_null_resize(const char *bdev_name, const uint64_t new_size_in_mb) 400 { 401 struct spdk_bdev_desc *desc; 402 struct spdk_bdev *bdev; 403 uint64_t current_size_in_mb; 404 uint64_t new_size_in_byte; 405 int rc = 0; 406 407 rc = spdk_bdev_open_ext(bdev_name, false, dummy_bdev_event_cb, NULL, &desc); 408 if (rc != 0) { 409 SPDK_ERRLOG("failed to open bdev; %s.\n", bdev_name); 410 return rc; 411 } 412 413 bdev = spdk_bdev_desc_get_bdev(desc); 414 415 if (bdev->module != &null_if) { 416 rc = -EINVAL; 417 goto exit; 418 } 419 420 current_size_in_mb = bdev->blocklen * bdev->blockcnt / (1024 * 1024); 421 if (new_size_in_mb < current_size_in_mb) { 422 SPDK_ERRLOG("The new bdev size must not be smaller than current bdev size.\n"); 423 rc = -EINVAL; 424 goto exit; 425 } 426 427 new_size_in_byte = new_size_in_mb * 1024 * 1024; 428 429 rc = spdk_bdev_notify_blockcnt_change(bdev, new_size_in_byte / bdev->blocklen); 430 if (rc != 0) { 431 SPDK_ERRLOG("failed to notify block cnt change.\n"); 432 } 433 434 exit: 435 spdk_bdev_close(desc); 436 return rc; 437 } 438 439 static void 440 _bdev_null_finish_cb(void *arg) 441 { 442 spdk_free(g_null_read_buf); 443 spdk_bdev_module_fini_done(); 444 } 445 446 static void 447 bdev_null_finish(void) 448 { 449 if (g_null_read_buf == NULL) { 450 spdk_bdev_module_fini_done(); 451 return; 452 } 453 spdk_io_device_unregister(&g_null_bdev_head, _bdev_null_finish_cb); 454 } 455 456 SPDK_LOG_REGISTER_COMPONENT(bdev_null) 457