projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[kernel] ocf: move all stuff into files, and fix build error on .25
[openwrt.git] / target / linux / generic-2.6 / files / crypto / ocf / ep80579 / icp_sym.c
1 /***************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
8 * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
22 * The full GNU General Public License is included in this distribution
23 * in the file called LICENSE.GPL.
24 *
25 * Contact Information:
26 * Intel Corporation
27 *
28 * BSD LICENSE
29 *
30 * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
31 * All rights reserved.
32 *
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions
35 * are met:
36 *
37 * * Redistributions of source code must retain the above copyright
38 * notice, this list of conditions and the following disclaimer.
39 * * Redistributions in binary form must reproduce the above copyright
40 * notice, this list of conditions and the following disclaimer in
41 * the documentation and/or other materials provided with the
42 * distribution.
43 * * Neither the name of Intel Corporation nor the names of its
44 * contributors may be used to endorse or promote products derived
45 * from this software without specific prior written permission.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
48 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
49 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
50 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
51 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
54 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
55 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
56 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
57 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
58 *
59 *
60 * version: Security.L.1.0.130
61 *
62 ***************************************************************************/
63 /*
64 * An OCF module that uses the API for Intel® QuickAssist Technology to do the
65 * cryptography.
66 *
67 * This driver requires the ICP Access Library that is available from Intel in
68 * order to operate.
69 */
70
71 #include "icp_ocf.h"
72
73 /*This is the call back function for all symmetric cryptographic processes.
74 Its main functionality is to free driver crypto operation structure and to
75 call back to OCF*/
76 static void
77 icp_ocfDrvSymCallBack(void *callbackTag,
78 CpaStatus status,
79 const CpaCySymOp operationType,
80 void *pOpData,
81 CpaBufferList * pDstBuffer, CpaBoolean verifyResult);
82
83 /*This function is used to extract crypto processing information from the OCF
84 inputs, so as that it may be passed onto LAC*/
85 static int
86 icp_ocfDrvProcessDataSetup(struct icp_drvOpData *drvOpData,
87 struct cryptodesc *crp_desc);
88
89 /*This function checks whether the crp_desc argument pertains to a digest or a
90 cipher operation*/
91 static int icp_ocfDrvAlgCheck(struct cryptodesc *crp_desc);
92
93 /*This function copies all the passed in session context information and stores
94 it in a LAC context structure*/
95 static int
96 icp_ocfDrvAlgorithmSetup(struct cryptoini *cri,
97 CpaCySymSessionSetupData * lacSessCtx);
98
99 /*This top level function is used to find a pointer to where a digest is
100 stored/needs to be inserted. */
101 static uint8_t *icp_ocfDrvDigestPointerFind(struct icp_drvOpData *drvOpData,
102 struct cryptodesc *crp_desc);
103
104 /*This function is called when a digest pointer has to be found within a
105 SKBUFF.*/
106 static inline uint8_t *icp_ocfDrvSkbuffDigestPointerFind(struct icp_drvOpData
107 *drvOpData,
108 int offsetInBytes,
109 uint32_t
110 digestSizeInBytes);
111
112 /*The following two functions are called if the SKBUFF digest pointer is not
113 positioned in the linear portion of the buffer (i.e. it is in a linked SKBUFF
114 or page fragment).*/
115 /*This function takes care of the page fragment case.*/
116 static inline uint8_t *icp_ocfDrvDigestSkbNRFragsCheck(struct sk_buff *skb,
117 struct skb_shared_info
118 *skb_shared,
119 int offsetInBytes,
120 uint32_t
121 digestSizeInBytes);
122
123 /*This function takes care of the linked list case.*/
124 static inline uint8_t *icp_ocfDrvDigestSkbFragListCheck(struct sk_buff *skb,
125 struct skb_shared_info
126 *skb_shared,
127 int offsetInBytes,
128 uint32_t
129 digestSizeInBytes);
130
131 /*This function is used to free an OCF->OCF_DRV session object*/
132 static void icp_ocfDrvFreeOCFSession(struct icp_drvSessionData *sessionData);
133
134 /*max IOV buffs supported in a UIO structure*/
135 #define NUM_IOV_SUPPORTED (1)
136
137 /* Name : icp_ocfDrvSymCallBack
138 *
139 * Description : When this function returns it signifies that the LAC
140 * component has completed the relevant symmetric operation.
141 *
142 * Notes : The callbackTag is a pointer to an icp_drvOpData. This memory
143 * object was passed to LAC for the cryptographic processing and contains all
144 * the relevant information for cleaning up buffer handles etc. so that the
145 * OCF Tolapai Driver portion of this crypto operation can be fully completed.
146 */
147 static void
148 icp_ocfDrvSymCallBack(void *callbackTag,
149 CpaStatus status,
150 const CpaCySymOp operationType,
151 void *pOpData,
152 CpaBufferList * pDstBuffer, CpaBoolean verifyResult)
153 {
154 struct cryptop *crp = NULL;
155 struct icp_drvOpData *temp_drvOpData =
156 (struct icp_drvOpData *)callbackTag;
157 uint64_t *tempBasePtr = NULL;
158 uint32_t tempLen = 0;
159
160 if (NULL == temp_drvOpData) {
161 DPRINTK("%s(): The callback from the LAC component"
162 " has failed due to Null userOpaque data"
163 "(status == %d).\n", __FUNCTION__, status);
164 DPRINTK("%s(): Unable to call OCF back! \n", __FUNCTION__);
165 return;
166 }
167
168 crp = temp_drvOpData->crp;
169 crp->crp_etype = ICP_OCF_DRV_NO_CRYPTO_PROCESS_ERROR;
170
171 if (NULL == pOpData) {
172 DPRINTK("%s(): The callback from the LAC component"
173 " has failed due to Null Symmetric Op data"
174 "(status == %d).\n", __FUNCTION__, status);
175 crp->crp_etype = ECANCELED;
176 crypto_done(crp);
177 return;
178 }
179
180 if (NULL == pDstBuffer) {
181 DPRINTK("%s(): The callback from the LAC component"
182 " has failed due to Null Dst Bufferlist data"
183 "(status == %d).\n", __FUNCTION__, status);
184 crp->crp_etype = ECANCELED;
185 crypto_done(crp);
186 return;
187 }
188
189 if (CPA_STATUS_SUCCESS == status) {
190
191 if (temp_drvOpData->bufferType == CRYPTO_F_SKBUF) {
192 if (ICP_OCF_DRV_STATUS_SUCCESS !=
193 icp_ocfDrvBufferListToSkBuff(pDstBuffer,
194 (struct sk_buff **)
195 &(crp->crp_buf))) {
196 EPRINTK("%s(): BufferList to SkBuff "
197 "conversion error.\n", __FUNCTION__);
198 crp->crp_etype = EPERM;
199 }
200 } else {
201 icp_ocfDrvBufferListToPtrAndLen(pDstBuffer,
202 (void **)&tempBasePtr,
203 &tempLen);
204 crp->crp_olen = (int)tempLen;
205 }
206
207 } else {
208 DPRINTK("%s(): The callback from the LAC component has failed"
209 "(status == %d).\n", __FUNCTION__, status);
210
211 crp->crp_etype = ECANCELED;
212 }
213
214 if (temp_drvOpData->numBufferListArray >
215 ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS) {
216 kfree(pDstBuffer->pBuffers);
217 }
218 icp_ocfDrvFreeMetaData(pDstBuffer);
219 kmem_cache_free(drvOpData_zone, temp_drvOpData);
220
221 /* Invoke the OCF callback function */
222 crypto_done(crp);
223
224 return;
225 }
226
227 /* Name : icp_ocfDrvNewSession
228 *
229 * Description : This function will create a new Driver<->OCF session
230 *
231 * Notes : LAC session registration happens during the first perform call.
232 * That is the first time we know all information about a given session.
233 */
234 int icp_ocfDrvNewSession(device_t dev, uint32_t * sid, struct cryptoini *cri)
235 {
236 struct icp_drvSessionData *sessionData = NULL;
237 uint32_t delete_session = 0;
238
239 /* The SID passed in should be our driver ID. We can return the */
240 /* local ID (LID) which is a unique identifier which we can use */
241 /* to differentiate between the encrypt/decrypt LAC session handles */
242 if (NULL == sid) {
243 EPRINTK("%s(): Invalid input parameters - NULL sid.\n",
244 __FUNCTION__);
245 return EINVAL;
246 }
247
248 if (NULL == cri) {
249 EPRINTK("%s(): Invalid input parameters - NULL cryptoini.\n",
250 __FUNCTION__);
251 return EINVAL;
252 }
253
254 if (icp_ocfDrvDriverId != *sid) {
255 EPRINTK("%s(): Invalid input parameters - bad driver ID\n",
256 __FUNCTION__);
257 EPRINTK("\t sid = 0x08%p \n \t cri = 0x08%p \n", sid, cri);
258 return EINVAL;
259 }
260
261 sessionData = kmem_cache_zalloc(drvSessionData_zone, GFP_ATOMIC);
262 if (NULL == sessionData) {
263 DPRINTK("%s():No memory for Session Data\n", __FUNCTION__);
264 return ENOMEM;
265 }
266
267 /*ENTER CRITICAL SECTION */
268 spin_lock_bh(&icp_ocfDrvSymSessInfoListSpinlock);
269 /*put this check in the spinlock so no new sessions can be added to the
270 linked list when we are exiting */
271 if (CPA_TRUE == atomic_read(&icp_ocfDrvIsExiting)) {
272 delete_session++;
273
274 } else if (NO_OCF_TO_DRV_MAX_SESSIONS != max_sessions) {
275 if (atomic_read(&num_ocf_to_drv_registered_sessions) >=
276 (max_sessions -
277 atomic_read(&lac_session_failed_dereg_count))) {
278 delete_session++;
279 } else {
280 atomic_inc(&num_ocf_to_drv_registered_sessions);
281 /* Add to session data linked list */
282 list_add(&(sessionData->listNode),
283 &icp_ocfDrvGlobalSymListHead);
284 }
285
286 } else if (NO_OCF_TO_DRV_MAX_SESSIONS == max_sessions) {
287 list_add(&(sessionData->listNode),
288 &icp_ocfDrvGlobalSymListHead);
289 }
290
291 sessionData->inUse = ICP_SESSION_INITIALISED;
292
293 /*EXIT CRITICAL SECTION */
294 spin_unlock_bh(&icp_ocfDrvSymSessInfoListSpinlock);
295
296 if (delete_session) {
297 DPRINTK("%s():No Session handles available\n", __FUNCTION__);
298 kmem_cache_free(drvSessionData_zone, sessionData);
299 return EPERM;
300 }
301
302 if (ICP_OCF_DRV_STATUS_SUCCESS !=
303 icp_ocfDrvAlgorithmSetup(cri, &(sessionData->lacSessCtx))) {
304 DPRINTK("%s():algorithm not supported\n", __FUNCTION__);
305 icp_ocfDrvFreeOCFSession(sessionData);
306 return EINVAL;
307 }
308
309 if (cri->cri_next) {
310 if (cri->cri_next->cri_next != NULL) {
311 DPRINTK("%s():only two chained algorithms supported\n",
312 __FUNCTION__);
313 icp_ocfDrvFreeOCFSession(sessionData);
314 return EPERM;
315 }
316
317 if (ICP_OCF_DRV_STATUS_SUCCESS !=
318 icp_ocfDrvAlgorithmSetup(cri->cri_next,
319 &(sessionData->lacSessCtx))) {
320 DPRINTK("%s():second algorithm not supported\n",
321 __FUNCTION__);
322 icp_ocfDrvFreeOCFSession(sessionData);
323 return EINVAL;
324 }
325
326 sessionData->lacSessCtx.symOperation =
327 CPA_CY_SYM_OP_ALGORITHM_CHAINING;
328 }
329
330 *sid = (uint32_t) sessionData;
331
332 return ICP_OCF_DRV_STATUS_SUCCESS;
333 }
334
335 /* Name : icp_ocfDrvAlgorithmSetup
336 *
337 * Description : This function builds the session context data from the
338 * information supplied through OCF. Algorithm chain order and whether the
339 * session is Encrypt/Decrypt can only be found out at perform time however, so
340 * the session is registered with LAC at that time.
341 */
342 static int
343 icp_ocfDrvAlgorithmSetup(struct cryptoini *cri,
344 CpaCySymSessionSetupData * lacSessCtx)
345 {
346
347 lacSessCtx->sessionPriority = CPA_CY_PRIORITY_NORMAL;
348
349 switch (cri->cri_alg) {
350
351 case CRYPTO_NULL_CBC:
352 DPRINTK("%s(): NULL CBC\n", __FUNCTION__);
353 lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
354 lacSessCtx->cipherSetupData.cipherAlgorithm =
355 CPA_CY_SYM_CIPHER_NULL;
356 lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
357 cri->cri_klen / NUM_BITS_IN_BYTE;
358 lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
359 break;
360
361 case CRYPTO_DES_CBC:
362 DPRINTK("%s(): DES CBC\n", __FUNCTION__);
363 lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
364 lacSessCtx->cipherSetupData.cipherAlgorithm =
365 CPA_CY_SYM_CIPHER_DES_CBC;
366 lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
367 cri->cri_klen / NUM_BITS_IN_BYTE;
368 lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
369 break;
370
371 case CRYPTO_3DES_CBC:
372 DPRINTK("%s(): 3DES CBC\n", __FUNCTION__);
373 lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
374 lacSessCtx->cipherSetupData.cipherAlgorithm =
375 CPA_CY_SYM_CIPHER_3DES_CBC;
376 lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
377 cri->cri_klen / NUM_BITS_IN_BYTE;
378 lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
379 break;
380
381 case CRYPTO_AES_CBC:
382 DPRINTK("%s(): AES CBC\n", __FUNCTION__);
383 lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
384 lacSessCtx->cipherSetupData.cipherAlgorithm =
385 CPA_CY_SYM_CIPHER_AES_CBC;
386 lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
387 cri->cri_klen / NUM_BITS_IN_BYTE;
388 lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
389 break;
390
391 case CRYPTO_ARC4:
392 DPRINTK("%s(): ARC4\n", __FUNCTION__);
393 lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
394 lacSessCtx->cipherSetupData.cipherAlgorithm =
395 CPA_CY_SYM_CIPHER_ARC4;
396 lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
397 cri->cri_klen / NUM_BITS_IN_BYTE;
398 lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
399 break;
400
401 case CRYPTO_SHA1:
402 DPRINTK("%s(): SHA1\n", __FUNCTION__);
403 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
404 lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_SHA1;
405 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
406 lacSessCtx->hashSetupData.digestResultLenInBytes =
407 (cri->cri_mlen ?
408 cri->cri_mlen : ICP_SHA1_DIGEST_SIZE_IN_BYTES);
409
410 break;
411
412 case CRYPTO_SHA1_HMAC:
413 DPRINTK("%s(): SHA1_HMAC\n", __FUNCTION__);
414 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
415 lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_SHA1;
416 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
417 lacSessCtx->hashSetupData.digestResultLenInBytes =
418 (cri->cri_mlen ?
419 cri->cri_mlen : ICP_SHA1_DIGEST_SIZE_IN_BYTES);
420 lacSessCtx->hashSetupData.authModeSetupData.authKey =
421 cri->cri_key;
422 lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
423 cri->cri_klen / NUM_BITS_IN_BYTE;
424 lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
425
426 break;
427
428 case CRYPTO_SHA2_256:
429 DPRINTK("%s(): SHA256\n", __FUNCTION__);
430 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
431 lacSessCtx->hashSetupData.hashAlgorithm =
432 CPA_CY_SYM_HASH_SHA256;
433 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
434 lacSessCtx->hashSetupData.digestResultLenInBytes =
435 (cri->cri_mlen ?
436 cri->cri_mlen : ICP_SHA256_DIGEST_SIZE_IN_BYTES);
437
438 break;
439
440 case CRYPTO_SHA2_256_HMAC:
441 DPRINTK("%s(): SHA256_HMAC\n", __FUNCTION__);
442 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
443 lacSessCtx->hashSetupData.hashAlgorithm =
444 CPA_CY_SYM_HASH_SHA256;
445 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
446 lacSessCtx->hashSetupData.digestResultLenInBytes =
447 (cri->cri_mlen ?
448 cri->cri_mlen : ICP_SHA256_DIGEST_SIZE_IN_BYTES);
449 lacSessCtx->hashSetupData.authModeSetupData.authKey =
450 cri->cri_key;
451 lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
452 cri->cri_klen / NUM_BITS_IN_BYTE;
453 lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
454
455 break;
456
457 case CRYPTO_SHA2_384:
458 DPRINTK("%s(): SHA384\n", __FUNCTION__);
459 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
460 lacSessCtx->hashSetupData.hashAlgorithm =
461 CPA_CY_SYM_HASH_SHA384;
462 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
463 lacSessCtx->hashSetupData.digestResultLenInBytes =
464 (cri->cri_mlen ?
465 cri->cri_mlen : ICP_SHA384_DIGEST_SIZE_IN_BYTES);
466
467 break;
468
469 case CRYPTO_SHA2_384_HMAC:
470 DPRINTK("%s(): SHA384_HMAC\n", __FUNCTION__);
471 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
472 lacSessCtx->hashSetupData.hashAlgorithm =
473 CPA_CY_SYM_HASH_SHA384;
474 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
475 lacSessCtx->hashSetupData.digestResultLenInBytes =
476 (cri->cri_mlen ?
477 cri->cri_mlen : ICP_SHA384_DIGEST_SIZE_IN_BYTES);
478 lacSessCtx->hashSetupData.authModeSetupData.authKey =
479 cri->cri_key;
480 lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
481 cri->cri_klen / NUM_BITS_IN_BYTE;
482 lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
483
484 break;
485
486 case CRYPTO_SHA2_512:
487 DPRINTK("%s(): SHA512\n", __FUNCTION__);
488 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
489 lacSessCtx->hashSetupData.hashAlgorithm =
490 CPA_CY_SYM_HASH_SHA512;
491 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
492 lacSessCtx->hashSetupData.digestResultLenInBytes =
493 (cri->cri_mlen ?
494 cri->cri_mlen : ICP_SHA512_DIGEST_SIZE_IN_BYTES);
495
496 break;
497
498 case CRYPTO_SHA2_512_HMAC:
499 DPRINTK("%s(): SHA512_HMAC\n", __FUNCTION__);
500 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
501 lacSessCtx->hashSetupData.hashAlgorithm =
502 CPA_CY_SYM_HASH_SHA512;
503 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
504 lacSessCtx->hashSetupData.digestResultLenInBytes =
505 (cri->cri_mlen ?
506 cri->cri_mlen : ICP_SHA512_DIGEST_SIZE_IN_BYTES);
507 lacSessCtx->hashSetupData.authModeSetupData.authKey =
508 cri->cri_key;
509 lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
510 cri->cri_klen / NUM_BITS_IN_BYTE;
511 lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
512
513 break;
514
515 case CRYPTO_MD5:
516 DPRINTK("%s(): MD5\n", __FUNCTION__);
517 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
518 lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_MD5;
519 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
520 lacSessCtx->hashSetupData.digestResultLenInBytes =
521 (cri->cri_mlen ?
522 cri->cri_mlen : ICP_MD5_DIGEST_SIZE_IN_BYTES);
523
524 break;
525
526 case CRYPTO_MD5_HMAC:
527 DPRINTK("%s(): MD5_HMAC\n", __FUNCTION__);
528 lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
529 lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_MD5;
530 lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
531 lacSessCtx->hashSetupData.digestResultLenInBytes =
532 (cri->cri_mlen ?
533 cri->cri_mlen : ICP_MD5_DIGEST_SIZE_IN_BYTES);
534 lacSessCtx->hashSetupData.authModeSetupData.authKey =
535 cri->cri_key;
536 lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
537 cri->cri_klen / NUM_BITS_IN_BYTE;
538 lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
539
540 break;
541
542 default:
543 DPRINTK("%s(): ALG Setup FAIL\n", __FUNCTION__);
544 return ICP_OCF_DRV_STATUS_FAIL;
545 }
546
547 return ICP_OCF_DRV_STATUS_SUCCESS;
548 }
549
550 /* Name : icp_ocfDrvFreeOCFSession
551 *
552 * Description : This function deletes all existing Session data representing
553 * the Cryptographic session established between OCF and this driver. This
554 * also includes freeing the memory allocated for the session context. The
555 * session object is also removed from the session linked list.
556 */
557 static void icp_ocfDrvFreeOCFSession(struct icp_drvSessionData *sessionData)
558 {
559
560 sessionData->inUse = ICP_SESSION_DEREGISTERED;
561
562 /*ENTER CRITICAL SECTION */
563 spin_lock_bh(&icp_ocfDrvSymSessInfoListSpinlock);
564
565 if (CPA_TRUE == atomic_read(&icp_ocfDrvIsExiting)) {
566 /*If the Driver is exiting, allow that process to
567 handle any deletions */
568 /*EXIT CRITICAL SECTION */
569 spin_unlock_bh(&icp_ocfDrvSymSessInfoListSpinlock);
570 return;
571 }
572
573 atomic_dec(&num_ocf_to_drv_registered_sessions);
574
575 list_del(&(sessionData->listNode));
576
577 /*EXIT CRITICAL SECTION */
578 spin_unlock_bh(&icp_ocfDrvSymSessInfoListSpinlock);
579
580 if (NULL != sessionData->sessHandle) {
581 kfree(sessionData->sessHandle);
582 }
583 kmem_cache_free(drvSessionData_zone, sessionData);
584 }
585
586 /* Name : icp_ocfDrvFreeLACSession
587 *
588 * Description : This attempts to deregister a LAC session. If it fails, the
589 * deregistation retry function is called.
590 */
591 int icp_ocfDrvFreeLACSession(device_t dev, uint64_t sid)
592 {
593 CpaCySymSessionCtx sessionToDeregister = NULL;
594 struct icp_drvSessionData *sessionData = NULL;
595 CpaStatus lacStatus = CPA_STATUS_SUCCESS;
596 int retval = 0;
597
598 sessionData = (struct icp_drvSessionData *)CRYPTO_SESID2LID(sid);
599 if (NULL == sessionData) {
600 EPRINTK("%s(): OCF Free session called with Null Session ID.\n",
601 __FUNCTION__);
602 return EINVAL;
603 }
604
605 sessionToDeregister = sessionData->sessHandle;
606
607 if (ICP_SESSION_INITIALISED == sessionData->inUse) {
608 DPRINTK("%s() Session not registered with LAC\n", __FUNCTION__);
609 } else if (NULL == sessionData->sessHandle) {
610 EPRINTK
611 ("%s(): OCF Free session called with Null Session Handle.\n",
612 __FUNCTION__);
613 return EINVAL;
614 } else {
615 lacStatus = cpaCySymRemoveSession(CPA_INSTANCE_HANDLE_SINGLE,
616 sessionToDeregister);
617 if (CPA_STATUS_RETRY == lacStatus) {
618 if (ICP_OCF_DRV_STATUS_SUCCESS !=
619 icp_ocfDrvDeregRetry(&sessionToDeregister)) {
620 /* the retry function increments the
621 dereg failed count */
622 DPRINTK("%s(): LAC failed to deregister the "
623 "session. (localSessionId= %p)\n",
624 __FUNCTION__, sessionToDeregister);
625 retval = EPERM;
626 }
627
628 } else if (CPA_STATUS_SUCCESS != lacStatus) {
629 DPRINTK("%s(): LAC failed to deregister the session. "
630 "localSessionId= %p, lacStatus = %d\n",
631 __FUNCTION__, sessionToDeregister, lacStatus);
632 atomic_inc(&lac_session_failed_dereg_count);
633 retval = EPERM;
634 }
635 }
636
637 icp_ocfDrvFreeOCFSession(sessionData);
638 return retval;
639
640 }
641
642 /* Name : icp_ocfDrvAlgCheck
643 *
644 * Description : This function checks whether the cryptodesc argument pertains
645 * to a sym or hash function
646 */
647 static int icp_ocfDrvAlgCheck(struct cryptodesc *crp_desc)
648 {
649
650 if (crp_desc->crd_alg == CRYPTO_3DES_CBC ||
651 crp_desc->crd_alg == CRYPTO_AES_CBC ||
652 crp_desc->crd_alg == CRYPTO_DES_CBC ||
653 crp_desc->crd_alg == CRYPTO_NULL_CBC ||
654 crp_desc->crd_alg == CRYPTO_ARC4) {
655 return ICP_OCF_DRV_ALG_CIPHER;
656 }
657
658 return ICP_OCF_DRV_ALG_HASH;
659 }
660
661 /* Name : icp_ocfDrvSymProcess
662 *
663 * Description : This function will map symmetric functionality calls from OCF
664 * to the LAC API. It will also allocate memory to store the session context.
665 *
666 * Notes: If it is the first perform call for a given session, then a LAC
667 * session is registered. After the session is registered, no checks as
668 * to whether session paramaters have changed (e.g. alg chain order) are
669 * done.
670 */
671 int icp_ocfDrvSymProcess(device_t dev, struct cryptop *crp, int hint)
672 {
673 struct icp_drvSessionData *sessionData = NULL;
674 struct icp_drvOpData *drvOpData = NULL;
675 CpaStatus lacStatus = CPA_STATUS_SUCCESS;
676 Cpa32U sessionCtxSizeInBytes = 0;
677 uint16_t numBufferListArray = 0;
678
679 if (NULL == crp) {
680 DPRINTK("%s(): Invalid input parameters, cryptop is NULL\n",
681 __FUNCTION__);
682 return EINVAL;
683 }
684
685 if (NULL == crp->crp_desc) {
686 DPRINTK("%s(): Invalid input parameters, no crp_desc attached "
687 "to crp\n", __FUNCTION__);
688 crp->crp_etype = EINVAL;
689 return EINVAL;
690 }
691
692 if (NULL == crp->crp_buf) {
693 DPRINTK("%s(): Invalid input parameters, no buffer attached "
694 "to crp\n", __FUNCTION__);
695 crp->crp_etype = EINVAL;
696 return EINVAL;
697 }
698
699 if (CPA_TRUE == atomic_read(&icp_ocfDrvIsExiting)) {
700 crp->crp_etype = EFAULT;
701 return EFAULT;
702 }
703
704 sessionData = (struct icp_drvSessionData *)
705 (CRYPTO_SESID2LID(crp->crp_sid));
706 if (NULL == sessionData) {
707 DPRINTK("%s(): Invalid input parameters, Null Session ID \n",
708 __FUNCTION__);
709 crp->crp_etype = EINVAL;
710 return EINVAL;
711 }
712
713 /*If we get a request against a deregisted session, cancel operation*/
714 if (ICP_SESSION_DEREGISTERED == sessionData->inUse) {
715 DPRINTK("%s(): Session ID %d was deregistered \n",
716 __FUNCTION__, (int)(CRYPTO_SESID2LID(crp->crp_sid)));
717 crp->crp_etype = EFAULT;
718 return EFAULT;
719 }
720
721 /*If none of the session states are set, then the session structure was either
722 not initialised properly or we are reading from a freed memory area (possible
723 due to OCF batch mode not removing queued requests against deregistered
724 sessions*/
725 if (ICP_SESSION_INITIALISED != sessionData->inUse &&
726 ICP_SESSION_RUNNING != sessionData->inUse) {
727 DPRINTK("%s(): Session - ID %d - not properly initialised or "
728 "memory freed back to the kernel \n",
729 __FUNCTION__, (int)(CRYPTO_SESID2LID(crp->crp_sid)));
730 crp->crp_etype = EINVAL;
731 return EINVAL;
732 }
733
734 /*For the below checks, remember error checking is already done in LAC.
735 We're not validating inputs subsequent to registration */
736 if (sessionData->inUse == ICP_SESSION_INITIALISED) {
737 DPRINTK("%s(): Initialising session\n", __FUNCTION__);
738
739 if (NULL != crp->crp_desc->crd_next) {
740 if (ICP_OCF_DRV_ALG_CIPHER ==
741 icp_ocfDrvAlgCheck(crp->crp_desc)) {
742
743 sessionData->lacSessCtx.algChainOrder =
744 CPA_CY_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH;
745
746 if (crp->crp_desc->crd_flags & CRD_F_ENCRYPT) {
747 sessionData->lacSessCtx.cipherSetupData.
748 cipherDirection =
749 CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT;
750 } else {
751 sessionData->lacSessCtx.cipherSetupData.
752 cipherDirection =
753 CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT;
754 }
755 } else {
756 sessionData->lacSessCtx.algChainOrder =
757 CPA_CY_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER;
758
759 if (crp->crp_desc->crd_next->crd_flags &
760 CRD_F_ENCRYPT) {
761 sessionData->lacSessCtx.cipherSetupData.
762 cipherDirection =
763 CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT;
764 } else {
765 sessionData->lacSessCtx.cipherSetupData.
766 cipherDirection =
767 CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT;
768 }
769
770 }
771
772 } else if (ICP_OCF_DRV_ALG_CIPHER ==
773 icp_ocfDrvAlgCheck(crp->crp_desc)) {
774 if (crp->crp_desc->crd_flags & CRD_F_ENCRYPT) {
775 sessionData->lacSessCtx.cipherSetupData.
776 cipherDirection =
777 CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT;
778 } else {
779 sessionData->lacSessCtx.cipherSetupData.
780 cipherDirection =
781 CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT;
782 }
783
784 }
785
786 /*No action required for standalone Auth here */
787
788 /* Allocate memory for SymSessionCtx before the Session Registration */
789 lacStatus =
790 cpaCySymSessionCtxGetSize(CPA_INSTANCE_HANDLE_SINGLE,
791 &(sessionData->lacSessCtx),
792 &sessionCtxSizeInBytes);
793 if (CPA_STATUS_SUCCESS != lacStatus) {
794 EPRINTK("%s(): cpaCySymSessionCtxGetSize failed - %d\n",
795 __FUNCTION__, lacStatus);
796 return EINVAL;
797 }
798 sessionData->sessHandle =
799 kmalloc(sessionCtxSizeInBytes, GFP_ATOMIC);
800 if (NULL == sessionData->sessHandle) {
801 EPRINTK
802 ("%s(): Failed to get memory for SymSessionCtx\n",
803 __FUNCTION__);
804 return ENOMEM;
805 }
806
807 lacStatus = cpaCySymInitSession(CPA_INSTANCE_HANDLE_SINGLE,
808 icp_ocfDrvSymCallBack,
809 &(sessionData->lacSessCtx),
810 sessionData->sessHandle);
811
812 if (CPA_STATUS_SUCCESS != lacStatus) {
813 EPRINTK("%s(): cpaCySymInitSession failed -%d \n",
814 __FUNCTION__, lacStatus);
815 return EFAULT;
816 }
817
818 sessionData->inUse = ICP_SESSION_RUNNING;
819 }
820
821 drvOpData = kmem_cache_zalloc(drvOpData_zone, GFP_ATOMIC);
822 if (NULL == drvOpData) {
823 EPRINTK("%s():Failed to get memory for drvOpData\n",
824 __FUNCTION__);
825 crp->crp_etype = ENOMEM;
826 return ENOMEM;
827 }
828
829 drvOpData->lacOpData.pSessionCtx = sessionData->sessHandle;
830 drvOpData->digestSizeInBytes = sessionData->lacSessCtx.hashSetupData.
831 digestResultLenInBytes;
832 drvOpData->crp = crp;
833
834 /* Set the default buffer list array memory allocation */
835 drvOpData->srcBuffer.pBuffers = drvOpData->bufferListArray;
836 drvOpData->numBufferListArray = ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS;
837
838 /*
839 * Allocate buffer list array memory allocation if the
840 * data fragment is more than the default allocation
841 */
842 if (crp->crp_flags & CRYPTO_F_SKBUF) {
843 numBufferListArray = icp_ocfDrvGetSkBuffFrags((struct sk_buff *)
844 crp->crp_buf);
845 if (ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS < numBufferListArray) {
846 DPRINTK("%s() numBufferListArray more than default\n",
847 __FUNCTION__);
848 drvOpData->srcBuffer.pBuffers = NULL;
849 drvOpData->srcBuffer.pBuffers =
850 kmalloc(numBufferListArray *
851 sizeof(CpaFlatBuffer), GFP_ATOMIC);
852 if (NULL == drvOpData->srcBuffer.pBuffers) {
853 EPRINTK("%s() Failed to get memory for "
854 "pBuffers\n", __FUNCTION__);
855 kmem_cache_free(drvOpData_zone, drvOpData);
856 crp->crp_etype = ENOMEM;
857 return ENOMEM;
858 }
859 drvOpData->numBufferListArray = numBufferListArray;
860 }
861 }
862
863 /*
864 * Check the type of buffer structure we got and convert it into
865 * CpaBufferList format.
866 */
867 if (crp->crp_flags & CRYPTO_F_SKBUF) {
868 if (ICP_OCF_DRV_STATUS_SUCCESS !=
869 icp_ocfDrvSkBuffToBufferList((struct sk_buff *)crp->crp_buf,
870 &(drvOpData->srcBuffer))) {
871 EPRINTK("%s():Failed to translate from SK_BUF "
872 "to bufferlist\n", __FUNCTION__);
873 crp->crp_etype = EINVAL;
874 goto err;
875 }
876
877 drvOpData->bufferType = CRYPTO_F_SKBUF;
878 } else if (crp->crp_flags & CRYPTO_F_IOV) {
879 /* OCF only supports IOV of one entry. */
880 if (NUM_IOV_SUPPORTED ==
881 ((struct uio *)(crp->crp_buf))->uio_iovcnt) {
882
883 icp_ocfDrvPtrAndLenToBufferList(((struct uio *)(crp->
884 crp_buf))->
885 uio_iov[0].iov_base,
886 ((struct uio *)(crp->
887 crp_buf))->
888 uio_iov[0].iov_len,
889 &(drvOpData->
890 srcBuffer));
891
892 drvOpData->bufferType = CRYPTO_F_IOV;
893
894 } else {
895 DPRINTK("%s():Unable to handle IOVs with lengths of "
896 "greater than one!\n", __FUNCTION__);
897 crp->crp_etype = EINVAL;
898 goto err;
899 }
900
901 } else {
902 icp_ocfDrvPtrAndLenToBufferList(crp->crp_buf,
903 crp->crp_ilen,
904 &(drvOpData->srcBuffer));
905
906 drvOpData->bufferType = CRYPTO_BUF_CONTIG;
907 }
908
909 if (ICP_OCF_DRV_STATUS_SUCCESS !=
910 icp_ocfDrvProcessDataSetup(drvOpData, drvOpData->crp->crp_desc)) {
911 crp->crp_etype = EINVAL;
912 goto err;
913 }
914
915 if (drvOpData->crp->crp_desc->crd_next != NULL) {
916 if (icp_ocfDrvProcessDataSetup(drvOpData, drvOpData->crp->
917 crp_desc->crd_next)) {
918 crp->crp_etype = EINVAL;
919 goto err;
920 }
921
922 }
923
924 /* Allocate srcBuffer's private meta data */
925 if (ICP_OCF_DRV_STATUS_SUCCESS !=
926 icp_ocfDrvAllocMetaData(&(drvOpData->srcBuffer), drvOpData)) {
927 EPRINTK("%s() icp_ocfDrvAllocMetaData failed\n", __FUNCTION__);
928 memset(&(drvOpData->lacOpData), 0, sizeof(CpaCySymOpData));
929 crp->crp_etype = EINVAL;
930 goto err;
931 }
932
933 /* Perform "in-place" crypto operation */
934 lacStatus = cpaCySymPerformOp(CPA_INSTANCE_HANDLE_SINGLE,
935 (void *)drvOpData,
936 &(drvOpData->lacOpData),
937 &(drvOpData->srcBuffer),
938 &(drvOpData->srcBuffer),
939 &(drvOpData->verifyResult));
940 if (CPA_STATUS_RETRY == lacStatus) {
941 DPRINTK("%s(): cpaCySymPerformOp retry, lacStatus = %d\n",
942 __FUNCTION__, lacStatus);
943 memset(&(drvOpData->lacOpData), 0, sizeof(CpaCySymOpData));
944 crp->crp_etype = EINVAL;
945 goto err;
946 }
947 if (CPA_STATUS_SUCCESS != lacStatus) {
948 EPRINTK("%s(): cpaCySymPerformOp failed, lacStatus = %d\n",
949 __FUNCTION__, lacStatus);
950 memset(&(drvOpData->lacOpData), 0, sizeof(CpaCySymOpData));
951 crp->crp_etype = EINVAL;
952 goto err;
953 }
954
955 return 0; //OCF success status value
956
957 err:
958 if (drvOpData->numBufferListArray > ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS) {
959 kfree(drvOpData->srcBuffer.pBuffers);
960 }
961 icp_ocfDrvFreeMetaData(&(drvOpData->srcBuffer));
962 kmem_cache_free(drvOpData_zone, drvOpData);
963
964 return crp->crp_etype;
965 }
966
967 /* Name : icp_ocfDrvProcessDataSetup
968 *
969 * Description : This function will setup all the cryptographic operation data
970 * that is required by LAC to execute the operation.
971 */
972 static int icp_ocfDrvProcessDataSetup(struct icp_drvOpData *drvOpData,
973 struct cryptodesc *crp_desc)
974 {
975 CpaCyRandGenOpData randGenOpData;
976 CpaFlatBuffer randData;
977
978 drvOpData->lacOpData.packetType = CPA_CY_SYM_PACKET_TYPE_FULL;
979
980 /* Convert from the cryptop to the ICP LAC crypto parameters */
981 switch (crp_desc->crd_alg) {
982 case CRYPTO_NULL_CBC:
983 drvOpData->lacOpData.
984 cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
985 drvOpData->lacOpData.
986 messageLenToCipherInBytes = crp_desc->crd_len;
987 drvOpData->verifyResult = CPA_FALSE;
988 drvOpData->lacOpData.ivLenInBytes = NULL_BLOCK_LEN;
989 break;
990 case CRYPTO_DES_CBC:
991 drvOpData->lacOpData.
992 cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
993 drvOpData->lacOpData.
994 messageLenToCipherInBytes = crp_desc->crd_len;
995 drvOpData->verifyResult = CPA_FALSE;
996 drvOpData->lacOpData.ivLenInBytes = DES_BLOCK_LEN;
997 break;
998 case CRYPTO_3DES_CBC:
999 drvOpData->lacOpData.
1000 cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
1001 drvOpData->lacOpData.
1002 messageLenToCipherInBytes = crp_desc->crd_len;
1003 drvOpData->verifyResult = CPA_FALSE;
1004 drvOpData->lacOpData.ivLenInBytes = DES3_BLOCK_LEN;
1005 break;
1006 case CRYPTO_ARC4:
1007 drvOpData->lacOpData.
1008 cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
1009 drvOpData->lacOpData.
1010 messageLenToCipherInBytes = crp_desc->crd_len;
1011 drvOpData->verifyResult = CPA_FALSE;
1012 drvOpData->lacOpData.ivLenInBytes = ARC4_COUNTER_LEN;
1013 break;
1014 case CRYPTO_AES_CBC:
1015 drvOpData->lacOpData.
1016 cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
1017 drvOpData->lacOpData.
1018 messageLenToCipherInBytes = crp_desc->crd_len;
1019 drvOpData->verifyResult = CPA_FALSE;
1020 drvOpData->lacOpData.ivLenInBytes = RIJNDAEL128_BLOCK_LEN;
1021 break;
1022 case CRYPTO_SHA1:
1023 case CRYPTO_SHA1_HMAC:
1024 case CRYPTO_SHA2_256:
1025 case CRYPTO_SHA2_256_HMAC:
1026 case CRYPTO_SHA2_384:
1027 case CRYPTO_SHA2_384_HMAC:
1028 case CRYPTO_SHA2_512:
1029 case CRYPTO_SHA2_512_HMAC:
1030 case CRYPTO_MD5:
1031 case CRYPTO_MD5_HMAC:
1032 drvOpData->lacOpData.
1033 hashStartSrcOffsetInBytes = crp_desc->crd_skip;
1034 drvOpData->lacOpData.
1035 messageLenToHashInBytes = crp_desc->crd_len;
1036 drvOpData->lacOpData.
1037 pDigestResult =
1038 icp_ocfDrvDigestPointerFind(drvOpData, crp_desc);
1039
1040 if (NULL == drvOpData->lacOpData.pDigestResult) {
1041 DPRINTK("%s(): ERROR - could not calculate "
1042 "Digest Result memory address\n", __FUNCTION__);
1043 return ICP_OCF_DRV_STATUS_FAIL;
1044 }
1045
1046 drvOpData->lacOpData.digestVerify = CPA_FALSE;
1047 break;
1048 default:
1049 DPRINTK("%s(): Crypto process error - algorithm not "
1050 "found \n", __FUNCTION__);
1051 return ICP_OCF_DRV_STATUS_FAIL;
1052 }
1053
1054 /* Figure out what the IV is supposed to be */
1055 if ((crp_desc->crd_alg == CRYPTO_DES_CBC) ||
1056 (crp_desc->crd_alg == CRYPTO_3DES_CBC) ||
1057 (crp_desc->crd_alg == CRYPTO_AES_CBC)) {
1058 /*ARC4 doesn't use an IV */
1059 if (crp_desc->crd_flags & CRD_F_IV_EXPLICIT) {
1060 /* Explicit IV provided to OCF */
1061 drvOpData->lacOpData.pIv = crp_desc->crd_iv;
1062 } else {
1063 /* IV is not explicitly provided to OCF */
1064
1065 /* Point the LAC OP Data IV pointer to our allocated
1066 storage location for this session. */
1067 drvOpData->lacOpData.pIv = drvOpData->ivData;
1068
1069 if ((crp_desc->crd_flags & CRD_F_ENCRYPT) &&
1070 ((crp_desc->crd_flags & CRD_F_IV_PRESENT) == 0)) {
1071
1072 /* Encrypting - need to create IV */
1073 randGenOpData.generateBits = CPA_TRUE;
1074 randGenOpData.lenInBytes = MAX_IV_LEN_IN_BYTES;
1075
1076 icp_ocfDrvPtrAndLenToFlatBuffer((Cpa8U *)
1077 drvOpData->
1078 ivData,
1079 MAX_IV_LEN_IN_BYTES,
1080 &randData);
1081
1082 if (CPA_STATUS_SUCCESS !=
1083 cpaCyRandGen(CPA_INSTANCE_HANDLE_SINGLE,
1084 NULL, NULL,
1085 &randGenOpData, &randData)) {
1086 DPRINTK("%s(): ERROR - Failed to"
1087 " generate"
1088 " Initialisation Vector\n",
1089 __FUNCTION__);
1090 return ICP_OCF_DRV_STATUS_FAIL;
1091 }
1092
1093 crypto_copyback(drvOpData->crp->
1094 crp_flags,
1095 drvOpData->crp->crp_buf,
1096 crp_desc->crd_inject,
1097 drvOpData->lacOpData.
1098 ivLenInBytes,
1099 (caddr_t) (drvOpData->lacOpData.
1100 pIv));
1101 } else {
1102 /* Reading IV from buffer */
1103 crypto_copydata(drvOpData->crp->
1104 crp_flags,
1105 drvOpData->crp->crp_buf,
1106 crp_desc->crd_inject,
1107 drvOpData->lacOpData.
1108 ivLenInBytes,
1109 (caddr_t) (drvOpData->lacOpData.
1110 pIv));
1111 }
1112
1113 }
1114
1115 }
1116
1117 return ICP_OCF_DRV_STATUS_SUCCESS;
1118 }
1119
1120 /* Name : icp_ocfDrvDigestPointerFind
1121 *
1122 * Description : This function is used to find the memory address of where the
1123 * digest information shall be stored in. Input buffer types are an skbuff, iov
1124 * or flat buffer. The address is found using the buffer data start address and
1125 * an offset.
1126 *
1127 * Note: In the case of a linux skbuff, the digest address may exist within
1128 * a memory space linked to from the start buffer. These linked memory spaces
1129 * must be traversed by the data length offset in order to find the digest start
1130 * address. Whether there is enough space for the digest must also be checked.
1131 */
1132
1133 static uint8_t *icp_ocfDrvDigestPointerFind(struct icp_drvOpData *drvOpData,
1134 struct cryptodesc *crp_desc)
1135 {
1136
1137 int offsetInBytes = crp_desc->crd_inject;
1138 uint32_t digestSizeInBytes = drvOpData->digestSizeInBytes;
1139 uint8_t *flat_buffer_base = NULL;
1140 int flat_buffer_length = 0;
1141 struct sk_buff *skb;
1142
1143 if (drvOpData->crp->crp_flags & CRYPTO_F_SKBUF) {
1144 /*check if enough overall space to store hash */
1145 skb = (struct sk_buff *)(drvOpData->crp->crp_buf);
1146
1147 if (skb->len < (offsetInBytes + digestSizeInBytes)) {
1148 DPRINTK("%s() Not enough space for Digest"
1149 " payload after the offset (%d), "
1150 "digest size (%d) \n", __FUNCTION__,
1151 offsetInBytes, digestSizeInBytes);
1152 return NULL;
1153 }
1154
1155 return icp_ocfDrvSkbuffDigestPointerFind(drvOpData,
1156 offsetInBytes,
1157 digestSizeInBytes);
1158
1159 } else {
1160 /* IOV or flat buffer */
1161 if (drvOpData->crp->crp_flags & CRYPTO_F_IOV) {
1162 /*single IOV check has already been done */
1163 flat_buffer_base = ((struct uio *)
1164 (drvOpData->crp->crp_buf))->
1165 uio_iov[0].iov_base;
1166 flat_buffer_length = ((struct uio *)
1167 (drvOpData->crp->crp_buf))->
1168 uio_iov[0].iov_len;
1169 } else {
1170 flat_buffer_base = (uint8_t *) drvOpData->crp->crp_buf;
1171 flat_buffer_length = drvOpData->crp->crp_ilen;
1172 }
1173
1174 if (flat_buffer_length < (offsetInBytes + digestSizeInBytes)) {
1175 DPRINTK("%s() Not enough space for Digest "
1176 "(IOV/Flat Buffer) \n", __FUNCTION__);
1177 return NULL;
1178 } else {
1179 return (uint8_t *) (flat_buffer_base + offsetInBytes);
1180 }
1181 }
1182 DPRINTK("%s() Should not reach this point\n", __FUNCTION__);
1183 return NULL;
1184 }
1185
1186 /* Name : icp_ocfDrvSkbuffDigestPointerFind
1187 *
1188 * Description : This function is used by icp_ocfDrvDigestPointerFind to process
1189 * the non-linear portion of the skbuff if the fragmentation type is a linked
1190 * list (frag_list is not NULL in the skb_shared_info structure)
1191 */
1192 static inline uint8_t *icp_ocfDrvSkbuffDigestPointerFind(struct icp_drvOpData
1193 *drvOpData,
1194 int offsetInBytes,
1195 uint32_t
1196 digestSizeInBytes)
1197 {
1198
1199 struct sk_buff *skb = NULL;
1200 struct skb_shared_info *skb_shared = NULL;
1201
1202 uint32_t skbuffisnonlinear = 0;
1203
1204 uint32_t skbheadlen = 0;
1205
1206 skb = (struct sk_buff *)(drvOpData->crp->crp_buf);
1207 skbuffisnonlinear = skb_is_nonlinear(skb);
1208
1209 skbheadlen = skb_headlen(skb);
1210
1211 /*Linear skb checks */
1212 if (skbheadlen > offsetInBytes) {
1213
1214 if (skbheadlen >= (offsetInBytes + digestSizeInBytes)) {
1215 return (uint8_t *) (skb->data + offsetInBytes);
1216 } else {
1217 DPRINTK("%s() Auth payload stretches "
1218 "accross contiguous memory\n", __FUNCTION__);
1219 return NULL;
1220 }
1221 } else {
1222 if (skbuffisnonlinear) {
1223 offsetInBytes -= skbheadlen;
1224 } else {
1225 DPRINTK("%s() Offset outside of buffer boundaries\n",
1226 __FUNCTION__);
1227 return NULL;
1228 }
1229 }
1230
1231 /*Non Linear checks */
1232 skb_shared = (struct skb_shared_info *)(skb->end);
1233 if (unlikely(NULL == skb_shared)) {
1234 DPRINTK("%s() skbuff shared info stucture is NULL! \n",
1235 __FUNCTION__);
1236 return NULL;
1237 } else if ((0 != skb_shared->nr_frags) &&
1238 (skb_shared->frag_list != NULL)) {
1239 DPRINTK("%s() skbuff nr_frags AND "
1240 "frag_list not supported \n", __FUNCTION__);
1241 return NULL;
1242 }
1243
1244 /*TCP segmentation more likely than IP fragmentation */
1245 if (likely(0 != skb_shared->nr_frags)) {
1246 return icp_ocfDrvDigestSkbNRFragsCheck(skb, skb_shared,
1247 offsetInBytes,
1248 digestSizeInBytes);
1249 } else if (skb_shared->frag_list != NULL) {
1250 return icp_ocfDrvDigestSkbFragListCheck(skb, skb_shared,
1251 offsetInBytes,
1252 digestSizeInBytes);
1253 } else {
1254 DPRINTK("%s() skbuff is non-linear but does not show any "
1255 "linked data\n", __FUNCTION__);
1256 return NULL;
1257 }
1258
1259 }
1260
1261 /* Name : icp_ocfDrvDigestSkbNRFragsCheck
1262 *
1263 * Description : This function is used by icp_ocfDrvSkbuffDigestPointerFind to
1264 * process the non-linear portion of the skbuff, if the fragmentation type is
1265 * page fragments
1266 */
1267 static inline uint8_t *icp_ocfDrvDigestSkbNRFragsCheck(struct sk_buff *skb,
1268 struct skb_shared_info
1269 *skb_shared,
1270 int offsetInBytes,
1271 uint32_t
1272 digestSizeInBytes)
1273 {
1274 int i = 0;
1275 /*nr_frags starts from 1 */
1276 if (MAX_SKB_FRAGS < skb_shared->nr_frags) {
1277 DPRINTK("%s error processing skbuff "
1278 "page frame -- MAX FRAGS exceeded \n", __FUNCTION__);
1279 return NULL;
1280 }
1281
1282 for (i = 0; i < skb_shared->nr_frags; i++) {
1283
1284 if (offsetInBytes >= skb_shared->frags[i].size) {
1285 /*offset still greater than data position */
1286 offsetInBytes -= skb_shared->frags[i].size;
1287 } else {
1288 /* found the page containing start of hash */
1289
1290 if (NULL == skb_shared->frags[i].page) {
1291 DPRINTK("%s() Linked page is NULL!\n",
1292 __FUNCTION__);
1293 return NULL;
1294 }
1295
1296 if (offsetInBytes + digestSizeInBytes >
1297 skb_shared->frags[i].size) {
1298 DPRINTK("%s() Auth payload stretches accross "
1299 "contiguous memory\n", __FUNCTION__);
1300 return NULL;
1301 } else {
1302 return (uint8_t *) (skb_shared->frags[i].page +
1303 skb_shared->frags[i].
1304 page_offset +
1305 offsetInBytes);
1306 }
1307 }
1308 /*only possible if internal page sizes are set wrong */
1309 if (offsetInBytes < 0) {
1310 DPRINTK("%s error processing skbuff page frame "
1311 "-- offset calculation \n", __FUNCTION__);
1312 return NULL;
1313 }
1314 }
1315 /*only possible if internal page sizes are set wrong */
1316 DPRINTK("%s error processing skbuff page frame "
1317 "-- ran out of page fragments, remaining offset = %d \n",
1318 __FUNCTION__, offsetInBytes);
1319 return NULL;
1320
1321 }
1322
1323 /* Name : icp_ocfDrvDigestSkbFragListCheck
1324 *
1325 * Description : This function is used by icp_ocfDrvSkbuffDigestPointerFind to
1326 * process the non-linear portion of the skbuff, if the fragmentation type is
1327 * a linked list
1328 *
1329 */
1330 static inline uint8_t *icp_ocfDrvDigestSkbFragListCheck(struct sk_buff *skb,
1331 struct skb_shared_info
1332 *skb_shared,
1333 int offsetInBytes,
1334 uint32_t
1335 digestSizeInBytes)
1336 {
1337
1338 struct sk_buff *skb_list = skb_shared->frag_list;
1339 /*check added for readability */
1340 if (NULL == skb_list) {
1341 DPRINTK("%s error processing skbuff "
1342 "-- no more list! \n", __FUNCTION__);
1343 return NULL;
1344 }
1345
1346 for (; skb_list; skb_list = skb_list->next) {
1347 if (NULL == skb_list) {
1348 DPRINTK("%s error processing skbuff "
1349 "-- no more list! \n", __FUNCTION__);
1350 return NULL;
1351 }
1352
1353 if (offsetInBytes >= skb_list->len) {
1354 offsetInBytes -= skb_list->len;
1355
1356 } else {
1357 if (offsetInBytes + digestSizeInBytes > skb_list->len) {
1358 DPRINTK("%s() Auth payload stretches accross "
1359 "contiguous memory\n", __FUNCTION__);
1360 return NULL;
1361 } else {
1362 return (uint8_t *)
1363 (skb_list->data + offsetInBytes);
1364 }
1365
1366 }
1367
1368 /*This check is only needed if internal skb_list length values
1369 are set wrong. */
1370 if (0 > offsetInBytes) {
1371 DPRINTK("%s() error processing skbuff object -- offset "
1372 "calculation \n", __FUNCTION__);
1373 return NULL;
1374 }
1375
1376 }
1377
1378 /*catch all for unusual for-loop exit.
1379 This code should never be reached */
1380 DPRINTK("%s() Catch-All hit! Process error.\n", __FUNCTION__);
1381 return NULL;
1382 }
Personal OpenWRT clone
This page took 0.122823 seconds and 5 git commands to generate.