/home/bhubbard/working/src/ceph/src/spdk/dpdk/lib/librte_cryptodev/rte

Bug Summary

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

Annotated Source Code

[?] Use j/k keys for keyboard navigation

/* SPDX-License-Identifier: BSD-3-Clause

#include <sys/types.h>

#include <sys/queue.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <errno(*__errno_location ()).h>

#include <stdint.h>

#include <inttypes.h>

#include <netinet/in.h>

#include <rte_byteorder.h>

#include <rte_log.h>

#include <rte_debug.h>

#include <rte_dev.h>

#include <rte_interrupts.h>

#include <rte_memory.h>

#include <rte_memcpy.h>

#include <rte_memzone.h>

#include <rte_launch.h>

#include <rte_tailq.h>

#include <rte_eal.h>

#include <rte_per_lcore.h>

#include <rte_lcore.h>

#include <rte_atomic.h>

#include <rte_branch_prediction.h>

#include <rte_common.h>

#include <rte_mempool.h>

#include <rte_malloc.h>

#include <rte_mbuf.h>

#include <rte_errno(per_lcore__rte_errno).h>

#include <rte_spinlock.h>

#include <rte_string_fns.h>

#include "rte_crypto.h"

#include "rte_cryptodev.h"

#include "rte_cryptodev_pmd.h"

static uint8_t nb_drivers;

static struct rte_cryptodev rte_crypto_devices[RTE_CRYPTO_MAX_DEVS64];

struct rte_cryptodev *rte_cryptodevs = rte_crypto_devices;

static struct rte_cryptodev_global cryptodev_globals = {

.devs = rte_crypto_devices,

.data = { NULL((void*)0) },

.nb_devs = 0,

.max_devs = RTE_CRYPTO_MAX_DEVS64

};

/* spinlock for crypto device callbacks */

static rte_spinlock_t rte_cryptodev_cb_lock = RTE_SPINLOCK_INITIALIZER{ 0 };

/**

* The user application callback description.

* It contains callback address to be registered by user application,

* the pointer to the parameters for callback, and the event type.

struct rte_cryptodev_callback {

TAILQ_ENTRY(rte_cryptodev_callback)struct { struct rte_cryptodev_callback *tqe_next; struct rte_cryptodev_callback
* *tqe_prev; } next; /**< Callbacks list */

rte_cryptodev_cb_fn cb_fn; /**< Callback address */

void *cb_arg; /**< Parameter for callback */

enum rte_cryptodev_event_type event; /**< Interrupt event type */

uint32_t active; /**< Callback is executing */

};

/**

* The crypto cipher algorithm strings identifiers.

* It could be used in application command line.

const char *

rte_crypto_cipher_algorithm_strings[] = {

[RTE_CRYPTO_CIPHER_3DES_CBC] = "3des-cbc",

[RTE_CRYPTO_CIPHER_3DES_ECB] = "3des-ecb",

[RTE_CRYPTO_CIPHER_3DES_CTR] = "3des-ctr",

[RTE_CRYPTO_CIPHER_AES_CBC] = "aes-cbc",

[RTE_CRYPTO_CIPHER_AES_CTR] = "aes-ctr",

[RTE_CRYPTO_CIPHER_AES_DOCSISBPI] = "aes-docsisbpi",

[RTE_CRYPTO_CIPHER_AES_ECB] = "aes-ecb",

[RTE_CRYPTO_CIPHER_AES_F8] = "aes-f8",

[RTE_CRYPTO_CIPHER_AES_XTS] = "aes-xts",

[RTE_CRYPTO_CIPHER_ARC4] = "arc4",

[RTE_CRYPTO_CIPHER_DES_CBC] = "des-cbc",

[RTE_CRYPTO_CIPHER_DES_DOCSISBPI] = "des-docsisbpi",

[RTE_CRYPTO_CIPHER_NULL] = "null",

[RTE_CRYPTO_CIPHER_KASUMI_F8] = "kasumi-f8",

100

[RTE_CRYPTO_CIPHER_SNOW3G_UEA2] = "snow3g-uea2",

101

[RTE_CRYPTO_CIPHER_ZUC_EEA3] = "zuc-eea3"

102

};

103

104

/**

105

* The crypto cipher operation strings identifiers.

106

* It could be used in application command line.

107

108

const char *

109

rte_crypto_cipher_operation_strings[] = {

110

[RTE_CRYPTO_CIPHER_OP_ENCRYPT] = "encrypt",

111

[RTE_CRYPTO_CIPHER_OP_DECRYPT] = "decrypt"

112

};

113

114

/**

115

* The crypto auth algorithm strings identifiers.

116

* It could be used in application command line.

117

118

const char *

119

rte_crypto_auth_algorithm_strings[] = {

120

[RTE_CRYPTO_AUTH_AES_CBC_MAC] = "aes-cbc-mac",

121

[RTE_CRYPTO_AUTH_AES_CMAC] = "aes-cmac",

122

[RTE_CRYPTO_AUTH_AES_GMAC] = "aes-gmac",

123

[RTE_CRYPTO_AUTH_AES_XCBC_MAC] = "aes-xcbc-mac",

124

125

[RTE_CRYPTO_AUTH_MD5] = "md5",

126

[RTE_CRYPTO_AUTH_MD5_HMAC] = "md5-hmac",

127

128

[RTE_CRYPTO_AUTH_NULL] = "null",

129

130

[RTE_CRYPTO_AUTH_SHA1] = "sha1",

131

[RTE_CRYPTO_AUTH_SHA1_HMAC] = "sha1-hmac",

132

133

[RTE_CRYPTO_AUTH_SHA224] = "sha2-224",

134

[RTE_CRYPTO_AUTH_SHA224_HMAC] = "sha2-224-hmac",

135

[RTE_CRYPTO_AUTH_SHA256] = "sha2-256",

136

[RTE_CRYPTO_AUTH_SHA256_HMAC] = "sha2-256-hmac",

137

[RTE_CRYPTO_AUTH_SHA384] = "sha2-384",

138

[RTE_CRYPTO_AUTH_SHA384_HMAC] = "sha2-384-hmac",

139

[RTE_CRYPTO_AUTH_SHA512] = "sha2-512",

140

[RTE_CRYPTO_AUTH_SHA512_HMAC] = "sha2-512-hmac",

141

142

[RTE_CRYPTO_AUTH_KASUMI_F9] = "kasumi-f9",

143

[RTE_CRYPTO_AUTH_SNOW3G_UIA2] = "snow3g-uia2",

144

[RTE_CRYPTO_AUTH_ZUC_EIA3] = "zuc-eia3"

145

};

146

147

/**

148

* The crypto AEAD algorithm strings identifiers.

149

* It could be used in application command line.

150

151

const char *

152

rte_crypto_aead_algorithm_strings[] = {

153

[RTE_CRYPTO_AEAD_AES_CCM] = "aes-ccm",

154

[RTE_CRYPTO_AEAD_AES_GCM] = "aes-gcm",

155

};

156

157

/**

158

* The crypto AEAD operation strings identifiers.

159

* It could be used in application command line.

160

161

const char *

162

rte_crypto_aead_operation_strings[] = {

163

[RTE_CRYPTO_AEAD_OP_ENCRYPT] = "encrypt",

164

[RTE_CRYPTO_AEAD_OP_DECRYPT] = "decrypt"

165

};

166

167

/**

168

* Asymmetric crypto transform operation strings identifiers.

169

170

const char *rte_crypto_asym_xform_strings[] = {

171

[RTE_CRYPTO_ASYM_XFORM_NONE] = "none",

172

[RTE_CRYPTO_ASYM_XFORM_RSA] = "rsa",

173

[RTE_CRYPTO_ASYM_XFORM_MODEX] = "modexp",

174

[RTE_CRYPTO_ASYM_XFORM_MODINV] = "modinv",

175

[RTE_CRYPTO_ASYM_XFORM_DH] = "dh",

176

[RTE_CRYPTO_ASYM_XFORM_DSA] = "dsa",

177

};

178

179

/**

180

* Asymmetric crypto operation strings identifiers.

181

182

const char *rte_crypto_asym_op_strings[] = {

183

[RTE_CRYPTO_ASYM_OP_ENCRYPT] = "encrypt",

184

[RTE_CRYPTO_ASYM_OP_DECRYPT] = "decrypt",

185

[RTE_CRYPTO_ASYM_OP_SIGN] = "sign",

186

[RTE_CRYPTO_ASYM_OP_VERIFY] = "verify",

187

[RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE] = "priv_key_generate",

188

[RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE] = "pub_key_generate",

189

[RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE] = "sharedsecret_compute",

190

};

191

192

/**

193

* The private data structure stored in the session mempool private data.

194

195

struct rte_cryptodev_sym_session_pool_private_data {

196

uint16_t nb_drivers;

197

/**< number of elements in sess_data array */

198

uint16_t user_data_sz;

199

/**< session user data will be placed after sess_data */

200

};

201

202

int

203

rte_cryptodev_get_cipher_algo_enum(enum rte_crypto_cipher_algorithm *algo_enum,

204

const char *algo_string)

205

{

206

unsigned int i;

207

208

for (i = 1; i < RTE_DIM(rte_crypto_cipher_algorithm_strings)(sizeof (rte_crypto_cipher_algorithm_strings) / sizeof ((rte_crypto_cipher_algorithm_strings
)[0])); i++) {

209

if (strcmp(algo_string, rte_crypto_cipher_algorithm_strings[i])__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(algo_string) && __builtin_constant_p (rte_crypto_cipher_algorithm_strings
[i]) && (__s1_len = __builtin_strlen (algo_string), __s2_len
= __builtin_strlen (rte_crypto_cipher_algorithm_strings[i]),
(!((size_t)(const void *)((algo_string) + 1) - (size_t)(const
void *)(algo_string) == 1) || __s1_len >= 4) && (
!((size_t)(const void *)((rte_crypto_cipher_algorithm_strings
[i]) + 1) - (size_t)(const void *)(rte_crypto_cipher_algorithm_strings
[i]) == 1) || __s2_len >= 4)) ? __builtin_strcmp (algo_string
, rte_crypto_cipher_algorithm_strings[i]) : (__builtin_constant_p
(algo_string) && ((size_t)(const void *)((algo_string
) + 1) - (size_t)(const void *)(algo_string) == 1) &&
(__s1_len = __builtin_strlen (algo_string), __s1_len < 4)
? (__builtin_constant_p (rte_crypto_cipher_algorithm_strings
[i]) && ((size_t)(const void *)((rte_crypto_cipher_algorithm_strings
[i]) + 1) - (size_t)(const void *)(rte_crypto_cipher_algorithm_strings
[i]) == 1) ? __builtin_strcmp (algo_string, rte_crypto_cipher_algorithm_strings
[i]) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (rte_crypto_cipher_algorithm_strings[
i]); int __result = (((const unsigned char *) (const char *) (
algo_string))[0] - __s2[0]); if (__s1_len > 0 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
algo_string))[1] - __s2[1]); if (__s1_len > 1 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
algo_string))[2] - __s2[2]); if (__s1_len > 2 && __result
== 0) __result = (((const unsigned char *) (const char *) (algo_string
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
rte_crypto_cipher_algorithm_strings[i]) && ((size_t)(
const void *)((rte_crypto_cipher_algorithm_strings[i]) + 1) -
(size_t)(const void *)(rte_crypto_cipher_algorithm_strings[i
]) == 1) && (__s2_len = __builtin_strlen (rte_crypto_cipher_algorithm_strings
[i]), __s2_len < 4) ? (__builtin_constant_p (algo_string) &&
((size_t)(const void *)((algo_string) + 1) - (size_t)(const void
*)(algo_string) == 1) ? __builtin_strcmp (algo_string, rte_crypto_cipher_algorithm_strings
[i]) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (algo_string); int __result =
(((const unsigned char *) (const char *) (rte_crypto_cipher_algorithm_strings
[i]))[0] - __s2[0]); if (__s2_len > 0 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_cipher_algorithm_strings
[i]))[1] - __s2[1]); if (__s2_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_cipher_algorithm_strings
[i]))[2] - __s2[2]); if (__s2_len > 2 && __result ==
0) __result = (((const unsigned char *) (const char *) (rte_crypto_cipher_algorithm_strings
[i]))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (
algo_string, rte_crypto_cipher_algorithm_strings[i])))); }) == 0) {

210

*algo_enum = (enum rte_crypto_cipher_algorithm) i;

211

return 0;

212

}

