1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2022 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "ftl_core.h" 7 #include "ftl_mngt.h" 8 #include "ftl_mngt_steps.h" 9 10 static const struct ftl_mngt_process_desc desc_startup; 11 static const struct ftl_mngt_process_desc desc_first_start; 12 static const struct ftl_mngt_process_desc desc_restore; 13 static const struct ftl_mngt_process_desc desc_clean_start; 14 15 static void 16 ftl_mngt_select_startup_mode(struct spdk_ftl_dev *dev, 17 struct ftl_mngt_process *mngt) 18 { 19 if (dev->conf.mode & SPDK_FTL_MODE_CREATE) { 20 ftl_mngt_call_process(mngt, &desc_first_start); 21 } else { 22 ftl_mngt_call_process(mngt, &desc_restore); 23 } 24 } 25 26 static void 27 ftl_mngt_select_restore_mode(struct spdk_ftl_dev *dev, 28 struct ftl_mngt_process *mngt) 29 { 30 if (dev->sb->clean) { 31 ftl_mngt_call_process(mngt, &desc_clean_start); 32 } else { 33 ftl_mngt_recover(dev, mngt); 34 } 35 } 36 37 /* 38 * Common startup steps required by FTL in all cases (creation, load, dirty shutdown recovery). 39 * Includes actions like opening the devices, calculating the expected size and version of metadata, etc. 40 */ 41 static const struct ftl_mngt_process_desc desc_startup = { 42 .name = "FTL startup", 43 .steps = { 44 { 45 .name = "Check configuration", 46 .action = ftl_mngt_check_conf, 47 }, 48 { 49 .name = "Open base bdev", 50 .action = ftl_mngt_open_base_bdev, 51 .cleanup = ftl_mngt_close_base_bdev 52 }, 53 { 54 .name = "Open cache bdev", 55 .action = ftl_mngt_open_cache_bdev, 56 .cleanup = ftl_mngt_close_cache_bdev 57 }, 58 #ifdef SPDK_FTL_VSS_EMU 59 { 60 .name = "Initialize VSS emu", 61 .action = ftl_mngt_md_init_vss_emu, 62 .cleanup = ftl_mngt_md_deinit_vss_emu 63 }, 64 #endif 65 { 66 .name = "Initialize superblock", 67 .action = ftl_mngt_superblock_init, 68 .cleanup = ftl_mngt_superblock_deinit 69 }, 70 { 71 .name = "Initialize memory pools", 72 .action = ftl_mngt_init_mem_pools, 73 .cleanup = ftl_mngt_deinit_mem_pools 74 }, 75 { 76 .name = "Initialize bands", 77 .action = ftl_mngt_init_bands, 78 .cleanup = ftl_mngt_deinit_bands 79 }, 80 { 81 .name = "Register IO device", 82 .action = ftl_mngt_register_io_device, 83 .cleanup = ftl_mngt_unregister_io_device 84 }, 85 { 86 .name = "Initialize core IO channel", 87 .action = ftl_mngt_init_io_channel, 88 .cleanup = ftl_mngt_deinit_io_channel 89 }, 90 { 91 .name = "Decorate bands", 92 .action = ftl_mngt_decorate_bands 93 }, 94 { 95 .name = "Initialize layout", 96 .action = ftl_mngt_init_layout 97 }, 98 { 99 .name = "Verify layout", 100 .action = ftl_mngt_layout_verify, 101 }, 102 { 103 .name = "Initialize metadata", 104 .action = ftl_mngt_init_md, 105 .cleanup = ftl_mngt_deinit_md 106 }, 107 { 108 .name = "Initialize band addresses", 109 .action = ftl_mngt_initialize_band_address 110 }, 111 { 112 .name = "Initialize NV cache", 113 .action = ftl_mngt_init_nv_cache, 114 .cleanup = ftl_mngt_deinit_nv_cache 115 }, 116 { 117 .name = "Upgrade layout", 118 .action = ftl_mngt_layout_upgrade, 119 }, 120 { 121 .name = "Initialize valid map", 122 .action = ftl_mngt_init_vld_map, 123 .cleanup = ftl_mngt_deinit_vld_map 124 }, 125 { 126 .name = "Initialize trim map", 127 .action = ftl_mngt_init_unmap_map, 128 .cleanup = ftl_mngt_deinit_unmap_map 129 }, 130 { 131 .name = "Initialize bands metadata", 132 .action = ftl_mngt_init_bands_md, 133 .cleanup = ftl_mngt_deinit_bands_md 134 }, 135 { 136 .name = "Initialize reloc", 137 .action = ftl_mngt_init_reloc, 138 .cleanup = ftl_mngt_deinit_reloc 139 }, 140 { 141 .name = "Select startup mode", 142 .action = ftl_mngt_select_startup_mode 143 }, 144 {} 145 } 146 }; 147 148 /* 149 * Steps executed when creating FTL for the first time - most important being scrubbing 150 * old data/metadata (so it's not leaked during dirty shutdown recovery) and laying out 151 * regions for the new metadata (initializing band states, etc). 152 */ 153 static const struct ftl_mngt_process_desc desc_first_start = { 154 .name = "FTL first start", 155 .steps = { 156 { 157 .name = "Initialize L2P", 158 .action = ftl_mngt_init_l2p, 159 .cleanup = ftl_mngt_deinit_l2p 160 }, 161 { 162 .name = "Clear L2P", 163 .action = ftl_mngt_clear_l2p, 164 }, 165 { 166 .name = "Scrub NV cache", 167 .action = ftl_mngt_scrub_nv_cache, 168 }, 169 { 170 .name = "Finalize band initialization", 171 .action = ftl_mngt_finalize_init_bands, 172 }, 173 { 174 .name = "Save initial band info metadata", 175 .action = ftl_mngt_persist_band_info_metadata, 176 }, 177 { 178 .name = "Save initial chunk info metadata", 179 .action = ftl_mngt_persist_nv_cache_metadata, 180 }, 181 { 182 .name = "Initialize P2L checkpointing", 183 .action = ftl_mngt_p2l_init_ckpt, 184 .cleanup = ftl_mngt_p2l_deinit_ckpt 185 }, 186 { 187 .name = "Wipe P2L region", 188 .action = ftl_mngt_p2l_wipe, 189 }, 190 { 191 .name = "Clear trim map", 192 .action = ftl_mngt_unmap_clear, 193 }, 194 { 195 .name = "Free P2L region bufs", 196 .action = ftl_mngt_p2l_free_bufs, 197 }, 198 { 199 .name = "Set FTL dirty state", 200 .action = ftl_mngt_set_dirty, 201 }, 202 { 203 .name = "Start core poller", 204 .action = ftl_mngt_start_core_poller, 205 .cleanup = ftl_mngt_stop_core_poller 206 }, 207 { 208 .name = "Finalize initialization", 209 .action = ftl_mngt_finalize_startup, 210 }, 211 {} 212 } 213 }; 214 215 /* 216 * Step utilized on loading of an FTL instance - decides on dirty/clean shutdown path. 217 */ 218 static const struct ftl_mngt_process_desc desc_restore = { 219 .name = "FTL restore", 220 .steps = { 221 { 222 .name = "Select recovery mode", 223 .action = ftl_mngt_select_restore_mode, 224 }, 225 {} 226 } 227 }; 228 229 /* 230 * Loading of FTL after clean shutdown. 231 */ 232 static const struct ftl_mngt_process_desc desc_clean_start = { 233 .name = "Clean startup", 234 .steps = { 235 { 236 .name = "Restore metadata", 237 .action = ftl_mngt_restore_md 238 }, 239 { 240 .name = "Initialize P2L checkpointing", 241 .action = ftl_mngt_p2l_init_ckpt, 242 .cleanup = ftl_mngt_p2l_deinit_ckpt 243 }, 244 { 245 .name = "Restore P2L checkpoints", 246 .action = ftl_mngt_p2l_restore_ckpt 247 }, 248 { 249 .name = "Initialize L2P", 250 .action = ftl_mngt_init_l2p, 251 .cleanup = ftl_mngt_deinit_l2p 252 }, 253 { 254 .name = "Restore L2P", 255 .action = ftl_mngt_restore_l2p, 256 }, 257 { 258 .name = "Finalize band initialization", 259 .action = ftl_mngt_finalize_init_bands, 260 }, 261 { 262 .name = "Free P2L region bufs", 263 .action = ftl_mngt_p2l_free_bufs, 264 }, 265 { 266 .name = "Start core poller", 267 .action = ftl_mngt_start_core_poller, 268 .cleanup = ftl_mngt_stop_core_poller 269 }, 270 { 271 .name = "Self test on startup", 272 .action = ftl_mngt_self_test, 273 }, 274 { 275 .name = "Set FTL dirty state", 276 .action = ftl_mngt_set_dirty, 277 }, 278 { 279 .name = "Finalize initialization", 280 .action = ftl_mngt_finalize_startup, 281 }, 282 {} 283 } 284 }; 285 286 int 287 ftl_mngt_call_dev_startup(struct spdk_ftl_dev *dev, ftl_mngt_completion cb, void *cb_cntx) 288 { 289 return ftl_mngt_process_execute(dev, &desc_startup, cb, cb_cntx); 290 } 291 292 struct ftl_unmap_ctx { 293 uint64_t lba; 294 uint64_t num_blocks; 295 spdk_ftl_fn cb_fn; 296 void *cb_arg; 297 struct spdk_thread *thread; 298 int status; 299 }; 300 301 static void 302 ftl_mngt_process_unmap_cb(void *ctx, int status) 303 { 304 struct ftl_mngt_process *mngt = ctx; 305 306 if (status) { 307 ftl_mngt_fail_step(ctx); 308 } else { 309 ftl_mngt_next_step(mngt); 310 } 311 } 312 313 static void 314 ftl_mngt_process_unmap(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt) 315 { 316 struct ftl_io *io = ftl_mngt_get_process_ctx(mngt); 317 struct ftl_unmap_ctx *ctx = ftl_mngt_get_caller_ctx(mngt); 318 int rc; 319 320 if (!dev->ioch) { 321 ftl_mngt_fail_step(mngt); 322 return; 323 } 324 325 rc = spdk_ftl_unmap(dev, io, dev->ioch, ctx->lba, ctx->num_blocks, ftl_mngt_process_unmap_cb, mngt); 326 if (rc == -EAGAIN) { 327 ftl_mngt_continue_step(mngt); 328 } 329 } 330 331 /* 332 * RPC unmap path. 333 */ 334 static const struct ftl_mngt_process_desc g_desc_unmap = { 335 .name = "FTL unmap", 336 .ctx_size = sizeof(struct ftl_io), 337 .steps = { 338 { 339 .name = "Process unmap", 340 .action = ftl_mngt_process_unmap, 341 }, 342 {} 343 } 344 }; 345 346 static void 347 unmap_user_cb(void *_ctx) 348 { 349 struct ftl_unmap_ctx *ctx = _ctx; 350 351 ctx->cb_fn(ctx->cb_arg, ctx->status); 352 free(ctx); 353 } 354 355 static void 356 ftl_mngt_unmap_cb(struct spdk_ftl_dev *dev, void *_ctx, int status) 357 { 358 struct ftl_unmap_ctx *ctx = _ctx; 359 ctx->status = status; 360 361 if (spdk_thread_send_msg(ctx->thread, unmap_user_cb, ctx)) { 362 ftl_abort(); 363 } 364 } 365 366 int 367 ftl_mngt_unmap(struct spdk_ftl_dev *dev, uint64_t lba, uint64_t num_blocks, spdk_ftl_fn cb, 368 void *cb_cntx) 369 { 370 struct ftl_unmap_ctx *ctx; 371 372 ctx = calloc(1, sizeof(*ctx)); 373 if (ctx == NULL) { 374 return -EAGAIN; 375 } 376 377 ctx->lba = lba; 378 ctx->num_blocks = num_blocks; 379 ctx->cb_fn = cb; 380 ctx->cb_arg = cb_cntx; 381 ctx->thread = spdk_get_thread(); 382 383 return ftl_mngt_process_execute(dev, &g_desc_unmap, ftl_mngt_unmap_cb, ctx); 384 } 385 386 void 387 ftl_mngt_rollback_device(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt) 388 { 389 ftl_mngt_call_process_rollback(mngt, &desc_startup); 390 } 391