Line data Source code
1 : /* SPDX-License-Identifier: BSD-3-Clause
2 : * Copyright (C) 2018 Intel Corporation.
3 : * All rights reserved.
4 : */
5 :
6 : #include "spdk/likely.h"
7 : #include "spdk/stdinc.h"
8 : #include "spdk/nvme.h"
9 : #include "spdk/thread.h"
10 : #include "spdk/bdev_module.h"
11 : #include "spdk/string.h"
12 : #include "spdk/ftl.h"
13 : #include "spdk/crc32.h"
14 :
15 : #include "ftl_core.h"
16 : #include "ftl_band.h"
17 : #include "ftl_io.h"
18 : #include "ftl_debug.h"
19 : #include "ftl_internal.h"
20 : #include "mngt/ftl_mngt.h"
21 :
22 :
23 : size_t
24 0 : spdk_ftl_io_size(void)
25 : {
26 0 : return sizeof(struct ftl_io);
27 : }
28 :
29 : static void
30 0 : ftl_io_cmpl_cb(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
31 : {
32 0 : struct ftl_io *io = cb_arg;
33 0 : struct spdk_ftl_dev *dev = io->dev;
34 :
35 0 : ftl_stats_bdev_io_completed(dev, FTL_STATS_TYPE_USER, bdev_io);
36 :
37 0 : if (spdk_unlikely(!success)) {
38 0 : io->status = -EIO;
39 : }
40 :
41 0 : ftl_trace_completion(dev, io, FTL_TRACE_COMPLETION_DISK);
42 :
43 0 : ftl_io_dec_req(io);
44 0 : if (ftl_io_done(io)) {
45 0 : ftl_io_complete(io);
46 : }
47 :
48 0 : spdk_bdev_free_io(bdev_io);
49 0 : }
50 :
51 : static void
52 0 : ftl_band_erase(struct ftl_band *band)
53 : {
54 0 : assert(band->md->state == FTL_BAND_STATE_CLOSED ||
55 : band->md->state == FTL_BAND_STATE_FREE);
56 :
57 0 : ftl_band_set_state(band, FTL_BAND_STATE_PREP);
58 0 : }
59 :
60 : static size_t
61 0 : ftl_get_limit(const struct spdk_ftl_dev *dev, int type)
62 : {
63 0 : assert(type < SPDK_FTL_LIMIT_MAX);
64 0 : return dev->conf.limits[type];
65 : }
66 :
67 : static bool
68 0 : ftl_shutdown_complete(struct spdk_ftl_dev *dev)
69 : {
70 : uint64_t i;
71 :
72 0 : if (dev->num_inflight) {
73 0 : return false;
74 : }
75 :
76 0 : if (!ftl_nv_cache_is_halted(&dev->nv_cache)) {
77 0 : ftl_nv_cache_halt(&dev->nv_cache);
78 0 : return false;
79 : }
80 :
81 0 : if (!ftl_writer_is_halted(&dev->writer_user)) {
82 0 : ftl_writer_halt(&dev->writer_user);
83 0 : return false;
84 : }
85 :
86 0 : if (!ftl_reloc_is_halted(dev->reloc)) {
87 0 : ftl_reloc_halt(dev->reloc);
88 0 : return false;
89 : }
90 :
91 0 : if (!ftl_writer_is_halted(&dev->writer_gc)) {
92 0 : ftl_writer_halt(&dev->writer_gc);
93 0 : return false;
94 : }
95 :
96 0 : if (!ftl_nv_cache_chunks_busy(&dev->nv_cache)) {
97 0 : return false;
98 : }
99 :
100 0 : for (i = 0; i < ftl_get_num_bands(dev); ++i) {
101 0 : if (dev->bands[i].queue_depth ||
102 0 : dev->bands[i].md->state == FTL_BAND_STATE_CLOSING) {
103 0 : return false;
104 : }
105 : }
106 :
107 0 : if (!ftl_l2p_is_halted(dev)) {
108 0 : ftl_l2p_halt(dev);
109 0 : return false;
110 : }
111 :
112 0 : return true;
113 : }
114 :
115 : void
116 0 : ftl_apply_limits(struct spdk_ftl_dev *dev)
117 : {
118 : size_t limit;
119 0 : struct ftl_stats *stats = &dev->stats;
120 : int i;
121 :
122 : /* Clear existing limit */
123 0 : dev->limit = SPDK_FTL_LIMIT_MAX;
124 :
125 0 : for (i = SPDK_FTL_LIMIT_CRIT; i < SPDK_FTL_LIMIT_MAX; ++i) {
126 0 : limit = ftl_get_limit(dev, i);
127 :
128 0 : if (dev->num_free <= limit) {
129 0 : stats->limits[i]++;
130 0 : dev->limit = i;
131 0 : break;
132 : }
133 : }
134 :
135 0 : ftl_trace_limits(dev, dev->limit, dev->num_free);
136 0 : }
137 :
138 : void
139 2 : ftl_invalidate_addr(struct spdk_ftl_dev *dev, ftl_addr addr)
140 : {
141 : struct ftl_band *band;
142 : struct ftl_p2l_map *p2l_map;
143 :
144 2 : if (ftl_addr_in_nvc(dev, addr)) {
145 0 : ftl_bitmap_clear(dev->valid_map, addr);
146 0 : return;
147 : }
148 :
149 2 : band = ftl_band_from_addr(dev, addr);
150 2 : p2l_map = &band->p2l_map;
151 :
152 : /* The bit might be already cleared if two writes are scheduled to the */
153 : /* same LBA at the same time */
154 2 : if (ftl_bitmap_get(dev->valid_map, addr)) {
155 2 : assert(p2l_map->num_valid > 0);
156 2 : ftl_bitmap_clear(dev->valid_map, addr);
157 2 : p2l_map->num_valid--;
158 : }
159 :
160 : /* Invalidate open/full band p2l_map entry to keep p2l and l2p
161 : * consistency when band is going to close state */
162 2 : if (FTL_BAND_STATE_OPEN == band->md->state || FTL_BAND_STATE_FULL == band->md->state) {
163 0 : p2l_map->band_map[ftl_band_block_offset_from_addr(band, addr)].lba = FTL_LBA_INVALID;
164 0 : p2l_map->band_map[ftl_band_block_offset_from_addr(band, addr)].seq_id = 0;
165 : }
166 : }
167 :
168 : static int
169 0 : ftl_read_canceled(int rc)
170 : {
171 0 : return rc == -EFAULT;
172 : }
173 :
174 : static int
175 0 : ftl_get_next_read_addr(struct ftl_io *io, ftl_addr *addr)
176 : {
177 0 : struct spdk_ftl_dev *dev = io->dev;
178 : ftl_addr next_addr;
179 : size_t i;
180 0 : bool addr_cached = false;
181 :
182 0 : *addr = ftl_l2p_get(dev, ftl_io_current_lba(io));
183 0 : io->map[io->pos] = *addr;
184 :
185 : /* If the address is invalid, skip it */
186 0 : if (*addr == FTL_ADDR_INVALID) {
187 0 : return -EFAULT;
188 : }
189 :
190 0 : addr_cached = ftl_addr_in_nvc(dev, *addr);
191 :
192 0 : for (i = 1; i < ftl_io_iovec_len_left(io); ++i) {
193 0 : next_addr = ftl_l2p_get(dev, ftl_io_get_lba(io, io->pos + i));
194 :
195 0 : if (next_addr == FTL_ADDR_INVALID) {
196 0 : break;
197 : }
198 :
199 : /* It's not enough to check for contiguity, if user data is on the last block
200 : * of base device and first nvc, then they're 'contiguous', but can't be handled
201 : * with one read request.
202 : */
203 0 : if (addr_cached != ftl_addr_in_nvc(dev, next_addr)) {
204 0 : break;
205 : }
206 :
207 0 : if (*addr + i != next_addr) {
208 0 : break;
209 : }
210 :
211 0 : io->map[io->pos + i] = next_addr;
212 : }
213 :
214 0 : return i;
215 : }
216 :
217 : static void ftl_submit_read(struct ftl_io *io);
218 :
219 : static void
220 0 : _ftl_submit_read(void *_io)
221 : {
222 0 : struct ftl_io *io = _io;
223 :
224 0 : ftl_submit_read(io);
225 0 : }
226 :
227 : static void
228 0 : ftl_submit_read(struct ftl_io *io)
229 : {
230 0 : struct spdk_ftl_dev *dev = io->dev;
231 0 : ftl_addr addr;
232 0 : int rc = 0, num_blocks;
233 :
234 0 : while (io->pos < io->num_blocks) {
235 0 : num_blocks = ftl_get_next_read_addr(io, &addr);
236 0 : rc = num_blocks;
237 :
238 : /* User LBA doesn't hold valid data (trimmed or never written to), fill with 0 and skip this block */
239 0 : if (ftl_read_canceled(rc)) {
240 0 : memset(ftl_io_iovec_addr(io), 0, FTL_BLOCK_SIZE);
241 0 : ftl_io_advance(io, 1);
242 0 : continue;
243 : }
244 :
245 0 : assert(num_blocks > 0);
246 :
247 0 : ftl_trace_submission(dev, io, addr, num_blocks);
248 :
249 0 : if (ftl_addr_in_nvc(dev, addr)) {
250 0 : rc = ftl_nv_cache_read(io, addr, num_blocks, ftl_io_cmpl_cb, io);
251 : } else {
252 0 : rc = spdk_bdev_read_blocks(dev->base_bdev_desc, dev->base_ioch,
253 : ftl_io_iovec_addr(io),
254 : addr, num_blocks, ftl_io_cmpl_cb, io);
255 : }
256 :
257 0 : if (spdk_unlikely(rc)) {
258 0 : if (rc == -ENOMEM) {
259 : struct spdk_bdev *bdev;
260 : struct spdk_io_channel *ch;
261 :
262 0 : if (ftl_addr_in_nvc(dev, addr)) {
263 0 : bdev = spdk_bdev_desc_get_bdev(dev->nv_cache.bdev_desc);
264 0 : ch = dev->nv_cache.cache_ioch;
265 : } else {
266 0 : bdev = spdk_bdev_desc_get_bdev(dev->base_bdev_desc);
267 0 : ch = dev->base_ioch;
268 : }
269 0 : io->bdev_io_wait.bdev = bdev;
270 0 : io->bdev_io_wait.cb_fn = _ftl_submit_read;
271 0 : io->bdev_io_wait.cb_arg = io;
272 0 : spdk_bdev_queue_io_wait(bdev, ch, &io->bdev_io_wait);
273 0 : return;
274 : } else {
275 0 : ftl_abort();
276 : }
277 : }
278 :
279 0 : ftl_io_inc_req(io);
280 0 : ftl_io_advance(io, num_blocks);
281 : }
282 :
283 : /* If we didn't have to read anything from the device, */
284 : /* complete the request right away */
285 0 : if (ftl_io_done(io)) {
286 0 : ftl_io_complete(io);
287 : }
288 : }
289 :
290 : bool
291 0 : ftl_needs_reloc(struct spdk_ftl_dev *dev)
292 : {
293 0 : size_t limit = ftl_get_limit(dev, SPDK_FTL_LIMIT_START);
294 :
295 0 : if (dev->num_free <= limit) {
296 0 : return true;
297 : }
298 :
299 0 : return false;
300 : }
301 :
302 : void
303 0 : spdk_ftl_dev_get_attrs(const struct spdk_ftl_dev *dev, struct spdk_ftl_attrs *attrs,
304 : size_t attrs_size)
305 : {
306 0 : attrs->num_blocks = dev->num_lbas;
307 0 : attrs->block_size = FTL_BLOCK_SIZE;
308 0 : attrs->optimum_io_size = dev->xfer_size;
309 : /* NOTE: check any new fields in attrs against attrs_size */
310 0 : }
311 :
312 : static void
313 0 : ftl_io_pin_cb(struct spdk_ftl_dev *dev, int status, struct ftl_l2p_pin_ctx *pin_ctx)
314 : {
315 0 : struct ftl_io *io = pin_ctx->cb_ctx;
316 :
317 0 : if (spdk_unlikely(status != 0)) {
318 : /* Retry on the internal L2P fault */
319 0 : io->status = -EAGAIN;
320 0 : ftl_io_complete(io);
321 0 : return;
322 : }
323 :
324 0 : io->flags |= FTL_IO_PINNED;
325 0 : ftl_submit_read(io);
326 : }
327 :
328 : static void
329 0 : ftl_io_pin(struct ftl_io *io)
330 : {
331 0 : if (spdk_unlikely(io->flags & FTL_IO_PINNED)) {
332 : /*
333 : * The IO is in a retry path and it had been pinned already.
334 : * Continue with further processing.
335 : */
336 0 : ftl_l2p_pin_skip(io->dev, ftl_io_pin_cb, io, &io->l2p_pin_ctx);
337 : } else {
338 : /* First time when pinning the IO */
339 0 : ftl_l2p_pin(io->dev, io->lba, io->num_blocks,
340 : ftl_io_pin_cb, io, &io->l2p_pin_ctx);
341 : }
342 0 : }
343 :
344 : static void
345 0 : start_io(struct ftl_io *io)
346 : {
347 0 : struct ftl_io_channel *ioch = ftl_io_channel_get_ctx(io->ioch);
348 0 : struct spdk_ftl_dev *dev = io->dev;
349 :
350 0 : io->map = ftl_mempool_get(ioch->map_pool);
351 0 : if (spdk_unlikely(!io->map)) {
352 0 : io->status = -ENOMEM;
353 0 : ftl_io_complete(io);
354 0 : return;
355 : }
356 :
357 0 : switch (io->type) {
358 0 : case FTL_IO_READ:
359 0 : TAILQ_INSERT_TAIL(&dev->rd_sq, io, queue_entry);
360 0 : break;
361 0 : case FTL_IO_WRITE:
362 0 : TAILQ_INSERT_TAIL(&dev->wr_sq, io, queue_entry);
363 0 : break;
364 0 : case FTL_IO_TRIM:
365 0 : TAILQ_INSERT_TAIL(&dev->trim_sq, io, queue_entry);
366 0 : break;
367 0 : default:
368 0 : io->status = -EOPNOTSUPP;
369 0 : ftl_io_complete(io);
370 : }
371 : }
372 :
373 : static int
374 0 : queue_io(struct spdk_ftl_dev *dev, struct ftl_io *io)
375 : {
376 : size_t result;
377 0 : struct ftl_io_channel *ioch = ftl_io_channel_get_ctx(io->ioch);
378 :
379 0 : result = spdk_ring_enqueue(ioch->sq, (void **)&io, 1, NULL);
380 0 : if (spdk_unlikely(0 == result)) {
381 0 : return -EAGAIN;
382 : }
383 :
384 0 : return 0;
385 : }
386 :
387 : int
388 0 : spdk_ftl_writev(struct spdk_ftl_dev *dev, struct ftl_io *io, struct spdk_io_channel *ch,
389 : uint64_t lba, uint64_t lba_cnt, struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn,
390 : void *cb_arg)
391 : {
392 : int rc;
393 :
394 0 : if (iov_cnt == 0) {
395 0 : return -EINVAL;
396 : }
397 :
398 0 : if (lba_cnt == 0) {
399 0 : return -EINVAL;
400 : }
401 :
402 0 : if (lba_cnt != ftl_iovec_num_blocks(iov, iov_cnt)) {
403 0 : FTL_ERRLOG(dev, "Invalid IO vector to handle, device %s, LBA %"PRIu64"\n",
404 : dev->conf.name, lba);
405 0 : return -EINVAL;
406 : }
407 :
408 0 : if (!dev->initialized) {
409 0 : return -EBUSY;
410 : }
411 :
412 0 : rc = ftl_io_init(ch, io, lba, lba_cnt, iov, iov_cnt, cb_fn, cb_arg, FTL_IO_WRITE);
413 0 : if (rc) {
414 0 : return rc;
415 : }
416 :
417 0 : return queue_io(dev, io);
418 : }
419 :
420 : int
421 0 : spdk_ftl_readv(struct spdk_ftl_dev *dev, struct ftl_io *io, struct spdk_io_channel *ch,
422 : uint64_t lba, uint64_t lba_cnt, struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn, void *cb_arg)
423 : {
424 : int rc;
425 :
426 0 : if (iov_cnt == 0) {
427 0 : return -EINVAL;
428 : }
429 :
430 0 : if (lba_cnt == 0) {
431 0 : return -EINVAL;
432 : }
433 :
434 0 : if (lba_cnt != ftl_iovec_num_blocks(iov, iov_cnt)) {
435 0 : FTL_ERRLOG(dev, "Invalid IO vector to handle, device %s, LBA %"PRIu64"\n",
436 : dev->conf.name, lba);
437 0 : return -EINVAL;
438 : }
439 :
440 0 : if (!dev->initialized) {
441 0 : return -EBUSY;
442 : }
443 :
444 0 : rc = ftl_io_init(ch, io, lba, lba_cnt, iov, iov_cnt, cb_fn, cb_arg, FTL_IO_READ);
445 0 : if (rc) {
446 0 : return rc;
447 : }
448 :
449 0 : return queue_io(dev, io);
450 : }
451 :
452 : int
453 0 : ftl_trim(struct spdk_ftl_dev *dev, struct ftl_io *io, struct spdk_io_channel *ch,
454 : uint64_t lba, uint64_t lba_cnt, spdk_ftl_fn cb_fn, void *cb_arg)
455 : {
456 : int rc;
457 :
458 0 : rc = ftl_io_init(ch, io, lba, lba_cnt, NULL, 0, cb_fn, cb_arg, FTL_IO_TRIM);
459 0 : if (rc) {
460 0 : return rc;
461 : }
462 :
463 0 : return queue_io(dev, io);
464 : }
465 :
466 : int
467 0 : spdk_ftl_unmap(struct spdk_ftl_dev *dev, struct ftl_io *io, struct spdk_io_channel *ch,
468 : uint64_t lba, uint64_t lba_cnt, spdk_ftl_fn cb_fn, void *cb_arg)
469 : {
470 : int rc;
471 0 : uint64_t alignment = dev->layout.l2p.lbas_in_page;
472 :
473 0 : if (lba_cnt == 0) {
474 0 : return -EINVAL;
475 : }
476 :
477 0 : if (lba + lba_cnt < lba_cnt) {
478 0 : return -EINVAL;
479 : }
480 :
481 0 : if (lba + lba_cnt > dev->num_lbas) {
482 0 : return -EINVAL;
483 : }
484 :
485 0 : if (!dev->initialized) {
486 0 : return -EBUSY;
487 : }
488 :
489 0 : if (lba % alignment || lba_cnt % alignment) {
490 0 : if (!io) {
491 : /* This is management/RPC path, its parameters must be aligned to 1MiB. */
492 0 : return -EINVAL;
493 : }
494 :
495 : /* Otherwise unaligned IO requests are NOPs */
496 0 : rc = ftl_io_init(ch, io, lba, lba_cnt, NULL, 0, cb_fn, cb_arg, FTL_IO_TRIM);
497 0 : if (rc) {
498 0 : return rc;
499 : }
500 :
501 0 : io->status = 0;
502 0 : ftl_io_complete(io);
503 0 : return 0;
504 : }
505 :
506 0 : if (io) {
507 0 : rc = ftl_trim(dev, io, ch, lba, lba_cnt, cb_fn, cb_arg);
508 : } else {
509 0 : rc = ftl_mngt_trim(dev, lba, lba_cnt, cb_fn, cb_arg);
510 : }
511 :
512 0 : return rc;
513 : }
514 :
515 : #define FTL_IO_QUEUE_BATCH 16
516 : int
517 0 : ftl_io_channel_poll(void *arg)
518 : {
519 0 : struct ftl_io_channel *ch = arg;
520 0 : void *ios[FTL_IO_QUEUE_BATCH];
521 : uint64_t i, count;
522 :
523 0 : count = spdk_ring_dequeue(ch->cq, ios, FTL_IO_QUEUE_BATCH);
524 0 : if (count == 0) {
525 0 : return SPDK_POLLER_IDLE;
526 : }
527 :
528 0 : for (i = 0; i < count; i++) {
529 0 : struct ftl_io *io = ios[i];
530 0 : io->user_fn(io->cb_ctx, io->status);
531 : }
532 :
533 0 : return SPDK_POLLER_BUSY;
534 : }
535 :
536 : static void
537 0 : ftl_process_io_channel(struct spdk_ftl_dev *dev, struct ftl_io_channel *ioch)
538 : {
539 0 : void *ios[FTL_IO_QUEUE_BATCH];
540 : size_t count, i;
541 :
542 0 : count = spdk_ring_dequeue(ioch->sq, ios, FTL_IO_QUEUE_BATCH);
543 0 : if (count == 0) {
544 0 : return;
545 : }
546 :
547 0 : for (i = 0; i < count; i++) {
548 0 : struct ftl_io *io = ios[i];
549 0 : start_io(io);
550 : }
551 : }
552 :
553 : static void
554 0 : ftl_trim_log_clear(struct spdk_ftl_dev *dev)
555 : {
556 0 : struct ftl_trim_log *log = ftl_md_get_buffer(dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_LOG]);
557 :
558 0 : memset(&log->hdr, 0, sizeof(log->hdr));
559 0 : }
560 :
561 : static void
562 0 : ftl_trim_finish(struct ftl_io *io, int status)
563 : {
564 0 : io->dev->trim_qd--;
565 :
566 0 : if (spdk_unlikely(status)) {
567 : #ifdef SPDK_FTL_RETRY_ON_ERROR
568 : ftl_io_clear(io);
569 : TAILQ_INSERT_HEAD(&io->dev->trim_sq, io, queue_entry);
570 : return;
571 : #else
572 0 : io->status = status;
573 : #endif
574 : }
575 :
576 0 : ftl_io_complete(io);
577 0 : }
578 :
579 : static void
580 0 : ftl_trim_log_close_cb(int status, void *cb_arg)
581 : {
582 0 : struct ftl_io *io = cb_arg;
583 :
584 0 : ftl_trim_finish(io, status);
585 0 : }
586 :
587 : static void
588 0 : ftl_trim_log_persist(struct ftl_io *io, ftl_md_io_entry_cb cb)
589 : {
590 0 : struct spdk_ftl_dev *dev = io->dev;
591 0 : struct ftl_md *trim_log = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_LOG];
592 :
593 0 : ftl_md_persist_entries(trim_log, 0, 1, ftl_md_get_buffer(trim_log), NULL,
594 : cb, io, &dev->trim_md_io_entry_ctx);
595 0 : }
596 :
597 : static void
598 0 : ftl_trim_md_cb(int status, void *cb_arg)
599 : {
600 0 : struct ftl_io *io = cb_arg;
601 0 : struct spdk_ftl_dev *dev = io->dev;
602 :
603 0 : if (status) {
604 0 : io->status = status;
605 : }
606 0 : ftl_trim_log_clear(dev);
607 0 : ftl_trim_log_persist(io, ftl_trim_log_close_cb);
608 0 : }
609 :
610 : static void
611 0 : ftl_trim_log_open_cb(int status, void *cb_arg)
612 : {
613 0 : struct ftl_io *io = cb_arg;
614 0 : struct spdk_ftl_dev *dev = io->dev;
615 0 : struct ftl_md *trim_md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_MD];
616 : uint64_t first, entires;
617 0 : const uint64_t entires_in_block = FTL_BLOCK_SIZE / sizeof(uint64_t);
618 : char *buffer;
619 :
620 0 : if (status) {
621 0 : ftl_trim_finish(io, status);
622 0 : return;
623 : }
624 :
625 : /* Map trim space into L2P pages */
626 0 : first = io->lba / dev->layout.l2p.lbas_in_page;
627 0 : entires = io->num_blocks / dev->layout.l2p.lbas_in_page;
628 : /* Map pages into trim metadata location */
629 0 : first = first / entires_in_block;
630 0 : entires = spdk_divide_round_up(entires, entires_in_block);
631 :
632 : /* Get trim metadata buffer */
633 0 : buffer = (char *)ftl_md_get_buffer(trim_md) + (FTL_BLOCK_SIZE * first);
634 :
635 : /* Persist the trim metadata snippet which corresponds to the trim IO */
636 0 : ftl_md_persist_entries(trim_md, first, entires, buffer, NULL,
637 : ftl_trim_md_cb, io, &dev->trim_md_io_entry_ctx);
638 : }
639 :
640 : void
641 0 : ftl_set_trim_map(struct spdk_ftl_dev *dev, uint64_t lba, uint64_t num_blocks, uint64_t seq_id)
642 : {
643 : uint64_t first_page, num_pages;
644 0 : uint64_t lbas_in_page = dev->layout.l2p.lbas_in_page;
645 0 : struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_MD];
646 0 : uint64_t *page = ftl_md_get_buffer(md);
647 : struct ftl_trim_log *log;
648 : size_t i;
649 :
650 0 : first_page = lba / lbas_in_page;
651 0 : num_pages = num_blocks / lbas_in_page;
652 :
653 : /* Fill trim metadata */
654 0 : for (i = first_page; i < first_page + num_pages; ++i) {
655 0 : ftl_bitmap_set(dev->trim_map, i);
656 0 : page[i] = seq_id;
657 : }
658 :
659 : /* Fill trim log */
660 0 : log = ftl_md_get_buffer(dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_LOG]);
661 0 : log->hdr.trim.seq_id = seq_id;
662 0 : log->hdr.trim.num_blocks = num_blocks;
663 0 : log->hdr.trim.start_lba = lba;
664 0 : }
665 :
666 : static bool
667 0 : ftl_process_trim(struct ftl_io *io)
668 : {
669 0 : struct spdk_ftl_dev *dev = io->dev;
670 : uint64_t seq_id;
671 :
672 0 : seq_id = ftl_nv_cache_acquire_trim_seq_id(&dev->nv_cache);
673 0 : if (seq_id == 0) {
674 0 : return false;
675 : }
676 :
677 0 : dev->trim_in_progress = true;
678 0 : dev->trim_qd++;
679 :
680 0 : dev->sb_shm->trim.start_lba = io->lba;
681 0 : dev->sb_shm->trim.num_blocks = io->num_blocks;
682 0 : dev->sb_shm->trim.seq_id = seq_id;
683 0 : dev->sb_shm->trim.in_progress = true;
684 0 : ftl_set_trim_map(dev, io->lba, io->num_blocks, seq_id);
685 0 : ftl_debug_inject_trim_error();
686 0 : dev->sb_shm->trim.in_progress = false;
687 :
688 0 : ftl_trim_log_persist(io, ftl_trim_log_open_cb);
689 0 : return true;
690 : }
691 :
692 : static void
693 0 : ftl_process_io_queue(struct spdk_ftl_dev *dev)
694 : {
695 : struct ftl_io_channel *ioch;
696 : struct ftl_io *io;
697 :
698 : /* TODO: Try to figure out a mechanism to batch more requests at the same time,
699 : * with keeping enough resources (pinned pages), between reads, writes and gc/compaction
700 : */
701 0 : if (!TAILQ_EMPTY(&dev->rd_sq)) {
702 0 : io = TAILQ_FIRST(&dev->rd_sq);
703 0 : TAILQ_REMOVE(&dev->rd_sq, io, queue_entry);
704 0 : assert(io->type == FTL_IO_READ);
705 0 : ftl_io_pin(io);
706 0 : ftl_add_io_activity(dev);
707 : }
708 :
709 0 : while (!TAILQ_EMPTY(&dev->wr_sq) && !ftl_nv_cache_throttle(dev)) {
710 0 : io = TAILQ_FIRST(&dev->wr_sq);
711 0 : TAILQ_REMOVE(&dev->wr_sq, io, queue_entry);
712 0 : assert(io->type == FTL_IO_WRITE);
713 0 : if (!ftl_nv_cache_write(io)) {
714 0 : TAILQ_INSERT_HEAD(&dev->wr_sq, io, queue_entry);
715 0 : break;
716 : }
717 0 : ftl_add_io_activity(dev);
718 : }
719 :
720 0 : if (!TAILQ_EMPTY(&dev->trim_sq) && dev->trim_qd == 0) {
721 0 : io = TAILQ_FIRST(&dev->trim_sq);
722 0 : TAILQ_REMOVE(&dev->trim_sq, io, queue_entry);
723 0 : assert(io->type == FTL_IO_TRIM);
724 :
725 : /*
726 : * Trim operation requires generating a sequence id for itself, which it gets based on the open chunk
727 : * in nv cache. If there are no open chunks (because we're in the middle of state transition or compaction
728 : * lagged behind), then we need to wait for the nv cache to resolve the situation - it's fine to just put the
729 : * trim and try again later.
730 : */
731 0 : if (!ftl_process_trim(io)) {
732 0 : TAILQ_INSERT_HEAD(&dev->trim_sq, io, queue_entry);
733 : } else {
734 0 : ftl_add_io_activity(dev);
735 : }
736 : }
737 :
738 0 : TAILQ_FOREACH(ioch, &dev->ioch_queue, entry) {
739 0 : ftl_process_io_channel(dev, ioch);
740 : }
741 0 : }
742 :
743 : int
744 0 : ftl_core_poller(void *ctx)
745 : {
746 0 : struct spdk_ftl_dev *dev = ctx;
747 0 : uint64_t io_activity_total_old = dev->stats.io_activity_total;
748 :
749 0 : if (dev->halt && ftl_shutdown_complete(dev)) {
750 0 : spdk_poller_unregister(&dev->core_poller);
751 0 : return SPDK_POLLER_IDLE;
752 : }
753 :
754 0 : ftl_process_io_queue(dev);
755 0 : ftl_writer_run(&dev->writer_user);
756 0 : ftl_writer_run(&dev->writer_gc);
757 0 : ftl_reloc(dev->reloc);
758 0 : ftl_nv_cache_process(dev);
759 0 : ftl_l2p_process(dev);
760 :
761 0 : if (io_activity_total_old != dev->stats.io_activity_total) {
762 0 : return SPDK_POLLER_BUSY;
763 : }
764 :
765 0 : return SPDK_POLLER_IDLE;
766 : }
767 :
768 : struct ftl_band *
769 0 : ftl_band_get_next_free(struct spdk_ftl_dev *dev)
770 : {
771 0 : struct ftl_band *band = NULL;
772 :
773 0 : if (!TAILQ_EMPTY(&dev->free_bands)) {
774 0 : band = TAILQ_FIRST(&dev->free_bands);
775 0 : TAILQ_REMOVE(&dev->free_bands, band, queue_entry);
776 0 : ftl_band_erase(band);
777 : }
778 :
779 0 : return band;
780 : }
781 :
782 : void *g_ftl_write_buf;
783 : void *g_ftl_read_buf;
784 :
785 : int
786 0 : spdk_ftl_init(void)
787 : {
788 0 : g_ftl_write_buf = spdk_zmalloc(FTL_ZERO_BUFFER_SIZE, FTL_ZERO_BUFFER_SIZE, NULL,
789 : SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
790 0 : if (!g_ftl_write_buf) {
791 0 : return -ENOMEM;
792 : }
793 :
794 0 : g_ftl_read_buf = spdk_zmalloc(FTL_ZERO_BUFFER_SIZE, FTL_ZERO_BUFFER_SIZE, NULL,
795 : SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
796 0 : if (!g_ftl_read_buf) {
797 0 : spdk_free(g_ftl_write_buf);
798 0 : g_ftl_write_buf = NULL;
799 0 : return -ENOMEM;
800 : }
801 0 : return 0;
802 : }
803 :
804 : void
805 0 : spdk_ftl_fini(void)
806 : {
807 0 : spdk_free(g_ftl_write_buf);
808 0 : spdk_free(g_ftl_read_buf);
809 0 : }
810 :
811 : void
812 0 : spdk_ftl_dev_set_fast_shutdown(struct spdk_ftl_dev *dev, bool fast_shutdown)
813 : {
814 0 : assert(dev);
815 0 : dev->conf.fast_shutdown = fast_shutdown;
816 0 : }
817 :
818 : void
819 0 : ftl_stats_bdev_io_completed(struct spdk_ftl_dev *dev, enum ftl_stats_type type,
820 : struct spdk_bdev_io *bdev_io)
821 : {
822 0 : struct ftl_stats_entry *stats_entry = &dev->stats.entries[type];
823 : struct ftl_stats_group *stats_group;
824 0 : uint32_t cdw0;
825 0 : int sct;
826 0 : int sc;
827 :
828 0 : switch (bdev_io->type) {
829 0 : case SPDK_BDEV_IO_TYPE_READ:
830 0 : stats_group = &stats_entry->read;
831 0 : break;
832 0 : case SPDK_BDEV_IO_TYPE_WRITE:
833 : case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
834 0 : stats_group = &stats_entry->write;
835 0 : break;
836 0 : default:
837 0 : return;
838 : }
839 :
840 0 : spdk_bdev_io_get_nvme_status(bdev_io, &cdw0, &sct, &sc);
841 :
842 0 : if (sct == SPDK_NVME_SCT_GENERIC && sc == SPDK_NVME_SC_SUCCESS) {
843 0 : stats_group->ios++;
844 0 : stats_group->blocks += bdev_io->u.bdev.num_blocks;
845 0 : } else if (sct == SPDK_NVME_SCT_MEDIA_ERROR) {
846 0 : stats_group->errors.media++;
847 : } else {
848 0 : stats_group->errors.other++;
849 : }
850 : }
851 :
852 : struct spdk_io_channel *
853 0 : spdk_ftl_get_io_channel(struct spdk_ftl_dev *dev)
854 : {
855 0 : return spdk_get_io_channel(dev);
856 : }
857 :
858 : void
859 0 : ftl_stats_crc_error(struct spdk_ftl_dev *dev, enum ftl_stats_type type)
860 : {
861 :
862 0 : struct ftl_stats_entry *stats_entry = &dev->stats.entries[type];
863 0 : struct ftl_stats_group *stats_group = &stats_entry->read;
864 :
865 0 : stats_group->errors.crc++;
866 0 : }
867 :
868 : struct ftl_get_stats_ctx {
869 : struct spdk_ftl_dev *dev;
870 : struct ftl_stats *stats;
871 : struct spdk_thread *thread;
872 : spdk_ftl_stats_fn cb_fn;
873 : void *cb_arg;
874 : };
875 :
876 : static void
877 0 : _ftl_get_stats_cb(void *_ctx)
878 : {
879 0 : struct ftl_get_stats_ctx *stats_ctx = _ctx;
880 :
881 0 : stats_ctx->cb_fn(stats_ctx->stats, stats_ctx->cb_arg);
882 0 : free(stats_ctx);
883 0 : }
884 :
885 : static void
886 0 : _ftl_get_stats(void *_ctx)
887 : {
888 0 : struct ftl_get_stats_ctx *stats_ctx = _ctx;
889 :
890 0 : *stats_ctx->stats = stats_ctx->dev->stats;
891 :
892 0 : if (spdk_thread_send_msg(stats_ctx->thread, _ftl_get_stats_cb, stats_ctx)) {
893 0 : ftl_abort();
894 : }
895 0 : }
896 :
897 : int
898 0 : spdk_ftl_get_stats(struct spdk_ftl_dev *dev, struct ftl_stats *stats, spdk_ftl_stats_fn cb_fn,
899 : void *cb_arg)
900 : {
901 : struct ftl_get_stats_ctx *stats_ctx;
902 : int rc;
903 :
904 0 : stats_ctx = calloc(1, sizeof(struct ftl_get_stats_ctx));
905 0 : if (!stats_ctx) {
906 0 : return -ENOMEM;
907 : }
908 :
909 0 : stats_ctx->dev = dev;
910 0 : stats_ctx->stats = stats;
911 0 : stats_ctx->cb_fn = cb_fn;
912 0 : stats_ctx->cb_arg = cb_arg;
913 0 : stats_ctx->thread = spdk_get_thread();
914 :
915 0 : rc = spdk_thread_send_msg(dev->core_thread, _ftl_get_stats, stats_ctx);
916 0 : if (rc) {
917 0 : goto stats_allocated;
918 : }
919 :
920 0 : return 0;
921 :
922 0 : stats_allocated:
923 0 : free(stats_ctx);
924 0 : return rc;
925 : }
926 :
927 2 : SPDK_LOG_REGISTER_COMPONENT(ftl_core)
|