213

}

214

215

/* Invalid string */

216

return -1;

217

}

218

219

int

220

rte_cryptodev_get_auth_algo_enum(enum rte_crypto_auth_algorithm *algo_enum,

221

const char *algo_string)

222

{

223

unsigned int i;

224

225

for (i = 1; i < RTE_DIM(rte_crypto_auth_algorithm_strings)(sizeof (rte_crypto_auth_algorithm_strings) / sizeof ((rte_crypto_auth_algorithm_strings
)[0])); i++) {

226

if (strcmp(algo_string, rte_crypto_auth_algorithm_strings[i])__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(algo_string) && __builtin_constant_p (rte_crypto_auth_algorithm_strings
[i]) && (__s1_len = __builtin_strlen (algo_string), __s2_len
= __builtin_strlen (rte_crypto_auth_algorithm_strings[i]), (
!((size_t)(const void *)((algo_string) + 1) - (size_t)(const void
*)(algo_string) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((rte_crypto_auth_algorithm_strings[i]) + 1) -
(size_t)(const void *)(rte_crypto_auth_algorithm_strings[i])
== 1) || __s2_len >= 4)) ? __builtin_strcmp (algo_string,
rte_crypto_auth_algorithm_strings[i]) : (__builtin_constant_p
(algo_string) && ((size_t)(const void *)((algo_string
) + 1) - (size_t)(const void *)(algo_string) == 1) &&
(__s1_len = __builtin_strlen (algo_string), __s1_len < 4)
? (__builtin_constant_p (rte_crypto_auth_algorithm_strings[i
]) && ((size_t)(const void *)((rte_crypto_auth_algorithm_strings
[i]) + 1) - (size_t)(const void *)(rte_crypto_auth_algorithm_strings
[i]) == 1) ? __builtin_strcmp (algo_string, rte_crypto_auth_algorithm_strings
[i]) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (rte_crypto_auth_algorithm_strings[i]
); int __result = (((const unsigned char *) (const char *) (algo_string
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (algo_string
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (algo_string
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (algo_string
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
rte_crypto_auth_algorithm_strings[i]) && ((size_t)(const
void *)((rte_crypto_auth_algorithm_strings[i]) + 1) - (size_t
)(const void *)(rte_crypto_auth_algorithm_strings[i]) == 1) &&
(__s2_len = __builtin_strlen (rte_crypto_auth_algorithm_strings
[i]), __s2_len < 4) ? (__builtin_constant_p (algo_string) &&
((size_t)(const void *)((algo_string) + 1) - (size_t)(const void
*)(algo_string) == 1) ? __builtin_strcmp (algo_string, rte_crypto_auth_algorithm_strings
[i]) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (algo_string); int __result =
(((const unsigned char *) (const char *) (rte_crypto_auth_algorithm_strings
[i]))[0] - __s2[0]); if (__s2_len > 0 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_auth_algorithm_strings
[i]))[1] - __s2[1]); if (__s2_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_auth_algorithm_strings
[i]))[2] - __s2[2]); if (__s2_len > 2 && __result ==
0) __result = (((const unsigned char *) (const char *) (rte_crypto_auth_algorithm_strings
[i]))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (
algo_string, rte_crypto_auth_algorithm_strings[i])))); }) == 0) {

227

*algo_enum = (enum rte_crypto_auth_algorithm) i;

228

return 0;

229

}

230

}

231

232

/* Invalid string */

233

return -1;

234

}

235

236

int

237

rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum,

238

const char *algo_string)

239

{

240

unsigned int i;

241

242

for (i = 1; i < RTE_DIM(rte_crypto_aead_algorithm_strings)(sizeof (rte_crypto_aead_algorithm_strings) / sizeof ((rte_crypto_aead_algorithm_strings
)[0])); i++) {

243

if (strcmp(algo_string, rte_crypto_aead_algorithm_strings[i])__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(algo_string) && __builtin_constant_p (rte_crypto_aead_algorithm_strings
[i]) && (__s1_len = __builtin_strlen (algo_string), __s2_len
= __builtin_strlen (rte_crypto_aead_algorithm_strings[i]), (
!((size_t)(const void *)((algo_string) + 1) - (size_t)(const void
*)(algo_string) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((rte_crypto_aead_algorithm_strings[i]) + 1) -
(size_t)(const void *)(rte_crypto_aead_algorithm_strings[i])
== 1) || __s2_len >= 4)) ? __builtin_strcmp (algo_string,
rte_crypto_aead_algorithm_strings[i]) : (__builtin_constant_p
(algo_string) && ((size_t)(const void *)((algo_string
) + 1) - (size_t)(const void *)(algo_string) == 1) &&
(__s1_len = __builtin_strlen (algo_string), __s1_len < 4)
? (__builtin_constant_p (rte_crypto_aead_algorithm_strings[i
]) && ((size_t)(const void *)((rte_crypto_aead_algorithm_strings
[i]) + 1) - (size_t)(const void *)(rte_crypto_aead_algorithm_strings
[i]) == 1) ? __builtin_strcmp (algo_string, rte_crypto_aead_algorithm_strings
[i]) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (rte_crypto_aead_algorithm_strings[i]
); int __result = (((const unsigned char *) (const char *) (algo_string
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (algo_string
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (algo_string
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (algo_string
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
rte_crypto_aead_algorithm_strings[i]) && ((size_t)(const
void *)((rte_crypto_aead_algorithm_strings[i]) + 1) - (size_t
)(const void *)(rte_crypto_aead_algorithm_strings[i]) == 1) &&
(__s2_len = __builtin_strlen (rte_crypto_aead_algorithm_strings
[i]), __s2_len < 4) ? (__builtin_constant_p (algo_string) &&
((size_t)(const void *)((algo_string) + 1) - (size_t)(const void
*)(algo_string) == 1) ? __builtin_strcmp (algo_string, rte_crypto_aead_algorithm_strings
[i]) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (algo_string); int __result =
(((const unsigned char *) (const char *) (rte_crypto_aead_algorithm_strings
[i]))[0] - __s2[0]); if (__s2_len > 0 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_aead_algorithm_strings
[i]))[1] - __s2[1]); if (__s2_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_aead_algorithm_strings
[i]))[2] - __s2[2]); if (__s2_len > 2 && __result ==
0) __result = (((const unsigned char *) (const char *) (rte_crypto_aead_algorithm_strings
[i]))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (
algo_string, rte_crypto_aead_algorithm_strings[i])))); }) == 0) {

244

*algo_enum = (enum rte_crypto_aead_algorithm) i;

245

return 0;

246

}

247

}

248

249

/* Invalid string */

250

return -1;

251

}

252

253

int __rte_experimental__attribute__((section(".text.experimental")))

254

rte_cryptodev_asym_get_xform_enum(enum rte_crypto_asym_xform_type *xform_enum,

255

const char *xform_string)

256

