Branch data Line data Source code
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_utils.h"
8 : : #include "ftl_mngt.h"
9 : : #include "ftl_mngt_steps.h"
10 : : #include "ftl_band.h"
11 : : #include "ftl_internal.h"
12 : : #include "ftl_nv_cache.h"
13 : : #include "ftl_debug.h"
14 : : #include "ftl_utils.h"
15 : :
16 : : void
17 : 22 : ftl_mngt_check_conf(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
18 : : {
19 [ + - ]: 22 : if (ftl_conf_is_valid(&dev->conf)) {
20 : 22 : ftl_mngt_next_step(mngt);
21 : : } else {
22 : 0 : ftl_mngt_fail_step(mngt);
23 : : }
24 : 22 : }
25 : :
26 : : static int
27 : 22 : init_p2l_map_pool(struct spdk_ftl_dev *dev)
28 : : {
29 : 22 : size_t p2l_pool_el_blks = spdk_divide_round_up(ftl_p2l_map_pool_elem_size(dev), FTL_BLOCK_SIZE);
30 : 22 : size_t p2l_pool_buf_blks = P2L_MEMPOOL_SIZE * p2l_pool_el_blks;
31 : : void *p2l_pool_buf;
32 : :
33 : 22 : dev->p2l_pool_md = ftl_md_create(dev, p2l_pool_buf_blks, 0, "p2l_pool",
34 : : ftl_md_create_shm_flags(dev), NULL);
35 [ - + ]: 22 : if (!dev->p2l_pool_md) {
36 : 0 : return -ENOMEM;
37 : : }
38 : :
39 : 22 : p2l_pool_buf = ftl_md_get_buffer(dev->p2l_pool_md);
40 : 22 : dev->p2l_pool = ftl_mempool_create_ext(p2l_pool_buf, P2L_MEMPOOL_SIZE,
41 : 22 : p2l_pool_el_blks * FTL_BLOCK_SIZE,
42 : : FTL_BLOCK_SIZE);
43 [ - + ]: 22 : if (!dev->p2l_pool) {
44 : 0 : return -ENOMEM;
45 : : }
46 : :
47 [ + - ]: 22 : if (!ftl_fast_startup(dev)) {
48 : 22 : ftl_mempool_initialize_ext(dev->p2l_pool);
49 : : }
50 : :
51 : 22 : return 0;
52 : : }
53 : :
54 : : static int
55 : 22 : init_band_md_pool(struct spdk_ftl_dev *dev)
56 : : {
57 : 22 : dev->band_md_pool = ftl_mempool_create(P2L_MEMPOOL_SIZE,
58 : : sizeof(struct ftl_band_md),
59 : : FTL_BLOCK_SIZE,
60 : : SPDK_ENV_SOCKET_ID_ANY);
61 [ - + ]: 22 : if (!dev->band_md_pool) {
62 : 0 : return -ENOMEM;
63 : : }
64 : :
65 : 22 : return 0;
66 : : }
67 : :
68 : : void
69 : 22 : ftl_mngt_init_mem_pools(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
70 : : {
71 [ - + ]: 22 : if (init_p2l_map_pool(dev)) {
72 : 0 : ftl_mngt_fail_step(mngt);
73 : 0 : return;
74 : : }
75 : :
76 [ - + ]: 22 : if (init_band_md_pool(dev)) {
77 : 0 : ftl_mngt_fail_step(mngt);
78 : 0 : return;
79 : : }
80 : :
81 : 22 : ftl_mngt_next_step(mngt);
82 : : }
83 : :
84 : : void
85 : 22 : ftl_mngt_deinit_mem_pools(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
86 : : {
87 [ + - ]: 22 : if (dev->p2l_pool) {
88 : 22 : ftl_mempool_destroy_ext(dev->p2l_pool);
89 : 22 : dev->p2l_pool = NULL;
90 : : }
91 : :
92 [ + - ]: 22 : if (dev->p2l_pool_md) {
93 : 22 : ftl_md_destroy(dev->p2l_pool_md, ftl_md_destroy_shm_flags(dev));
94 : 22 : dev->p2l_pool_md = NULL;
95 : : }
96 : :
97 [ + - ]: 22 : if (dev->band_md_pool) {
98 : 22 : ftl_mempool_destroy(dev->band_md_pool);
99 : 22 : dev->band_md_pool = NULL;
100 : : }
101 : :
102 : 22 : ftl_mngt_next_step(mngt);
103 : 22 : }
104 : :
105 : : void
106 : 22 : ftl_mngt_init_reloc(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
107 : : {
108 : 22 : dev->reloc = ftl_reloc_init(dev);
109 [ - + ]: 22 : if (!dev->reloc) {
110 [ # # ]: 0 : FTL_ERRLOG(dev, "Unable to initialize reloc structures\n");
111 : 0 : ftl_mngt_fail_step(mngt);
112 : 0 : return;
113 : : }
114 : :
115 : 22 : ftl_mngt_next_step(mngt);
116 : : }
117 : :
118 : : void
119 : 22 : ftl_mngt_deinit_reloc(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
120 : : {
121 : 22 : ftl_reloc_free(dev->reloc);
122 : 22 : ftl_mngt_next_step(mngt);
123 : 22 : }
124 : :
125 : : void
126 : 22 : ftl_mngt_init_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
127 : : {
128 [ - + ]: 22 : if (ftl_nv_cache_init(dev)) {
129 [ # # ]: 0 : FTL_ERRLOG(dev, "Unable to initialize persistent cache\n");
130 : 0 : ftl_mngt_fail_step(mngt);
131 : 0 : return;
132 : : }
133 : :
134 : 22 : ftl_mngt_next_step(mngt);
135 : : }
136 : :
137 : : void
138 : 22 : ftl_mngt_deinit_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
139 : : {
140 : 22 : ftl_nv_cache_deinit(dev);
141 : 22 : ftl_mngt_next_step(mngt);
142 : 22 : }
143 : :
144 : : static void
145 : 5 : user_clear_cb(struct spdk_ftl_dev *dev, void *cb_ctx, int status)
146 : : {
147 : 5 : struct ftl_mngt_process *mngt = cb_ctx;
148 : :
149 [ - + ]: 5 : if (status) {
150 [ # # ]: 0 : FTL_ERRLOG(ftl_mngt_get_dev(mngt), "FTL NV Cache: ERROR of clearing user cache data\n");
151 : 0 : ftl_mngt_fail_step(mngt);
152 : : } else {
153 : 5 : ftl_mngt_next_step(mngt);
154 : : }
155 : 5 : }
156 : :
157 : : void
158 : 22 : ftl_mngt_scrub_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
159 : : {
160 : 22 : bool is_first_start = (dev->conf.mode & SPDK_FTL_MODE_CREATE) != 0;
161 [ + + - + : 38 : bool is_major_upgrade = dev->sb->clean == 1 && dev->sb_shm->shm_clean == 0 &&
+ - ]
162 [ - + ]: 16 : dev->sb->upgrade_ready == 1;
163 : :
164 [ + + - + ]: 22 : if (is_first_start || is_major_upgrade) {
165 [ + - ]: 5 : FTL_NOTICELOG(dev, "NV cache data region needs scrubbing, this may take a while.\n");
166 [ + - ]: 5 : FTL_NOTICELOG(dev, "Scrubbing %"PRIu64" chunks\n", dev->layout.nvc.chunk_count);
167 : :
168 : : /* Need to scrub user data, so in case of dirty shutdown the recovery won't
169 : : * pull in data during open chunks recovery from any previous instance (since during short
170 : : * tests it's very likely that chunks seq_id will be in line between new head md and old VSS)
171 : : */
172 : 5 : ftl_nv_cache_scrub(dev, user_clear_cb, mngt);
173 : : } else {
174 : 17 : ftl_mngt_skip_step(mngt);
175 : : }
176 : 22 : }
177 : :
178 : : void
179 : 22 : ftl_mngt_finalize_startup(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
180 : : {
181 [ - + ]: 22 : if (ftl_bitmap_find_first_set(dev->trim_map, 0, UINT64_MAX) != UINT64_MAX) {
182 : 0 : dev->trim_in_progress = true;
183 : : }
184 : :
185 : 22 : ftl_property_register(dev, "superblock_version", &dev->sb->header.version,
186 : : sizeof(dev->sb->header.version), NULL, NULL,
187 : : ftl_property_dump_uint64, NULL, NULL, false);
188 : :
189 : : /* Clear the limit applications as they're incremented incorrectly by
190 : : * the initialization code.
191 : : */
192 [ - + ]: 22 : memset(dev->stats.limits, 0, sizeof(dev->stats.limits));
193 : 22 : dev->initialized = 1;
194 : 22 : dev->sb_shm->shm_ready = true;
195 : :
196 : 22 : ftl_l2p_resume(dev);
197 : 22 : ftl_reloc_resume(dev->reloc);
198 : 22 : ftl_writer_resume(&dev->writer_user);
199 : 22 : ftl_writer_resume(&dev->writer_gc);
200 : 22 : ftl_nv_cache_resume(&dev->nv_cache);
201 : :
202 : 22 : ftl_mngt_next_step(mngt);
203 : 22 : }
204 : :
205 : : void
206 : 22 : ftl_mngt_start_core_poller(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
207 : : {
208 : 22 : dev->core_poller = SPDK_POLLER_REGISTER(ftl_core_poller, dev, 0);
209 [ - + ]: 22 : if (!dev->core_poller) {
210 [ # # ]: 0 : FTL_ERRLOG(dev, "Unable to register core poller\n");
211 : 0 : ftl_mngt_fail_step(mngt);
212 : 0 : return;
213 : : }
214 : :
215 : 22 : ftl_mngt_next_step(mngt);
216 : : }
217 : :
218 : : void
219 : 128090 : ftl_mngt_stop_core_poller(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
220 : : {
221 : 128090 : dev->halt = true;
222 : :
223 [ + + ]: 128090 : if (dev->core_poller) {
224 : 128068 : ftl_mngt_continue_step(mngt);
225 : : } else {
226 : 22 : ftl_mngt_next_step(mngt);
227 : : }
228 : 128090 : }
229 : :
230 : : void
231 : 22 : ftl_mngt_dump_stats(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
232 : : {
233 : 22 : ftl_dev_dump_bands(dev);
234 : 22 : ftl_dev_dump_stats(dev);
235 : 22 : ftl_mngt_next_step(mngt);
236 : 22 : }
237 : :
238 : : void
239 : 22 : ftl_mngt_init_vld_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
240 : : {
241 : 22 : struct ftl_md *valid_map_md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_VALID_MAP];
242 : :
243 : 22 : dev->valid_map = ftl_bitmap_create(ftl_md_get_buffer(valid_map_md),
244 : : ftl_md_get_buffer_size(valid_map_md));
245 [ - + ]: 22 : if (!dev->valid_map) {
246 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to create valid map\n");
247 : 0 : ftl_mngt_fail_step(mngt);
248 : 0 : return;
249 : : }
250 : :
251 : 22 : ftl_mngt_next_step(mngt);
252 : : }
253 : :
254 : : void
255 : 22 : ftl_mngt_deinit_vld_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
256 : : {
257 [ + - ]: 22 : if (dev->valid_map) {
258 : 22 : ftl_bitmap_destroy(dev->valid_map);
259 : 22 : dev->valid_map = NULL;
260 : : }
261 : :
262 : 22 : ftl_mngt_next_step(mngt);
263 : 22 : }
264 : : void
265 : 22 : ftl_mngt_init_trim_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
266 : : {
267 : 22 : uint64_t num_l2p_pages = spdk_divide_round_up(dev->num_lbas, dev->layout.l2p.lbas_in_page);
268 : 22 : uint64_t map_blocks = ftl_bitmap_bits_to_blocks(num_l2p_pages);
269 : :
270 : 22 : dev->trim_map_md = ftl_md_create(dev,
271 : : map_blocks,
272 : : 0,
273 : : "trim_bitmap",
274 : : ftl_md_create_shm_flags(dev), NULL);
275 : :
276 [ - + ]: 22 : if (!dev->trim_map_md) {
277 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to create trim bitmap md\n");
278 : 0 : ftl_mngt_fail_step(mngt);
279 : 0 : return;
280 : : }
281 : :
282 : 22 : dev->trim_map = ftl_bitmap_create(ftl_md_get_buffer(dev->trim_map_md),
283 : : ftl_md_get_buffer_size(dev->trim_map_md));
284 : :
285 [ - + ]: 22 : if (!dev->trim_map) {
286 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to create trim map\n");
287 : 0 : ftl_mngt_fail_step(mngt);
288 : 0 : return;
289 : : }
290 : :
291 : 22 : ftl_mngt_next_step(mngt);
292 : : }
293 : :
294 : : static void
295 : 10 : trim_clear_cb(struct spdk_ftl_dev *dev, struct ftl_md *md, int status)
296 : : {
297 : 10 : struct ftl_mngt_process *mngt = md->owner.cb_ctx;
298 : :
299 [ - + ]: 10 : if (status) {
300 : 0 : ftl_mngt_fail_step(mngt);
301 : : } else {
302 : 10 : ftl_mngt_next_step(mngt);
303 : : }
304 : 10 : }
305 : :
306 : : void
307 : 5 : ftl_mngt_trim_metadata_clear(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
308 : : {
309 : 5 : struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_MD];
310 : :
311 : 5 : md->cb = trim_clear_cb;
312 : 5 : md->owner.cb_ctx = mngt;
313 : 5 : ftl_md_clear(md, 0, NULL);
314 : 5 : }
315 : :
316 : : void
317 : 5 : ftl_mngt_trim_log_clear(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
318 : : {
319 : 5 : struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_LOG];
320 : :
321 : 5 : md->cb = trim_clear_cb;
322 : 5 : md->owner.cb_ctx = mngt;
323 : 5 : ftl_md_clear(md, 0, NULL);
324 : 5 : }
325 : :
326 : : void
327 : 22 : ftl_mngt_deinit_trim_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
328 : : {
329 : 22 : ftl_bitmap_destroy(dev->trim_map);
330 : 22 : dev->trim_map = NULL;
331 : :
332 : 22 : ftl_md_destroy(dev->trim_map_md, ftl_md_destroy_shm_flags(dev));
333 : 22 : dev->trim_map_md = NULL;
334 : :
335 : 22 : ftl_mngt_next_step(mngt);
336 : 22 : }
337 : :
338 : : struct ftl_mngt_property_caller_ctx {
339 : : struct spdk_ftl_dev *dev;
340 : : struct spdk_jsonrpc_request *request;
341 : : spdk_ftl_fn cb_fn;
342 : : void *cb_arg;
343 : : struct spdk_thread *cb_thread;
344 : : const char *property;
345 : : const char *value;
346 : : size_t value_size;
347 : : };
348 : :
349 : : static void
350 : 3 : ftl_get_properties_cb(void *arg)
351 : : {
352 : 3 : struct ftl_mngt_property_caller_ctx *cctx = arg;
353 : :
354 : 3 : cctx->cb_fn(cctx->cb_arg, 0);
355 : 3 : free(cctx);
356 : 3 : }
357 : :
358 : : static void
359 : 3 : ftl_get_properties_msg(void *arg)
360 : : {
361 : 3 : struct ftl_mngt_property_caller_ctx *cctx = arg;
362 : : int rc;
363 : :
364 : 3 : ftl_property_dump(cctx->dev, cctx->request);
365 : 3 : rc = spdk_thread_send_msg(cctx->cb_thread, ftl_get_properties_cb, cctx);
366 [ - + ]: 3 : ftl_bug(rc);
367 : 3 : }
368 : :
369 : : int
370 : 3 : spdk_ftl_get_properties(struct spdk_ftl_dev *dev, struct spdk_jsonrpc_request *request,
371 : : spdk_ftl_fn cb_fn, void *cb_arg)
372 : : {
373 : : int rc;
374 : 3 : struct ftl_mngt_property_caller_ctx *ctx = calloc(1, sizeof(*ctx));
375 : :
376 [ - + ]: 3 : if (ctx == NULL) {
377 : 0 : return -ENOMEM;
378 : : }
379 : 3 : ctx->dev = dev;
380 : 3 : ctx->request = request;
381 : 3 : ctx->cb_fn = cb_fn;
382 : 3 : ctx->cb_arg = cb_arg;
383 : 3 : ctx->cb_thread = spdk_get_thread();
384 : :
385 : 3 : rc = spdk_thread_send_msg(dev->core_thread, ftl_get_properties_msg, ctx);
386 [ - + ]: 3 : if (rc) {
387 : 0 : free(ctx);
388 : 0 : return rc;
389 : : }
390 : :
391 : 3 : return 0;
392 : : }
393 : :
394 : : struct ftl_set_property_process_ctx {
395 : : void *value;
396 : : size_t value_size;
397 : : };
398 : :
399 : : static void
400 : 3 : ftl_mngt_set_property_decode(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
401 : : {
402 : 3 : struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
403 : 3 : struct ftl_mngt_property_caller_ctx *cctx = ftl_mngt_get_caller_ctx(mngt);
404 : :
405 [ - + ]: 3 : if (ftl_property_decode(dev, cctx->property, cctx->value, cctx->value_size,
406 : : &pctx->value, &pctx->value_size)) {
407 : 0 : ftl_mngt_fail_step(mngt);
408 : : } else {
409 : 3 : ftl_mngt_next_step(mngt);
410 : : }
411 : 3 : }
412 : :
413 : : static void
414 : 3 : ftl_mngt_set_property(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
415 : : {
416 : 3 : struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
417 : 3 : struct ftl_mngt_property_caller_ctx *cctx = ftl_mngt_get_caller_ctx(mngt);
418 : :
419 [ - + ]: 3 : if (ftl_property_set(dev, mngt, cctx->property, pctx->value, pctx->value_size)) {
420 : 0 : ftl_mngt_fail_step(mngt);
421 : : }
422 : 3 : }
423 : :
424 : : static void
425 : 3 : ftl_mngt_set_property_cleanup(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
426 : : {
427 : 3 : struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
428 : 3 : free(pctx->value);
429 : 3 : pctx->value = NULL;
430 : 3 : pctx->value_size = 0;
431 : 3 : ftl_mngt_next_step(mngt);
432 : 3 : }
433 : :
434 : : static const struct ftl_mngt_process_desc desc_set_property = {
435 : : .name = "Set FTL property",
436 : : .ctx_size = sizeof(struct ftl_set_property_process_ctx),
437 : : .steps = {
438 : : {
439 : : .name = "Decode property",
440 : : .action = ftl_mngt_set_property_decode,
441 : : .cleanup = ftl_mngt_set_property_cleanup
442 : : },
443 : : {
444 : : .name = "Set property",
445 : : .action = ftl_mngt_set_property,
446 : : .cleanup = ftl_mngt_set_property_cleanup
447 : : },
448 : : {
449 : : .name = "Property setting cleanup",
450 : : .action = ftl_mngt_set_property_cleanup,
451 : : },
452 : : {}
453 : : }
454 : : };
455 : :
456 : : static void
457 : 3 : ftl_mngt_property_caller_cb(struct spdk_ftl_dev *dev, void *ctx, int status)
458 : : {
459 : 3 : struct ftl_mngt_property_caller_ctx *cctx = ctx;
460 : :
461 : 3 : cctx->cb_fn(cctx->cb_arg, status);
462 : 3 : free(cctx);
463 : 3 : }
464 : :
465 : : int
466 : 3 : spdk_ftl_set_property(struct spdk_ftl_dev *dev,
467 : : const char *property, const char *value, size_t value_size,
468 : : spdk_ftl_fn cb_fn, void *cb_arg)
469 : : {
470 : : int rc;
471 : 3 : struct ftl_mngt_property_caller_ctx *cctx = calloc(1, sizeof(*cctx));
472 : :
473 [ - + ]: 3 : if (cctx == NULL) {
474 : 0 : return -EAGAIN;
475 : : }
476 : 3 : cctx->cb_fn = cb_fn;
477 : 3 : cctx->cb_arg = cb_arg;
478 : 3 : cctx->property = property;
479 : 3 : cctx->value = value;
480 : 3 : cctx->value_size = value_size;
481 : :
482 : 3 : rc = ftl_mngt_process_execute(dev, &desc_set_property, ftl_mngt_property_caller_cb, cctx);
483 [ - + ]: 3 : if (rc) {
484 : 0 : free(cctx);
485 : : }
486 : :
487 : 3 : return rc;
488 : : }
|