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, struct ftl_md *md, int status)
146 : : {
147 : 5 : struct ftl_mngt_process *mngt = md->owner.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 : 5 : ftl_mngt_scrub_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
159 : : {
160 : 5 : struct ftl_layout_region *region = ftl_layout_region_get(dev, FTL_LAYOUT_REGION_TYPE_DATA_NVC);
161 : 5 : struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_DATA_NVC];
162 : 5 : union ftl_md_vss vss;
163 : :
164 [ + - ]: 5 : FTL_NOTICELOG(dev, "First startup needs to scrub nv cache data region, this may take some time.\n");
165 [ + - ]: 5 : FTL_NOTICELOG(dev, "Scrubbing %lluGiB\n", region->current.blocks * FTL_BLOCK_SIZE / GiB);
166 : :
167 : : /* Need to scrub user data, so in case of dirty shutdown the recovery won't
168 : : * pull in data during open chunks recovery from any previous instance (since during short
169 : : * tests it's very likely that chunks seq_id will be in line between new head md and old VSS)
170 : : */
171 : 5 : md->cb = user_clear_cb;
172 : 5 : md->owner.cb_ctx = mngt;
173 : :
174 : 5 : vss.version.md_version = region->current.version;
175 : 5 : vss.nv_cache.lba = FTL_ADDR_INVALID;
176 : 5 : ftl_md_clear(md, 0, &vss);
177 : 5 : }
178 : :
179 : : void
180 : 22 : ftl_mngt_finalize_startup(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
181 : : {
182 [ - + ]: 22 : if (ftl_bitmap_find_first_set(dev->unmap_map, 0, UINT64_MAX) != UINT64_MAX) {
183 : 0 : dev->unmap_in_progress = true;
184 : : }
185 : :
186 : 22 : ftl_property_register(dev, "superblock_version", &dev->sb->header.version,
187 : : sizeof(dev->sb->header.version), NULL, NULL,
188 : : ftl_property_dump_uint64, NULL, NULL, false);
189 : :
190 : : /* Clear the limit applications as they're incremented incorrectly by
191 : : * the initialization code.
192 : : */
193 [ - + ]: 22 : memset(dev->stats.limits, 0, sizeof(dev->stats.limits));
194 : 22 : dev->initialized = 1;
195 : 22 : dev->sb_shm->shm_ready = true;
196 : :
197 : 22 : ftl_l2p_resume(dev);
198 : 22 : ftl_reloc_resume(dev->reloc);
199 : 22 : ftl_writer_resume(&dev->writer_user);
200 : 22 : ftl_writer_resume(&dev->writer_gc);
201 : 22 : ftl_nv_cache_resume(&dev->nv_cache);
202 : :
203 : 22 : ftl_mngt_next_step(mngt);
204 : 22 : }
205 : :
206 : : void
207 : 22 : ftl_mngt_start_core_poller(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
208 : : {
209 : 22 : dev->core_poller = SPDK_POLLER_REGISTER(ftl_core_poller, dev, 0);
210 [ - + ]: 22 : if (!dev->core_poller) {
211 [ # # ]: 0 : FTL_ERRLOG(dev, "Unable to register core poller\n");
212 : 0 : ftl_mngt_fail_step(mngt);
213 : 0 : return;
214 : : }
215 : :
216 : 22 : ftl_mngt_next_step(mngt);
217 : : }
218 : :
219 : : void
220 : 164822 : ftl_mngt_stop_core_poller(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
221 : : {
222 : 164822 : dev->halt = true;
223 : :
224 [ + + ]: 164822 : if (dev->core_poller) {
225 : 164800 : ftl_mngt_continue_step(mngt);
226 : : } else {
227 : 22 : ftl_mngt_next_step(mngt);
228 : : }
229 : 164822 : }
230 : :
231 : : void
232 : 22 : ftl_mngt_dump_stats(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
233 : : {
234 : 22 : ftl_dev_dump_bands(dev);
235 : 22 : ftl_dev_dump_stats(dev);
236 : 22 : ftl_mngt_next_step(mngt);
237 : 22 : }
238 : :
239 : : void
240 : 22 : ftl_mngt_init_vld_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
241 : : {
242 : 22 : struct ftl_md *valid_map_md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_VALID_MAP];
243 : :
244 : 22 : dev->valid_map = ftl_bitmap_create(ftl_md_get_buffer(valid_map_md),
245 : : ftl_md_get_buffer_size(valid_map_md));
246 [ - + ]: 22 : if (!dev->valid_map) {
247 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to create valid map\n");
248 : 0 : ftl_mngt_fail_step(mngt);
249 : 0 : return;
250 : : }
251 : :
252 : 22 : ftl_mngt_next_step(mngt);
253 : : }
254 : :
255 : : void
256 : 22 : ftl_mngt_deinit_vld_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
257 : : {
258 [ + - ]: 22 : if (dev->valid_map) {
259 : 22 : ftl_bitmap_destroy(dev->valid_map);
260 : 22 : dev->valid_map = NULL;
261 : : }
262 : :
263 : 22 : ftl_mngt_next_step(mngt);
264 : 22 : }
265 : : void
266 : 22 : ftl_mngt_init_unmap_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
267 : : {
268 : 22 : uint64_t num_l2p_pages = spdk_divide_round_up(dev->num_lbas, dev->layout.l2p.lbas_in_page);
269 : 22 : uint64_t map_blocks = ftl_bitmap_bits_to_blocks(num_l2p_pages);
270 : :
271 : 22 : dev->unmap_map_md = ftl_md_create(dev,
272 : : map_blocks,
273 : : 0,
274 : : "trim_bitmap",
275 : : ftl_md_create_shm_flags(dev), NULL);
276 : :
277 [ - + ]: 22 : if (!dev->unmap_map_md) {
278 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to create trim bitmap md\n");
279 : 0 : ftl_mngt_fail_step(mngt);
280 : 0 : return;
281 : : }
282 : :
283 : 22 : dev->unmap_map = ftl_bitmap_create(ftl_md_get_buffer(dev->unmap_map_md),
284 : : ftl_md_get_buffer_size(dev->unmap_map_md));
285 : :
286 [ - + ]: 22 : if (!dev->unmap_map) {
287 [ # # ]: 0 : FTL_ERRLOG(dev, "Failed to create unmap map\n");
288 : 0 : ftl_mngt_fail_step(mngt);
289 : 0 : return;
290 : : }
291 : :
292 : 22 : ftl_mngt_next_step(mngt);
293 : : }
294 : :
295 : : static void
296 : 5 : unmap_clear_cb(struct spdk_ftl_dev *dev, struct ftl_md *md, int status)
297 : : {
298 : 5 : struct ftl_mngt_process *mngt = md->owner.cb_ctx;
299 : :
300 [ - + ]: 5 : if (status) {
301 [ # # ]: 0 : FTL_ERRLOG(dev, "ERROR of clearing trim unmap\n");
302 : 0 : ftl_mngt_fail_step(mngt);
303 : : } else {
304 : 5 : ftl_mngt_next_step(mngt);
305 : : }
306 : 5 : }
307 : :
308 : : void
309 : 5 : ftl_mngt_unmap_clear(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
310 : : {
311 : 5 : struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_MD];
312 : :
313 : 5 : md->cb = unmap_clear_cb;
314 : 5 : md->owner.cb_ctx = mngt;
315 : :
316 : 5 : ftl_md_clear(md, 0, NULL);
317 : 5 : }
318 : :
319 : : void
320 : 22 : ftl_mngt_deinit_unmap_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
321 : : {
322 : 22 : ftl_bitmap_destroy(dev->unmap_map);
323 : 22 : dev->unmap_map = NULL;
324 : :
325 : 22 : ftl_md_destroy(dev->unmap_map_md, ftl_md_destroy_shm_flags(dev));
326 : 22 : dev->unmap_map_md = NULL;
327 : :
328 : 22 : ftl_mngt_next_step(mngt);
329 : 22 : }
330 : :
331 : : struct ftl_mngt_property_caller_ctx {
332 : : struct spdk_ftl_dev *dev;
333 : : struct spdk_jsonrpc_request *request;
334 : : spdk_ftl_fn cb_fn;
335 : : void *cb_arg;
336 : : struct spdk_thread *cb_thread;
337 : : const char *property;
338 : : const char *value;
339 : : size_t value_size;
340 : : };
341 : :
342 : : static void
343 : 3 : ftl_get_properties_cb(void *arg)
344 : : {
345 : 3 : struct ftl_mngt_property_caller_ctx *cctx = arg;
346 : :
347 : 3 : cctx->cb_fn(cctx->cb_arg, 0);
348 : 3 : free(cctx);
349 : 3 : }
350 : :
351 : : static void
352 : 3 : ftl_get_properties_msg(void *arg)
353 : : {
354 : 3 : struct ftl_mngt_property_caller_ctx *cctx = arg;
355 : : int rc;
356 : :
357 : 3 : ftl_property_dump(cctx->dev, cctx->request);
358 : 3 : rc = spdk_thread_send_msg(cctx->cb_thread, ftl_get_properties_cb, cctx);
359 [ - + ]: 3 : ftl_bug(rc);
360 : 3 : }
361 : :
362 : : int
363 : 3 : spdk_ftl_get_properties(struct spdk_ftl_dev *dev, struct spdk_jsonrpc_request *request,
364 : : spdk_ftl_fn cb_fn, void *cb_arg)
365 : : {
366 : : int rc;
367 : 3 : struct ftl_mngt_property_caller_ctx *ctx = calloc(1, sizeof(*ctx));
368 : :
369 [ - + ]: 3 : if (ctx == NULL) {
370 : 0 : return -ENOMEM;
371 : : }
372 : 3 : ctx->dev = dev;
373 : 3 : ctx->request = request;
374 : 3 : ctx->cb_fn = cb_fn;
375 : 3 : ctx->cb_arg = cb_arg;
376 : 3 : ctx->cb_thread = spdk_get_thread();
377 : :
378 : 3 : rc = spdk_thread_send_msg(dev->core_thread, ftl_get_properties_msg, ctx);
379 [ - + ]: 3 : if (rc) {
380 : 0 : free(ctx);
381 : 0 : return rc;
382 : : }
383 : :
384 : 3 : return 0;
385 : : }
386 : :
387 : : struct ftl_set_property_process_ctx {
388 : : void *value;
389 : : size_t value_size;
390 : : };
391 : :
392 : : static void
393 : 3 : ftl_mngt_set_property_decode(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
394 : : {
395 : 3 : struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
396 : 3 : struct ftl_mngt_property_caller_ctx *cctx = ftl_mngt_get_caller_ctx(mngt);
397 : :
398 [ - + ]: 3 : if (ftl_property_decode(dev, cctx->property, cctx->value, cctx->value_size,
399 : : &pctx->value, &pctx->value_size)) {
400 : 0 : ftl_mngt_fail_step(mngt);
401 : : } else {
402 : 3 : ftl_mngt_next_step(mngt);
403 : : }
404 : 3 : }
405 : :
406 : : static void
407 : 3 : ftl_mngt_set_property(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
408 : : {
409 : 3 : struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
410 : 3 : struct ftl_mngt_property_caller_ctx *cctx = ftl_mngt_get_caller_ctx(mngt);
411 : :
412 [ - + ]: 3 : if (ftl_property_set(dev, mngt, cctx->property, pctx->value, pctx->value_size)) {
413 : 0 : ftl_mngt_fail_step(mngt);
414 : : }
415 : 3 : }
416 : :
417 : : static void
418 : 3 : ftl_mngt_set_property_cleanup(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
419 : : {
420 : 3 : struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
421 : 3 : free(pctx->value);
422 : 3 : pctx->value = NULL;
423 : 3 : pctx->value_size = 0;
424 : 3 : ftl_mngt_next_step(mngt);
425 : 3 : }
426 : :
427 : : static const struct ftl_mngt_process_desc desc_set_property = {
428 : : .name = "Set FTL property",
429 : : .ctx_size = sizeof(struct ftl_set_property_process_ctx),
430 : : .steps = {
431 : : {
432 : : .name = "Decode property",
433 : : .action = ftl_mngt_set_property_decode,
434 : : .cleanup = ftl_mngt_set_property_cleanup
435 : : },
436 : : {
437 : : .name = "Set property",
438 : : .action = ftl_mngt_set_property,
439 : : .cleanup = ftl_mngt_set_property_cleanup
440 : : },
441 : : {
442 : : .name = "Property setting cleanup",
443 : : .action = ftl_mngt_set_property_cleanup,
444 : : },
445 : : {}
446 : : }
447 : : };
448 : :
449 : : static void
450 : 3 : ftl_mngt_property_caller_cb(struct spdk_ftl_dev *dev, void *ctx, int status)
451 : : {
452 : 3 : struct ftl_mngt_property_caller_ctx *cctx = ctx;
453 : :
454 : 3 : cctx->cb_fn(cctx->cb_arg, status);
455 : 3 : free(cctx);
456 : 3 : }
457 : :
458 : : int
459 : 3 : spdk_ftl_set_property(struct spdk_ftl_dev *dev,
460 : : const char *property, const char *value, size_t value_size,
461 : : spdk_ftl_fn cb_fn, void *cb_arg)
462 : : {
463 : : int rc;
464 : 3 : struct ftl_mngt_property_caller_ctx *cctx = calloc(1, sizeof(*cctx));
465 : :
466 [ - + ]: 3 : if (cctx == NULL) {
467 : 0 : return -EAGAIN;
468 : : }
469 : 3 : cctx->cb_fn = cb_fn;
470 : 3 : cctx->cb_arg = cb_arg;
471 : 3 : cctx->property = property;
472 : 3 : cctx->value = value;
473 : 3 : cctx->value_size = value_size;
474 : :
475 : 3 : rc = ftl_mngt_process_execute(dev, &desc_set_property, ftl_mngt_property_caller_cb, cctx);
476 [ - + ]: 3 : if (rc) {
477 : 0 : free(cctx);
478 : : }
479 : :
480 : 3 : return rc;
481 : : }
|