{

257

unsigned int i;

258

259

for (i = 1; i < RTE_DIM(rte_crypto_asym_xform_strings)(sizeof (rte_crypto_asym_xform_strings) / sizeof ((rte_crypto_asym_xform_strings
)[0])); i++) {

260

if (strcmp(xform_string,__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(xform_string) && __builtin_constant_p (rte_crypto_asym_xform_strings
[i]) && (__s1_len = __builtin_strlen (xform_string), __s2_len
= __builtin_strlen (rte_crypto_asym_xform_strings[i]), (!((size_t
)(const void *)((xform_string) + 1) - (size_t)(const void *)(
xform_string) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((rte_crypto_asym_xform_strings[i]) + 1) - (size_t
)(const void *)(rte_crypto_asym_xform_strings[i]) == 1) || __s2_len
>= 4)) ? __builtin_strcmp (xform_string, rte_crypto_asym_xform_strings
[i]) : (__builtin_constant_p (xform_string) && ((size_t
)(const void *)((xform_string) + 1) - (size_t)(const void *)(
xform_string) == 1) && (__s1_len = __builtin_strlen (
xform_string), __s1_len < 4) ? (__builtin_constant_p (rte_crypto_asym_xform_strings
[i]) && ((size_t)(const void *)((rte_crypto_asym_xform_strings
[i]) + 1) - (size_t)(const void *)(rte_crypto_asym_xform_strings
[i]) == 1) ? __builtin_strcmp (xform_string, rte_crypto_asym_xform_strings
[i]) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (rte_crypto_asym_xform_strings[i]); int
__result = (((const unsigned char *) (const char *) (xform_string
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (xform_string
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (xform_string
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (xform_string
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
rte_crypto_asym_xform_strings[i]) && ((size_t)(const void
*)((rte_crypto_asym_xform_strings[i]) + 1) - (size_t)(const void
*)(rte_crypto_asym_xform_strings[i]) == 1) && (__s2_len
= __builtin_strlen (rte_crypto_asym_xform_strings[i]), __s2_len
< 4) ? (__builtin_constant_p (xform_string) && ((
size_t)(const void *)((xform_string) + 1) - (size_t)(const void
*)(xform_string) == 1) ? __builtin_strcmp (xform_string, rte_crypto_asym_xform_strings
[i]) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (xform_string); int __result
= (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[0] - __s2[0]); if (__s2_len > 0 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[1] - __s2[1]); if (__s2_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[2] - __s2[2]); if (__s2_len > 2 && __result ==
0) __result = (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (
xform_string, rte_crypto_asym_xform_strings[i])))); })

261

rte_crypto_asym_xform_strings[i])__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(xform_string) && __builtin_constant_p (rte_crypto_asym_xform_strings
[i]) && (__s1_len = __builtin_strlen (xform_string), __s2_len
= __builtin_strlen (rte_crypto_asym_xform_strings[i]), (!((size_t
)(const void *)((xform_string) + 1) - (size_t)(const void *)(
xform_string) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((rte_crypto_asym_xform_strings[i]) + 1) - (size_t
)(const void *)(rte_crypto_asym_xform_strings[i]) == 1) || __s2_len
>= 4)) ? __builtin_strcmp (xform_string, rte_crypto_asym_xform_strings
[i]) : (__builtin_constant_p (xform_string) && ((size_t
)(const void *)((xform_string) + 1) - (size_t)(const void *)(
xform_string) == 1) && (__s1_len = __builtin_strlen (
xform_string), __s1_len < 4) ? (__builtin_constant_p (rte_crypto_asym_xform_strings
[i]) && ((size_t)(const void *)((rte_crypto_asym_xform_strings
[i]) + 1) - (size_t)(const void *)(rte_crypto_asym_xform_strings
[i]) == 1) ? __builtin_strcmp (xform_string, rte_crypto_asym_xform_strings
[i]) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (rte_crypto_asym_xform_strings[i]); int
__result = (((const unsigned char *) (const char *) (xform_string
))[0] - __s2[0]); if (__s1_len > 0 && __result == 0
) { __result = (((const unsigned char *) (const char *) (xform_string
))[1] - __s2[1]); if (__s1_len > 1 && __result == 0
) { __result = (((const unsigned char *) (const char *) (xform_string
))[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (xform_string
))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (
rte_crypto_asym_xform_strings[i]) && ((size_t)(const void
*)((rte_crypto_asym_xform_strings[i]) + 1) - (size_t)(const void
*)(rte_crypto_asym_xform_strings[i]) == 1) && (__s2_len
= __builtin_strlen (rte_crypto_asym_xform_strings[i]), __s2_len
< 4) ? (__builtin_constant_p (xform_string) && ((
size_t)(const void *)((xform_string) + 1) - (size_t)(const void
*)(xform_string) == 1) ? __builtin_strcmp (xform_string, rte_crypto_asym_xform_strings
[i]) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (xform_string); int __result
= (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[0] - __s2[0]); if (__s2_len > 0 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[1] - __s2[1]); if (__s2_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[2] - __s2[2]); if (__s2_len > 2 && __result ==
0) __result = (((const unsigned char *) (const char *) (rte_crypto_asym_xform_strings
[i]))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (
xform_string, rte_crypto_asym_xform_strings[i])))); }) == 0) {

262

*xform_enum = (enum rte_crypto_asym_xform_type) i;

263

return 0;

264

}

265

}

266

267

/* Invalid string */

268

return -1;

269

}

270

271

/**

272

* The crypto auth operation strings identifiers.

273

* It could be used in application command line.

274

275

const char *

276

rte_crypto_auth_operation_strings[] = {

277

[RTE_CRYPTO_AUTH_OP_VERIFY] = "verify",

278

[RTE_CRYPTO_AUTH_OP_GENERATE] = "generate"

279

};

280

281

const struct rte_cryptodev_symmetric_capability *

282

rte_cryptodev_sym_capability_get(uint8_t dev_id,

283

const struct rte_cryptodev_sym_capability_idx *idx)

284

{

285

const struct rte_cryptodev_capabilities *capability;

286

struct rte_cryptodev_info dev_info;

287

int i = 0;

288

289

rte_cryptodev_info_get(dev_id, &dev_info);

Calling 'rte_cryptodev_info_get'

→

←

Returning from 'rte_cryptodev_info_get'

→

290

291

while ((capability = &dev_info.capabilities[i++])->op !=

←

Assigned value is garbage or undefined

292

RTE_CRYPTO_OP_TYPE_UNDEFINED) {

293

if (capability->op != RTE_CRYPTO_OP_TYPE_SYMMETRIC)

294

continue;

295

296

if (capability->sym.xform_type != idx->type)

297

continue;

298

299

if (idx->type == RTE_CRYPTO_SYM_XFORM_AUTH &&

300

capability->sym.auth.algo == idx->algo.auth)

301

return &capability->sym;

302

303

if (idx->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&

304

capability->sym.cipher.algo == idx->algo.cipher)

305

return &capability->sym;

306

307

if (idx->type == RTE_CRYPTO_SYM_XFORM_AEAD &&

308

capability->sym.aead.algo == idx->algo.aead)

309

return &capability->sym;

310

}

311

312

return NULL((void*)0);

313

314

}

315

316

static int

317

param_range_check(uint16_t size, const struct rte_crypto_param_range *range)

318

{

319

unsigned int next_size;

320

321

/* Check lower/upper bounds */

322

if (size < range->min)

323

return -1;

324

325

if (size > range->max)

326

return -1;

327

328

/* If range is actually only one value, size is correct */

329

if (range->increment == 0)

330

return 0;

331

332

/* Check if value is one of the supported sizes */

333

for (next_size = range->min; next_size <= range->max;

334

next_size += range->increment)

335

if (size == next_size)

336

return 0;

337

338

return -1;

339

}

340

341

const struct rte_cryptodev_asymmetric_xform_capability * __rte_experimental__attribute__((section(".text.experimental")))

342

rte_cryptodev_asym_capability_get(uint8_t dev_id,

343

const struct rte_cryptodev_asym_capability_idx *idx)

344

{

345

const struct rte_cryptodev_capabilities *capability;

346

struct rte_cryptodev_info dev_info;

347

unsigned int i = 0;

348

349

memset(&dev_info, 0, sizeof(struct rte_cryptodev_info));

350

rte_cryptodev_info_get(dev_id, &dev_info);

351

352

while ((capability = &dev_info.capabilities[i++])->op !=

353

RTE_CRYPTO_OP_TYPE_UNDEFINED) {

354

if (capability->op != RTE_CRYPTO_OP_TYPE_ASYMMETRIC)

355

continue;

356

357

if (capability->asym.xform_capa.xform_type == idx->type)

358

return &capability->asym.xform_capa;

359

}

360

return NULL((void*)0);

361

};

362

363

int

364

rte_cryptodev_sym_capability_check_cipher(

365

const struct rte_cryptodev_symmetric_capability *capability,

366

uint16_t key_size, uint16_t iv_size)

367

{

368

if (param_range_check(key_size, &capability->cipher.key_size) != 0)

369

return -1;

370

371

if (param_range_check(iv_size, &capability->cipher.iv_size) != 0)

372

return -1;

373

374

return 0;

375

}

376

377

int

378

rte_cryptodev_sym_capability_check_auth(

379

const struct rte_cryptodev_symmetric_capability *capability,

380

uint16_t key_size, uint16_t digest_size, uint16_t iv_size)

381

{

382

if (param_range_check(key_size, &capability->auth.key_size) != 0)

383

return -1;

384

385

if (param_range_check(digest_size, &capability->auth.digest_size) != 0)

386

return -1;

387

388

if (param_range_check(iv_size, &capability->auth.iv_size) != 0)

389

return -1;

390

391

return 0;

392

}

393

394

int

395

rte_cryptodev_sym_capability_check_aead(

396

const struct rte_cryptodev_symmetric_capability *capability,

397

uint16_t key_size, uint16_t digest_size, uint16_t aad_size,

398

uint16_t iv_size)

399

{

400

if (param_range_check(key_size, &capability->aead.key_size) != 0)

401

return -1;

402

403

if (param_range_check(digest_size, &capability->aead.digest_size) != 0)

404

return -1;

405

406

if (param_range_check(aad_size, &capability->aead.aad_size) != 0)

407

return -1;

408

409

if (param_range_check(iv_size, &capability->aead.iv_size) != 0)

410

return -1;

411

412

return 0;

413

}

414

int __rte_experimental__attribute__((section(".text.experimental")))

415

rte_cryptodev_asym_xform_capability_check_optype(

416

const struct rte_cryptodev_asymmetric_xform_capability *capability,

417

enum rte_crypto_asym_op_type op_type)

418

{

419

if (capability->op_types & (1 << op_type))

420

return 1;

421

422

return 0;

423

}

424

425

int __rte_experimental__attribute__((section(".text.experimental")))

426

rte_cryptodev_asym_xform_capability_check_modlen(

427

const struct rte_cryptodev_asymmetric_xform_capability *capability,

428

uint16_t modlen)

429

{

430

/* no need to check for limits, if min or max = 0 */

431

if (capability->modlen.min != 0) {

432

if (modlen < capability->modlen.min)

433

return -1;

434

}

435

436

if (capability->modlen.max != 0) {

437

if (modlen > capability->modlen.max)

438

return -1;

439

}

440

441

/* in any case, check if given modlen is module increment */

442

if (capability->modlen.increment != 0) {

443

if (modlen % (capability->modlen.increment))

444

return -1;

445

}

446

447

return 0;

448

}

449

450

451

const char *

452

rte_cryptodev_get_feature_name(uint64_t flag)

453

{

454

switch (flag) {

455

case RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO(1ULL << 0):

456

return "SYMMETRIC_CRYPTO";

457

case RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO(1ULL << 1):

458

return "ASYMMETRIC_CRYPTO";

459

case RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING(1ULL << 2):

460

return "SYM_OPERATION_CHAINING";

461

case RTE_CRYPTODEV_FF_CPU_SSE(1ULL << 3):

462

return "CPU_SSE";

463

case RTE_CRYPTODEV_FF_CPU_AVX(1ULL << 4):

464

return "CPU_AVX";

465

case RTE_CRYPTODEV_FF_CPU_AVX2(1ULL << 5):

466

return "CPU_AVX2";

467

case RTE_CRYPTODEV_FF_CPU_AVX512(1ULL << 8):

468

return "CPU_AVX512";

469

case RTE_CRYPTODEV_FF_CPU_AESNI(1ULL << 6):

470

return "CPU_AESNI";

471

case RTE_CRYPTODEV_FF_HW_ACCELERATED(1ULL << 7):

472

return "HW_ACCELERATED";

473

case RTE_CRYPTODEV_FF_IN_PLACE_SGL(1ULL << 9):

474

return "IN_PLACE_SGL";

475

case RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT(1ULL << 10):

476

return "OOP_SGL_IN_SGL_OUT";

477

case RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT(1ULL << 11):

478

return "OOP_SGL_IN_LB_OUT";

479

case RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT(1ULL << 12):

480

return "OOP_LB_IN_SGL_OUT";

481

case RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT(1ULL << 13):

482

return "OOP_LB_IN_LB_OUT";

483

case RTE_CRYPTODEV_FF_CPU_NEON(1ULL << 14):

484

return "CPU_NEON";

485

case RTE_CRYPTODEV_FF_CPU_ARM_CE(1ULL << 15):

486

return "CPU_ARM_CE";

487

case RTE_CRYPTODEV_FF_SECURITY(1ULL << 16):

488

return "SECURITY_PROTOCOL";

489

case RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP(1ULL << 17):

490

return "RSA_PRIV_OP_KEY_EXP";

491

case RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT(1ULL << 18):

492

return "RSA_PRIV_OP_KEY_QT";

493

default:

494

return NULL((void*)0);

495

}

496

}

497

498

struct rte_cryptodev *

499

rte_cryptodev_pmd_get_dev(uint8_t dev_id)

500

{

501

return &cryptodev_globals.devs[dev_id];

502

}

503

504

struct rte_cryptodev *

505

rte_cryptodev_pmd_get_named_dev(const char *name)

506

{

507

struct rte_cryptodev *dev;

508

unsigned int i;

509

510

if (name == NULL((void*)0))

511

return NULL((void*)0);

512

513

for (i = 0; i < cryptodev_globals.max_devs; i++) {

514

dev = &cryptodev_globals.devs[i];

515

516

if ((dev->attached == RTE_CRYPTODEV_ATTACHED(1)) &&

517

(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))

518

return dev;

519

}

520

521

return NULL((void*)0);

522

}

523

524

unsigned int

525

rte_cryptodev_pmd_is_valid_dev(uint8_t dev_id)

526

{

527

struct rte_cryptodev *dev = NULL((void*)0);

528

529

if (dev_id >= cryptodev_globals.nb_devs)

530

return 0;

531

532

dev = rte_cryptodev_pmd_get_dev(dev_id);

533

if (dev->attached != RTE_CRYPTODEV_ATTACHED(1))

534

return 0;

535

else

536

return 1;

537

}

538

539

540

int

541

rte_cryptodev_get_dev_id(const char *name)

542

{

543

unsigned i;

544

545

if (name == NULL((void*)0))

546

return -1;

547

548

for (i = 0; i < cryptodev_globals.nb_devs; i++)

549

if ((strcmp(cryptodev_globals.devs[i].data->name, name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(cryptodev_globals.devs[i].data->name) && __builtin_constant_p
(name) && (__s1_len = __builtin_strlen (cryptodev_globals
.devs[i].data->name), __s2_len = __builtin_strlen (name), (
!((size_t)(const void *)((cryptodev_globals.devs[i].data->
name) + 1) - (size_t)(const void *)(cryptodev_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 (cryptodev_globals
.devs[i].data->name, name) : (__builtin_constant_p (cryptodev_globals
.devs[i].data->name) && ((size_t)(const void *)((cryptodev_globals
.devs[i].data->name) + 1) - (size_t)(const void *)(cryptodev_globals
.devs[i].data->name) == 1) && (__s1_len = __builtin_strlen
(cryptodev_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
(cryptodev_globals.devs[i].data->name, name) : (__extension__
({ const unsigned char *__s2 = (const unsigned char *) (const
char *) (name); int __result = (((const unsigned char *) (const
char *) (cryptodev_globals.devs[i].data->name))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (cryptodev_globals
.devs[i].data->name))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((const unsigned char *) (const
char *) (cryptodev_globals.devs[i].data->name))[2] - __s2
[2]); if (__s1_len > 2 && __result == 0) __result =
(((const unsigned char *) (const char *) (cryptodev_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
(cryptodev_globals.devs[i].data->name) && ((size_t
)(const void *)((cryptodev_globals.devs[i].data->name) + 1
) - (size_t)(const void *)(cryptodev_globals.devs[i].data->
name) == 1) ? __builtin_strcmp (cryptodev_globals.devs[i].data
->name, name) : (- (__extension__ ({ const unsigned char *
__s2 = (const unsigned char *) (const char *) (cryptodev_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 (cryptodev_globals.devs[i].data->name, name
)))); })

550

== 0) &&

551

(cryptodev_globals.devs[i].attached ==

552

RTE_CRYPTODEV_ATTACHED(1)))

553

return i;

554

555

return -1;

556

}

557

558

uint8_t

559

rte_cryptodev_count(void)

560

{

561

return cryptodev_globals.nb_devs;

562

}

563

564

uint8_t

565

rte_cryptodev_device_count_by_driver(uint8_t driver_id)

566

{

567

uint8_t i, dev_count = 0;

568

569

for (i = 0; i < cryptodev_globals.max_devs; i++)

570

if (cryptodev_globals.devs[i].driver_id == driver_id &&

571

cryptodev_globals.devs[i].attached ==

572

RTE_CRYPTODEV_ATTACHED(1))

573

dev_count++;

574

575

return dev_count;

576

}

577

578

uint8_t

579

rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices,

580

uint8_t nb_devices)

581

{

582

uint8_t i, count = 0;

583

struct rte_cryptodev *devs = cryptodev_globals.devs;

584

uint8_t max_devs = cryptodev_globals.max_devs;

585

586

for (i = 0; i < max_devs && count < nb_devices; i++) {

587

588

if (devs[i].attached == RTE_CRYPTODEV_ATTACHED(1)) {

589

int cmp;

590

591

cmp = strncmp(devs[i].device->driver->name,(__extension__ (__builtin_constant_p (strlen(driver_name) + 1
) && ((__builtin_constant_p (devs[i].device->driver
->name) && strlen (devs[i].device->driver->name
) < ((size_t) (strlen(driver_name) + 1))) || (__builtin_constant_p
(driver_name) && strlen (driver_name) < ((size_t)
(strlen(driver_name) + 1)))) ? __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) + 1)))

592

driver_name,(__extension__ (__builtin_constant_p (strlen(driver_name) + 1
) && ((__builtin_constant_p (devs[i].device->driver
->name) && strlen (devs[i].device->driver->name
) < ((size_t) (strlen(driver_name) + 1))) || (__builtin_constant_p
(driver_name) && strlen (driver_name) < ((size_t)
(strlen(driver_name) + 1)))) ? __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) + 1)))

593

strlen(driver_name) + 1)(__extension__ (__builtin_constant_p (strlen(driver_name) + 1
) && ((__builtin_constant_p (devs[i].device->driver
->name) && strlen (devs[i].device->driver->name
) < ((size_t) (strlen(driver_name) + 1))) || (__builtin_constant_p
(driver_name) && strlen (driver_name) < ((size_t)
(strlen(driver_name) + 1)))) ? __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) + 1)));

594

595

if (cmp == 0)

596

devices[count++] = devs[i].data->dev_id;

597

}

598

}

599

600

return count;

601

}

602

603

void *

604

rte_cryptodev_get_sec_ctx(uint8_t dev_id)

605

{

606

if (rte_crypto_devices[dev_id].feature_flags &

607

RTE_CRYPTODEV_FF_SECURITY(1ULL << 16))

608

return rte_crypto_devices[dev_id].security_ctx;

609

610

return NULL((void*)0);

611

}

612

613

int

614

rte_cryptodev_socket_id(uint8_t dev_id)

615

{

616

struct rte_cryptodev *dev;

617

618

if (!rte_cryptodev_pmd_is_valid_dev(dev_id))

619

return -1;

620

621

dev = rte_cryptodev_pmd_get_dev(dev_id);

622

623

return dev->data->socket_id;

624

}

625

626

static inline int

627

rte_cryptodev_data_alloc(uint8_t dev_id, struct rte_cryptodev_data **data,

628

int socket_id)

629

{

630

char mz_name[RTE_CRYPTODEV_NAME_MAX_LEN(64)];

631

const struct rte_memzone *mz;

632

int n;

633

634

/* generate memzone name */

635

n = snprintf(mz_name, sizeof(mz_name), "rte_cryptodev_data_%u", dev_id);

636

if (n >= (int)sizeof(mz_name))

637

return -EINVAL22;

638

639

if (rte_eal_process_type() == RTE_PROC_PRIMARY) {

640

mz = rte_memzone_reserve(mz_name,

641

sizeof(struct rte_cryptodev_data),

642

socket_id, 0);

643

} else

644

mz = rte_memzone_lookup(mz_name);

645

646

if (mz == NULL((void*)0))

647

return -ENOMEM12;

648

649

*data = mz->addr;

650

if (rte_eal_process_type() == RTE_PROC_PRIMARY)

651

memset(*data, 0, sizeof(struct rte_cryptodev_data));

652

653

return 0;

654

}

655

656

static uint8_t

657

rte_cryptodev_find_free_device_index(void)

658

{

659

uint8_t dev_id;

660

661

for (dev_id = 0; dev_id < RTE_CRYPTO_MAX_DEVS64; dev_id++) {

662

if (rte_crypto_devices[dev_id].attached ==

663

RTE_CRYPTODEV_DETACHED(0))

664

return dev_id;

665

}

666

return RTE_CRYPTO_MAX_DEVS64;

667

}

668

669

struct rte_cryptodev *

670

rte_cryptodev_pmd_allocate(const char *name, int socket_id)

671

{

672

struct rte_cryptodev *cryptodev;

673

uint8_t dev_id;

674

675

if (rte_cryptodev_pmd_get_named_dev(name) != NULL((void*)0)) {

676

CDEV_LOG_ERR("Crypto device with name %s already "rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Crypto device with name %s already "
"allocated!" "\n" "%.0s", __func__, 677, name, "")

677

"allocated!", name)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Crypto device with name %s already "
"allocated!" "\n" "%.0s", __func__, 677, name, "");

678

return NULL((void*)0);

679

}

680

681

dev_id = rte_cryptodev_find_free_device_index();

682

if (dev_id == RTE_CRYPTO_MAX_DEVS64) {

683

CDEV_LOG_ERR("Reached maximum number of crypto devices")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Reached maximum number of crypto devices"
"\n" "%.0s", __func__, 683, "");

684

return NULL((void*)0);

685

}

686

687

cryptodev = rte_cryptodev_pmd_get_dev(dev_id);

688

689

if (cryptodev->data == NULL((void*)0)) {

690

struct rte_cryptodev_data *cryptodev_data =

691

cryptodev_globals.data[dev_id];

692

693

int retval = rte_cryptodev_data_alloc(dev_id, &cryptodev_data,

694

socket_id);

695

696

if (retval < 0 || cryptodev_data == NULL((void*)0))

697

return NULL((void*)0);

698

699

cryptodev->data = cryptodev_data;

700

701

strlcpy(cryptodev->data->name, name,rte_strlcpy(cryptodev->data->name, name, (64))

702

RTE_CRYPTODEV_NAME_MAX_LEN)rte_strlcpy(cryptodev->data->name, name, (64));

703

704

cryptodev->data->dev_id = dev_id;

705

cryptodev->data->socket_id = socket_id;

706

cryptodev->data->dev_started = 0;

707

708

/* init user callbacks */

709

TAILQ_INIT(&(cryptodev->link_intr_cbs))do { (&(cryptodev->link_intr_cbs))->tqh_first = ((void
*)0); (&(cryptodev->link_intr_cbs))->tqh_last = &
(&(cryptodev->link_intr_cbs))->tqh_first; } while (
0);

710

711

cryptodev->attached = RTE_CRYPTODEV_ATTACHED(1);

712

713

cryptodev_globals.nb_devs++;

714

}

715

716

return cryptodev;

717

}

718

719

int

720

rte_cryptodev_pmd_release_device(struct rte_cryptodev *cryptodev)

721

{

722

int ret;

723

724

if (cryptodev == NULL((void*)0))

725

return -EINVAL22;

726

727

/* Close device only if device operations have been set */

728

if (cryptodev->dev_ops) {

729

ret = rte_cryptodev_close(cryptodev->data->dev_id);

730

if (ret < 0)

731

return ret;

732

}

733

734

cryptodev->attached = RTE_CRYPTODEV_DETACHED(0);

735

cryptodev_globals.nb_devs--;

736

return 0;

737

}

738

739

uint16_t

740

rte_cryptodev_queue_pair_count(uint8_t dev_id)

741

{

742

struct rte_cryptodev *dev;

743

744

dev = &rte_crypto_devices[dev_id];

745

return dev->data->nb_queue_pairs;

746

}

747

748

static int

749

rte_cryptodev_queue_pairs_config(struct rte_cryptodev *dev, uint16_t nb_qpairs,

750

int socket_id)

751

{

752

struct rte_cryptodev_info dev_info;

753

void **qp;

754

unsigned i;

755

756

if ((dev == NULL((void*)0)) || (nb_qpairs < 1)) {

757

CDEV_LOG_ERR("invalid param: dev %p, nb_queues %u",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "invalid param: dev %p, nb_queues %u"
"\n" "%.0s", __func__, 758, dev, nb_qpairs, "")

758

dev, nb_qpairs)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "invalid param: dev %p, nb_queues %u"
"\n" "%.0s", __func__, 758, dev, nb_qpairs, "");

759

return -EINVAL22;

760

}

761

762

CDEV_LOG_DEBUG("Setup %d queues pairs on device %u",rte_log(8U, 17, "CRYPTODEV" ": " "%s() line %u: " "Setup %d queues pairs on device %u"
"\n" "%.0s", __func__, 763, nb_qpairs, dev->data->dev_id
, "")

763

nb_qpairs, dev->data->dev_id)rte_log(8U, 17, "CRYPTODEV" ": " "%s() line %u: " "Setup %d queues pairs on device %u"
"\n" "%.0s", __func__, 763, nb_qpairs, dev->data->dev_id
, "");

764

765

memset(&dev_info, 0, sizeof(struct rte_cryptodev_info));

766

767

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);

768

(*dev->dev_ops->dev_infos_get)(dev, &dev_info);

769

770

if (nb_qpairs > (dev_info.max_nb_queue_pairs)) {

771

CDEV_LOG_ERR("Invalid num queue_pairs (%u) for dev %u",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid num queue_pairs (%u) for dev %u"
"\n" "%.0s", __func__, 772, nb_qpairs, dev->data->dev_id
, "")

772

nb_qpairs, dev->data->dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid num queue_pairs (%u) for dev %u"
"\n" "%.0s", __func__, 772, nb_qpairs, dev->data->dev_id
, "");

773

return -EINVAL22;

774

}

775

776

if (dev->data->queue_pairs == NULL((void*)0)) { /* first time configuration */

777

dev->data->queue_pairs = rte_zmalloc_socket(

778

"cryptodev->queue_pairs",

779

sizeof(dev->data->queue_pairs[0]) * nb_qpairs,

780

RTE_CACHE_LINE_SIZE64, socket_id);

781

782

if (dev->data->queue_pairs == NULL((void*)0)) {

783

dev->data->nb_queue_pairs = 0;

784

CDEV_LOG_ERR("failed to get memory for qp meta data, "rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "failed to get memory for qp meta data, "
"nb_queues %u" "\n" "%.0s", __func__, 786, nb_qpairs, "")

785

"nb_queues %u",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "failed to get memory for qp meta data, "
"nb_queues %u" "\n" "%.0s", __func__, 786, nb_qpairs, "")

786

nb_qpairs)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "failed to get memory for qp meta data, "
"nb_queues %u" "\n" "%.0s", __func__, 786, nb_qpairs, "");

787

return -(ENOMEM12);

788

}

789

} else { /* re-configure */

790

int ret;

791

uint16_t old_nb_queues = dev->data->nb_queue_pairs;

792

793

qp = dev->data->queue_pairs;

794

795

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)

796

-ENOTSUP)do { if ((*dev->dev_ops->queue_pair_release) == ((void*
)0)) return -95; } while (0);

797

798

for (i = nb_qpairs; i < old_nb_queues; i++) {

799

ret = (*dev->dev_ops->queue_pair_release)(dev, i);

800

if (ret < 0)

801

return ret;

802

}

803

804

qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs,

805

RTE_CACHE_LINE_SIZE64);

