Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/opencrypto/crypto.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: crypto.c,v 1.29.4.2 2009/05/03 17:24:45 snj Exp $ */ 2 /* $FreeBSD: src/sys/opencrypto/crypto.c,v 1.4.2.5 2003/02/26 00:14:05 sam Exp $ */ 3 /* $OpenBSD: crypto.c,v 1.41 2002/07/17 23:52:38 art Exp $ */ 4 5 /*- 6 * Copyright (c) 2008 The NetBSD Foundation, Inc. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Coyote Point Systems, Inc. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /* 35 * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu) 36 * 37 * This code was written by Angelos D. Keromytis in Athens, Greece, in 38 * February 2000. Network Security Technologies Inc. (NSTI) kindly 39 * supported the development of this code. 40 * 41 * Copyright (c) 2000, 2001 Angelos D. Keromytis 42 * 43 * Permission to use, copy, and modify this software with or without fee 44 * is hereby granted, provided that this entire notice is included in 45 * all source code copies of any software which is or includes a copy or 46 * modification of this software. 47 * 48 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR 49 * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY 50 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE 51 * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR 52 * PURPOSE. 53 */ 54 55 #include <sys/cdefs.h> 56 __KERNEL_RCSID(0, "$NetBSD: crypto.c,v 1.29.4.2 2009/05/03 17:24:45 snj Exp $"); 57 58 #include <sys/param.h> 59 #include <sys/reboot.h> 60 #include <sys/systm.h> 61 #include <sys/malloc.h> 62 #include <sys/proc.h> 63 #include <sys/pool.h> 64 #include <sys/kthread.h> 65 #include <sys/once.h> 66 #include <sys/sysctl.h> 67 #include <sys/intr.h> 68 69 #include "opt_ocf.h" 70 #include <opencrypto/cryptodev.h> 71 #include <opencrypto/xform.h> /* XXX for M_XDATA */ 72 73 kcondvar_t cryptoret_cv; 74 kmutex_t crypto_mtx; 75 76 /* below are kludges for residual code wrtitten to FreeBSD interfaces */ 77 #define SWI_CRYPTO 17 78 #define register_swi(lvl, fn) \ 79 softint_establish(SOFTINT_NET, (void (*)(void*))fn, NULL) 80 #define unregister_swi(lvl, fn) softint_disestablish(softintr_cookie) 81 #define setsoftcrypto(x) softint_schedule(x) 82 83 #define SESID2HID(sid) (((sid) >> 32) & 0xffffffff) 84 85 int crypto_ret_q_check(struct cryptop *); 86 87 /* 88 * Crypto drivers register themselves by allocating a slot in the 89 * crypto_drivers table with crypto_get_driverid() and then registering 90 * each algorithm they support with crypto_register() and crypto_kregister(). 91 */ 92 static struct cryptocap *crypto_drivers; 93 static int crypto_drivers_num; 94 static void* softintr_cookie; 95 96 /* 97 * There are two queues for crypto requests; one for symmetric (e.g. 98 * cipher) operations and one for asymmetric (e.g. MOD) operations. 99 * See below for how synchronization is handled. 100 */ 101 static TAILQ_HEAD(,cryptop) crp_q = /* request queues */ 102 TAILQ_HEAD_INITIALIZER(crp_q); 103 static TAILQ_HEAD(,cryptkop) crp_kq = 104 TAILQ_HEAD_INITIALIZER(crp_kq); 105 106 /* 107 * There are two queues for processing completed crypto requests; one 108 * for the symmetric and one for the asymmetric ops. We only need one 109 * but have two to avoid type futzing (cryptop vs. cryptkop). See below 110 * for how synchronization is handled. 111 */ 112 static TAILQ_HEAD(crprethead, cryptop) crp_ret_q = /* callback queues */ 113 TAILQ_HEAD_INITIALIZER(crp_ret_q); 114 static TAILQ_HEAD(krprethead, cryptkop) crp_ret_kq = 115 TAILQ_HEAD_INITIALIZER(crp_ret_kq); 116 117 /* 118 * XXX these functions are ghastly hacks for when the submission 119 * XXX routines discover a request that was not CBIMM is already 120 * XXX done, and must be yanked from the retq (where _done) put it 121 * XXX as cryptoret won't get the chance. The queue is walked backwards 122 * XXX as the request is generally the last one queued. 123 * 124 * call with the lock held, or else. 125 */ 126 int 127 crypto_ret_q_remove(struct cryptop *crp) 128 { 129 struct cryptop * acrp, *next; 130 131 TAILQ_FOREACH_REVERSE_SAFE(acrp, &crp_ret_q, crprethead, crp_next, next) { 132 if (acrp == crp) { 133 TAILQ_REMOVE(&crp_ret_q, crp, crp_next); 134 crp->crp_flags &= (~CRYPTO_F_ONRETQ); 135 return 1; 136 } 137 } 138 return 0; 139 } 140 141 int 142 crypto_ret_kq_remove(struct cryptkop *krp) 143 { 144 struct cryptkop * akrp, *next; 145 146 TAILQ_FOREACH_REVERSE_SAFE(akrp, &crp_ret_kq, krprethead, krp_next, next) { 147 if (akrp == krp) { 148 TAILQ_REMOVE(&crp_ret_kq, krp, krp_next); 149 krp->krp_flags &= (~CRYPTO_F_ONRETQ); 150 return 1; 151 } 152 } 153 return 0; 154 } 155 156 /* 157 * Crypto op and desciptor data structures are allocated 158 * from separate private zones(FreeBSD)/pools(netBSD/OpenBSD) . 159 */ 160 struct pool cryptop_pool; 161 struct pool cryptodesc_pool; 162 struct pool cryptkop_pool; 163 164 int crypto_usercrypto = 1; /* userland may open /dev/crypto */ 165 int crypto_userasymcrypto = 1; /* userland may do asym crypto reqs */ 166 /* 167 * cryptodevallowsoft is (intended to be) sysctl'able, controlling 168 * access to hardware versus software transforms as below: 169 * 170 * crypto_devallowsoft < 0: Force userlevel requests to use software 171 * transforms, always 172 * crypto_devallowsoft = 0: Use hardware if present, grant userlevel 173 * requests for non-accelerated transforms 174 * (handling the latter in software) 175 * crypto_devallowsoft > 0: Allow user requests only for transforms which 176 * are hardware-accelerated. 177 */ 178 int crypto_devallowsoft = 1; /* only use hardware crypto */ 179 180 SYSCTL_SETUP(sysctl_opencrypto_setup, "sysctl opencrypto subtree setup") 181 { 182 sysctl_createv(clog, 0, NULL, NULL, 183 CTLFLAG_PERMANENT, 184 CTLTYPE_NODE, "kern", NULL, 185 NULL, 0, NULL, 0, 186 CTL_KERN, CTL_EOL); 187 sysctl_createv(clog, 0, NULL, NULL, 188 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 189 CTLTYPE_INT, "usercrypto", 190 SYSCTL_DESCR("Enable/disable user-mode access to " 191 "crypto support"), 192 NULL, 0, &crypto_usercrypto, 0, 193 CTL_KERN, CTL_CREATE, CTL_EOL); 194 sysctl_createv(clog, 0, NULL, NULL, 195 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 196 CTLTYPE_INT, "userasymcrypto", 197 SYSCTL_DESCR("Enable/disable user-mode access to " 198 "asymmetric crypto support"), 199 NULL, 0, &crypto_userasymcrypto, 0, 200 CTL_KERN, CTL_CREATE, CTL_EOL); 201 sysctl_createv(clog, 0, NULL, NULL, 202 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 203 CTLTYPE_INT, "cryptodevallowsoft", 204 SYSCTL_DESCR("Enable/disable use of software " 205 "asymmetric crypto support"), 206 NULL, 0, &crypto_devallowsoft, 0, 207 CTL_KERN, CTL_CREATE, CTL_EOL); 208 } 209 210 MALLOC_DEFINE(M_CRYPTO_DATA, "crypto", "crypto session records"); 211 212 /* 213 * Synchronization: read carefully, this is non-trivial. 214 * 215 * Crypto requests are submitted via crypto_dispatch. Typically 216 * these come in from network protocols at spl0 (output path) or 217 * spl[,soft]net (input path). 218 * 219 * Requests are typically passed on the driver directly, but they 220 * may also be queued for processing by a software interrupt thread, 221 * cryptointr, that runs at splsoftcrypto. This thread dispatches 222 * the requests to crypto drivers (h/w or s/w) who call crypto_done 223 * when a request is complete. Hardware crypto drivers are assumed 224 * to register their IRQ's as network devices so their interrupt handlers 225 * and subsequent "done callbacks" happen at spl[imp,net]. 226 * 227 * Completed crypto ops are queued for a separate kernel thread that 228 * handles the callbacks at spl0. This decoupling insures the crypto 229 * driver interrupt service routine is not delayed while the callback 230 * takes place and that callbacks are delivered after a context switch 231 * (as opposed to a software interrupt that clients must block). 232 * 233 * This scheme is not intended for SMP machines. 234 */ 235 static void cryptointr(void); /* swi thread to dispatch ops */ 236 static void cryptoret(void); /* kernel thread for callbacks*/ 237 static struct lwp *cryptothread; 238 static void crypto_destroy(void); 239 static int crypto_invoke(struct cryptop *crp, int hint); 240 static int crypto_kinvoke(struct cryptkop *krp, int hint); 241 242 static struct cryptostats cryptostats; 243 #ifdef CRYPTO_TIMING 244 static int crypto_timing = 0; 245 #endif 246 247 static int 248 crypto_init0(void) 249 { 250 int error; 251 252 mutex_init(&crypto_mtx, MUTEX_DEFAULT, IPL_NET); 253 cv_init(&cryptoret_cv, "crypto_wait"); 254 pool_init(&cryptop_pool, sizeof(struct cryptop), 0, 0, 255 0, "cryptop", NULL, IPL_NET); 256 pool_init(&cryptodesc_pool, sizeof(struct cryptodesc), 0, 0, 257 0, "cryptodesc", NULL, IPL_NET); 258 pool_init(&cryptkop_pool, sizeof(struct cryptkop), 0, 0, 259 0, "cryptkop", NULL, IPL_NET); 260 261 crypto_drivers = malloc(CRYPTO_DRIVERS_INITIAL * 262 sizeof(struct cryptocap), M_CRYPTO_DATA, M_NOWAIT | M_ZERO); 263 if (crypto_drivers == NULL) { 264 printf("crypto_init: cannot malloc driver table\n"); 265 return 0; 266 } 267 crypto_drivers_num = CRYPTO_DRIVERS_INITIAL; 268 269 softintr_cookie = register_swi(SWI_CRYPTO, cryptointr); 270 error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, 271 (void (*)(void*))cryptoret, NULL, &cryptothread, "cryptoret"); 272 if (error) { 273 printf("crypto_init: cannot start cryptoret thread; error %d", 274 error); 275 crypto_destroy(); 276 } 277 278 return 0; 279 } 280 281 void 282 crypto_init(void) 283 { 284 static ONCE_DECL(crypto_init_once); 285 286 RUN_ONCE(&crypto_init_once, crypto_init0); 287 } 288 289 static void 290 crypto_destroy(void) 291 { 292 /* XXX no wait to reclaim zones */ 293 if (crypto_drivers != NULL) 294 free(crypto_drivers, M_CRYPTO_DATA); 295 unregister_swi(SWI_CRYPTO, cryptointr); 296 } 297 298 /* 299 * Create a new session. Must be called with crypto_mtx held. 300 */ 301 int 302 crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int hard) 303 { 304 struct cryptoini *cr; 305 u_int32_t hid, lid; 306 int err = EINVAL; 307 308 KASSERT(mutex_owned(&crypto_mtx)); 309 310 if (crypto_drivers == NULL) 311 goto done; 312 313 /* 314 * The algorithm we use here is pretty stupid; just use the 315 * first driver that supports all the algorithms we need. 316 * 317 * XXX We need more smarts here (in real life too, but that's 318 * XXX another story altogether). 319 */ 320 321 for (hid = 0; hid < crypto_drivers_num; hid++) { 322 /* 323 * If it's not initialized or has remaining sessions 324 * referencing it, skip. 325 */ 326 if (crypto_drivers[hid].cc_newsession == NULL || 327 (crypto_drivers[hid].cc_flags & CRYPTOCAP_F_CLEANUP)) 328 continue; 329 330 /* Hardware required -- ignore software drivers. */ 331 if (hard > 0 && 332 (crypto_drivers[hid].cc_flags & CRYPTOCAP_F_SOFTWARE)) 333 continue; 334 /* Software required -- ignore hardware drivers. */ 335 if (hard < 0 && 336 (crypto_drivers[hid].cc_flags & CRYPTOCAP_F_SOFTWARE) == 0) 337 continue; 338 339 /* See if all the algorithms are supported. */ 340 for (cr = cri; cr; cr = cr->cri_next) 341 if (crypto_drivers[hid].cc_alg[cr->cri_alg] == 0) { 342 DPRINTF(("crypto_newsession: alg %d not supported\n", cr->cri_alg)); 343 break; 344 } 345 346 if (cr == NULL) { 347 /* Ok, all algorithms are supported. */ 348 349 /* 350 * Can't do everything in one session. 351 * 352 * XXX Fix this. We need to inject a "virtual" session layer right 353 * XXX about here. 354 */ 355 356 /* Call the driver initialization routine. */ 357 lid = hid; /* Pass the driver ID. */ 358 err = crypto_drivers[hid].cc_newsession( 359 crypto_drivers[hid].cc_arg, &lid, cri); 360 if (err == 0) { 361 (*sid) = hid; 362 (*sid) <<= 32; 363 (*sid) |= (lid & 0xffffffff); 364 crypto_drivers[hid].cc_sessions++; 365 } 366 goto done; 367 /*break;*/ 368 } 369 } 370 done: 371 return err; 372 } 373 374 /* 375 * Delete an existing session (or a reserved session on an unregistered 376 * driver). Must be called with crypto_mtx mutex held. 377 */ 378 int 379 crypto_freesession(u_int64_t sid) 380 { 381 u_int32_t hid; 382 int err = 0; 383 384 KASSERT(mutex_owned(&crypto_mtx)); 385 386 if (crypto_drivers == NULL) { 387 err = EINVAL; 388 goto done; 389 } 390 391 /* Determine two IDs. */ 392 hid = SESID2HID(sid); 393 394 if (hid >= crypto_drivers_num) { 395 err = ENOENT; 396 goto done; 397 } 398 399 if (crypto_drivers[hid].cc_sessions) 400 crypto_drivers[hid].cc_sessions--; 401 402 /* Call the driver cleanup routine, if available. */ 403 if (crypto_drivers[hid].cc_freesession) { 404 err = crypto_drivers[hid].cc_freesession( 405 crypto_drivers[hid].cc_arg, sid); 406 } 407 else 408 err = 0; 409 410 /* 411 * If this was the last session of a driver marked as invalid, 412 * make the entry available for reuse. 413 */ 414 if ((crypto_drivers[hid].cc_flags & CRYPTOCAP_F_CLEANUP) && 415 crypto_drivers[hid].cc_sessions == 0) 416 bzero(&crypto_drivers[hid], sizeof(struct cryptocap)); 417 418 done: 419 return err; 420 } 421 422 /* 423 * Return an unused driver id. Used by drivers prior to registering 424 * support for the algorithms they handle. 425 */ 426 int32_t 427 crypto_get_driverid(u_int32_t flags) 428 { 429 struct cryptocap *newdrv; 430 int i; 431 432 crypto_init(); /* XXX oh, this is foul! */ 433 434 mutex_spin_enter(&crypto_mtx); 435 for (i = 0; i < crypto_drivers_num; i++) 436 if (crypto_drivers[i].cc_process == NULL && 437 (crypto_drivers[i].cc_flags & CRYPTOCAP_F_CLEANUP) == 0 && 438 crypto_drivers[i].cc_sessions == 0) 439 break; 440 441 /* Out of entries, allocate some more. */ 442 if (i == crypto_drivers_num) { 443 /* Be careful about wrap-around. */ 444 if (2 * crypto_drivers_num <= crypto_drivers_num) { 445 mutex_spin_exit(&crypto_mtx); 446 printf("crypto: driver count wraparound!\n"); 447 return -1; 448 } 449 450 newdrv = malloc(2 * crypto_drivers_num * 451 sizeof(struct cryptocap), M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 452 if (newdrv == NULL) { 453 mutex_spin_exit(&crypto_mtx); 454 printf("crypto: no space to expand driver table!\n"); 455 return -1; 456 } 457 458 bcopy(crypto_drivers, newdrv, 459 crypto_drivers_num * sizeof(struct cryptocap)); 460 461 crypto_drivers_num *= 2; 462 463 free(crypto_drivers, M_CRYPTO_DATA); 464 crypto_drivers = newdrv; 465 } 466 467 /* NB: state is zero'd on free */ 468 crypto_drivers[i].cc_sessions = 1; /* Mark */ 469 crypto_drivers[i].cc_flags = flags; 470 471 if (bootverbose) 472 printf("crypto: assign driver %u, flags %u\n", i, flags); 473 474 mutex_spin_exit(&crypto_mtx); 475 476 return i; 477 } 478 479 static struct cryptocap * 480 crypto_checkdriver(u_int32_t hid) 481 { 482 if (crypto_drivers == NULL) 483 return NULL; 484 return (hid >= crypto_drivers_num ? NULL : &crypto_drivers[hid]); 485 } 486 487 /* 488 * Register support for a key-related algorithm. This routine 489 * is called once for each algorithm supported a driver. 490 */ 491 int 492 crypto_kregister(u_int32_t driverid, int kalg, u_int32_t flags, 493 int (*kprocess)(void*, struct cryptkop *, int), 494 void *karg) 495 { 496 struct cryptocap *cap; 497 int err; 498 499 mutex_spin_enter(&crypto_mtx); 500 501 cap = crypto_checkdriver(driverid); 502 if (cap != NULL && 503 (CRK_ALGORITM_MIN <= kalg && kalg <= CRK_ALGORITHM_MAX)) { 504 /* 505 * XXX Do some performance testing to determine placing. 506 * XXX We probably need an auxiliary data structure that 507 * XXX describes relative performances. 508 */ 509 510 cap->cc_kalg[kalg] = flags | CRYPTO_ALG_FLAG_SUPPORTED; 511 if (bootverbose) { 512 printf("crypto: driver %u registers key alg %u " 513 " flags %u\n", 514 driverid, 515 kalg, 516 flags 517 ); 518 } 519 520 if (cap->cc_kprocess == NULL) { 521 cap->cc_karg = karg; 522 cap->cc_kprocess = kprocess; 523 } 524 err = 0; 525 } else 526 err = EINVAL; 527 528 mutex_spin_exit(&crypto_mtx); 529 return err; 530 } 531 532 /* 533 * Register support for a non-key-related algorithm. This routine 534 * is called once for each such algorithm supported by a driver. 535 */ 536 int 537 crypto_register(u_int32_t driverid, int alg, u_int16_t maxoplen, 538 u_int32_t flags, 539 int (*newses)(void*, u_int32_t*, struct cryptoini*), 540 int (*freeses)(void*, u_int64_t), 541 int (*process)(void*, struct cryptop *, int), 542 void *arg) 543 { 544 struct cryptocap *cap; 545 int err; 546 547 mutex_spin_enter(&crypto_mtx); 548 549 cap = crypto_checkdriver(driverid); 550 /* NB: algorithms are in the range [1..max] */ 551 if (cap != NULL && 552 (CRYPTO_ALGORITHM_MIN <= alg && alg <= CRYPTO_ALGORITHM_MAX)) { 553 /* 554 * XXX Do some performance testing to determine placing. 555 * XXX We probably need an auxiliary data structure that 556 * XXX describes relative performances. 557 */ 558 559 cap->cc_alg[alg] = flags | CRYPTO_ALG_FLAG_SUPPORTED; 560 cap->cc_max_op_len[alg] = maxoplen; 561 if (bootverbose) { 562 printf("crypto: driver %u registers alg %u " 563 "flags %u maxoplen %u\n", 564 driverid, 565 alg, 566 flags, 567 maxoplen 568 ); 569 } 570 571 if (cap->cc_process == NULL) { 572 cap->cc_arg = arg; 573 cap->cc_newsession = newses; 574 cap->cc_process = process; 575 cap->cc_freesession = freeses; 576 cap->cc_sessions = 0; /* Unmark */ 577 } 578 err = 0; 579 } else 580 err = EINVAL; 581 582 mutex_spin_exit(&crypto_mtx); 583 return err; 584 } 585 586 /* 587 * Unregister a crypto driver. If there are pending sessions using it, 588 * leave enough information around so that subsequent calls using those 589 * sessions will correctly detect the driver has been unregistered and 590 * reroute requests. 591 */ 592 int 593 crypto_unregister(u_int32_t driverid, int alg) 594 { 595 int i, err; 596 u_int32_t ses; 597 struct cryptocap *cap; 598 599 mutex_spin_enter(&crypto_mtx); 600 601 cap = crypto_checkdriver(driverid); 602 if (cap != NULL && 603 (CRYPTO_ALGORITHM_MIN <= alg && alg <= CRYPTO_ALGORITHM_MAX) && 604 cap->cc_alg[alg] != 0) { 605 cap->cc_alg[alg] = 0; 606 cap->cc_max_op_len[alg] = 0; 607 608 /* Was this the last algorithm ? */ 609 for (i = 1; i <= CRYPTO_ALGORITHM_MAX; i++) 610 if (cap->cc_alg[i] != 0) 611 break; 612 613 if (i == CRYPTO_ALGORITHM_MAX + 1) { 614 ses = cap->cc_sessions; 615 bzero(cap, sizeof(struct cryptocap)); 616 if (ses != 0) { 617 /* 618 * If there are pending sessions, just mark as invalid. 619 */ 620 cap->cc_flags |= CRYPTOCAP_F_CLEANUP; 621 cap->cc_sessions = ses; 622 } 623 } 624 err = 0; 625 } else 626 err = EINVAL; 627 628 mutex_spin_exit(&crypto_mtx); 629 return err; 630 } 631 632 /* 633 * Unregister all algorithms associated with a crypto driver. 634 * If there are pending sessions using it, leave enough information 635 * around so that subsequent calls using those sessions will 636 * correctly detect the driver has been unregistered and reroute 637 * requests. 638 * 639 * XXX careful. Don't change this to call crypto_unregister() for each 640 * XXX registered algorithm unless you drop the mutex across the calls; 641 * XXX you can't take it recursively. 642 */ 643 int 644 crypto_unregister_all(u_int32_t driverid) 645 { 646 int i, err; 647 u_int32_t ses; 648 struct cryptocap *cap; 649 650 mutex_spin_enter(&crypto_mtx); 651 cap = crypto_checkdriver(driverid); 652 if (cap != NULL) { 653 for (i = CRYPTO_ALGORITHM_MIN; i <= CRYPTO_ALGORITHM_MAX; i++) { 654 cap->cc_alg[i] = 0; 655 cap->cc_max_op_len[i] = 0; 656 } 657 ses = cap->cc_sessions; 658 bzero(cap, sizeof(struct cryptocap)); 659 if (ses != 0) { 660 /* 661 * If there are pending sessions, just mark as invalid. 662 */ 663 cap->cc_flags |= CRYPTOCAP_F_CLEANUP; 664 cap->cc_sessions = ses; 665 } 666 err = 0; 667 } else 668 err = EINVAL; 669 670 mutex_spin_exit(&crypto_mtx); 671 return err; 672 } 673 674 /* 675 * Clear blockage on a driver. The what parameter indicates whether 676 * the driver is now ready for cryptop's and/or cryptokop's. 677 */ 678 int 679 crypto_unblock(u_int32_t driverid, int what) 680 { 681 struct cryptocap *cap; 682 int needwakeup, err; 683 684 mutex_spin_enter(&crypto_mtx); 685 cap = crypto_checkdriver(driverid); 686 if (cap != NULL) { 687 needwakeup = 0; 688 if (what & CRYPTO_SYMQ) { 689 needwakeup |= cap->cc_qblocked; 690 cap->cc_qblocked = 0; 691 } 692 if (what & CRYPTO_ASYMQ) { 693 needwakeup |= cap->cc_kqblocked; 694 cap->cc_kqblocked = 0; 695 } 696 err = 0; 697 mutex_spin_exit(&crypto_mtx); 698 if (needwakeup) 699 setsoftcrypto(softintr_cookie); 700 } else { 701 err = EINVAL; 702 mutex_spin_exit(&crypto_mtx); 703 } 704 705 return err; 706 } 707 708 /* 709 * Dispatch a crypto request to a driver or queue 710 * it, to be processed by the kernel thread. 711 */ 712 int 713 crypto_dispatch(struct cryptop *crp) 714 { 715 u_int32_t hid = SESID2HID(crp->crp_sid); 716 int result; 717 718 mutex_spin_enter(&crypto_mtx); 719 DPRINTF(("crypto_dispatch: crp %08x, reqid 0x%x, alg %d\n", 720 (uint32_t)crp, 721 crp->crp_reqid, 722 crp->crp_desc->crd_alg)); 723 724 cryptostats.cs_ops++; 725 726 #ifdef CRYPTO_TIMING 727 if (crypto_timing) 728 nanouptime(&crp->crp_tstamp); 729 #endif 730 if ((crp->crp_flags & CRYPTO_F_BATCH) == 0) { 731 struct cryptocap *cap; 732 /* 733 * Caller marked the request to be processed 734 * immediately; dispatch it directly to the 735 * driver unless the driver is currently blocked. 736 */ 737 cap = crypto_checkdriver(hid); 738 if (cap && !cap->cc_qblocked) { 739 mutex_spin_exit(&crypto_mtx); 740 result = crypto_invoke(crp, 0); 741 if (result == ERESTART) { 742 /* 743 * The driver ran out of resources, mark the 744 * driver ``blocked'' for cryptop's and put 745 * the op on the queue. 746 */ 747 mutex_spin_enter(&crypto_mtx); 748 crypto_drivers[hid].cc_qblocked = 1; 749 TAILQ_INSERT_HEAD(&crp_q, crp, crp_next); 750 cryptostats.cs_blocks++; 751 mutex_spin_exit(&crypto_mtx); 752 } 753 goto out_released; 754 } else { 755 /* 756 * The driver is blocked, just queue the op until 757 * it unblocks and the swi thread gets kicked. 758 */ 759 TAILQ_INSERT_TAIL(&crp_q, crp, crp_next); 760 result = 0; 761 } 762 } else { 763 int wasempty = TAILQ_EMPTY(&crp_q); 764 /* 765 * Caller marked the request as ``ok to delay''; 766 * queue it for the swi thread. This is desirable 767 * when the operation is low priority and/or suitable 768 * for batching. 769 */ 770 TAILQ_INSERT_TAIL(&crp_q, crp, crp_next); 771 if (wasempty) { 772 mutex_spin_exit(&crypto_mtx); 773 setsoftcrypto(softintr_cookie); 774 result = 0; 775 goto out_released; 776 } 777 778 result = 0; 779 } 780 781 mutex_spin_exit(&crypto_mtx); 782 out_released: 783 return result; 784 } 785 786 /* 787 * Add an asymetric crypto request to a queue, 788 * to be processed by the kernel thread. 789 */ 790 int 791 crypto_kdispatch(struct cryptkop *krp) 792 { 793 struct cryptocap *cap; 794 int result; 795 796 mutex_spin_enter(&crypto_mtx); 797 cryptostats.cs_kops++; 798 799 cap = crypto_checkdriver(krp->krp_hid); 800 if (cap && !cap->cc_kqblocked) { 801 mutex_spin_exit(&crypto_mtx); 802 result = crypto_kinvoke(krp, 0); 803 if (result == ERESTART) { 804 /* 805 * The driver ran out of resources, mark the 806 * driver ``blocked'' for cryptop's and put 807 * the op on the queue. 808 */ 809 mutex_spin_enter(&crypto_mtx); 810 crypto_drivers[krp->krp_hid].cc_kqblocked = 1; 811 TAILQ_INSERT_HEAD(&crp_kq, krp, krp_next); 812 cryptostats.cs_kblocks++; 813 mutex_spin_exit(&crypto_mtx); 814 } 815 } else { 816 /* 817 * The driver is blocked, just queue the op until 818 * it unblocks and the swi thread gets kicked. 819 */ 820 TAILQ_INSERT_TAIL(&crp_kq, krp, krp_next); 821 result = 0; 822 mutex_spin_exit(&crypto_mtx); 823 } 824 825 return result; 826 } 827 828 /* 829 * Dispatch an assymetric crypto request to the appropriate crypto devices. 830 */ 831 static int 832 crypto_kinvoke(struct cryptkop *krp, int hint) 833 { 834 u_int32_t hid; 835 int error; 836 837 /* Sanity checks. */ 838 if (krp == NULL) 839 return EINVAL; 840 if (krp->krp_callback == NULL) { 841 cv_destroy(&krp->krp_cv); 842 pool_put(&cryptkop_pool, krp); 843 return EINVAL; 844 } 845 846 for (hid = 0; hid < crypto_drivers_num; hid++) { 847 if ((crypto_drivers[hid].cc_flags & CRYPTOCAP_F_SOFTWARE) && 848 crypto_devallowsoft == 0) 849 continue; 850 if (crypto_drivers[hid].cc_kprocess == NULL) 851 continue; 852 if ((crypto_drivers[hid].cc_kalg[krp->krp_op] & 853 CRYPTO_ALG_FLAG_SUPPORTED) == 0) 854 continue; 855 break; 856 } 857 if (hid < crypto_drivers_num) { 858 krp->krp_hid = hid; 859 error = crypto_drivers[hid].cc_kprocess( 860 crypto_drivers[hid].cc_karg, krp, hint); 861 } else { 862 error = ENODEV; 863 } 864 865 if (error) { 866 krp->krp_status = error; 867 crypto_kdone(krp); 868 } 869 return 0; 870 } 871 872 #ifdef CRYPTO_TIMING 873 static void 874 crypto_tstat(struct cryptotstat *ts, struct timespec *tv) 875 { 876 struct timespec now, t; 877 878 nanouptime(&now); 879 t.tv_sec = now.tv_sec - tv->tv_sec; 880 t.tv_nsec = now.tv_nsec - tv->tv_nsec; 881 if (t.tv_nsec < 0) { 882 t.tv_sec--; 883 t.tv_nsec += 1000000000; 884 } 885 timespecadd(&ts->acc, &t, &t); 886 if (timespeccmp(&t, &ts->min, <)) 887 ts->min = t; 888 if (timespeccmp(&t, &ts->max, >)) 889 ts->max = t; 890 ts->count++; 891 892 *tv = now; 893 } 894 #endif 895 896 /* 897 * Dispatch a crypto request to the appropriate crypto devices. 898 */ 899 static int 900 crypto_invoke(struct cryptop *crp, int hint) 901 { 902 u_int32_t hid; 903 int (*process)(void*, struct cryptop *, int); 904 905 #ifdef CRYPTO_TIMING 906 if (crypto_timing) 907 crypto_tstat(&cryptostats.cs_invoke, &crp->crp_tstamp); 908 #endif 909 /* Sanity checks. */ 910 if (crp == NULL) 911 return EINVAL; 912 if (crp->crp_callback == NULL) { 913 return EINVAL; 914 } 915 if (crp->crp_desc == NULL) { 916 crp->crp_etype = EINVAL; 917 crypto_done(crp); 918 return 0; 919 } 920 921 hid = SESID2HID(crp->crp_sid); 922 if (hid < crypto_drivers_num) { 923 mutex_spin_enter(&crypto_mtx); 924 if (crypto_drivers[hid].cc_flags & CRYPTOCAP_F_CLEANUP) 925 crypto_freesession(crp->crp_sid); 926 process = crypto_drivers[hid].cc_process; 927 mutex_spin_exit(&crypto_mtx); 928 } else { 929 process = NULL; 930 } 931 932 if (process == NULL) { 933 struct cryptodesc *crd; 934 u_int64_t nid = 0; 935 936 /* 937 * Driver has unregistered; migrate the session and return 938 * an error to the caller so they'll resubmit the op. 939 */ 940 mutex_spin_enter(&crypto_mtx); 941 for (crd = crp->crp_desc; crd->crd_next; crd = crd->crd_next) 942 crd->CRD_INI.cri_next = &(crd->crd_next->CRD_INI); 943 944 if (crypto_newsession(&nid, &(crp->crp_desc->CRD_INI), 0) == 0) 945 crp->crp_sid = nid; 946 947 crp->crp_etype = EAGAIN; 948 mutex_spin_exit(&crypto_mtx); 949 950 crypto_done(crp); 951 return 0; 952 } else { 953 /* 954 * Invoke the driver to process the request. 955 */ 956 DPRINTF(("calling process for %08x\n", (uint32_t)crp)); 957 return (*process)(crypto_drivers[hid].cc_arg, crp, hint); 958 } 959 } 960 961 /* 962 * Release a set of crypto descriptors. 963 */ 964 void 965 crypto_freereq(struct cryptop *crp) 966 { 967 struct cryptodesc *crd; 968 969 if (crp == NULL) 970 return; 971 DPRINTF(("crypto_freereq[%d]: crp %p\n", 972 (uint32_t)crp->crp_sid, crp)); 973 974 /* sanity check */ 975 if (crp->crp_flags & CRYPTO_F_ONRETQ) { 976 panic("crypto_freereq() freeing crp on RETQ\n"); 977 } 978 979 while ((crd = crp->crp_desc) != NULL) { 980 crp->crp_desc = crd->crd_next; 981 pool_put(&cryptodesc_pool, crd); 982 } 983 cv_destroy(&crp->crp_cv); 984 pool_put(&cryptop_pool, crp); 985 } 986 987 /* 988 * Acquire a set of crypto descriptors. 989 */ 990 struct cryptop * 991 crypto_getreq(int num) 992 { 993 struct cryptodesc *crd; 994 struct cryptop *crp; 995 996 crp = pool_get(&cryptop_pool, 0); 997 if (crp == NULL) { 998 return NULL; 999 } 1000 bzero(crp, sizeof(struct cryptop)); 1001 cv_init(&crp->crp_cv, "crydev"); 1002 1003 while (num--) { 1004 crd = pool_get(&cryptodesc_pool, 0); 1005 if (crd == NULL) { 1006 crypto_freereq(crp); 1007 return NULL; 1008 } 1009 1010 bzero(crd, sizeof(struct cryptodesc)); 1011 crd->crd_next = crp->crp_desc; 1012 crp->crp_desc = crd; 1013 } 1014 1015 return crp; 1016 } 1017 1018 /* 1019 * Invoke the callback on behalf of the driver. 1020 */ 1021 void 1022 crypto_done(struct cryptop *crp) 1023 { 1024 int wasempty; 1025 1026 if (crp->crp_etype != 0) 1027 cryptostats.cs_errs++; 1028 #ifdef CRYPTO_TIMING 1029 if (crypto_timing) 1030 crypto_tstat(&cryptostats.cs_done, &crp->crp_tstamp); 1031 #endif 1032 DPRINTF(("crypto_done[%d]: crp %08x\n", 1033 (uint32_t)crp->crp_sid, (uint32_t)crp)); 1034 1035 /* 1036 * Normal case; queue the callback for the thread. 1037 * 1038 * The return queue is manipulated by the swi thread 1039 * and, potentially, by crypto device drivers calling 1040 * back to mark operations completed. Thus we need 1041 * to mask both while manipulating the return queue. 1042 */ 1043 if (crp->crp_flags & CRYPTO_F_CBIMM) { 1044 /* 1045 * Do the callback directly. This is ok when the 1046 * callback routine does very little (e.g. the 1047 * /dev/crypto callback method just does a wakeup). 1048 */ 1049 mutex_spin_enter(&crypto_mtx); 1050 crp->crp_flags |= CRYPTO_F_DONE; 1051 mutex_spin_exit(&crypto_mtx); 1052 1053 #ifdef CRYPTO_TIMING 1054 if (crypto_timing) { 1055 /* 1056 * NB: We must copy the timestamp before 1057 * doing the callback as the cryptop is 1058 * likely to be reclaimed. 1059 */ 1060 struct timespec t = crp->crp_tstamp; 1061 crypto_tstat(&cryptostats.cs_cb, &t); 1062 crp->crp_callback(crp); 1063 crypto_tstat(&cryptostats.cs_finis, &t); 1064 } else 1065 #endif 1066 crp->crp_callback(crp); 1067 } else { 1068 mutex_spin_enter(&crypto_mtx); 1069 crp->crp_flags |= CRYPTO_F_DONE; 1070 1071 if (crp->crp_flags & CRYPTO_F_USER) { 1072 /* the request has completed while 1073 * running in the user context 1074 * so don't queue it - the user 1075 * thread won't sleep when it sees 1076 * the CRYPTO_F_DONE flag. 1077 * This is an optimization to avoid 1078 * unecessary context switches. 1079 */ 1080 DPRINTF(("crypto_done[%d]: crp %08x CRYPTO_F_USER\n", 1081 (uint32_t)crp->crp_sid, (uint32_t)crp)); 1082 } else { 1083 wasempty = TAILQ_EMPTY(&crp_ret_q); 1084 DPRINTF(("crypto_done[%d]: queueing %08x\n", 1085 (uint32_t)crp->crp_sid, (uint32_t)crp)); 1086 crp->crp_flags |= CRYPTO_F_ONRETQ; 1087 TAILQ_INSERT_TAIL(&crp_ret_q, crp, crp_next); 1088 if (wasempty) { 1089 DPRINTF(("crypto_done[%d]: waking cryptoret, crp %08x " \ 1090 "hit empty queue\n.", 1091 (uint32_t)crp->crp_sid, (uint32_t)crp)); 1092 cv_signal(&cryptoret_cv); 1093 } 1094 } 1095 mutex_spin_exit(&crypto_mtx); 1096 } 1097 } 1098 1099 /* 1100 * Invoke the callback on behalf of the driver. 1101 */ 1102 void 1103 crypto_kdone(struct cryptkop *krp) 1104 { 1105 int wasempty; 1106 1107 if (krp->krp_status != 0) 1108 cryptostats.cs_kerrs++; 1109 1110 krp->krp_flags |= CRYPTO_F_DONE; 1111 1112 /* 1113 * The return queue is manipulated by the swi thread 1114 * and, potentially, by crypto device drivers calling 1115 * back to mark operations completed. Thus we need 1116 * to mask both while manipulating the return queue. 1117 */ 1118 if (krp->krp_flags & CRYPTO_F_CBIMM) { 1119 krp->krp_callback(krp); 1120 } else { 1121 mutex_spin_enter(&crypto_mtx); 1122 wasempty = TAILQ_EMPTY(&crp_ret_kq); 1123 krp->krp_flags |= CRYPTO_F_ONRETQ; 1124 TAILQ_INSERT_TAIL(&crp_ret_kq, krp, krp_next); 1125 if (wasempty) 1126 cv_signal(&cryptoret_cv); 1127 mutex_spin_exit(&crypto_mtx); 1128 } 1129 } 1130 1131 int 1132 crypto_getfeat(int *featp) 1133 { 1134 int hid, kalg, feat = 0; 1135 1136 mutex_spin_enter(&crypto_mtx); 1137 1138 if (crypto_userasymcrypto == 0) 1139 goto out; 1140 1141 for (hid = 0; hid < crypto_drivers_num; hid++) { 1142 if ((crypto_drivers[hid].cc_flags & CRYPTOCAP_F_SOFTWARE) && 1143 crypto_devallowsoft == 0) { 1144 continue; 1145 } 1146 if (crypto_drivers[hid].cc_kprocess == NULL) 1147 continue; 1148 for (kalg = 0; kalg < CRK_ALGORITHM_MAX; kalg++) 1149 if ((crypto_drivers[hid].cc_kalg[kalg] & 1150 CRYPTO_ALG_FLAG_SUPPORTED) != 0) 1151 feat |= 1 << kalg; 1152 } 1153 out: 1154 mutex_spin_exit(&crypto_mtx); 1155 *featp = feat; 1156 return (0); 1157 } 1158 1159 /* 1160 * Software interrupt thread to dispatch crypto requests. 1161 */ 1162 static void 1163 cryptointr(void) 1164 { 1165 struct cryptop *crp, *submit, *cnext; 1166 struct cryptkop *krp, *knext; 1167 struct cryptocap *cap; 1168 int result, hint; 1169 1170 cryptostats.cs_intrs++; 1171 mutex_spin_enter(&crypto_mtx); 1172 do { 1173 /* 1174 * Find the first element in the queue that can be 1175 * processed and look-ahead to see if multiple ops 1176 * are ready for the same driver. 1177 */ 1178 submit = NULL; 1179 hint = 0; 1180 TAILQ_FOREACH_SAFE(crp, &crp_q, crp_next, cnext) { 1181 u_int32_t hid = SESID2HID(crp->crp_sid); 1182 cap = crypto_checkdriver(hid); 1183 if (cap == NULL || cap->cc_process == NULL) { 1184 /* Op needs to be migrated, process it. */ 1185 if (submit == NULL) 1186 submit = crp; 1187 break; 1188 } 1189 if (!cap->cc_qblocked) { 1190 if (submit != NULL) { 1191 /* 1192 * We stop on finding another op, 1193 * regardless whether its for the same 1194 * driver or not. We could keep 1195 * searching the queue but it might be 1196 * better to just use a per-driver 1197 * queue instead. 1198 */ 1199 if (SESID2HID(submit->crp_sid) == hid) 1200 hint = CRYPTO_HINT_MORE; 1201 break; 1202 } else { 1203 submit = crp; 1204 if ((submit->crp_flags & CRYPTO_F_BATCH) == 0) 1205 break; 1206 /* keep scanning for more are q'd */ 1207 } 1208 } 1209 } 1210 if (submit != NULL) { 1211 TAILQ_REMOVE(&crp_q, submit, crp_next); 1212 mutex_spin_exit(&crypto_mtx); 1213 result = crypto_invoke(submit, hint); 1214 /* we must take here as the TAILQ op or kinvoke 1215 may need this mutex below. sigh. */ 1216 mutex_spin_enter(&crypto_mtx); 1217 if (result == ERESTART) { 1218 /* 1219 * The driver ran out of resources, mark the 1220 * driver ``blocked'' for cryptop's and put 1221 * the request back in the queue. It would 1222 * best to put the request back where we got 1223 * it but that's hard so for now we put it 1224 * at the front. This should be ok; putting 1225 * it at the end does not work. 1226 */ 1227 /* XXX validate sid again? */ 1228 crypto_drivers[SESID2HID(submit->crp_sid)].cc_qblocked = 1; 1229 TAILQ_INSERT_HEAD(&crp_q, submit, crp_next); 1230 cryptostats.cs_blocks++; 1231 } 1232 } 1233 1234 /* As above, but for key ops */ 1235 TAILQ_FOREACH_SAFE(krp, &crp_kq, krp_next, knext) { 1236 cap = crypto_checkdriver(krp->krp_hid); 1237 if (cap == NULL || cap->cc_kprocess == NULL) { 1238 /* Op needs to be migrated, process it. */ 1239 break; 1240 } 1241 if (!cap->cc_kqblocked) 1242 break; 1243 } 1244 if (krp != NULL) { 1245 TAILQ_REMOVE(&crp_kq, krp, krp_next); 1246 mutex_spin_exit(&crypto_mtx); 1247 result = crypto_kinvoke(krp, 0); 1248 /* the next iteration will want the mutex. :-/ */ 1249 mutex_spin_enter(&crypto_mtx); 1250 if (result == ERESTART) { 1251 /* 1252 * The driver ran out of resources, mark the 1253 * driver ``blocked'' for cryptkop's and put 1254 * the request back in the queue. It would 1255 * best to put the request back where we got 1256 * it but that's hard so for now we put it 1257 * at the front. This should be ok; putting 1258 * it at the end does not work. 1259 */ 1260 /* XXX validate sid again? */ 1261 crypto_drivers[krp->krp_hid].cc_kqblocked = 1; 1262 TAILQ_INSERT_HEAD(&crp_kq, krp, krp_next); 1263 cryptostats.cs_kblocks++; 1264 } 1265 } 1266 } while (submit != NULL || krp != NULL); 1267 mutex_spin_exit(&crypto_mtx); 1268 } 1269 1270 /* 1271 * Kernel thread to do callbacks. 1272 */ 1273 static void 1274 cryptoret(void) 1275 { 1276 struct cryptop *crp; 1277 struct cryptkop *krp; 1278 1279 mutex_spin_enter(&crypto_mtx); 1280 for (;;) { 1281 crp = TAILQ_FIRST(&crp_ret_q); 1282 if (crp != NULL) { 1283 TAILQ_REMOVE(&crp_ret_q, crp, crp_next); 1284 crp->crp_flags &= ~CRYPTO_F_ONRETQ; 1285 } 1286 krp = TAILQ_FIRST(&crp_ret_kq); 1287 if (krp != NULL) { 1288 TAILQ_REMOVE(&crp_ret_kq, krp, krp_next); 1289 krp->krp_flags &= ~CRYPTO_F_ONRETQ; 1290 } 1291 1292 /* drop before calling any callbacks. */ 1293 if (crp == NULL && krp == NULL) { 1294 cryptostats.cs_rets++; 1295 cv_wait(&cryptoret_cv, &crypto_mtx); 1296 continue; 1297 } 1298 1299 mutex_spin_exit(&crypto_mtx); 1300 1301 if (crp != NULL) { 1302 #ifdef CRYPTO_TIMING 1303 if (crypto_timing) { 1304 /* 1305 * NB: We must copy the timestamp before 1306 * doing the callback as the cryptop is 1307 * likely to be reclaimed. 1308 */ 1309 struct timespec t = crp->crp_tstamp; 1310 crypto_tstat(&cryptostats.cs_cb, &t); 1311 crp->crp_callback(crp); 1312 crypto_tstat(&cryptostats.cs_finis, &t); 1313 } else 1314 #endif 1315 { 1316 crp->crp_callback(crp); 1317 } 1318 } 1319 if (krp != NULL) 1320 krp->krp_callback(krp); 1321 1322 mutex_spin_enter(&crypto_mtx); 1323 } 1324 }
Cache object: 2658cc3ceb7be1e05ecd15210b16a313
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]