Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "bdev_malloc.h"
10 : : #include "spdk/endian.h"
11 : : #include "spdk/env.h"
12 : : #include "spdk/accel.h"
13 : : #include "spdk/dma.h"
14 : : #include "spdk/likely.h"
15 : : #include "spdk/string.h"
16 : :
17 : : #include "spdk/log.h"
18 : :
19 : : struct malloc_disk {
20 : : struct spdk_bdev disk;
21 : : void *malloc_buf;
22 : : void *malloc_md_buf;
23 : : TAILQ_ENTRY(malloc_disk) link;
24 : : };
25 : :
26 : : struct malloc_task {
27 : : struct iovec iov;
28 : : int num_outstanding;
29 : : enum spdk_bdev_io_status status;
30 : : TAILQ_ENTRY(malloc_task) tailq;
31 : : };
32 : :
33 : : struct malloc_channel {
34 : : struct spdk_io_channel *accel_channel;
35 : : struct spdk_poller *completion_poller;
36 : : TAILQ_HEAD(, malloc_task) completed_tasks;
37 : : };
38 : :
39 : : static int
40 : 1779322 : _malloc_verify_pi(struct spdk_bdev_io *bdev_io, struct iovec *iovs, int iovcnt,
41 : : void *md_buf)
42 : : {
43 [ # # # # ]: 1779322 : struct spdk_bdev *bdev = bdev_io->bdev;
44 : 838144 : struct spdk_dif_ctx dif_ctx;
45 : 838144 : struct spdk_dif_error err_blk;
46 : : int rc;
47 : 838144 : struct spdk_dif_ctx_init_ext_opts dif_opts;
48 : :
49 [ + + # # : 1779322 : assert(bdev_io->u.bdev.memory_domain == NULL);
# # # # #
# # # ]
50 : 1779322 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
51 [ # # # # : 1779322 : dif_opts.dif_pi_format = bdev->dif_pi_format;
# # ]
52 : 2632413 : rc = spdk_dif_ctx_init(&dif_ctx,
53 [ # # # # ]: 619799 : bdev->blocklen,
54 [ # # # # ]: 619799 : bdev->md_len,
55 [ - + # # : 1779322 : bdev->md_interleave,
# # ]
56 [ - + # # : 1779322 : bdev->dif_is_head_of_md,
# # ]
57 [ # # # # ]: 619799 : bdev->dif_type,
58 [ # # # # : 619799 : bdev_io->u.bdev.dif_check_flags,
# # # # ]
59 [ # # # # : 1779322 : bdev_io->u.bdev.offset_blocks & 0xFFFFFFFF,
# # # # ]
60 : : 0xFFFF, 0, 0, 0, &dif_opts);
61 [ - + ]: 1779322 : if (rc != 0) {
62 : 0 : SPDK_ERRLOG("Failed to initialize DIF/DIX context\n");
63 : 0 : return rc;
64 : : }
65 : :
66 [ + - ]: 1779322 : if (spdk_bdev_is_md_interleaved(bdev)) {
67 : 2399121 : rc = spdk_dif_verify(iovs,
68 : 619799 : iovcnt,
69 [ # # # # : 1779322 : bdev_io->u.bdev.num_blocks,
# # # # ]
70 : : &dif_ctx,
71 : : &err_blk);
72 : 619799 : } else {
73 : 0 : struct iovec md_iov = {
74 : 0 : .iov_base = md_buf,
75 [ # # # # : 0 : .iov_len = bdev_io->u.bdev.num_blocks * bdev->md_len,
# # # # #
# # # ]
76 : : };
77 : :
78 [ # # # # : 0 : if (bdev_io->u.bdev.md_buf == NULL) {
# # # # #
# ]
79 : 0 : return 0;
80 : : }
81 : :
82 : 0 : rc = spdk_dix_verify(iovs,
83 : 0 : iovcnt,
84 : : &md_iov,
85 [ # # # # : 0 : bdev_io->u.bdev.num_blocks,
# # # # ]
86 : : &dif_ctx,
87 : : &err_blk);
88 : : }
89 : :
90 [ + + ]: 1779322 : if (rc != 0) {
91 [ # # # # : 0 : SPDK_ERRLOG("DIF/DIX verify failed: lba %" PRIu64 ", num_blocks %" PRIu64 ", "
# # # # #
# # # # #
# # # # #
# # # ]
92 : : "err_type %u, expected %lu, actual %lu, err_offset %u\n",
93 : : bdev_io->u.bdev.offset_blocks,
94 : : bdev_io->u.bdev.num_blocks,
95 : : err_blk.err_type,
96 : : err_blk.expected,
97 : : err_blk.actual,
98 : : err_blk.err_offset);
99 : 0 : }
100 : :
101 : 1779322 : return rc;
102 : 619799 : }
103 : :
104 : : static int
105 : 3 : malloc_verify_pi_io_buf(struct spdk_bdev_io *bdev_io)
106 : : {
107 : 3 : return _malloc_verify_pi(bdev_io,
108 [ # # # # : 0 : bdev_io->u.bdev.iovs,
# # # # ]
109 [ # # # # : 0 : bdev_io->u.bdev.iovcnt,
# # # # ]
110 [ # # # # : 0 : bdev_io->u.bdev.md_buf);
# # # # ]
111 : : }
112 : :
113 : : static int
114 : 1772971 : malloc_verify_pi_malloc_buf(struct spdk_bdev_io *bdev_io)
115 : : {
116 : 838144 : struct iovec iov;
117 [ # # # # ]: 1772971 : struct spdk_bdev *bdev = bdev_io->bdev;
118 [ # # # # ]: 1772971 : struct malloc_disk *mdisk = bdev->ctxt;
119 : : uint64_t len, offset;
120 : :
121 [ # # # # : 1772971 : len = bdev_io->u.bdev.num_blocks * bdev->blocklen;
# # # # #
# # # ]
122 [ # # # # : 1772971 : offset = bdev_io->u.bdev.offset_blocks * bdev->blocklen;
# # # # #
# # # ]
123 : :
124 [ # # # # ]: 1772971 : iov.iov_base = mdisk->malloc_buf + offset;
125 [ # # ]: 1772971 : iov.iov_len = len;
126 : :
127 : 1772971 : return _malloc_verify_pi(bdev_io, &iov, 1, NULL);
128 : : }
129 : :
130 : : static int
131 : 0 : malloc_unmap_write_zeroes_generate_pi(struct spdk_bdev_io *bdev_io)
132 : : {
133 [ # # # # ]: 0 : struct spdk_bdev *bdev = bdev_io->bdev;
134 [ # # # # : 0 : struct malloc_disk *mdisk = bdev_io->bdev->ctxt;
# # # # ]
135 [ # # # # : 0 : uint32_t block_size = bdev_io->bdev->blocklen;
# # # # ]
136 : : uint32_t dif_check_flags;
137 : 0 : struct spdk_dif_ctx dif_ctx;
138 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
139 : : int rc;
140 : :
141 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
142 [ # # # # : 0 : dif_opts.dif_pi_format = bdev->dif_pi_format;
# # ]
143 [ # # # # ]: 0 : dif_check_flags = bdev->dif_check_flags | SPDK_DIF_CHECK_TYPE_REFTAG |
144 [ # # ]: 0 : SPDK_DIF_FLAGS_APPTAG_CHECK;
145 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
146 [ # # # # ]: 0 : bdev->blocklen,
147 [ # # # # ]: 0 : bdev->md_len,
148 [ # # # # : 0 : bdev->md_interleave,
# # ]
149 [ # # # # : 0 : bdev->dif_is_head_of_md,
# # ]
150 [ # # # # ]: 0 : bdev->dif_type,
151 : 0 : dif_check_flags,
152 : : SPDK_DIF_REFTAG_IGNORE,
153 : : 0xFFFF, SPDK_DIF_APPTAG_IGNORE,
154 : : 0, 0, &dif_opts);
155 [ # # ]: 0 : if (rc != 0) {
156 : 0 : SPDK_ERRLOG("Initialization of DIF/DIX context failed\n");
157 : 0 : return rc;
158 : : }
159 : :
160 [ # # # # : 0 : if (bdev->md_interleave) {
# # # # ]
161 : 0 : struct iovec iov = {
162 [ # # # # : 0 : .iov_base = mdisk->malloc_buf + bdev_io->u.bdev.offset_blocks * block_size,
# # # # #
# # # ]
163 [ # # # # : 0 : .iov_len = bdev_io->u.bdev.num_blocks * block_size,
# # # # ]
164 : : };
165 : :
166 [ # # # # : 0 : rc = spdk_dif_generate(&iov, 1, bdev_io->u.bdev.num_blocks, &dif_ctx);
# # # # ]
167 : 0 : } else {
168 : 0 : struct iovec iov = {
169 [ # # # # : 0 : .iov_base = mdisk->malloc_buf + bdev_io->u.bdev.offset_blocks * block_size,
# # # # #
# # # ]
170 [ # # # # : 0 : .iov_len = bdev_io->u.bdev.num_blocks * block_size,
# # # # ]
171 : : };
172 : :
173 : 0 : struct iovec md_iov = {
174 [ # # # # : 0 : .iov_base = mdisk->malloc_md_buf + bdev_io->u.bdev.offset_blocks * bdev->md_len,
# # # # #
# # # # #
# # ]
175 [ # # # # : 0 : .iov_len = bdev_io->u.bdev.num_blocks * bdev->md_len,
# # # # #
# # # ]
176 : : };
177 : :
178 [ # # # # : 0 : rc = spdk_dix_generate(&iov, 1, &md_iov, bdev_io->u.bdev.num_blocks, &dif_ctx);
# # # # ]
179 : : }
180 : :
181 [ # # ]: 0 : if (rc != 0) {
182 : 0 : SPDK_ERRLOG("Formatting by DIF/DIX failed\n");
183 : 0 : }
184 : :
185 : :
186 : 0 : return rc;
187 : 0 : }
188 : :
189 : : static void
190 : 99809785 : malloc_done(void *ref, int status)
191 : : {
192 : 99809785 : struct malloc_task *task = (struct malloc_task *)ref;
193 : 99809785 : struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(task);
194 : : int rc;
195 : :
196 [ + + ]: 99809785 : if (status != 0) {
197 [ + - ]: 34350 : if (status == -ENOMEM) {
198 [ + - # # : 34350 : if (task->status == SPDK_BDEV_IO_STATUS_SUCCESS) {
# # ]
199 [ # # # # ]: 34350 : task->status = SPDK_BDEV_IO_STATUS_NOMEM;
200 : 0 : }
201 : 0 : } else {
202 [ # # # # ]: 0 : task->status = SPDK_BDEV_IO_STATUS_FAILED;
203 : : }
204 : 0 : }
205 : :
206 [ + + + - : 99809785 : if (--task->num_outstanding != 0) {
- + ]
207 : 134 : return;
208 : : }
209 : :
210 [ + + + + : 99809651 : if (bdev_io->bdev->dif_type != SPDK_DIF_DISABLE &&
+ - + - -
+ # # ]
211 [ + - # # ]: 1769007 : task->status == SPDK_BDEV_IO_STATUS_SUCCESS) {
212 [ + + + + : 1787304 : switch (bdev_io->type) {
# # # # ]
213 : 579860 : case SPDK_BDEV_IO_TYPE_READ:
214 [ + + ]: 894487 : if (!spdk_bdev_io_hide_metadata(bdev_io)) {
215 : 3 : rc = malloc_verify_pi_io_buf(bdev_io);
216 : 0 : } else {
217 : 894484 : rc = 0;
218 : : }
219 : 894487 : break;
220 : 579663 : case SPDK_BDEV_IO_TYPE_WRITE:
221 [ + + ]: 892817 : if (!spdk_bdev_io_hide_metadata(bdev_io)) {
222 : 0 : rc = 0;
223 : 0 : } else {
224 : 892817 : rc = malloc_verify_pi_malloc_buf(bdev_io);
225 : : }
226 : 892817 : break;
227 : 0 : case SPDK_BDEV_IO_TYPE_UNMAP:
228 : : case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
229 : 0 : rc = malloc_unmap_write_zeroes_generate_pi(bdev_io);
230 : 0 : break;
231 : 0 : default:
232 : 0 : rc = 0;
233 : 0 : break;
234 : : }
235 : :
236 [ + + ]: 1787304 : if (rc != 0) {
237 [ # # # # ]: 0 : task->status = SPDK_BDEV_IO_STATUS_FAILED;
238 : 0 : }
239 : 627781 : }
240 : :
241 [ + + + - : 99846245 : assert(!bdev_io->u.bdev.accel_sequence || task->status == SPDK_BDEV_IO_STATUS_NOMEM);
+ - + - -
+ # # # #
# # # # ]
242 [ + - + - ]: 99846245 : spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task), task->status);
243 : 33701615 : }
244 : :
245 : : static void
246 : 5030216 : malloc_complete_task(struct malloc_task *task, struct malloc_channel *mch,
247 : : enum spdk_bdev_io_status status)
248 : : {
249 [ # # # # ]: 5030216 : task->status = status;
250 [ # # # # : 5030216 : TAILQ_INSERT_TAIL(&mch->completed_tasks, task, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
251 : 5030216 : }
252 : :
253 : : static TAILQ_HEAD(, malloc_disk) g_malloc_disks = TAILQ_HEAD_INITIALIZER(g_malloc_disks);
254 : :
255 : : int malloc_disk_count = 0;
256 : :
257 : : static int bdev_malloc_initialize(void);
258 : : static void bdev_malloc_deinitialize(void);
259 : :
260 : : static int
261 : 1625 : bdev_malloc_get_ctx_size(void)
262 : : {
263 : 1625 : return sizeof(struct malloc_task);
264 : : }
265 : :
266 : : static struct spdk_bdev_module malloc_if = {
267 : : .name = "malloc",
268 : : .module_init = bdev_malloc_initialize,
269 : : .module_fini = bdev_malloc_deinitialize,
270 : : .get_ctx_size = bdev_malloc_get_ctx_size,
271 : :
272 : : };
273 : :
274 : 1727 : SPDK_BDEV_MODULE_REGISTER(malloc, &malloc_if)
275 : :
276 : : static void
277 : 1669 : malloc_disk_free(struct malloc_disk *malloc_disk)
278 : : {
279 [ + + ]: 1669 : if (!malloc_disk) {
280 : 0 : return;
281 : : }
282 : :
283 [ - + - + : 1669 : free(malloc_disk->disk.name);
- + ]
284 [ - + - + ]: 1669 : spdk_free(malloc_disk->malloc_buf);
285 [ - + - + ]: 1669 : spdk_free(malloc_disk->malloc_md_buf);
286 : 1669 : free(malloc_disk);
287 : 161 : }
288 : :
289 : : static int
290 : 1669 : bdev_malloc_destruct(void *ctx)
291 : : {
292 : 1669 : struct malloc_disk *malloc_disk = ctx;
293 : :
294 [ + + + - : 1669 : TAILQ_REMOVE(&g_malloc_disks, malloc_disk, link);
+ - + - #
# # # # #
# # # # #
# # # # #
# # + - +
- + - + -
+ - + - +
- + - + -
+ - + - ]
295 : 1669 : malloc_disk_free(malloc_disk);
296 : 1669 : return 0;
297 : : }
298 : :
299 : : static int
300 : 89122867 : bdev_malloc_check_iov_len(struct iovec *iovs, int iovcnt, size_t nbytes)
301 : : {
302 : : int i;
303 : :
304 [ + + - + ]: 178727596 : for (i = 0; i < iovcnt; i++) {
305 [ + + + - : 89607372 : if (nbytes < iovs[i].iov_len) {
+ - + - ]
306 : 2643 : return 0;
307 : : }
308 : :
309 [ - + - + : 89604729 : nbytes -= iovs[i].iov_len;
- + ]
310 : 31874632 : }
311 : :
312 : 89120224 : return nbytes != 0;
313 : 31930528 : }
314 : :
315 : : static size_t
316 : 134 : malloc_get_md_len(struct spdk_bdev_io *bdev_io)
317 : : {
318 [ # # # # : 134 : return bdev_io->u.bdev.num_blocks * bdev_io->bdev->md_len;
# # # # #
# # # # #
# # ]
319 : : }
320 : :
321 : : static uint64_t
322 : 134 : malloc_get_md_offset(struct spdk_bdev_io *bdev_io)
323 : : {
324 [ # # # # : 134 : return bdev_io->u.bdev.offset_blocks * bdev_io->bdev->md_len;
# # # # #
# # # # #
# # ]
325 : : }
326 : :
327 : : static void *
328 : 134 : malloc_get_md_buf(struct spdk_bdev_io *bdev_io)
329 : : {
330 [ # # # # ]: 134 : struct malloc_disk *mdisk = SPDK_CONTAINEROF(bdev_io->bdev, struct malloc_disk, disk);
331 : :
332 [ - + # # : 134 : assert(spdk_bdev_is_md_separate(bdev_io->bdev));
# # # # ]
333 : :
334 [ # # # # : 134 : return (char *)mdisk->malloc_md_buf + malloc_get_md_offset(bdev_io);
# # ]
335 : : }
336 : :
337 : : static void
338 : 34350 : malloc_sequence_fail(struct malloc_task *task, int status)
339 : : {
340 : 34350 : struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(task);
341 : :
342 : : /* For ENOMEM, the IO will be retried by the bdev layer, so we don't abort the sequence */
343 [ - + ]: 34350 : if (status != -ENOMEM) {
344 [ # # # # : 0 : spdk_accel_sequence_abort(bdev_io->u.bdev.accel_sequence);
# # # # ]
345 [ # # # # : 0 : bdev_io->u.bdev.accel_sequence = NULL;
# # # # ]
346 : 0 : }
347 : :
348 : 34350 : malloc_done(task, status);
349 : 34350 : }
350 : :
351 : : static void
352 : 88828076 : malloc_sequence_done(void *ctx, int status)
353 : : {
354 : 88828076 : struct malloc_task *task = ctx;
355 : 88828076 : struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(task);
356 : :
357 [ + - + - : 88828076 : bdev_io->u.bdev.accel_sequence = NULL;
+ - + - ]
358 : : /* Prevent bdev layer from retrying the request if the sequence failed with ENOMEM */
359 [ + - ]: 88828076 : malloc_done(task, status != -ENOMEM ? status : -EFAULT);
360 : 88828076 : }
361 : :
362 : : static void
363 : 51074342 : bdev_malloc_readv(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
364 : : struct malloc_task *task, struct spdk_bdev_io *bdev_io)
365 : : {
366 : : uint64_t len, offset;
367 : 51074342 : int res = 0;
368 : :
369 [ + - + - : 51074342 : len = bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen;
+ - + - +
- + - + -
+ - ]
370 [ + - + - : 51074342 : offset = bdev_io->u.bdev.offset_blocks * bdev_io->bdev->blocklen;
+ - + - +
- + - + -
+ - ]
371 : :
372 [ + + + - : 51074342 : if (bdev_malloc_check_iov_len(bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, len)) {
+ - + - +
- + - + -
+ - - + ]
373 : 0 : spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task),
374 : : SPDK_BDEV_IO_STATUS_FAILED);
375 : 0 : return;
376 : : }
377 : :
378 [ + - + - ]: 51074342 : task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
379 [ + - + - ]: 51074342 : task->num_outstanding = 0;
380 [ + - + - : 51074342 : task->iov.iov_base = mdisk->malloc_buf + offset;
+ - + - +
- ]
381 [ + - + - : 51074342 : task->iov.iov_len = len;
+ - ]
382 : :
383 [ + + + + : 51074342 : SPDK_DEBUGLOG(bdev_malloc, "read %zu bytes from offset %#" PRIx64 ", iovcnt=%d\n",
+ - # # #
# # # #
# ]
384 : : len, offset, bdev_io->u.bdev.iovcnt);
385 : :
386 [ + - + - ]: 51074342 : task->num_outstanding++;
387 [ + - + - : 94150805 : res = spdk_accel_append_copy(&bdev_io->u.bdev.accel_sequence, ch,
+ - ]
388 [ + - + - : 51074342 : bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
+ - + - +
- + - + -
+ - ]
389 [ + - + - : 22958992 : bdev_io->u.bdev.memory_domain,
+ - + - ]
390 [ + - + - : 22958992 : bdev_io->u.bdev.memory_domain_ctx,
+ - + - ]
391 [ + - ]: 22958992 : &task->iov, 1, NULL, NULL, NULL, NULL);
392 [ + + ]: 51074342 : if (spdk_unlikely(res != 0)) {
393 : 33976 : malloc_sequence_fail(task, res);
394 : 33976 : return;
395 : : }
396 : :
397 [ + - + - : 51040366 : spdk_accel_sequence_reverse(bdev_io->u.bdev.accel_sequence);
+ - + - ]
398 [ + - + - : 51040366 : spdk_accel_sequence_finish(bdev_io->u.bdev.accel_sequence, malloc_sequence_done, task);
+ - + - ]
399 : :
400 [ + + + - : 51040366 : if (bdev_io->u.bdev.md_buf == NULL) {
+ - + - -
+ ]
401 : 51040299 : return;
402 : : }
403 : :
404 [ - + - + : 67 : SPDK_DEBUGLOG(bdev_malloc, "read metadata %zu bytes from offset%#" PRIx64 "\n",
# # ]
405 : : malloc_get_md_len(bdev_io), malloc_get_md_offset(bdev_io));
406 : :
407 [ # # # # ]: 67 : task->num_outstanding++;
408 [ # # # # : 67 : res = spdk_accel_submit_copy(ch, bdev_io->u.bdev.md_buf, malloc_get_md_buf(bdev_io),
# # # # ]
409 : 0 : malloc_get_md_len(bdev_io), malloc_done, task);
410 [ - + ]: 67 : if (res != 0) {
411 : 0 : malloc_done(task, res);
412 : 0 : }
413 : 22958992 : }
414 : :
415 : : static void
416 : 38514395 : bdev_malloc_writev(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
417 : : struct malloc_task *task, struct spdk_bdev_io *bdev_io)
418 : : {
419 : : uint64_t len, offset;
420 : 38514395 : int res = 0;
421 : :
422 [ + - + - : 38514395 : len = bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen;
+ - + - +
- + - + -
+ - ]
423 [ + - + - : 38514395 : offset = bdev_io->u.bdev.offset_blocks * bdev_io->bdev->blocklen;
+ - + - +
- + - + -
+ - ]
424 : :
425 [ + + + - : 38514395 : if (bdev_malloc_check_iov_len(bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt, len)) {
+ - + - +
- + - + -
+ - - + ]
426 : 0 : spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task),
427 : : SPDK_BDEV_IO_STATUS_FAILED);
428 : 0 : return;
429 : : }
430 : :
431 [ + - + - ]: 38514395 : task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
432 [ + - + - ]: 38514395 : task->num_outstanding = 0;
433 [ + - + - : 38514395 : task->iov.iov_base = mdisk->malloc_buf + offset;
+ - + - +
- ]
434 [ + - + - : 38514395 : task->iov.iov_len = len;
+ - ]
435 : :
436 [ + + + + : 38514395 : SPDK_DEBUGLOG(bdev_malloc, "write %zu bytes to offset %#" PRIx64 ", iovcnt=%d\n",
+ - # # #
# # # #
# ]
437 : : len, offset, bdev_io->u.bdev.iovcnt);
438 : :
439 [ + - + - ]: 38514395 : task->num_outstanding++;
440 [ + - + - : 72170109 : res = spdk_accel_append_copy(&bdev_io->u.bdev.accel_sequence, ch, &task->iov, 1, NULL, NULL,
+ - + - ]
441 [ + - + - : 38514395 : bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
+ - + - +
- + - + -
+ - ]
442 [ + - + - : 9437406 : bdev_io->u.bdev.memory_domain,
+ - + - ]
443 [ + - + - : 9437406 : bdev_io->u.bdev.memory_domain_ctx, NULL, NULL);
+ - + - ]
444 [ + + ]: 38514395 : if (spdk_unlikely(res != 0)) {
445 : 374 : malloc_sequence_fail(task, res);
446 : 374 : return;
447 : : }
448 : :
449 [ + - + - : 38514021 : spdk_accel_sequence_finish(bdev_io->u.bdev.accel_sequence, malloc_sequence_done, task);
+ - + - ]
450 : :
451 [ + + + - : 38514021 : if (bdev_io->u.bdev.md_buf == NULL) {
+ - + - -
+ ]
452 : 38513954 : return;
453 : : }
454 : :
455 [ - + - + : 67 : SPDK_DEBUGLOG(bdev_malloc, "write metadata %zu bytes to offset %#" PRIx64 "\n",
# # ]
456 : : malloc_get_md_len(bdev_io), malloc_get_md_offset(bdev_io));
457 : :
458 [ # # # # ]: 67 : task->num_outstanding++;
459 [ # # # # : 67 : res = spdk_accel_submit_copy(ch, malloc_get_md_buf(bdev_io), bdev_io->u.bdev.md_buf,
# # # # ]
460 : 0 : malloc_get_md_len(bdev_io), malloc_done, task);
461 [ - + ]: 67 : if (res != 0) {
462 : 0 : malloc_done(task, res);
463 : 0 : }
464 : 9437406 : }
465 : :
466 : : static int
467 : 11512185 : bdev_malloc_unmap(struct malloc_disk *mdisk,
468 : : struct spdk_io_channel *ch,
469 : : struct malloc_task *task,
470 : : uint64_t offset,
471 : : uint64_t byte_count)
472 : : {
473 [ # # # # ]: 11512185 : task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
474 [ # # # # ]: 11512185 : task->num_outstanding = 1;
475 : :
476 [ # # # # ]: 14072183 : return spdk_accel_submit_fill(ch, mdisk->malloc_buf + offset, 0,
477 : 2559998 : byte_count, malloc_done, task);
478 : : }
479 : :
480 : : static void
481 : 116 : bdev_malloc_copy(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
482 : : struct malloc_task *task,
483 : : uint64_t dst_offset, uint64_t src_offset, size_t len)
484 : : {
485 : 116 : int64_t res = 0;
486 [ # # # # ]: 116 : void *dst = mdisk->malloc_buf + dst_offset;
487 [ # # # # ]: 116 : void *src = mdisk->malloc_buf + src_offset;
488 : :
489 [ + + - + : 116 : SPDK_DEBUGLOG(bdev_malloc, "Copy %zu bytes from offset %#" PRIx64 " to offset %#" PRIx64 "\n",
# # ]
490 : : len, src_offset, dst_offset);
491 : :
492 [ # # # # ]: 116 : task->status = SPDK_BDEV_IO_STATUS_SUCCESS;
493 [ # # # # ]: 116 : task->num_outstanding = 1;
494 : :
495 : 116 : res = spdk_accel_submit_copy(ch, dst, src, len, malloc_done, task);
496 [ + + ]: 116 : if (res != 0) {
497 : 0 : malloc_done(task, res);
498 : 0 : }
499 : 116 : }
500 : :
501 : : static int
502 : 105871546 : _bdev_malloc_submit_request(struct malloc_channel *mch, struct spdk_bdev_io *bdev_io)
503 : : {
504 [ + - ]: 105871546 : struct malloc_task *task = (struct malloc_task *)bdev_io->driver_ctx;
505 [ + - + - : 105871546 : struct malloc_disk *disk = bdev_io->bdev->ctxt;
+ - + - ]
506 [ + - + - : 105871546 : uint32_t block_size = bdev_io->bdev->blocklen;
+ - + - ]
507 : : int rc;
508 : :
509 [ + + + + : 105871546 : switch (bdev_io->type) {
+ + + + +
+ - - -
- ]
510 : 31634887 : case SPDK_BDEV_IO_TYPE_READ:
511 [ + + + - : 54576299 : if (bdev_io->u.bdev.iovs[0].iov_base == NULL) {
+ - + - +
- + - + -
+ - ]
512 [ + + # # : 3582783 : assert(bdev_io->u.bdev.iovcnt == 1);
# # # # #
# # # ]
513 [ - + # # : 3582783 : assert(bdev_io->u.bdev.memory_domain == NULL);
# # # # #
# # # ]
514 [ # # # # : 3582783 : bdev_io->u.bdev.iovs[0].iov_base =
# # # # #
# # # #
# ]
515 [ # # # # : 7066881 : disk->malloc_buf + bdev_io->u.bdev.offset_blocks * block_size;
# # # # #
# # # ]
516 [ # # # # : 3582783 : bdev_io->u.bdev.iovs[0].iov_len = bdev_io->u.bdev.num_blocks * block_size;
# # # # #
# # # # #
# # # # #
# # # ]
517 [ + + # # : 3582783 : if (spdk_bdev_is_md_separate(bdev_io->bdev)) {
# # ]
518 : 0 : spdk_bdev_io_set_md_buf(bdev_io, malloc_get_md_buf(bdev_io),
519 : 0 : malloc_get_md_len(bdev_io));
520 : 0 : }
521 : 3582783 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_SUCCESS);
522 : 3582783 : return 0;
523 : : }
524 : :
525 [ + + + + : 51573376 : if (bdev_io->bdev->dif_type != SPDK_DIF_DISABLE &&
+ - + - -
+ # # ]
526 : 888385 : spdk_bdev_io_hide_metadata(bdev_io)) {
527 : 891662 : rc = malloc_verify_pi_malloc_buf(bdev_io);
528 [ - + ]: 891662 : if (rc != 0) {
529 : 0 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_FAILED);
530 : 0 : return 0;
531 : : }
532 : 311805 : }
533 : :
534 [ + - + - ]: 51000076 : bdev_malloc_readv(disk, mch->accel_channel, task, bdev_io);
535 : 51000076 : return 0;
536 : :
537 : 29076989 : case SPDK_BDEV_IO_TYPE_WRITE:
538 [ + + + - : 38328682 : if (bdev_io->bdev->dif_type != SPDK_DIF_DISABLE &&
+ - + - -
+ # # ]
539 [ - + ]: 887614 : !spdk_bdev_io_hide_metadata(bdev_io)) {
540 : 0 : rc = malloc_verify_pi_io_buf(bdev_io);
541 [ # # ]: 0 : if (rc != 0) {
542 : 0 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_FAILED);
543 : 0 : return 0;
544 : : }
545 : 0 : }
546 : :
547 [ + - + - ]: 38328682 : bdev_malloc_writev(disk, mch->accel_channel, task, bdev_io);
548 : 38328682 : return 0;
549 : :
550 : 91 : case SPDK_BDEV_IO_TYPE_RESET:
551 : 109 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_SUCCESS);
552 : 109 : return 0;
553 : :
554 : 1057489 : case SPDK_BDEV_IO_TYPE_FLUSH:
555 : 1057489 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_SUCCESS);
556 : 1057489 : return 0;
557 : :
558 : 8533784 : case SPDK_BDEV_IO_TYPE_UNMAP:
559 [ # # # # ]: 13077524 : return bdev_malloc_unmap(disk, mch->accel_channel, task,
560 [ # # # # : 10805654 : bdev_io->u.bdev.offset_blocks * block_size,
# # # # ]
561 [ # # # # : 10805654 : bdev_io->u.bdev.num_blocks * block_size);
# # # # ]
562 : :
563 : 418403 : case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
564 : : /* bdev_malloc_unmap is implemented with a call to mem_cpy_fill which zeroes out all of the requested bytes. */
565 [ # # # # ]: 1008323 : return bdev_malloc_unmap(disk, mch->accel_channel, task,
566 [ # # # # : 713363 : bdev_io->u.bdev.offset_blocks * block_size,
# # # # ]
567 [ # # # # : 713363 : bdev_io->u.bdev.num_blocks * block_size);
# # # # ]
568 : :
569 : 389680 : case SPDK_BDEV_IO_TYPE_ZCOPY:
570 [ + + # # : 389680 : if (bdev_io->u.bdev.zcopy.start) {
# # # # #
# ]
571 : : void *buf;
572 : : size_t len;
573 : :
574 [ # # # # : 194840 : buf = disk->malloc_buf + bdev_io->u.bdev.offset_blocks * block_size;
# # # # #
# # # ]
575 [ # # # # : 194840 : len = bdev_io->u.bdev.num_blocks * block_size;
# # # # ]
576 : 194840 : spdk_bdev_io_set_buf(bdev_io, buf, len);
577 [ - + # # : 194840 : if (spdk_bdev_is_md_separate(bdev_io->bdev)) {
# # ]
578 : 0 : spdk_bdev_io_set_md_buf(bdev_io, malloc_get_md_buf(bdev_io),
579 : 0 : malloc_get_md_len(bdev_io));
580 : 0 : }
581 : 0 : }
582 : 389680 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_SUCCESS);
583 : 389680 : return 0;
584 : 154 : case SPDK_BDEV_IO_TYPE_ABORT:
585 : 154 : malloc_complete_task(task, mch, SPDK_BDEV_IO_STATUS_FAILED);
586 : 154 : return 0;
587 : 104 : case SPDK_BDEV_IO_TYPE_COPY:
588 [ # # # # ]: 128 : bdev_malloc_copy(disk, mch->accel_channel, task,
589 [ # # # # : 116 : bdev_io->u.bdev.offset_blocks * block_size,
# # # # ]
590 [ # # # # : 116 : bdev_io->u.bdev.copy.src_offset_blocks * block_size,
# # # # #
# ]
591 [ # # # # : 116 : bdev_io->u.bdev.num_blocks * block_size);
# # # # ]
592 : 116 : return 0;
593 : :
594 : 0 : default:
595 : 0 : return -1;
596 : : }
597 : : return 0;
598 : 34766525 : }
599 : :
600 : : static void
601 : 105101102 : bdev_malloc_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
602 : : {
603 : 105101102 : struct malloc_channel *mch = spdk_io_channel_get_ctx(ch);
604 : :
605 [ - + ]: 105101102 : if (_bdev_malloc_submit_request(mch, bdev_io) != 0) {
606 [ # # ]: 0 : malloc_complete_task((struct malloc_task *)bdev_io->driver_ctx, mch,
607 : : SPDK_BDEV_IO_STATUS_FAILED);
608 : 0 : }
609 : 105101102 : }
610 : :
611 : : static bool
612 : 4737985 : bdev_malloc_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
613 : : {
614 [ + + ]: 4737985 : switch (io_type) {
615 : 3471102 : case SPDK_BDEV_IO_TYPE_READ:
616 : : case SPDK_BDEV_IO_TYPE_WRITE:
617 : : case SPDK_BDEV_IO_TYPE_FLUSH:
618 : : case SPDK_BDEV_IO_TYPE_RESET:
619 : : case SPDK_BDEV_IO_TYPE_UNMAP:
620 : : case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
621 : : case SPDK_BDEV_IO_TYPE_ZCOPY:
622 : : case SPDK_BDEV_IO_TYPE_ABORT:
623 : : case SPDK_BDEV_IO_TYPE_COPY:
624 : 4605014 : return true;
625 : :
626 : 131565 : default:
627 : 132971 : return false;
628 : : }
629 : 1135318 : }
630 : :
631 : : static struct spdk_io_channel *
632 : 4785 : bdev_malloc_get_io_channel(void *ctx)
633 : : {
634 : 4785 : return spdk_get_io_channel(&g_malloc_disks);
635 : : }
636 : :
637 : : static void
638 : 230 : bdev_malloc_write_json_config(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)
639 : : {
640 : 230 : spdk_json_write_object_begin(w);
641 : :
642 : 230 : spdk_json_write_named_string(w, "method", "bdev_malloc_create");
643 : :
644 : 230 : spdk_json_write_named_object_begin(w, "params");
645 [ # # # # ]: 230 : spdk_json_write_named_string(w, "name", bdev->name);
646 [ # # # # ]: 230 : spdk_json_write_named_uint64(w, "num_blocks", bdev->blockcnt);
647 [ # # # # ]: 230 : spdk_json_write_named_uint32(w, "block_size", bdev->blocklen);
648 [ # # # # ]: 230 : spdk_json_write_named_uint32(w, "physical_block_size", bdev->phys_blocklen);
649 [ # # ]: 230 : spdk_json_write_named_uuid(w, "uuid", &bdev->uuid);
650 [ # # # # ]: 230 : spdk_json_write_named_uint32(w, "optimal_io_boundary", bdev->optimal_io_boundary);
651 [ # # # # ]: 230 : spdk_json_write_named_uint32(w, "md_size", bdev->md_len);
652 [ # # # # ]: 230 : spdk_json_write_named_uint32(w, "dif_type", bdev->dif_type);
653 [ - + # # : 230 : spdk_json_write_named_bool(w, "dif_is_head_of_md", bdev->dif_is_head_of_md);
# # ]
654 [ # # # # ]: 230 : spdk_json_write_named_uint32(w, "dif_pi_format", bdev->dif_pi_format);
655 : :
656 : 230 : spdk_json_write_object_end(w);
657 : :
658 : 230 : spdk_json_write_object_end(w);
659 : 230 : }
660 : :
661 : : static int
662 : 51529 : bdev_malloc_get_memory_domains(void *ctx, struct spdk_memory_domain **domains, int array_size)
663 : : {
664 : 51529 : struct malloc_disk *malloc_disk = ctx;
665 : : struct spdk_memory_domain *domain;
666 : 51529 : int num_domains = 0;
667 : :
668 [ + + + - : 51529 : if (malloc_disk->disk.dif_type != SPDK_DIF_DISABLE) {
+ - - + ]
669 : 153 : return 0;
670 : : }
671 : :
672 : : /* Report support for every memory domain */
673 [ + + ]: 154128 : for (domain = spdk_memory_domain_get_first(NULL); domain != NULL;
674 : 102752 : domain = spdk_memory_domain_get_next(domain, NULL)) {
675 [ + + + + ]: 102752 : if (domains != NULL && num_domains < array_size) {
676 [ + - + - ]: 24326 : domains[num_domains] = domain;
677 : 86 : }
678 [ + - ]: 102752 : num_domains++;
679 : 2702 : }
680 : :
681 : 51376 : return num_domains;
682 : 1381 : }
683 : :
684 : : static bool
685 : 401184 : bdev_malloc_accel_sequence_supported(void *ctx, enum spdk_bdev_io_type type)
686 : : {
687 [ + + ]: 401184 : switch (type) {
688 : 36468 : case SPDK_BDEV_IO_TYPE_READ:
689 : : case SPDK_BDEV_IO_TYPE_WRITE:
690 : 38208 : return true;
691 : 346446 : default:
692 : 362976 : return false;
693 : : }
694 : 18270 : }
695 : :
696 : : static const struct spdk_bdev_fn_table malloc_fn_table = {
697 : : .destruct = bdev_malloc_destruct,
698 : : .submit_request = bdev_malloc_submit_request,
699 : : .io_type_supported = bdev_malloc_io_type_supported,
700 : : .get_io_channel = bdev_malloc_get_io_channel,
701 : : .write_config_json = bdev_malloc_write_json_config,
702 : : .get_memory_domains = bdev_malloc_get_memory_domains,
703 : : .accel_sequence_supported = bdev_malloc_accel_sequence_supported,
704 : : };
705 : :
706 : : static int
707 : 15 : malloc_disk_setup_pi(struct malloc_disk *mdisk)
708 : : {
709 [ # # ]: 15 : struct spdk_bdev *bdev = &mdisk->disk;
710 : 9 : struct spdk_dif_ctx dif_ctx;
711 : 9 : struct iovec iov, md_iov;
712 : : uint32_t dif_check_flags;
713 : : int rc;
714 : 9 : struct spdk_dif_ctx_init_ext_opts dif_opts;
715 : :
716 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
717 [ # # # # : 15 : dif_opts.dif_pi_format = bdev->dif_pi_format;
# # ]
718 : : /* Set APPTAG|REFTAG_IGNORE to PI fields after creation of malloc bdev */
719 [ # # # # ]: 15 : dif_check_flags = bdev->dif_check_flags | SPDK_DIF_CHECK_TYPE_REFTAG |
720 [ # # ]: 0 : SPDK_DIF_FLAGS_APPTAG_CHECK;
721 : 24 : rc = spdk_dif_ctx_init(&dif_ctx,
722 [ # # # # ]: 3 : bdev->blocklen,
723 [ # # # # ]: 3 : bdev->md_len,
724 [ - + # # : 15 : bdev->md_interleave,
# # ]
725 [ - + # # : 15 : bdev->dif_is_head_of_md,
# # ]
726 [ # # # # ]: 3 : bdev->dif_type,
727 : 3 : dif_check_flags,
728 : : SPDK_DIF_REFTAG_IGNORE,
729 : : 0xFFFF, SPDK_DIF_APPTAG_IGNORE,
730 : : 0, 0, &dif_opts);
731 [ - + ]: 15 : if (rc != 0) {
732 : 0 : SPDK_ERRLOG("Initialization of DIF/DIX context failed\n");
733 : 0 : return rc;
734 : : }
735 : :
736 [ # # # # ]: 15 : iov.iov_base = mdisk->malloc_buf;
737 [ # # # # : 15 : iov.iov_len = bdev->blockcnt * bdev->blocklen;
# # # # #
# ]
738 : :
739 [ + + + - : 15 : if (mdisk->disk.md_interleave) {
# # # # #
# ]
740 [ # # # # ]: 15 : rc = spdk_dif_generate(&iov, 1, bdev->blockcnt, &dif_ctx);
741 : 3 : } else {
742 [ # # # # ]: 0 : md_iov.iov_base = mdisk->malloc_md_buf;
743 [ # # # # : 0 : md_iov.iov_len = bdev->blockcnt * bdev->md_len;
# # # # #
# ]
744 : :
745 [ # # # # ]: 0 : rc = spdk_dix_generate(&iov, 1, &md_iov, bdev->blockcnt, &dif_ctx);
746 : : }
747 : :
748 [ + + ]: 15 : if (rc != 0) {
749 : 0 : SPDK_ERRLOG("Formatting by DIF/DIX failed\n");
750 : 0 : }
751 : :
752 : 15 : return rc;
753 : 3 : }
754 : :
755 : : int
756 : 1669 : create_malloc_disk(struct spdk_bdev **bdev, const struct malloc_bdev_opts *opts)
757 : : {
758 : : struct malloc_disk *mdisk;
759 : : uint32_t block_size;
760 : : int rc;
761 : :
762 [ + + # # ]: 1669 : assert(opts != NULL);
763 : :
764 [ + + + - : 1669 : if (opts->num_blocks == 0) {
+ - ]
765 : 0 : SPDK_ERRLOG("Disk num_blocks must be greater than 0");
766 : 0 : return -EINVAL;
767 : : }
768 : :
769 [ + + + - : 1669 : if (opts->block_size % 512) {
+ - - + ]
770 : 0 : SPDK_ERRLOG("Data block size must be 512 bytes aligned\n");
771 : 0 : return -EINVAL;
772 : : }
773 : :
774 [ + + + - : 1669 : if (opts->physical_block_size % 512) {
+ - - + ]
775 : 0 : SPDK_ERRLOG("Physical block must be 512 bytes aligned\n");
776 : 0 : return -EINVAL;
777 : : }
778 : :
779 [ + - + - : 1669 : switch (opts->md_size) {
- + ]
780 : 1508 : case 0:
781 : : case 8:
782 : : case 16:
783 : : case 32:
784 : : case 64:
785 : : case 128:
786 : 1669 : break;
787 : 0 : default:
788 [ # # # # ]: 0 : SPDK_ERRLOG("metadata size %u is not supported\n", opts->md_size);
789 : 0 : return -EINVAL;
790 : : }
791 : :
792 [ + + + + : 1669 : if (opts->md_interleave) {
+ - - + ]
793 [ # # # # : 22 : block_size = opts->block_size + opts->md_size;
# # # # ]
794 : 3 : } else {
795 [ + - + - ]: 1647 : block_size = opts->block_size;
796 : : }
797 : :
798 : 1669 : mdisk = calloc(1, sizeof(*mdisk));
799 [ + + ]: 1669 : if (!mdisk) {
800 : 0 : SPDK_ERRLOG("mdisk calloc() failed\n");
801 : 0 : return -ENOMEM;
802 : : }
803 : :
804 : : /*
805 : : * Allocate the large backend memory buffer from pinned memory.
806 : : *
807 : : * TODO: need to pass a hint so we know which socket to allocate
808 : : * from on multi-socket systems.
809 : : */
810 [ + - + - : 1669 : mdisk->malloc_buf = spdk_zmalloc(opts->num_blocks * block_size, 2 * 1024 * 1024, NULL,
+ - + - ]
811 : : SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
812 [ + + + - : 1669 : if (!mdisk->malloc_buf) {
+ - ]
813 : 0 : SPDK_ERRLOG("malloc_buf spdk_zmalloc() failed\n");
814 : 0 : malloc_disk_free(mdisk);
815 : 0 : return -ENOMEM;
816 : : }
817 : :
818 [ + + + + : 1669 : if (!opts->md_interleave && opts->md_size != 0) {
+ + + - +
- + - +
- ]
819 [ # # # # : 7 : mdisk->malloc_md_buf = spdk_zmalloc(opts->num_blocks * opts->md_size, 2 * 1024 * 1024, NULL,
# # # # #
# # # ]
820 : : SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
821 [ - + # # : 7 : if (!mdisk->malloc_md_buf) {
# # ]
822 : 0 : SPDK_ERRLOG("malloc_md_buf spdk_zmalloc() failed\n");
823 : 0 : malloc_disk_free(mdisk);
824 : 0 : return -ENOMEM;
825 : : }
826 : 0 : }
827 : :
828 [ + + + - : 1669 : if (opts->name) {
+ + ]
829 [ + + + - : 1364 : mdisk->disk.name = strdup(opts->name);
+ - + - +
- + - ]
830 : 147 : } else {
831 : : /* Auto-generate a name */
832 [ + - + - : 305 : mdisk->disk.name = spdk_sprintf_alloc("Malloc%d", malloc_disk_count);
+ - ]
833 [ + - ]: 305 : malloc_disk_count++;
834 : : }
835 [ + + + - : 1669 : if (!mdisk->disk.name) {
+ - + - ]
836 : 0 : malloc_disk_free(mdisk);
837 : 0 : return -ENOMEM;
838 : : }
839 [ + - + - : 1669 : mdisk->disk.product_name = "Malloc disk";
+ - ]
840 : :
841 [ + - + - : 1669 : mdisk->disk.write_cache = 1;
+ - ]
842 [ + - + - : 1669 : mdisk->disk.blocklen = block_size;
+ - ]
843 [ + - + - : 1669 : mdisk->disk.phys_blocklen = opts->physical_block_size;
+ - + - +
- ]
844 [ + - + - : 1669 : mdisk->disk.blockcnt = opts->num_blocks;
+ - + - +
- ]
845 [ + - + - : 1669 : mdisk->disk.md_len = opts->md_size;
+ - + - +
- ]
846 [ + + + - : 1669 : mdisk->disk.md_interleave = opts->md_interleave;
+ - + - +
- + - ]
847 [ + - + - : 1669 : mdisk->disk.dif_type = opts->dif_type;
+ - + - +
- ]
848 [ + + + - : 1669 : mdisk->disk.dif_is_head_of_md = opts->dif_is_head_of_md;
+ - + - +
- + - ]
849 : : /* Current block device layer API does not propagate
850 : : * any DIF related information from user. So, we can
851 : : * not generate or verify Application Tag.
852 : : */
853 [ + - + + : 1669 : switch (opts->dif_type) {
- - - + ]
854 : 12 : case SPDK_DIF_TYPE1:
855 : : case SPDK_DIF_TYPE2:
856 [ # # # # : 15 : mdisk->disk.dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK |
# # # # ]
857 [ # # ]: 0 : SPDK_DIF_FLAGS_REFTAG_CHECK;
858 : 15 : break;
859 : 0 : case SPDK_DIF_TYPE3:
860 [ # # # # : 0 : mdisk->disk.dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK;
# # # # ]
861 : 0 : break;
862 : 1496 : case SPDK_DIF_DISABLE:
863 : 1654 : break;
864 : : }
865 [ + - + - : 1669 : mdisk->disk.dif_pi_format = opts->dif_pi_format;
+ - + - +
- ]
866 : :
867 [ + + + - : 1669 : if (opts->dif_type != SPDK_DIF_DISABLE) {
+ - ]
868 : 15 : rc = malloc_disk_setup_pi(mdisk);
869 [ - + ]: 15 : if (rc) {
870 : 0 : SPDK_ERRLOG("Failed to set up protection information.\n");
871 : 0 : malloc_disk_free(mdisk);
872 : 0 : return rc;
873 : : }
874 : 3 : }
875 : :
876 [ + + + - : 1669 : if (opts->optimal_io_boundary) {
+ - ]
877 [ # # # # : 3 : mdisk->disk.optimal_io_boundary = opts->optimal_io_boundary;
# # # # #
# ]
878 [ # # # # : 3 : mdisk->disk.split_on_optimal_io_boundary = true;
# # ]
879 : 0 : }
880 [ + + + + ]: 1669 : if (!spdk_uuid_is_null(&opts->uuid)) {
881 [ + - + - : 611 : spdk_uuid_copy(&mdisk->disk.uuid, &opts->uuid);
+ - ]
882 : 113 : }
883 : :
884 [ + - + - : 1669 : mdisk->disk.max_copy = 0;
+ - ]
885 [ + - + - : 1669 : mdisk->disk.ctxt = mdisk;
+ - ]
886 [ + - + - : 1669 : mdisk->disk.fn_table = &malloc_fn_table;
+ - ]
887 [ + - + - : 1669 : mdisk->disk.module = &malloc_if;
+ - ]
888 : :
889 [ + - ]: 1669 : rc = spdk_bdev_register(&mdisk->disk);
890 [ - + ]: 1669 : if (rc) {
891 : 0 : malloc_disk_free(mdisk);
892 : 0 : return rc;
893 : : }
894 : :
895 [ + - + - ]: 1669 : *bdev = &(mdisk->disk);
896 : :
897 [ + - + - : 1669 : TAILQ_INSERT_TAIL(&g_malloc_disks, mdisk, link);
+ - + - +
- + - + -
+ - + - +
- + - +
- ]
898 : :
899 : 1669 : return rc;
900 : 161 : }
901 : :
902 : : void
903 : 397 : delete_malloc_disk(const char *name, spdk_delete_malloc_complete cb_fn, void *cb_arg)
904 : : {
905 : : int rc;
906 : :
907 : 397 : rc = spdk_bdev_unregister_by_name(name, &malloc_if, cb_fn, cb_arg);
908 [ - + ]: 397 : if (rc != 0) {
909 [ # # # # ]: 0 : cb_fn(cb_arg, rc);
910 : 0 : }
911 : 397 : }
912 : :
913 : : static int
914 : 503305256 : malloc_completion_poller(void *ctx)
915 : : {
916 : 503305256 : struct malloc_channel *ch = ctx;
917 : : struct malloc_task *task;
918 : 328971257 : TAILQ_HEAD(, malloc_task) completed_tasks;
919 : 503305256 : uint32_t num_completions = 0;
920 : :
921 [ + - ]: 503305256 : TAILQ_INIT(&completed_tasks);
922 [ + + + + : 503305256 : TAILQ_SWAP(&completed_tasks, &ch->completed_tasks, malloc_task, tailq);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- # # # #
# # + - +
- + - + -
+ - # # #
# # # # #
# # + - +
- + - + -
+ - ]
923 : :
924 [ + + ]: 508335494 : while (!TAILQ_EMPTY(&completed_tasks)) {
925 : 5030238 : task = TAILQ_FIRST(&completed_tasks);
926 [ + + # # : 5030238 : TAILQ_REMOVE(&completed_tasks, task, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
927 [ # # # # ]: 5030238 : spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task), task->status);
928 : 5030238 : num_completions++;
929 : : }
930 : :
931 : 503305256 : return num_completions > 0 ? SPDK_POLLER_BUSY : SPDK_POLLER_IDLE;
932 : : }
933 : :
934 : : static int
935 : 3519 : malloc_create_channel_cb(void *io_device, void *ctx)
936 : : {
937 : 3519 : struct malloc_channel *ch = ctx;
938 : :
939 [ + - + - ]: 3519 : ch->accel_channel = spdk_accel_get_io_channel();
940 [ + + + - : 3519 : if (!ch->accel_channel) {
+ - ]
941 : 0 : SPDK_ERRLOG("Failed to get accel framework's IO channel\n");
942 : 0 : return -ENOMEM;
943 : : }
944 : :
945 [ + - + - ]: 3519 : ch->completion_poller = SPDK_POLLER_REGISTER(malloc_completion_poller, ch, 0);
946 [ + + + - : 3519 : if (!ch->completion_poller) {
+ - ]
947 : 0 : SPDK_ERRLOG("Failed to register malloc completion poller\n");
948 [ # # # # ]: 0 : spdk_put_io_channel(ch->accel_channel);
949 : 0 : return -ENOMEM;
950 : : }
951 : :
952 [ + - + - : 3519 : TAILQ_INIT(&ch->completed_tasks);
+ - + - +
- + - + -
+ - ]
953 : :
954 : 3519 : return 0;
955 : 344 : }
956 : :
957 : : static void
958 : 3519 : malloc_destroy_channel_cb(void *io_device, void *ctx)
959 : : {
960 : 3519 : struct malloc_channel *ch = ctx;
961 : :
962 [ + + + - : 3519 : assert(TAILQ_EMPTY(&ch->completed_tasks));
+ - + - #
# ]
963 : :
964 [ + - + - ]: 3519 : spdk_put_io_channel(ch->accel_channel);
965 [ + - ]: 3519 : spdk_poller_unregister(&ch->completion_poller);
966 : 3519 : }
967 : :
968 : : static int
969 : 1608 : bdev_malloc_initialize(void)
970 : : {
971 : : /* This needs to be reset for each reinitialization of submodules.
972 : : * Otherwise after enough devices or reinitializations the value gets too high.
973 : : * TODO: Make malloc bdev name mandatory and remove this counter. */
974 : 1608 : malloc_disk_count = 0;
975 : :
976 : 1608 : spdk_io_device_register(&g_malloc_disks, malloc_create_channel_cb,
977 : : malloc_destroy_channel_cb, sizeof(struct malloc_channel),
978 : : "bdev_malloc");
979 : :
980 : 1608 : return 0;
981 : : }
982 : :
983 : : static void
984 : 1608 : bdev_malloc_deinitialize(void)
985 : : {
986 : 1608 : spdk_io_device_unregister(&g_malloc_disks, NULL);
987 : 1608 : }
988 : :
989 : 1727 : SPDK_LOG_REGISTER_COMPONENT(bdev_malloc)
|