806

if (qp == NULL((void*)0)) {

807

CDEV_LOG_ERR("failed to realloc qp meta data,"rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "failed to realloc qp meta data,"
" nb_queues %u" "\n" "%.0s", __func__, 808, nb_qpairs, "")

808

" nb_queues %u", nb_qpairs)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "failed to realloc qp meta data,"
" nb_queues %u" "\n" "%.0s", __func__, 808, nb_qpairs, "");

809

return -(ENOMEM12);

810

}

811

812

if (nb_qpairs > old_nb_queues) {

813

uint16_t new_qs = nb_qpairs - old_nb_queues;

814

815

memset(qp + old_nb_queues, 0,

816

sizeof(qp[0]) * new_qs);

817

}

818

819

dev->data->queue_pairs = qp;

820

821

}

822

dev->data->nb_queue_pairs = nb_qpairs;

823

return 0;

824

}

825

826

int

827

rte_cryptodev_configure(uint8_t dev_id, struct rte_cryptodev_config *config)

828

{

829

struct rte_cryptodev *dev;

830

int diag;

831

832

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

833

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 833, dev_id, "");

834

return -EINVAL22;

835

}

836

837

dev = &rte_crypto_devices[dev_id];

838

839

if (dev->data->dev_started) {

840

CDEV_LOG_ERR(rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "device %d must be stopped to allow configuration"
"\n" "%.0s", __func__, 841, dev_id, "")

841

"device %d must be stopped to allow configuration", dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "device %d must be stopped to allow configuration"
"\n" "%.0s", __func__, 841, dev_id, "");

