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 "spdk/queue.h"
7 : : #include "spdk/assert.h"
8 : : #include "spdk/env.h"
9 : :
10 : : #include "ftl_mngt.h"
11 : : #include "ftl_core.h"
12 : :
13 : : struct ftl_mngt_step_status {
14 : : uint64_t start;
15 : : uint64_t stop;
16 : : int status;
17 : : int silent;
18 : : TAILQ_ENTRY(ftl_mngt_step) entry;
19 : : };
20 : :
21 : : struct ftl_mngt_step {
22 : : void *ctx;
23 : : const struct ftl_mngt_step_desc *desc;
24 : : struct ftl_mngt_step_status action;
25 : : struct ftl_mngt_step_status rollback;
26 : : };
27 : :
28 : : struct ftl_mngt_process {
29 : : struct spdk_ftl_dev *dev;
30 : : int status;
31 : : bool silent;
32 : : bool rollback;
33 : : bool continuing;
34 : : struct {
35 : : ftl_mngt_completion cb;
36 : : void *cb_ctx;
37 : : struct spdk_thread *thread;
38 : : } caller;
39 : : void *ctx;
40 : : uint64_t tsc_start;
41 : : uint64_t tsc_stop;
42 : : const struct ftl_mngt_process_desc *desc;
43 : : TAILQ_HEAD(, ftl_mngt_step) action_queue_todo;
44 : : TAILQ_HEAD(, ftl_mngt_step) action_queue_done;
45 : : TAILQ_HEAD(, ftl_mngt_step) rollback_queue_todo;
46 : : TAILQ_HEAD(, ftl_mngt_step) rollback_queue_done;
47 : : struct {
48 : : struct ftl_mngt_step step;
49 : : struct ftl_mngt_step_desc desc;
50 : : } cleanup;
51 : : struct ftl_mng_tracer *tracer;
52 : : };
53 : :
54 : : static void action_next(struct ftl_mngt_process *mngt);
55 : : static void action_msg(void *ctx);
56 : : static void action_execute(struct ftl_mngt_process *mngt);
57 : : static void action_done(struct ftl_mngt_process *mngt, int status);
58 : : static void rollback_next(struct ftl_mngt_process *mngt);
59 : : static void rollback_msg(void *ctx);
60 : : static void rollback_execute(struct ftl_mngt_process *mngt);
61 : : static void rollback_done(struct ftl_mngt_process *mngt, int status);
62 : :
63 : : static inline struct ftl_mngt_step *
64 : 1869 : get_current_step(struct ftl_mngt_process *mngt)
65 : : {
66 [ + + + + ]: 1869 : if (!mngt->rollback) {
67 : 1807 : return TAILQ_FIRST(&mngt->action_queue_todo);
68 : : } else {
69 : 62 : return TAILQ_FIRST(&mngt->rollback_queue_todo);
70 : : }
71 : : }
72 : :
73 : : static int
74 : 1666 : init_step(struct ftl_mngt_process *mngt,
75 : : const struct ftl_mngt_step_desc *desc)
76 : : {
77 : : struct ftl_mngt_step *step;
78 : :
79 : 1666 : step = calloc(1, sizeof(*step));
80 [ - + ]: 1666 : if (!step) {
81 : 0 : return -ENOMEM;
82 : : }
83 : :
84 : : /* Initialize the step's argument */
85 [ + + ]: 1666 : if (desc->ctx_size) {
86 : 30 : step->ctx = calloc(1, desc->ctx_size);
87 [ - + ]: 30 : if (!step->ctx) {
88 : 0 : free(step);
89 : 0 : return -ENOMEM;
90 : : }
91 : : }
92 : 1666 : step->desc = desc;
93 : 1666 : TAILQ_INSERT_TAIL(&mngt->action_queue_todo, step, action.entry);
94 : :
95 : 1666 : return 0;
96 : : }
97 : :
98 : : static void
99 : 255 : free_mngt(struct ftl_mngt_process *mngt)
100 : : {
101 : 255 : TAILQ_HEAD(, ftl_mngt_step) steps;
102 : :
103 [ - + ]: 255 : if (!mngt) {
104 : 0 : return;
105 : : }
106 : :
107 : 255 : TAILQ_INIT(&steps);
108 [ + + ]: 255 : TAILQ_CONCAT(&steps, &mngt->action_queue_todo, action.entry);
109 [ + + ]: 255 : TAILQ_CONCAT(&steps, &mngt->action_queue_done, action.entry);
110 : :
111 [ + + ]: 1921 : while (!TAILQ_EMPTY(&steps)) {
112 : 1666 : struct ftl_mngt_step *step = TAILQ_FIRST(&steps);
113 [ + + ]: 1666 : TAILQ_REMOVE(&steps, step, action.entry);
114 : :
115 : 1666 : free(step->ctx);
116 : 1666 : free(step);
117 : : }
118 : :
119 : 255 : free(mngt->ctx);
120 : 255 : free(mngt);
121 : : }
122 : :
123 : : static struct ftl_mngt_process *
124 : 255 : allocate_mngt(struct spdk_ftl_dev *dev, const struct ftl_mngt_process_desc *pdesc,
125 : : ftl_mngt_completion cb, void *cb_ctx, bool silent)
126 : : {
127 : : struct ftl_mngt_process *mngt;
128 : :
129 : : /* Initialize management process */
130 : 255 : mngt = calloc(1, sizeof(*mngt));
131 [ - + ]: 255 : if (!mngt) {
132 : 0 : goto error;
133 : : }
134 : 255 : mngt->dev = dev;
135 : 255 : mngt->silent = silent;
136 : 255 : mngt->caller.cb = cb;
137 : 255 : mngt->caller.cb_ctx = cb_ctx;
138 : 255 : mngt->caller.thread = spdk_get_thread();
139 : :
140 : : /* Initialize process context */
141 [ + + ]: 255 : if (pdesc->ctx_size) {
142 : 39 : mngt->ctx = calloc(1, pdesc->ctx_size);
143 [ - + ]: 39 : if (!mngt->ctx) {
144 : 0 : goto error;
145 : : }
146 : : }
147 : 255 : mngt->tsc_start = spdk_get_ticks();
148 : 255 : mngt->desc = pdesc;
149 : 255 : TAILQ_INIT(&mngt->action_queue_todo);
150 : 255 : TAILQ_INIT(&mngt->action_queue_done);
151 : 255 : TAILQ_INIT(&mngt->rollback_queue_todo);
152 : 255 : TAILQ_INIT(&mngt->rollback_queue_done);
153 : :
154 : 255 : return mngt;
155 : 0 : error:
156 : 0 : free_mngt(mngt);
157 : 0 : return NULL;
158 : : }
159 : :
160 : : static int
161 : 209 : _ftl_mngt_process_execute(struct spdk_ftl_dev *dev, const struct ftl_mngt_process_desc *pdesc,
162 : : ftl_mngt_completion cb, void *cb_ctx, bool silent)
163 : : {
164 : : const struct ftl_mngt_step_desc *sdesc;
165 : : struct ftl_mngt_process *mngt;
166 : 209 : int rc = 0;
167 : :
168 : 209 : mngt = allocate_mngt(dev, pdesc, cb, cb_ctx, silent);
169 [ - + ]: 209 : if (!mngt) {
170 : 0 : rc = -ENOMEM;
171 : 0 : goto error;
172 : : }
173 : :
174 [ + + ]: 209 : if (pdesc->error_handler) {
175 : : /* Initialize a step for error handler */
176 : 22 : mngt->cleanup.step.desc = &mngt->cleanup.desc;
177 : 22 : mngt->cleanup.desc.name = "Handle ERROR";
178 : 22 : mngt->cleanup.desc.cleanup = pdesc->error_handler;
179 : :
180 : : /* Queue error handler to the rollback queue, it will be executed at the end */
181 [ - + ]: 22 : TAILQ_INSERT_HEAD(&mngt->rollback_queue_todo, &mngt->cleanup.step,
182 : : rollback.entry);
183 : : }
184 : :
185 : : /* Initialize steps */
186 : 209 : sdesc = mngt->desc->steps;
187 [ + + ]: 1537 : while (sdesc->action) {
188 : 1328 : rc = init_step(mngt, sdesc);
189 [ - + ]: 1328 : if (rc) {
190 : 0 : goto error;
191 : : }
192 : 1328 : sdesc++;
193 : : }
194 : :
195 : 209 : action_execute(mngt);
196 : 209 : return 0;
197 : 0 : error:
198 : 0 : free_mngt(mngt);
199 : 0 : return rc;
200 : : }
201 : :
202 : : int
203 : 75 : ftl_mngt_process_execute(struct spdk_ftl_dev *dev, const struct ftl_mngt_process_desc *pdesc,
204 : : ftl_mngt_completion cb, void *cb_ctx)
205 : : {
206 : 75 : return _ftl_mngt_process_execute(dev, pdesc, cb, cb_ctx, false);
207 : : }
208 : :
209 : : int
210 : 46 : ftl_mngt_process_rollback(struct spdk_ftl_dev *dev, const struct ftl_mngt_process_desc *pdesc,
211 : : ftl_mngt_completion cb, void *cb_ctx)
212 : : {
213 : : const struct ftl_mngt_step_desc *sdesc;
214 : : struct ftl_mngt_process *mngt;
215 : 46 : int rc = 0;
216 : :
217 : 46 : mngt = allocate_mngt(dev, pdesc, cb, cb_ctx, true);
218 [ - + ]: 46 : if (!mngt) {
219 : 0 : rc = -ENOMEM;
220 : 0 : goto error;
221 : : }
222 : :
223 : : /* Initialize steps for rollback */
224 : 46 : sdesc = mngt->desc->steps;
225 [ + + ]: 542 : while (sdesc->action) {
226 [ + + ]: 496 : if (!sdesc->cleanup) {
227 : 158 : sdesc++;
228 : 158 : continue;
229 : : }
230 : 338 : rc = init_step(mngt, sdesc);
231 [ - + ]: 338 : if (rc) {
232 : 0 : goto error;
233 : : }
234 : 338 : sdesc++;
235 : : }
236 : :
237 : : /* Build rollback list */
238 : : struct ftl_mngt_step *step;
239 [ + + ]: 384 : TAILQ_FOREACH(step, &mngt->action_queue_todo, action.entry) {
240 : 338 : step->action.silent = true;
241 [ + + ]: 338 : TAILQ_INSERT_HEAD(&mngt->rollback_queue_todo, step,
242 : : rollback.entry);
243 : : }
244 : :
245 : 46 : mngt->rollback = true;
246 : 46 : rollback_execute(mngt);
247 : 46 : return 0;
248 : 0 : error:
249 : 0 : free_mngt(mngt);
250 : 0 : return rc;
251 : : }
252 : :
253 : : struct spdk_ftl_dev *
254 : 122 : ftl_mngt_get_dev(struct ftl_mngt_process *mngt)
255 : : {
256 : 122 : return mngt->dev;
257 : : }
258 : :
259 : : int
260 : 39 : ftl_mngt_alloc_step_ctx(struct ftl_mngt_process *mngt, size_t size)
261 : : {
262 : 39 : struct ftl_mngt_step *step = get_current_step(mngt);
263 : 39 : void *arg = calloc(1, size);
264 : :
265 [ - + ]: 39 : if (!arg) {
266 : 0 : return -ENOMEM;
267 : : }
268 : :
269 : 39 : free(step->ctx);
270 : 39 : step->ctx = arg;
271 : :
272 : 39 : return 0;
273 : : }
274 : :
275 : : void *
276 : 1643 : ftl_mngt_get_step_ctx(struct ftl_mngt_process *mngt)
277 : : {
278 : 1643 : return get_current_step(mngt)->ctx;
279 : : }
280 : :
281 : : void *
282 : 57 : ftl_mngt_get_process_ctx(struct ftl_mngt_process *mngt)
283 : : {
284 : 57 : return mngt->ctx;
285 : : }
286 : :
287 : : void *
288 : 26 : ftl_mngt_get_caller_ctx(struct ftl_mngt_process *mngt)
289 : : {
290 : 26 : return mngt->caller.cb_ctx;
291 : : }
292 : :
293 : : void
294 : 1662 : ftl_mngt_next_step(struct ftl_mngt_process *mngt)
295 : : {
296 [ + + + + ]: 1662 : if (false == mngt->rollback) {
297 : 1304 : action_next(mngt);
298 : : } else {
299 : 358 : rollback_next(mngt);
300 : : }
301 : 1662 : }
302 : :
303 : : void
304 : 23 : ftl_mngt_skip_step(struct ftl_mngt_process *mngt)
305 : : {
306 [ - + + + ]: 23 : if (mngt->rollback) {
307 : 22 : get_current_step(mngt)->rollback.silent = true;
308 : : } else {
309 : 1 : get_current_step(mngt)->action.silent = true;
310 : : }
311 : 23 : ftl_mngt_next_step(mngt);
312 : 23 : }
313 : :
314 : : void
315 : 133511 : ftl_mngt_continue_step(struct ftl_mngt_process *mngt)
316 : : {
317 : :
318 [ + + + - ]: 133511 : if (!mngt->continuing) {
319 [ + + + + ]: 133511 : if (false == mngt->rollback) {
320 : 133495 : action_execute(mngt);
321 : : } else {
322 : 16 : rollback_execute(mngt);
323 : : }
324 : : }
325 : :
326 : 133511 : mngt->continuing = true;
327 : 133511 : }
328 : :
329 : : static void
330 : 164 : child_cb(struct spdk_ftl_dev *dev, void *ctx, int status)
331 : : {
332 : 164 : struct ftl_mngt_process *parent = ctx;
333 : :
334 [ + + ]: 164 : if (status) {
335 : 4 : ftl_mngt_fail_step(parent);
336 : : } else {
337 : 160 : ftl_mngt_next_step(parent);
338 : : }
339 : 164 : }
340 : :
341 : : void
342 : 134 : ftl_mngt_call_process(struct ftl_mngt_process *mngt,
343 : : const struct ftl_mngt_process_desc *pdesc)
344 : : {
345 [ - + ]: 134 : if (_ftl_mngt_process_execute(mngt->dev, pdesc, child_cb, mngt, true)) {
346 : 0 : ftl_mngt_fail_step(mngt);
347 : : } else {
348 [ + + + + ]: 134 : if (mngt->rollback) {
349 : 4 : get_current_step(mngt)->rollback.silent = true;
350 : : } else {
351 : 130 : get_current_step(mngt)->action.silent = true;
352 : : }
353 : : }
354 : 134 : }
355 : :
356 : : void
357 : 30 : ftl_mngt_call_process_rollback(struct ftl_mngt_process *mngt,
358 : : const struct ftl_mngt_process_desc *pdesc)
359 : : {
360 [ - + ]: 30 : if (ftl_mngt_process_rollback(mngt->dev, pdesc, child_cb, mngt)) {
361 : 0 : ftl_mngt_fail_step(mngt);
362 : : } else {
363 [ + + + + ]: 30 : if (mngt->rollback) {
364 : 4 : get_current_step(mngt)->rollback.silent = true;
365 : : } else {
366 : 26 : get_current_step(mngt)->action.silent = true;
367 : : }
368 : : }
369 : 30 : }
370 : :
371 : : void
372 : 12 : ftl_mngt_fail_step(struct ftl_mngt_process *mngt)
373 : : {
374 : 12 : mngt->status = -1;
375 : :
376 [ + + + - ]: 12 : if (false == mngt->rollback) {
377 : 12 : action_done(mngt, -1);
378 : : } else {
379 : 0 : rollback_done(mngt, -1);
380 : : }
381 : :
382 : 12 : mngt->rollback = true;
383 : 12 : rollback_execute(mngt);
384 : 12 : }
385 : :
386 : : static inline float
387 : 1562 : tsc_to_ms(uint64_t tsc)
388 : : {
389 : 1562 : float ms = tsc;
390 : 1562 : ms /= (float)spdk_get_ticks_hz();
391 : 1562 : ms *= 1000.0;
392 : 1562 : return ms;
393 : : }
394 : :
395 : : static void
396 : 1674 : trace_step(struct spdk_ftl_dev *dev, struct ftl_mngt_step *step, bool rollback)
397 : : {
398 : : uint64_t duration;
399 [ + + ]: 1674 : const char *what = rollback ? "Rollback" : "Action";
400 [ + + ]: 1674 : int silent = rollback ? step->rollback.silent : step->action.silent;
401 : :
402 [ + + ]: 1674 : if (silent) {
403 : 187 : return;
404 : : }
405 : :
406 [ + - ]: 1487 : FTL_NOTICELOG(dev, "%s\n", what);
407 [ + - ]: 1487 : FTL_NOTICELOG(dev, "\t name: %s\n", step->desc->name);
408 : 1487 : duration = step->action.stop - step->action.start;
409 [ + - ]: 1487 : FTL_NOTICELOG(dev, "\t duration: %.3f ms\n", tsc_to_ms(duration));
410 [ + - ]: 1487 : FTL_NOTICELOG(dev, "\t status: %d\n", step->action.status);
411 : : }
412 : :
413 : : static void
414 : 255 : finish_msg(void *ctx)
415 : : {
416 : 255 : struct ftl_mngt_process *mngt = ctx;
417 : 255 : char *devname = NULL;
418 : :
419 [ + + + + : 255 : if (!mngt->silent && mngt->dev->conf.name) {
+ + ]
420 : : /* the callback below can free the device so make a temp copy of the name */
421 [ - + ]: 51 : devname = strdup(mngt->dev->conf.name);
422 : : }
423 : :
424 : 255 : mngt->caller.cb(mngt->dev, mngt->caller.cb_ctx, mngt->status);
425 : :
426 [ + + + + ]: 255 : if (!mngt->silent) {
427 : : /* TODO: refactor the logging macros to pass just the name instead of device */
428 : 75 : struct spdk_ftl_dev tmpdev = {
429 : : .conf = {
430 : : .name = devname
431 : : }
432 : : };
433 : :
434 : 75 : FTL_NOTICELOG(&tmpdev, "Management process finished, name '%s', duration = %.3f ms, result %d\n",
435 : : mngt->desc->name,
436 : : tsc_to_ms(mngt->tsc_stop - mngt->tsc_start),
437 : : mngt->status);
438 : : }
439 : 255 : free_mngt(mngt);
440 : 255 : free(devname);
441 : 255 : }
442 : :
443 : : void
444 : 255 : ftl_mngt_finish(struct ftl_mngt_process *mngt)
445 : : {
446 : 255 : mngt->tsc_stop = spdk_get_ticks();
447 : 255 : spdk_thread_send_msg(mngt->caller.thread, finish_msg, mngt);
448 : 255 : }
449 : :
450 : : /*
451 : : * Actions
452 : : */
453 : : static void
454 : 1304 : action_next(struct ftl_mngt_process *mngt)
455 : : {
456 [ - + ]: 1304 : if (TAILQ_EMPTY(&mngt->action_queue_todo)) {
457 : : /* Nothing to do, finish the management process */
458 : 0 : ftl_mngt_finish(mngt);
459 : 0 : return;
460 : : } else {
461 : 1304 : action_done(mngt, 0);
462 : 1304 : action_execute(mngt);
463 : : }
464 : : }
465 : :
466 : : static void
467 : 135008 : action_msg(void *ctx)
468 : : {
469 : 135008 : struct ftl_mngt_process *mngt = ctx;
470 : : struct ftl_mngt_step *step;
471 : :
472 : 135008 : mngt->continuing = false;
473 : :
474 [ + + ]: 135008 : if (TAILQ_EMPTY(&mngt->action_queue_todo)) {
475 : 197 : ftl_mngt_finish(mngt);
476 : 197 : return;
477 : : }
478 : :
479 : 134811 : step = TAILQ_FIRST(&mngt->action_queue_todo);
480 [ + + ]: 134811 : if (!step->action.start) {
481 : 1332 : step->action.start = spdk_get_ticks();
482 : : }
483 : 134811 : step->desc->action(mngt->dev, mngt);
484 : : }
485 : :
486 : : static void
487 : 135008 : action_execute(struct ftl_mngt_process *mngt)
488 : : {
489 : 135008 : spdk_thread_send_msg(mngt->dev->core_thread, action_msg, mngt);
490 : 135008 : }
491 : :
492 : : static void
493 : 1316 : action_done(struct ftl_mngt_process *mngt, int status)
494 : : {
495 : : struct ftl_mngt_step *step;
496 : :
497 [ - + ]: 1316 : assert(!TAILQ_EMPTY(&mngt->action_queue_todo));
498 : 1316 : step = TAILQ_FIRST(&mngt->action_queue_todo);
499 [ + + ]: 1316 : TAILQ_REMOVE(&mngt->action_queue_todo, step, action.entry);
500 : :
501 : 1316 : TAILQ_INSERT_TAIL(&mngt->action_queue_done, step, action.entry);
502 [ + + ]: 1316 : if (step->desc->cleanup) {
503 [ + + ]: 431 : TAILQ_INSERT_HEAD(&mngt->rollback_queue_todo, step,
504 : : rollback.entry);
505 : : }
506 : :
507 : 1316 : step->action.stop = spdk_get_ticks();
508 : 1316 : step->action.status = status;
509 : :
510 : 1316 : trace_step(mngt->dev, step, false);
511 : 1316 : }
512 : :
513 : : /*
514 : : * Rollback
515 : : */
516 : : static void
517 : 358 : rollback_next(struct ftl_mngt_process *mngt)
518 : : {
519 [ - + ]: 358 : if (TAILQ_EMPTY(&mngt->rollback_queue_todo)) {
520 : : /* Nothing to do, finish the management process */
521 : 0 : ftl_mngt_finish(mngt);
522 : 0 : return;
523 : : } else {
524 : 358 : rollback_done(mngt, 0);
525 : 358 : rollback_execute(mngt);
526 : : }
527 : : }
528 : :
529 : : static void
530 : 432 : rollback_msg(void *ctx)
531 : : {
532 : 432 : struct ftl_mngt_process *mngt = ctx;
533 : : struct ftl_mngt_step *step;
534 : :
535 : 432 : mngt->continuing = false;
536 : :
537 [ + + ]: 432 : if (TAILQ_EMPTY(&mngt->rollback_queue_todo)) {
538 : 58 : ftl_mngt_finish(mngt);
539 : 58 : return;
540 : : }
541 : :
542 : 374 : step = TAILQ_FIRST(&mngt->rollback_queue_todo);
543 [ + - ]: 374 : if (!step->rollback.start) {
544 : 374 : step->rollback.start = spdk_get_ticks();
545 : : }
546 : 374 : step->desc->cleanup(mngt->dev, mngt);
547 : : }
548 : :
549 : : static void
550 : 432 : rollback_execute(struct ftl_mngt_process *mngt)
551 : : {
552 : 432 : spdk_thread_send_msg(mngt->dev->core_thread, rollback_msg, mngt);
553 : 432 : }
554 : :
555 : : void
556 : 358 : rollback_done(struct ftl_mngt_process *mngt, int status)
557 : : {
558 : : struct ftl_mngt_step *step;
559 : :
560 [ - + ]: 358 : assert(!TAILQ_EMPTY(&mngt->rollback_queue_todo));
561 : 358 : step = TAILQ_FIRST(&mngt->rollback_queue_todo);
562 [ + + ]: 358 : TAILQ_REMOVE(&mngt->rollback_queue_todo, step, rollback.entry);
563 : 358 : TAILQ_INSERT_TAIL(&mngt->rollback_queue_done, step, rollback.entry);
564 : :
565 : 358 : step->rollback.stop = spdk_get_ticks();
566 : 358 : step->rollback.status = status;
567 : :
568 : 358 : trace_step(mngt->dev, step, true);
569 : 358 : }
|