Bug Summary

File:home/bhubbard/working/src/ceph/src/spdk/dpdk/lib/librte_compressdev/rte_compressdev.c
Warning:line 45, column 21
Assigned value is garbage or undefined

Annotated Source Code

[?] Use j/k keys for keyboard navigation

1/* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017-2018 Intel Corporation
3 */
4
5#include <string.h>
6#include <stdarg.h>
7#include <stdio.h>
8#include <inttypes.h>
9
10#include <rte_string_fns.h>
11#include <rte_malloc.h>
12#include <rte_eal.h>
13#include <rte_memzone.h>
14
15#include "rte_compressdev.h"
16#include "rte_compressdev_internal.h"
17#include "rte_compressdev_pmd.h"
18
19#define RTE_COMPRESSDEV_DETACHED(0) (0)
20#define RTE_COMPRESSDEV_ATTACHED(1) (1)
21
22static struct rte_compressdev rte_comp_devices[RTE_COMPRESS_MAX_DEVS64];
23
24static struct rte_compressdev_global compressdev_globals = {
25 .devs = rte_comp_devices,
26 .data = { NULL((void*)0) },
27 .nb_devs = 0,
28 .max_devs = RTE_COMPRESS_MAX_DEVS64
29};
30
31const struct rte_compressdev_capabilities * __rte_experimental__attribute__((section(".text.experimental")))
32rte_compressdev_capability_get(uint8_t dev_id,
33 enum rte_comp_algorithm algo)
34{
35 const struct rte_compressdev_capabilities *capability;
36 struct rte_compressdev_info dev_info;
37 int i = 0;
38
39 if (dev_id >= compressdev_globals.nb_devs) {
1
Taking false branch
→
40 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%d" "\n"
, __func__, dev_id);
41 return NULL((void*)0);
42 }
43 rte_compressdev_info_get(dev_id, &dev_info);
2
←
Calling 'rte_compressdev_info_get'
→
4
←
Returning from 'rte_compressdev_info_get'
→
44
45 while ((capability = &dev_info.capabilities[i++])->algo !=
5
←
Assigned value is garbage or undefined
46 RTE_COMP_ALGO_UNSPECIFIED){
47 if (capability->algo == algo)
48 return capability;
49 }
50
51 return NULL((void*)0);
52}
53
54const char * __rte_experimental__attribute__((section(".text.experimental")))
55rte_compressdev_get_feature_name(uint64_t flag)
56{
57 switch (flag) {
58 case RTE_COMPDEV_FF_HW_ACCELERATED(1ULL << 0):
59 return "HW_ACCELERATED";
60 case RTE_COMPDEV_FF_CPU_SSE(1ULL << 1):
61 return "CPU_SSE";
62 case RTE_COMPDEV_FF_CPU_AVX(1ULL << 2):
63 return "CPU_AVX";
64 case RTE_COMPDEV_FF_CPU_AVX2(1ULL << 3):
65 return "CPU_AVX2";
66 case RTE_COMPDEV_FF_CPU_AVX512(1ULL << 4):
67 return "CPU_AVX512";
68 case RTE_COMPDEV_FF_CPU_NEON(1ULL << 5):
69 return "CPU_NEON";
70 case RTE_COMPDEV_FF_OP_DONE_IN_DEQUEUE(1ULL << 6):
71 return "OP_DONE_IN_DEQ";
72 default:
73 return NULL((void*)0);
74 }
75}
76
77static struct rte_compressdev *
78rte_compressdev_get_dev(uint8_t dev_id)
79{
80 return &compressdev_globals.devs[dev_id];
81}
82
83struct rte_compressdev * __rte_experimental__attribute__((section(".text.experimental")))
84rte_compressdev_pmd_get_named_dev(const char *name)
85{
86 struct rte_compressdev *dev;
87 unsigned int i;
88
89 if (name == NULL((void*)0))
90 return NULL((void*)0);
91
92 for (i = 0; i < compressdev_globals.max_devs; i++) {
93 dev = &compressdev_globals.devs[i];
94
95 if ((dev->attached == RTE_COMPRESSDEV_ATTACHED(1)) &&
96 (strcmp(dev->data->name, name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(dev->data->name) && __builtin_constant_p (name
) && (__s1_len = __builtin_strlen (dev->data->name
), __s2_len = __builtin_strlen (name), (!((size_t)(const void
*)((dev->data->name) + 1) - (size_t)(const void *)(dev
->data->name) == 1) || __s1_len >= 4) && (!(
(size_t)(const void *)((name) + 1) - (size_t)(const void *)(name
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (dev->data
->name, name) : (__builtin_constant_p (dev->data->name
) && ((size_t)(const void *)((dev->data->name) +
1) - (size_t)(const void *)(dev->data->name) == 1) &&
(__s1_len = __builtin_strlen (dev->data->name), __s1_len
< 4) ? (__builtin_constant_p (name) && ((size_t)(
const void *)((name) + 1) - (size_t)(const void *)(name) == 1
) ? __builtin_strcmp (dev->data->name, name) : (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (name); int __result = (((const unsigned char *) (const
char *) (dev->data->name))[0] - __s2[0]); if (__s1_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (dev->data->name))[1] - __s2[1]
); if (__s1_len > 1 && __result == 0) { __result =
(((const unsigned char *) (const char *) (dev->data->name
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (dev->
data->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(name) && ((size_t)(const void *)((name) + 1) - (size_t
)(const void *)(name) == 1) && (__s2_len = __builtin_strlen
(name), __s2_len < 4) ? (__builtin_constant_p (dev->data
->name) && ((size_t)(const void *)((dev->data->
name) + 1) - (size_t)(const void *)(dev->data->name) ==
1) ? __builtin_strcmp (dev->data->name, name) : (- (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (dev->data->name); int __result = (((const unsigned
char *) (const char *) (name))[0] - __s2[0]); if (__s2_len >
0 && __result == 0) { __result = (((const unsigned char
*) (const char *) (name))[1] - __s2[1]); if (__s2_len > 1
&& __result == 0) { __result = (((const unsigned char
*) (const char *) (name))[2] - __s2[2]); if (__s2_len > 2
&& __result == 0) __result = (((const unsigned char *
) (const char *) (name))[3] - __s2[3]); } } __result; })))) :
__builtin_strcmp (dev->data->name, name)))); }) == 0))
97 return dev;
98 }
99
100 return NULL((void*)0);
101}
102
103static unsigned int
104rte_compressdev_is_valid_dev(uint8_t dev_id)
105{
106 struct rte_compressdev *dev = NULL((void*)0);
107
108 if (dev_id >= compressdev_globals.nb_devs)
109 return 0;
110
111 dev = rte_compressdev_get_dev(dev_id);
112 if (dev->attached != RTE_COMPRESSDEV_ATTACHED(1))
113 return 0;
114 else
115 return 1;
116}
117
118
119int __rte_experimental__attribute__((section(".text.experimental")))
120rte_compressdev_get_dev_id(const char *name)
121{
122 unsigned int i;
123
124 if (name == NULL((void*)0))
125 return -1;
126
127 for (i = 0; i < compressdev_globals.nb_devs; i++)
128 if ((strcmp(compressdev_globals.devs[i].data->name, name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(compressdev_globals.devs[i].data->name) && __builtin_constant_p
(name) && (__s1_len = __builtin_strlen (compressdev_globals
.devs[i].data->name), __s2_len = __builtin_strlen (name), (
!((size_t)(const void *)((compressdev_globals.devs[i].data->
name) + 1) - (size_t)(const void *)(compressdev_globals.devs[
i].data->name) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((name) + 1) - (size_t)(const void *)(name) ==
1) || __s2_len >= 4)) ? __builtin_strcmp (compressdev_globals
.devs[i].data->name, name) : (__builtin_constant_p (compressdev_globals
.devs[i].data->name) && ((size_t)(const void *)((compressdev_globals
.devs[i].data->name) + 1) - (size_t)(const void *)(compressdev_globals
.devs[i].data->name) == 1) && (__s1_len = __builtin_strlen
(compressdev_globals.devs[i].data->name), __s1_len < 4
) ? (__builtin_constant_p (name) && ((size_t)(const void
*)((name) + 1) - (size_t)(const void *)(name) == 1) ? __builtin_strcmp
(compressdev_globals.devs[i].data->name, name) : (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (name); int __result = (((const unsigned char *) (const
char *) (compressdev_globals.devs[i].data->name))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (compressdev_globals
.devs[i].data->name))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (compressdev_globals.devs[i].data->name))[2] - __s2
[2]); if (__s1_len > 2 && __result == 0) __result =
(((const unsigned char *) (const char *) (compressdev_globals
.devs[i].data->name))[3] - __s2[3]); } } __result; }))) : (
__builtin_constant_p (name) && ((size_t)(const void *
)((name) + 1) - (size_t)(const void *)(name) == 1) &&
(__s2_len = __builtin_strlen (name), __s2_len < 4) ? (__builtin_constant_p
(compressdev_globals.devs[i].data->name) && ((size_t
)(const void *)((compressdev_globals.devs[i].data->name) +
1) - (size_t)(const void *)(compressdev_globals.devs[i].data
->name) == 1) ? __builtin_strcmp (compressdev_globals.devs
[i].data->name, name) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (compressdev_globals
.devs[i].data->name); int __result = (((const unsigned char
*) (const char *) (name))[0] - __s2[0]); if (__s2_len > 0
&& __result == 0) { __result = (((const unsigned char
*) (const char *) (name))[1] - __s2[1]); if (__s2_len > 1
&& __result == 0) { __result = (((const unsigned char
*) (const char *) (name))[2] - __s2[2]); if (__s2_len > 2
&& __result == 0) __result = (((const unsigned char *
) (const char *) (name))[3] - __s2[3]); } } __result; })))) :
__builtin_strcmp (compressdev_globals.devs[i].data->name,
name)))); })
129 == 0) &&
130 (compressdev_globals.devs[i].attached ==
131 RTE_COMPRESSDEV_ATTACHED(1)))
132 return i;
133
134 return -1;
135}
136
137uint8_t __rte_experimental__attribute__((section(".text.experimental")))
138rte_compressdev_count(void)
139{
140 return compressdev_globals.nb_devs;
141}
142
143uint8_t __rte_experimental__attribute__((section(".text.experimental")))
144rte_compressdev_devices_get(const char *driver_name, uint8_t *devices,
145 uint8_t nb_devices)
146{
147 uint8_t i, count = 0;
148 struct rte_compressdev *devs = compressdev_globals.devs;
149 uint8_t max_devs = compressdev_globals.max_devs;
150
151 for (i = 0; i < max_devs && count < nb_devices; i++) {
152
153 if (devs[i].attached == RTE_COMPRESSDEV_ATTACHED(1)) {
154 int cmp;
155
156 cmp = strncmp(devs[i].device->driver->name,(__extension__ (__builtin_constant_p (strlen(driver_name)) &&
((__builtin_constant_p (devs[i].device->driver->name) &&
strlen (devs[i].device->driver->name) < ((size_t) (
strlen(driver_name)))) || (__builtin_constant_p (driver_name)
&& strlen (driver_name) < ((size_t) (strlen(driver_name
))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(devs[i].device->driver->name) && __builtin_constant_p
(driver_name) && (__s1_len = __builtin_strlen (devs[
i].device->driver->name), __s2_len = __builtin_strlen (
driver_name), (!((size_t)(const void *)((devs[i].device->driver
->name) + 1) - (size_t)(const void *)(devs[i].device->driver
->name) == 1) || __s1_len >= 4) && (!((size_t)(
const void *)((driver_name) + 1) - (size_t)(const void *)(driver_name
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (devs[i].device
->driver->name, driver_name) : (__builtin_constant_p (devs
[i].device->driver->name) && ((size_t)(const void
*)((devs[i].device->driver->name) + 1) - (size_t)(const
void *)(devs[i].device->driver->name) == 1) &&
(__s1_len = __builtin_strlen (devs[i].device->driver->
name), __s1_len < 4) ? (__builtin_constant_p (driver_name)
&& ((size_t)(const void *)((driver_name) + 1) - (size_t
)(const void *)(driver_name) == 1) ? __builtin_strcmp (devs[i
].device->driver->name, driver_name) : (__extension__ (
{ const unsigned char *__s2 = (const unsigned char *) (const char
*) (driver_name); int __result = (((const unsigned char *) (
const char *) (devs[i].device->driver->name))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (devs[i].device->
driver->name))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (devs[i].device->driver->name))[2] - __s2[2]);
if (__s1_len > 2 && __result == 0) __result = (((
const unsigned char *) (const char *) (devs[i].device->driver
->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(driver_name) && ((size_t)(const void *)((driver_name
) + 1) - (size_t)(const void *)(driver_name) == 1) &&
(__s2_len = __builtin_strlen (driver_name), __s2_len < 4)
? (__builtin_constant_p (devs[i].device->driver->name)
&& ((size_t)(const void *)((devs[i].device->driver
->name) + 1) - (size_t)(const void *)(devs[i].device->driver
->name) == 1) ? __builtin_strcmp (devs[i].device->driver
->name, driver_name) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (devs[i]
.device->driver->name); int __result = (((const unsigned
char *) (const char *) (driver_name))[0] - __s2[0]); if (__s2_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (driver_name))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (driver_name))[2] - __s2[2]); if (__s2_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (driver_name))[3] - __s2[3]); } } __result
; })))) : __builtin_strcmp (devs[i].device->driver->name
, driver_name)))); }) : strncmp (devs[i].device->driver->
name, driver_name, strlen(driver_name))))
157 driver_name,(__extension__ (__builtin_constant_p (strlen(driver_name)) &&
((__builtin_constant_p (devs[i].device->driver->name) &&
strlen (devs[i].device->driver->name) < ((size_t) (
strlen(driver_name)))) || (__builtin_constant_p (driver_name)
&& strlen (driver_name) < ((size_t) (strlen(driver_name
))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(devs[i].device->driver->name) && __builtin_constant_p
(driver_name) && (__s1_len = __builtin_strlen (devs[
i].device->driver->name), __s2_len = __builtin_strlen (
driver_name), (!((size_t)(const void *)((devs[i].device->driver
->name) + 1) - (size_t)(const void *)(devs[i].device->driver
->name) == 1) || __s1_len >= 4) && (!((size_t)(
const void *)((driver_name) + 1) - (size_t)(const void *)(driver_name
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (devs[i].device
->driver->name, driver_name) : (__builtin_constant_p (devs
[i].device->driver->name) && ((size_t)(const void
*)((devs[i].device->driver->name) + 1) - (size_t)(const
void *)(devs[i].device->driver->name) == 1) &&
(__s1_len = __builtin_strlen (devs[i].device->driver->
name), __s1_len < 4) ? (__builtin_constant_p (driver_name)
&& ((size_t)(const void *)((driver_name) + 1) - (size_t
)(const void *)(driver_name) == 1) ? __builtin_strcmp (devs[i
].device->driver->name, driver_name) : (__extension__ (
{ const unsigned char *__s2 = (const unsigned char *) (const char
*) (driver_name); int __result = (((const unsigned char *) (
const char *) (devs[i].device->driver->name))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (devs[i].device->
driver->name))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (devs[i].device->driver->name))[2] - __s2[2]);
if (__s1_len > 2 && __result == 0) __result = (((
const unsigned char *) (const char *) (devs[i].device->driver
->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(driver_name) && ((size_t)(const void *)((driver_name
) + 1) - (size_t)(const void *)(driver_name) == 1) &&
(__s2_len = __builtin_strlen (driver_name), __s2_len < 4)
? (__builtin_constant_p (devs[i].device->driver->name)
&& ((size_t)(const void *)((devs[i].device->driver
->name) + 1) - (size_t)(const void *)(devs[i].device->driver
->name) == 1) ? __builtin_strcmp (devs[i].device->driver
->name, driver_name) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (devs[i]
.device->driver->name); int __result = (((const unsigned
char *) (const char *) (driver_name))[0] - __s2[0]); if (__s2_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (driver_name))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (driver_name))[2] - __s2[2]); if (__s2_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (driver_name))[3] - __s2[3]); } } __result
; })))) : __builtin_strcmp (devs[i].device->driver->name
, driver_name)))); }) : strncmp (devs[i].device->driver->
name, driver_name, strlen(driver_name))))
158 strlen(driver_name))(__extension__ (__builtin_constant_p (strlen(driver_name)) &&
((__builtin_constant_p (devs[i].device->driver->name) &&
strlen (devs[i].device->driver->name) < ((size_t) (
strlen(driver_name)))) || (__builtin_constant_p (driver_name)
&& strlen (driver_name) < ((size_t) (strlen(driver_name
))))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(devs[i].device->driver->name) && __builtin_constant_p
(driver_name) && (__s1_len = __builtin_strlen (devs[
i].device->driver->name), __s2_len = __builtin_strlen (
driver_name), (!((size_t)(const void *)((devs[i].device->driver
->name) + 1) - (size_t)(const void *)(devs[i].device->driver
->name) == 1) || __s1_len >= 4) && (!((size_t)(
const void *)((driver_name) + 1) - (size_t)(const void *)(driver_name
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (devs[i].device
->driver->name, driver_name) : (__builtin_constant_p (devs
[i].device->driver->name) && ((size_t)(const void
*)((devs[i].device->driver->name) + 1) - (size_t)(const
void *)(devs[i].device->driver->name) == 1) &&
(__s1_len = __builtin_strlen (devs[i].device->driver->
name), __s1_len < 4) ? (__builtin_constant_p (driver_name)
&& ((size_t)(const void *)((driver_name) + 1) - (size_t
)(const void *)(driver_name) == 1) ? __builtin_strcmp (devs[i
].device->driver->name, driver_name) : (__extension__ (
{ const unsigned char *__s2 = (const unsigned char *) (const char
*) (driver_name); int __result = (((const unsigned char *) (
const char *) (devs[i].device->driver->name))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (devs[i].device->
driver->name))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (devs[i].device->driver->name))[2] - __s2[2]);
if (__s1_len > 2 && __result == 0) __result = (((
const unsigned char *) (const char *) (devs[i].device->driver
->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(driver_name) && ((size_t)(const void *)((driver_name
) + 1) - (size_t)(const void *)(driver_name) == 1) &&
(__s2_len = __builtin_strlen (driver_name), __s2_len < 4)
? (__builtin_constant_p (devs[i].device->driver->name)
&& ((size_t)(const void *)((devs[i].device->driver
->name) + 1) - (size_t)(const void *)(devs[i].device->driver
->name) == 1) ? __builtin_strcmp (devs[i].device->driver
->name, driver_name) : (- (__extension__ ({ const unsigned
char *__s2 = (const unsigned char *) (const char *) (devs[i]
.device->driver->name); int __result = (((const unsigned
char *) (const char *) (driver_name))[0] - __s2[0]); if (__s2_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (driver_name))[1] - __s2[1]); if (__s2_len
> 1 && __result == 0) { __result = (((const unsigned
char *) (const char *) (driver_name))[2] - __s2[2]); if (__s2_len
> 2 && __result == 0) __result = (((const unsigned
char *) (const char *) (driver_name))[3] - __s2[3]); } } __result
; })))) : __builtin_strcmp (devs[i].device->driver->name
, driver_name)))); }) : strncmp (devs[i].device->driver->
name, driver_name, strlen(driver_name))));
159
160 if (cmp == 0)
161 devices[count++] = devs[i].data->dev_id;
162 }
163 }
164
165 return count;
166}
167
168int __rte_experimental__attribute__((section(".text.experimental")))
169rte_compressdev_socket_id(uint8_t dev_id)
170{
171 struct rte_compressdev *dev;
172
173 if (!rte_compressdev_is_valid_dev(dev_id))
174 return -1;
175
176 dev = rte_compressdev_get_dev(dev_id);
177
178 return dev->data->socket_id;
179}
180
181static inline int
182rte_compressdev_data_alloc(uint8_t dev_id, struct rte_compressdev_data **data,
183 int socket_id)
184{
185 char mz_name[RTE_COMPRESSDEV_NAME_MAX_LEN(64)];
186 const struct rte_memzone *mz;
187 int n;
188
189 /* generate memzone name */
190 n = snprintf(mz_name, sizeof(mz_name),
191 "rte_compressdev_data_%u", dev_id);
192 if (n >= (int)sizeof(mz_name))
193 return -EINVAL22;
194
195 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
196 mz = rte_memzone_reserve(mz_name,
197 sizeof(struct rte_compressdev_data),
198 socket_id, 0);
199 } else
200 mz = rte_memzone_lookup(mz_name);
201
202 if (mz == NULL((void*)0))
203 return -ENOMEM12;
204
205 *data = mz->addr;
206 if (rte_eal_process_type() == RTE_PROC_PRIMARY)
207 memset(*data, 0, sizeof(struct rte_compressdev_data));
208
209 return 0;
210}
211
212static uint8_t
213rte_compressdev_find_free_device_index(void)
214{
215 uint8_t dev_id;
216
217 for (dev_id = 0; dev_id < RTE_COMPRESS_MAX_DEVS64; dev_id++) {
218 if (rte_comp_devices[dev_id].attached ==
219 RTE_COMPRESSDEV_DETACHED(0))
220 return dev_id;
221 }
222 return RTE_COMPRESS_MAX_DEVS64;
223}
224
225struct rte_compressdev * __rte_experimental__attribute__((section(".text.experimental")))
226rte_compressdev_pmd_allocate(const char *name, int socket_id)
227{
228 struct rte_compressdev *compressdev;
229 uint8_t dev_id;
230
231 if (rte_compressdev_pmd_get_named_dev(name) != NULL((void*)0)) {
232 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""comp device with name %s already allocated!"
"\n", __func__, name)
233 "comp device with name %s already allocated!", name)rte_log(4U, compressdev_logtype, "%s(): ""comp device with name %s already allocated!"
"\n", __func__, name);
234 return NULL((void*)0);
235 }
236
237 dev_id = rte_compressdev_find_free_device_index();
238 if (dev_id == RTE_COMPRESS_MAX_DEVS64) {
239 COMPRESSDEV_LOG(ERR, "Reached maximum number of comp devices")rte_log(4U, compressdev_logtype, "%s(): ""Reached maximum number of comp devices"
"\n", __func__);
240 return NULL((void*)0);
241 }
242 compressdev = rte_compressdev_get_dev(dev_id);
243
244 if (compressdev->data == NULL((void*)0)) {
245 struct rte_compressdev_data *compressdev_data =
246 compressdev_globals.data[dev_id];
247
248 int retval = rte_compressdev_data_alloc(dev_id,
249 &compressdev_data, socket_id);
250
251 if (retval < 0 || compressdev_data == NULL((void*)0))
252 return NULL((void*)0);
253
254 compressdev->data = compressdev_data;
255
256 strlcpy(compressdev->data->name, name,rte_strlcpy(compressdev->data->name, name, (64))
257 RTE_COMPRESSDEV_NAME_MAX_LEN)rte_strlcpy(compressdev->data->name, name, (64));
258
259 compressdev->data->dev_id = dev_id;
260 compressdev->data->socket_id = socket_id;
261 compressdev->data->dev_started = 0;
262
263 compressdev->attached = RTE_COMPRESSDEV_ATTACHED(1);
264
265 compressdev_globals.nb_devs++;
266 }
267
268 return compressdev;
269}
270
271int __rte_experimental__attribute__((section(".text.experimental")))
272rte_compressdev_pmd_release_device(struct rte_compressdev *compressdev)
273{
274 int ret;
275
276 if (compressdev == NULL((void*)0))
277 return -EINVAL22;
278
279 /* Close device only if device operations have been set */
280 if (compressdev->dev_ops) {
281 ret = rte_compressdev_close(compressdev->data->dev_id);
282 if (ret < 0)
283 return ret;
284 }
285
286 compressdev->attached = RTE_COMPRESSDEV_DETACHED(0);
287 compressdev_globals.nb_devs--;
288 return 0;
289}
290
291uint16_t __rte_experimental__attribute__((section(".text.experimental")))
292rte_compressdev_queue_pair_count(uint8_t dev_id)
293{
294 struct rte_compressdev *dev;
295
296 dev = &rte_comp_devices[dev_id];
297 return dev->data->nb_queue_pairs;
298}
299
300static int
301rte_compressdev_queue_pairs_config(struct rte_compressdev *dev,
302 uint16_t nb_qpairs, int socket_id)
303{
304 struct rte_compressdev_info dev_info;
305 void **qp;
306 unsigned int i;
307
308 if ((dev == NULL((void*)0)) || (nb_qpairs < 1)) {
309 COMPRESSDEV_LOG(ERR, "invalid param: dev %p, nb_queues %u",rte_log(4U, compressdev_logtype, "%s(): ""invalid param: dev %p, nb_queues %u"
"\n", __func__, dev, nb_qpairs)
310 dev, nb_qpairs)rte_log(4U, compressdev_logtype, "%s(): ""invalid param: dev %p, nb_queues %u"
"\n", __func__, dev, nb_qpairs);
311 return -EINVAL22;
312 }
313
314 COMPRESSDEV_LOG(DEBUG, "Setup %d queues pairs on device %u",rte_log(8U, compressdev_logtype, "%s(): ""Setup %d queues pairs on device %u"
"\n", __func__, nb_qpairs, dev->data->dev_id)
315 nb_qpairs, dev->data->dev_id)rte_log(8U, compressdev_logtype, "%s(): ""Setup %d queues pairs on device %u"
"\n", __func__, nb_qpairs, dev->data->dev_id);
316
317 memset(&dev_info, 0, sizeof(struct rte_compressdev_info));
318
319 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP)do { if ((*dev->dev_ops->dev_infos_get) == ((void*)0)) return
-95; } while (0);
320 (*dev->dev_ops->dev_infos_get)(dev, &dev_info);
321
322 if ((dev_info.max_nb_queue_pairs != 0) &&
323 (nb_qpairs > dev_info.max_nb_queue_pairs)) {
324 COMPRESSDEV_LOG(ERR, "Invalid num queue_pairs (%u) for dev %u",rte_log(4U, compressdev_logtype, "%s(): ""Invalid num queue_pairs (%u) for dev %u"
"\n", __func__, nb_qpairs, dev->data->dev_id)
325 nb_qpairs, dev->data->dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid num queue_pairs (%u) for dev %u"
"\n", __func__, nb_qpairs, dev->data->dev_id);
326 return -EINVAL22;
327 }
328
329 if (dev->data->queue_pairs == NULL((void*)0)) { /* first time configuration */
330 dev->data->queue_pairs = rte_zmalloc_socket(
331 "compressdev->queue_pairs",
332 sizeof(dev->data->queue_pairs[0]) * nb_qpairs,
333 RTE_CACHE_LINE_SIZE64, socket_id);
334
335 if (dev->data->queue_pairs == NULL((void*)0)) {
336 dev->data->nb_queue_pairs = 0;
337 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""failed to get memory for qp meta data, nb_queues %u"
"\n", __func__, nb_qpairs)
338 "failed to get memory for qp meta data, nb_queues %u",rte_log(4U, compressdev_logtype, "%s(): ""failed to get memory for qp meta data, nb_queues %u"
"\n", __func__, nb_qpairs)
339 nb_qpairs)rte_log(4U, compressdev_logtype, "%s(): ""failed to get memory for qp meta data, nb_queues %u"
"\n", __func__, nb_qpairs);
340 return -(ENOMEM12);
341 }
342 } else { /* re-configure */
343 int ret;
344 uint16_t old_nb_queues = dev->data->nb_queue_pairs;
345
346 qp = dev->data->queue_pairs;
347
348 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,do { if ((*dev->dev_ops->queue_pair_release) == ((void*
)0)) return -95; } while (0)
349 -ENOTSUP)do { if ((*dev->dev_ops->queue_pair_release) == ((void*
)0)) return -95; } while (0);
350
351 for (i = nb_qpairs; i < old_nb_queues; i++) {
352 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
353 if (ret < 0)
354 return ret;
355 }
356
357 qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,
358 RTE_CACHE_LINE_SIZE64);
359 if (qp == NULL((void*)0)) {
360 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""failed to realloc qp meta data, nb_queues %u"
"\n", __func__, nb_qpairs)
361 "failed to realloc qp meta data, nb_queues %u",rte_log(4U, compressdev_logtype, "%s(): ""failed to realloc qp meta data, nb_queues %u"
"\n", __func__, nb_qpairs)
362 nb_qpairs)rte_log(4U, compressdev_logtype, "%s(): ""failed to realloc qp meta data, nb_queues %u"
"\n", __func__, nb_qpairs);
363 return -(ENOMEM12);
364 }
365
366 if (nb_qpairs > old_nb_queues) {
367 uint16_t new_qs = nb_qpairs - old_nb_queues;
368
369 memset(qp + old_nb_queues, 0,
370 sizeof(qp[0]) * new_qs);
371 }
372
373 dev->data->queue_pairs = qp;
374
375 }
376 dev->data->nb_queue_pairs = nb_qpairs;
377 return 0;
378}
379
380static int
381rte_compressdev_queue_pairs_release(struct rte_compressdev *dev)
382{
383 uint16_t num_qps, i;
384 int ret;
385
386 if (dev == NULL((void*)0)) {
387 COMPRESSDEV_LOG(ERR, "invalid param: dev %p", dev)rte_log(4U, compressdev_logtype, "%s(): ""invalid param: dev %p"
"\n", __func__, dev);
388 return -EINVAL22;
389 }
390
391 num_qps = dev->data->nb_queue_pairs;
392
393 if (num_qps == 0)
394 return 0;
395
396 COMPRESSDEV_LOG(DEBUG, "Free %d queues pairs on device %u",rte_log(8U, compressdev_logtype, "%s(): ""Free %d queues pairs on device %u"
"\n", __func__, dev->data->nb_queue_pairs, dev->data
->dev_id)
397 dev->data->nb_queue_pairs, dev->data->dev_id)rte_log(8U, compressdev_logtype, "%s(): ""Free %d queues pairs on device %u"
"\n", __func__, dev->data->nb_queue_pairs, dev->data
->dev_id);
398
399 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release,do { if ((*dev->dev_ops->queue_pair_release) == ((void*
)0)) return -95; } while (0)
400 -ENOTSUP)do { if ((*dev->dev_ops->queue_pair_release) == ((void*
)0)) return -95; } while (0);
401
402 for (i = 0; i < num_qps; i++) {
403 ret = (*dev->dev_ops->queue_pair_release)(dev, i);
404 if (ret < 0)
405 return ret;
406 }
407
408 if (dev->data->queue_pairs != NULL((void*)0))
409 rte_free(dev->data->queue_pairs);
410 dev->data->queue_pairs = NULL((void*)0);
411 dev->data->nb_queue_pairs = 0;
412
413 return 0;
414}
415
416int __rte_experimental__attribute__((section(".text.experimental")))
417rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config)
418{
419 struct rte_compressdev *dev;
420 int diag;
421
422 if (!rte_compressdev_is_valid_dev(dev_id)) {
423 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%" "u"
"\n", __func__, dev_id);
424 return -EINVAL22;
425 }
426
427 dev = &rte_comp_devices[dev_id];
428
429 if (dev->data->dev_started) {
430 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""device %d must be stopped to allow configuration"
"\n", __func__, dev_id)
431 "device %d must be stopped to allow configuration", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""device %d must be stopped to allow configuration"
"\n", __func__, dev_id);
432 return -EBUSY16;
433 }
434
435 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP)do { if ((*dev->dev_ops->dev_configure) == ((void*)0)) return
-95; } while (0);
436
437 /* Setup new number of queue pairs and reconfigure device. */
438 diag = rte_compressdev_queue_pairs_config(dev, config->nb_queue_pairs,
439 config->socket_id);
440 if (diag != 0) {
441 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""dev%d rte_comp_dev_queue_pairs_config = %d"
"\n", __func__, dev_id, diag)
442 "dev%d rte_comp_dev_queue_pairs_config = %d",rte_log(4U, compressdev_logtype, "%s(): ""dev%d rte_comp_dev_queue_pairs_config = %d"
"\n", __func__, dev_id, diag)
443 dev_id, diag)rte_log(4U, compressdev_logtype, "%s(): ""dev%d rte_comp_dev_queue_pairs_config = %d"
"\n", __func__, dev_id, diag);
444 return diag;
445 }
446
447 return (*dev->dev_ops->dev_configure)(dev, config);
448}
449
450int __rte_experimental__attribute__((section(".text.experimental")))
451rte_compressdev_start(uint8_t dev_id)
452{
453 struct rte_compressdev *dev;
454 int diag;
455
456 COMPRESSDEV_LOG(DEBUG, "Start dev_id=%" PRIu8, dev_id)rte_log(8U, compressdev_logtype, "%s(): ""Start dev_id=%" "u"
"\n", __func__, dev_id);
457
458 if (!rte_compressdev_is_valid_dev(dev_id)) {
459 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%" "u"
"\n", __func__, dev_id);
460 return -EINVAL22;
461 }
462
463 dev = &rte_comp_devices[dev_id];
464
465 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP)do { if ((*dev->dev_ops->dev_start) == ((void*)0)) return
-95; } while (0);
466
467 if (dev->data->dev_started != 0) {
468 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""Device with dev_id=%"
"u" " already started" "\n", __func__, dev_id)
469 "Device with dev_id=%" PRIu8 " already started", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Device with dev_id=%"
"u" " already started" "\n", __func__, dev_id);
470 return 0;
471 }
472
473 diag = (*dev->dev_ops->dev_start)(dev);
474 if (diag == 0)
475 dev->data->dev_started = 1;
476 else
477 return diag;
478
479 return 0;
480}
481
482void __rte_experimental__attribute__((section(".text.experimental")))
483rte_compressdev_stop(uint8_t dev_id)
484{
485 struct rte_compressdev *dev;
486
487 if (!rte_compressdev_is_valid_dev(dev_id)) {
488 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%" "u"
"\n", __func__, dev_id);
489 return;
490 }
491
492 dev = &rte_comp_devices[dev_id];
493
494 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop)do { if ((*dev->dev_ops->dev_stop) == ((void*)0)) return
; } while (0);
495
496 if (dev->data->dev_started == 0) {
497 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""Device with dev_id=%"
"u" " already stopped" "\n", __func__, dev_id)
498 "Device with dev_id=%" PRIu8 " already stopped", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Device with dev_id=%"
"u" " already stopped" "\n", __func__, dev_id);
499 return;
500 }
501
502 (*dev->dev_ops->dev_stop)(dev);
503 dev->data->dev_started = 0;
504}
505
506int __rte_experimental__attribute__((section(".text.experimental")))
507rte_compressdev_close(uint8_t dev_id)
508{
509 struct rte_compressdev *dev;
510 int retval;
511
512 if (!rte_compressdev_is_valid_dev(dev_id)) {
513 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%" "u"
"\n", __func__, dev_id);
514 return -1;
515 }
516
517 dev = &rte_comp_devices[dev_id];
518
519 /* Device must be stopped before it can be closed */
520 if (dev->data->dev_started == 1) {
521 COMPRESSDEV_LOG(ERR, "Device %u must be stopped before closing",rte_log(4U, compressdev_logtype, "%s(): ""Device %u must be stopped before closing"
"\n", __func__, dev_id)
522 dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Device %u must be stopped before closing"
"\n", __func__, dev_id);
523 return -EBUSY16;
524 }
525
526 /* Free queue pairs memory */
527 retval = rte_compressdev_queue_pairs_release(dev);
528
529 if (retval < 0)
530 return retval;
531
532 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP)do { if ((*dev->dev_ops->dev_close) == ((void*)0)) return
-95; } while (0);
533 retval = (*dev->dev_ops->dev_close)(dev);
534
535 if (retval < 0)
536 return retval;
537
538 return 0;
539}
540
541int __rte_experimental__attribute__((section(".text.experimental")))
542rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
543 uint32_t max_inflight_ops, int socket_id)
544{
545 struct rte_compressdev *dev;
546
547 if (!rte_compressdev_is_valid_dev(dev_id)) {
548 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%" "u"
"\n", __func__, dev_id);
549 return -EINVAL22;
550 }
551
552 dev = &rte_comp_devices[dev_id];
553 if (queue_pair_id >= dev->data->nb_queue_pairs) {
554 COMPRESSDEV_LOG(ERR, "Invalid queue_pair_id=%d", queue_pair_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid queue_pair_id=%d"
"\n", __func__, queue_pair_id);
555 return -EINVAL22;
556 }
557
558 if (dev->data->dev_started) {
559 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""device %d must be stopped to allow configuration"
"\n", __func__, dev_id)
560 "device %d must be stopped to allow configuration", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""device %d must be stopped to allow configuration"
"\n", __func__, dev_id);
561 return -EBUSY16;
562 }
563
564 if (max_inflight_ops == 0) {
565 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""Invalid maximum number of inflight operations"
"\n", __func__)
566 "Invalid maximum number of inflight operations")rte_log(4U, compressdev_logtype, "%s(): ""Invalid maximum number of inflight operations"
"\n", __func__);
567 return -EINVAL22;
568 }
569
570 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP)do { if ((*dev->dev_ops->queue_pair_setup) == ((void*)0
)) return -95; } while (0);
571
572 return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id,
573 max_inflight_ops, socket_id);
574}
575
576uint16_t __rte_experimental__attribute__((section(".text.experimental")))
577rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
578 struct rte_comp_op **ops, uint16_t nb_ops)
579{
580 struct rte_compressdev *dev = &rte_comp_devices[dev_id];
581
582 nb_ops = (*dev->dequeue_burst)
583 (dev->data->queue_pairs[qp_id], ops, nb_ops);
584
585 return nb_ops;
586}
587
588uint16_t __rte_experimental__attribute__((section(".text.experimental")))
589rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
590 struct rte_comp_op **ops, uint16_t nb_ops)
591{
592 struct rte_compressdev *dev = &rte_comp_devices[dev_id];
593
594 return (*dev->enqueue_burst)(
595 dev->data->queue_pairs[qp_id], ops, nb_ops);
596}
597
598int __rte_experimental__attribute__((section(".text.experimental")))
599rte_compressdev_stats_get(uint8_t dev_id, struct rte_compressdev_stats *stats)
600{
601 struct rte_compressdev *dev;
602
603 if (!rte_compressdev_is_valid_dev(dev_id)) {
604 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%d" "\n"
, __func__, dev_id);
605 return -ENODEV19;
606 }
607
608 if (stats == NULL((void*)0)) {
609 COMPRESSDEV_LOG(ERR, "Invalid stats ptr")rte_log(4U, compressdev_logtype, "%s(): ""Invalid stats ptr" "\n"
, __func__);
610 return -EINVAL22;
611 }
612
613 dev = &rte_comp_devices[dev_id];
614 memset(stats, 0, sizeof(*stats));
615
616 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP)do { if ((*dev->dev_ops->stats_get) == ((void*)0)) return
-95; } while (0);
617 (*dev->dev_ops->stats_get)(dev, stats);
618 return 0;
619}
620
621void __rte_experimental__attribute__((section(".text.experimental")))
622rte_compressdev_stats_reset(uint8_t dev_id)
623{
624 struct rte_compressdev *dev;
625
626 if (!rte_compressdev_is_valid_dev(dev_id)) {
627 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%" "u"
"\n", __func__, dev_id);
628 return;
629 }
630
631 dev = &rte_comp_devices[dev_id];
632
633 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset)do { if ((*dev->dev_ops->stats_reset) == ((void*)0)) return
; } while (0);
634 (*dev->dev_ops->stats_reset)(dev);
635}
636
637
638void __rte_experimental__attribute__((section(".text.experimental")))
639rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info)
640{
641 struct rte_compressdev *dev;
642
643 if (dev_id >= compressdev_globals.nb_devs) {
3
←
Taking true branch
→
644 COMPRESSDEV_LOG(ERR, "Invalid dev_id=%d", dev_id)rte_log(4U, compressdev_logtype, "%s(): ""Invalid dev_id=%d" "\n"
, __func__, dev_id);
645 return;
646 }
647
648 dev = &rte_comp_devices[dev_id];
649
650 memset(dev_info, 0, sizeof(struct rte_compressdev_info));
651
652 RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get)do { if ((*dev->dev_ops->dev_infos_get) == ((void*)0)) return
; } while (0);
653 (*dev->dev_ops->dev_infos_get)(dev, dev_info);
654
655 dev_info->driver_name = dev->device->driver->name;
656}
657
658int __rte_experimental__attribute__((section(".text.experimental")))
659rte_compressdev_private_xform_create(uint8_t dev_id,
660 const struct rte_comp_xform *xform,
661 void **priv_xform)
662{
663 struct rte_compressdev *dev;
664 int ret;
665
666 dev = rte_compressdev_get_dev(dev_id);
667
668 if (xform == NULL((void*)0) || priv_xform == NULL((void*)0) || dev == NULL((void*)0))
669 return -EINVAL22;
670
671 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_create, -ENOTSUP)do { if ((*dev->dev_ops->private_xform_create) == ((void
*)0)) return -95; } while (0);
672 ret = (*dev->dev_ops->private_xform_create)(dev, xform, priv_xform);
673 if (ret < 0) {
674 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to create private_xform: err=%d"
"\n", __func__, dev_id, ret)
675 "dev_id %d failed to create private_xform: err=%d",rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to create private_xform: err=%d"
"\n", __func__, dev_id, ret)
676 dev_id, ret)rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to create private_xform: err=%d"
"\n", __func__, dev_id, ret);
677 return ret;
678 };
679
680 return 0;
681}
682
683int __rte_experimental__attribute__((section(".text.experimental")))
684rte_compressdev_private_xform_free(uint8_t dev_id, void *priv_xform)
685{
686 struct rte_compressdev *dev;
687 int ret;
688
689 dev = rte_compressdev_get_dev(dev_id);
690
691 if (dev == NULL((void*)0) || priv_xform == NULL((void*)0))
692 return -EINVAL22;
693
694 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->private_xform_free, -ENOTSUP)do { if ((*dev->dev_ops->private_xform_free) == ((void*
)0)) return -95; } while (0);
695 ret = dev->dev_ops->private_xform_free(dev, priv_xform);
696 if (ret < 0) {
697 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to free private xform: err=%d"
"\n", __func__, dev_id, ret)
698 "dev_id %d failed to free private xform: err=%d",rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to free private xform: err=%d"
"\n", __func__, dev_id, ret)
699 dev_id, ret)rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to free private xform: err=%d"
"\n", __func__, dev_id, ret);
700 return ret;
701 };
702
703 return 0;
704}
705
706int __rte_experimental__attribute__((section(".text.experimental")))
707rte_compressdev_stream_create(uint8_t dev_id,
708 const struct rte_comp_xform *xform,
709 void **stream)
710{
711 struct rte_compressdev *dev;
712 int ret;
713
714 dev = rte_compressdev_get_dev(dev_id);
715
716 if (xform == NULL((void*)0) || dev == NULL((void*)0) || stream == NULL((void*)0))
717 return -EINVAL22;
718
719 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_create, -ENOTSUP)do { if ((*dev->dev_ops->stream_create) == ((void*)0)) return
-95; } while (0);
720 ret = (*dev->dev_ops->stream_create)(dev, xform, stream);
721 if (ret < 0) {
722 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to create stream: err=%d"
"\n", __func__, dev_id, ret)
723 "dev_id %d failed to create stream: err=%d",rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to create stream: err=%d"
"\n", __func__, dev_id, ret)
724 dev_id, ret)rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to create stream: err=%d"
"\n", __func__, dev_id, ret);
725 return ret;
726 };
727
728 return 0;
729}
730
731
732int __rte_experimental__attribute__((section(".text.experimental")))
733rte_compressdev_stream_free(uint8_t dev_id, void *stream)
734{
735 struct rte_compressdev *dev;
736 int ret;
737
738 dev = rte_compressdev_get_dev(dev_id);
739
740 if (dev == NULL((void*)0) || stream == NULL((void*)0))
741 return -EINVAL22;
742
743 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stream_free, -ENOTSUP)do { if ((*dev->dev_ops->stream_free) == ((void*)0)) return
-95; } while (0);
744 ret = dev->dev_ops->stream_free(dev, stream);
745 if (ret < 0) {
746 COMPRESSDEV_LOG(ERR,rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to free stream: err=%d"
"\n", __func__, dev_id, ret)
747 "dev_id %d failed to free stream: err=%d",rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to free stream: err=%d"
"\n", __func__, dev_id, ret)
748 dev_id, ret)rte_log(4U, compressdev_logtype, "%s(): ""dev_id %d failed to free stream: err=%d"
"\n", __func__, dev_id, ret);
749 return ret;
750 };
751
752 return 0;
753}
754
755const char * __rte_experimental__attribute__((section(".text.experimental")))
756rte_compressdev_name_get(uint8_t dev_id)
757{
758 struct rte_compressdev *dev = rte_compressdev_get_dev(dev_id);
759
760 if (dev == NULL((void*)0))
761 return NULL((void*)0);
762
763 return dev->data->name;
764}
765
766RTE_INIT(rte_compressdev_log)static void __attribute__((constructor(65535), used)) rte_compressdev_log
(void)
767{
768 compressdev_logtype = rte_log_register("lib.compressdev");
769 if (compressdev_logtype >= 0)
770 rte_log_set_level(compressdev_logtype, RTE_LOG_NOTICE6U);
771}