842

return -EBUSY16;

843

}

844

845

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);

846

847

/* Setup new number of queue pairs and reconfigure device. */

848

diag = rte_cryptodev_queue_pairs_config(dev, config->nb_queue_pairs,

849

config->socket_id);

850

if (diag != 0) {

851

CDEV_LOG_ERR("dev%d rte_crypto_dev_queue_pairs_config = %d",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev%d rte_crypto_dev_queue_pairs_config = %d"
"\n" "%.0s", __func__, 852, dev_id, diag, "")

852

dev_id, diag)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev%d rte_crypto_dev_queue_pairs_config = %d"
"\n" "%.0s", __func__, 852, dev_id, diag, "");

853

return diag;

854

}

855

856

return (*dev->dev_ops->dev_configure)(dev, config);

857

}

858

859

860

int

861

rte_cryptodev_start(uint8_t dev_id)

862

{

863

struct rte_cryptodev *dev;

864

int diag;

865

866

CDEV_LOG_DEBUG("Start dev_id=%" PRIu8, dev_id)rte_log(8U, 17, "CRYPTODEV" ": " "%s() line %u: " "Start dev_id=%"
"u" "\n" "%.0s", __func__, 866, dev_id, "");

867

868

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

869

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 869, dev_id, "");

870

return -EINVAL22;

871

}

872

873

dev = &rte_crypto_devices[dev_id];

874

875

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);

876

877

if (dev->data->dev_started != 0) {

878

CDEV_LOG_ERR("Device with dev_id=%" PRIu8 " already started",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Device with dev_id=%"
"u" " already started" "\n" "%.0s", __func__, 879, dev_id, ""
)

879

dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Device with dev_id=%"
"u" " already started" "\n" "%.0s", __func__, 879, dev_id, ""
);

880

return 0;

881

}

882

883

diag = (*dev->dev_ops->dev_start)(dev);

884

if (diag == 0)

885

dev->data->dev_started = 1;

886

else

887

return diag;

888

889

return 0;

890

}

891

892

void

893

rte_cryptodev_stop(uint8_t dev_id)

894

{

895

struct rte_cryptodev *dev;

896

897

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

898

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 898, dev_id, "");

899

return;

900

}

901

902

dev = &rte_crypto_devices[dev_id];

903

904

RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop)do { if ((*dev->dev_ops->dev_stop) == ((void*)0)) return
; } while (0);

905

906

if (dev->data->dev_started == 0) {

907

CDEV_LOG_ERR("Device with dev_id=%" PRIu8 " already stopped",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Device with dev_id=%"
"u" " already stopped" "\n" "%.0s", __func__, 908, dev_id, ""
)

908

dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Device with dev_id=%"
"u" " already stopped" "\n" "%.0s", __func__, 908, dev_id, ""
);

909

return;

910

}

911

912

(*dev->dev_ops->dev_stop)(dev);

913

dev->data->dev_started = 0;

914

}

915

916

int

917

rte_cryptodev_close(uint8_t dev_id)

918

{

919

struct rte_cryptodev *dev;

920

int retval;

921

922

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

923

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 923, dev_id, "");

924

return -1;

925

}

926

927

dev = &rte_crypto_devices[dev_id];

928

929

/* Device must be stopped before it can be closed */

930

if (dev->data->dev_started == 1) {

931

CDEV_LOG_ERR("Device %u must be stopped before closing",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Device %u must be stopped before closing"
"\n" "%.0s", __func__, 932, dev_id, "")

932

dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Device %u must be stopped before closing"
"\n" "%.0s", __func__, 932, dev_id, "");

933

return -EBUSY16;

934

}

935

936

/* We can't close the device if there are outstanding sessions in use */

937

if (dev->data->session_pool != NULL((void*)0)) {

938

if (!rte_mempool_full(dev->data->session_pool)) {

939

CDEV_LOG_ERR("dev_id=%u close failed, session mempool "rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id=%u close failed, session mempool "
"has sessions still in use, free " "all sessions before calling close"
"\n" "%.0s", __func__, 942, (unsigned)dev_id, "")

940

"has sessions still in use, free "rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id=%u close failed, session mempool "
"has sessions still in use, free " "all sessions before calling close"
"\n" "%.0s", __func__, 942, (unsigned)dev_id, "")

941

"all sessions before calling close",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id=%u close failed, session mempool "
"has sessions still in use, free " "all sessions before calling close"
"\n" "%.0s", __func__, 942, (unsigned)dev_id, "")

942

(unsigned)dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id=%u close failed, session mempool "
"has sessions still in use, free " "all sessions before calling close"
"\n" "%.0s", __func__, 942, (unsigned)dev_id, "");

943

return -EBUSY16;

944

}

945

}

946

947

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);

948

retval = (*dev->dev_ops->dev_close)(dev);

949

950

if (retval < 0)

951

return retval;

952

953

return 0;

954

}

955

956

int

957

rte_cryptodev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,

958

const struct rte_cryptodev_qp_conf *qp_conf, int socket_id)

959

960

{

961

struct rte_cryptodev *dev;

962

963

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

964

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 964, dev_id, "");

965

return -EINVAL22;

966

}

967

968

dev = &rte_crypto_devices[dev_id];

969

if (queue_pair_id >= dev->data->nb_queue_pairs) {

970

CDEV_LOG_ERR("Invalid queue_pair_id=%d", queue_pair_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid queue_pair_id=%d"
"\n" "%.0s", __func__, 970, queue_pair_id, "");

971

return -EINVAL22;

972

}

973

974

if (!qp_conf) {

975

CDEV_LOG_ERR("qp_conf cannot be NULL\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "qp_conf cannot be NULL\n"
"\n" "%.0s", __func__, 975, "");

976

return -EINVAL22;

977

}

978

979

if ((qp_conf->mp_session && !qp_conf->mp_session_private) ||

980

(!qp_conf->mp_session && qp_conf->mp_session_private)) {

981

CDEV_LOG_ERR("Invalid mempools\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid mempools\n"
"\n" "%.0s", __func__, 981, "");

982

return -EINVAL22;

983

}

984

985

if (qp_conf->mp_session) {

986

struct rte_cryptodev_sym_session_pool_private_data *pool_priv;

987

uint32_t obj_size = qp_conf->mp_session->elt_size;

988

uint32_t obj_priv_size = qp_conf->mp_session_private->elt_size;

989

struct rte_cryptodev_sym_session s = {0};

990

991

pool_priv = rte_mempool_get_priv(qp_conf->mp_session);

992

if (!pool_priv || qp_conf->mp_session->private_data_size <

993

sizeof(*pool_priv)) {

994

CDEV_LOG_ERR("Invalid mempool\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid mempool\n"
"\n" "%.0s", __func__, 994, "");

995

return -EINVAL22;

996

}

997

998

s.nb_drivers = pool_priv->nb_drivers;

999

s.user_data_sz = pool_priv->user_data_sz;

1000

1001

if ((rte_cryptodev_sym_get_existing_header_session_size(&s) >

1002

obj_size) || (s.nb_drivers <= dev->driver_id) ||

1003

rte_cryptodev_sym_get_private_session_size(dev_id) >

1004

obj_priv_size) {

1005

CDEV_LOG_ERR("Invalid mempool\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid mempool\n"
"\n" "%.0s", __func__, 1005, "");

1006

return -EINVAL22;

1007

}

1008

}

