Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2020 Intel Corporation.
3 : : * Copyright (c) 2022, 2023 NVIDIA CORPORATION & AFFILIATES.
4 : : * All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "spdk/accel_module.h"
10 : :
11 : : #include "accel_internal.h"
12 : :
13 : : #include "spdk/dma.h"
14 : : #include "spdk/env.h"
15 : : #include "spdk/likely.h"
16 : : #include "spdk/log.h"
17 : : #include "spdk/thread.h"
18 : : #include "spdk/json.h"
19 : : #include "spdk/crc32.h"
20 : : #include "spdk/util.h"
21 : : #include "spdk/hexlify.h"
22 : : #include "spdk/string.h"
23 : :
24 : : /* Accelerator Framework: The following provides a top level
25 : : * generic API for the accelerator functions defined here. Modules,
26 : : * such as the one in /module/accel/ioat, supply the implementation
27 : : * with the exception of the pure software implementation contained
28 : : * later in this file.
29 : : */
30 : :
31 : : #define ALIGN_4K 0x1000
32 : : #define MAX_TASKS_PER_CHANNEL 0x800
33 : : #define ACCEL_SMALL_CACHE_SIZE 128
34 : : #define ACCEL_LARGE_CACHE_SIZE 16
35 : : /* Set MSB, so we don't return NULL pointers as buffers */
36 : : #define ACCEL_BUFFER_BASE ((void *)(1ull << 63))
37 : : #define ACCEL_BUFFER_OFFSET_MASK ((uintptr_t)ACCEL_BUFFER_BASE - 1)
38 : :
39 : : #define ACCEL_CRYPTO_TWEAK_MODE_DEFAULT SPDK_ACCEL_CRYPTO_TWEAK_MODE_SIMPLE_LBA
40 : : #define ACCEL_TASKS_IN_SEQUENCE_LIMIT 8
41 : :
42 : : struct accel_module {
43 : : struct spdk_accel_module_if *module;
44 : : bool supports_memory_domains;
45 : : };
46 : :
47 : : /* Largest context size for all accel modules */
48 : : static size_t g_max_accel_module_size = sizeof(struct spdk_accel_task);
49 : :
50 : : static struct spdk_accel_module_if *g_accel_module = NULL;
51 : : static spdk_accel_fini_cb g_fini_cb_fn = NULL;
52 : : static void *g_fini_cb_arg = NULL;
53 : : static bool g_modules_started = false;
54 : : static struct spdk_memory_domain *g_accel_domain;
55 : :
56 : : /* Global list of registered accelerator modules */
57 : : static TAILQ_HEAD(, spdk_accel_module_if) spdk_accel_module_list =
58 : : TAILQ_HEAD_INITIALIZER(spdk_accel_module_list);
59 : :
60 : : /* Crypto keyring */
61 : : static TAILQ_HEAD(, spdk_accel_crypto_key) g_keyring = TAILQ_HEAD_INITIALIZER(g_keyring);
62 : : static struct spdk_spinlock g_keyring_spin;
63 : :
64 : : /* Global array mapping capabilities to modules */
65 : : static struct accel_module g_modules_opc[SPDK_ACCEL_OPC_LAST] = {};
66 : : static char *g_modules_opc_override[SPDK_ACCEL_OPC_LAST] = {};
67 : : TAILQ_HEAD(, spdk_accel_driver) g_accel_drivers = TAILQ_HEAD_INITIALIZER(g_accel_drivers);
68 : : static struct spdk_accel_driver *g_accel_driver;
69 : : static struct spdk_accel_opts g_opts = {
70 : : .small_cache_size = ACCEL_SMALL_CACHE_SIZE,
71 : : .large_cache_size = ACCEL_LARGE_CACHE_SIZE,
72 : : .task_count = MAX_TASKS_PER_CHANNEL,
73 : : .sequence_count = MAX_TASKS_PER_CHANNEL,
74 : : .buf_count = MAX_TASKS_PER_CHANNEL,
75 : : };
76 : : static struct accel_stats g_stats;
77 : : static struct spdk_spinlock g_stats_lock;
78 : :
79 : : static const char *g_opcode_strings[SPDK_ACCEL_OPC_LAST] = {
80 : : "copy", "fill", "dualcast", "compare", "crc32c", "copy_crc32c",
81 : : "compress", "decompress", "encrypt", "decrypt", "xor",
82 : : "dif_verify", "dif_verify_copy", "dif_generate", "dif_generate_copy"
83 : : };
84 : :
85 : : enum accel_sequence_state {
86 : : ACCEL_SEQUENCE_STATE_INIT,
87 : : ACCEL_SEQUENCE_STATE_CHECK_VIRTBUF,
88 : : ACCEL_SEQUENCE_STATE_AWAIT_VIRTBUF,
89 : : ACCEL_SEQUENCE_STATE_CHECK_BOUNCEBUF,
90 : : ACCEL_SEQUENCE_STATE_AWAIT_BOUNCEBUF,
91 : : ACCEL_SEQUENCE_STATE_PULL_DATA,
92 : : ACCEL_SEQUENCE_STATE_AWAIT_PULL_DATA,
93 : : ACCEL_SEQUENCE_STATE_EXEC_TASK,
94 : : ACCEL_SEQUENCE_STATE_AWAIT_TASK,
95 : : ACCEL_SEQUENCE_STATE_COMPLETE_TASK,
96 : : ACCEL_SEQUENCE_STATE_NEXT_TASK,
97 : : ACCEL_SEQUENCE_STATE_PUSH_DATA,
98 : : ACCEL_SEQUENCE_STATE_AWAIT_PUSH_DATA,
99 : : ACCEL_SEQUENCE_STATE_DRIVER_EXEC_TASKS,
100 : : ACCEL_SEQUENCE_STATE_DRIVER_AWAIT_TASKS,
101 : : ACCEL_SEQUENCE_STATE_DRIVER_COMPLETE_TASKS,
102 : : ACCEL_SEQUENCE_STATE_ERROR,
103 : : ACCEL_SEQUENCE_STATE_MAX,
104 : : };
105 : :
106 : : static const char *g_seq_states[]
107 : : __attribute__((unused)) = {
108 : : [ACCEL_SEQUENCE_STATE_INIT] = "init",
109 : : [ACCEL_SEQUENCE_STATE_CHECK_VIRTBUF] = "check-virtbuf",
110 : : [ACCEL_SEQUENCE_STATE_AWAIT_VIRTBUF] = "await-virtbuf",
111 : : [ACCEL_SEQUENCE_STATE_CHECK_BOUNCEBUF] = "check-bouncebuf",
112 : : [ACCEL_SEQUENCE_STATE_AWAIT_BOUNCEBUF] = "await-bouncebuf",
113 : : [ACCEL_SEQUENCE_STATE_PULL_DATA] = "pull-data",
114 : : [ACCEL_SEQUENCE_STATE_AWAIT_PULL_DATA] = "await-pull-data",
115 : : [ACCEL_SEQUENCE_STATE_EXEC_TASK] = "exec-task",
116 : : [ACCEL_SEQUENCE_STATE_AWAIT_TASK] = "await-task",
117 : : [ACCEL_SEQUENCE_STATE_COMPLETE_TASK] = "complete-task",
118 : : [ACCEL_SEQUENCE_STATE_NEXT_TASK] = "next-task",
119 : : [ACCEL_SEQUENCE_STATE_PUSH_DATA] = "push-data",
120 : : [ACCEL_SEQUENCE_STATE_AWAIT_PUSH_DATA] = "await-push-data",
121 : : [ACCEL_SEQUENCE_STATE_DRIVER_EXEC_TASKS] = "driver-exec-tasks",
122 : : [ACCEL_SEQUENCE_STATE_DRIVER_AWAIT_TASKS] = "driver-await-tasks",
123 : : [ACCEL_SEQUENCE_STATE_DRIVER_COMPLETE_TASKS] = "driver-complete-tasks",
124 : : [ACCEL_SEQUENCE_STATE_ERROR] = "error",
125 : : [ACCEL_SEQUENCE_STATE_MAX] = "",
126 : : };
127 : :
128 : : #define ACCEL_SEQUENCE_STATE_STRING(s) \
129 : : (((s) >= ACCEL_SEQUENCE_STATE_INIT && (s) < ACCEL_SEQUENCE_STATE_MAX) \
130 : : ? g_seq_states[s] : "unknown")
131 : :
132 : : struct accel_buffer {
133 : : struct spdk_accel_sequence *seq;
134 : : void *buf;
135 : : uint64_t len;
136 : : struct spdk_iobuf_entry iobuf;
137 : : spdk_accel_sequence_get_buf_cb cb_fn;
138 : : void *cb_ctx;
139 : : SLIST_ENTRY(accel_buffer) link;
140 : : struct accel_io_channel *ch;
141 : : };
142 : :
143 : : struct accel_io_channel {
144 : : struct spdk_io_channel *module_ch[SPDK_ACCEL_OPC_LAST];
145 : : struct spdk_io_channel *driver_channel;
146 : : void *task_pool_base;
147 : : struct spdk_accel_sequence *seq_pool_base;
148 : : struct accel_buffer *buf_pool_base;
149 : : struct spdk_accel_task_aux_data *task_aux_data_base;
150 : : STAILQ_HEAD(, spdk_accel_task) task_pool;
151 : : SLIST_HEAD(, spdk_accel_task_aux_data) task_aux_data_pool;
152 : : SLIST_HEAD(, spdk_accel_sequence) seq_pool;
153 : : SLIST_HEAD(, accel_buffer) buf_pool;
154 : : struct spdk_iobuf_channel iobuf;
155 : : struct accel_stats stats;
156 : : };
157 : :
158 : : TAILQ_HEAD(accel_sequence_tasks, spdk_accel_task);
159 : :
160 : : struct spdk_accel_sequence {
161 : : struct accel_io_channel *ch;
162 : : struct accel_sequence_tasks tasks;
163 : : SLIST_HEAD(, accel_buffer) bounce_bufs;
164 : : int status;
165 : : /* state uses enum accel_sequence_state */
166 : : uint8_t state;
167 : : bool in_process_sequence;
168 : : spdk_accel_completion_cb cb_fn;
169 : : void *cb_arg;
170 : : SLIST_ENTRY(spdk_accel_sequence) link;
171 : : };
172 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_accel_sequence) == 64, "invalid size");
173 : :
174 : : #define accel_update_stats(ch, event, v) \
175 : : do { \
176 : : (ch)->stats.event += (v); \
177 : : } while (0)
178 : :
179 : : #define accel_update_task_stats(ch, task, event, v) \
180 : : accel_update_stats(ch, operations[(task)->op_code].event, v)
181 : :
182 : : static inline void accel_sequence_task_cb(void *cb_arg, int status);
183 : :
184 : : static inline void
185 : 619610446 : accel_sequence_set_state(struct spdk_accel_sequence *seq, enum accel_sequence_state state)
186 : : {
187 [ - + - + : 619610446 : SPDK_DEBUGLOG(accel, "seq=%p, setting state: %s -> %s\n", seq,
- - - - ]
188 : : ACCEL_SEQUENCE_STATE_STRING(seq->state), ACCEL_SEQUENCE_STATE_STRING(state));
189 [ - + - - ]: 619610446 : assert(seq->state != ACCEL_SEQUENCE_STATE_ERROR || state == ACCEL_SEQUENCE_STATE_ERROR);
190 : 619610446 : seq->state = state;
191 : 619610446 : }
192 : :
193 : : static void
194 : 36 : accel_sequence_set_fail(struct spdk_accel_sequence *seq, int status)
195 : : {
196 : 36 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_ERROR);
197 [ - + ]: 36 : assert(status != 0);
198 : 36 : seq->status = status;
199 : 36 : }
200 : :
201 : : int
202 : 1274 : spdk_accel_get_opc_module_name(enum spdk_accel_opcode opcode, const char **module_name)
203 : : {
204 [ - + ]: 1274 : if (opcode >= SPDK_ACCEL_OPC_LAST) {
205 : : /* invalid opcode */
206 : 0 : return -EINVAL;
207 : : }
208 : :
209 [ + - ]: 1274 : if (g_modules_opc[opcode].module) {
210 : 1274 : *module_name = g_modules_opc[opcode].module->name;
211 : : } else {
212 : 0 : return -ENOENT;
213 : : }
214 : :
215 : 1274 : return 0;
216 : : }
217 : :
218 : : void
219 : 0 : _accel_for_each_module(struct module_info *info, _accel_for_each_module_fn fn)
220 : : {
221 : : struct spdk_accel_module_if *accel_module;
222 : : enum spdk_accel_opcode opcode;
223 : 0 : int j = 0;
224 : :
225 [ # # ]: 0 : TAILQ_FOREACH(accel_module, &spdk_accel_module_list, tailq) {
226 [ # # ]: 0 : for (opcode = 0; opcode < SPDK_ACCEL_OPC_LAST; opcode++) {
227 [ # # ]: 0 : if (accel_module->supports_opcode(opcode)) {
228 : 0 : info->ops[j] = opcode;
229 : 0 : j++;
230 : : }
231 : : }
232 : 0 : info->name = accel_module->name;
233 : 0 : info->num_ops = j;
234 : 0 : fn(info);
235 : 0 : j = 0;
236 : : }
237 : 0 : }
238 : :
239 : : const char *
240 : 1355 : spdk_accel_get_opcode_name(enum spdk_accel_opcode opcode)
241 : : {
242 [ + - ]: 1355 : if (opcode < SPDK_ACCEL_OPC_LAST) {
243 : 1355 : return g_opcode_strings[opcode];
244 : : }
245 : :
246 : 0 : return NULL;
247 : : }
248 : :
249 : : int
250 : 89 : spdk_accel_assign_opc(enum spdk_accel_opcode opcode, const char *name)
251 : : {
252 : : char *copy;
253 : :
254 [ - + - + ]: 89 : if (g_modules_started == true) {
255 : : /* we don't allow re-assignment once things have started */
256 : 0 : return -EINVAL;
257 : : }
258 : :
259 [ - + ]: 89 : if (opcode >= SPDK_ACCEL_OPC_LAST) {
260 : : /* invalid opcode */
261 : 0 : return -EINVAL;
262 : : }
263 : :
264 [ - + ]: 89 : copy = strdup(name);
265 [ - + ]: 89 : if (copy == NULL) {
266 : 0 : return -ENOMEM;
267 : : }
268 : :
269 : : /* module selection will be validated after the framework starts. */
270 : 89 : free(g_modules_opc_override[opcode]);
271 : 89 : g_modules_opc_override[opcode] = copy;
272 : :
273 : 89 : return 0;
274 : : }
275 : :
276 : : inline static struct spdk_accel_task *
277 : 219200711 : _get_task(struct accel_io_channel *accel_ch, spdk_accel_completion_cb cb_fn, void *cb_arg)
278 : : {
279 : : struct spdk_accel_task *accel_task;
280 : :
281 : 219200711 : accel_task = STAILQ_FIRST(&accel_ch->task_pool);
282 [ + + ]: 219200711 : if (spdk_unlikely(accel_task == NULL)) {
283 : 268 : accel_update_stats(accel_ch, retry.task, 1);
284 : 268 : return NULL;
285 : : }
286 : :
287 : 219200437 : accel_update_stats(accel_ch, task_outstanding, 1);
288 [ + + ]: 219200437 : STAILQ_REMOVE_HEAD(&accel_ch->task_pool, link);
289 : 219200437 : accel_task->link.stqe_next = NULL;
290 : :
291 : 219200437 : accel_task->cb_fn = cb_fn;
292 : 219200437 : accel_task->cb_arg = cb_arg;
293 : 219200437 : accel_task->accel_ch = accel_ch;
294 : 219200437 : accel_task->s.iovs = NULL;
295 : 219200437 : accel_task->d.iovs = NULL;
296 : :
297 : 219200437 : return accel_task;
298 : : }
299 : :
300 : : static void
301 : 219200405 : _put_task(struct accel_io_channel *ch, struct spdk_accel_task *task)
302 : : {
303 [ + + ]: 219200405 : STAILQ_INSERT_HEAD(&ch->task_pool, task, link);
304 : 219200405 : accel_update_stats(ch, task_outstanding, -1);
305 : 219200405 : }
306 : :
307 : : void
308 : 216022190 : spdk_accel_task_complete(struct spdk_accel_task *accel_task, int status)
309 : : {
310 : 216022190 : struct accel_io_channel *accel_ch = accel_task->accel_ch;
311 : : spdk_accel_completion_cb cb_fn;
312 : : void *cb_arg;
313 : :
314 : 216022190 : accel_update_task_stats(accel_ch, accel_task, executed, 1);
315 : 216022190 : accel_update_task_stats(accel_ch, accel_task, num_bytes, accel_task->nbytes);
316 [ + + ]: 216022190 : if (spdk_unlikely(status != 0)) {
317 : 192 : accel_update_task_stats(accel_ch, accel_task, failed, 1);
318 : : }
319 : :
320 [ + + ]: 216022190 : if (accel_task->seq) {
321 : 88245801 : accel_sequence_task_cb(accel_task->seq, status);
322 : 88245801 : return;
323 : : }
324 : :
325 : 127776359 : cb_fn = accel_task->cb_fn;
326 : 127776359 : cb_arg = accel_task->cb_arg;
327 : :
328 [ + + + + ]: 127776359 : if (accel_task->has_aux) {
329 : 89818850 : SLIST_INSERT_HEAD(&accel_ch->task_aux_data_pool, accel_task->aux, link);
330 : 89818850 : accel_task->aux = NULL;
331 : 89818850 : accel_task->has_aux = false;
332 : : }
333 : :
334 : : /* We should put the accel_task into the list firstly in order to avoid
335 : : * the accel task list is exhausted when there is recursive call to
336 : : * allocate accel_task in user's call back function (cb_fn)
337 : : */
338 : 127776359 : _put_task(accel_ch, accel_task);
339 : :
340 : 127776359 : cb_fn(cb_arg, status);
341 : : }
342 : :
343 : : static inline int
344 : 216022178 : accel_submit_task(struct accel_io_channel *accel_ch, struct spdk_accel_task *task)
345 : : {
346 : 216022178 : struct spdk_io_channel *module_ch = accel_ch->module_ch[task->op_code];
347 : 216022178 : struct spdk_accel_module_if *module = g_modules_opc[task->op_code].module;
348 : : int rc;
349 : :
350 : 216022178 : rc = module->submit_tasks(module_ch, task);
351 [ + + ]: 216022178 : if (spdk_unlikely(rc != 0)) {
352 : 8 : accel_update_task_stats(accel_ch, task, failed, 1);
353 : : }
354 : :
355 : 216022178 : return rc;
356 : : }
357 : :
358 : : static inline uint64_t
359 : 133073816 : accel_get_iovlen(struct iovec *iovs, uint32_t iovcnt)
360 : : {
361 : 133073816 : uint64_t result = 0;
362 : : uint32_t i;
363 : :
364 [ + + ]: 280046641 : for (i = 0; i < iovcnt; ++i) {
365 : 146972825 : result += iovs[i].iov_len;
366 : : }
367 : :
368 : 133073816 : return result;
369 : : }
370 : :
371 : : #define ACCEL_TASK_ALLOC_AUX_BUF(task) \
372 : : do { \
373 : : (task)->aux = SLIST_FIRST(&(task)->accel_ch->task_aux_data_pool); \
374 : : if (spdk_unlikely(!(task)->aux)) { \
375 : : SPDK_ERRLOG("Fatal problem, aux data was not allocated\n"); \
376 : : _put_task(task->accel_ch, task); \
377 : : assert(0); \
378 : : return -ENOMEM; \
379 : : } \
380 : : SLIST_REMOVE_HEAD(&(task)->accel_ch->task_aux_data_pool, link); \
381 : : (task)->has_aux = true; \
382 : : } while (0)
383 : :
384 : : /* Accel framework public API for copy function */
385 : : int
386 : 10174973 : spdk_accel_submit_copy(struct spdk_io_channel *ch, void *dst, void *src,
387 : : uint64_t nbytes, spdk_accel_completion_cb cb_fn, void *cb_arg)
388 : : {
389 : 10174973 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
390 : : struct spdk_accel_task *accel_task;
391 : :
392 : 10174973 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
393 [ + + ]: 10174973 : if (spdk_unlikely(accel_task == NULL)) {
394 : 4 : return -ENOMEM;
395 : : }
396 : :
397 [ - + ]: 10174969 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
398 : :
399 : 10174969 : accel_task->s.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_SRC];
400 : 10174969 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
401 : 10174969 : accel_task->d.iovs[0].iov_base = dst;
402 : 10174969 : accel_task->d.iovs[0].iov_len = nbytes;
403 : 10174969 : accel_task->d.iovcnt = 1;
404 : 10174969 : accel_task->s.iovs[0].iov_base = src;
405 : 10174969 : accel_task->s.iovs[0].iov_len = nbytes;
406 : 10174969 : accel_task->s.iovcnt = 1;
407 : 10174969 : accel_task->nbytes = nbytes;
408 : 10174969 : accel_task->op_code = SPDK_ACCEL_OPC_COPY;
409 : 10174969 : accel_task->src_domain = NULL;
410 : 10174969 : accel_task->dst_domain = NULL;
411 : :
412 : 10174969 : return accel_submit_task(accel_ch, accel_task);
413 : : }
414 : :
415 : : /* Accel framework public API for dual cast copy function */
416 : : int
417 : 10409424 : spdk_accel_submit_dualcast(struct spdk_io_channel *ch, void *dst1,
418 : : void *dst2, void *src, uint64_t nbytes,
419 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
420 : : {
421 : 10409424 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
422 : : struct spdk_accel_task *accel_task;
423 : :
424 [ + + + + ]: 10409424 : if ((uintptr_t)dst1 & (ALIGN_4K - 1) || (uintptr_t)dst2 & (ALIGN_4K - 1)) {
425 : 8 : SPDK_ERRLOG("Dualcast requires 4K alignment on dst addresses\n");
426 : 8 : return -EINVAL;
427 : : }
428 : :
429 : 10409416 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
430 [ + + ]: 10409416 : if (spdk_unlikely(accel_task == NULL)) {
431 : 4 : return -ENOMEM;
432 : : }
433 : :
434 [ - + ]: 10409412 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
435 : :
436 : 10409412 : accel_task->s.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_SRC];
437 : 10409412 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
438 : 10409412 : accel_task->d2.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST2];
439 : 10409412 : accel_task->d.iovs[0].iov_base = dst1;
440 : 10409412 : accel_task->d.iovs[0].iov_len = nbytes;
441 : 10409412 : accel_task->d.iovcnt = 1;
442 : 10409412 : accel_task->d2.iovs[0].iov_base = dst2;
443 : 10409412 : accel_task->d2.iovs[0].iov_len = nbytes;
444 : 10409412 : accel_task->d2.iovcnt = 1;
445 : 10409412 : accel_task->s.iovs[0].iov_base = src;
446 : 10409412 : accel_task->s.iovs[0].iov_len = nbytes;
447 : 10409412 : accel_task->s.iovcnt = 1;
448 : 10409412 : accel_task->nbytes = nbytes;
449 : 10409412 : accel_task->op_code = SPDK_ACCEL_OPC_DUALCAST;
450 : 10409412 : accel_task->src_domain = NULL;
451 : 10409412 : accel_task->dst_domain = NULL;
452 : :
453 : 10409412 : return accel_submit_task(accel_ch, accel_task);
454 : : }
455 : :
456 : : /* Accel framework public API for compare function */
457 : :
458 : : int
459 : 15113672 : spdk_accel_submit_compare(struct spdk_io_channel *ch, void *src1,
460 : : void *src2, uint64_t nbytes, spdk_accel_completion_cb cb_fn,
461 : : void *cb_arg)
462 : : {
463 : 15113672 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
464 : : struct spdk_accel_task *accel_task;
465 : :
466 : 15113672 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
467 [ + + ]: 15113672 : if (spdk_unlikely(accel_task == NULL)) {
468 : 4 : return -ENOMEM;
469 : : }
470 : :
471 [ - + ]: 15113668 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
472 : :
473 : 15113668 : accel_task->s.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_SRC];
474 : 15113668 : accel_task->s2.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_SRC2];
475 : 15113668 : accel_task->s.iovs[0].iov_base = src1;
476 : 15113668 : accel_task->s.iovs[0].iov_len = nbytes;
477 : 15113668 : accel_task->s.iovcnt = 1;
478 : 15113668 : accel_task->s2.iovs[0].iov_base = src2;
479 : 15113668 : accel_task->s2.iovs[0].iov_len = nbytes;
480 : 15113668 : accel_task->s2.iovcnt = 1;
481 : 15113668 : accel_task->nbytes = nbytes;
482 : 15113668 : accel_task->op_code = SPDK_ACCEL_OPC_COMPARE;
483 : 15113668 : accel_task->src_domain = NULL;
484 : 15113668 : accel_task->dst_domain = NULL;
485 : :
486 : 15113668 : return accel_submit_task(accel_ch, accel_task);
487 : : }
488 : :
489 : : /* Accel framework public API for fill function */
490 : : int
491 : 26205256 : spdk_accel_submit_fill(struct spdk_io_channel *ch, void *dst,
492 : : uint8_t fill, uint64_t nbytes,
493 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
494 : : {
495 : 26205256 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
496 : : struct spdk_accel_task *accel_task;
497 : :
498 : 26205256 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
499 [ + + ]: 26205256 : if (spdk_unlikely(accel_task == NULL)) {
500 : 4 : return -ENOMEM;
501 : : }
502 : :
503 [ - + ]: 26205252 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
504 : :
505 : 26205252 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
506 : 26205252 : accel_task->d.iovs[0].iov_base = dst;
507 : 26205252 : accel_task->d.iovs[0].iov_len = nbytes;
508 : 26205252 : accel_task->d.iovcnt = 1;
509 : 26205252 : accel_task->nbytes = nbytes;
510 [ - + ]: 26205252 : memset(&accel_task->fill_pattern, fill, sizeof(uint64_t));
511 : 26205252 : accel_task->op_code = SPDK_ACCEL_OPC_FILL;
512 : 26205252 : accel_task->src_domain = NULL;
513 : 26205252 : accel_task->dst_domain = NULL;
514 : :
515 : 26205252 : return accel_submit_task(accel_ch, accel_task);
516 : : }
517 : :
518 : : /* Accel framework public API for CRC-32C function */
519 : : int
520 : 8 : spdk_accel_submit_crc32c(struct spdk_io_channel *ch, uint32_t *crc_dst,
521 : : void *src, uint32_t seed, uint64_t nbytes, spdk_accel_completion_cb cb_fn,
522 : : void *cb_arg)
523 : : {
524 : 8 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
525 : : struct spdk_accel_task *accel_task;
526 : :
527 : 8 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
528 [ + + ]: 8 : if (spdk_unlikely(accel_task == NULL)) {
529 : 4 : return -ENOMEM;
530 : : }
531 : :
532 [ - + ]: 4 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
533 : :
534 : 4 : accel_task->s.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_SRC];
535 : 4 : accel_task->s.iovs[0].iov_base = src;
536 : 4 : accel_task->s.iovs[0].iov_len = nbytes;
537 : 4 : accel_task->s.iovcnt = 1;
538 : 4 : accel_task->nbytes = nbytes;
539 : 4 : accel_task->crc_dst = crc_dst;
540 : 4 : accel_task->seed = seed;
541 : 4 : accel_task->op_code = SPDK_ACCEL_OPC_CRC32C;
542 : 4 : accel_task->src_domain = NULL;
543 : 4 : accel_task->dst_domain = NULL;
544 : :
545 : 4 : return accel_submit_task(accel_ch, accel_task);
546 : : }
547 : :
548 : : /* Accel framework public API for chained CRC-32C function */
549 : : int
550 : 21084464 : spdk_accel_submit_crc32cv(struct spdk_io_channel *ch, uint32_t *crc_dst,
551 : : struct iovec *iov, uint32_t iov_cnt, uint32_t seed,
552 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
553 : : {
554 : 21084464 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
555 : : struct spdk_accel_task *accel_task;
556 : :
557 [ - + ]: 21084464 : if (iov == NULL) {
558 : 0 : SPDK_ERRLOG("iov should not be NULL");
559 : 0 : return -EINVAL;
560 : : }
561 : :
562 [ - + ]: 21084464 : if (!iov_cnt) {
563 : 0 : SPDK_ERRLOG("iovcnt should not be zero value\n");
564 : 0 : return -EINVAL;
565 : : }
566 : :
567 : 21084464 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
568 [ - + ]: 21084464 : if (spdk_unlikely(accel_task == NULL)) {
569 : 0 : SPDK_ERRLOG("no memory\n");
570 : 0 : assert(0);
571 : : return -ENOMEM;
572 : : }
573 : :
574 : 21084464 : accel_task->s.iovs = iov;
575 : 21084464 : accel_task->s.iovcnt = iov_cnt;
576 : 21084464 : accel_task->nbytes = accel_get_iovlen(iov, iov_cnt);
577 : 21084464 : accel_task->crc_dst = crc_dst;
578 : 21084464 : accel_task->seed = seed;
579 : 21084464 : accel_task->op_code = SPDK_ACCEL_OPC_CRC32C;
580 : 21084464 : accel_task->src_domain = NULL;
581 : 21084464 : accel_task->dst_domain = NULL;
582 : :
583 : 21084464 : return accel_submit_task(accel_ch, accel_task);
584 : : }
585 : :
586 : : /* Accel framework public API for copy with CRC-32C function */
587 : : int
588 : 8 : spdk_accel_submit_copy_crc32c(struct spdk_io_channel *ch, void *dst,
589 : : void *src, uint32_t *crc_dst, uint32_t seed, uint64_t nbytes,
590 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
591 : : {
592 : 8 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
593 : : struct spdk_accel_task *accel_task;
594 : :
595 : 8 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
596 [ + + ]: 8 : if (spdk_unlikely(accel_task == NULL)) {
597 : 4 : return -ENOMEM;
598 : : }
599 : :
600 [ - + ]: 4 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
601 : :
602 : 4 : accel_task->s.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_SRC];
603 : 4 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
604 : 4 : accel_task->d.iovs[0].iov_base = dst;
605 : 4 : accel_task->d.iovs[0].iov_len = nbytes;
606 : 4 : accel_task->d.iovcnt = 1;
607 : 4 : accel_task->s.iovs[0].iov_base = src;
608 : 4 : accel_task->s.iovs[0].iov_len = nbytes;
609 : 4 : accel_task->s.iovcnt = 1;
610 : 4 : accel_task->nbytes = nbytes;
611 : 4 : accel_task->crc_dst = crc_dst;
612 : 4 : accel_task->seed = seed;
613 : 4 : accel_task->op_code = SPDK_ACCEL_OPC_COPY_CRC32C;
614 : 4 : accel_task->src_domain = NULL;
615 : 4 : accel_task->dst_domain = NULL;
616 : :
617 : 4 : return accel_submit_task(accel_ch, accel_task);
618 : : }
619 : :
620 : : /* Accel framework public API for chained copy + CRC-32C function */
621 : : int
622 : 11373344 : spdk_accel_submit_copy_crc32cv(struct spdk_io_channel *ch, void *dst,
623 : : struct iovec *src_iovs, uint32_t iov_cnt, uint32_t *crc_dst,
624 : : uint32_t seed, spdk_accel_completion_cb cb_fn, void *cb_arg)
625 : : {
626 : 11373344 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
627 : : struct spdk_accel_task *accel_task;
628 : : uint64_t nbytes;
629 : :
630 [ - + ]: 11373344 : if (src_iovs == NULL) {
631 : 0 : SPDK_ERRLOG("iov should not be NULL");
632 : 0 : return -EINVAL;
633 : : }
634 : :
635 [ - + ]: 11373344 : if (!iov_cnt) {
636 : 0 : SPDK_ERRLOG("iovcnt should not be zero value\n");
637 : 0 : return -EINVAL;
638 : : }
639 : :
640 : 11373344 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
641 [ - + ]: 11373344 : if (spdk_unlikely(accel_task == NULL)) {
642 : 0 : SPDK_ERRLOG("no memory\n");
643 : 0 : assert(0);
644 : : return -ENOMEM;
645 : : }
646 : :
647 : 11373344 : nbytes = accel_get_iovlen(src_iovs, iov_cnt);
648 : :
649 [ - + ]: 11373344 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
650 : :
651 : 11373344 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
652 : 11373344 : accel_task->d.iovs[0].iov_base = dst;
653 : 11373344 : accel_task->d.iovs[0].iov_len = nbytes;
654 : 11373344 : accel_task->d.iovcnt = 1;
655 : 11373344 : accel_task->s.iovs = src_iovs;
656 : 11373344 : accel_task->s.iovcnt = iov_cnt;
657 : 11373344 : accel_task->nbytes = nbytes;
658 : 11373344 : accel_task->crc_dst = crc_dst;
659 : 11373344 : accel_task->seed = seed;
660 : 11373344 : accel_task->op_code = SPDK_ACCEL_OPC_COPY_CRC32C;
661 : 11373344 : accel_task->src_domain = NULL;
662 : 11373344 : accel_task->dst_domain = NULL;
663 : :
664 : 11373344 : return accel_submit_task(accel_ch, accel_task);
665 : : }
666 : :
667 : : int
668 : 1278104 : spdk_accel_submit_compress(struct spdk_io_channel *ch, void *dst, uint64_t nbytes,
669 : : struct iovec *src_iovs, size_t src_iovcnt, uint32_t *output_size,
670 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
671 : : {
672 : 1278104 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
673 : : struct spdk_accel_task *accel_task;
674 : :
675 : 1278104 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
676 [ - + ]: 1278104 : if (spdk_unlikely(accel_task == NULL)) {
677 : 0 : return -ENOMEM;
678 : : }
679 : :
680 [ - + ]: 1278104 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
681 : :
682 : 1278104 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
683 : 1278104 : accel_task->d.iovs[0].iov_base = dst;
684 : 1278104 : accel_task->d.iovs[0].iov_len = nbytes;
685 : 1278104 : accel_task->d.iovcnt = 1;
686 : 1278104 : accel_task->output_size = output_size;
687 : 1278104 : accel_task->s.iovs = src_iovs;
688 : 1278104 : accel_task->s.iovcnt = src_iovcnt;
689 : 1278104 : accel_task->nbytes = nbytes;
690 : 1278104 : accel_task->op_code = SPDK_ACCEL_OPC_COMPRESS;
691 : 1278104 : accel_task->src_domain = NULL;
692 : 1278104 : accel_task->dst_domain = NULL;
693 : :
694 : 1278104 : return accel_submit_task(accel_ch, accel_task);
695 : : }
696 : :
697 : : int
698 : 8610222 : spdk_accel_submit_decompress(struct spdk_io_channel *ch, struct iovec *dst_iovs,
699 : : size_t dst_iovcnt, struct iovec *src_iovs, size_t src_iovcnt,
700 : : uint32_t *output_size, spdk_accel_completion_cb cb_fn,
701 : : void *cb_arg)
702 : : {
703 : 8610222 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
704 : : struct spdk_accel_task *accel_task;
705 : :
706 : 8610222 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
707 [ - + ]: 8610222 : if (spdk_unlikely(accel_task == NULL)) {
708 : 0 : return -ENOMEM;
709 : : }
710 : :
711 : 8610222 : accel_task->output_size = output_size;
712 : 8610222 : accel_task->s.iovs = src_iovs;
713 : 8610222 : accel_task->s.iovcnt = src_iovcnt;
714 : 8610222 : accel_task->d.iovs = dst_iovs;
715 : 8610222 : accel_task->d.iovcnt = dst_iovcnt;
716 : 8610222 : accel_task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
717 : 8610222 : accel_task->op_code = SPDK_ACCEL_OPC_DECOMPRESS;
718 : 8610222 : accel_task->src_domain = NULL;
719 : 8610222 : accel_task->dst_domain = NULL;
720 : :
721 : 8610222 : return accel_submit_task(accel_ch, accel_task);
722 : : }
723 : :
724 : : int
725 : 3 : spdk_accel_submit_encrypt(struct spdk_io_channel *ch, struct spdk_accel_crypto_key *key,
726 : : struct iovec *dst_iovs, uint32_t dst_iovcnt,
727 : : struct iovec *src_iovs, uint32_t src_iovcnt,
728 : : uint64_t iv, uint32_t block_size,
729 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
730 : : {
731 : 3 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
732 : : struct spdk_accel_task *accel_task;
733 : :
734 [ + - - + : 3 : if (spdk_unlikely(!dst_iovs || !dst_iovcnt || !src_iovs || !src_iovcnt || !key || !block_size)) {
+ - - + +
- - + + -
- + + - -
+ ]
735 : 0 : return -EINVAL;
736 : : }
737 : :
738 : 3 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
739 [ - + ]: 3 : if (spdk_unlikely(accel_task == NULL)) {
740 : 0 : return -ENOMEM;
741 : : }
742 : :
743 : 3 : accel_task->crypto_key = key;
744 : 3 : accel_task->s.iovs = src_iovs;
745 : 3 : accel_task->s.iovcnt = src_iovcnt;
746 : 3 : accel_task->d.iovs = dst_iovs;
747 : 3 : accel_task->d.iovcnt = dst_iovcnt;
748 : 3 : accel_task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
749 : 3 : accel_task->iv = iv;
750 : 3 : accel_task->block_size = block_size;
751 : 3 : accel_task->op_code = SPDK_ACCEL_OPC_ENCRYPT;
752 : 3 : accel_task->src_domain = NULL;
753 : 3 : accel_task->dst_domain = NULL;
754 : :
755 : 3 : return accel_submit_task(accel_ch, accel_task);
756 : : }
757 : :
758 : : int
759 : 0 : spdk_accel_submit_decrypt(struct spdk_io_channel *ch, struct spdk_accel_crypto_key *key,
760 : : struct iovec *dst_iovs, uint32_t dst_iovcnt,
761 : : struct iovec *src_iovs, uint32_t src_iovcnt,
762 : : uint64_t iv, uint32_t block_size,
763 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
764 : : {
765 : 0 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
766 : : struct spdk_accel_task *accel_task;
767 : :
768 [ # # # # : 0 : if (spdk_unlikely(!dst_iovs || !dst_iovcnt || !src_iovs || !src_iovcnt || !key || !block_size)) {
# # # # #
# # # # #
# # # # #
# ]
769 : 0 : return -EINVAL;
770 : : }
771 : :
772 : 0 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
773 [ # # ]: 0 : if (spdk_unlikely(accel_task == NULL)) {
774 : 0 : return -ENOMEM;
775 : : }
776 : :
777 : 0 : accel_task->crypto_key = key;
778 : 0 : accel_task->s.iovs = src_iovs;
779 : 0 : accel_task->s.iovcnt = src_iovcnt;
780 : 0 : accel_task->d.iovs = dst_iovs;
781 : 0 : accel_task->d.iovcnt = dst_iovcnt;
782 : 0 : accel_task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
783 : 0 : accel_task->iv = iv;
784 : 0 : accel_task->block_size = block_size;
785 : 0 : accel_task->op_code = SPDK_ACCEL_OPC_DECRYPT;
786 : 0 : accel_task->src_domain = NULL;
787 : 0 : accel_task->dst_domain = NULL;
788 : :
789 : 0 : return accel_submit_task(accel_ch, accel_task);
790 : : }
791 : :
792 : : int
793 : 15264345 : spdk_accel_submit_xor(struct spdk_io_channel *ch, void *dst, void **sources, uint32_t nsrcs,
794 : : uint64_t nbytes, spdk_accel_completion_cb cb_fn, void *cb_arg)
795 : : {
796 : 15264345 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
797 : : struct spdk_accel_task *accel_task;
798 : :
799 : 15264345 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
800 [ + + ]: 15264345 : if (spdk_unlikely(accel_task == NULL)) {
801 : 228 : return -ENOMEM;
802 : : }
803 : :
804 [ - + ]: 15264117 : ACCEL_TASK_ALLOC_AUX_BUF(accel_task);
805 : :
806 : 15264117 : accel_task->d.iovs = &accel_task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
807 : 15264117 : accel_task->nsrcs.srcs = sources;
808 : 15264117 : accel_task->nsrcs.cnt = nsrcs;
809 : 15264117 : accel_task->d.iovs[0].iov_base = dst;
810 : 15264117 : accel_task->d.iovs[0].iov_len = nbytes;
811 : 15264117 : accel_task->d.iovcnt = 1;
812 : 15264117 : accel_task->nbytes = nbytes;
813 : 15264117 : accel_task->op_code = SPDK_ACCEL_OPC_XOR;
814 : 15264117 : accel_task->src_domain = NULL;
815 : 15264117 : accel_task->dst_domain = NULL;
816 : :
817 : 15264117 : return accel_submit_task(accel_ch, accel_task);
818 : : }
819 : :
820 : : int
821 : 2552400 : spdk_accel_submit_dif_verify(struct spdk_io_channel *ch,
822 : : struct iovec *iovs, size_t iovcnt, uint32_t num_blocks,
823 : : const struct spdk_dif_ctx *ctx, struct spdk_dif_error *err,
824 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
825 : : {
826 : 2552400 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
827 : : struct spdk_accel_task *accel_task;
828 : :
829 : 2552400 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
830 [ - + ]: 2552400 : if (accel_task == NULL) {
831 : 0 : return -ENOMEM;
832 : : }
833 : :
834 : 2552400 : accel_task->s.iovs = iovs;
835 : 2552400 : accel_task->s.iovcnt = iovcnt;
836 : 2552400 : accel_task->dif.ctx = ctx;
837 : 2552400 : accel_task->dif.err = err;
838 : 2552400 : accel_task->dif.num_blocks = num_blocks;
839 : 2552400 : accel_task->nbytes = num_blocks * ctx->block_size;
840 : 2552400 : accel_task->op_code = SPDK_ACCEL_OPC_DIF_VERIFY;
841 : 2552400 : accel_task->src_domain = NULL;
842 : 2552400 : accel_task->dst_domain = NULL;
843 : :
844 : 2552400 : return accel_submit_task(accel_ch, accel_task);
845 : : }
846 : :
847 : : int
848 : 3233376 : spdk_accel_submit_dif_generate(struct spdk_io_channel *ch,
849 : : struct iovec *iovs, size_t iovcnt, uint32_t num_blocks,
850 : : const struct spdk_dif_ctx *ctx,
851 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
852 : : {
853 : 3233376 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
854 : : struct spdk_accel_task *accel_task;
855 : :
856 : 3233376 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
857 [ - + ]: 3233376 : if (accel_task == NULL) {
858 : 0 : return -ENOMEM;
859 : : }
860 : :
861 : 3233376 : accel_task->s.iovs = iovs;
862 : 3233376 : accel_task->s.iovcnt = iovcnt;
863 : 3233376 : accel_task->dif.ctx = ctx;
864 : 3233376 : accel_task->dif.num_blocks = num_blocks;
865 : 3233376 : accel_task->nbytes = num_blocks * ctx->block_size;
866 : 3233376 : accel_task->op_code = SPDK_ACCEL_OPC_DIF_GENERATE;
867 : 3233376 : accel_task->src_domain = NULL;
868 : 3233376 : accel_task->dst_domain = NULL;
869 : :
870 : 3233376 : return accel_submit_task(accel_ch, accel_task);
871 : : }
872 : :
873 : : int
874 : 2476928 : spdk_accel_submit_dif_generate_copy(struct spdk_io_channel *ch, struct iovec *dst_iovs,
875 : : size_t dst_iovcnt, struct iovec *src_iovs, size_t src_iovcnt,
876 : : uint32_t num_blocks, const struct spdk_dif_ctx *ctx,
877 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
878 : : {
879 : 2476928 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
880 : : struct spdk_accel_task *accel_task;
881 : :
882 : 2476928 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
883 [ - + ]: 2476928 : if (accel_task == NULL) {
884 : 0 : return -ENOMEM;
885 : : }
886 : :
887 : 2476928 : accel_task->s.iovs = src_iovs;
888 : 2476928 : accel_task->s.iovcnt = src_iovcnt;
889 : 2476928 : accel_task->d.iovs = dst_iovs;
890 : 2476928 : accel_task->d.iovcnt = dst_iovcnt;
891 : 2476928 : accel_task->dif.ctx = ctx;
892 : 2476928 : accel_task->dif.num_blocks = num_blocks;
893 : 2476928 : accel_task->nbytes = num_blocks * ctx->block_size;
894 : 2476928 : accel_task->op_code = SPDK_ACCEL_OPC_DIF_GENERATE_COPY;
895 : 2476928 : accel_task->src_domain = NULL;
896 : 2476928 : accel_task->dst_domain = NULL;
897 : :
898 : 2476928 : return accel_submit_task(accel_ch, accel_task);
899 : : }
900 : :
901 : : int
902 : 120 : spdk_accel_submit_dif_verify_copy(struct spdk_io_channel *ch,
903 : : struct iovec *dst_iovs, size_t dst_iovcnt,
904 : : struct iovec *src_iovs, size_t src_iovcnt, uint32_t num_blocks,
905 : : const struct spdk_dif_ctx *ctx, struct spdk_dif_error *err,
906 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
907 : : {
908 : 120 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
909 : : struct spdk_accel_task *accel_task;
910 : :
911 : 120 : accel_task = _get_task(accel_ch, cb_fn, cb_arg);
912 [ - + ]: 120 : if (accel_task == NULL) {
913 : 0 : return -ENOMEM;
914 : : }
915 : :
916 : 120 : accel_task->s.iovs = src_iovs;
917 : 120 : accel_task->s.iovcnt = src_iovcnt;
918 : 120 : accel_task->d.iovs = dst_iovs;
919 : 120 : accel_task->d.iovcnt = dst_iovcnt;
920 : 120 : accel_task->dif.ctx = ctx;
921 : 120 : accel_task->dif.err = err;
922 : 120 : accel_task->dif.num_blocks = num_blocks;
923 : 120 : accel_task->nbytes = num_blocks * ctx->block_size;
924 : 120 : accel_task->op_code = SPDK_ACCEL_OPC_DIF_VERIFY_COPY;
925 : 120 : accel_task->src_domain = NULL;
926 : 120 : accel_task->dst_domain = NULL;
927 : :
928 : 120 : return accel_submit_task(accel_ch, accel_task);
929 : : }
930 : :
931 : : static inline struct accel_buffer *
932 : 3366804 : accel_get_buf(struct accel_io_channel *ch, uint64_t len)
933 : : {
934 : : struct accel_buffer *buf;
935 : :
936 : 3366804 : buf = SLIST_FIRST(&ch->buf_pool);
937 [ - + ]: 3366804 : if (spdk_unlikely(buf == NULL)) {
938 : 0 : accel_update_stats(ch, retry.bufdesc, 1);
939 : 0 : return NULL;
940 : : }
941 : :
942 : 3366804 : SLIST_REMOVE_HEAD(&ch->buf_pool, link);
943 : 3366804 : buf->len = len;
944 : 3366804 : buf->buf = NULL;
945 : 3366804 : buf->seq = NULL;
946 : 3366804 : buf->cb_fn = NULL;
947 : :
948 : 3366804 : return buf;
949 : : }
950 : :
951 : : static inline void
952 : 3366804 : accel_put_buf(struct accel_io_channel *ch, struct accel_buffer *buf)
953 : : {
954 [ + + ]: 3366804 : if (buf->buf != NULL) {
955 : 982049 : spdk_iobuf_put(&ch->iobuf, buf->buf, buf->len);
956 : : }
957 : :
958 : 3366804 : SLIST_INSERT_HEAD(&ch->buf_pool, buf, link);
959 : 3366804 : }
960 : :
961 : : static inline struct spdk_accel_sequence *
962 : 87619046 : accel_sequence_get(struct accel_io_channel *ch)
963 : : {
964 : : struct spdk_accel_sequence *seq;
965 : :
966 : : /* Sequence cannot be allocated if number of available task objects cannot satisfy required limit.
967 : : * This is to prevent potential dead lock when few requests are pending task resource and none can
968 : : * advance the processing. This solution should work only if there is single async operation after
969 : : * sequence obj obtained, so assume that is possible to happen with io buffer allocation now, if
970 : : * there are more async operations then solution should be improved. */
971 [ + + ]: 87619046 : if (spdk_unlikely(g_opts.task_count - ch->stats.task_outstanding < ACCEL_TASKS_IN_SEQUENCE_LIMIT)) {
972 : 99450 : return NULL;
973 : : }
974 : :
975 : 87519598 : seq = SLIST_FIRST(&ch->seq_pool);
976 [ + + ]: 87519598 : if (spdk_unlikely(seq == NULL)) {
977 : 12 : accel_update_stats(ch, retry.sequence, 1);
978 : 12 : return NULL;
979 : : }
980 : :
981 : 87519586 : accel_update_stats(ch, sequence_outstanding, 1);
982 : 87519586 : SLIST_REMOVE_HEAD(&ch->seq_pool, link);
983 : :
984 : 87519586 : TAILQ_INIT(&seq->tasks);
985 : 87519586 : SLIST_INIT(&seq->bounce_bufs);
986 : :
987 : 87519586 : seq->ch = ch;
988 : 87519586 : seq->status = 0;
989 : 87519586 : seq->state = ACCEL_SEQUENCE_STATE_INIT;
990 : 87519586 : seq->in_process_sequence = false;
991 : :
992 : 87519586 : return seq;
993 : : }
994 : :
995 : : static inline void
996 : 87519586 : accel_sequence_put(struct spdk_accel_sequence *seq)
997 : : {
998 : 87519586 : struct accel_io_channel *ch = seq->ch;
999 : : struct accel_buffer *buf;
1000 : :
1001 [ + + ]: 88101466 : while (!SLIST_EMPTY(&seq->bounce_bufs)) {
1002 : 581880 : buf = SLIST_FIRST(&seq->bounce_bufs);
1003 : 581880 : SLIST_REMOVE_HEAD(&seq->bounce_bufs, link);
1004 : 581880 : accel_put_buf(seq->ch, buf);
1005 : : }
1006 : :
1007 [ - + ]: 87519586 : assert(TAILQ_EMPTY(&seq->tasks));
1008 : 87519586 : seq->ch = NULL;
1009 : :
1010 : 87519586 : SLIST_INSERT_HEAD(&ch->seq_pool, seq, link);
1011 : 87519586 : accel_update_stats(ch, sequence_outstanding, -1);
1012 : 87519586 : }
1013 : :
1014 : : static void accel_sequence_task_cb(void *cb_arg, int status);
1015 : :
1016 : : static inline struct spdk_accel_task *
1017 : 91424028 : accel_sequence_get_task(struct accel_io_channel *ch, struct spdk_accel_sequence *seq,
1018 : : spdk_accel_step_cb cb_fn, void *cb_arg)
1019 : : {
1020 : : struct spdk_accel_task *task;
1021 : :
1022 : 91424028 : task = _get_task(ch, NULL, NULL);
1023 [ + + ]: 91424028 : if (spdk_unlikely(task == NULL)) {
1024 : 12 : return task;
1025 : : }
1026 : :
1027 : 91424016 : task->step_cb_fn = cb_fn;
1028 : 91424016 : task->cb_arg = cb_arg;
1029 : 91424016 : task->seq = seq;
1030 : :
1031 : 91424016 : return task;
1032 : : }
1033 : :
1034 : : int
1035 : 86798884 : spdk_accel_append_copy(struct spdk_accel_sequence **pseq, struct spdk_io_channel *ch,
1036 : : struct iovec *dst_iovs, uint32_t dst_iovcnt,
1037 : : struct spdk_memory_domain *dst_domain, void *dst_domain_ctx,
1038 : : struct iovec *src_iovs, uint32_t src_iovcnt,
1039 : : struct spdk_memory_domain *src_domain, void *src_domain_ctx,
1040 : : spdk_accel_step_cb cb_fn, void *cb_arg)
1041 : : {
1042 : 86798884 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1043 : : struct spdk_accel_task *task;
1044 : 86798884 : struct spdk_accel_sequence *seq = *pseq;
1045 : :
1046 [ + + ]: 86798884 : if (seq == NULL) {
1047 : 83620740 : seq = accel_sequence_get(accel_ch);
1048 [ + + ]: 83620740 : if (spdk_unlikely(seq == NULL)) {
1049 : 31244 : return -ENOMEM;
1050 : : }
1051 : : }
1052 : :
1053 [ - + ]: 86767642 : assert(seq->ch == accel_ch);
1054 : 86767642 : task = accel_sequence_get_task(accel_ch, seq, cb_fn, cb_arg);
1055 [ + + ]: 86767642 : if (spdk_unlikely(task == NULL)) {
1056 [ + - ]: 4 : if (*pseq == NULL) {
1057 : 4 : accel_sequence_put(seq);
1058 : : }
1059 : :
1060 : 4 : return -ENOMEM;
1061 : : }
1062 : :
1063 : 86767638 : task->dst_domain = dst_domain;
1064 : 86767638 : task->dst_domain_ctx = dst_domain_ctx;
1065 : 86767638 : task->d.iovs = dst_iovs;
1066 : 86767638 : task->d.iovcnt = dst_iovcnt;
1067 : 86767638 : task->src_domain = src_domain;
1068 : 86767638 : task->src_domain_ctx = src_domain_ctx;
1069 : 86767638 : task->s.iovs = src_iovs;
1070 : 86767638 : task->s.iovcnt = src_iovcnt;
1071 : 86767638 : task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
1072 : 86767638 : task->op_code = SPDK_ACCEL_OPC_COPY;
1073 : :
1074 : 86767638 : TAILQ_INSERT_TAIL(&seq->tasks, task, seq_link);
1075 : 86767638 : *pseq = seq;
1076 : :
1077 : 86767638 : return 0;
1078 : : }
1079 : :
1080 : : int
1081 : 165 : spdk_accel_append_fill(struct spdk_accel_sequence **pseq, struct spdk_io_channel *ch,
1082 : : void *buf, uint64_t len,
1083 : : struct spdk_memory_domain *domain, void *domain_ctx, uint8_t pattern,
1084 : : spdk_accel_step_cb cb_fn, void *cb_arg)
1085 : : {
1086 : 165 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1087 : : struct spdk_accel_task *task;
1088 : 165 : struct spdk_accel_sequence *seq = *pseq;
1089 : :
1090 [ + + ]: 165 : if (seq == NULL) {
1091 : 95 : seq = accel_sequence_get(accel_ch);
1092 [ + + ]: 95 : if (spdk_unlikely(seq == NULL)) {
1093 : 4 : return -ENOMEM;
1094 : : }
1095 : : }
1096 : :
1097 [ - + ]: 161 : assert(seq->ch == accel_ch);
1098 : 161 : task = accel_sequence_get_task(accel_ch, seq, cb_fn, cb_arg);
1099 [ + + ]: 161 : if (spdk_unlikely(task == NULL)) {
1100 [ + - ]: 4 : if (*pseq == NULL) {
1101 : 4 : accel_sequence_put(seq);
1102 : : }
1103 : :
1104 : 4 : return -ENOMEM;
1105 : : }
1106 : :
1107 [ - + ]: 157 : memset(&task->fill_pattern, pattern, sizeof(uint64_t));
1108 : :
1109 : 157 : task->aux = SLIST_FIRST(&task->accel_ch->task_aux_data_pool);
1110 [ - + ]: 157 : if (spdk_unlikely(!task->aux)) {
1111 : 0 : SPDK_ERRLOG("Fatal problem, aux data was not allocated\n");
1112 [ # # ]: 0 : if (*pseq == NULL) {
1113 : 0 : accel_sequence_put((seq));
1114 : : }
1115 : :
1116 : 0 : task->seq = NULL;
1117 : 0 : _put_task(task->accel_ch, task);
1118 : 0 : assert(0);
1119 : : return -ENOMEM;
1120 : : }
1121 : 157 : SLIST_REMOVE_HEAD(&task->accel_ch->task_aux_data_pool, link);
1122 : 157 : task->has_aux = true;
1123 : :
1124 : 157 : task->d.iovs = &task->aux->iovs[SPDK_ACCEL_AUX_IOV_DST];
1125 : 157 : task->d.iovs[0].iov_base = buf;
1126 : 157 : task->d.iovs[0].iov_len = len;
1127 : 157 : task->d.iovcnt = 1;
1128 : 157 : task->nbytes = len;
1129 : 157 : task->src_domain = NULL;
1130 : 157 : task->dst_domain = domain;
1131 : 157 : task->dst_domain_ctx = domain_ctx;
1132 : 157 : task->op_code = SPDK_ACCEL_OPC_FILL;
1133 : :
1134 : 157 : TAILQ_INSERT_TAIL(&seq->tasks, task, seq_link);
1135 : 157 : *pseq = seq;
1136 : :
1137 : 157 : return 0;
1138 : : }
1139 : :
1140 : : int
1141 : 181 : spdk_accel_append_decompress(struct spdk_accel_sequence **pseq, struct spdk_io_channel *ch,
1142 : : struct iovec *dst_iovs, size_t dst_iovcnt,
1143 : : struct spdk_memory_domain *dst_domain, void *dst_domain_ctx,
1144 : : struct iovec *src_iovs, size_t src_iovcnt,
1145 : : struct spdk_memory_domain *src_domain, void *src_domain_ctx,
1146 : : spdk_accel_step_cb cb_fn, void *cb_arg)
1147 : : {
1148 : 181 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1149 : : struct spdk_accel_task *task;
1150 : 181 : struct spdk_accel_sequence *seq = *pseq;
1151 : :
1152 [ + + ]: 181 : if (seq == NULL) {
1153 : 80 : seq = accel_sequence_get(accel_ch);
1154 [ + + ]: 80 : if (spdk_unlikely(seq == NULL)) {
1155 : 4 : return -ENOMEM;
1156 : : }
1157 : : }
1158 : :
1159 [ - + ]: 177 : assert(seq->ch == accel_ch);
1160 : 177 : task = accel_sequence_get_task(accel_ch, seq, cb_fn, cb_arg);
1161 [ + + ]: 177 : if (spdk_unlikely(task == NULL)) {
1162 [ + - ]: 4 : if (*pseq == NULL) {
1163 : 4 : accel_sequence_put(seq);
1164 : : }
1165 : :
1166 : 4 : return -ENOMEM;
1167 : : }
1168 : :
1169 : : /* TODO: support output_size for chaining */
1170 : 173 : task->output_size = NULL;
1171 : 173 : task->dst_domain = dst_domain;
1172 : 173 : task->dst_domain_ctx = dst_domain_ctx;
1173 : 173 : task->d.iovs = dst_iovs;
1174 : 173 : task->d.iovcnt = dst_iovcnt;
1175 : 173 : task->src_domain = src_domain;
1176 : 173 : task->src_domain_ctx = src_domain_ctx;
1177 : 173 : task->s.iovs = src_iovs;
1178 : 173 : task->s.iovcnt = src_iovcnt;
1179 : 173 : task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
1180 : 173 : task->op_code = SPDK_ACCEL_OPC_DECOMPRESS;
1181 : :
1182 : 173 : TAILQ_INSERT_TAIL(&seq->tasks, task, seq_link);
1183 : 173 : *pseq = seq;
1184 : :
1185 : 173 : return 0;
1186 : : }
1187 : :
1188 : : int
1189 : 2784906 : spdk_accel_append_encrypt(struct spdk_accel_sequence **pseq, struct spdk_io_channel *ch,
1190 : : struct spdk_accel_crypto_key *key,
1191 : : struct iovec *dst_iovs, uint32_t dst_iovcnt,
1192 : : struct spdk_memory_domain *dst_domain, void *dst_domain_ctx,
1193 : : struct iovec *src_iovs, uint32_t src_iovcnt,
1194 : : struct spdk_memory_domain *src_domain, void *src_domain_ctx,
1195 : : uint64_t iv, uint32_t block_size,
1196 : : spdk_accel_step_cb cb_fn, void *cb_arg)
1197 : : {
1198 : 2784906 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1199 : : struct spdk_accel_task *task;
1200 : 2784906 : struct spdk_accel_sequence *seq = *pseq;
1201 : :
1202 [ + - + - : 2784906 : assert(dst_iovs && dst_iovcnt && src_iovs && src_iovcnt && key && block_size);
+ - + - +
- + + ]
1203 : :
1204 [ + + ]: 2784906 : if (seq == NULL) {
1205 : 2384763 : seq = accel_sequence_get(accel_ch);
1206 [ + + ]: 2384763 : if (spdk_unlikely(seq == NULL)) {
1207 : 33994 : return -ENOMEM;
1208 : : }
1209 : : }
1210 : :
1211 [ - + ]: 2750912 : assert(seq->ch == accel_ch);
1212 : 2750912 : task = accel_sequence_get_task(accel_ch, seq, cb_fn, cb_arg);
1213 [ - + ]: 2750912 : if (spdk_unlikely(task == NULL)) {
1214 [ # # ]: 0 : if (*pseq == NULL) {
1215 : 0 : accel_sequence_put(seq);
1216 : : }
1217 : :
1218 : 0 : return -ENOMEM;
1219 : : }
1220 : :
1221 : 2750912 : task->crypto_key = key;
1222 : 2750912 : task->src_domain = src_domain;
1223 : 2750912 : task->src_domain_ctx = src_domain_ctx;
1224 : 2750912 : task->s.iovs = src_iovs;
1225 : 2750912 : task->s.iovcnt = src_iovcnt;
1226 : 2750912 : task->dst_domain = dst_domain;
1227 : 2750912 : task->dst_domain_ctx = dst_domain_ctx;
1228 : 2750912 : task->d.iovs = dst_iovs;
1229 : 2750912 : task->d.iovcnt = dst_iovcnt;
1230 : 2750912 : task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
1231 : 2750912 : task->iv = iv;
1232 : 2750912 : task->block_size = block_size;
1233 : 2750912 : task->op_code = SPDK_ACCEL_OPC_ENCRYPT;
1234 : :
1235 : 2750912 : TAILQ_INSERT_TAIL(&seq->tasks, task, seq_link);
1236 : 2750912 : *pseq = seq;
1237 : :
1238 : 2750912 : return 0;
1239 : : }
1240 : :
1241 : : int
1242 : 1232366 : spdk_accel_append_decrypt(struct spdk_accel_sequence **pseq, struct spdk_io_channel *ch,
1243 : : struct spdk_accel_crypto_key *key,
1244 : : struct iovec *dst_iovs, uint32_t dst_iovcnt,
1245 : : struct spdk_memory_domain *dst_domain, void *dst_domain_ctx,
1246 : : struct iovec *src_iovs, uint32_t src_iovcnt,
1247 : : struct spdk_memory_domain *src_domain, void *src_domain_ctx,
1248 : : uint64_t iv, uint32_t block_size,
1249 : : spdk_accel_step_cb cb_fn, void *cb_arg)
1250 : : {
1251 : 1232366 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1252 : : struct spdk_accel_task *task;
1253 : 1232366 : struct spdk_accel_sequence *seq = *pseq;
1254 : :
1255 [ + - + - : 1232366 : assert(dst_iovs && dst_iovcnt && src_iovs && src_iovcnt && key && block_size);
+ - + - +
- + + ]
1256 : :
1257 [ + + ]: 1232366 : if (seq == NULL) {
1258 : 1005936 : seq = accel_sequence_get(accel_ch);
1259 [ + + ]: 1005936 : if (spdk_unlikely(seq == NULL)) {
1260 : 34216 : return -ENOMEM;
1261 : : }
1262 : : }
1263 : :
1264 [ - + ]: 1198150 : assert(seq->ch == accel_ch);
1265 : 1198150 : task = accel_sequence_get_task(accel_ch, seq, cb_fn, cb_arg);
1266 [ - + ]: 1198150 : if (spdk_unlikely(task == NULL)) {
1267 [ # # ]: 0 : if (*pseq == NULL) {
1268 : 0 : accel_sequence_put(seq);
1269 : : }
1270 : :
1271 : 0 : return -ENOMEM;
1272 : : }
1273 : :
1274 : 1198150 : task->crypto_key = key;
1275 : 1198150 : task->src_domain = src_domain;
1276 : 1198150 : task->src_domain_ctx = src_domain_ctx;
1277 : 1198150 : task->s.iovs = src_iovs;
1278 : 1198150 : task->s.iovcnt = src_iovcnt;
1279 : 1198150 : task->dst_domain = dst_domain;
1280 : 1198150 : task->dst_domain_ctx = dst_domain_ctx;
1281 : 1198150 : task->d.iovs = dst_iovs;
1282 : 1198150 : task->d.iovcnt = dst_iovcnt;
1283 : 1198150 : task->nbytes = accel_get_iovlen(src_iovs, src_iovcnt);
1284 : 1198150 : task->iv = iv;
1285 : 1198150 : task->block_size = block_size;
1286 : 1198150 : task->op_code = SPDK_ACCEL_OPC_DECRYPT;
1287 : :
1288 : 1198150 : TAILQ_INSERT_TAIL(&seq->tasks, task, seq_link);
1289 : 1198150 : *pseq = seq;
1290 : :
1291 : 1198150 : return 0;
1292 : : }
1293 : :
1294 : : int
1295 : 706986 : spdk_accel_append_crc32c(struct spdk_accel_sequence **pseq, struct spdk_io_channel *ch,
1296 : : uint32_t *dst, struct iovec *iovs, uint32_t iovcnt,
1297 : : struct spdk_memory_domain *domain, void *domain_ctx,
1298 : : uint32_t seed, spdk_accel_step_cb cb_fn, void *cb_arg)
1299 : : {
1300 : 706986 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1301 : : struct spdk_accel_task *task;
1302 : 706986 : struct spdk_accel_sequence *seq = *pseq;
1303 : :
1304 [ + + ]: 706986 : if (seq == NULL) {
1305 : 607432 : seq = accel_sequence_get(accel_ch);
1306 [ - + ]: 607432 : if (spdk_unlikely(seq == NULL)) {
1307 : 0 : return -ENOMEM;
1308 : : }
1309 : : }
1310 : :
1311 [ - + ]: 706986 : assert(seq->ch == accel_ch);
1312 : 706986 : task = accel_sequence_get_task(accel_ch, seq, cb_fn, cb_arg);
1313 [ - + ]: 706986 : if (spdk_unlikely(task == NULL)) {
1314 [ # # ]: 0 : if (*pseq == NULL) {
1315 : 0 : accel_sequence_put(seq);
1316 : : }
1317 : :
1318 : 0 : return -ENOMEM;
1319 : : }
1320 : :
1321 : 706986 : task->s.iovs = iovs;
1322 : 706986 : task->s.iovcnt = iovcnt;
1323 : 706986 : task->src_domain = domain;
1324 : 706986 : task->src_domain_ctx = domain_ctx;
1325 : 706986 : task->nbytes = accel_get_iovlen(iovs, iovcnt);
1326 : 706986 : task->crc_dst = dst;
1327 : 706986 : task->seed = seed;
1328 : 706986 : task->op_code = SPDK_ACCEL_OPC_CRC32C;
1329 : 706986 : task->dst_domain = NULL;
1330 : :
1331 : 706986 : TAILQ_INSERT_TAIL(&seq->tasks, task, seq_link);
1332 : 706986 : *pseq = seq;
1333 : :
1334 : 706986 : return 0;
1335 : : }
1336 : :
1337 : : int
1338 : 2784924 : spdk_accel_get_buf(struct spdk_io_channel *ch, uint64_t len, void **buf,
1339 : : struct spdk_memory_domain **domain, void **domain_ctx)
1340 : : {
1341 : 2784924 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1342 : : struct accel_buffer *accel_buf;
1343 : :
1344 : 2784924 : accel_buf = accel_get_buf(accel_ch, len);
1345 [ - + ]: 2784924 : if (spdk_unlikely(accel_buf == NULL)) {
1346 : 0 : return -ENOMEM;
1347 : : }
1348 : :
1349 : 2784924 : accel_buf->ch = accel_ch;
1350 : :
1351 : : /* We always return the same pointer and identify the buffers through domain_ctx */
1352 : 2784924 : *buf = ACCEL_BUFFER_BASE;
1353 : 2784924 : *domain_ctx = accel_buf;
1354 : 2784924 : *domain = g_accel_domain;
1355 : :
1356 : 2784924 : return 0;
1357 : : }
1358 : :
1359 : : void
1360 : 2784924 : spdk_accel_put_buf(struct spdk_io_channel *ch, void *buf,
1361 : : struct spdk_memory_domain *domain, void *domain_ctx)
1362 : : {
1363 : 2784924 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
1364 : 2784924 : struct accel_buffer *accel_buf = domain_ctx;
1365 : :
1366 [ - + ]: 2784924 : assert(domain == g_accel_domain);
1367 [ - + ]: 2784924 : assert(buf == ACCEL_BUFFER_BASE);
1368 : :
1369 : 2784924 : accel_put_buf(accel_ch, accel_buf);
1370 : 2784924 : }
1371 : :
1372 : : static void
1373 : 91424016 : accel_sequence_complete_task(struct spdk_accel_sequence *seq, struct spdk_accel_task *task)
1374 : : {
1375 : 91424016 : struct accel_io_channel *ch = seq->ch;
1376 : : spdk_accel_step_cb cb_fn;
1377 : : void *cb_arg;
1378 : :
1379 [ + + ]: 91424016 : TAILQ_REMOVE(&seq->tasks, task, seq_link);
1380 : 91424016 : cb_fn = task->step_cb_fn;
1381 : 91424016 : cb_arg = task->cb_arg;
1382 : 91424016 : task->seq = NULL;
1383 [ + + + + ]: 91424016 : if (task->has_aux) {
1384 : 1432072 : SLIST_INSERT_HEAD(&ch->task_aux_data_pool, task->aux, link);
1385 : 1432072 : task->aux = NULL;
1386 : 1432072 : task->has_aux = false;
1387 : : }
1388 : :
1389 : 91424016 : _put_task(ch, task);
1390 : :
1391 [ + + ]: 91424016 : if (cb_fn != NULL) {
1392 : 707561 : cb_fn(cb_arg);
1393 : : }
1394 : 91424016 : }
1395 : :
1396 : : static void
1397 : 87519574 : accel_sequence_complete_tasks(struct spdk_accel_sequence *seq)
1398 : : {
1399 : : struct spdk_accel_task *task;
1400 : :
1401 [ + + ]: 87519646 : while (!TAILQ_EMPTY(&seq->tasks)) {
1402 : 72 : task = TAILQ_FIRST(&seq->tasks);
1403 : 72 : accel_sequence_complete_task(seq, task);
1404 : : }
1405 : 87519574 : }
1406 : :
1407 : : static void
1408 : 87519566 : accel_sequence_complete(struct spdk_accel_sequence *seq)
1409 : : {
1410 : 87519566 : spdk_accel_completion_cb cb_fn = seq->cb_fn;
1411 : 87519566 : void *cb_arg = seq->cb_arg;
1412 : 87519566 : int status = seq->status;
1413 : :
1414 [ - + - + ]: 87519566 : SPDK_DEBUGLOG(accel, "Completed sequence: %p with status: %d\n", seq, status);
1415 : :
1416 : 87519566 : accel_update_stats(seq->ch, sequence_executed, 1);
1417 [ + + ]: 87519566 : if (spdk_unlikely(status != 0)) {
1418 : 40 : accel_update_stats(seq->ch, sequence_failed, 1);
1419 : : }
1420 : :
1421 : : /* First notify all users that appended operations to this sequence */
1422 : 87519566 : accel_sequence_complete_tasks(seq);
1423 : 87519566 : accel_sequence_put(seq);
1424 : :
1425 : : /* Then notify the user that finished the sequence */
1426 : 87519566 : cb_fn(cb_arg, status);
1427 : 87519566 : }
1428 : :
1429 : : static void
1430 : 850139 : accel_update_virt_iov(struct iovec *diov, struct iovec *siov, struct accel_buffer *accel_buf)
1431 : : {
1432 : : uintptr_t offset;
1433 : :
1434 : 850139 : offset = (uintptr_t)siov->iov_base & ACCEL_BUFFER_OFFSET_MASK;
1435 [ - + ]: 850139 : assert(offset < accel_buf->len);
1436 : :
1437 : 850139 : diov->iov_base = (char *)accel_buf->buf + offset;
1438 : 850139 : diov->iov_len = siov->iov_len;
1439 : 850139 : }
1440 : :
1441 : : static void
1442 : 449938 : accel_sequence_set_virtbuf(struct spdk_accel_sequence *seq, struct accel_buffer *buf)
1443 : : {
1444 : : struct spdk_accel_task *task;
1445 : : struct iovec *iov;
1446 : :
1447 : : /* Now that we've allocated the actual data buffer for this accel_buffer, update all tasks
1448 : : * in a sequence that were using it.
1449 : : */
1450 [ + + ]: 1349846 : TAILQ_FOREACH(task, &seq->tasks, seq_link) {
1451 [ + + + + ]: 899908 : if (task->src_domain == g_accel_domain && task->src_domain_ctx == buf) {
1452 [ + + + - ]: 400173 : if (!task->has_aux) {
1453 : 400173 : task->aux = SLIST_FIRST(&task->accel_ch->task_aux_data_pool);
1454 [ - + ]: 400173 : assert(task->aux && "Can't allocate aux data structure");
1455 : 400173 : task->has_aux = true;
1456 : 400173 : SLIST_REMOVE_HEAD(&task->accel_ch->task_aux_data_pool, link);
1457 : : }
1458 : :
1459 : 400173 : iov = &task->aux->iovs[SPDK_ACCEL_AXU_IOV_VIRT_SRC];
1460 [ - + ]: 400173 : assert(task->s.iovcnt == 1);
1461 : 400173 : accel_update_virt_iov(iov, &task->s.iovs[0], buf);
1462 : 400173 : task->src_domain = NULL;
1463 : 400173 : task->s.iovs = iov;
1464 : : }
1465 [ + + + + ]: 899908 : if (task->dst_domain == g_accel_domain && task->dst_domain_ctx == buf) {
1466 [ + + + + ]: 449966 : if (!task->has_aux) {
1467 : 449906 : task->aux = SLIST_FIRST(&task->accel_ch->task_aux_data_pool);
1468 [ - + ]: 449906 : assert(task->aux && "Can't allocate aux data structure");
1469 : 449906 : task->has_aux = true;
1470 : 449906 : SLIST_REMOVE_HEAD(&task->accel_ch->task_aux_data_pool, link);
1471 : : }
1472 : :
1473 : 449966 : iov = &task->aux->iovs[SPDK_ACCEL_AXU_IOV_VIRT_DST];
1474 [ - + ]: 449966 : assert(task->d.iovcnt == 1);
1475 : 449966 : accel_update_virt_iov(iov, &task->d.iovs[0], buf);
1476 : 449966 : task->dst_domain = NULL;
1477 : 449966 : task->d.iovs = iov;
1478 : : }
1479 : : }
1480 : 449938 : }
1481 : :
1482 : : static void accel_process_sequence(struct spdk_accel_sequence *seq);
1483 : :
1484 : : static void
1485 : 12 : accel_iobuf_get_virtbuf_cb(struct spdk_iobuf_entry *entry, void *buf)
1486 : : {
1487 : : struct accel_buffer *accel_buf;
1488 : :
1489 : 12 : accel_buf = SPDK_CONTAINEROF(entry, struct accel_buffer, iobuf);
1490 : :
1491 [ - + ]: 12 : assert(accel_buf->seq != NULL);
1492 [ - + ]: 12 : assert(accel_buf->buf == NULL);
1493 : 12 : accel_buf->buf = buf;
1494 : :
1495 [ - + ]: 12 : assert(accel_buf->seq->state == ACCEL_SEQUENCE_STATE_AWAIT_VIRTBUF);
1496 : 12 : accel_sequence_set_state(accel_buf->seq, ACCEL_SEQUENCE_STATE_CHECK_VIRTBUF);
1497 : 12 : accel_sequence_set_virtbuf(accel_buf->seq, accel_buf);
1498 : 12 : accel_process_sequence(accel_buf->seq);
1499 : 12 : }
1500 : :
1501 : : static bool
1502 : 1031818 : accel_sequence_alloc_buf(struct spdk_accel_sequence *seq, struct accel_buffer *buf,
1503 : : spdk_iobuf_get_cb cb_fn)
1504 : : {
1505 : 1031818 : struct accel_io_channel *ch = seq->ch;
1506 : :
1507 [ - + ]: 1031818 : assert(buf->seq == NULL);
1508 : :
1509 : 1031818 : buf->seq = seq;
1510 : :
1511 : : /* Buffer might be already allocated by memory domain translation. */
1512 [ + + ]: 1031818 : if (buf->buf) {
1513 : 49769 : return true;
1514 : : }
1515 : :
1516 : 982049 : buf->buf = spdk_iobuf_get(&ch->iobuf, buf->len, &buf->iobuf, cb_fn);
1517 [ + + ]: 982049 : if (spdk_unlikely(buf->buf == NULL)) {
1518 : 20 : accel_update_stats(ch, retry.iobuf, 1);
1519 : 20 : return false;
1520 : : }
1521 : :
1522 : 982029 : return true;
1523 : : }
1524 : :
1525 : : static bool
1526 : 88245781 : accel_sequence_check_virtbuf(struct spdk_accel_sequence *seq, struct spdk_accel_task *task)
1527 : : {
1528 : : /* If a task doesn't have dst/src (e.g. fill, crc32), its dst/src domain should be set to
1529 : : * NULL */
1530 [ - + ]: 88245781 : if (task->src_domain == g_accel_domain) {
1531 [ # # ]: 0 : if (!accel_sequence_alloc_buf(seq, task->src_domain_ctx,
1532 : : accel_iobuf_get_virtbuf_cb)) {
1533 : 0 : return false;
1534 : : }
1535 : :
1536 : 0 : accel_sequence_set_virtbuf(seq, task->src_domain_ctx);
1537 : : }
1538 : :
1539 [ + + ]: 88245781 : if (task->dst_domain == g_accel_domain) {
1540 [ + + ]: 449938 : if (!accel_sequence_alloc_buf(seq, task->dst_domain_ctx,
1541 : : accel_iobuf_get_virtbuf_cb)) {
1542 : 12 : return false;
1543 : : }
1544 : :
1545 : 449926 : accel_sequence_set_virtbuf(seq, task->dst_domain_ctx);
1546 : : }
1547 : :
1548 : 88245769 : return true;
1549 : : }
1550 : :
1551 : : static void
1552 : 0 : accel_sequence_get_buf_cb(struct spdk_iobuf_entry *entry, void *buf)
1553 : : {
1554 : : struct accel_buffer *accel_buf;
1555 : :
1556 : 0 : accel_buf = SPDK_CONTAINEROF(entry, struct accel_buffer, iobuf);
1557 : :
1558 [ # # ]: 0 : assert(accel_buf->seq != NULL);
1559 [ # # ]: 0 : assert(accel_buf->buf == NULL);
1560 : 0 : accel_buf->buf = buf;
1561 : :
1562 : 0 : accel_sequence_set_virtbuf(accel_buf->seq, accel_buf);
1563 : 0 : accel_buf->cb_fn(accel_buf->seq, accel_buf->cb_ctx);
1564 : 0 : }
1565 : :
1566 : : bool
1567 : 0 : spdk_accel_alloc_sequence_buf(struct spdk_accel_sequence *seq, void *buf,
1568 : : struct spdk_memory_domain *domain, void *domain_ctx,
1569 : : spdk_accel_sequence_get_buf_cb cb_fn, void *cb_ctx)
1570 : : {
1571 : 0 : struct accel_buffer *accel_buf = domain_ctx;
1572 : :
1573 [ # # ]: 0 : assert(domain == g_accel_domain);
1574 : 0 : accel_buf->cb_fn = cb_fn;
1575 : 0 : accel_buf->cb_ctx = cb_ctx;
1576 : :
1577 [ # # ]: 0 : if (!accel_sequence_alloc_buf(seq, accel_buf, accel_sequence_get_buf_cb)) {
1578 : 0 : return false;
1579 : : }
1580 : :
1581 : 0 : accel_sequence_set_virtbuf(seq, accel_buf);
1582 : :
1583 : 0 : return true;
1584 : : }
1585 : :
1586 : : struct spdk_accel_task *
1587 : 96 : spdk_accel_sequence_first_task(struct spdk_accel_sequence *seq)
1588 : : {
1589 : 96 : return TAILQ_FIRST(&seq->tasks);
1590 : : }
1591 : :
1592 : : struct spdk_accel_task *
1593 : 0 : spdk_accel_sequence_next_task(struct spdk_accel_task *task)
1594 : : {
1595 : 0 : return TAILQ_NEXT(task, seq_link);
1596 : : }
1597 : :
1598 : : static inline void
1599 : 581880 : accel_set_bounce_buffer(struct spdk_accel_bounce_buffer *bounce, struct iovec **iovs,
1600 : : uint32_t *iovcnt, struct spdk_memory_domain **domain, void **domain_ctx,
1601 : : struct accel_buffer *buf)
1602 : : {
1603 : 581880 : bounce->orig_iovs = *iovs;
1604 : 581880 : bounce->orig_iovcnt = *iovcnt;
1605 : 581880 : bounce->orig_domain = *domain;
1606 : 581880 : bounce->orig_domain_ctx = *domain_ctx;
1607 : 581880 : bounce->iov.iov_base = buf->buf;
1608 : 581880 : bounce->iov.iov_len = buf->len;
1609 : :
1610 : 581880 : *iovs = &bounce->iov;
1611 : 581880 : *iovcnt = 1;
1612 : 581880 : *domain = NULL;
1613 : 581880 : }
1614 : :
1615 : : static void
1616 : 4 : accel_iobuf_get_src_bounce_cb(struct spdk_iobuf_entry *entry, void *buf)
1617 : : {
1618 : : struct spdk_accel_task *task;
1619 : : struct accel_buffer *accel_buf;
1620 : :
1621 : 4 : accel_buf = SPDK_CONTAINEROF(entry, struct accel_buffer, iobuf);
1622 [ - + ]: 4 : assert(accel_buf->buf == NULL);
1623 : 4 : accel_buf->buf = buf;
1624 : :
1625 : 4 : task = TAILQ_FIRST(&accel_buf->seq->tasks);
1626 [ - + ]: 4 : assert(task != NULL);
1627 : :
1628 [ - + ]: 4 : assert(accel_buf->seq->state == ACCEL_SEQUENCE_STATE_AWAIT_BOUNCEBUF);
1629 : 4 : accel_sequence_set_state(accel_buf->seq, ACCEL_SEQUENCE_STATE_CHECK_BOUNCEBUF);
1630 [ - + ]: 4 : assert(task->aux);
1631 [ - + - + ]: 4 : assert(task->has_aux);
1632 : 4 : accel_set_bounce_buffer(&task->aux->bounce.s, &task->s.iovs, &task->s.iovcnt, &task->src_domain,
1633 : : &task->src_domain_ctx, accel_buf);
1634 : 4 : accel_process_sequence(accel_buf->seq);
1635 : 4 : }
1636 : :
1637 : : static void
1638 : 4 : accel_iobuf_get_dst_bounce_cb(struct spdk_iobuf_entry *entry, void *buf)
1639 : : {
1640 : : struct spdk_accel_task *task;
1641 : : struct accel_buffer *accel_buf;
1642 : :
1643 : 4 : accel_buf = SPDK_CONTAINEROF(entry, struct accel_buffer, iobuf);
1644 [ - + ]: 4 : assert(accel_buf->buf == NULL);
1645 : 4 : accel_buf->buf = buf;
1646 : :
1647 : 4 : task = TAILQ_FIRST(&accel_buf->seq->tasks);
1648 [ - + ]: 4 : assert(task != NULL);
1649 : :
1650 [ - + ]: 4 : assert(accel_buf->seq->state == ACCEL_SEQUENCE_STATE_AWAIT_BOUNCEBUF);
1651 : 4 : accel_sequence_set_state(accel_buf->seq, ACCEL_SEQUENCE_STATE_CHECK_BOUNCEBUF);
1652 [ - + ]: 4 : assert(task->aux);
1653 [ - + - + ]: 4 : assert(task->has_aux);
1654 : 4 : accel_set_bounce_buffer(&task->aux->bounce.d, &task->d.iovs, &task->d.iovcnt, &task->dst_domain,
1655 : : &task->dst_domain_ctx, accel_buf);
1656 : 4 : accel_process_sequence(accel_buf->seq);
1657 : 4 : }
1658 : :
1659 : : static int
1660 : 88245717 : accel_sequence_check_bouncebuf(struct spdk_accel_sequence *seq, struct spdk_accel_task *task)
1661 : : {
1662 : : struct accel_buffer *buf;
1663 : :
1664 [ + + ]: 88245717 : if (task->src_domain != NULL) {
1665 : : /* By the time we're here, accel buffers should have been allocated */
1666 [ - + ]: 174380 : assert(task->src_domain != g_accel_domain);
1667 : :
1668 [ + + + + ]: 174380 : if (!task->has_aux) {
1669 : 174376 : task->aux = SLIST_FIRST(&task->accel_ch->task_aux_data_pool);
1670 [ - + ]: 174376 : if (spdk_unlikely(!task->aux)) {
1671 : 0 : SPDK_ERRLOG("Can't allocate aux data structure\n");
1672 : 0 : assert(0);
1673 : : return -EAGAIN;
1674 : : }
1675 : 174376 : task->has_aux = true;
1676 : 174376 : SLIST_REMOVE_HEAD(&task->accel_ch->task_aux_data_pool, link);
1677 : : }
1678 : 174380 : buf = accel_get_buf(seq->ch, accel_get_iovlen(task->s.iovs, task->s.iovcnt));
1679 [ - + ]: 174380 : if (buf == NULL) {
1680 : 0 : SPDK_ERRLOG("Couldn't allocate buffer descriptor\n");
1681 : 0 : return -ENOMEM;
1682 : : }
1683 : :
1684 : 174380 : SLIST_INSERT_HEAD(&seq->bounce_bufs, buf, link);
1685 [ + + ]: 174380 : if (!accel_sequence_alloc_buf(seq, buf, accel_iobuf_get_src_bounce_cb)) {
1686 : 4 : return -EAGAIN;
1687 : : }
1688 : :
1689 : 174376 : accel_set_bounce_buffer(&task->aux->bounce.s, &task->s.iovs, &task->s.iovcnt,
1690 : : &task->src_domain, &task->src_domain_ctx, buf);
1691 : : }
1692 : :
1693 [ + + ]: 88245713 : if (task->dst_domain != NULL) {
1694 : : /* By the time we're here, accel buffers should have been allocated */
1695 [ - + ]: 407500 : assert(task->dst_domain != g_accel_domain);
1696 : :
1697 [ - + + + ]: 407500 : if (!task->has_aux) {
1698 : 407460 : task->aux = SLIST_FIRST(&task->accel_ch->task_aux_data_pool);
1699 [ - + ]: 407460 : if (spdk_unlikely(!task->aux)) {
1700 : 0 : SPDK_ERRLOG("Can't allocate aux data structure\n");
1701 : 0 : assert(0);
1702 : : return -EAGAIN;
1703 : : }
1704 : 407460 : task->has_aux = true;
1705 : 407460 : SLIST_REMOVE_HEAD(&task->accel_ch->task_aux_data_pool, link);
1706 : : }
1707 : 407500 : buf = accel_get_buf(seq->ch, accel_get_iovlen(task->d.iovs, task->d.iovcnt));
1708 [ - + ]: 407500 : if (buf == NULL) {
1709 : : /* The src buffer will be released when a sequence is completed */
1710 : 0 : SPDK_ERRLOG("Couldn't allocate buffer descriptor\n");
1711 : 0 : return -ENOMEM;
1712 : : }
1713 : :
1714 : 407500 : SLIST_INSERT_HEAD(&seq->bounce_bufs, buf, link);
1715 [ + + ]: 407500 : if (!accel_sequence_alloc_buf(seq, buf, accel_iobuf_get_dst_bounce_cb)) {
1716 : 4 : return -EAGAIN;
1717 : : }
1718 : :
1719 : 407496 : accel_set_bounce_buffer(&task->aux->bounce.d, &task->d.iovs, &task->d.iovcnt,
1720 : : &task->dst_domain, &task->dst_domain_ctx, buf);
1721 : : }
1722 : :
1723 : 88245709 : return 0;
1724 : : }
1725 : :
1726 : : static void
1727 : 174376 : accel_task_pull_data_cb(void *ctx, int status)
1728 : : {
1729 : 174376 : struct spdk_accel_sequence *seq = ctx;
1730 : :
1731 [ - + ]: 174376 : assert(seq->state == ACCEL_SEQUENCE_STATE_AWAIT_PULL_DATA);
1732 [ + + ]: 174376 : if (spdk_likely(status == 0)) {
1733 : 174372 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_EXEC_TASK);
1734 : : } else {
1735 : 4 : accel_sequence_set_fail(seq, status);
1736 : : }
1737 : :
1738 : 174376 : accel_process_sequence(seq);
1739 : 174376 : }
1740 : :
1741 : : static void
1742 : 174380 : accel_task_pull_data(struct spdk_accel_sequence *seq, struct spdk_accel_task *task)
1743 : : {
1744 : : int rc;
1745 : :
1746 [ - + - + ]: 174380 : assert(task->has_aux);
1747 [ - + ]: 174380 : assert(task->aux);
1748 [ - + ]: 174380 : assert(task->aux->bounce.s.orig_iovs != NULL);
1749 [ - + ]: 174380 : assert(task->aux->bounce.s.orig_domain != NULL);
1750 [ - + ]: 174380 : assert(task->aux->bounce.s.orig_domain != g_accel_domain);
1751 [ - + - + ]: 174380 : assert(!g_modules_opc[task->op_code].supports_memory_domains);
1752 : :
1753 : 697466 : rc = spdk_memory_domain_pull_data(task->aux->bounce.s.orig_domain,
1754 : 174380 : task->aux->bounce.s.orig_domain_ctx,
1755 : 348742 : task->aux->bounce.s.orig_iovs, task->aux->bounce.s.orig_iovcnt,
1756 : : task->s.iovs, task->s.iovcnt,
1757 : : accel_task_pull_data_cb, seq);
1758 [ + + ]: 174380 : if (spdk_unlikely(rc != 0)) {
1759 : 4 : SPDK_ERRLOG("Failed to pull data from memory domain: %s, rc: %d\n",
1760 : : spdk_memory_domain_get_dma_device_id(task->aux->bounce.s.orig_domain), rc);
1761 : 4 : accel_sequence_set_fail(seq, rc);
1762 : : }
1763 : 174380 : }
1764 : :
1765 : : static void
1766 : 407488 : accel_task_push_data_cb(void *ctx, int status)
1767 : : {
1768 : 407488 : struct spdk_accel_sequence *seq = ctx;
1769 : :
1770 [ - + ]: 407488 : assert(seq->state == ACCEL_SEQUENCE_STATE_AWAIT_PUSH_DATA);
1771 [ + + ]: 407488 : if (spdk_likely(status == 0)) {
1772 : 407484 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_NEXT_TASK);
1773 : : } else {
1774 : 4 : accel_sequence_set_fail(seq, status);
1775 : : }
1776 : :
1777 : 407488 : accel_process_sequence(seq);
1778 : 407488 : }
1779 : :
1780 : : static void
1781 : 407492 : accel_task_push_data(struct spdk_accel_sequence *seq, struct spdk_accel_task *task)
1782 : : {
1783 : : int rc;
1784 : :
1785 [ - + - + ]: 407492 : assert(task->has_aux);
1786 [ - + ]: 407492 : assert(task->aux);
1787 [ - + ]: 407492 : assert(task->aux->bounce.d.orig_iovs != NULL);
1788 [ - + ]: 407492 : assert(task->aux->bounce.d.orig_domain != NULL);
1789 [ - + ]: 407492 : assert(task->aux->bounce.d.orig_domain != g_accel_domain);
1790 [ - + - + ]: 407492 : assert(!g_modules_opc[task->op_code].supports_memory_domains);
1791 : :
1792 : 1629920 : rc = spdk_memory_domain_push_data(task->aux->bounce.d.orig_domain,
1793 : 407492 : task->aux->bounce.d.orig_domain_ctx,
1794 : 814968 : task->aux->bounce.d.orig_iovs, task->aux->bounce.d.orig_iovcnt,
1795 : : task->d.iovs, task->d.iovcnt,
1796 : : accel_task_push_data_cb, seq);
1797 [ + + ]: 407492 : if (spdk_unlikely(rc != 0)) {
1798 : 4 : SPDK_ERRLOG("Failed to push data to memory domain: %s, rc: %d\n",
1799 : : spdk_memory_domain_get_dma_device_id(task->aux->bounce.s.orig_domain), rc);
1800 : 4 : accel_sequence_set_fail(seq, rc);
1801 : : }
1802 : 407492 : }
1803 : :
1804 : : static void
1805 : 176347211 : accel_process_sequence(struct spdk_accel_sequence *seq)
1806 : : {
1807 : 176347211 : struct accel_io_channel *accel_ch = seq->ch;
1808 : : struct spdk_accel_task *task;
1809 : : enum accel_sequence_state state;
1810 : : int rc;
1811 : :
1812 : : /* Prevent recursive calls to this function */
1813 [ + + + + ]: 176347211 : if (spdk_unlikely(seq->in_process_sequence)) {
1814 : 296 : return;
1815 : : }
1816 : 176346915 : seq->in_process_sequence = true;
1817 : :
1818 : 176346915 : task = TAILQ_FIRST(&seq->tasks);
1819 : : do {
1820 : 354321172 : state = seq->state;
1821 [ + + + + : 354321172 : switch (state) {
+ + + + +
+ + + - ]
1822 : 88245789 : case ACCEL_SEQUENCE_STATE_INIT:
1823 [ + + ]: 88245789 : if (g_accel_driver != NULL) {
1824 : 52 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_DRIVER_EXEC_TASKS);
1825 : 52 : break;
1826 : : }
1827 : : /* Fall through */
1828 : : case ACCEL_SEQUENCE_STATE_CHECK_VIRTBUF:
1829 : 88245781 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_AWAIT_VIRTBUF);
1830 [ + + ]: 88245781 : if (!accel_sequence_check_virtbuf(seq, task)) {
1831 : : /* We couldn't allocate a buffer, wait until one is available */
1832 : 12 : break;
1833 : : }
1834 : 88245769 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_CHECK_BOUNCEBUF);
1835 : : /* Fall through */
1836 : 88245777 : case ACCEL_SEQUENCE_STATE_CHECK_BOUNCEBUF:
1837 : : /* If a module supports memory domains, we don't need to allocate bounce
1838 : : * buffers */
1839 [ + + + + ]: 88245777 : if (g_modules_opc[task->op_code].supports_memory_domains) {
1840 : 60 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_EXEC_TASK);
1841 : 60 : break;
1842 : : }
1843 : 88245717 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_AWAIT_BOUNCEBUF);
1844 : 88245717 : rc = accel_sequence_check_bouncebuf(seq, task);
1845 [ + + ]: 88245717 : if (spdk_unlikely(rc != 0)) {
1846 : : /* We couldn't allocate a buffer, wait until one is available */
1847 [ + - ]: 8 : if (rc == -EAGAIN) {
1848 : 8 : break;
1849 : : }
1850 : 0 : accel_sequence_set_fail(seq, rc);
1851 : 0 : break;
1852 : : }
1853 [ + + + + : 88245709 : if (task->has_aux && task->s.iovs == &task->aux->bounce.s.iov) {
+ + ]
1854 [ - + ]: 174380 : assert(task->aux->bounce.s.orig_iovs);
1855 : 174380 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_PULL_DATA);
1856 : 174380 : break;
1857 : : }
1858 : 88071329 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_EXEC_TASK);
1859 : : /* Fall through */
1860 : 88245761 : case ACCEL_SEQUENCE_STATE_EXEC_TASK:
1861 [ - + - + ]: 88245761 : SPDK_DEBUGLOG(accel, "Executing %s operation, sequence: %p\n",
1862 : : g_opcode_strings[task->op_code], seq);
1863 : :
1864 : 88245761 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_AWAIT_TASK);
1865 : 88245761 : rc = accel_submit_task(accel_ch, task);
1866 [ + + ]: 88245761 : if (spdk_unlikely(rc != 0)) {
1867 : 8 : SPDK_ERRLOG("Failed to submit %s operation, sequence: %p\n",
1868 : : g_opcode_strings[task->op_code], seq);
1869 : 8 : accel_sequence_set_fail(seq, rc);
1870 : : }
1871 : 88245761 : break;
1872 : 174380 : case ACCEL_SEQUENCE_STATE_PULL_DATA:
1873 : 174380 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_AWAIT_PULL_DATA);
1874 : 174380 : accel_task_pull_data(seq, task);
1875 : 174380 : break;
1876 : 88245745 : case ACCEL_SEQUENCE_STATE_COMPLETE_TASK:
1877 [ + + + + : 88245745 : if (task->has_aux && task->d.iovs == &task->aux->bounce.d.iov) {
+ + ]
1878 [ - + ]: 407492 : assert(task->aux->bounce.d.orig_iovs);
1879 : 407492 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_PUSH_DATA);
1880 : 407492 : break;
1881 : : }
1882 : 87838253 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_NEXT_TASK);
1883 : 87838253 : break;
1884 : 407492 : case ACCEL_SEQUENCE_STATE_PUSH_DATA:
1885 : 407492 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_AWAIT_PUSH_DATA);
1886 : 407492 : accel_task_push_data(seq, task);
1887 : 407492 : break;
1888 : 88245737 : case ACCEL_SEQUENCE_STATE_NEXT_TASK:
1889 : 88245737 : accel_sequence_complete_task(seq, task);
1890 : : /* Check if there are any remaining tasks */
1891 : 88245737 : task = TAILQ_FIRST(&seq->tasks);
1892 [ + + ]: 88245737 : if (task == NULL) {
1893 : : /* Immediately return here to make sure we don't touch the sequence
1894 : : * after it's completed */
1895 : 87519514 : accel_sequence_complete(seq);
1896 : 87519514 : return;
1897 : : }
1898 : 726223 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_INIT);
1899 : 726223 : break;
1900 : 52 : case ACCEL_SEQUENCE_STATE_DRIVER_EXEC_TASKS:
1901 [ - + ]: 52 : assert(!TAILQ_EMPTY(&seq->tasks));
1902 : :
1903 : 52 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_DRIVER_AWAIT_TASKS);
1904 : 52 : rc = g_accel_driver->execute_sequence(accel_ch->driver_channel, seq);
1905 [ + + ]: 52 : if (spdk_unlikely(rc != 0)) {
1906 : 4 : SPDK_ERRLOG("Failed to execute sequence: %p using driver: %s\n",
1907 : : seq, g_accel_driver->name);
1908 : 4 : accel_sequence_set_fail(seq, rc);
1909 : : }
1910 : 52 : break;
1911 : 44 : case ACCEL_SEQUENCE_STATE_DRIVER_COMPLETE_TASKS:
1912 : : /* Get the task again, as the driver might have completed some tasks
1913 : : * synchronously */
1914 : 44 : task = TAILQ_FIRST(&seq->tasks);
1915 [ + + ]: 44 : if (task == NULL) {
1916 : : /* Immediately return here to make sure we don't touch the sequence
1917 : : * after it's completed */
1918 : 12 : accel_sequence_complete(seq);
1919 : 12 : return;
1920 : : }
1921 : : /* We don't want to execute the next task through the driver, so we
1922 : : * explicitly omit the INIT state here */
1923 : 32 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_CHECK_VIRTBUF);
1924 : 32 : break;
1925 : 40 : case ACCEL_SEQUENCE_STATE_ERROR:
1926 : : /* Immediately return here to make sure we don't touch the sequence
1927 : : * after it's completed */
1928 [ - + ]: 40 : assert(seq->status != 0);
1929 : 40 : accel_sequence_complete(seq);
1930 : 40 : return;
1931 : 88827389 : case ACCEL_SEQUENCE_STATE_AWAIT_VIRTBUF:
1932 : : case ACCEL_SEQUENCE_STATE_AWAIT_BOUNCEBUF:
1933 : : case ACCEL_SEQUENCE_STATE_AWAIT_PULL_DATA:
1934 : : case ACCEL_SEQUENCE_STATE_AWAIT_TASK:
1935 : : case ACCEL_SEQUENCE_STATE_AWAIT_PUSH_DATA:
1936 : : case ACCEL_SEQUENCE_STATE_DRIVER_AWAIT_TASKS:
1937 : 88827389 : break;
1938 : 0 : default:
1939 : 0 : assert(0 && "bad state");
1940 : : break;
1941 : : }
1942 [ + + ]: 266801526 : } while (seq->state != state);
1943 : :
1944 : 88827389 : seq->in_process_sequence = false;
1945 : : }
1946 : :
1947 : : static void
1948 : 88245801 : accel_sequence_task_cb(void *cb_arg, int status)
1949 : : {
1950 : 88245801 : struct spdk_accel_sequence *seq = cb_arg;
1951 : 88245801 : struct spdk_accel_task *task = TAILQ_FIRST(&seq->tasks);
1952 : :
1953 [ + + - ]: 88245801 : switch (seq->state) {
1954 : 88245753 : case ACCEL_SEQUENCE_STATE_AWAIT_TASK:
1955 : 88245753 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_COMPLETE_TASK);
1956 [ + + ]: 88245753 : if (spdk_unlikely(status != 0)) {
1957 : 8 : SPDK_ERRLOG("Failed to execute %s operation, sequence: %p\n",
1958 : : g_opcode_strings[task->op_code], seq);
1959 : 8 : accel_sequence_set_fail(seq, status);
1960 : : }
1961 : :
1962 : 88245753 : accel_process_sequence(seq);
1963 : 88245753 : break;
1964 : 48 : case ACCEL_SEQUENCE_STATE_DRIVER_AWAIT_TASKS:
1965 [ - + ]: 48 : assert(g_accel_driver != NULL);
1966 : : /* Immediately remove the task from the outstanding list to make sure the next call
1967 : : * to spdk_accel_sequence_first_task() doesn't return it */
1968 : 48 : accel_sequence_complete_task(seq, task);
1969 [ + + ]: 48 : if (spdk_unlikely(status != 0)) {
1970 : 4 : SPDK_ERRLOG("Failed to execute %s operation, sequence: %p through "
1971 : : "driver: %s\n", g_opcode_strings[task->op_code], seq,
1972 : : g_accel_driver->name);
1973 : : /* Update status without using accel_sequence_set_fail() to avoid changing
1974 : : * seq's state to ERROR until driver calls spdk_accel_sequence_continue() */
1975 : 4 : seq->status = status;
1976 : : }
1977 : 48 : break;
1978 : 0 : default:
1979 : 0 : assert(0 && "bad state");
1980 : : break;
1981 : : }
1982 : 88245801 : }
1983 : :
1984 : : void
1985 : 48 : spdk_accel_sequence_continue(struct spdk_accel_sequence *seq)
1986 : : {
1987 [ - + ]: 48 : assert(g_accel_driver != NULL);
1988 [ - + ]: 48 : assert(seq->state == ACCEL_SEQUENCE_STATE_DRIVER_AWAIT_TASKS);
1989 : :
1990 [ + + ]: 48 : if (spdk_likely(seq->status == 0)) {
1991 : 44 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_DRIVER_COMPLETE_TASKS);
1992 : : } else {
1993 : 4 : accel_sequence_set_state(seq, ACCEL_SEQUENCE_STATE_ERROR);
1994 : : }
1995 : :
1996 : 48 : accel_process_sequence(seq);
1997 : 48 : }
1998 : :
1999 : : static bool
2000 : 3178179 : accel_compare_iovs(struct iovec *iova, uint32_t iovacnt, struct iovec *iovb, uint32_t iovbcnt)
2001 : : {
2002 : : /* For now, just do a dumb check that the iovecs arrays are exactly the same */
2003 [ - + ]: 3178179 : if (iovacnt != iovbcnt) {
2004 : 0 : return false;
2005 : : }
2006 : :
2007 [ - + - + ]: 3178179 : return memcmp(iova, iovb, sizeof(*iova) * iovacnt) == 0;
2008 : : }
2009 : :
2010 : : static bool
2011 : 2301076 : accel_task_set_dstbuf(struct spdk_accel_task *task, struct spdk_accel_task *next)
2012 : : {
2013 : : struct spdk_accel_task *prev;
2014 : :
2015 [ + + - ]: 2301076 : switch (task->op_code) {
2016 : 2301060 : case SPDK_ACCEL_OPC_DECOMPRESS:
2017 : : case SPDK_ACCEL_OPC_FILL:
2018 : : case SPDK_ACCEL_OPC_ENCRYPT:
2019 : : case SPDK_ACCEL_OPC_DECRYPT:
2020 [ - + ]: 2301060 : if (task->dst_domain != next->src_domain) {
2021 : 0 : return false;
2022 : : }
2023 [ + + ]: 2301060 : if (!accel_compare_iovs(task->d.iovs, task->d.iovcnt,
2024 : : next->s.iovs, next->s.iovcnt)) {
2025 : 4 : return false;
2026 : : }
2027 : 2301056 : task->d.iovs = next->d.iovs;
2028 : 2301056 : task->d.iovcnt = next->d.iovcnt;
2029 : 2301056 : task->dst_domain = next->dst_domain;
2030 : 2301056 : task->dst_domain_ctx = next->dst_domain_ctx;
2031 : 2301056 : break;
2032 : 16 : case SPDK_ACCEL_OPC_CRC32C:
2033 : : /* crc32 is special, because it doesn't have a dst buffer */
2034 [ - + ]: 16 : if (task->src_domain != next->src_domain) {
2035 : 0 : return false;
2036 : : }
2037 [ + + ]: 16 : if (!accel_compare_iovs(task->s.iovs, task->s.iovcnt,
2038 : : next->s.iovs, next->s.iovcnt)) {
2039 : 4 : return false;
2040 : : }
2041 : : /* We can only change crc32's buffer if we can change previous task's buffer */
2042 : 12 : prev = TAILQ_PREV(task, accel_sequence_tasks, seq_link);
2043 [ + + ]: 12 : if (prev == NULL) {
2044 : 4 : return false;
2045 : : }
2046 [ - + ]: 8 : if (!accel_task_set_dstbuf(prev, next)) {
2047 : 0 : return false;
2048 : : }
2049 : 8 : task->s.iovs = next->d.iovs;
2050 : 8 : task->s.iovcnt = next->d.iovcnt;
2051 : 8 : task->src_domain = next->dst_domain;
2052 : 8 : task->src_domain_ctx = next->dst_domain_ctx;
2053 : 8 : break;
2054 : 0 : default:
2055 : 0 : return false;
2056 : : }
2057 : :
2058 : 2301064 : return true;
2059 : : }
2060 : :
2061 : : static void
2062 : 3904422 : accel_sequence_merge_tasks(struct spdk_accel_sequence *seq, struct spdk_accel_task *task,
2063 : : struct spdk_accel_task **next_task)
2064 : : {
2065 : 3904422 : struct spdk_accel_task *next = *next_task;
2066 : :
2067 [ + + - ]: 3904422 : switch (task->op_code) {
2068 : 877111 : case SPDK_ACCEL_OPC_COPY:
2069 : : /* We only allow changing src of operations that actually have a src, e.g. we never
2070 : : * do it for fill. Theoretically, it is possible, but we'd have to be careful to
2071 : : * change the src of the operation after fill (which in turn could also be a fill).
2072 : : * So, for the sake of simplicity, skip this type of operations for now.
2073 : : */
2074 [ + + ]: 877111 : if (next->op_code != SPDK_ACCEL_OPC_DECOMPRESS &&
2075 [ + + ]: 877091 : next->op_code != SPDK_ACCEL_OPC_COPY &&
2076 [ + + ]: 877087 : next->op_code != SPDK_ACCEL_OPC_ENCRYPT &&
2077 [ + + ]: 877077 : next->op_code != SPDK_ACCEL_OPC_DECRYPT &&
2078 [ + - ]: 8 : next->op_code != SPDK_ACCEL_OPC_COPY_CRC32C) {
2079 : 8 : break;
2080 : : }
2081 [ - + ]: 877103 : if (task->dst_domain != next->src_domain) {
2082 : 0 : break;
2083 : : }
2084 [ - + ]: 877103 : if (!accel_compare_iovs(task->d.iovs, task->d.iovcnt,
2085 : : next->s.iovs, next->s.iovcnt)) {
2086 : 0 : break;
2087 : : }
2088 : 877103 : next->s.iovs = task->s.iovs;
2089 : 877103 : next->s.iovcnt = task->s.iovcnt;
2090 : 877103 : next->src_domain = task->src_domain;
2091 : 877103 : next->src_domain_ctx = task->src_domain_ctx;
2092 : 877103 : accel_sequence_complete_task(seq, task);
2093 : 877103 : break;
2094 : 3027311 : case SPDK_ACCEL_OPC_DECOMPRESS:
2095 : : case SPDK_ACCEL_OPC_FILL:
2096 : : case SPDK_ACCEL_OPC_ENCRYPT:
2097 : : case SPDK_ACCEL_OPC_DECRYPT:
2098 : : case SPDK_ACCEL_OPC_CRC32C:
2099 : : /* We can only merge tasks when one of them is a copy */
2100 [ + + ]: 3027311 : if (next->op_code != SPDK_ACCEL_OPC_COPY) {
2101 : 726243 : break;
2102 : : }
2103 [ + + ]: 2301068 : if (!accel_task_set_dstbuf(task, next)) {
2104 : 12 : break;
2105 : : }
2106 : : /* We're removing next_task from the tasks queue, so we need to update its pointer,
2107 : : * so that the TAILQ_FOREACH_SAFE() loop below works correctly */
2108 : 2301056 : *next_task = TAILQ_NEXT(next, seq_link);
2109 : 2301056 : accel_sequence_complete_task(seq, next);
2110 : 2301056 : break;
2111 : 0 : default:
2112 : 0 : assert(0 && "bad opcode");
2113 : : break;
2114 : : }
2115 : 3904422 : }
2116 : :
2117 : : void
2118 : 87519566 : spdk_accel_sequence_finish(struct spdk_accel_sequence *seq,
2119 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
2120 : : {
2121 : 55421827 : struct spdk_accel_task *task, *next;
2122 : :
2123 : : /* Try to remove any copy operations if possible */
2124 [ + + ]: 91423988 : TAILQ_FOREACH_SAFE(task, &seq->tasks, seq_link, next) {
2125 [ + + ]: 89122940 : if (next == NULL) {
2126 : 85218518 : break;
2127 : : }
2128 : 3904422 : accel_sequence_merge_tasks(seq, task, &next);
2129 : : }
2130 : :
2131 : 87519566 : seq->cb_fn = cb_fn;
2132 : 87519566 : seq->cb_arg = cb_arg;
2133 : :
2134 : 87519566 : accel_process_sequence(seq);
2135 : 87519566 : }
2136 : :
2137 : : void
2138 : 41598076 : spdk_accel_sequence_reverse(struct spdk_accel_sequence *seq)
2139 : : {
2140 : 41598076 : struct accel_sequence_tasks tasks = TAILQ_HEAD_INITIALIZER(tasks);
2141 : : struct spdk_accel_task *task;
2142 : :
2143 [ + - - + ]: 41598076 : TAILQ_SWAP(&tasks, &seq->tasks, spdk_accel_task, seq_link);
2144 : :
2145 [ + + ]: 84349378 : while (!TAILQ_EMPTY(&tasks)) {
2146 : 42751312 : task = TAILQ_FIRST(&tasks);
2147 [ + + ]: 42751312 : TAILQ_REMOVE(&tasks, task, seq_link);
2148 [ + + ]: 42751312 : TAILQ_INSERT_HEAD(&seq->tasks, task, seq_link);
2149 : : }
2150 : 41598076 : }
2151 : :
2152 : : void
2153 : 400440 : spdk_accel_sequence_abort(struct spdk_accel_sequence *seq)
2154 : : {
2155 [ + + ]: 400440 : if (seq == NULL) {
2156 : 400432 : return;
2157 : : }
2158 : :
2159 : 8 : accel_sequence_complete_tasks(seq);
2160 : 8 : accel_sequence_put(seq);
2161 : : }
2162 : :
2163 : : struct spdk_memory_domain *
2164 : 89766 : spdk_accel_get_memory_domain(void)
2165 : : {
2166 : 89766 : return g_accel_domain;
2167 : : }
2168 : :
2169 : : static struct spdk_accel_module_if *
2170 : 5825 : _module_find_by_name(const char *name)
2171 : : {
2172 : 5825 : struct spdk_accel_module_if *accel_module = NULL;
2173 : :
2174 [ + + ]: 8907 : TAILQ_FOREACH(accel_module, &spdk_accel_module_list, tailq) {
2175 [ + + - + : 3155 : if (strcmp(name, accel_module->name) == 0) {
+ + ]
2176 : 73 : break;
2177 : : }
2178 : : }
2179 : :
2180 : 5825 : return accel_module;
2181 : : }
2182 : :
2183 : : static inline struct spdk_accel_crypto_key *
2184 : 256 : _accel_crypto_key_get(const char *name)
2185 : : {
2186 : : struct spdk_accel_crypto_key *key;
2187 : :
2188 [ - + ]: 256 : assert(spdk_spin_held(&g_keyring_spin));
2189 : :
2190 [ + + ]: 532 : TAILQ_FOREACH(key, &g_keyring, link) {
2191 [ + + - + : 410 : if (strcmp(name, key->param.key_name) == 0) {
+ + ]
2192 : 134 : return key;
2193 : : }
2194 : : }
2195 : :
2196 : 122 : return NULL;
2197 : : }
2198 : :
2199 : : static void
2200 : 117 : accel_crypto_key_free_mem(struct spdk_accel_crypto_key *key)
2201 : : {
2202 [ + - ]: 117 : if (key->param.hex_key) {
2203 : 117 : spdk_memset_s(key->param.hex_key, key->key_size * 2, 0, key->key_size * 2);
2204 : 117 : free(key->param.hex_key);
2205 : : }
2206 [ + + ]: 117 : if (key->param.hex_key2) {
2207 : 57 : spdk_memset_s(key->param.hex_key2, key->key2_size * 2, 0, key->key2_size * 2);
2208 : 57 : free(key->param.hex_key2);
2209 : : }
2210 : 117 : free(key->param.tweak_mode);
2211 : 117 : free(key->param.key_name);
2212 : 117 : free(key->param.cipher);
2213 [ + - ]: 117 : if (key->key) {
2214 : 117 : spdk_memset_s(key->key, key->key_size, 0, key->key_size);
2215 : 117 : free(key->key);
2216 : : }
2217 [ + + ]: 117 : if (key->key2) {
2218 : 57 : spdk_memset_s(key->key2, key->key2_size, 0, key->key2_size);
2219 : 57 : free(key->key2);
2220 : : }
2221 : 117 : free(key);
2222 : 117 : }
2223 : :
2224 : : static void
2225 : 117 : accel_crypto_key_destroy_unsafe(struct spdk_accel_crypto_key *key)
2226 : : {
2227 [ - + ]: 117 : assert(key->module_if);
2228 [ - + ]: 117 : assert(key->module_if->crypto_key_deinit);
2229 : :
2230 : 117 : key->module_if->crypto_key_deinit(key);
2231 : 117 : accel_crypto_key_free_mem(key);
2232 : 117 : }
2233 : :
2234 : : /*
2235 : : * This function mitigates a timing side channel which could be caused by using strcmp()
2236 : : * Please refer to chapter "Mitigating Information Leakage Based on Variable Timing" in
2237 : : * the article [1] for more details
2238 : : * [1] https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/secure-coding/mitigate-timing-side-channel-crypto-implementation.html
2239 : : */
2240 : : static bool
2241 : 57 : accel_aes_xts_keys_equal(const char *k1, size_t k1_len, const char *k2, size_t k2_len)
2242 : : {
2243 : : size_t i;
2244 : 57 : volatile size_t x = k1_len ^ k2_len;
2245 : :
2246 [ + + ]: 969 : for (i = 0; ((i < k1_len) & (i < k2_len)); i++) {
2247 : 912 : x |= k1[i] ^ k2[i];
2248 : : }
2249 : :
2250 : 57 : return x == 0;
2251 : : }
2252 : :
2253 : : static const char *g_tweak_modes[] = {
2254 : : [SPDK_ACCEL_CRYPTO_TWEAK_MODE_SIMPLE_LBA] = "SIMPLE_LBA",
2255 : : [SPDK_ACCEL_CRYPTO_TWEAK_MODE_JOIN_NEG_LBA_WITH_LBA] = "JOIN_NEG_LBA_WITH_LBA",
2256 : : [SPDK_ACCEL_CRYPTO_TWEAK_MODE_INCR_512_FULL_LBA] = "INCR_512_FULL_LBA",
2257 : : [SPDK_ACCEL_CRYPTO_TWEAK_MODE_INCR_512_UPPER_LBA] = "INCR_512_UPPER_LBA",
2258 : : };
2259 : :
2260 : : static const char *g_ciphers[] = {
2261 : : [SPDK_ACCEL_CIPHER_AES_CBC] = "AES_CBC",
2262 : : [SPDK_ACCEL_CIPHER_AES_XTS] = "AES_XTS",
2263 : : };
2264 : :
2265 : : int
2266 : 117 : spdk_accel_crypto_key_create(const struct spdk_accel_crypto_key_create_param *param)
2267 : : {
2268 : : struct spdk_accel_module_if *module;
2269 : : struct spdk_accel_crypto_key *key;
2270 : : size_t hex_key_size, hex_key2_size;
2271 : 117 : bool found = false;
2272 : : size_t i;
2273 : : int rc;
2274 : :
2275 [ + - + - : 117 : if (!param || !param->hex_key || !param->cipher || !param->key_name) {
+ - - + ]
2276 : 0 : return -EINVAL;
2277 : : }
2278 : :
2279 [ - + ]: 117 : if (g_modules_opc[SPDK_ACCEL_OPC_ENCRYPT].module != g_modules_opc[SPDK_ACCEL_OPC_DECRYPT].module) {
2280 : : /* hardly ever possible, but let's check and warn the user */
2281 : 0 : SPDK_ERRLOG("Different accel modules are used for encryption and decryption\n");
2282 : : }
2283 : 117 : module = g_modules_opc[SPDK_ACCEL_OPC_ENCRYPT].module;
2284 : :
2285 [ - + ]: 117 : if (!module) {
2286 : 0 : SPDK_ERRLOG("No accel module found assigned for crypto operation\n");
2287 : 0 : return -ENOENT;
2288 : : }
2289 : :
2290 [ + - - + ]: 117 : if (!module->crypto_key_init || !module->crypto_supports_cipher) {
2291 : 0 : SPDK_ERRLOG("Module %s doesn't support crypto operations\n", module->name);
2292 : 0 : return -ENOTSUP;
2293 : : }
2294 : :
2295 : 117 : key = calloc(1, sizeof(*key));
2296 [ - + ]: 117 : if (!key) {
2297 : 0 : return -ENOMEM;
2298 : : }
2299 : :
2300 [ - + ]: 117 : key->param.key_name = strdup(param->key_name);
2301 [ - + ]: 117 : if (!key->param.key_name) {
2302 : 0 : rc = -ENOMEM;
2303 : 0 : goto error;
2304 : : }
2305 : :
2306 [ + - ]: 174 : for (i = 0; i < SPDK_COUNTOF(g_ciphers); ++i) {
2307 [ - + ]: 174 : assert(g_ciphers[i]);
2308 : :
2309 [ + + - + : 174 : if (strncmp(param->cipher, g_ciphers[i], strlen(g_ciphers[i])) == 0) {
- + + + ]
2310 : 117 : key->cipher = i;
2311 : 117 : found = true;
2312 : 117 : break;
2313 : : }
2314 : : }
2315 : :
2316 [ - + ]: 117 : if (!found) {
2317 : 0 : SPDK_ERRLOG("Failed to parse cipher\n");
2318 : 0 : rc = -EINVAL;
2319 : 0 : goto error;
2320 : : }
2321 : :
2322 [ - + ]: 117 : key->param.cipher = strdup(param->cipher);
2323 [ - + ]: 117 : if (!key->param.cipher) {
2324 : 0 : rc = -ENOMEM;
2325 : 0 : goto error;
2326 : : }
2327 : :
2328 [ - + ]: 117 : hex_key_size = strnlen(param->hex_key, SPDK_ACCEL_CRYPTO_KEY_MAX_HEX_LENGTH);
2329 [ - + ]: 117 : if (hex_key_size == SPDK_ACCEL_CRYPTO_KEY_MAX_HEX_LENGTH) {
2330 : 0 : SPDK_ERRLOG("key1 size exceeds max %d\n", SPDK_ACCEL_CRYPTO_KEY_MAX_HEX_LENGTH);
2331 : 0 : rc = -EINVAL;
2332 : 0 : goto error;
2333 : : }
2334 : :
2335 [ - + ]: 117 : if (hex_key_size == 0) {
2336 : 0 : SPDK_ERRLOG("key1 size cannot be 0\n");
2337 : 0 : rc = -EINVAL;
2338 : 0 : goto error;
2339 : : }
2340 : :
2341 [ - + ]: 117 : key->param.hex_key = strdup(param->hex_key);
2342 [ - + ]: 117 : if (!key->param.hex_key) {
2343 : 0 : rc = -ENOMEM;
2344 : 0 : goto error;
2345 : : }
2346 : :
2347 : 117 : key->key_size = hex_key_size / 2;
2348 : 117 : key->key = spdk_unhexlify(key->param.hex_key);
2349 [ - + ]: 117 : if (!key->key) {
2350 : 0 : SPDK_ERRLOG("Failed to unhexlify key1\n");
2351 : 0 : rc = -EINVAL;
2352 : 0 : goto error;
2353 : : }
2354 : :
2355 [ + + ]: 117 : if (param->hex_key2) {
2356 [ - + ]: 57 : hex_key2_size = strnlen(param->hex_key2, SPDK_ACCEL_CRYPTO_KEY_MAX_HEX_LENGTH);
2357 [ - + ]: 57 : if (hex_key2_size == SPDK_ACCEL_CRYPTO_KEY_MAX_HEX_LENGTH) {
2358 : 0 : SPDK_ERRLOG("key2 size exceeds max %d\n", SPDK_ACCEL_CRYPTO_KEY_MAX_HEX_LENGTH);
2359 : 0 : rc = -EINVAL;
2360 : 0 : goto error;
2361 : : }
2362 : :
2363 [ - + ]: 57 : if (hex_key2_size == 0) {
2364 : 0 : SPDK_ERRLOG("key2 size cannot be 0\n");
2365 : 0 : rc = -EINVAL;
2366 : 0 : goto error;
2367 : : }
2368 : :
2369 [ - + ]: 57 : key->param.hex_key2 = strdup(param->hex_key2);
2370 [ - + ]: 57 : if (!key->param.hex_key2) {
2371 : 0 : rc = -ENOMEM;
2372 : 0 : goto error;
2373 : : }
2374 : :
2375 : 57 : key->key2_size = hex_key2_size / 2;
2376 : 57 : key->key2 = spdk_unhexlify(key->param.hex_key2);
2377 [ - + ]: 57 : if (!key->key2) {
2378 : 0 : SPDK_ERRLOG("Failed to unhexlify key2\n");
2379 : 0 : rc = -EINVAL;
2380 : 0 : goto error;
2381 : : }
2382 : : }
2383 : :
2384 : 117 : key->tweak_mode = ACCEL_CRYPTO_TWEAK_MODE_DEFAULT;
2385 [ - + ]: 117 : if (param->tweak_mode) {
2386 : 0 : found = false;
2387 : :
2388 [ # # ]: 0 : key->param.tweak_mode = strdup(param->tweak_mode);
2389 [ # # ]: 0 : if (!key->param.tweak_mode) {
2390 : 0 : rc = -ENOMEM;
2391 : 0 : goto error;
2392 : : }
2393 : :
2394 [ # # ]: 0 : for (i = 0; i < SPDK_COUNTOF(g_tweak_modes); ++i) {
2395 [ # # ]: 0 : assert(g_tweak_modes[i]);
2396 : :
2397 [ # # # # : 0 : if (strncmp(param->tweak_mode, g_tweak_modes[i], strlen(g_tweak_modes[i])) == 0) {
# # # # ]
2398 : 0 : key->tweak_mode = i;
2399 : 0 : found = true;
2400 : 0 : break;
2401 : : }
2402 : : }
2403 : :
2404 [ # # ]: 0 : if (!found) {
2405 : 0 : SPDK_ERRLOG("Failed to parse tweak mode\n");
2406 : 0 : rc = -EINVAL;
2407 : 0 : goto error;
2408 : : }
2409 : : }
2410 : :
2411 [ + + + - ]: 117 : if ((!module->crypto_supports_tweak_mode && key->tweak_mode != ACCEL_CRYPTO_TWEAK_MODE_DEFAULT) ||
2412 [ + + - + ]: 117 : (module->crypto_supports_tweak_mode && !module->crypto_supports_tweak_mode(key->tweak_mode))) {
2413 : 0 : SPDK_ERRLOG("Module %s doesn't support %s tweak mode\n", module->name,
2414 : : g_tweak_modes[key->tweak_mode]);
2415 : 0 : rc = -EINVAL;
2416 : 0 : goto error;
2417 : : }
2418 : :
2419 [ - + ]: 117 : if (!module->crypto_supports_cipher(key->cipher, key->key_size)) {
2420 : 0 : SPDK_ERRLOG("Module %s doesn't support %s cipher with %zu key size\n", module->name,
2421 : : g_ciphers[key->cipher], key->key_size);
2422 : 0 : rc = -EINVAL;
2423 : 0 : goto error;
2424 : : }
2425 : :
2426 [ + + ]: 117 : if (key->cipher == SPDK_ACCEL_CIPHER_AES_XTS) {
2427 [ - + ]: 57 : if (!key->key2) {
2428 : 0 : SPDK_ERRLOG("%s key2 is missing\n", g_ciphers[key->cipher]);
2429 : 0 : rc = -EINVAL;
2430 : 0 : goto error;
2431 : : }
2432 : :
2433 [ - + ]: 57 : if (key->key_size != key->key2_size) {
2434 : 0 : SPDK_ERRLOG("%s key size %zu is not equal to key2 size %zu\n", g_ciphers[key->cipher],
2435 : : key->key_size,
2436 : : key->key2_size);
2437 : 0 : rc = -EINVAL;
2438 : 0 : goto error;
2439 : : }
2440 : :
2441 [ - + ]: 57 : if (accel_aes_xts_keys_equal(key->key, key->key_size, key->key2, key->key2_size)) {
2442 : 0 : SPDK_ERRLOG("%s identical keys are not secure\n", g_ciphers[key->cipher]);
2443 : 0 : rc = -EINVAL;
2444 : 0 : goto error;
2445 : : }
2446 : : }
2447 : :
2448 [ + + ]: 117 : if (key->cipher == SPDK_ACCEL_CIPHER_AES_CBC) {
2449 [ - + ]: 60 : if (key->key2_size) {
2450 : 0 : SPDK_ERRLOG("%s doesn't use key2\n", g_ciphers[key->cipher]);
2451 : 0 : rc = -EINVAL;
2452 : 0 : goto error;
2453 : : }
2454 : : }
2455 : :
2456 : 117 : key->module_if = module;
2457 : :
2458 : 117 : spdk_spin_lock(&g_keyring_spin);
2459 [ - + ]: 117 : if (_accel_crypto_key_get(param->key_name)) {
2460 : 0 : rc = -EEXIST;
2461 : : } else {
2462 : 117 : rc = module->crypto_key_init(key);
2463 [ - + ]: 117 : if (rc) {
2464 : 0 : SPDK_ERRLOG("Module %s failed to initialize crypto key\n", module->name);
2465 : : } else {
2466 : 117 : TAILQ_INSERT_TAIL(&g_keyring, key, link);
2467 : : }
2468 : : }
2469 : 117 : spdk_spin_unlock(&g_keyring_spin);
2470 : :
2471 [ - + ]: 117 : if (rc) {
2472 : 0 : goto error;
2473 : : }
2474 : :
2475 : 117 : return 0;
2476 : :
2477 : 0 : error:
2478 : 0 : accel_crypto_key_free_mem(key);
2479 : 0 : return rc;
2480 : : }
2481 : :
2482 : : int
2483 : 8 : spdk_accel_crypto_key_destroy(struct spdk_accel_crypto_key *key)
2484 : : {
2485 [ + - - + ]: 8 : if (!key || !key->module_if) {
2486 : 0 : return -EINVAL;
2487 : : }
2488 : :
2489 : 8 : spdk_spin_lock(&g_keyring_spin);
2490 [ - + ]: 8 : if (!_accel_crypto_key_get(key->param.key_name)) {
2491 : 0 : spdk_spin_unlock(&g_keyring_spin);
2492 : 0 : return -ENOENT;
2493 : : }
2494 [ - + ]: 8 : TAILQ_REMOVE(&g_keyring, key, link);
2495 : 8 : spdk_spin_unlock(&g_keyring_spin);
2496 : :
2497 : 8 : accel_crypto_key_destroy_unsafe(key);
2498 : :
2499 : 8 : return 0;
2500 : : }
2501 : :
2502 : : struct spdk_accel_crypto_key *
2503 : 131 : spdk_accel_crypto_key_get(const char *name)
2504 : : {
2505 : : struct spdk_accel_crypto_key *key;
2506 : :
2507 : 131 : spdk_spin_lock(&g_keyring_spin);
2508 : 131 : key = _accel_crypto_key_get(name);
2509 : 131 : spdk_spin_unlock(&g_keyring_spin);
2510 : :
2511 : 131 : return key;
2512 : : }
2513 : :
2514 : : /* Helper function when accel modules register with the framework. */
2515 : : void
2516 : 5748 : spdk_accel_module_list_add(struct spdk_accel_module_if *accel_module)
2517 : : {
2518 : : struct spdk_accel_module_if *tmp;
2519 : :
2520 [ - + ]: 5748 : if (_module_find_by_name(accel_module->name)) {
2521 : 0 : SPDK_NOTICELOG("Module %s already registered\n", accel_module->name);
2522 : 0 : assert(false);
2523 : : return;
2524 : : }
2525 : :
2526 [ + + ]: 6824 : TAILQ_FOREACH(tmp, &spdk_accel_module_list, tailq) {
2527 [ + + ]: 2954 : if (accel_module->priority < tmp->priority) {
2528 : 1878 : break;
2529 : : }
2530 : : }
2531 : :
2532 [ + + ]: 5748 : if (tmp != NULL) {
2533 : 1878 : TAILQ_INSERT_BEFORE(tmp, accel_module, tailq);
2534 : : } else {
2535 : 3870 : TAILQ_INSERT_TAIL(&spdk_accel_module_list, accel_module, tailq);
2536 : : }
2537 : : }
2538 : :
2539 : : /* Framework level channel create callback. */
2540 : : static int
2541 : 11465 : accel_create_channel(void *io_device, void *ctx_buf)
2542 : : {
2543 : 11465 : struct accel_io_channel *accel_ch = ctx_buf;
2544 : : struct spdk_accel_task *accel_task;
2545 : : struct spdk_accel_task_aux_data *accel_task_aux;
2546 : : struct spdk_accel_sequence *seq;
2547 : : struct accel_buffer *buf;
2548 : : size_t task_size_aligned;
2549 : : uint8_t *task_mem;
2550 : 11465 : uint32_t i = 0, j;
2551 : : int rc;
2552 : :
2553 : 11465 : task_size_aligned = SPDK_ALIGN_CEIL(g_max_accel_module_size, SPDK_CACHE_LINE_SIZE);
2554 : 11465 : accel_ch->task_pool_base = aligned_alloc(SPDK_CACHE_LINE_SIZE,
2555 : 11465 : g_opts.task_count * task_size_aligned);
2556 [ - + ]: 11465 : if (!accel_ch->task_pool_base) {
2557 : 0 : return -ENOMEM;
2558 : : }
2559 [ - + ]: 11465 : memset(accel_ch->task_pool_base, 0, g_opts.task_count * task_size_aligned);
2560 : :
2561 : 11465 : accel_ch->seq_pool_base = aligned_alloc(SPDK_CACHE_LINE_SIZE,
2562 : 11465 : g_opts.sequence_count * sizeof(struct spdk_accel_sequence));
2563 [ - + ]: 11465 : if (accel_ch->seq_pool_base == NULL) {
2564 : 0 : goto err;
2565 : : }
2566 [ - + ]: 11465 : memset(accel_ch->seq_pool_base, 0, g_opts.sequence_count * sizeof(struct spdk_accel_sequence));
2567 : :
2568 : 11465 : accel_ch->task_aux_data_base = calloc(g_opts.task_count, sizeof(struct spdk_accel_task_aux_data));
2569 [ - + ]: 11465 : if (accel_ch->task_aux_data_base == NULL) {
2570 : 0 : goto err;
2571 : : }
2572 : :
2573 : 11465 : accel_ch->buf_pool_base = calloc(g_opts.buf_count, sizeof(struct accel_buffer));
2574 [ - + ]: 11465 : if (accel_ch->buf_pool_base == NULL) {
2575 : 0 : goto err;
2576 : : }
2577 : :
2578 : 11465 : STAILQ_INIT(&accel_ch->task_pool);
2579 : 11465 : SLIST_INIT(&accel_ch->task_aux_data_pool);
2580 : 11465 : SLIST_INIT(&accel_ch->seq_pool);
2581 : 11465 : SLIST_INIT(&accel_ch->buf_pool);
2582 : :
2583 : 11465 : task_mem = accel_ch->task_pool_base;
2584 [ + + ]: 23473498 : for (i = 0; i < g_opts.task_count; i++) {
2585 : 23462034 : accel_task = (struct spdk_accel_task *)task_mem;
2586 : 23462034 : accel_task->aux = NULL;
2587 : 23462034 : STAILQ_INSERT_TAIL(&accel_ch->task_pool, accel_task, link);
2588 : 23462034 : task_mem += task_size_aligned;
2589 : 23462034 : accel_task_aux = &accel_ch->task_aux_data_base[i];
2590 : 23462034 : SLIST_INSERT_HEAD(&accel_ch->task_aux_data_pool, accel_task_aux, link);
2591 : : }
2592 [ + + ]: 23491786 : for (i = 0; i < g_opts.sequence_count; i++) {
2593 : 23480322 : seq = &accel_ch->seq_pool_base[i];
2594 : 23480322 : SLIST_INSERT_HEAD(&accel_ch->seq_pool, seq, link);
2595 : : }
2596 [ + + ]: 23491786 : for (i = 0; i < g_opts.buf_count; i++) {
2597 : 23480322 : buf = &accel_ch->buf_pool_base[i];
2598 : 23480322 : SLIST_INSERT_HEAD(&accel_ch->buf_pool, buf, link);
2599 : : }
2600 : :
2601 : : /* Assign modules and get IO channels for each */
2602 [ + + ]: 183440 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; i++) {
2603 : 171975 : accel_ch->module_ch[i] = g_modules_opc[i].module->get_io_channel();
2604 : : /* This can happen if idxd runs out of channels. */
2605 [ - + ]: 171975 : if (accel_ch->module_ch[i] == NULL) {
2606 : 0 : SPDK_ERRLOG("Module %s failed to get io channel\n", g_modules_opc[i].module->name);
2607 : 0 : goto err;
2608 : : }
2609 : : }
2610 : :
2611 [ - + ]: 11465 : if (g_accel_driver != NULL) {
2612 : 0 : accel_ch->driver_channel = g_accel_driver->get_io_channel();
2613 [ # # ]: 0 : if (accel_ch->driver_channel == NULL) {
2614 : 0 : SPDK_ERRLOG("Failed to get driver's IO channel\n");
2615 : 0 : goto err;
2616 : : }
2617 : : }
2618 : :
2619 : 11465 : rc = spdk_iobuf_channel_init(&accel_ch->iobuf, "accel", g_opts.small_cache_size,
2620 : : g_opts.large_cache_size);
2621 [ - + ]: 11465 : if (rc != 0) {
2622 : 0 : SPDK_ERRLOG("Failed to initialize iobuf accel channel\n");
2623 : 0 : goto err;
2624 : : }
2625 : :
2626 : 11465 : return 0;
2627 : 0 : err:
2628 [ # # ]: 0 : if (accel_ch->driver_channel != NULL) {
2629 : 0 : spdk_put_io_channel(accel_ch->driver_channel);
2630 : : }
2631 [ # # ]: 0 : for (j = 0; j < i; j++) {
2632 : 0 : spdk_put_io_channel(accel_ch->module_ch[j]);
2633 : : }
2634 : 0 : free(accel_ch->task_pool_base);
2635 : 0 : free(accel_ch->task_aux_data_base);
2636 : 0 : free(accel_ch->seq_pool_base);
2637 : 0 : free(accel_ch->buf_pool_base);
2638 : :
2639 : 0 : return -ENOMEM;
2640 : : }
2641 : :
2642 : : static void
2643 : 11549 : accel_add_stats(struct accel_stats *total, struct accel_stats *stats)
2644 : : {
2645 : : int i;
2646 : :
2647 : 11549 : total->sequence_executed += stats->sequence_executed;
2648 : 11549 : total->sequence_failed += stats->sequence_failed;
2649 : 11549 : total->sequence_outstanding += stats->sequence_outstanding;
2650 : 11549 : total->task_outstanding += stats->task_outstanding;
2651 : 11549 : total->retry.task += stats->retry.task;
2652 : 11549 : total->retry.sequence += stats->retry.sequence;
2653 : 11549 : total->retry.iobuf += stats->retry.iobuf;
2654 : 11549 : total->retry.bufdesc += stats->retry.bufdesc;
2655 [ + + ]: 184784 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2656 : 173235 : total->operations[i].executed += stats->operations[i].executed;
2657 : 173235 : total->operations[i].failed += stats->operations[i].failed;
2658 : 173235 : total->operations[i].num_bytes += stats->operations[i].num_bytes;
2659 : : }
2660 : 11549 : }
2661 : :
2662 : : /* Framework level channel destroy callback. */
2663 : : static void
2664 : 11465 : accel_destroy_channel(void *io_device, void *ctx_buf)
2665 : : {
2666 : 11465 : struct accel_io_channel *accel_ch = ctx_buf;
2667 : : int i;
2668 : :
2669 : 11465 : spdk_iobuf_channel_fini(&accel_ch->iobuf);
2670 : :
2671 [ - + ]: 11465 : if (accel_ch->driver_channel != NULL) {
2672 : 0 : spdk_put_io_channel(accel_ch->driver_channel);
2673 : : }
2674 : :
2675 [ + + ]: 183440 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; i++) {
2676 [ - + ]: 171975 : assert(accel_ch->module_ch[i] != NULL);
2677 : 171975 : spdk_put_io_channel(accel_ch->module_ch[i]);
2678 : 171975 : accel_ch->module_ch[i] = NULL;
2679 : : }
2680 : :
2681 : : /* Update global stats to make sure channel's stats aren't lost after a channel is gone */
2682 : 11465 : spdk_spin_lock(&g_stats_lock);
2683 : 11465 : accel_add_stats(&g_stats, &accel_ch->stats);
2684 : 11465 : spdk_spin_unlock(&g_stats_lock);
2685 : :
2686 : 11465 : free(accel_ch->task_pool_base);
2687 : 11465 : free(accel_ch->task_aux_data_base);
2688 : 11465 : free(accel_ch->seq_pool_base);
2689 : 11465 : free(accel_ch->buf_pool_base);
2690 : 11465 : }
2691 : :
2692 : : struct spdk_io_channel *
2693 : 35981 : spdk_accel_get_io_channel(void)
2694 : : {
2695 : 35981 : return spdk_get_io_channel(&spdk_accel_module_list);
2696 : : }
2697 : :
2698 : : static int
2699 : 2666 : accel_module_initialize(void)
2700 : : {
2701 : : struct spdk_accel_module_if *accel_module, *tmp_module;
2702 : 2666 : int rc = 0, module_rc;
2703 : :
2704 [ + + ]: 7969 : TAILQ_FOREACH_SAFE(accel_module, &spdk_accel_module_list, tailq, tmp_module) {
2705 : 5303 : module_rc = accel_module->module_init();
2706 [ - + ]: 5303 : if (module_rc) {
2707 [ # # ]: 0 : TAILQ_REMOVE(&spdk_accel_module_list, accel_module, tailq);
2708 [ # # ]: 0 : if (module_rc == -ENODEV) {
2709 : 0 : SPDK_NOTICELOG("No devices for module %s, skipping\n", accel_module->name);
2710 [ # # ]: 0 : } else if (!rc) {
2711 : 0 : SPDK_ERRLOG("Module %s initialization failed with %d\n", accel_module->name, module_rc);
2712 : 0 : rc = module_rc;
2713 : : }
2714 : 0 : continue;
2715 : : }
2716 : :
2717 [ - + - + ]: 5303 : SPDK_DEBUGLOG(accel, "Module %s initialized.\n", accel_module->name);
2718 : : }
2719 : :
2720 : 2666 : return rc;
2721 : : }
2722 : :
2723 : : static void
2724 : 39990 : accel_module_init_opcode(enum spdk_accel_opcode opcode)
2725 : : {
2726 : 39990 : struct accel_module *module = &g_modules_opc[opcode];
2727 : 39990 : struct spdk_accel_module_if *module_if = module->module;
2728 : :
2729 [ - + ]: 39990 : if (module_if->get_memory_domains != NULL) {
2730 : 0 : module->supports_memory_domains = module_if->get_memory_domains(NULL, 0) > 0;
2731 : : }
2732 : 39990 : }
2733 : :
2734 : : static int
2735 : 49769 : accel_memory_domain_translate(struct spdk_memory_domain *src_domain, void *src_domain_ctx,
2736 : : struct spdk_memory_domain *dst_domain, struct spdk_memory_domain_translation_ctx *dst_domain_ctx,
2737 : : void *addr, size_t len, struct spdk_memory_domain_translation_result *result)
2738 : : {
2739 : 49769 : struct accel_buffer *buf = src_domain_ctx;
2740 : :
2741 [ - + - + ]: 49769 : SPDK_DEBUGLOG(accel, "translate addr %p, len %zu\n", addr, len);
2742 : :
2743 [ - + ]: 49769 : assert(g_accel_domain == src_domain);
2744 [ - + ]: 49769 : assert(spdk_memory_domain_get_system_domain() == dst_domain);
2745 [ - + ]: 49769 : assert(buf->buf == NULL);
2746 [ - + ]: 49769 : assert(addr == ACCEL_BUFFER_BASE);
2747 [ - + ]: 49769 : assert(len == buf->len);
2748 : :
2749 : 49769 : buf->buf = spdk_iobuf_get(&buf->ch->iobuf, buf->len, NULL, NULL);
2750 [ - + ]: 49769 : if (spdk_unlikely(buf->buf == NULL)) {
2751 : 0 : return -ENOMEM;
2752 : : }
2753 : :
2754 : 49769 : result->iov_count = 1;
2755 : 49769 : result->iov.iov_base = buf->buf;
2756 : 49769 : result->iov.iov_len = buf->len;
2757 [ - + - + ]: 49769 : SPDK_DEBUGLOG(accel, "translated addr %p\n", result->iov.iov_base);
2758 : 49769 : return 0;
2759 : : }
2760 : :
2761 : : static void
2762 : 49769 : accel_memory_domain_invalidate(struct spdk_memory_domain *domain, void *domain_ctx,
2763 : : struct iovec *iov, uint32_t iovcnt)
2764 : : {
2765 : 49769 : struct accel_buffer *buf = domain_ctx;
2766 : :
2767 [ - + - + ]: 49769 : SPDK_DEBUGLOG(accel, "invalidate addr %p, len %zu\n", iov[0].iov_base, iov[0].iov_len);
2768 : :
2769 [ - + ]: 49769 : assert(g_accel_domain == domain);
2770 [ - + ]: 49769 : assert(iovcnt == 1);
2771 [ - + ]: 49769 : assert(buf->buf != NULL);
2772 [ - + ]: 49769 : assert(iov[0].iov_base == buf->buf);
2773 [ - + ]: 49769 : assert(iov[0].iov_len == buf->len);
2774 : :
2775 : 49769 : spdk_iobuf_put(&buf->ch->iobuf, buf->buf, buf->len);
2776 : 49769 : buf->buf = NULL;
2777 : 49769 : }
2778 : :
2779 : : int
2780 : 2666 : spdk_accel_initialize(void)
2781 : : {
2782 : : enum spdk_accel_opcode op;
2783 : 2666 : struct spdk_accel_module_if *accel_module = NULL;
2784 : : int rc;
2785 : :
2786 : : /*
2787 : : * We need a unique identifier for the accel framework, so use the
2788 : : * spdk_accel_module_list address for this purpose.
2789 : : */
2790 : 2666 : spdk_io_device_register(&spdk_accel_module_list, accel_create_channel, accel_destroy_channel,
2791 : : sizeof(struct accel_io_channel), "accel");
2792 : :
2793 : 2666 : spdk_spin_init(&g_keyring_spin);
2794 : 2666 : spdk_spin_init(&g_stats_lock);
2795 : :
2796 : 2666 : rc = spdk_memory_domain_create(&g_accel_domain, SPDK_DMA_DEVICE_TYPE_ACCEL, NULL,
2797 : : "SPDK_ACCEL_DMA_DEVICE");
2798 [ - + ]: 2666 : if (rc != 0) {
2799 : 0 : SPDK_ERRLOG("Failed to create accel memory domain\n");
2800 : 0 : return rc;
2801 : : }
2802 : :
2803 : 2666 : spdk_memory_domain_set_translation(g_accel_domain, accel_memory_domain_translate);
2804 : 2666 : spdk_memory_domain_set_invalidate(g_accel_domain, accel_memory_domain_invalidate);
2805 : :
2806 : 2666 : g_modules_started = true;
2807 : 2666 : rc = accel_module_initialize();
2808 [ - + ]: 2666 : if (rc) {
2809 : 0 : return rc;
2810 : : }
2811 : :
2812 [ - + - - ]: 2666 : if (g_accel_driver != NULL && g_accel_driver->init != NULL) {
2813 : 0 : rc = g_accel_driver->init();
2814 [ # # ]: 0 : if (rc != 0) {
2815 : 0 : SPDK_ERRLOG("Failed to initialize driver %s: %s\n", g_accel_driver->name,
2816 : : spdk_strerror(-rc));
2817 : 0 : return rc;
2818 : : }
2819 : : }
2820 : :
2821 : : /* The module list is order by priority, with the highest priority modules being at the end
2822 : : * of the list. The software module should be somewhere at the beginning of the list,
2823 : : * before all HW modules.
2824 : : * NOTE: all opcodes must be supported by software in the event that no HW modules are
2825 : : * initialized to support the operation.
2826 : : */
2827 [ + + ]: 7969 : TAILQ_FOREACH(accel_module, &spdk_accel_module_list, tailq) {
2828 [ + + ]: 84848 : for (op = 0; op < SPDK_ACCEL_OPC_LAST; op++) {
2829 [ + + ]: 79545 : if (accel_module->supports_opcode(op)) {
2830 : 42854 : g_modules_opc[op].module = accel_module;
2831 [ - + - + ]: 42854 : SPDK_DEBUGLOG(accel, "OPC 0x%x now assigned to %s\n", op, accel_module->name);
2832 : : }
2833 : : }
2834 : :
2835 [ + + ]: 5303 : if (accel_module->get_ctx_size != NULL) {
2836 [ + + ]: 5287 : g_max_accel_module_size = spdk_max(g_max_accel_module_size,
2837 : : accel_module->get_ctx_size());
2838 : : }
2839 : : }
2840 : :
2841 : : /* Now lets check for overrides and apply all that exist */
2842 [ + + ]: 42656 : for (op = 0; op < SPDK_ACCEL_OPC_LAST; op++) {
2843 [ + + ]: 39990 : if (g_modules_opc_override[op] != NULL) {
2844 : 69 : accel_module = _module_find_by_name(g_modules_opc_override[op]);
2845 [ - + ]: 69 : if (accel_module == NULL) {
2846 : 0 : SPDK_ERRLOG("Invalid module name of %s\n", g_modules_opc_override[op]);
2847 : 0 : return -EINVAL;
2848 : : }
2849 [ - + ]: 69 : if (accel_module->supports_opcode(op) == false) {
2850 : 0 : SPDK_ERRLOG("Module %s does not support op code %d\n", accel_module->name, op);
2851 : 0 : return -EINVAL;
2852 : : }
2853 : 69 : g_modules_opc[op].module = accel_module;
2854 : : }
2855 : : }
2856 : :
2857 [ - + ]: 2666 : if (g_modules_opc[SPDK_ACCEL_OPC_ENCRYPT].module != g_modules_opc[SPDK_ACCEL_OPC_DECRYPT].module) {
2858 : 0 : SPDK_ERRLOG("Different accel modules are assigned to encrypt and decrypt operations");
2859 : 0 : return -EINVAL;
2860 : : }
2861 : :
2862 [ + + ]: 42656 : for (op = 0; op < SPDK_ACCEL_OPC_LAST; op++) {
2863 [ - + ]: 39990 : assert(g_modules_opc[op].module != NULL);
2864 : 39990 : accel_module_init_opcode(op);
2865 : : }
2866 : :
2867 : 2666 : rc = spdk_iobuf_register_module("accel");
2868 [ - + ]: 2666 : if (rc != 0) {
2869 : 0 : SPDK_ERRLOG("Failed to register accel iobuf module\n");
2870 : 0 : return rc;
2871 : : }
2872 : :
2873 : 2666 : return 0;
2874 : : }
2875 : :
2876 : : static void
2877 : 2666 : accel_module_finish_cb(void)
2878 : : {
2879 : 2666 : spdk_accel_fini_cb cb_fn = g_fini_cb_fn;
2880 : :
2881 : 2666 : cb_fn(g_fini_cb_arg);
2882 : 2666 : g_fini_cb_fn = NULL;
2883 : 2666 : g_fini_cb_arg = NULL;
2884 : 2666 : }
2885 : :
2886 : : static void
2887 : 14 : accel_write_overridden_opc(struct spdk_json_write_ctx *w, const char *opc_str,
2888 : : const char *module_str)
2889 : : {
2890 : 14 : spdk_json_write_object_begin(w);
2891 : 14 : spdk_json_write_named_string(w, "method", "accel_assign_opc");
2892 : 14 : spdk_json_write_named_object_begin(w, "params");
2893 : 14 : spdk_json_write_named_string(w, "opname", opc_str);
2894 : 14 : spdk_json_write_named_string(w, "module", module_str);
2895 : 14 : spdk_json_write_object_end(w);
2896 : 14 : spdk_json_write_object_end(w);
2897 : 14 : }
2898 : :
2899 : : static void
2900 : 23 : __accel_crypto_key_dump_param(struct spdk_json_write_ctx *w, struct spdk_accel_crypto_key *key)
2901 : : {
2902 : 23 : spdk_json_write_named_string(w, "name", key->param.key_name);
2903 : 23 : spdk_json_write_named_string(w, "cipher", key->param.cipher);
2904 : 23 : spdk_json_write_named_string(w, "key", key->param.hex_key);
2905 [ + + ]: 23 : if (key->param.hex_key2) {
2906 : 5 : spdk_json_write_named_string(w, "key2", key->param.hex_key2);
2907 : : }
2908 : :
2909 [ - + ]: 23 : if (key->param.tweak_mode) {
2910 : 0 : spdk_json_write_named_string(w, "tweak_mode", key->param.tweak_mode);
2911 : : }
2912 : 23 : }
2913 : :
2914 : : void
2915 : 9 : _accel_crypto_key_dump_param(struct spdk_json_write_ctx *w, struct spdk_accel_crypto_key *key)
2916 : : {
2917 : 9 : spdk_json_write_object_begin(w);
2918 : 9 : __accel_crypto_key_dump_param(w, key);
2919 : 9 : spdk_json_write_object_end(w);
2920 : 9 : }
2921 : :
2922 : : static void
2923 : 14 : _accel_crypto_key_write_config_json(struct spdk_json_write_ctx *w,
2924 : : struct spdk_accel_crypto_key *key)
2925 : : {
2926 : 14 : spdk_json_write_object_begin(w);
2927 : 14 : spdk_json_write_named_string(w, "method", "accel_crypto_key_create");
2928 : 14 : spdk_json_write_named_object_begin(w, "params");
2929 : 14 : __accel_crypto_key_dump_param(w, key);
2930 : 14 : spdk_json_write_object_end(w);
2931 : 14 : spdk_json_write_object_end(w);
2932 : 14 : }
2933 : :
2934 : : static void
2935 : 148 : accel_write_options(struct spdk_json_write_ctx *w)
2936 : : {
2937 : 148 : spdk_json_write_object_begin(w);
2938 : 148 : spdk_json_write_named_string(w, "method", "accel_set_options");
2939 : 148 : spdk_json_write_named_object_begin(w, "params");
2940 : 148 : spdk_json_write_named_uint32(w, "small_cache_size", g_opts.small_cache_size);
2941 : 148 : spdk_json_write_named_uint32(w, "large_cache_size", g_opts.large_cache_size);
2942 : 148 : spdk_json_write_named_uint32(w, "task_count", g_opts.task_count);
2943 : 148 : spdk_json_write_named_uint32(w, "sequence_count", g_opts.sequence_count);
2944 : 148 : spdk_json_write_named_uint32(w, "buf_count", g_opts.buf_count);
2945 : 148 : spdk_json_write_object_end(w);
2946 : 148 : spdk_json_write_object_end(w);
2947 : 148 : }
2948 : :
2949 : : static void
2950 : 148 : _accel_crypto_keys_write_config_json(struct spdk_json_write_ctx *w, bool full_dump)
2951 : : {
2952 : : struct spdk_accel_crypto_key *key;
2953 : :
2954 : 148 : spdk_spin_lock(&g_keyring_spin);
2955 [ + + ]: 162 : TAILQ_FOREACH(key, &g_keyring, link) {
2956 [ + - ]: 14 : if (full_dump) {
2957 : 14 : _accel_crypto_key_write_config_json(w, key);
2958 : : } else {
2959 : 0 : _accel_crypto_key_dump_param(w, key);
2960 : : }
2961 : : }
2962 : 148 : spdk_spin_unlock(&g_keyring_spin);
2963 : 148 : }
2964 : :
2965 : : void
2966 : 0 : _accel_crypto_keys_dump_param(struct spdk_json_write_ctx *w)
2967 : : {
2968 : 0 : _accel_crypto_keys_write_config_json(w, false);
2969 : 0 : }
2970 : :
2971 : : void
2972 : 148 : spdk_accel_write_config_json(struct spdk_json_write_ctx *w)
2973 : : {
2974 : : struct spdk_accel_module_if *accel_module;
2975 : : int i;
2976 : :
2977 : 148 : spdk_json_write_array_begin(w);
2978 : 148 : accel_write_options(w);
2979 : :
2980 [ + + ]: 453 : TAILQ_FOREACH(accel_module, &spdk_accel_module_list, tailq) {
2981 [ + + ]: 305 : if (accel_module->write_config_json) {
2982 : 157 : accel_module->write_config_json(w);
2983 : : }
2984 : : }
2985 [ + + ]: 2368 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; i++) {
2986 [ + + ]: 2220 : if (g_modules_opc_override[i]) {
2987 : 14 : accel_write_overridden_opc(w, g_opcode_strings[i], g_modules_opc_override[i]);
2988 : : }
2989 : : }
2990 : :
2991 : 148 : _accel_crypto_keys_write_config_json(w, true);
2992 : :
2993 : 148 : spdk_json_write_array_end(w);
2994 : 148 : }
2995 : :
2996 : : void
2997 : 7969 : spdk_accel_module_finish(void)
2998 : : {
2999 [ + + ]: 7969 : if (!g_accel_module) {
3000 : 2666 : g_accel_module = TAILQ_FIRST(&spdk_accel_module_list);
3001 : : } else {
3002 : 5303 : g_accel_module = TAILQ_NEXT(g_accel_module, tailq);
3003 : : }
3004 : :
3005 [ + + ]: 7969 : if (!g_accel_module) {
3006 [ - + - - ]: 2666 : if (g_accel_driver != NULL && g_accel_driver->fini != NULL) {
3007 : 0 : g_accel_driver->fini();
3008 : : }
3009 : :
3010 : 2666 : spdk_spin_destroy(&g_keyring_spin);
3011 : 2666 : spdk_spin_destroy(&g_stats_lock);
3012 [ + - ]: 2666 : if (g_accel_domain) {
3013 : 2666 : spdk_memory_domain_destroy(g_accel_domain);
3014 : 2666 : g_accel_domain = NULL;
3015 : : }
3016 : 2666 : accel_module_finish_cb();
3017 : 2666 : return;
3018 : : }
3019 : :
3020 [ + + ]: 5303 : if (g_accel_module->module_fini) {
3021 : 5287 : spdk_thread_send_msg(spdk_get_thread(), g_accel_module->module_fini, NULL);
3022 : : } else {
3023 : 16 : spdk_accel_module_finish();
3024 : : }
3025 : : }
3026 : :
3027 : : static void
3028 : 2666 : accel_io_device_unregister_cb(void *io_device)
3029 : : {
3030 : : struct spdk_accel_crypto_key *key, *key_tmp;
3031 : : enum spdk_accel_opcode op;
3032 : :
3033 : 2666 : spdk_spin_lock(&g_keyring_spin);
3034 [ + + ]: 2775 : TAILQ_FOREACH_SAFE(key, &g_keyring, link, key_tmp) {
3035 : 109 : accel_crypto_key_destroy_unsafe(key);
3036 : : }
3037 : 2666 : spdk_spin_unlock(&g_keyring_spin);
3038 : :
3039 [ + + ]: 42656 : for (op = 0; op < SPDK_ACCEL_OPC_LAST; op++) {
3040 [ + + ]: 39990 : if (g_modules_opc_override[op] != NULL) {
3041 : 69 : free(g_modules_opc_override[op]);
3042 : 69 : g_modules_opc_override[op] = NULL;
3043 : : }
3044 : 39990 : g_modules_opc[op].module = NULL;
3045 : : }
3046 : :
3047 : 2666 : spdk_accel_module_finish();
3048 : 2666 : }
3049 : :
3050 : : void
3051 : 2666 : spdk_accel_finish(spdk_accel_fini_cb cb_fn, void *cb_arg)
3052 : : {
3053 [ - + ]: 2666 : assert(cb_fn != NULL);
3054 : :
3055 : 2666 : g_fini_cb_fn = cb_fn;
3056 : 2666 : g_fini_cb_arg = cb_arg;
3057 : :
3058 : 2666 : spdk_io_device_unregister(&spdk_accel_module_list, accel_io_device_unregister_cb);
3059 : 2666 : }
3060 : :
3061 : : static struct spdk_accel_driver *
3062 : 8 : accel_find_driver(const char *name)
3063 : : {
3064 : : struct spdk_accel_driver *driver;
3065 : :
3066 [ + + ]: 8 : TAILQ_FOREACH(driver, &g_accel_drivers, tailq) {
3067 [ + + - + : 4 : if (strcmp(driver->name, name) == 0) {
+ - ]
3068 : 4 : return driver;
3069 : : }
3070 : : }
3071 : :
3072 : 4 : return NULL;
3073 : : }
3074 : :
3075 : : int
3076 : 4 : spdk_accel_set_driver(const char *name)
3077 : : {
3078 : : struct spdk_accel_driver *driver;
3079 : :
3080 : 4 : driver = accel_find_driver(name);
3081 [ - + ]: 4 : if (driver == NULL) {
3082 : 0 : SPDK_ERRLOG("Couldn't find driver named '%s'\n", name);
3083 : 0 : return -ENODEV;
3084 : : }
3085 : :
3086 : 4 : g_accel_driver = driver;
3087 : :
3088 : 4 : return 0;
3089 : : }
3090 : :
3091 : : const char *
3092 : 0 : spdk_accel_get_driver_name(void)
3093 : : {
3094 [ # # ]: 0 : if (!g_accel_driver) {
3095 : 0 : return NULL;
3096 : : }
3097 : :
3098 : 0 : return g_accel_driver->name;
3099 : : }
3100 : :
3101 : : void
3102 : 4 : spdk_accel_driver_register(struct spdk_accel_driver *driver)
3103 : : {
3104 [ - + ]: 4 : if (accel_find_driver(driver->name)) {
3105 : 0 : SPDK_ERRLOG("Driver named '%s' has already been registered\n", driver->name);
3106 : 0 : assert(0);
3107 : : return;
3108 : : }
3109 : :
3110 : 4 : TAILQ_INSERT_TAIL(&g_accel_drivers, driver, tailq);
3111 : : }
3112 : :
3113 : : int
3114 : 220 : spdk_accel_set_opts(const struct spdk_accel_opts *opts)
3115 : : {
3116 [ - + ]: 220 : if (!opts) {
3117 : 0 : SPDK_ERRLOG("opts cannot be NULL\n");
3118 : 0 : return -1;
3119 : : }
3120 : :
3121 [ - + ]: 220 : if (!opts->opts_size) {
3122 : 0 : SPDK_ERRLOG("opts_size inside opts cannot be zero value\n");
3123 : 0 : return -1;
3124 : : }
3125 : :
3126 : : #define SET_FIELD(field) \
3127 : : if (offsetof(struct spdk_accel_opts, field) + sizeof(opts->field) <= opts->opts_size) { \
3128 : : g_opts.field = opts->field; \
3129 : : } \
3130 : :
3131 [ + - ]: 220 : SET_FIELD(small_cache_size);
3132 [ + - ]: 220 : SET_FIELD(large_cache_size);
3133 [ + - ]: 220 : SET_FIELD(task_count);
3134 [ + - ]: 220 : SET_FIELD(sequence_count);
3135 [ + - ]: 220 : SET_FIELD(buf_count);
3136 : :
3137 : 220 : g_opts.opts_size = opts->opts_size;
3138 : :
3139 : : #undef SET_FIELD
3140 : :
3141 : 220 : return 0;
3142 : : }
3143 : :
3144 : : void
3145 : 220 : spdk_accel_get_opts(struct spdk_accel_opts *opts, size_t opts_size)
3146 : : {
3147 [ - + ]: 220 : if (!opts) {
3148 : 0 : SPDK_ERRLOG("opts should not be NULL\n");
3149 : 0 : return;
3150 : : }
3151 : :
3152 [ - + ]: 220 : if (!opts_size) {
3153 : 0 : SPDK_ERRLOG("opts_size should not be zero value\n");
3154 : 0 : return;
3155 : : }
3156 : :
3157 : 220 : opts->opts_size = opts_size;
3158 : :
3159 : : #define SET_FIELD(field) \
3160 : : if (offsetof(struct spdk_accel_opts, field) + sizeof(opts->field) <= opts_size) { \
3161 : : opts->field = g_opts.field; \
3162 : : } \
3163 : :
3164 [ + - ]: 220 : SET_FIELD(small_cache_size);
3165 [ + - ]: 220 : SET_FIELD(large_cache_size);
3166 [ + - ]: 220 : SET_FIELD(task_count);
3167 [ + - ]: 220 : SET_FIELD(sequence_count);
3168 [ + - ]: 220 : SET_FIELD(buf_count);
3169 : :
3170 : : #undef SET_FIELD
3171 : :
3172 : : /* Do not remove this statement, you should always update this statement when you adding a new field,
3173 : : * and do not forget to add the SET_FIELD statement for your added field. */
3174 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_accel_opts) == 28, "Incorrect size");
3175 : : }
3176 : :
3177 : : struct accel_get_stats_ctx {
3178 : : struct accel_stats stats;
3179 : : accel_get_stats_cb cb_fn;
3180 : : void *cb_arg;
3181 : : };
3182 : :
3183 : : static void
3184 : 52 : accel_get_channel_stats_done(struct spdk_io_channel_iter *iter, int status)
3185 : : {
3186 : 52 : struct accel_get_stats_ctx *ctx = spdk_io_channel_iter_get_ctx(iter);
3187 : :
3188 : 52 : ctx->cb_fn(&ctx->stats, ctx->cb_arg);
3189 : 52 : free(ctx);
3190 : 52 : }
3191 : :
3192 : : static void
3193 : 32 : accel_get_channel_stats(struct spdk_io_channel_iter *iter)
3194 : : {
3195 : 32 : struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(iter);
3196 : 32 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
3197 : 32 : struct accel_get_stats_ctx *ctx = spdk_io_channel_iter_get_ctx(iter);
3198 : :
3199 : 32 : accel_add_stats(&ctx->stats, &accel_ch->stats);
3200 : 32 : spdk_for_each_channel_continue(iter, 0);
3201 : 32 : }
3202 : :
3203 : : int
3204 : 52 : accel_get_stats(accel_get_stats_cb cb_fn, void *cb_arg)
3205 : : {
3206 : : struct accel_get_stats_ctx *ctx;
3207 : :
3208 : 52 : ctx = calloc(1, sizeof(*ctx));
3209 [ - + ]: 52 : if (ctx == NULL) {
3210 : 0 : return -ENOMEM;
3211 : : }
3212 : :
3213 : 52 : spdk_spin_lock(&g_stats_lock);
3214 : 52 : accel_add_stats(&ctx->stats, &g_stats);
3215 : 52 : spdk_spin_unlock(&g_stats_lock);
3216 : :
3217 : 52 : ctx->cb_fn = cb_fn;
3218 : 52 : ctx->cb_arg = cb_arg;
3219 : :
3220 : 52 : spdk_for_each_channel(&spdk_accel_module_list, accel_get_channel_stats, ctx,
3221 : : accel_get_channel_stats_done);
3222 : :
3223 : 52 : return 0;
3224 : : }
3225 : :
3226 : : void
3227 : 560 : spdk_accel_get_opcode_stats(struct spdk_io_channel *ch, enum spdk_accel_opcode opcode,
3228 : : struct spdk_accel_opcode_stats *stats, size_t size)
3229 : : {
3230 : 560 : struct accel_io_channel *accel_ch = spdk_io_channel_get_ctx(ch);
3231 : :
3232 : : #define FIELD_OK(field) \
3233 : : offsetof(struct spdk_accel_opcode_stats, field) + sizeof(stats->field) <= size
3234 : :
3235 : : #define SET_FIELD(field, value) \
3236 : : if (FIELD_OK(field)) { \
3237 : : stats->field = value; \
3238 : : }
3239 : :
3240 [ + - ]: 560 : SET_FIELD(executed, accel_ch->stats.operations[opcode].executed);
3241 [ + - ]: 560 : SET_FIELD(failed, accel_ch->stats.operations[opcode].failed);
3242 [ + - ]: 560 : SET_FIELD(num_bytes, accel_ch->stats.operations[opcode].num_bytes);
3243 : :
3244 : : #undef FIELD_OK
3245 : : #undef SET_FIELD
3246 : 560 : }
3247 : :
3248 : : uint8_t
3249 : 684 : spdk_accel_get_buf_align(enum spdk_accel_opcode opcode,
3250 : : const struct spdk_accel_operation_exec_ctx *ctx)
3251 : : {
3252 : 684 : struct spdk_accel_module_if *module = g_modules_opc[opcode].module;
3253 : 684 : struct spdk_accel_opcode_info modinfo = {}, drvinfo = {};
3254 : :
3255 [ - + - - ]: 684 : if (g_accel_driver != NULL && g_accel_driver->get_operation_info != NULL) {
3256 : 0 : g_accel_driver->get_operation_info(opcode, ctx, &drvinfo);
3257 : : }
3258 : :
3259 [ + - ]: 684 : if (module->get_operation_info != NULL) {
3260 : 684 : module->get_operation_info(opcode, ctx, &modinfo);
3261 : : }
3262 : :
3263 : : /* If a driver is set, it'll execute most of the operations, while the rest will usually
3264 : : * fall back to accel_sw, which doesn't have any alignment requiremenets. However, to be
3265 : : * extra safe, return the max(driver, module) if a driver delegates some operations to a
3266 : : * hardware module. */
3267 : 684 : return spdk_max(modinfo.required_alignment, drvinfo.required_alignment);
3268 : : }
3269 : :
3270 : : struct spdk_accel_module_if *
3271 : 2566 : spdk_accel_get_module(const char *name)
3272 : : {
3273 : : struct spdk_accel_module_if *module;
3274 : :
3275 [ + - ]: 5132 : TAILQ_FOREACH(module, &spdk_accel_module_list, tailq) {
3276 [ + + - + : 5132 : if (strcmp(module->name, name) == 0) {
+ + ]
3277 : 2566 : return module;
3278 : : }
3279 : : }
3280 : :
3281 : 0 : return NULL;
3282 : : }
3283 : :
3284 : : int
3285 : 0 : spdk_accel_get_opc_memory_domains(enum spdk_accel_opcode opcode,
3286 : : struct spdk_memory_domain **domains,
3287 : : int array_size)
3288 : : {
3289 [ # # ]: 0 : assert(opcode < SPDK_ACCEL_OPC_LAST);
3290 : :
3291 [ # # ]: 0 : if (g_modules_opc[opcode].module->get_memory_domains) {
3292 : 0 : return g_modules_opc[opcode].module->get_memory_domains(domains, array_size);
3293 : : }
3294 : :
3295 : 0 : return 0;
3296 : : }
3297 : :
3298 : 2857 : SPDK_LOG_REGISTER_COMPONENT(accel)
|