Branch data 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/stdinc.h"
7 : : #include "spdk/ftl.h"
8 : : #include "spdk/likely.h"
9 : : #include "spdk/util.h"
10 : :
11 : : #include "ftl_io.h"
12 : : #include "ftl_core.h"
13 : : #include "ftl_band.h"
14 : : #include "ftl_debug.h"
15 : :
16 : : void
17 : 1958588 : ftl_io_inc_req(struct ftl_io *io)
18 : : {
19 : 1958588 : io->dev->num_inflight++;
20 : 1958588 : io->req_cnt++;
21 : 1958588 : }
22 : :
23 : : void
24 : 1958588 : ftl_io_dec_req(struct ftl_io *io)
25 : : {
26 [ - + ]: 1958588 : assert(io->dev->num_inflight > 0);
27 [ - + ]: 1958588 : assert(io->req_cnt > 0);
28 : :
29 : 1958588 : io->dev->num_inflight--;
30 : 1958588 : io->req_cnt--;
31 : 1958588 : }
32 : :
33 : : struct iovec *
34 : 8917768 : ftl_io_iovec(struct ftl_io *io)
35 : : {
36 : 8917768 : return &io->iov[0];
37 : : }
38 : :
39 : : uint64_t
40 : 9354583 : ftl_io_get_lba(const struct ftl_io *io, size_t offset)
41 : : {
42 [ - + ]: 9354583 : assert(offset < io->num_blocks);
43 : 9354583 : return io->lba + offset;
44 : : }
45 : :
46 : : uint64_t
47 : 1960742 : ftl_io_current_lba(const struct ftl_io *io)
48 : : {
49 : 1960742 : return ftl_io_get_lba(io, io->pos);
50 : : }
51 : :
52 : : void
53 : 1960742 : ftl_io_advance(struct ftl_io *io, size_t num_blocks)
54 : : {
55 : 1960742 : struct iovec *iov = ftl_io_iovec(io);
56 : 1960742 : size_t iov_blocks, block_left = num_blocks;
57 : :
58 : 1960742 : io->pos += num_blocks;
59 : :
60 [ - + ]: 1960742 : if (io->iov_cnt == 0) {
61 : 0 : return;
62 : : }
63 : :
64 [ + + ]: 3921365 : while (block_left > 0) {
65 [ - + ]: 1960742 : assert(io->iov_pos < io->iov_cnt);
66 : 1960742 : iov_blocks = iov[io->iov_pos].iov_len / FTL_BLOCK_SIZE;
67 : :
68 [ + + ]: 1960742 : if (io->iov_off + block_left < iov_blocks) {
69 : 119 : io->iov_off += block_left;
70 : 119 : break;
71 : : }
72 : :
73 [ - + ]: 1960623 : assert(iov_blocks > io->iov_off);
74 : 1960623 : block_left -= (iov_blocks - io->iov_off);
75 : 1960623 : io->iov_off = 0;
76 : 1960623 : io->iov_pos++;
77 : : }
78 : : }
79 : :
80 : : size_t
81 : 3615498 : ftl_iovec_num_blocks(struct iovec *iov, size_t iov_cnt)
82 : : {
83 : 3615498 : size_t num_blocks = 0, i = 0;
84 : :
85 [ + + ]: 7230996 : for (; i < iov_cnt; ++i) {
86 [ - + ]: 3615498 : if (iov[i].iov_len & (FTL_BLOCK_SIZE - 1)) {
87 : 0 : return 0;
88 : : }
89 : :
90 : 3615498 : num_blocks += iov[i].iov_len / FTL_BLOCK_SIZE;
91 : : }
92 : :
93 : 3615498 : return num_blocks;
94 : : }
95 : :
96 : : void *
97 : 1960742 : ftl_io_iovec_addr(struct ftl_io *io)
98 : : {
99 [ - + ]: 1960742 : assert(io->iov_pos < io->iov_cnt);
100 [ - + ]: 1960742 : assert(io->iov_off * FTL_BLOCK_SIZE < ftl_io_iovec(io)[io->iov_pos].iov_len);
101 : :
102 : 3921484 : return (char *)ftl_io_iovec(io)[io->iov_pos].iov_base +
103 : 1960742 : io->iov_off * FTL_BLOCK_SIZE;
104 : : }
105 : :
106 : : size_t
107 : 3035542 : ftl_io_iovec_len_left(struct ftl_io *io)
108 : : {
109 [ + - ]: 3035542 : if (io->iov_pos < io->iov_cnt) {
110 : 3035542 : struct iovec *iov = ftl_io_iovec(io);
111 : 3035542 : return iov[io->iov_pos].iov_len / FTL_BLOCK_SIZE - io->iov_off;
112 : : } else {
113 : 0 : return 0;
114 : : }
115 : : }
116 : :
117 : : static void
118 : 3615514 : ftl_io_cb(struct ftl_io *io, void *arg, int status)
119 : : {
120 : 3615514 : struct ftl_io_channel *ioch = ftl_io_channel_get_ctx(io->ioch);
121 : : size_t result __attribute__((unused));
122 : :
123 [ + + ]: 3615514 : if (spdk_unlikely(status)) {
124 : 4 : io->status = status;
125 : :
126 [ - + ]: 4 : if (-EAGAIN == status) {
127 : : /* IO has to be rescheduled again */
128 [ # # # # ]: 0 : switch (io->type) {
129 : 0 : case FTL_IO_READ:
130 : 0 : ftl_io_clear(io);
131 [ # # ]: 0 : TAILQ_INSERT_HEAD(&io->dev->rd_sq, io, queue_entry);
132 : 0 : break;
133 : 0 : case FTL_IO_WRITE:
134 : 0 : ftl_io_clear(io);
135 [ # # ]: 0 : TAILQ_INSERT_HEAD(&io->dev->wr_sq, io, queue_entry);
136 : 0 : break;
137 : 0 : case FTL_IO_TRIM:
138 : 0 : ftl_io_clear(io);
139 [ # # ]: 0 : TAILQ_INSERT_HEAD(&io->dev->trim_sq, io, queue_entry);
140 : 0 : break;
141 : 0 : default:
142 : : /* Unknown IO type, complete to the user */
143 : 0 : assert(0);
144 : : break;
145 : : }
146 : :
147 : 2 : }
148 : :
149 [ - + ]: 4 : if (!io->status) {
150 : : /* IO rescheduled, return from the function */
151 : 0 : return;
152 : : }
153 : : }
154 : :
155 [ + + ]: 3615514 : if (io->map) {
156 : 3615502 : ftl_mempool_put(ioch->map_pool, io->map);
157 : : }
158 : :
159 : 3615514 : result = spdk_ring_enqueue(ioch->cq, (void **)&io, 1, NULL);
160 [ - + ]: 3615514 : assert(result != 0);
161 : : }
162 : :
163 : : int
164 : 3615502 : ftl_io_init(struct spdk_io_channel *_ioch, struct ftl_io *io, uint64_t lba, size_t num_blocks,
165 : : struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn, void *cb_ctx, int type)
166 : : {
167 : 3615502 : struct ftl_io_channel *ioch = ftl_io_channel_get_ctx(_ioch);
168 : 3615502 : struct spdk_ftl_dev *dev = ioch->dev;
169 : :
170 [ - + ]: 3615502 : memset(io, 0, sizeof(struct ftl_io));
171 : 3615502 : io->ioch = _ioch;
172 : :
173 : 3615502 : io->flags |= FTL_IO_INITIALIZED;
174 : 3615502 : io->type = type;
175 : 3615502 : io->dev = dev;
176 : 3615502 : io->lba = FTL_LBA_INVALID;
177 : 3615502 : io->addr = FTL_ADDR_INVALID;
178 : 3615502 : io->cb_ctx = cb_ctx;
179 : 3615502 : io->lba = lba;
180 : 3615502 : io->user_fn = cb_fn;
181 : 3615502 : io->iov = iov;
182 : 3615502 : io->iov_cnt = iov_cnt;
183 : 3615502 : io->num_blocks = num_blocks;
184 : 3615502 : io->trace = ftl_trace_alloc_id(dev);
185 : :
186 : 3615502 : ftl_trace_lba_io_init(io->dev, io);
187 : 3615502 : return 0;
188 : : }
189 : :
190 : : static void
191 : 1960623 : ftl_io_complete_verify(struct ftl_io *io)
192 : : {
193 : 1960623 : struct spdk_ftl_dev *dev = io->dev;
194 : : uint64_t i;
195 : 1960623 : uint64_t lba = io->lba;
196 : :
197 [ - + ]: 1960623 : assert(io->num_blocks <= dev->xfer_size);
198 : :
199 [ - + ]: 1960623 : if (FTL_IO_WRITE == io->type) {
200 : 0 : return;
201 : : }
202 : :
203 [ - + ]: 1960623 : if (spdk_unlikely(io->status)) {
204 : 0 : return;
205 : : }
206 : :
207 [ + + ]: 4998383 : for (i = 0; i < io->num_blocks; i++, lba++) {
208 : 3037760 : ftl_addr current_addr = ftl_l2p_get(dev, lba);
209 : :
210 : : /* If user read request gets stuck for whatever reason, then it's possible the LBA
211 : : * has been relocated by GC or compaction and it may no longer be safe to return data
212 : : * from that address */
213 [ - + ]: 3037760 : if (spdk_unlikely(current_addr != io->map[i])) {
214 : 0 : io->status = -EAGAIN;
215 : 0 : break;
216 : : }
217 : : }
218 : : }
219 : :
220 : : void
221 : 3615514 : ftl_io_complete(struct ftl_io *io)
222 : : {
223 : 3615514 : io->flags &= ~FTL_IO_INITIALIZED;
224 : 3615514 : io->done = true;
225 : :
226 [ + + ]: 3615514 : if (io->flags & FTL_IO_PINNED) {
227 : 1960623 : ftl_io_complete_verify(io);
228 : 1960623 : ftl_l2p_unpin(io->dev, io->lba, io->num_blocks);
229 : : }
230 : :
231 : 3615514 : ftl_io_cb(io, io->cb_ctx, io->status);
232 : 3615514 : }
233 : :
234 : : void
235 : 0 : ftl_io_fail(struct ftl_io *io, int status)
236 : : {
237 : 0 : io->status = status;
238 : 0 : ftl_io_advance(io, io->num_blocks - io->pos);
239 : 0 : }
240 : :
241 : : void
242 : 0 : ftl_io_clear(struct ftl_io *io)
243 : : {
244 : 0 : io->req_cnt = io->pos = io->iov_pos = io->iov_off = 0;
245 : 0 : io->done = false;
246 : 0 : io->status = 0;
247 : 0 : io->flags = 0;
248 : 0 : io->band = NULL;
249 : 0 : }
|