1009

1010

if (dev->data->dev_started) {

1011

CDEV_LOG_ERR(rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "device %d must be stopped to allow configuration"
"\n" "%.0s", __func__, 1012, dev_id, "")

1012

1013

return -EBUSY16;

1014

}

1015

1016

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);

1017

1018

return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id, qp_conf,

1019

socket_id);

1020

}

1021

1022

1023

int

1024

rte_cryptodev_stats_get(uint8_t dev_id, struct rte_cryptodev_stats *stats)

1025

{

1026

struct rte_cryptodev *dev;

1027

1028

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

1029

CDEV_LOG_ERR("Invalid dev_id=%d", dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%d"
"\n" "%.0s", __func__, 1029, dev_id, "");

1030

return -ENODEV19;

1031

}

1032

1033

if (stats == NULL((void*)0)) {

1034

CDEV_LOG_ERR("Invalid stats ptr")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid stats ptr"
"\n" "%.0s", __func__, 1034, "");

1035

return -EINVAL22;

1036

}

1037

1038

dev = &rte_crypto_devices[dev_id];

1039

memset(stats, 0, sizeof(*stats));

1040

1041

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);

1042

(*dev->dev_ops->stats_get)(dev, stats);

1043

return 0;

1044

}

1045

1046

void

1047

rte_cryptodev_stats_reset(uint8_t dev_id)

1048

{

1049

struct rte_cryptodev *dev;

1050

1051

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

1052

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 1052, dev_id, "");

1053

return;

1054

}

1055

1056

dev = &rte_crypto_devices[dev_id];

1057

1058

RTE_FUNC_PTR_OR_RET(*dev->dev_ops->stats_reset)do { if ((*dev->dev_ops->stats_reset) == ((void*)0)) return
; } while (0);

1059

(*dev->dev_ops->stats_reset)(dev);

1060

}

1061

1062

1063

void

1064

rte_cryptodev_info_get(uint8_t dev_id, struct rte_cryptodev_info *dev_info)

1065

{

1066

struct rte_cryptodev *dev;

1067

1068

if (dev_id >= cryptodev_globals.nb_devs) {

←

Taking true branch

→

1069

CDEV_LOG_ERR("Invalid dev_id=%d", dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%d"
"\n" "%.0s", __func__, 1069, dev_id, "");

1070

return;

1071

}

1072

1073

dev = &rte_crypto_devices[dev_id];

1074

1075

memset(dev_info, 0, sizeof(struct rte_cryptodev_info));

1076

1077

RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get)do { if ((*dev->dev_ops->dev_infos_get) == ((void*)0)) return
; } while (0);

1078

(*dev->dev_ops->dev_infos_get)(dev, dev_info);

1079

1080

dev_info->driver_name = dev->device->driver->name;

1081

dev_info->device = dev->device;

1082

}

1083

1084

1085

int

1086

rte_cryptodev_callback_register(uint8_t dev_id,

1087

enum rte_cryptodev_event_type event,

1088

rte_cryptodev_cb_fn cb_fn, void *cb_arg)

1089

{

1090

struct rte_cryptodev *dev;

1091

struct rte_cryptodev_callback *user_cb;

1092

1093

if (!cb_fn)

1094

return -EINVAL22;

1095

1096

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

1097

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 1097, dev_id, "");

1098

return -EINVAL22;

1099

}

1100

1101

dev = &rte_crypto_devices[dev_id];

1102

rte_spinlock_lock(&rte_cryptodev_cb_lock);

1103

1104

TAILQ_FOREACH(user_cb, &(dev->link_intr_cbs), next)for ((user_cb) = ((&(dev->link_intr_cbs))->tqh_first
); (user_cb); (user_cb) = ((user_cb)->next.tqe_next)) {

1105

if (user_cb->cb_fn == cb_fn &&

1106

user_cb->cb_arg == cb_arg &&

1107

user_cb->event == event) {

1108

break;

1109

}

1110

}

1111

1112

/* create a new callback. */

1113

if (user_cb == NULL((void*)0)) {

1114

user_cb = rte_zmalloc("INTR_USER_CALLBACK",

1115

sizeof(struct rte_cryptodev_callback), 0);

1116

if (user_cb != NULL((void*)0)) {

1117

user_cb->cb_fn = cb_fn;

1118

user_cb->cb_arg = cb_arg;

1119

user_cb->event = event;

1120

TAILQ_INSERT_TAIL(&(dev->link_intr_cbs), user_cb, next)do { (user_cb)->next.tqe_next = ((void*)0); (user_cb)->
next.tqe_prev = (&(dev->link_intr_cbs))->tqh_last; *
(&(dev->link_intr_cbs))->tqh_last = (user_cb); (&
(dev->link_intr_cbs))->tqh_last = &(user_cb)->next
.tqe_next; } while ( 0);

1121

}

1122

}

1123

1124

rte_spinlock_unlock(&rte_cryptodev_cb_lock);

1125

return (user_cb == NULL((void*)0)) ? -ENOMEM12 : 0;

1126

}

1127

1128

int

1129

rte_cryptodev_callback_unregister(uint8_t dev_id,

1130

enum rte_cryptodev_event_type event,

1131

rte_cryptodev_cb_fn cb_fn, void *cb_arg)

1132

{

1133

int ret;

1134

struct rte_cryptodev *dev;

1135

struct rte_cryptodev_callback *cb, *next;

1136

1137

if (!cb_fn)

1138

return -EINVAL22;

1139

1140

if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {

1141

CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid dev_id=%"
"u" "\n" "%.0s", __func__, 1141, dev_id, "");

1142

return -EINVAL22;

1143

}

1144

1145

dev = &rte_crypto_devices[dev_id];

1146

rte_spinlock_lock(&rte_cryptodev_cb_lock);

1147

1148

ret = 0;

1149

for (cb = TAILQ_FIRST(&dev->link_intr_cbs)((&dev->link_intr_cbs)->tqh_first); cb != NULL((void*)0); cb = next) {

1150

1151

next = TAILQ_NEXT(cb, next)((cb)->next.tqe_next);

1152

1153

if (cb->cb_fn != cb_fn || cb->event != event ||

1154

(cb->cb_arg != (void *)-1 &&

1155

cb->cb_arg != cb_arg))

1156

continue;

1157

1158

1159

* if this callback is not executing right now,

1160

* then remove it.

1161

1162

if (cb->active == 0) {

1163

TAILQ_REMOVE(&(dev->link_intr_cbs), cb, next)do { if (((cb)->next.tqe_next) != ((void*)0)) (cb)->next
.tqe_next->next.tqe_prev = (cb)->next.tqe_prev; else (&
(dev->link_intr_cbs))->tqh_last = (cb)->next.tqe_prev
; *(cb)->next.tqe_prev = (cb)->next.tqe_next; } while (
0);

1164

rte_free(cb);

1165

} else {

1166

ret = -EAGAIN11;

1167

}

1168

}

1169

1170

rte_spinlock_unlock(&rte_cryptodev_cb_lock);

1171

return ret;

1172

}

1173

1174

void

1175

rte_cryptodev_pmd_callback_process(struct rte_cryptodev *dev,

1176

enum rte_cryptodev_event_type event)

1177

{

1178

struct rte_cryptodev_callback *cb_lst;

1179

struct rte_cryptodev_callback dev_cb;

1180

1181

rte_spinlock_lock(&rte_cryptodev_cb_lock);

1182

TAILQ_FOREACH(cb_lst, &(dev->link_intr_cbs), next)for ((cb_lst) = ((&(dev->link_intr_cbs))->tqh_first
); (cb_lst); (cb_lst) = ((cb_lst)->next.tqe_next)) {

1183

if (cb_lst->cb_fn == NULL((void*)0) || cb_lst->event != event)

1184

continue;

1185

dev_cb = *cb_lst;

1186

cb_lst->active = 1;

1187

rte_spinlock_unlock(&rte_cryptodev_cb_lock);

1188

dev_cb.cb_fn(dev->data->dev_id, dev_cb.event,

1189

dev_cb.cb_arg);

1190

rte_spinlock_lock(&rte_cryptodev_cb_lock);

1191

cb_lst->active = 0;

1192

}

1193

rte_spinlock_unlock(&rte_cryptodev_cb_lock);

1194

}

1195

1196

1197

int

1198

rte_cryptodev_sym_session_init(uint8_t dev_id,

1199

struct rte_cryptodev_sym_session *sess,

1200

struct rte_crypto_sym_xform *xforms,

1201

struct rte_mempool *mp)

1202

{

1203

struct rte_cryptodev *dev;

1204

uint32_t sess_priv_sz = rte_cryptodev_sym_get_private_session_size(

1205

dev_id);

1206

uint8_t index;

1207

int ret;

1208

1209

dev = rte_cryptodev_pmd_get_dev(dev_id);

1210

1211

if (sess == NULL((void*)0) || xforms == NULL((void*)0) || dev == NULL((void*)0))

1212

return -EINVAL22;

1213

1214

if (mp->elt_size < sess_priv_sz)

1215

return -EINVAL22;

1216

1217

index = dev->driver_id;

1218

if (index >= sess->nb_drivers)

1219

return -EINVAL22;

1220

1221

RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->sym_session_configure, -ENOTSUP)do { if ((*dev->dev_ops->sym_session_configure) == ((void
*)0)) return -95; } while (0);

1222

1223

if (sess->sess_data[index].refcnt == 0) {

1224

ret = dev->dev_ops->sym_session_configure(dev, xforms,

1225

sess, mp);

1226

if (ret < 0) {

1227

CDEV_LOG_ERR(rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id %d failed to configure session details"
"\n" "%.0s", __func__, 1229, dev_id, "")

1228

"dev_id %d failed to configure session details",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id %d failed to configure session details"
"\n" "%.0s", __func__, 1229, dev_id, "")

1229

dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id %d failed to configure session details"
"\n" "%.0s", __func__, 1229, dev_id, "");

1230

return ret;

1231

}

1232

}

1233

1234

sess->sess_data[index].refcnt++;

1235

return 0;

1236

}

1237

1238

int __rte_experimental__attribute__((section(".text.experimental")))

1239

rte_cryptodev_asym_session_init(uint8_t dev_id,

1240

struct rte_cryptodev_asym_session *sess,

1241

struct rte_crypto_asym_xform *xforms,

1242

struct rte_mempool *mp)

1243

{

1244

struct rte_cryptodev *dev;

1245

uint8_t index;

1246

int ret;

1247

1248

dev = rte_cryptodev_pmd_get_dev(dev_id);

1249

1250

if (sess == NULL((void*)0) || xforms == NULL((void*)0) || dev == NULL((void*)0))

1251

return -EINVAL22;

1252

1253

index = dev->driver_id;

1254

1255

RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->asym_session_configure,do { if ((*dev->dev_ops->asym_session_configure) == ((void
*)0)) return -95; } while (0)

1256

-ENOTSUP)do { if ((*dev->dev_ops->asym_session_configure) == ((void
*)0)) return -95; } while (0);

1257

1258

if (sess->sess_private_data[index] == NULL((void*)0)) {

1259

ret = dev->dev_ops->asym_session_configure(dev,

1260

xforms,

1261

sess, mp);

1262

if (ret < 0) {

1263

CDEV_LOG_ERR(rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id %d failed to configure session details"
"\n" "%.0s", __func__, 1265, dev_id, "")

1264

"dev_id %d failed to configure session details",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id %d failed to configure session details"
"\n" "%.0s", __func__, 1265, dev_id, "")

1265

dev_id)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "dev_id %d failed to configure session details"
"\n" "%.0s", __func__, 1265, dev_id, "");

1266

return ret;

1267

}

1268

}

1269

1270

return 0;

1271

}

1272

1273

struct rte_mempool * __rte_experimental__attribute__((section(".text.experimental")))

1274

rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts,

1275

uint32_t elt_size, uint32_t cache_size, uint16_t user_data_size,

1276

int socket_id)

1277

{

1278

struct rte_mempool *mp;

1279

struct rte_cryptodev_sym_session_pool_private_data *pool_priv;

1280

uint32_t obj_sz;

1281

1282

obj_sz = rte_cryptodev_sym_get_header_session_size() + user_data_size;

1283

if (obj_sz > elt_size)

1284

CDEV_LOG_INFO("elt_size %u is expanded to %u\n", elt_size,rte_log(7U, 17, "CRYPTODEV" ": " "elt_size %u is expanded to %u\n"
"\n" "%.0s", elt_size, obj_sz, "")

1285

obj_sz)rte_log(7U, 17, "CRYPTODEV" ": " "elt_size %u is expanded to %u\n"
"\n" "%.0s", elt_size, obj_sz, "");

1286

else

1287

obj_sz = elt_size;

1288

1289

mp = rte_mempool_create(name, nb_elts, obj_sz, cache_size,

1290

(uint32_t)(sizeof(*pool_priv)),

1291

NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0),

1292

socket_id, 0);

1293

if (mp == NULL((void*)0)) {

1294

CDEV_LOG_ERR("%s(name=%s) failed, rte_errno=%d\n",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "%s(name=%s) failed, rte_errno=%d\n"
"\n" "%.0s", __func__, 1295, __func__, name, (per_lcore__rte_errno
), "")

1295

__func__, name, rte_errno)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "%s(name=%s) failed, rte_errno=%d\n"
"\n" "%.0s", __func__, 1295, __func__, name, (per_lcore__rte_errno
), "");

1296

return NULL((void*)0);

1297

}

1298

1299

pool_priv = rte_mempool_get_priv(mp);

1300

if (!pool_priv) {

1301

CDEV_LOG_ERR("%s(name=%s) failed to get private data\n",rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "%s(name=%s) failed to get private data\n"
"\n" "%.0s", __func__, 1302, __func__, name, "")

1302

__func__, name)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "%s(name=%s) failed to get private data\n"
"\n" "%.0s", __func__, 1302, __func__, name, "");

1303

rte_mempool_free(mp);

1304

return NULL((void*)0);

1305

}

1306

1307

pool_priv->nb_drivers = nb_drivers;

1308

pool_priv->user_data_sz = user_data_size;

1309

1310

return mp;

1311

}

1312

1313

static unsigned int

1314

rte_cryptodev_sym_session_data_size(struct rte_cryptodev_sym_session *sess)

1315

{

1316

return (sizeof(sess->sess_data[0]) * sess->nb_drivers) +

1317

sess->user_data_sz;

1318

}

1319

1320

struct rte_cryptodev_sym_session *

1321

rte_cryptodev_sym_session_create(struct rte_mempool *mp)

1322

{

1323

struct rte_cryptodev_sym_session *sess;

1324

struct rte_cryptodev_sym_session_pool_private_data *pool_priv;

1325

1326

if (!mp) {

1327

CDEV_LOG_ERR("Invalid mempool\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid mempool\n"
"\n" "%.0s", __func__, 1327, "");

1328

return NULL((void*)0);

1329

}

1330

1331

pool_priv = rte_mempool_get_priv(mp);

1332

1333

if (!pool_priv || mp->private_data_size < sizeof(*pool_priv)) {

1334

CDEV_LOG_ERR("Invalid mempool\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid mempool\n"
"\n" "%.0s", __func__, 1334, "");

1335

return NULL((void*)0);

1336

}

1337

1338

/* Allocate a session structure from the session pool */

1339

if (rte_mempool_get(mp, (void **)&sess)) {

1340

CDEV_LOG_ERR("couldn't get object from session mempool")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "couldn't get object from session mempool"
"\n" "%.0s", __func__, 1340, "");

1341

return NULL((void*)0);

1342

}

1343

1344

sess->nb_drivers = pool_priv->nb_drivers;

1345

sess->user_data_sz = pool_priv->user_data_sz;

1346

sess->opaque_data = 0;

1347

1348

/* Clear device session pointer.

1349

* Include the flag indicating presence of user data

1350

1351

memset(sess->sess_data, 0,

1352

rte_cryptodev_sym_session_data_size(sess));

1353

1354

return sess;

1355

}

1356

1357

struct rte_cryptodev_asym_session * __rte_experimental__attribute__((section(".text.experimental")))

1358

rte_cryptodev_asym_session_create(struct rte_mempool *mp)

1359

{

1360

struct rte_cryptodev_asym_session *sess;

1361

1362

/* Allocate a session structure from the session pool */

1363

if (rte_mempool_get(mp, (void **)&sess)) {

1364

CDEV_LOG_ERR("couldn't get object from session mempool")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "couldn't get object from session mempool"
"\n" "%.0s", __func__, 1364, "");

1365

return NULL((void*)0);

1366

}

1367

1368

/* Clear device session pointer.

1369

* Include the flag indicating presence of private data

1370

1371

memset(sess, 0, (sizeof(void *) * nb_drivers) + sizeof(uint8_t));

1372

1373

return sess;

1374

}

1375

1376

int

1377

rte_cryptodev_sym_session_clear(uint8_t dev_id,

1378

struct rte_cryptodev_sym_session *sess)

1379

{

1380

struct rte_cryptodev *dev;

1381

uint8_t driver_id;

1382

1383

dev = rte_cryptodev_pmd_get_dev(dev_id);

1384

1385

if (dev == NULL((void*)0) || sess == NULL((void*)0))

1386

return -EINVAL22;

1387

1388

driver_id = dev->driver_id;

1389

if (sess->sess_data[driver_id].refcnt == 0)

1390

return 0;

1391

if (--sess->sess_data[driver_id].refcnt != 0)

1392

return -EBUSY16;

1393

1394

RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->sym_session_clear, -ENOTSUP)do { if ((*dev->dev_ops->sym_session_clear) == ((void*)
0)) return -95; } while (0);

1395

1396

dev->dev_ops->sym_session_clear(dev, sess);

1397

1398

return 0;

1399

}

1400

1401

int __rte_experimental__attribute__((section(".text.experimental")))

1402

rte_cryptodev_asym_session_clear(uint8_t dev_id,

1403

struct rte_cryptodev_asym_session *sess)

1404

{

1405

struct rte_cryptodev *dev;

1406

1407

dev = rte_cryptodev_pmd_get_dev(dev_id);

1408

1409

if (dev == NULL((void*)0) || sess == NULL((void*)0))

1410

return -EINVAL22;

1411

1412

RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->asym_session_clear, -ENOTSUP)do { if ((*dev->dev_ops->asym_session_clear) == ((void*
)0)) return -95; } while (0);

1413

1414

dev->dev_ops->asym_session_clear(dev, sess);

1415

1416

return 0;

1417

}

1418

1419

int

1420

rte_cryptodev_sym_session_free(struct rte_cryptodev_sym_session *sess)

1421

{

1422

uint8_t i;

1423

struct rte_mempool *sess_mp;

1424

1425

if (sess == NULL((void*)0))

1426

return -EINVAL22;

1427

1428

/* Check that all device private data has been freed */

1429

for (i = 0; i < sess->nb_drivers; i++) {

1430

if (sess->sess_data[i].refcnt != 0)

1431

return -EBUSY16;

1432

}

1433

1434

/* Return session to mempool */

1435

sess_mp = rte_mempool_from_obj(sess);

1436

rte_mempool_put(sess_mp, sess);

1437

1438

return 0;

1439

}

1440

1441

int __rte_experimental__attribute__((section(".text.experimental")))

1442

rte_cryptodev_asym_session_free(struct rte_cryptodev_asym_session *sess)

1443

{

1444

uint8_t i;

1445

void *sess_priv;

1446

struct rte_mempool *sess_mp;

1447

1448

if (sess == NULL((void*)0))

1449

return -EINVAL22;

1450

1451

/* Check that all device private data has been freed */

1452

for (i = 0; i < nb_drivers; i++) {

1453

sess_priv = get_asym_session_private_data(sess, i);

1454

if (sess_priv != NULL((void*)0))

1455

return -EBUSY16;

1456

}

1457

1458

/* Return session to mempool */

1459

sess_mp = rte_mempool_from_obj(sess);

1460

rte_mempool_put(sess_mp, sess);

1461

1462

return 0;

1463

}

1464

1465

unsigned int

1466

rte_cryptodev_sym_get_header_session_size(void)

1467

{

1468

1469

* Header contains pointers to the private data of all registered

1470

* drivers and all necessary information to ensure safely clear

1471

* or free al session.

1472

1473

struct rte_cryptodev_sym_session s = {0};

1474

1475

s.nb_drivers = nb_drivers;

1476

1477

return (unsigned int)(sizeof(s) +

1478

rte_cryptodev_sym_session_data_size(&s));

1479

}

1480

1481

unsigned int __rte_experimental__attribute__((section(".text.experimental")))

1482

rte_cryptodev_sym_get_existing_header_session_size(

1483

struct rte_cryptodev_sym_session *sess)

1484

{

1485

if (!sess)

1486

return 0;

1487

else

1488

return (unsigned int)(sizeof(*sess) +

1489

rte_cryptodev_sym_session_data_size(sess));

1490

}

1491

1492

unsigned int __rte_experimental__attribute__((section(".text.experimental")))

1493

rte_cryptodev_asym_get_header_session_size(void)

1494

{

1495

1496

* Header contains pointers to the private data

1497

* of all registered drivers, and a flag which

1498

* indicates presence of private data

1499

1500

return ((sizeof(void *) * nb_drivers) + sizeof(uint8_t));

1501

}

1502

1503

unsigned int

1504

rte_cryptodev_sym_get_private_session_size(uint8_t dev_id)

1505

{

1506

struct rte_cryptodev *dev;

1507

unsigned int priv_sess_size;

1508

1509

if (!rte_cryptodev_pmd_is_valid_dev(dev_id))

1510

return 0;

1511

1512

dev = rte_cryptodev_pmd_get_dev(dev_id);

1513

1514

if (*dev->dev_ops->sym_session_get_size == NULL((void*)0))

1515

return 0;

1516

1517

priv_sess_size = (*dev->dev_ops->sym_session_get_size)(dev);

1518

1519

return priv_sess_size;

1520

}

1521

1522

unsigned int __rte_experimental__attribute__((section(".text.experimental")))

1523

rte_cryptodev_asym_get_private_session_size(uint8_t dev_id)

1524

{

1525

struct rte_cryptodev *dev;

1526

unsigned int header_size = sizeof(void *) * nb_drivers;

1527

unsigned int priv_sess_size;

1528

1529

if (!rte_cryptodev_pmd_is_valid_dev(dev_id))

1530

return 0;

1531

1532

dev = rte_cryptodev_pmd_get_dev(dev_id);

1533

1534

if (*dev->dev_ops->asym_session_get_size == NULL((void*)0))

1535

return 0;

1536

1537

priv_sess_size = (*dev->dev_ops->asym_session_get_size)(dev);

1538

if (priv_sess_size < header_size)

1539

return header_size;

1540

1541

return priv_sess_size;

1542

1543

}

1544

1545

int __rte_experimental__attribute__((section(".text.experimental")))

1546

rte_cryptodev_sym_session_set_user_data(

1547

struct rte_cryptodev_sym_session *sess,

1548

void *data,

1549

uint16_t size)

1550

{

1551

if (sess == NULL((void*)0))

1552

return -EINVAL22;

1553

1554

if (sess->user_data_sz < size)

1555

return -ENOMEM12;

1556

1557

rte_memcpy(sess->sess_data + sess->nb_drivers, data, size);

1558

return 0;

1559

}

1560

1561

void * __rte_experimental__attribute__((section(".text.experimental")))

1562

rte_cryptodev_sym_session_get_user_data(

1563

struct rte_cryptodev_sym_session *sess)

1564

{

1565

if (sess == NULL((void*)0) || sess->user_data_sz == 0)

1566

return NULL((void*)0);

1567

1568

return (void *)(sess->sess_data + sess->nb_drivers);

1569

}

1570

1571

/** Initialise rte_crypto_op mempool element */

1572

static void

1573

rte_crypto_op_init(struct rte_mempool *mempool,

1574

void *opaque_arg,

1575

void *_op_data,

1576

__rte_unused__attribute__((__unused__)) unsigned i)

1577

{

1578

struct rte_crypto_op *op = _op_data;

1579

enum rte_crypto_op_type type = *(enum rte_crypto_op_type *)opaque_arg;

1580

1581

memset(_op_data, 0, mempool->elt_size);

1582

1583

__rte_crypto_op_reset(op, type);

1584

1585

op->phys_addr = rte_mem_virt2iova(_op_data);

1586

op->mempool = mempool;

1587

}

1588

1589

1590

struct rte_mempool *

1591

rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type,

1592

unsigned nb_elts, unsigned cache_size, uint16_t priv_size,

1593

int socket_id)

1594

{

1595

struct rte_crypto_op_pool_private *priv;

1596

1597

unsigned elt_size = sizeof(struct rte_crypto_op) +

1598

priv_size;

1599

1600

if (type == RTE_CRYPTO_OP_TYPE_SYMMETRIC) {

1601

elt_size += sizeof(struct rte_crypto_sym_op);

1602

} else if (type == RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {

1603

elt_size += sizeof(struct rte_crypto_asym_op);

1604

} else if (type == RTE_CRYPTO_OP_TYPE_UNDEFINED) {

1605

elt_size += RTE_MAX(sizeof(struct rte_crypto_sym_op),__extension__ ({ __typeof__ (sizeof(struct rte_crypto_sym_op)
) _a = (sizeof(struct rte_crypto_sym_op)); __typeof__ (sizeof
(struct rte_crypto_asym_op)) _b = (sizeof(struct rte_crypto_asym_op
)); _a > _b ? _a : _b; })

1606

sizeof(struct rte_crypto_asym_op))__extension__ ({ __typeof__ (sizeof(struct rte_crypto_sym_op)
) _a = (sizeof(struct rte_crypto_sym_op)); __typeof__ (sizeof
(struct rte_crypto_asym_op)) _b = (sizeof(struct rte_crypto_asym_op
)); _a > _b ? _a : _b; });

1607

} else {

1608

CDEV_LOG_ERR("Invalid op_type\n")rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Invalid op_type\n"
"\n" "%.0s", __func__, 1608, "");

1609

return NULL((void*)0);

1610

}

1611

1612

/* lookup mempool in case already allocated */

1613

struct rte_mempool *mp = rte_mempool_lookup(name);

1614

1615

if (mp != NULL((void*)0)) {

1616

priv = (struct rte_crypto_op_pool_private *)

1617

rte_mempool_get_priv(mp);

1618

1619

if (mp->elt_size != elt_size ||

1620

mp->cache_size < cache_size ||

1621

mp->size < nb_elts ||

1622

priv->priv_size < priv_size) {

1623

mp = NULL((void*)0);

1624

CDEV_LOG_ERR("Mempool %s already exists but with "rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Mempool %s already exists but with "
"incompatible parameters" "\n" "%.0s", __func__, 1625, name,
"")

1625

"incompatible parameters", name)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Mempool %s already exists but with "
"incompatible parameters" "\n" "%.0s", __func__, 1625, name,
"");

1626

return NULL((void*)0);

1627

}

1628

return mp;

1629

}

1630

1631

mp = rte_mempool_create(

1632

name,

1633

nb_elts,

1634

elt_size,

1635

cache_size,

1636

sizeof(struct rte_crypto_op_pool_private),

1637

NULL((void*)0),

1638

NULL((void*)0),

1639

rte_crypto_op_init,

1640

&type,

1641

socket_id,

1642

0);

1643

1644

if (mp == NULL((void*)0)) {

1645

CDEV_LOG_ERR("Failed to create mempool %s", name)rte_log(4U, 17, "CRYPTODEV" ": " "%s() line %u: " "Failed to create mempool %s"
"\n" "%.0s", __func__, 1645, name, "");

1646

return NULL((void*)0);

1647

}

1648

1649

priv = (struct rte_crypto_op_pool_private *)

1650

rte_mempool_get_priv(mp);

1651

1652

priv->priv_size = priv_size;

1653

priv->type = type;

1654

1655

return mp;

1656

}

1657

1658

int

1659

rte_cryptodev_pmd_create_dev_name(char *name, const char *dev_name_prefix)

1660

{

1661

struct rte_cryptodev *dev = NULL((void*)0);

1662

uint32_t i = 0;

1663

1664

if (name == NULL((void*)0))

1665

return -EINVAL22;

1666

1667

for (i = 0; i < RTE_CRYPTO_MAX_DEVS64; i++) {

1668

int ret = snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN(64),

1669

"%s_%u", dev_name_prefix, i);

1670

1671

if (ret < 0)

1672

return ret;

1673

1674

dev = rte_cryptodev_pmd_get_named_dev(name);

1675

if (!dev)

1676

return 0;

1677

}

1678

1679

return -1;

1680

}

1681

1682

TAILQ_HEAD(cryptodev_driver_list, cryptodev_driver)struct cryptodev_driver_list { struct cryptodev_driver *tqh_first
; struct cryptodev_driver * *tqh_last; };

1683

1684

static struct cryptodev_driver_list cryptodev_driver_list =

1685

TAILQ_HEAD_INITIALIZER(cryptodev_driver_list){ ((void*)0), &(cryptodev_driver_list).tqh_first };

1686

1687

int

1688

rte_cryptodev_driver_id_get(const char *name)

1689

{

1690

struct cryptodev_driver *driver;

1691

const char *driver_name;

1692

1693

if (name == NULL((void*)0)) {

1694

RTE_LOG(DEBUG, CRYPTODEV, "name pointer NULL")rte_log(8U, 17, "CRYPTODEV" ": " "name pointer NULL");

1695

return -1;

1696

}

1697

1698

TAILQ_FOREACH(driver, &cryptodev_driver_list, next)for ((driver) = ((&cryptodev_driver_list)->tqh_first);
(driver); (driver) = ((driver)->next.tqe_next)) {

1699

driver_name = driver->driver->name;

1700

if (strncmp(driver_name, name, strlen(driver_name) + 1)(__extension__ (__builtin_constant_p (strlen(driver_name) + 1
) && ((__builtin_constant_p (driver_name) && strlen
(driver_name) < ((size_t) (strlen(driver_name) + 1))) || (
__builtin_constant_p (name) && strlen (name) < ((size_t
) (strlen(driver_name) + 1)))) ? __extension__ ({ size_t __s1_len
, __s2_len; (__builtin_constant_p (driver_name) && __builtin_constant_p
(name) && (__s1_len = __builtin_strlen (driver_name)
, __s2_len = __builtin_strlen (name), (!((size_t)(const void *
)((driver_name) + 1) - (size_t)(const void *)(driver_name) ==
1) || __s1_len >= 4) && (!((size_t)(const void *)
((name) + 1) - (size_t)(const void *)(name) == 1) || __s2_len
>= 4)) ? __builtin_strcmp (driver_name, name) : (__builtin_constant_p
(driver_name) && ((size_t)(const void *)((driver_name
) + 1) - (size_t)(const void *)(driver_name) == 1) &&
(__s1_len = __builtin_strlen (driver_name), __s1_len < 4)
? (__builtin_constant_p (name) && ((size_t)(const void
*)((name) + 1) - (size_t)(const void *)(name) == 1) ? __builtin_strcmp
(driver_name, name) : (__extension__ ({ const unsigned char *
__s2 = (const unsigned char *) (const char *) (name); int __result
= (((const unsigned char *) (const char *) (driver_name))[0]
- __s2[0]); if (__s1_len > 0 && __result == 0) { __result
= (((const unsigned char *) (const char *) (driver_name))[1]
- __s2[1]); if (__s1_len > 1 && __result == 0) { __result
= (((const unsigned char *) (const char *) (driver_name))[2]
- __s2[2]); if (__s1_len > 2 && __result == 0) __result
= (((const unsigned char *) (const char *) (driver_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 (driver_name)
&& ((size_t)(const void *)((driver_name) + 1) - (size_t
)(const void *)(driver_name) == 1) ? __builtin_strcmp (driver_name
, name) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (driver_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 (driver_name, name))
)); }) : strncmp (driver_name, name, strlen(driver_name) + 1)
)) == 0)

1701

return driver->id;

1702

}

1703

return -1;

1704

}

1705

1706

const char *

1707

rte_cryptodev_name_get(uint8_t dev_id)

1708

{

1709

struct rte_cryptodev *dev = rte_cryptodev_pmd_get_dev(dev_id);

1710

1711

if (dev == NULL((void*)0))

1712

return NULL((void*)0);

1713

1714

return dev->data->name;

1715

}

1716

1717

const char *

1718

rte_cryptodev_driver_name_get(uint8_t driver_id)

1719

{

1720

struct cryptodev_driver *driver;

1721

1722

TAILQ_FOREACH(driver, &cryptodev_driver_list, next)for ((driver) = ((&cryptodev_driver_list)->tqh_first);
(driver); (driver) = ((driver)->next.tqe_next))

1723

if (driver->id == driver_id)

1724

return driver->driver->name;

1725

return NULL((void*)0);

1726

}

1727

1728

uint8_t

1729

rte_cryptodev_allocate_driver(struct cryptodev_driver *crypto_drv,

1730

const struct rte_driver *drv)

1731

{

1732

crypto_drv->driver = drv;

1733

crypto_drv->id = nb_drivers;

1734

1735

TAILQ_INSERT_TAIL(&cryptodev_driver_list, crypto_drv, next)do { (crypto_drv)->next.tqe_next = ((void*)0); (crypto_drv
)->next.tqe_prev = (&cryptodev_driver_list)->tqh_last
; *(&cryptodev_driver_list)->tqh_last = (crypto_drv); (
&cryptodev_driver_list)->tqh_last = &(crypto_drv)->
next.tqe_next; } while ( 0);

1736

1737

return nb_drivers++;

1738

}