Home | History | Annotate | Line # | Download | only in opencrypto
cryptodev.c revision 1.102
      1  1.102    hikaru /*	$NetBSD: cryptodev.c,v 1.102 2019/11/29 08:30:30 hikaru Exp $ */
      2    1.4  jonathan /*	$FreeBSD: src/sys/opencrypto/cryptodev.c,v 1.4.2.4 2003/06/03 00:09:02 sam Exp $	*/
      3    1.1  jonathan /*	$OpenBSD: cryptodev.c,v 1.53 2002/07/10 22:21:30 mickey Exp $	*/
      4    1.1  jonathan 
      5   1.36       tls /*-
      6   1.36       tls  * Copyright (c) 2008 The NetBSD Foundation, Inc.
      7   1.36       tls  * All rights reserved.
      8   1.36       tls  *
      9   1.36       tls  * This code is derived from software contributed to The NetBSD Foundation
     10   1.36       tls  * by Coyote Point Systems, Inc.
     11   1.36       tls  *
     12   1.36       tls  * Redistribution and use in source and binary forms, with or without
     13   1.36       tls  * modification, are permitted provided that the following conditions
     14   1.36       tls  * are met:
     15   1.36       tls  * 1. Redistributions of source code must retain the above copyright
     16   1.36       tls  *    notice, this list of conditions and the following disclaimer.
     17   1.36       tls  * 2. Redistributions in binary form must reproduce the above copyright
     18   1.36       tls  *    notice, this list of conditions and the following disclaimer in the
     19   1.36       tls  *    documentation and/or other materials provided with the distribution.
     20   1.36       tls  *
     21   1.36       tls  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     22   1.36       tls  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     23   1.36       tls  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     24   1.36       tls  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     25   1.36       tls  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26   1.36       tls  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27   1.36       tls  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28   1.36       tls  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29   1.36       tls  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30   1.36       tls  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     31   1.36       tls  * POSSIBILITY OF SUCH DAMAGE.
     32   1.36       tls  */
     33   1.36       tls 
     34    1.1  jonathan /*
     35    1.1  jonathan  * Copyright (c) 2001 Theo de Raadt
     36    1.1  jonathan  *
     37    1.1  jonathan  * Redistribution and use in source and binary forms, with or without
     38    1.1  jonathan  * modification, are permitted provided that the following conditions
     39    1.1  jonathan  * are met:
     40    1.1  jonathan  *
     41    1.1  jonathan  * 1. Redistributions of source code must retain the above copyright
     42    1.1  jonathan  *   notice, this list of conditions and the following disclaimer.
     43    1.1  jonathan  * 2. Redistributions in binary form must reproduce the above copyright
     44    1.1  jonathan  *   notice, this list of conditions and the following disclaimer in the
     45    1.1  jonathan  *   documentation and/or other materials provided with the distribution.
     46    1.1  jonathan  * 3. The name of the author may not be used to endorse or promote products
     47    1.1  jonathan  *   derived from this software without specific prior written permission.
     48    1.1  jonathan  *
     49    1.1  jonathan  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     50    1.1  jonathan  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     51    1.1  jonathan  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     52    1.1  jonathan  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     53    1.1  jonathan  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     54    1.1  jonathan  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     55    1.1  jonathan  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     56    1.1  jonathan  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     57    1.1  jonathan  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     58    1.1  jonathan  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     59    1.1  jonathan  *
     60    1.1  jonathan  * Effort sponsored in part by the Defense Advanced Research Projects
     61    1.1  jonathan  * Agency (DARPA) and Air Force Research Laboratory, Air Force
     62    1.1  jonathan  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
     63    1.1  jonathan  *
     64    1.1  jonathan  */
     65    1.1  jonathan 
     66    1.1  jonathan #include <sys/cdefs.h>
     67  1.102    hikaru __KERNEL_RCSID(0, "$NetBSD: cryptodev.c,v 1.102 2019/11/29 08:30:30 hikaru Exp $");
     68    1.1  jonathan 
     69    1.1  jonathan #include <sys/param.h>
     70    1.1  jonathan #include <sys/systm.h>
     71   1.36       tls #include <sys/kmem.h>
     72    1.1  jonathan #include <sys/malloc.h>
     73    1.1  jonathan #include <sys/mbuf.h>
     74   1.29       tls #include <sys/pool.h>
     75    1.1  jonathan #include <sys/sysctl.h>
     76    1.1  jonathan #include <sys/file.h>
     77    1.1  jonathan #include <sys/filedesc.h>
     78    1.1  jonathan #include <sys/errno.h>
     79    1.2  jonathan #include <sys/md5.h>
     80    1.1  jonathan #include <sys/sha1.h>
     81    1.1  jonathan #include <sys/conf.h>
     82    1.1  jonathan #include <sys/device.h>
     83   1.21      elad #include <sys/kauth.h>
     84   1.36       tls #include <sys/select.h>
     85   1.36       tls #include <sys/poll.h>
     86   1.37    dogcow #include <sys/atomic.h>
     87   1.48  christos #include <sys/stat.h>
     88   1.70  pgoyette #include <sys/module.h>
     89   1.99  pgoyette #include <sys/compat_stub.h>
     90    1.1  jonathan 
     91   1.70  pgoyette #ifdef _KERNEL_OPT
     92   1.33       tls #include "opt_ocf.h"
     93   1.55  drochner #include "opt_compat_netbsd.h"
     94   1.70  pgoyette #endif
     95   1.70  pgoyette 
     96    1.1  jonathan #include <opencrypto/cryptodev.h>
     97   1.99  pgoyette #include <opencrypto/ocryptodev.h>
     98   1.55  drochner #include <opencrypto/cryptodev_internal.h>
     99    1.1  jonathan #include <opencrypto/xform.h>
    100    1.1  jonathan 
    101   1.84  christos #include "ioconf.h"
    102   1.84  christos 
    103   1.92  knakahar kmutex_t cryptodev_mtx;
    104   1.89  knakahar 
    105    1.1  jonathan struct csession {
    106    1.1  jonathan 	TAILQ_ENTRY(csession) next;
    107    1.1  jonathan 	u_int64_t	sid;
    108    1.1  jonathan 	u_int32_t	ses;
    109    1.1  jonathan 
    110   1.46    darran 	u_int32_t	cipher;		/* note: shares name space in crd_alg */
    111   1.54  drochner 	const struct enc_xform *txform;
    112   1.46    darran 	u_int32_t	mac;		/* note: shares name space in crd_alg */
    113   1.54  drochner 	const struct auth_hash *thash;
    114   1.46    darran 	u_int32_t	comp_alg;	/* note: shares name space in crd_alg */
    115   1.54  drochner 	const struct comp_algo *tcomp;
    116    1.1  jonathan 
    117   1.26  christos 	void *		key;
    118    1.1  jonathan 	int		keylen;
    119    1.1  jonathan 	u_char		tmp_iv[EALG_MAX_BLOCK_LEN];
    120    1.1  jonathan 
    121   1.26  christos 	void *		mackey;
    122    1.1  jonathan 	int		mackeylen;
    123    1.1  jonathan 	u_char		tmp_mac[CRYPTO_MAX_MAC_LEN];
    124    1.1  jonathan 
    125   1.29       tls 	struct iovec	iovec[1];	/* user requests never have more */
    126    1.1  jonathan 	struct uio	uio;
    127    1.1  jonathan 	int		error;
    128    1.1  jonathan };
    129    1.1  jonathan 
    130    1.1  jonathan struct fcrypt {
    131    1.1  jonathan 	TAILQ_HEAD(csessionlist, csession) csessions;
    132   1.36       tls 	TAILQ_HEAD(crprethead, cryptop) crp_ret_mq;
    133   1.36       tls 	TAILQ_HEAD(krprethead, cryptkop) crp_ret_mkq;
    134    1.1  jonathan 	int		sesn;
    135   1.36       tls 	struct selinfo	sinfo;
    136   1.36       tls 	u_int32_t	requestid;
    137   1.48  christos 	struct timespec atime;
    138   1.48  christos 	struct timespec mtime;
    139   1.48  christos 	struct timespec btime;
    140    1.1  jonathan };
    141    1.1  jonathan 
    142   1.29       tls /* For our fixed-size allocations */
    143   1.38     rmind static struct pool fcrpl;
    144   1.38     rmind static struct pool csepl;
    145    1.1  jonathan 
    146    1.1  jonathan /* Declaration of master device (fd-cloning/ctxt-allocating) entrypoints */
    147   1.16  christos static int	cryptoopen(dev_t dev, int flag, int mode, struct lwp *l);
    148    1.1  jonathan static int	cryptoread(dev_t dev, struct uio *uio, int ioflag);
    149    1.1  jonathan static int	cryptowrite(dev_t dev, struct uio *uio, int ioflag);
    150   1.16  christos static int	cryptoselect(dev_t dev, int rw, struct lwp *l);
    151    1.1  jonathan 
    152   1.74  pgoyette static int	crypto_refcount = 0;	/* Prevent detaching while in use */
    153   1.74  pgoyette 
    154    1.1  jonathan /* Declaration of cloned-device (per-ctxt) entrypoints */
    155   1.36       tls static int	cryptof_read(struct file *, off_t *, struct uio *,
    156   1.42  christos     kauth_cred_t, int);
    157   1.36       tls static int	cryptof_write(struct file *, off_t *, struct uio *,
    158   1.42  christos     kauth_cred_t, int);
    159   1.36       tls static int	cryptof_ioctl(struct file *, u_long, void *);
    160   1.36       tls static int	cryptof_close(struct file *);
    161   1.36       tls static int 	cryptof_poll(struct file *, int);
    162   1.48  christos static int 	cryptof_stat(struct file *, struct stat *);
    163    1.1  jonathan 
    164   1.12  christos static const struct fileops cryptofops = {
    165   1.97  christos 	.fo_name = "cryptof",
    166   1.47        ad 	.fo_read = cryptof_read,
    167   1.47        ad 	.fo_write = cryptof_write,
    168   1.47        ad 	.fo_ioctl = cryptof_ioctl,
    169   1.47        ad 	.fo_fcntl = fnullop_fcntl,
    170   1.47        ad 	.fo_poll = cryptof_poll,
    171   1.48  christos 	.fo_stat = cryptof_stat,
    172   1.47        ad 	.fo_close = cryptof_close,
    173   1.47        ad 	.fo_kqfilter = fnullop_kqfilter,
    174   1.51       dsl 	.fo_restart = fnullop_restart,
    175    1.1  jonathan };
    176    1.1  jonathan 
    177   1.46    darran struct csession *cryptodev_csefind(struct fcrypt *, u_int);
    178    1.1  jonathan static struct	csession *csefind(struct fcrypt *, u_int);
    179    1.1  jonathan static int	csedelete(struct fcrypt *, struct csession *);
    180    1.1  jonathan static struct	csession *cseadd(struct fcrypt *, struct csession *);
    181   1.42  christos static struct	csession *csecreate(struct fcrypt *, u_int64_t, void *,
    182   1.46    darran     u_int64_t, void *, u_int64_t, u_int32_t, u_int32_t, u_int32_t,
    183   1.54  drochner     const struct enc_xform *, const struct auth_hash *,
    184   1.54  drochner     const struct comp_algo *);
    185    1.1  jonathan static int	csefree(struct csession *);
    186    1.1  jonathan 
    187    1.1  jonathan static int	cryptodev_key(struct crypt_kop *);
    188   1.36       tls static int	cryptodev_mkey(struct fcrypt *, struct crypt_n_kop *, int);
    189   1.36       tls static int	cryptodev_msessionfin(struct fcrypt *, int, u_int32_t *);
    190    1.1  jonathan 
    191    1.1  jonathan static int	cryptodev_cb(void *);
    192    1.1  jonathan static int	cryptodevkey_cb(void *);
    193    1.1  jonathan 
    194   1.36       tls static int	cryptodev_mcb(void *);
    195   1.36       tls static int	cryptodevkey_mcb(void *);
    196   1.36       tls 
    197   1.36       tls static int 	cryptodev_getmstatus(struct fcrypt *, struct crypt_result *,
    198   1.42  christos     int);
    199   1.36       tls static int	cryptodev_getstatus(struct fcrypt *, struct crypt_result *);
    200   1.36       tls 
    201    1.9  jonathan /*
    202    1.9  jonathan  * sysctl-able control variables for /dev/crypto now defined in crypto.c:
    203    1.9  jonathan  * crypto_usercrypto, crypto_userasmcrypto, crypto_devallowsoft.
    204    1.9  jonathan  */
    205    1.1  jonathan 
    206    1.1  jonathan /* ARGSUSED */
    207    1.1  jonathan int
    208   1.35        ad cryptof_read(file_t *fp, off_t *poff,
    209   1.25  christos     struct uio *uio, kauth_cred_t cred, int flags)
    210    1.1  jonathan {
    211   1.42  christos 	return EIO;
    212    1.1  jonathan }
    213    1.1  jonathan 
    214    1.1  jonathan /* ARGSUSED */
    215    1.1  jonathan int
    216   1.35        ad cryptof_write(file_t *fp, off_t *poff,
    217   1.25  christos     struct uio *uio, kauth_cred_t cred, int flags)
    218    1.1  jonathan {
    219   1.42  christos 	return EIO;
    220    1.1  jonathan }
    221    1.1  jonathan 
    222    1.1  jonathan /* ARGSUSED */
    223    1.1  jonathan int
    224   1.36       tls cryptof_ioctl(struct file *fp, u_long cmd, void *data)
    225    1.1  jonathan {
    226   1.81      matt 	struct fcrypt *fcr = fp->f_fcrypt;
    227    1.1  jonathan 	struct csession *cse;
    228    1.1  jonathan 	struct session_op *sop;
    229   1.36       tls 	struct session_n_op *snop;
    230    1.1  jonathan 	struct crypt_op *cop;
    231   1.36       tls 	struct crypt_mop *mop;
    232   1.36       tls 	struct crypt_mkop *mkop;
    233   1.36       tls 	struct crypt_n_op *cnop;
    234   1.36       tls 	struct crypt_n_kop *knop;
    235   1.36       tls 	struct crypt_sgop *sgop;
    236   1.36       tls 	struct crypt_sfop *sfop;
    237   1.36       tls 	struct cryptret *crypt_ret;
    238   1.36       tls 	struct crypt_result *crypt_res;
    239    1.1  jonathan 	u_int32_t ses;
    240   1.36       tls 	u_int32_t *sesid;
    241    1.1  jonathan 	int error = 0;
    242   1.36       tls 	size_t count;
    243    1.1  jonathan 
    244   1.29       tls 	/* backwards compatibility */
    245   1.35        ad         file_t *criofp;
    246   1.29       tls 	struct fcrypt *criofcr;
    247   1.29       tls 	int criofd;
    248   1.29       tls 
    249   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    250   1.48  christos 	getnanotime(&fcr->atime);
    251   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    252   1.48  christos 
    253   1.36       tls 	switch (cmd) {
    254   1.29       tls         case CRIOGET:   /* XXX deprecated, remove after 5.0 */
    255   1.36       tls 		if ((error = fd_allocfile(&criofp, &criofd)) != 0)
    256   1.36       tls 			return error;
    257   1.36       tls 		criofcr = pool_get(&fcrpl, PR_WAITOK);
    258   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    259   1.36       tls 		TAILQ_INIT(&criofcr->csessions);
    260   1.36       tls 		TAILQ_INIT(&criofcr->crp_ret_mq);
    261   1.36       tls 		TAILQ_INIT(&criofcr->crp_ret_mkq);
    262   1.36       tls 		selinit(&criofcr->sinfo);
    263   1.36       tls 
    264   1.29       tls                 /*
    265   1.29       tls                  * Don't ever return session 0, to allow detection of
    266   1.29       tls                  * failed creation attempts with multi-create ioctl.
    267   1.29       tls                  */
    268   1.36       tls 		criofcr->sesn = 1;
    269   1.36       tls 		criofcr->requestid = 1;
    270   1.74  pgoyette 		crypto_refcount++;
    271   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    272   1.36       tls 		(void)fd_clone(criofp, criofd, (FREAD|FWRITE),
    273   1.29       tls 			      &cryptofops, criofcr);
    274   1.36       tls 		*(u_int32_t *)data = criofd;
    275   1.29       tls 		return error;
    276   1.36       tls 		break;
    277    1.1  jonathan 	case CIOCGSESSION:
    278    1.1  jonathan 		sop = (struct session_op *)data;
    279   1.36       tls 		error = cryptodev_session(fcr, sop);
    280   1.36       tls 		break;
    281   1.36       tls 	case CIOCNGSESSION:
    282   1.36       tls 		sgop = (struct crypt_sgop *)data;
    283   1.93  knakahar 		if (sgop->count <= 0
    284   1.93  knakahar 		    || SIZE_MAX / sizeof(struct session_n_op) <= sgop->count) {
    285   1.93  knakahar 			error = EINVAL;
    286   1.93  knakahar 			break;
    287   1.93  knakahar 		}
    288   1.36       tls 		snop = kmem_alloc((sgop->count *
    289   1.36       tls 				  sizeof(struct session_n_op)), KM_SLEEP);
    290   1.36       tls 		error = copyin(sgop->sessions, snop, sgop->count *
    291   1.36       tls 			       sizeof(struct session_n_op));
    292   1.36       tls 		if (error) {
    293   1.36       tls 			goto mbail;
    294    1.1  jonathan 		}
    295    1.1  jonathan 
    296   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    297   1.48  christos 		fcr->mtime = fcr->atime;
    298   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    299   1.36       tls 		error = cryptodev_msession(fcr, snop, sgop->count);
    300   1.36       tls 		if (error) {
    301   1.36       tls 			goto mbail;
    302    1.1  jonathan 		}
    303    1.1  jonathan 
    304   1.36       tls 		error = copyout(snop, sgop->sessions, sgop->count *
    305   1.42  christos 		    sizeof(struct session_n_op));
    306   1.36       tls mbail:
    307   1.39       tls 		kmem_free(snop, sgop->count * sizeof(struct session_n_op));
    308    1.1  jonathan 		break;
    309    1.1  jonathan 	case CIOCFSESSION:
    310   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    311   1.48  christos 		fcr->mtime = fcr->atime;
    312    1.1  jonathan 		ses = *(u_int32_t *)data;
    313    1.1  jonathan 		cse = csefind(fcr, ses);
    314   1.56  drochner 		if (cse == NULL) {
    315   1.92  knakahar 			mutex_exit(&cryptodev_mtx);
    316   1.42  christos 			return EINVAL;
    317   1.56  drochner 		}
    318    1.1  jonathan 		csedelete(fcr, cse);
    319   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    320    1.1  jonathan 		error = csefree(cse);
    321    1.1  jonathan 		break;
    322   1.36       tls 	case CIOCNFSESSION:
    323   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    324   1.48  christos 		fcr->mtime = fcr->atime;
    325   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    326   1.36       tls 		sfop = (struct crypt_sfop *)data;
    327   1.93  knakahar 		if (sfop->count <= 0
    328   1.93  knakahar 		    || SIZE_MAX / sizeof(u_int32_t) <= sfop->count) {
    329   1.93  knakahar 			error = EINVAL;
    330   1.93  knakahar 			break;
    331   1.93  knakahar 		}
    332   1.36       tls 		sesid = kmem_alloc((sfop->count * sizeof(u_int32_t)),
    333   1.42  christos 		    KM_SLEEP);
    334   1.42  christos 		error = copyin(sfop->sesid, sesid,
    335   1.42  christos 		    (sfop->count * sizeof(u_int32_t)));
    336   1.36       tls 		if (!error) {
    337   1.36       tls 			error = cryptodev_msessionfin(fcr, sfop->count, sesid);
    338   1.36       tls 		}
    339   1.36       tls 		kmem_free(sesid, (sfop->count * sizeof(u_int32_t)));
    340   1.36       tls 		break;
    341    1.1  jonathan 	case CIOCCRYPT:
    342   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    343   1.48  christos 		fcr->mtime = fcr->atime;
    344    1.1  jonathan 		cop = (struct crypt_op *)data;
    345    1.1  jonathan 		cse = csefind(fcr, cop->ses);
    346   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    347   1.18  christos 		if (cse == NULL) {
    348   1.90  knakahar 			DPRINTF("csefind failed\n");
    349   1.42  christos 			return EINVAL;
    350   1.18  christos 		}
    351   1.35        ad 		error = cryptodev_op(cse, cop, curlwp);
    352   1.90  knakahar 		DPRINTF("cryptodev_op error = %d\n", error);
    353    1.1  jonathan 		break;
    354   1.36       tls 	case CIOCNCRYPTM:
    355   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    356   1.48  christos 		fcr->mtime = fcr->atime;
    357   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    358   1.36       tls 		mop = (struct crypt_mop *)data;
    359   1.93  knakahar 		if (mop->count <= 0
    360   1.93  knakahar 		    || SIZE_MAX / sizeof(struct crypt_n_op) <= mop->count) {
    361   1.93  knakahar 			error = EINVAL;
    362   1.93  knakahar 			break;
    363   1.93  knakahar 		}
    364   1.36       tls 		cnop = kmem_alloc((mop->count * sizeof(struct crypt_n_op)),
    365   1.42  christos 		    KM_SLEEP);
    366   1.42  christos 		error = copyin(mop->reqs, cnop,
    367   1.42  christos 		    (mop->count * sizeof(struct crypt_n_op)));
    368   1.36       tls 		if(!error) {
    369   1.42  christos 			error = cryptodev_mop(fcr, cnop, mop->count, curlwp);
    370   1.36       tls 			if (!error) {
    371   1.36       tls 				error = copyout(cnop, mop->reqs,
    372   1.42  christos 				    (mop->count * sizeof(struct crypt_n_op)));
    373   1.36       tls 			}
    374   1.36       tls 		}
    375   1.36       tls 		kmem_free(cnop, (mop->count * sizeof(struct crypt_n_op)));
    376   1.85   msaitoh 		break;
    377    1.1  jonathan 	case CIOCKEY:
    378    1.1  jonathan 		error = cryptodev_key((struct crypt_kop *)data);
    379   1.90  knakahar 		DPRINTF("cryptodev_key error = %d\n", error);
    380    1.1  jonathan 		break;
    381   1.36       tls 	case CIOCNFKEYM:
    382   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    383   1.48  christos 		fcr->mtime = fcr->atime;
    384   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    385   1.36       tls 		mkop = (struct crypt_mkop *)data;
    386   1.93  knakahar 		if (mkop->count <= 0
    387   1.93  knakahar 		    || SIZE_MAX / sizeof(struct crypt_n_kop) <= mkop->count) {
    388   1.93  knakahar 			error = EINVAL;
    389   1.93  knakahar 			break;
    390   1.93  knakahar 		}
    391   1.36       tls 		knop = kmem_alloc((mkop->count * sizeof(struct crypt_n_kop)),
    392   1.42  christos 		    KM_SLEEP);
    393   1.36       tls 		error = copyin(mkop->reqs, knop,
    394   1.42  christos 		    (mkop->count * sizeof(struct crypt_n_kop)));
    395   1.36       tls 		if (!error) {
    396   1.36       tls 			error = cryptodev_mkey(fcr, knop, mkop->count);
    397   1.36       tls 			if (!error)
    398   1.36       tls 				error = copyout(knop, mkop->reqs,
    399   1.42  christos 				    (mkop->count * sizeof(struct crypt_n_kop)));
    400   1.36       tls 		}
    401   1.36       tls 		kmem_free(knop, (mkop->count * sizeof(struct crypt_n_kop)));
    402   1.36       tls 		break;
    403    1.1  jonathan 	case CIOCASYMFEAT:
    404    1.1  jonathan 		error = crypto_getfeat((int *)data);
    405    1.1  jonathan 		break;
    406   1.36       tls 	case CIOCNCRYPTRETM:
    407   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    408   1.48  christos 		fcr->mtime = fcr->atime;
    409   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    410   1.36       tls 		crypt_ret = (struct cryptret *)data;
    411   1.36       tls 		count = crypt_ret->count;
    412   1.93  knakahar 		if (count <= 0
    413   1.93  knakahar 		    || SIZE_MAX / sizeof(struct crypt_result) <= count) {
    414   1.93  knakahar 			error = EINVAL;
    415   1.93  knakahar 			break;
    416   1.93  knakahar 		}
    417   1.42  christos 		crypt_res = kmem_alloc((count * sizeof(struct crypt_result)),
    418   1.42  christos 		    KM_SLEEP);
    419   1.36       tls 		error = copyin(crypt_ret->results, crypt_res,
    420   1.42  christos 		    (count * sizeof(struct crypt_result)));
    421   1.36       tls 		if (error)
    422   1.36       tls 			goto reterr;
    423   1.36       tls 		crypt_ret->count = cryptodev_getmstatus(fcr, crypt_res,
    424   1.42  christos 		    crypt_ret->count);
    425   1.36       tls 		/* sanity check count */
    426   1.36       tls 		if (crypt_ret->count > count) {
    427   1.37    dogcow 			printf("%s.%d: error returned count %zd > original "
    428   1.42  christos 			    " count %zd\n",
    429   1.42  christos 			    __FILE__, __LINE__, crypt_ret->count, count);
    430   1.36       tls 			crypt_ret->count = count;
    431   1.36       tls 
    432   1.36       tls 		}
    433   1.36       tls 		error = copyout(crypt_res, crypt_ret->results,
    434   1.42  christos 		    (crypt_ret->count * sizeof(struct crypt_result)));
    435   1.36       tls reterr:
    436   1.42  christos 		kmem_free(crypt_res, (count * sizeof(struct crypt_result)));
    437   1.36       tls 		break;
    438   1.36       tls 	case CIOCNCRYPTRET:
    439   1.85   msaitoh 		error = cryptodev_getstatus(fcr, (struct crypt_result *)data);
    440   1.36       tls 		break;
    441    1.1  jonathan 	default:
    442   1.46    darran 		/* Check for backward compatible commands */
    443   1.99  pgoyette 
    444  1.100  pgoyette 		MODULE_HOOK_CALL(ocryptof_50_hook, (fp, cmd, data),
    445   1.99  pgoyette 		    enosys(), error);
    446   1.99  pgoyette 		if (error == ENOSYS)
    447   1.99  pgoyette 			error = EINVAL;
    448   1.99  pgoyette 		return error;
    449    1.1  jonathan 	}
    450   1.42  christos 	return error;
    451    1.1  jonathan }
    452    1.1  jonathan 
    453   1.46    darran int
    454   1.25  christos cryptodev_op(struct csession *cse, struct crypt_op *cop, struct lwp *l)
    455    1.1  jonathan {
    456    1.1  jonathan 	struct cryptop *crp = NULL;
    457   1.46    darran 	struct cryptodesc *crde = NULL, *crda = NULL, *crdc = NULL;
    458   1.33       tls 	int error;
    459   1.46    darran 	int iov_len = cop->len;
    460   1.46    darran 	int flags=0;
    461   1.46    darran 	int dst_len;	/* copyout size */
    462    1.1  jonathan 
    463    1.1  jonathan 	if (cop->len > 256*1024-4)
    464   1.42  christos 		return E2BIG;
    465    1.1  jonathan 
    466   1.13  jonathan 	if (cse->txform) {
    467   1.58  drochner 		if (cop->len < cse->txform->blocksize
    468   1.58  drochner 		    + (cop->iv ? 0 : cse->txform->ivsize) ||
    469   1.58  drochner 		    (cop->len - (cop->iv ? 0 : cse->txform->ivsize))
    470   1.58  drochner 		    % cse->txform->blocksize != 0)
    471   1.42  christos 			return EINVAL;
    472   1.13  jonathan 	}
    473    1.1  jonathan 
    474   1.90  knakahar 	DPRINTF("cryptodev_op[%u]: iov_len %d\n",
    475   1.90  knakahar 		CRYPTO_SESID2LID(cse->sid), iov_len);
    476   1.46    darran 	if ((cse->tcomp) && cop->dst_len) {
    477   1.46    darran 		if (iov_len < cop->dst_len) {
    478   1.46    darran 			/* Need larger iov to deal with decompress */
    479   1.46    darran 			iov_len = cop->dst_len;
    480   1.46    darran 		}
    481   1.90  knakahar 		DPRINTF("cryptodev_op: iov_len -> %d for decompress\n", iov_len);
    482   1.46    darran 	}
    483   1.46    darran 
    484   1.42  christos 	(void)memset(&cse->uio, 0, sizeof(cse->uio));
    485    1.1  jonathan 	cse->uio.uio_iovcnt = 1;
    486    1.1  jonathan 	cse->uio.uio_resid = 0;
    487    1.1  jonathan 	cse->uio.uio_rw = UIO_WRITE;
    488    1.1  jonathan 	cse->uio.uio_iov = cse->iovec;
    489   1.17      yamt 	UIO_SETUP_SYSSPACE(&cse->uio);
    490   1.29       tls 	memset(&cse->iovec, 0, sizeof(cse->iovec));
    491   1.46    darran 
    492   1.46    darran 	/* the iov needs to be big enough to handle the uncompressed
    493   1.46    darran 	 * data.... */
    494   1.46    darran 	cse->uio.uio_iov[0].iov_len = iov_len;
    495   1.64  drochner 	if (iov_len > 0)
    496   1.64  drochner 		cse->uio.uio_iov[0].iov_base = kmem_alloc(iov_len, KM_SLEEP);
    497   1.29       tls 	cse->uio.uio_resid = cse->uio.uio_iov[0].iov_len;
    498   1.90  knakahar 	DPRINTF("lid[%u]: uio.iov_base %p malloced %d bytes\n",
    499   1.53  jakllsch 		CRYPTO_SESID2LID(cse->sid),
    500   1.90  knakahar 		cse->uio.uio_iov[0].iov_base, iov_len);
    501    1.1  jonathan 
    502   1.46    darran 	crp = crypto_getreq((cse->tcomp != NULL) + (cse->txform != NULL) + (cse->thash != NULL));
    503    1.1  jonathan 	if (crp == NULL) {
    504    1.1  jonathan 		error = ENOMEM;
    505    1.1  jonathan 		goto bail;
    506    1.1  jonathan 	}
    507   1.90  knakahar 	DPRINTF("lid[%u]: crp %p\n", CRYPTO_SESID2LID(cse->sid), crp);
    508   1.46    darran 
    509   1.46    darran 	/* crds are always ordered tcomp, thash, then txform */
    510   1.46    darran 	/* with optional missing links */
    511   1.46    darran 
    512   1.46    darran 	/* XXX: If we're going to compress then hash or encrypt, we need
    513   1.46    darran 	 * to be able to pass on the new size of the data.
    514   1.46    darran 	 */
    515   1.46    darran 
    516   1.46    darran 	if (cse->tcomp) {
    517   1.46    darran 		crdc = crp->crp_desc;
    518   1.46    darran 	}
    519    1.1  jonathan 
    520    1.1  jonathan 	if (cse->thash) {
    521   1.46    darran 		crda = crdc ? crdc->crd_next : crp->crp_desc;
    522   1.44  christos 		if (cse->txform && crda)
    523    1.1  jonathan 			crde = crda->crd_next;
    524    1.1  jonathan 	} else {
    525   1.46    darran 		if (cse->txform) {
    526   1.46    darran 			crde = crdc ? crdc->crd_next : crp->crp_desc;
    527   1.46    darran 		} else if (!cse->tcomp) {
    528    1.1  jonathan 			error = EINVAL;
    529    1.1  jonathan 			goto bail;
    530    1.1  jonathan 		}
    531    1.1  jonathan 	}
    532    1.1  jonathan 
    533   1.90  knakahar 	DPRINTF("ocf[%u]: iov_len %zu, cop->len %u\n",
    534   1.53  jakllsch 			CRYPTO_SESID2LID(cse->sid),
    535   1.46    darran 			cse->uio.uio_iov[0].iov_len,
    536   1.90  knakahar 			cop->len);
    537   1.46    darran 
    538    1.1  jonathan 	if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len)))
    539   1.36       tls 	{
    540   1.36       tls 		printf("copyin failed %s %d \n", (char *)cop->src, error);
    541    1.1  jonathan 		goto bail;
    542   1.36       tls 	}
    543    1.1  jonathan 
    544   1.46    darran 	if (crdc) {
    545   1.46    darran 		switch (cop->op) {
    546   1.46    darran 		case COP_COMP:
    547   1.46    darran 			crdc->crd_flags |= CRD_F_COMP;
    548   1.46    darran 			break;
    549   1.46    darran 		case COP_DECOMP:
    550   1.46    darran 			crdc->crd_flags &= ~CRD_F_COMP;
    551   1.46    darran 			break;
    552   1.46    darran 		default:
    553   1.46    darran 			break;
    554   1.46    darran 		}
    555   1.46    darran 		/* more data to follow? */
    556   1.46    darran 		if (cop->flags & COP_F_MORE) {
    557   1.46    darran 			flags |= CRYPTO_F_MORE;
    558   1.46    darran 		}
    559   1.46    darran 		crdc->crd_len = cop->len;
    560   1.46    darran 		crdc->crd_inject = 0;
    561   1.46    darran 
    562   1.46    darran 		crdc->crd_alg = cse->comp_alg;
    563   1.46    darran 		crdc->crd_key = NULL;
    564   1.46    darran 		crdc->crd_klen = 0;
    565   1.90  knakahar 		DPRINTF("lid[%u]: crdc setup for comp_alg %d.\n",
    566   1.90  knakahar 			CRYPTO_SESID2LID(cse->sid), crdc->crd_alg);
    567   1.46    darran 	}
    568   1.46    darran 
    569    1.1  jonathan 	if (crda) {
    570    1.1  jonathan 		crda->crd_skip = 0;
    571    1.1  jonathan 		crda->crd_len = cop->len;
    572    1.1  jonathan 		crda->crd_inject = 0;	/* ??? */
    573    1.1  jonathan 
    574    1.1  jonathan 		crda->crd_alg = cse->mac;
    575    1.1  jonathan 		crda->crd_key = cse->mackey;
    576    1.1  jonathan 		crda->crd_klen = cse->mackeylen * 8;
    577   1.90  knakahar 		DPRINTF("crda setup for mac %d.\n", crda->crd_alg);
    578    1.1  jonathan 	}
    579    1.1  jonathan 
    580    1.1  jonathan 	if (crde) {
    581   1.46    darran 		switch (cop->op) {
    582   1.46    darran 		case COP_ENCRYPT:
    583    1.1  jonathan 			crde->crd_flags |= CRD_F_ENCRYPT;
    584   1.46    darran 			break;
    585   1.46    darran 		case COP_DECRYPT:
    586    1.1  jonathan 			crde->crd_flags &= ~CRD_F_ENCRYPT;
    587   1.46    darran 			break;
    588   1.46    darran 		default:
    589   1.46    darran 			break;
    590   1.46    darran 		}
    591    1.1  jonathan 		crde->crd_len = cop->len;
    592    1.1  jonathan 		crde->crd_inject = 0;
    593    1.1  jonathan 
    594   1.66  drochner 		if (cse->cipher == CRYPTO_AES_GCM_16 && crda)
    595   1.66  drochner 			crda->crd_len = 0;
    596   1.66  drochner 		else if (cse->cipher == CRYPTO_AES_GMAC)
    597   1.66  drochner 			crde->crd_len = 0;
    598   1.66  drochner 
    599    1.1  jonathan 		crde->crd_alg = cse->cipher;
    600    1.1  jonathan 		crde->crd_key = cse->key;
    601    1.1  jonathan 		crde->crd_klen = cse->keylen * 8;
    602   1.90  knakahar 		DPRINTF("crde setup for cipher %d.\n", crde->crd_alg);
    603    1.1  jonathan 	}
    604    1.1  jonathan 
    605   1.46    darran 
    606    1.1  jonathan 	crp->crp_ilen = cop->len;
    607   1.86  knakahar 	/*
    608   1.86  knakahar 	 * The request is flagged as CRYPTO_F_USER as long as it is running
    609   1.86  knakahar 	 * in the user IOCTL thread. However, whether the request completes
    610   1.86  knakahar 	 * immediately or belatedly is depends on the used encryption driver.
    611   1.45    darran 	 */
    612   1.46    darran 	crp->crp_flags = CRYPTO_F_IOV | (cop->flags & COP_F_BATCH) | CRYPTO_F_USER |
    613   1.46    darran 			flags;
    614   1.26  christos 	crp->crp_buf = (void *)&cse->uio;
    615    1.1  jonathan 	crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb;
    616    1.1  jonathan 	crp->crp_sid = cse->sid;
    617    1.1  jonathan 	crp->crp_opaque = (void *)cse;
    618    1.1  jonathan 
    619    1.1  jonathan 	if (cop->iv) {
    620    1.1  jonathan 		if (crde == NULL) {
    621    1.1  jonathan 			error = EINVAL;
    622    1.1  jonathan 			goto bail;
    623    1.1  jonathan 		}
    624   1.62  drochner 		if (cse->txform->ivsize == 0) {
    625    1.1  jonathan 			error = EINVAL;
    626    1.1  jonathan 			goto bail;
    627    1.1  jonathan 		}
    628   1.36       tls 		if ((error = copyin(cop->iv, cse->tmp_iv,
    629   1.58  drochner 		    cse->txform->ivsize)))
    630    1.1  jonathan 			goto bail;
    631   1.58  drochner 		(void)memcpy(crde->crd_iv, cse->tmp_iv, cse->txform->ivsize);
    632    1.1  jonathan 		crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
    633    1.1  jonathan 		crde->crd_skip = 0;
    634    1.1  jonathan 	} else if (crde) {
    635   1.62  drochner 		if (cse->txform->ivsize == 0) {
    636   1.20  christos 			crde->crd_skip = 0;
    637   1.20  christos 		} else {
    638   1.61  drochner 			if (!(crde->crd_flags & CRD_F_ENCRYPT))
    639   1.61  drochner 				crde->crd_flags |= CRD_F_IV_PRESENT;
    640   1.58  drochner 			crde->crd_skip = cse->txform->ivsize;
    641   1.58  drochner 			crde->crd_len -= cse->txform->ivsize;
    642   1.20  christos 		}
    643    1.1  jonathan 	}
    644    1.1  jonathan 
    645    1.1  jonathan 	if (cop->mac) {
    646    1.1  jonathan 		if (crda == NULL) {
    647    1.1  jonathan 			error = EINVAL;
    648    1.1  jonathan 			goto bail;
    649    1.1  jonathan 		}
    650    1.1  jonathan 		crp->crp_mac=cse->tmp_mac;
    651    1.1  jonathan 	}
    652    1.1  jonathan 
    653   1.67  drochner 	cv_init(&crp->crp_cv, "crydev");
    654   1.67  drochner 
    655   1.33       tls 	/*
    656   1.33       tls 	 * XXX there was a comment here which said that we went to
    657   1.33       tls 	 * XXX splcrypto() but needed to only if CRYPTO_F_CBIMM,
    658   1.33       tls 	 * XXX disabled on NetBSD since 1.6O due to a race condition.
    659   1.33       tls 	 * XXX But crypto_dispatch went to splcrypto() itself!  (And
    660   1.92  knakahar 	 * XXX now takes the cryptodev_mtx mutex itself).  We do, however,
    661   1.33       tls 	 * XXX need to hold the mutex across the call to cv_wait().
    662   1.33       tls 	 * XXX     (should we arrange for crypto_dispatch to return to
    663   1.33       tls 	 * XXX      us with it held?  it seems quite ugly to do so.)
    664   1.33       tls 	 */
    665   1.36       tls #ifdef notyet
    666   1.36       tls eagain:
    667   1.36       tls #endif
    668    1.1  jonathan 	error = crypto_dispatch(crp);
    669   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    670   1.36       tls 
    671   1.45    darran 	/*
    672   1.98  dholland 	 * Don't touch crp before returned by any error or received
    673   1.86  knakahar 	 * cv_signal(&crp->crp_cv). It is required to restructure locks.
    674   1.45    darran 	 */
    675   1.45    darran 
    676   1.36       tls 	switch (error) {
    677   1.36       tls #ifdef notyet	/* don't loop forever -- but EAGAIN not possible here yet */
    678   1.36       tls 	case EAGAIN:
    679   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    680   1.36       tls 		goto eagain;
    681   1.36       tls 		break;
    682   1.36       tls #endif
    683   1.36       tls 	case 0:
    684   1.36       tls 		break;
    685   1.36       tls 	default:
    686   1.90  knakahar 		DPRINTF("not waiting, error.\n");
    687   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    688   1.67  drochner 		cv_destroy(&crp->crp_cv);
    689    1.1  jonathan 		goto bail;
    690    1.1  jonathan 	}
    691   1.45    darran 
    692   1.95  knakahar 	while (!(crp->crp_devflags & CRYPTODEV_F_RET)) {
    693   1.90  knakahar 		DPRINTF("cse->sid[%d]: sleeping on cv %p for crp %p\n",
    694   1.90  knakahar 			(uint32_t)cse->sid, &crp->crp_cv, crp);
    695   1.92  knakahar 		cv_wait(&crp->crp_cv, &cryptodev_mtx);	/* XXX cv_wait_sig? */
    696   1.33       tls 	}
    697   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    698   1.67  drochner 	cv_destroy(&crp->crp_cv);
    699    1.1  jonathan 
    700    1.1  jonathan 	if (crp->crp_etype != 0) {
    701   1.90  knakahar 		DPRINTF("crp_etype %d\n", crp->crp_etype);
    702    1.1  jonathan 		error = crp->crp_etype;
    703    1.1  jonathan 		goto bail;
    704    1.1  jonathan 	}
    705    1.1  jonathan 
    706    1.1  jonathan 	if (cse->error) {
    707   1.90  knakahar 		DPRINTF("cse->error %d\n", cse->error);
    708    1.1  jonathan 		error = cse->error;
    709    1.1  jonathan 		goto bail;
    710    1.1  jonathan 	}
    711    1.1  jonathan 
    712   1.46    darran 	dst_len = crp->crp_ilen;
    713   1.46    darran 	/* let the user know how much data was returned */
    714   1.46    darran 	if (crp->crp_olen) {
    715   1.64  drochner 		if (crp->crp_olen > (cop->dst_len ? cop->dst_len : cop->len)) {
    716   1.82  christos 			error = ENOSPC;
    717   1.64  drochner 			goto bail;
    718   1.64  drochner 		}
    719   1.46    darran 		dst_len = cop->dst_len = crp->crp_olen;
    720   1.46    darran 	}
    721   1.46    darran 
    722   1.46    darran 	if (cop->dst) {
    723   1.90  knakahar 		DPRINTF("copyout %d bytes to %p\n", dst_len, cop->dst);
    724   1.46    darran 	}
    725    1.1  jonathan 	if (cop->dst &&
    726   1.46    darran 	    (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, dst_len)))
    727   1.36       tls 	{
    728   1.90  knakahar 		DPRINTF("copyout error %d\n", error);
    729    1.1  jonathan 		goto bail;
    730   1.34       tls 	}
    731    1.1  jonathan 
    732    1.1  jonathan 	if (cop->mac &&
    733   1.34       tls 	    (error = copyout(crp->crp_mac, cop->mac, cse->thash->authsize))) {
    734   1.90  knakahar 		DPRINTF("mac copyout error %d\n", error);
    735    1.1  jonathan 		goto bail;
    736   1.34       tls 	}
    737    1.1  jonathan 
    738   1.46    darran 
    739    1.1  jonathan bail:
    740   1.45    darran 	if (crp) {
    741    1.1  jonathan 		crypto_freereq(crp);
    742   1.45    darran 	}
    743   1.46    darran 	if (cse->uio.uio_iov[0].iov_base) {
    744   1.46    darran 		kmem_free(cse->uio.uio_iov[0].iov_base,iov_len);
    745   1.46    darran 	}
    746    1.1  jonathan 
    747   1.42  christos 	return error;
    748    1.1  jonathan }
    749    1.1  jonathan 
    750    1.1  jonathan static int
    751    1.1  jonathan cryptodev_cb(void *op)
    752    1.1  jonathan {
    753    1.1  jonathan 	struct cryptop *crp = (struct cryptop *) op;
    754    1.1  jonathan 	struct csession *cse = (struct csession *)crp->crp_opaque;
    755   1.33       tls 	int error = 0;
    756    1.1  jonathan 
    757   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    758    1.1  jonathan 	cse->error = crp->crp_etype;
    759   1.33       tls 	if (crp->crp_etype == EAGAIN) {
    760   1.33       tls 		/* always drop mutex to call dispatch routine */
    761   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    762   1.33       tls 		error = crypto_dispatch(crp);
    763   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    764   1.33       tls 	}
    765   1.33       tls 	if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
    766   1.95  knakahar 		crp->crp_devflags |= CRYPTODEV_F_RET;
    767   1.33       tls 		cv_signal(&crp->crp_cv);
    768   1.33       tls 	}
    769   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    770   1.42  christos 	return 0;
    771    1.1  jonathan }
    772    1.1  jonathan 
    773    1.1  jonathan static int
    774   1.36       tls cryptodev_mcb(void *op)
    775   1.36       tls {
    776   1.36       tls 	struct cryptop *crp = (struct cryptop *) op;
    777   1.36       tls 	struct csession *cse = (struct csession *)crp->crp_opaque;
    778   1.36       tls 	int  error=0;
    779   1.36       tls 
    780   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    781   1.36       tls 	cse->error = crp->crp_etype;
    782   1.36       tls 	if (crp->crp_etype == EAGAIN) {
    783   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    784   1.36       tls 		error = crypto_dispatch(crp);
    785   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    786   1.36       tls 	}
    787   1.36       tls 	if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
    788   1.36       tls 		cv_signal(&crp->crp_cv);
    789   1.36       tls 	}
    790   1.36       tls 
    791   1.36       tls 	TAILQ_INSERT_TAIL(&crp->fcrp->crp_ret_mq, crp, crp_next);
    792   1.38     rmind 	selnotify(&crp->fcrp->sinfo, 0, 0);
    793   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    794   1.42  christos 	return 0;
    795   1.36       tls }
    796   1.36       tls 
    797   1.36       tls static int
    798    1.1  jonathan cryptodevkey_cb(void *op)
    799    1.1  jonathan {
    800   1.42  christos 	struct cryptkop *krp = op;
    801   1.36       tls 
    802   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    803   1.95  knakahar 	krp->krp_devflags |= CRYPTODEV_F_RET;
    804   1.36       tls 	cv_signal(&krp->krp_cv);
    805   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    806   1.42  christos 	return 0;
    807   1.36       tls }
    808   1.36       tls 
    809   1.36       tls static int
    810   1.36       tls cryptodevkey_mcb(void *op)
    811   1.36       tls {
    812   1.42  christos 	struct cryptkop *krp = op;
    813    1.1  jonathan 
    814   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    815   1.33       tls 	cv_signal(&krp->krp_cv);
    816   1.36       tls 	TAILQ_INSERT_TAIL(&krp->fcrp->crp_ret_mkq, krp, krp_next);
    817   1.38     rmind 	selnotify(&krp->fcrp->sinfo, 0, 0);
    818   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    819   1.42  christos 	return 0;
    820    1.1  jonathan }
    821    1.1  jonathan 
    822    1.1  jonathan static int
    823    1.1  jonathan cryptodev_key(struct crypt_kop *kop)
    824    1.1  jonathan {
    825    1.1  jonathan 	struct cryptkop *krp = NULL;
    826    1.1  jonathan 	int error = EINVAL;
    827    1.1  jonathan 	int in, out, size, i;
    828    1.1  jonathan 
    829   1.42  christos 	if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM)
    830   1.42  christos 		return EFBIG;
    831    1.1  jonathan 
    832    1.1  jonathan 	in = kop->crk_iparams;
    833    1.1  jonathan 	out = kop->crk_oparams;
    834    1.1  jonathan 	switch (kop->crk_op) {
    835    1.1  jonathan 	case CRK_MOD_EXP:
    836    1.1  jonathan 		if (in == 3 && out == 1)
    837    1.1  jonathan 			break;
    838   1.42  christos 		return EINVAL;
    839    1.1  jonathan 	case CRK_MOD_EXP_CRT:
    840    1.1  jonathan 		if (in == 6 && out == 1)
    841    1.1  jonathan 			break;
    842   1.42  christos 		return EINVAL;
    843    1.1  jonathan 	case CRK_DSA_SIGN:
    844    1.1  jonathan 		if (in == 5 && out == 2)
    845    1.1  jonathan 			break;
    846   1.42  christos 		return EINVAL;
    847    1.1  jonathan 	case CRK_DSA_VERIFY:
    848    1.1  jonathan 		if (in == 7 && out == 0)
    849    1.1  jonathan 			break;
    850   1.42  christos 		return EINVAL;
    851    1.1  jonathan 	case CRK_DH_COMPUTE_KEY:
    852    1.1  jonathan 		if (in == 3 && out == 1)
    853    1.1  jonathan 			break;
    854   1.42  christos 		return EINVAL;
    855   1.27       tls 	case CRK_MOD_ADD:
    856   1.27       tls 		if (in == 3 && out == 1)
    857   1.27       tls 			break;
    858   1.42  christos 		return EINVAL;
    859   1.27       tls 	case CRK_MOD_ADDINV:
    860   1.27       tls 		if (in == 2 && out == 1)
    861   1.27       tls 			break;
    862   1.42  christos 		return EINVAL;
    863   1.27       tls 	case CRK_MOD_SUB:
    864   1.27       tls 		if (in == 3 && out == 1)
    865   1.27       tls 			break;
    866   1.42  christos 		return EINVAL;
    867   1.27       tls 	case CRK_MOD_MULT:
    868   1.27       tls 		if (in == 3 && out == 1)
    869   1.27       tls 			break;
    870   1.42  christos 		return EINVAL;
    871   1.27       tls 	case CRK_MOD_MULTINV:
    872   1.27       tls 		if (in == 2 && out == 1)
    873   1.27       tls 			break;
    874   1.42  christos 		return EINVAL;
    875   1.27       tls 	case CRK_MOD:
    876   1.27       tls 		if (in == 2 && out == 1)
    877   1.27       tls 			break;
    878   1.42  christos 		return EINVAL;
    879    1.1  jonathan 	default:
    880   1.42  christos 		return EINVAL;
    881    1.1  jonathan 	}
    882    1.1  jonathan 
    883   1.91  knakahar 	krp = crypto_kgetreq(1, PR_WAITOK);
    884   1.91  knakahar 	if (krp == NULL) {
    885   1.91  knakahar 		/* limited by opencrypto.crypto_ret_kq.maxlen */
    886   1.91  knakahar 		return ENOMEM;
    887   1.91  knakahar 	}
    888   1.42  christos 	(void)memset(krp, 0, sizeof *krp);
    889   1.33       tls 	cv_init(&krp->krp_cv, "crykdev");
    890    1.1  jonathan 	krp->krp_op = kop->crk_op;
    891    1.1  jonathan 	krp->krp_status = kop->crk_status;
    892    1.1  jonathan 	krp->krp_iparams = kop->crk_iparams;
    893    1.1  jonathan 	krp->krp_oparams = kop->crk_oparams;
    894    1.1  jonathan 	krp->krp_status = 0;
    895    1.1  jonathan 	krp->krp_callback = (int (*) (struct cryptkop *)) cryptodevkey_cb;
    896    1.1  jonathan 
    897    1.1  jonathan 	for (i = 0; i < CRK_MAXPARAM; i++)
    898    1.1  jonathan 		krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits;
    899    1.1  jonathan 	for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
    900    1.1  jonathan 		size = (krp->krp_param[i].crp_nbits + 7) / 8;
    901    1.1  jonathan 		if (size == 0)
    902    1.1  jonathan 			continue;
    903   1.36       tls 		krp->krp_param[i].crp_p = kmem_alloc(size, KM_SLEEP);
    904    1.1  jonathan 		if (i >= krp->krp_iparams)
    905    1.1  jonathan 			continue;
    906   1.42  christos 		error = copyin(kop->crk_param[i].crp_p,
    907   1.42  christos 		    krp->krp_param[i].crp_p, size);
    908    1.1  jonathan 		if (error)
    909    1.1  jonathan 			goto fail;
    910    1.1  jonathan 	}
    911    1.1  jonathan 
    912    1.1  jonathan 	error = crypto_kdispatch(krp);
    913   1.33       tls 	if (error != 0) {
    914    1.1  jonathan 		goto fail;
    915   1.33       tls 	}
    916   1.33       tls 
    917   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    918   1.95  knakahar 	while (!(krp->krp_devflags & CRYPTODEV_F_RET)) {
    919   1.92  knakahar 		cv_wait(&krp->krp_cv, &cryptodev_mtx);	/* XXX cv_wait_sig? */
    920   1.33       tls 	}
    921   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    922    1.1  jonathan 
    923    1.1  jonathan 	if (krp->krp_status != 0) {
    924   1.90  knakahar 		DPRINTF("krp->krp_status 0x%08x\n", krp->krp_status);
    925    1.1  jonathan 		error = krp->krp_status;
    926    1.1  jonathan 		goto fail;
    927    1.1  jonathan 	}
    928    1.1  jonathan 
    929   1.42  christos 	for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams;
    930   1.42  christos 	    i++) {
    931    1.1  jonathan 		size = (krp->krp_param[i].crp_nbits + 7) / 8;
    932    1.1  jonathan 		if (size == 0)
    933    1.1  jonathan 			continue;
    934   1.42  christos 		error = copyout(krp->krp_param[i].crp_p,
    935   1.42  christos 		    kop->crk_param[i].crp_p, size);
    936   1.34       tls 		if (error) {
    937   1.90  knakahar 			DPRINTF("copyout oparam %d failed, "
    938   1.90  knakahar 			    "error=%d\n", i-krp->krp_iparams, error);
    939    1.1  jonathan 			goto fail;
    940   1.34       tls 		}
    941    1.1  jonathan 	}
    942    1.1  jonathan 
    943    1.1  jonathan fail:
    944   1.43  christos 	kop->crk_status = krp->krp_status;
    945   1.43  christos 	for (i = 0; i < CRK_MAXPARAM; i++) {
    946   1.43  christos 		struct crparam *kp = &(krp->krp_param[i]);
    947   1.43  christos 		if (krp->krp_param[i].crp_p) {
    948   1.43  christos 			size = (kp->crp_nbits + 7)  / 8;
    949   1.43  christos 			KASSERT(size > 0);
    950   1.43  christos 			(void)memset(kp->crp_p, 0, size);
    951   1.43  christos 			kmem_free(kp->crp_p, size);
    952    1.1  jonathan 		}
    953    1.1  jonathan 	}
    954   1.45    darran 	cv_destroy(&krp->krp_cv);
    955   1.91  knakahar 	crypto_kfreereq(krp);
    956   1.90  knakahar 	DPRINTF("error=0x%08x\n", error);
    957   1.42  christos 	return error;
    958    1.1  jonathan }
    959    1.1  jonathan 
    960    1.1  jonathan /* ARGSUSED */
    961    1.1  jonathan static int
    962   1.36       tls cryptof_close(struct file *fp)
    963    1.1  jonathan {
    964   1.81      matt 	struct fcrypt *fcr = fp->f_fcrypt;
    965    1.1  jonathan 	struct csession *cse;
    966    1.1  jonathan 
    967   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
    968    1.1  jonathan 	while ((cse = TAILQ_FIRST(&fcr->csessions))) {
    969    1.1  jonathan 		TAILQ_REMOVE(&fcr->csessions, cse, next);
    970   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
    971    1.1  jonathan 		(void)csefree(cse);
    972   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
    973    1.1  jonathan 	}
    974   1.36       tls 	seldestroy(&fcr->sinfo);
    975   1.81      matt 	fp->f_fcrypt = NULL;
    976   1.74  pgoyette 	crypto_refcount--;
    977   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
    978    1.1  jonathan 
    979   1.38     rmind 	pool_put(&fcrpl, fcr);
    980    1.1  jonathan 	return 0;
    981    1.1  jonathan }
    982    1.1  jonathan 
    983   1.46    darran /* needed for compatibility module */
    984   1.46    darran struct	csession *cryptodev_csefind(struct fcrypt *fcr, u_int ses)
    985   1.46    darran {
    986   1.46    darran 	return csefind(fcr, ses);
    987   1.46    darran }
    988   1.46    darran 
    989   1.92  knakahar /* csefind: call with cryptodev_mtx held. */
    990    1.1  jonathan static struct csession *
    991    1.1  jonathan csefind(struct fcrypt *fcr, u_int ses)
    992    1.1  jonathan {
    993   1.45    darran 	struct csession *cse, *cnext, *ret = NULL;
    994    1.1  jonathan 
    995   1.92  knakahar 	KASSERT(mutex_owned(&cryptodev_mtx));
    996   1.45    darran 	TAILQ_FOREACH_SAFE(cse, &fcr->csessions, next, cnext)
    997    1.1  jonathan 		if (cse->ses == ses)
    998   1.33       tls 			ret = cse;
    999   1.36       tls 
   1000   1.42  christos 	return ret;
   1001    1.1  jonathan }
   1002    1.1  jonathan 
   1003   1.92  knakahar /* csedelete: call with cryptodev_mtx held. */
   1004    1.1  jonathan static int
   1005    1.1  jonathan csedelete(struct fcrypt *fcr, struct csession *cse_del)
   1006    1.1  jonathan {
   1007   1.45    darran 	struct csession *cse, *cnext;
   1008   1.33       tls 	int ret = 0;
   1009    1.1  jonathan 
   1010   1.92  knakahar 	KASSERT(mutex_owned(&cryptodev_mtx));
   1011   1.45    darran 	TAILQ_FOREACH_SAFE(cse, &fcr->csessions, next, cnext) {
   1012    1.1  jonathan 		if (cse == cse_del) {
   1013    1.1  jonathan 			TAILQ_REMOVE(&fcr->csessions, cse, next);
   1014   1.33       tls 			ret = 1;
   1015    1.1  jonathan 		}
   1016    1.1  jonathan 	}
   1017   1.42  christos 	return ret;
   1018    1.1  jonathan }
   1019    1.1  jonathan 
   1020    1.1  jonathan static struct csession *
   1021    1.1  jonathan cseadd(struct fcrypt *fcr, struct csession *cse)
   1022    1.1  jonathan {
   1023   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   1024   1.33       tls 	/* don't let session ID wrap! */
   1025   1.33       tls 	if (fcr->sesn + 1 == 0) return NULL;
   1026    1.1  jonathan 	TAILQ_INSERT_TAIL(&fcr->csessions, cse, next);
   1027    1.1  jonathan 	cse->ses = fcr->sesn++;
   1028   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   1029   1.42  christos 	return cse;
   1030    1.1  jonathan }
   1031    1.1  jonathan 
   1032    1.1  jonathan static struct csession *
   1033   1.26  christos csecreate(struct fcrypt *fcr, u_int64_t sid, void *key, u_int64_t keylen,
   1034   1.26  christos     void *mackey, u_int64_t mackeylen, u_int32_t cipher, u_int32_t mac,
   1035   1.54  drochner     u_int32_t comp_alg, const struct enc_xform *txform,
   1036   1.54  drochner     const struct auth_hash *thash, const struct comp_algo *tcomp)
   1037    1.1  jonathan {
   1038    1.1  jonathan 	struct csession *cse;
   1039    1.1  jonathan 
   1040   1.29       tls 	cse = pool_get(&csepl, PR_NOWAIT);
   1041    1.1  jonathan 	if (cse == NULL)
   1042    1.1  jonathan 		return NULL;
   1043    1.1  jonathan 	cse->key = key;
   1044    1.1  jonathan 	cse->keylen = keylen/8;
   1045    1.1  jonathan 	cse->mackey = mackey;
   1046    1.1  jonathan 	cse->mackeylen = mackeylen/8;
   1047    1.1  jonathan 	cse->sid = sid;
   1048    1.1  jonathan 	cse->cipher = cipher;
   1049    1.1  jonathan 	cse->mac = mac;
   1050   1.46    darran 	cse->comp_alg = comp_alg;
   1051    1.1  jonathan 	cse->txform = txform;
   1052    1.1  jonathan 	cse->thash = thash;
   1053   1.46    darran 	cse->tcomp = tcomp;
   1054   1.34       tls 	cse->error = 0;
   1055   1.28       tls 	if (cseadd(fcr, cse))
   1056   1.42  christos 		return cse;
   1057   1.28       tls 	else {
   1058   1.33       tls 		pool_put(&csepl, cse);
   1059   1.28       tls 		return NULL;
   1060   1.28       tls 	}
   1061    1.1  jonathan }
   1062    1.1  jonathan 
   1063   1.92  knakahar /* csefree: call with cryptodev_mtx held. */
   1064    1.1  jonathan static int
   1065    1.1  jonathan csefree(struct csession *cse)
   1066    1.1  jonathan {
   1067    1.1  jonathan 	int error;
   1068    1.1  jonathan 
   1069    1.1  jonathan 	error = crypto_freesession(cse->sid);
   1070    1.1  jonathan 	if (cse->key)
   1071   1.36       tls 		free(cse->key, M_XDATA);
   1072    1.1  jonathan 	if (cse->mackey)
   1073   1.36       tls 		free(cse->mackey, M_XDATA);
   1074   1.29       tls 	pool_put(&csepl, cse);
   1075   1.42  christos 	return error;
   1076    1.1  jonathan }
   1077    1.1  jonathan 
   1078    1.1  jonathan static int
   1079   1.25  christos cryptoopen(dev_t dev, int flag, int mode,
   1080   1.25  christos     struct lwp *l)
   1081    1.1  jonathan {
   1082   1.35        ad 	file_t *fp;
   1083   1.29       tls         struct fcrypt *fcr;
   1084   1.29       tls         int fd, error;
   1085   1.29       tls 
   1086    1.1  jonathan 	if (crypto_usercrypto == 0)
   1087   1.42  christos 		return ENXIO;
   1088   1.29       tls 
   1089   1.35        ad 	if ((error = fd_allocfile(&fp, &fd)) != 0)
   1090   1.29       tls 		return error;
   1091   1.29       tls 
   1092   1.29       tls 	fcr = pool_get(&fcrpl, PR_WAITOK);
   1093   1.48  christos 	getnanotime(&fcr->btime);
   1094   1.48  christos 	fcr->atime = fcr->mtime = fcr->btime;
   1095   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   1096   1.29       tls 	TAILQ_INIT(&fcr->csessions);
   1097   1.36       tls 	TAILQ_INIT(&fcr->crp_ret_mq);
   1098   1.36       tls 	TAILQ_INIT(&fcr->crp_ret_mkq);
   1099   1.36       tls 	selinit(&fcr->sinfo);
   1100   1.29       tls 	/*
   1101   1.29       tls 	 * Don't ever return session 0, to allow detection of
   1102   1.29       tls 	 * failed creation attempts with multi-create ioctl.
   1103   1.29       tls 	 */
   1104   1.29       tls 	fcr->sesn = 1;
   1105   1.36       tls 	fcr->requestid = 1;
   1106   1.74  pgoyette 	crypto_refcount++;
   1107   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   1108   1.35        ad 	return fd_clone(fp, fd, flag, &cryptofops, fcr);
   1109    1.1  jonathan }
   1110    1.1  jonathan 
   1111    1.1  jonathan static int
   1112   1.25  christos cryptoread(dev_t dev, struct uio *uio, int ioflag)
   1113    1.1  jonathan {
   1114   1.42  christos 	return EIO;
   1115    1.1  jonathan }
   1116    1.1  jonathan 
   1117    1.1  jonathan static int
   1118   1.25  christos cryptowrite(dev_t dev, struct uio *uio, int ioflag)
   1119    1.1  jonathan {
   1120   1.42  christos 	return EIO;
   1121    1.1  jonathan }
   1122    1.1  jonathan 
   1123    1.1  jonathan int
   1124   1.25  christos cryptoselect(dev_t dev, int rw, struct lwp *l)
   1125    1.1  jonathan {
   1126   1.42  christos 	return 0;
   1127    1.1  jonathan }
   1128    1.1  jonathan 
   1129    1.1  jonathan /*static*/
   1130    1.1  jonathan struct cdevsw crypto_cdevsw = {
   1131   1.78  dholland 	.d_open = cryptoopen,
   1132   1.78  dholland 	.d_close = noclose,
   1133   1.78  dholland 	.d_read = cryptoread,
   1134   1.78  dholland 	.d_write = cryptowrite,
   1135   1.78  dholland 	.d_ioctl = noioctl,
   1136   1.78  dholland 	.d_stop = nostop,
   1137   1.78  dholland 	.d_tty = notty,
   1138   1.78  dholland 	.d_poll = cryptoselect /*nopoll*/,
   1139   1.78  dholland 	.d_mmap = nommap,
   1140   1.78  dholland 	.d_kqfilter = nokqfilter,
   1141   1.79  dholland 	.d_discard = nodiscard,
   1142   1.78  dholland 	.d_flag = D_OTHER
   1143    1.1  jonathan };
   1144    1.1  jonathan 
   1145   1.46    darran int
   1146   1.36       tls cryptodev_mop(struct fcrypt *fcr,
   1147   1.36       tls               struct crypt_n_op * cnop,
   1148   1.36       tls               int count, struct lwp *l)
   1149   1.36       tls {
   1150   1.36       tls 	struct cryptop *crp = NULL;
   1151   1.46    darran 	struct cryptodesc *crde = NULL, *crda = NULL, *crdc = NULL;
   1152   1.36       tls 	int req, error=0;
   1153   1.36       tls 	struct csession *cse;
   1154   1.46    darran 	int flags=0;
   1155   1.46    darran 	int iov_len;
   1156   1.36       tls 
   1157   1.36       tls 	for (req = 0; req < count; req++) {
   1158   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
   1159   1.36       tls 		cse = csefind(fcr, cnop[req].ses);
   1160   1.36       tls 		if (cse == NULL) {
   1161   1.90  knakahar 			DPRINTF("csefind failed\n");
   1162   1.36       tls 			cnop[req].status = EINVAL;
   1163   1.92  knakahar 			mutex_exit(&cryptodev_mtx);
   1164   1.36       tls 			continue;
   1165   1.36       tls 		}
   1166   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
   1167   1.36       tls 
   1168   1.36       tls 		if (cnop[req].len > 256*1024-4) {
   1169   1.90  knakahar 			DPRINTF("length failed\n");
   1170   1.36       tls 			cnop[req].status = EINVAL;
   1171   1.36       tls 			continue;
   1172   1.36       tls 		}
   1173   1.36       tls 		if (cse->txform) {
   1174   1.58  drochner 			if (cnop[req].len < cse->txform->blocksize -
   1175   1.58  drochner 			    (cnop[req].iv ? 0 : cse->txform->ivsize) ||
   1176   1.58  drochner 			    (cnop[req].len -
   1177   1.58  drochner 			     (cnop[req].iv ? 0 : cse->txform->ivsize))
   1178   1.58  drochner 			    % cse->txform->blocksize) {
   1179   1.36       tls 				cnop[req].status = EINVAL;
   1180   1.36       tls 				continue;
   1181   1.36       tls 			}
   1182   1.36       tls 		}
   1183   1.36       tls 
   1184   1.94  knakahar 		/* sanitize */
   1185   1.94  knakahar 		if (cnop[req].len <= 0) {
   1186   1.94  knakahar 			cnop[req].status = ENOMEM;
   1187   1.94  knakahar 			goto bail;
   1188   1.94  knakahar 		}
   1189   1.94  knakahar 
   1190   1.42  christos 		crp = crypto_getreq((cse->txform != NULL) +
   1191   1.46    darran 				    (cse->thash != NULL) +
   1192   1.46    darran 				    (cse->tcomp != NULL));
   1193   1.36       tls 		if (crp == NULL) {
   1194   1.36       tls 			cnop[req].status = ENOMEM;
   1195   1.36       tls 			goto bail;
   1196   1.36       tls 		}
   1197   1.36       tls 
   1198   1.46    darran 		iov_len = cnop[req].len;
   1199   1.46    darran 		/* got a compression/decompression max size? */
   1200   1.46    darran 		if ((cse->tcomp) && cnop[req].dst_len) {
   1201   1.46    darran 			if (iov_len < cnop[req].dst_len) {
   1202   1.46    darran 				/* Need larger iov to deal with decompress */
   1203   1.46    darran 				iov_len = cnop[req].dst_len;
   1204   1.46    darran 			}
   1205   1.90  knakahar 			DPRINTF("iov_len -> %d for decompress\n", iov_len);
   1206   1.46    darran 		}
   1207   1.46    darran 
   1208   1.42  christos 		(void)memset(&crp->uio, 0, sizeof(crp->uio));
   1209   1.36       tls 		crp->uio.uio_iovcnt = 1;
   1210   1.36       tls 		crp->uio.uio_resid = 0;
   1211   1.36       tls 		crp->uio.uio_rw = UIO_WRITE;
   1212   1.36       tls 		crp->uio.uio_iov = crp->iovec;
   1213   1.36       tls 		UIO_SETUP_SYSSPACE(&crp->uio);
   1214   1.36       tls 		memset(&crp->iovec, 0, sizeof(crp->iovec));
   1215   1.46    darran 		crp->uio.uio_iov[0].iov_len = iov_len;
   1216   1.90  knakahar 		DPRINTF("kmem_alloc(%d) for iov \n", iov_len);
   1217   1.46    darran 		crp->uio.uio_iov[0].iov_base = kmem_alloc(iov_len, KM_SLEEP);
   1218   1.36       tls 		crp->uio.uio_resid = crp->uio.uio_iov[0].iov_len;
   1219   1.36       tls 
   1220   1.46    darran 		if (cse->tcomp) {
   1221   1.46    darran 			crdc = crp->crp_desc;
   1222   1.46    darran 		}
   1223   1.46    darran 
   1224   1.36       tls 		if (cse->thash) {
   1225   1.46    darran 			crda = crdc ? crdc->crd_next : crp->crp_desc;
   1226   1.44  christos 			if (cse->txform && crda)
   1227   1.36       tls 				crde = crda->crd_next;
   1228   1.36       tls 		} else {
   1229   1.46    darran 			if (cse->txform) {
   1230   1.46    darran 				crde = crdc ? crdc->crd_next : crp->crp_desc;
   1231   1.46    darran 			} else if (!cse->tcomp) {
   1232   1.46    darran 				error = EINVAL;
   1233   1.46    darran 				goto bail;
   1234   1.36       tls 			}
   1235   1.36       tls 		}
   1236   1.36       tls 
   1237   1.36       tls 		if ((copyin(cnop[req].src,
   1238   1.36       tls 		    crp->uio.uio_iov[0].iov_base, cnop[req].len))) {
   1239   1.36       tls 			cnop[req].status = EINVAL;
   1240   1.36       tls 			goto bail;
   1241   1.36       tls 		}
   1242   1.46    darran 
   1243   1.46    darran 		if (crdc) {
   1244   1.46    darran 			switch (cnop[req].op) {
   1245   1.46    darran 			case COP_COMP:
   1246   1.46    darran 				crdc->crd_flags |= CRD_F_COMP;
   1247   1.46    darran 				break;
   1248   1.46    darran 			case COP_DECOMP:
   1249   1.46    darran 				crdc->crd_flags &= ~CRD_F_COMP;
   1250   1.46    darran 				break;
   1251   1.46    darran 			default:
   1252   1.46    darran 				break;
   1253   1.46    darran 			}
   1254   1.46    darran 			/* more data to follow? */
   1255   1.46    darran 			if (cnop[req].flags & COP_F_MORE) {
   1256   1.46    darran 				flags |= CRYPTO_F_MORE;
   1257   1.46    darran 			}
   1258   1.46    darran 			crdc->crd_len = cnop[req].len;
   1259   1.46    darran 			crdc->crd_inject = 0;
   1260   1.46    darran 
   1261   1.46    darran 			crdc->crd_alg = cse->comp_alg;
   1262   1.46    darran 			crdc->crd_key = NULL;
   1263   1.46    darran 			crdc->crd_klen = 0;
   1264   1.90  knakahar 			DPRINTF("cse->sid[%d]: crdc setup for comp_alg %d"
   1265   1.46    darran 				 " len %d.\n",
   1266   1.46    darran 				(uint32_t)cse->sid, crdc->crd_alg,
   1267   1.90  knakahar 				crdc->crd_len);
   1268   1.46    darran 		}
   1269   1.36       tls 
   1270   1.36       tls 		if (crda) {
   1271   1.36       tls 			crda->crd_skip = 0;
   1272   1.36       tls 			crda->crd_len = cnop[req].len;
   1273   1.36       tls 			crda->crd_inject = 0;	/* ??? */
   1274   1.36       tls 
   1275   1.36       tls 			crda->crd_alg = cse->mac;
   1276   1.36       tls 			crda->crd_key = cse->mackey;
   1277   1.36       tls 			crda->crd_klen = cse->mackeylen * 8;
   1278   1.36       tls 		}
   1279   1.36       tls 
   1280   1.36       tls 		if (crde) {
   1281   1.36       tls 			if (cnop[req].op == COP_ENCRYPT)
   1282   1.36       tls 				crde->crd_flags |= CRD_F_ENCRYPT;
   1283   1.36       tls 			else
   1284   1.36       tls 				crde->crd_flags &= ~CRD_F_ENCRYPT;
   1285   1.36       tls 			crde->crd_len = cnop[req].len;
   1286   1.36       tls 			crde->crd_inject = 0;
   1287   1.36       tls 
   1288   1.36       tls 			crde->crd_alg = cse->cipher;
   1289   1.36       tls #ifdef notyet		/* XXX must notify h/w driver new key, drain */
   1290   1.36       tls 			if(cnop[req].key && cnop[req].keylen) {
   1291   1.36       tls 				crde->crd_key = malloc(cnop[req].keylen,
   1292   1.36       tls 						    M_XDATA, M_WAITOK);
   1293   1.36       tls 				if((error = copyin(cnop[req].key,
   1294   1.36       tls 				    crde->crd_key, cnop[req].keylen))) {
   1295   1.36       tls 					cnop[req].status = EINVAL;
   1296   1.36       tls 					goto bail;
   1297   1.36       tls 				}
   1298   1.36       tls 				crde->crd_klen =  cnop[req].keylen * 8;
   1299   1.36       tls 			} else { ... }
   1300   1.36       tls #endif
   1301   1.36       tls 			crde->crd_key = cse->key;
   1302   1.36       tls 			crde->crd_klen = cse->keylen * 8;
   1303   1.36       tls 		}
   1304   1.36       tls 
   1305   1.36       tls 		crp->crp_ilen = cnop[req].len;
   1306   1.42  christos 		crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM |
   1307   1.46    darran 		    (cnop[req].flags & COP_F_BATCH) | flags;
   1308   1.36       tls 		crp->crp_buf = (void *)&crp->uio;
   1309   1.36       tls 		crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_mcb;
   1310   1.36       tls 		crp->crp_sid = cse->sid;
   1311   1.36       tls 		crp->crp_opaque = (void *)cse;
   1312   1.36       tls 		crp->fcrp = fcr;
   1313   1.36       tls 		crp->dst = cnop[req].dst;
   1314   1.46    darran 		crp->len = cnop[req].len; /* input len, iov may be larger */
   1315   1.36       tls 		crp->mac = cnop[req].mac;
   1316   1.90  knakahar 		DPRINTF("iov_base %p dst %p len %d mac %p\n",
   1317   1.46    darran 			    crp->uio.uio_iov[0].iov_base, crp->dst, crp->len,
   1318   1.90  knakahar 			    crp->mac);
   1319   1.36       tls 
   1320   1.36       tls 		if (cnop[req].iv) {
   1321   1.36       tls 			if (crde == NULL) {
   1322   1.36       tls 				cnop[req].status = EINVAL;
   1323   1.36       tls 				goto bail;
   1324   1.36       tls 			}
   1325   1.36       tls 			if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
   1326   1.36       tls 				cnop[req].status = EINVAL;
   1327   1.36       tls 				goto bail;
   1328   1.36       tls 			}
   1329   1.36       tls 			if ((error = copyin(cnop[req].iv, crp->tmp_iv,
   1330   1.58  drochner 			    cse->txform->ivsize))) {
   1331   1.36       tls 				cnop[req].status = EINVAL;
   1332   1.36       tls 				goto bail;
   1333   1.36       tls 			}
   1334   1.42  christos 			(void)memcpy(crde->crd_iv, crp->tmp_iv,
   1335   1.58  drochner 			    cse->txform->ivsize);
   1336   1.36       tls 			crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
   1337   1.36       tls 			crde->crd_skip = 0;
   1338   1.36       tls 		} else if (crde) {
   1339   1.36       tls 			if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
   1340   1.36       tls 				crde->crd_skip = 0;
   1341   1.36       tls 			} else {
   1342   1.61  drochner 				if (!(crde->crd_flags & CRD_F_ENCRYPT))
   1343   1.61  drochner 					crde->crd_flags |= CRD_F_IV_PRESENT;
   1344   1.58  drochner 				crde->crd_skip = cse->txform->ivsize;
   1345   1.58  drochner 				crde->crd_len -= cse->txform->ivsize;
   1346   1.36       tls 			}
   1347   1.36       tls 		}
   1348   1.36       tls 
   1349   1.36       tls 		if (cnop[req].mac) {
   1350   1.36       tls 			if (crda == NULL) {
   1351   1.36       tls 				cnop[req].status = EINVAL;
   1352   1.36       tls 				goto bail;
   1353   1.36       tls 			}
   1354   1.36       tls 			crp->crp_mac=cse->tmp_mac;
   1355   1.36       tls 		}
   1356   1.36       tls 		cnop[req].reqid = atomic_inc_32_nv(&(fcr->requestid));
   1357   1.36       tls 		crp->crp_reqid = cnop[req].reqid;
   1358   1.36       tls 		crp->crp_usropaque = cnop[req].opaque;
   1359   1.67  drochner 		cv_init(&crp->crp_cv, "crydev");
   1360   1.36       tls #ifdef notyet
   1361   1.36       tls eagain:
   1362   1.36       tls #endif
   1363   1.36       tls 		cnop[req].status = crypto_dispatch(crp);
   1364   1.92  knakahar 		mutex_enter(&cryptodev_mtx);	/* XXX why mutex? */
   1365   1.36       tls 
   1366   1.36       tls 		switch (cnop[req].status) {
   1367   1.36       tls #ifdef notyet	/* don't loop forever -- but EAGAIN not possible here yet */
   1368   1.36       tls 		case EAGAIN:
   1369   1.92  knakahar 			mutex_exit(&cryptodev_mtx);
   1370   1.36       tls 			goto eagain;
   1371   1.36       tls 			break;
   1372   1.36       tls #endif
   1373   1.36       tls 		case 0:
   1374   1.36       tls 			break;
   1375   1.36       tls 		default:
   1376   1.90  knakahar 			DPRINTF("not waiting, error.\n");
   1377   1.92  knakahar 			mutex_exit(&cryptodev_mtx);
   1378   1.67  drochner 			cv_destroy(&crp->crp_cv);
   1379   1.36       tls 			goto bail;
   1380   1.36       tls 		}
   1381   1.36       tls 
   1382   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
   1383   1.67  drochner 		cv_destroy(&crp->crp_cv);
   1384   1.36       tls bail:
   1385   1.36       tls 		if (cnop[req].status) {
   1386   1.36       tls 			if (crp) {
   1387   1.46    darran 				if (crp->uio.uio_iov[0].iov_base) {
   1388   1.46    darran 					kmem_free(crp->uio.uio_iov[0].iov_base,
   1389   1.46    darran 					    crp->uio.uio_iov[0].iov_len);
   1390   1.46    darran 				}
   1391   1.36       tls 				crypto_freereq(crp);
   1392   1.36       tls 			}
   1393   1.36       tls 			error = 0;
   1394   1.36       tls 		}
   1395   1.36       tls 	}
   1396   1.42  christos 	return error;
   1397   1.36       tls }
   1398   1.36       tls 
   1399   1.36       tls static int
   1400   1.36       tls cryptodev_mkey(struct fcrypt *fcr, struct crypt_n_kop *kop, int count)
   1401   1.36       tls {
   1402   1.36       tls 	struct cryptkop *krp = NULL;
   1403   1.36       tls 	int error = EINVAL;
   1404   1.36       tls 	int in, out, size, i, req;
   1405   1.36       tls 
   1406   1.36       tls 	for (req = 0; req < count; req++) {
   1407   1.42  christos 		if (kop[req].crk_iparams + kop[req].crk_oparams > CRK_MAXPARAM)
   1408   1.42  christos 			return EFBIG;
   1409   1.36       tls 
   1410   1.36       tls 		in = kop[req].crk_iparams;
   1411   1.36       tls 		out = kop[req].crk_oparams;
   1412   1.36       tls 		switch (kop[req].crk_op) {
   1413   1.36       tls 		case CRK_MOD_EXP:
   1414   1.36       tls 			if (in == 3 && out == 1)
   1415   1.36       tls 				break;
   1416   1.36       tls 			kop[req].crk_status = EINVAL;
   1417   1.36       tls 			continue;
   1418   1.36       tls 		case CRK_MOD_EXP_CRT:
   1419   1.36       tls 			if (in == 6 && out == 1)
   1420   1.36       tls 				break;
   1421   1.36       tls 			kop[req].crk_status = EINVAL;
   1422   1.36       tls 			continue;
   1423   1.36       tls 		case CRK_DSA_SIGN:
   1424   1.36       tls 			if (in == 5 && out == 2)
   1425   1.36       tls 				break;
   1426   1.36       tls 			kop[req].crk_status = EINVAL;
   1427   1.36       tls 			continue;
   1428   1.36       tls 		case CRK_DSA_VERIFY:
   1429   1.36       tls 			if (in == 7 && out == 0)
   1430   1.36       tls 				break;
   1431   1.36       tls 			kop[req].crk_status = EINVAL;
   1432   1.36       tls 			continue;
   1433   1.36       tls 		case CRK_DH_COMPUTE_KEY:
   1434   1.36       tls 			if (in == 3 && out == 1)
   1435   1.36       tls 				break;
   1436   1.36       tls 			kop[req].crk_status = EINVAL;
   1437   1.36       tls 			continue;
   1438   1.36       tls 		case CRK_MOD_ADD:
   1439   1.36       tls 			if (in == 3 && out == 1)
   1440   1.36       tls 				break;
   1441   1.36       tls 			kop[req].crk_status = EINVAL;
   1442   1.36       tls 			continue;
   1443   1.36       tls 		case CRK_MOD_ADDINV:
   1444   1.36       tls 			if (in == 2 && out == 1)
   1445   1.36       tls 				break;
   1446   1.36       tls 			kop[req].crk_status = EINVAL;
   1447   1.36       tls 			continue;
   1448   1.36       tls 		case CRK_MOD_SUB:
   1449   1.36       tls 			if (in == 3 && out == 1)
   1450   1.36       tls 				break;
   1451   1.36       tls 			kop[req].crk_status = EINVAL;
   1452   1.36       tls 			continue;
   1453   1.36       tls 		case CRK_MOD_MULT:
   1454   1.36       tls 			if (in == 3 && out == 1)
   1455   1.85   msaitoh 				break;
   1456   1.36       tls 			kop[req].crk_status = EINVAL;
   1457   1.36       tls 			continue;
   1458   1.36       tls 		case CRK_MOD_MULTINV:
   1459   1.36       tls 			if (in == 2 && out == 1)
   1460   1.36       tls 				break;
   1461   1.36       tls 			kop[req].crk_status = EINVAL;
   1462   1.36       tls 			continue;
   1463   1.36       tls 		case CRK_MOD:
   1464   1.36       tls 			if (in == 2 && out == 1)
   1465   1.36       tls 				break;
   1466   1.36       tls 			kop[req].crk_status = EINVAL;
   1467   1.36       tls 			continue;
   1468   1.36       tls 		default:
   1469   1.36       tls 			kop[req].crk_status = EINVAL;
   1470   1.36       tls 			continue;
   1471   1.36       tls 		}
   1472   1.36       tls 
   1473   1.91  knakahar 		krp = crypto_kgetreq(1, PR_WAITOK);
   1474   1.91  knakahar 		if (krp == NULL) {
   1475   1.91  knakahar 			/* limited by opencrypto.crypto_ret_kq.maxlen */
   1476   1.91  knakahar 			continue;
   1477   1.91  knakahar 		}
   1478   1.42  christos 		(void)memset(krp, 0, sizeof *krp);
   1479   1.36       tls 		cv_init(&krp->krp_cv, "crykdev");
   1480   1.36       tls 		krp->krp_op = kop[req].crk_op;
   1481   1.36       tls 		krp->krp_status = kop[req].crk_status;
   1482   1.36       tls 		krp->krp_iparams = kop[req].crk_iparams;
   1483   1.36       tls 		krp->krp_oparams = kop[req].crk_oparams;
   1484   1.36       tls 		krp->krp_status = 0;
   1485   1.36       tls 		krp->krp_callback =
   1486   1.36       tls 		    (int (*) (struct cryptkop *)) cryptodevkey_mcb;
   1487   1.42  christos 		(void)memcpy(krp->crk_param, kop[req].crk_param,
   1488   1.42  christos 		    sizeof(kop[req].crk_param));
   1489   1.36       tls 
   1490   1.36       tls 		krp->krp_flags = CRYPTO_F_CBIMM;
   1491   1.36       tls 
   1492   1.36       tls 		for (i = 0; i < CRK_MAXPARAM; i++)
   1493   1.36       tls 			krp->krp_param[i].crp_nbits =
   1494   1.36       tls 			    kop[req].crk_param[i].crp_nbits;
   1495   1.36       tls 		for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
   1496   1.36       tls 			size = (krp->krp_param[i].crp_nbits + 7) / 8;
   1497   1.36       tls 			if (size == 0)
   1498   1.36       tls 				continue;
   1499   1.36       tls 			krp->krp_param[i].crp_p =
   1500   1.36       tls 			    kmem_alloc(size, KM_SLEEP);
   1501   1.36       tls 			if (i >= krp->krp_iparams)
   1502   1.36       tls 				continue;
   1503   1.42  christos 			kop[req].crk_status =
   1504   1.42  christos 			    copyin(kop[req].crk_param[i].crp_p,
   1505   1.42  christos 			    krp->krp_param[i].crp_p, size);
   1506   1.36       tls 			if (kop[req].crk_status)
   1507   1.36       tls 				goto fail;
   1508   1.36       tls 		}
   1509   1.36       tls 		krp->fcrp = fcr;
   1510   1.36       tls 
   1511   1.36       tls 		kop[req].crk_reqid = atomic_inc_32_nv(&(fcr->requestid));
   1512   1.36       tls 		krp->krp_reqid = kop[req].crk_reqid;
   1513   1.36       tls 		krp->krp_usropaque = kop[req].crk_opaque;
   1514   1.36       tls 
   1515   1.36       tls 		kop[req].crk_status = crypto_kdispatch(krp);
   1516   1.36       tls 		if (kop[req].crk_status != 0) {
   1517   1.36       tls 			goto fail;
   1518   1.36       tls 		}
   1519   1.36       tls 
   1520   1.36       tls fail:
   1521   1.36       tls 		if(kop[req].crk_status) {
   1522   1.36       tls 			if (krp) {
   1523   1.36       tls 				kop[req].crk_status = krp->krp_status;
   1524   1.36       tls 				for (i = 0; i < CRK_MAXPARAM; i++) {
   1525   1.36       tls 					struct crparam *kp =
   1526   1.36       tls 						&(krp->krp_param[i]);
   1527   1.36       tls 					if (kp->crp_p) {
   1528   1.36       tls 						size = (kp->crp_nbits + 7) / 8;
   1529   1.36       tls 						KASSERT(size > 0);
   1530   1.36       tls 						memset(kp->crp_p, 0, size);
   1531   1.36       tls 						kmem_free(kp->crp_p, size);
   1532   1.36       tls 					}
   1533   1.36       tls 				}
   1534   1.45    darran 				cv_destroy(&krp->krp_cv);
   1535   1.91  knakahar 				crypto_kfreereq(krp);
   1536   1.36       tls 			}
   1537   1.36       tls 		}
   1538   1.36       tls 		error = 0;
   1539   1.36       tls 	}
   1540   1.90  knakahar 	DPRINTF("error=0x%08x\n", error);
   1541   1.42  christos 	return error;
   1542   1.36       tls }
   1543   1.36       tls 
   1544   1.46    darran int
   1545   1.45    darran cryptodev_session(struct fcrypt *fcr, struct session_op *sop)
   1546   1.45    darran {
   1547   1.36       tls 	struct cryptoini cria, crie;
   1548   1.46    darran 	struct cryptoini cric;		/* compressor */
   1549   1.46    darran 	struct cryptoini *crihead = NULL;
   1550   1.54  drochner 	const struct enc_xform *txform = NULL;
   1551   1.54  drochner 	const struct auth_hash *thash = NULL;
   1552   1.54  drochner 	const struct comp_algo *tcomp = NULL;
   1553   1.36       tls 	struct csession *cse;
   1554   1.36       tls 	u_int64_t sid;
   1555   1.36       tls 	int error = 0;
   1556   1.36       tls 
   1557   1.90  knakahar 	DPRINTF("cipher=%d, mac=%d\n", sop->cipher, sop->mac);
   1558   1.46    darran 
   1559   1.36       tls 	/* XXX there must be a way to not embed the list of xforms here */
   1560   1.36       tls 	switch (sop->cipher) {
   1561   1.36       tls 	case 0:
   1562   1.36       tls 		break;
   1563   1.36       tls 	case CRYPTO_DES_CBC:
   1564   1.36       tls 		txform = &enc_xform_des;
   1565   1.36       tls 		break;
   1566   1.36       tls 	case CRYPTO_3DES_CBC:
   1567   1.36       tls 		txform = &enc_xform_3des;
   1568   1.36       tls 		break;
   1569   1.36       tls 	case CRYPTO_BLF_CBC:
   1570   1.36       tls 		txform = &enc_xform_blf;
   1571   1.36       tls 		break;
   1572   1.36       tls 	case CRYPTO_CAST_CBC:
   1573   1.36       tls 		txform = &enc_xform_cast5;
   1574   1.52   hubertf 		break;
   1575   1.36       tls 	case CRYPTO_SKIPJACK_CBC:
   1576   1.36       tls 		txform = &enc_xform_skipjack;
   1577   1.36       tls 		break;
   1578   1.36       tls 	case CRYPTO_AES_CBC:
   1579   1.36       tls 		txform = &enc_xform_rijndael128;
   1580   1.36       tls 		break;
   1581   1.60  drochner 	case CRYPTO_CAMELLIA_CBC:
   1582   1.60  drochner 		txform = &enc_xform_camellia;
   1583   1.60  drochner 		break;
   1584   1.59  drochner 	case CRYPTO_AES_CTR:
   1585   1.59  drochner 		txform = &enc_xform_aes_ctr;
   1586   1.59  drochner 		break;
   1587   1.66  drochner 	case CRYPTO_AES_GCM_16:
   1588   1.66  drochner 		txform = &enc_xform_aes_gcm;
   1589   1.66  drochner 		break;
   1590   1.66  drochner 	case CRYPTO_AES_GMAC:
   1591   1.66  drochner 		txform = &enc_xform_aes_gmac;
   1592   1.66  drochner 		break;
   1593   1.36       tls 	case CRYPTO_NULL_CBC:
   1594   1.36       tls 		txform = &enc_xform_null;
   1595   1.36       tls 		break;
   1596   1.36       tls 	case CRYPTO_ARC4:
   1597   1.36       tls 		txform = &enc_xform_arc4;
   1598   1.36       tls 		break;
   1599   1.36       tls 	default:
   1600   1.90  knakahar 		DPRINTF("Invalid cipher %d\n", sop->cipher);
   1601   1.36       tls 		return EINVAL;
   1602   1.36       tls 	}
   1603   1.36       tls 
   1604   1.46    darran 	switch (sop->comp_alg) {
   1605   1.46    darran 	case 0:
   1606   1.46    darran 		break;
   1607   1.46    darran 	case CRYPTO_DEFLATE_COMP:
   1608   1.46    darran 		tcomp = &comp_algo_deflate;
   1609   1.46    darran 		break;
   1610   1.46    darran 	case CRYPTO_GZIP_COMP:
   1611   1.46    darran 		tcomp = &comp_algo_gzip;
   1612   1.90  knakahar 		DPRINTF("tcomp for GZIP\n");
   1613   1.46    darran 		break;
   1614   1.46    darran 	default:
   1615   1.90  knakahar 		DPRINTF("Invalid compression alg %d\n", sop->comp_alg);
   1616   1.46    darran 		return EINVAL;
   1617   1.46    darran 	}
   1618   1.46    darran 
   1619   1.36       tls 	switch (sop->mac) {
   1620   1.36       tls 	case 0:
   1621   1.36       tls 		break;
   1622   1.36       tls 	case CRYPTO_MD5_HMAC:
   1623   1.36       tls 		thash = &auth_hash_hmac_md5;
   1624   1.36       tls 		break;
   1625   1.36       tls 	case CRYPTO_SHA1_HMAC:
   1626   1.36       tls 		thash = &auth_hash_hmac_sha1;
   1627   1.36       tls 		break;
   1628   1.36       tls 	case CRYPTO_MD5_HMAC_96:
   1629   1.36       tls 		thash = &auth_hash_hmac_md5_96;
   1630   1.36       tls 		break;
   1631   1.36       tls 	case CRYPTO_SHA1_HMAC_96:
   1632   1.36       tls 		thash = &auth_hash_hmac_sha1_96;
   1633   1.36       tls 		break;
   1634   1.36       tls 	case CRYPTO_SHA2_HMAC:
   1635   1.36       tls 		/* XXX switching on key length seems questionable */
   1636   1.36       tls 		if (sop->mackeylen == auth_hash_hmac_sha2_256.keysize) {
   1637   1.36       tls 			thash = &auth_hash_hmac_sha2_256;
   1638   1.36       tls 		} else if (sop->mackeylen == auth_hash_hmac_sha2_384.keysize) {
   1639   1.36       tls 			thash = &auth_hash_hmac_sha2_384;
   1640   1.36       tls 		} else if (sop->mackeylen == auth_hash_hmac_sha2_512.keysize) {
   1641   1.36       tls 			thash = &auth_hash_hmac_sha2_512;
   1642   1.36       tls 		} else {
   1643   1.90  knakahar 			DPRINTF("Invalid mackeylen %d\n", sop->mackeylen);
   1644   1.36       tls 			return EINVAL;
   1645   1.36       tls 		}
   1646   1.36       tls 		break;
   1647  1.102    hikaru 	case CRYPTO_SHA2_384_HMAC:
   1648  1.102    hikaru 		thash = &auth_hash_hmac_sha2_384;
   1649  1.102    hikaru 		break;
   1650  1.102    hikaru 	case CRYPTO_SHA2_512_HMAC:
   1651  1.102    hikaru 		thash = &auth_hash_hmac_sha2_512;
   1652  1.102    hikaru 		break;
   1653   1.36       tls 	case CRYPTO_RIPEMD160_HMAC:
   1654   1.36       tls 		thash = &auth_hash_hmac_ripemd_160;
   1655   1.36       tls 		break;
   1656   1.36       tls 	case CRYPTO_RIPEMD160_HMAC_96:
   1657   1.36       tls 		thash = &auth_hash_hmac_ripemd_160_96;
   1658   1.36       tls 		break;
   1659   1.36       tls 	case CRYPTO_MD5:
   1660   1.36       tls 		thash = &auth_hash_md5;
   1661   1.36       tls 		break;
   1662   1.36       tls 	case CRYPTO_SHA1:
   1663   1.36       tls 		thash = &auth_hash_sha1;
   1664   1.36       tls 		break;
   1665   1.63  drochner 	case CRYPTO_AES_XCBC_MAC_96:
   1666   1.63  drochner 		thash = &auth_hash_aes_xcbc_mac_96;
   1667   1.63  drochner 		break;
   1668   1.66  drochner 	case CRYPTO_AES_128_GMAC:
   1669   1.66  drochner 		thash = &auth_hash_gmac_aes_128;
   1670   1.66  drochner 		break;
   1671   1.66  drochner 	case CRYPTO_AES_192_GMAC:
   1672   1.66  drochner 		thash = &auth_hash_gmac_aes_192;
   1673   1.66  drochner 		break;
   1674   1.66  drochner 	case CRYPTO_AES_256_GMAC:
   1675   1.66  drochner 		thash = &auth_hash_gmac_aes_256;
   1676   1.66  drochner 		break;
   1677   1.36       tls 	case CRYPTO_NULL_HMAC:
   1678   1.36       tls 		thash = &auth_hash_null;
   1679   1.36       tls 		break;
   1680   1.36       tls 	default:
   1681   1.90  knakahar 		DPRINTF("Invalid mac %d\n", sop->mac);
   1682   1.42  christos 		return EINVAL;
   1683   1.36       tls 	}
   1684   1.36       tls 
   1685   1.36       tls 	memset(&crie, 0, sizeof(crie));
   1686   1.36       tls 	memset(&cria, 0, sizeof(cria));
   1687   1.46    darran 	memset(&cric, 0, sizeof(cric));
   1688   1.46    darran 
   1689   1.46    darran 	if (tcomp) {
   1690   1.46    darran 		cric.cri_alg = tcomp->type;
   1691   1.46    darran 		cric.cri_klen = 0;
   1692   1.90  knakahar 		DPRINTF("tcomp->type = %d\n", tcomp->type);
   1693   1.46    darran 
   1694   1.46    darran 		crihead = &cric;
   1695   1.65  drochner 		if (txform) {
   1696   1.65  drochner 			cric.cri_next = &crie;
   1697   1.65  drochner 		} else if (thash) {
   1698   1.46    darran 			cric.cri_next = &cria;
   1699   1.46    darran 		}
   1700   1.46    darran 	}
   1701   1.36       tls 
   1702   1.36       tls 	if (txform) {
   1703   1.36       tls 		crie.cri_alg = txform->type;
   1704   1.36       tls 		crie.cri_klen = sop->keylen * 8;
   1705   1.36       tls 		if (sop->keylen > txform->maxkey ||
   1706   1.36       tls 		    sop->keylen < txform->minkey) {
   1707   1.90  knakahar 			DPRINTF("keylen %d not in [%d,%d]\n",
   1708   1.90  knakahar 			    sop->keylen, txform->minkey, txform->maxkey);
   1709   1.42  christos 			error = EINVAL;
   1710   1.36       tls 			goto bail;
   1711   1.36       tls 		}
   1712   1.36       tls 
   1713   1.36       tls 		crie.cri_key = malloc(crie.cri_klen / 8, M_XDATA, M_WAITOK);
   1714   1.42  christos 		if ((error = copyin(sop->key, crie.cri_key, crie.cri_klen / 8)))
   1715   1.36       tls 			goto bail;
   1716   1.46    darran 		if (!crihead) {
   1717   1.46    darran 			crihead = &crie;
   1718   1.46    darran 		}
   1719   1.65  drochner 		if (thash)
   1720   1.65  drochner 			crie.cri_next = &cria;
   1721   1.46    darran 	}
   1722   1.36       tls 
   1723   1.36       tls 	if (thash) {
   1724   1.36       tls 		cria.cri_alg = thash->type;
   1725   1.36       tls 		cria.cri_klen = sop->mackeylen * 8;
   1726   1.36       tls 		if (sop->mackeylen != thash->keysize) {
   1727   1.90  knakahar 			DPRINTF("mackeylen %d != keysize %d\n",
   1728   1.90  knakahar 			    sop->mackeylen, thash->keysize);
   1729   1.36       tls 			error = EINVAL;
   1730   1.36       tls 			goto bail;
   1731   1.36       tls 		}
   1732   1.36       tls 		if (cria.cri_klen) {
   1733   1.36       tls 			cria.cri_key = malloc(cria.cri_klen / 8, M_XDATA,
   1734   1.42  christos 			    M_WAITOK);
   1735   1.36       tls 			if ((error = copyin(sop->mackey, cria.cri_key,
   1736   1.42  christos 			    cria.cri_klen / 8))) {
   1737   1.36       tls 				goto bail;
   1738   1.36       tls 			}
   1739   1.36       tls 		}
   1740   1.46    darran 		if (!crihead) {
   1741   1.46    darran 			crihead = &cria;
   1742   1.46    darran 		}
   1743   1.36       tls 	}
   1744   1.46    darran 
   1745   1.46    darran 	error = crypto_newsession(&sid, crihead, crypto_devallowsoft);
   1746   1.36       tls 	if (!error) {
   1747   1.90  knakahar 		DPRINTF("got session %d\n", (uint32_t)sid);
   1748   1.36       tls 		cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen,
   1749   1.46    darran 		    cria.cri_key, cria.cri_klen, (txform ? sop->cipher : 0), sop->mac,
   1750   1.46    darran 		    (tcomp ? sop->comp_alg : 0), txform, thash, tcomp);
   1751   1.36       tls 		if (cse != NULL) {
   1752   1.36       tls 			sop->ses = cse->ses;
   1753   1.36       tls 		} else {
   1754   1.90  knakahar 			DPRINTF("csecreate failed\n");
   1755   1.36       tls 			crypto_freesession(sid);
   1756   1.36       tls 			error = EINVAL;
   1757   1.36       tls 		}
   1758   1.36       tls 	} else {
   1759   1.90  knakahar 		DPRINTF("SIOCSESSION violates kernel parameters %d\n", error);
   1760   1.36       tls 	}
   1761   1.36       tls bail:
   1762   1.36       tls 	if (error) {
   1763   1.36       tls 		if (crie.cri_key) {
   1764   1.36       tls 			memset(crie.cri_key, 0, crie.cri_klen / 8);
   1765   1.36       tls 			free(crie.cri_key, M_XDATA);
   1766   1.36       tls 		}
   1767   1.36       tls 		if (cria.cri_key) {
   1768   1.36       tls 			memset(cria.cri_key, 0, cria.cri_klen / 8);
   1769   1.36       tls 			free(cria.cri_key, M_XDATA);
   1770   1.36       tls 		}
   1771   1.36       tls 	}
   1772   1.36       tls 	return error;
   1773   1.36       tls }
   1774   1.36       tls 
   1775   1.46    darran int
   1776   1.36       tls cryptodev_msession(struct fcrypt *fcr, struct session_n_op *sn_ops,
   1777   1.36       tls 		   int count)
   1778   1.36       tls {
   1779   1.36       tls 	int i;
   1780   1.36       tls 
   1781   1.36       tls 	for (i = 0; i < count; i++, sn_ops++) {
   1782   1.36       tls 		struct session_op s_op;
   1783   1.36       tls 		s_op.cipher =		sn_ops->cipher;
   1784   1.36       tls 		s_op.mac =		sn_ops->mac;
   1785   1.94  knakahar 		s_op.comp_alg =		sn_ops->comp_alg;
   1786   1.36       tls 		s_op.keylen =		sn_ops->keylen;
   1787   1.36       tls 		s_op.key =		sn_ops->key;
   1788   1.36       tls 		s_op.mackeylen =	sn_ops->mackeylen;
   1789   1.36       tls 		s_op.mackey =		sn_ops->mackey;
   1790   1.36       tls 
   1791   1.36       tls 		sn_ops->status = cryptodev_session(fcr, &s_op);
   1792   1.94  knakahar 
   1793   1.36       tls 		sn_ops->ses =		s_op.ses;
   1794   1.36       tls 	}
   1795   1.36       tls 
   1796   1.36       tls 	return 0;
   1797   1.36       tls }
   1798   1.36       tls 
   1799   1.36       tls static int
   1800   1.36       tls cryptodev_msessionfin(struct fcrypt *fcr, int count, u_int32_t *sesid)
   1801   1.36       tls {
   1802   1.36       tls 	struct csession *cse;
   1803   1.36       tls 	int req, error = 0;
   1804   1.36       tls 
   1805   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   1806   1.36       tls 	for(req = 0; req < count; req++) {
   1807   1.36       tls 		cse = csefind(fcr, sesid[req]);
   1808   1.36       tls 		if (cse == NULL)
   1809   1.36       tls 			continue;
   1810   1.36       tls 		csedelete(fcr, cse);
   1811   1.92  knakahar 		mutex_exit(&cryptodev_mtx);
   1812   1.36       tls 		error = csefree(cse);
   1813   1.92  knakahar 		mutex_enter(&cryptodev_mtx);
   1814   1.36       tls 	}
   1815   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   1816   1.69    martin 	return error;
   1817   1.36       tls }
   1818   1.36       tls 
   1819   1.36       tls /*
   1820   1.42  christos  * collect as many completed requests as are availble, or count completed
   1821   1.42  christos  * requests whichever is less.
   1822   1.36       tls  * return the number of requests.
   1823   1.36       tls  */
   1824   1.36       tls static int
   1825   1.36       tls cryptodev_getmstatus(struct fcrypt *fcr, struct crypt_result *crypt_res,
   1826   1.42  christos     int count)
   1827   1.36       tls {
   1828   1.36       tls 	struct cryptop *crp = NULL;
   1829   1.36       tls 	struct cryptkop *krp = NULL;
   1830   1.36       tls 	struct csession *cse;
   1831   1.36       tls 	int i, size, req = 0;
   1832   1.36       tls 	int completed=0;
   1833   1.36       tls 
   1834   1.46    darran 	/* On queue so nobody else can grab them
   1835   1.46    darran 	 * and copyout can be delayed-- no locking */
   1836   1.46    darran 	TAILQ_HEAD(, cryptop) crp_delfree_q =
   1837   1.46    darran 		TAILQ_HEAD_INITIALIZER(crp_delfree_q);
   1838   1.46    darran 	TAILQ_HEAD(, cryptkop) krp_delfree_q =
   1839   1.46    darran 		TAILQ_HEAD_INITIALIZER(krp_delfree_q);
   1840   1.36       tls 
   1841   1.36       tls 	/* at this point we do not know which response user is requesting for
   1842   1.36       tls 	 * (symmetric or asymmetric) so we copyout one from each i.e if the
   1843   1.36       tls 	 * count is 2 then 1 from symmetric and 1 from asymmetric queue and
   1844   1.36       tls 	 * if 3 then 2 symmetric and 1 asymmetric and so on */
   1845   1.46    darran 
   1846   1.46    darran 	/* pull off a list of requests while protected from changes */
   1847   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   1848   1.46    darran 	while (req < count) {
   1849   1.36       tls 		crp = TAILQ_FIRST(&fcr->crp_ret_mq);
   1850   1.46    darran 		if (crp) {
   1851   1.46    darran 			TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
   1852   1.46    darran 			TAILQ_INSERT_TAIL(&crp_delfree_q, crp, crp_next);
   1853   1.36       tls 			cse = (struct csession *)crp->crp_opaque;
   1854   1.46    darran 
   1855   1.46    darran 			/* see if the session is still valid */
   1856   1.36       tls 			cse = csefind(fcr, cse->ses);
   1857   1.46    darran 			if (cse != NULL) {
   1858   1.46    darran 				crypt_res[req].status = 0;
   1859   1.46    darran 			} else {
   1860   1.90  knakahar 				DPRINTF("csefind failed\n");
   1861   1.36       tls 				crypt_res[req].status = EINVAL;
   1862   1.46    darran 			}
   1863   1.46    darran 			req++;
   1864   1.46    darran 		}
   1865   1.46    darran 		if(req < count) {
   1866   1.46    darran 			crypt_res[req].status = 0;
   1867   1.46    darran 			krp = TAILQ_FIRST(&fcr->crp_ret_mkq);
   1868   1.46    darran 			if (krp) {
   1869   1.46    darran 				TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
   1870   1.46    darran 				TAILQ_INSERT_TAIL(&krp_delfree_q, krp, krp_next);
   1871   1.46    darran 			req++;
   1872   1.46    darran 			}
   1873   1.46    darran 		}
   1874   1.46    darran 	}
   1875   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   1876   1.46    darran 
   1877   1.46    darran 	/* now do all the work outside the mutex */
   1878   1.46    darran 	for(req=0; req < count ;) {
   1879   1.46    darran 		crp = TAILQ_FIRST(&crp_delfree_q);
   1880   1.46    darran 		if (crp) {
   1881   1.46    darran 			if (crypt_res[req].status != 0) {
   1882   1.46    darran 				/* csefind failed during collection */
   1883   1.36       tls 				goto bail;
   1884   1.36       tls 			}
   1885   1.46    darran 			cse = (struct csession *)crp->crp_opaque;
   1886   1.46    darran 			crypt_res[req].reqid = crp->crp_reqid;
   1887   1.46    darran 			crypt_res[req].opaque = crp->crp_usropaque;
   1888   1.46    darran 			completed++;
   1889   1.36       tls 
   1890   1.36       tls 			if (crp->crp_etype != 0) {
   1891   1.36       tls 				crypt_res[req].status = crp->crp_etype;
   1892   1.36       tls 				goto bail;
   1893   1.36       tls 			}
   1894   1.36       tls 
   1895   1.36       tls 			if (cse->error) {
   1896   1.36       tls 				crypt_res[req].status = cse->error;
   1897   1.36       tls 				goto bail;
   1898   1.36       tls 			}
   1899   1.36       tls 
   1900   1.42  christos 			if (crp->dst && (crypt_res[req].status =
   1901   1.42  christos 			    copyout(crp->uio.uio_iov[0].iov_base, crp->dst,
   1902   1.42  christos 			    crp->len)))
   1903   1.36       tls 				goto bail;
   1904   1.36       tls 
   1905   1.42  christos 			if (crp->mac && (crypt_res[req].status =
   1906   1.42  christos 			    copyout(crp->crp_mac, crp->mac,
   1907   1.42  christos 			    cse->thash->authsize)))
   1908   1.36       tls 				goto bail;
   1909   1.46    darran 
   1910   1.36       tls bail:
   1911   1.46    darran 			TAILQ_REMOVE(&crp_delfree_q, crp, crp_next);
   1912   1.46    darran 			kmem_free(crp->uio.uio_iov[0].iov_base,
   1913   1.46    darran 			    crp->uio.uio_iov[0].iov_len);
   1914   1.46    darran 			crypto_freereq(crp);
   1915   1.36       tls 			req++;
   1916   1.36       tls 		}
   1917   1.36       tls 
   1918   1.46    darran 		if (req < count) {
   1919   1.46    darran 			krp = TAILQ_FIRST(&krp_delfree_q);
   1920   1.36       tls 			if (krp) {
   1921   1.36       tls 				crypt_res[req].reqid = krp->krp_reqid;
   1922   1.36       tls 				crypt_res[req].opaque = krp->krp_usropaque;
   1923   1.36       tls 				completed++;
   1924   1.36       tls 				if (krp->krp_status != 0) {
   1925   1.90  knakahar 					DPRINTF("krp->krp_status 0x%08x\n",
   1926   1.90  knakahar 					    krp->krp_status);
   1927   1.42  christos 					crypt_res[req].status = krp->krp_status;
   1928   1.36       tls 					goto fail;
   1929   1.36       tls 				}
   1930   1.36       tls 
   1931   1.36       tls 				for (i = krp->krp_iparams; i < krp->krp_iparams
   1932   1.42  christos 				    + krp->krp_oparams; i++) {
   1933   1.36       tls 					size = (krp->krp_param[i].crp_nbits
   1934   1.42  christos 					    + 7) / 8;
   1935   1.36       tls 					if (size == 0)
   1936   1.36       tls 						continue;
   1937   1.36       tls 					crypt_res[req].status = copyout
   1938   1.36       tls 					    (krp->krp_param[i].crp_p,
   1939   1.36       tls 					    krp->crk_param[i].crp_p, size);
   1940   1.36       tls 					if (crypt_res[req].status) {
   1941   1.90  knakahar 						DPRINTF("copyout oparam %d failed, "
   1942   1.42  christos 						    "error=%d\n",
   1943   1.42  christos 						    i - krp->krp_iparams,
   1944   1.90  knakahar 						    crypt_res[req].status);
   1945   1.36       tls 						goto fail;
   1946   1.36       tls 					}
   1947   1.36       tls 				}
   1948   1.36       tls fail:
   1949   1.46    darran 				TAILQ_REMOVE(&krp_delfree_q, krp, krp_next);
   1950   1.36       tls 				/* not sure what to do for this */
   1951   1.36       tls 				/* kop[req].crk_status = krp->krp_status; */
   1952   1.46    darran 				for (i = 0; i < CRK_MAXPARAM; i++) {
   1953   1.46    darran 					struct crparam *kp = &(krp->krp_param[i]);
   1954   1.46    darran 					if (kp->crp_p) {
   1955   1.46    darran 						size = (kp->crp_nbits + 7) / 8;
   1956   1.46    darran 						KASSERT(size > 0);
   1957   1.46    darran 						(void)memset(kp->crp_p, 0, size);
   1958   1.46    darran 						kmem_free(kp->crp_p, size);
   1959   1.46    darran 					}
   1960   1.46    darran 				}
   1961   1.46    darran 				cv_destroy(&krp->krp_cv);
   1962   1.91  knakahar 				crypto_kfreereq(krp);
   1963   1.46    darran 				req++;
   1964   1.36       tls 			}
   1965   1.36       tls 		}
   1966   1.36       tls 	}
   1967   1.36       tls 
   1968   1.85   msaitoh 	return completed;
   1969   1.36       tls }
   1970   1.36       tls 
   1971   1.36       tls static int
   1972   1.36       tls cryptodev_getstatus (struct fcrypt *fcr, struct crypt_result *crypt_res)
   1973   1.36       tls {
   1974   1.45    darran         struct cryptop *crp = NULL, *cnext;
   1975   1.45    darran         struct cryptkop *krp = NULL, *knext;
   1976   1.36       tls         struct csession *cse;
   1977   1.36       tls         int i, size, req = 0;
   1978   1.36       tls 
   1979   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   1980   1.36       tls 	/* Here we dont know for which request the user is requesting the
   1981   1.36       tls 	 * response so checking in both the queues */
   1982   1.45    darran 	TAILQ_FOREACH_SAFE(crp, &fcr->crp_ret_mq, crp_next, cnext) {
   1983   1.36       tls 		if(crp && (crp->crp_reqid == crypt_res->reqid)) {
   1984   1.36       tls 			cse = (struct csession *)crp->crp_opaque;
   1985   1.36       tls 		        crypt_res->opaque = crp->crp_usropaque;
   1986   1.36       tls 			cse = csefind(fcr, cse->ses);
   1987   1.36       tls 			if (cse == NULL) {
   1988   1.90  knakahar 				DPRINTF("csefind failed\n");
   1989   1.36       tls 				crypt_res->status = EINVAL;
   1990   1.36       tls 				goto bail;
   1991   1.36       tls 			}
   1992   1.36       tls 
   1993   1.36       tls 			if (crp->crp_etype != 0) {
   1994   1.36       tls 				crypt_res->status = crp->crp_etype;
   1995   1.36       tls 				goto bail;
   1996   1.36       tls 			}
   1997   1.36       tls 
   1998   1.36       tls 			if (cse->error) {
   1999   1.36       tls 				crypt_res->status = cse->error;
   2000   1.36       tls 				goto bail;
   2001   1.36       tls 			}
   2002   1.36       tls 
   2003   1.42  christos 			if (crp->dst && (crypt_res->status =
   2004   1.42  christos 			    copyout(crp->uio.uio_iov[0].iov_base,
   2005   1.42  christos 			    crp->dst, crp->len)))
   2006   1.36       tls 				goto bail;
   2007   1.36       tls 
   2008   1.42  christos 			if (crp->mac && (crypt_res->status =
   2009   1.42  christos 			    copyout(crp->crp_mac, crp->mac,
   2010   1.42  christos 			    cse->thash->authsize)))
   2011   1.36       tls 				goto bail;
   2012   1.36       tls bail:
   2013   1.36       tls 			TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
   2014   1.36       tls 
   2015   1.92  knakahar 			mutex_exit(&cryptodev_mtx);
   2016   1.36       tls 			crypto_freereq(crp);
   2017   1.36       tls 			return 0;
   2018   1.36       tls 		}
   2019   1.36       tls 	}
   2020   1.36       tls 
   2021   1.45    darran 	TAILQ_FOREACH_SAFE(krp, &fcr->crp_ret_mkq, krp_next, knext) {
   2022   1.36       tls 		if(krp && (krp->krp_reqid == crypt_res->reqid)) {
   2023   1.36       tls 			crypt_res[req].opaque = krp->krp_usropaque;
   2024   1.36       tls 			if (krp->krp_status != 0) {
   2025   1.90  knakahar 				DPRINTF("krp->krp_status 0x%08x\n",
   2026   1.90  knakahar 				    krp->krp_status);
   2027   1.36       tls 				crypt_res[req].status = krp->krp_status;
   2028   1.36       tls 				goto fail;
   2029   1.36       tls 			}
   2030   1.36       tls 
   2031   1.42  christos 			for (i = krp->krp_iparams; i < krp->krp_iparams +
   2032   1.42  christos 			    krp->krp_oparams; i++) {
   2033   1.36       tls 				size = (krp->krp_param[i].crp_nbits + 7) / 8;
   2034   1.36       tls 				if (size == 0)
   2035   1.36       tls 					continue;
   2036   1.42  christos 				crypt_res[req].status = copyout(
   2037   1.42  christos 				    krp->krp_param[i].crp_p,
   2038   1.42  christos 				    krp->crk_param[i].crp_p, size);
   2039   1.36       tls 				if (crypt_res[req].status) {
   2040   1.90  knakahar 					DPRINTF("copyout oparam "
   2041   1.42  christos 					    "%d failed, error=%d\n",
   2042   1.42  christos 					    i - krp->krp_iparams,
   2043   1.90  knakahar 					    crypt_res[req].status);
   2044   1.36       tls 					goto fail;
   2045   1.36       tls 				}
   2046   1.36       tls 			}
   2047   1.36       tls fail:
   2048   1.36       tls 			TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
   2049   1.92  knakahar 			mutex_exit(&cryptodev_mtx);
   2050   1.36       tls 			/* not sure what to do for this */
   2051   1.36       tls 			/* kop[req].crk_status = krp->krp_status; */
   2052   1.36       tls 			for (i = 0; i < CRK_MAXPARAM; i++) {
   2053   1.36       tls 				struct crparam *kp = &(krp->krp_param[i]);
   2054   1.36       tls 				if (kp->crp_p) {
   2055   1.36       tls 					size = (kp->crp_nbits + 7) / 8;
   2056   1.36       tls 					KASSERT(size > 0);
   2057   1.36       tls 					memset(kp->crp_p, 0, size);
   2058   1.36       tls 					kmem_free(kp->crp_p, size);
   2059   1.36       tls 				}
   2060   1.36       tls 			}
   2061   1.45    darran 			cv_destroy(&krp->krp_cv);
   2062   1.91  knakahar 			crypto_kfreereq(krp);
   2063   1.36       tls 			return 0;
   2064   1.36       tls 		}
   2065   1.36       tls 	}
   2066   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   2067   1.85   msaitoh 	return EINPROGRESS;
   2068   1.36       tls }
   2069   1.36       tls 
   2070   1.36       tls static int
   2071   1.48  christos cryptof_stat(struct file *fp, struct stat *st)
   2072   1.48  christos {
   2073   1.81      matt 	struct fcrypt *fcr = fp->f_fcrypt;
   2074   1.48  christos 
   2075   1.68     joerg 	(void)memset(st, 0, sizeof(*st));
   2076   1.49  christos 
   2077   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   2078   1.48  christos 	st->st_dev = makedev(cdevsw_lookup_major(&crypto_cdevsw), fcr->sesn);
   2079   1.48  christos 	st->st_atimespec = fcr->atime;
   2080   1.48  christos 	st->st_mtimespec = fcr->mtime;
   2081   1.48  christos 	st->st_ctimespec = st->st_birthtimespec = fcr->btime;
   2082   1.49  christos 	st->st_uid = kauth_cred_geteuid(fp->f_cred);
   2083   1.49  christos 	st->st_gid = kauth_cred_getegid(fp->f_cred);
   2084   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   2085   1.49  christos 
   2086   1.48  christos 	return 0;
   2087   1.48  christos }
   2088   1.48  christos 
   2089   1.48  christos static int
   2090   1.36       tls cryptof_poll(struct file *fp, int events)
   2091   1.36       tls {
   2092   1.81      matt 	struct fcrypt *fcr = fp->f_fcrypt;
   2093   1.38     rmind 	int revents = 0;
   2094   1.36       tls 
   2095   1.36       tls 	if (!(events & (POLLIN | POLLRDNORM))) {
   2096   1.36       tls 		/* only support read and POLLIN */
   2097   1.36       tls 		return 0;
   2098   1.36       tls 	}
   2099   1.36       tls 
   2100   1.92  knakahar 	mutex_enter(&cryptodev_mtx);
   2101   1.36       tls 	if (TAILQ_EMPTY(&fcr->crp_ret_mq) && TAILQ_EMPTY(&fcr->crp_ret_mkq)) {
   2102   1.38     rmind 		/* no completed requests pending, save the poll for later */
   2103   1.36       tls 		selrecord(curlwp, &fcr->sinfo);
   2104   1.36       tls 	} else {
   2105   1.36       tls 		/* let the app(s) know that there are completed requests */
   2106   1.38     rmind 		revents = events & (POLLIN | POLLRDNORM);
   2107   1.36       tls 	}
   2108   1.92  knakahar 	mutex_exit(&cryptodev_mtx);
   2109   1.38     rmind 
   2110   1.38     rmind 	return revents;
   2111   1.36       tls }
   2112   1.36       tls 
   2113   1.15   thorpej /*
   2114   1.15   thorpej  * Pseudo-device initialization routine for /dev/crypto
   2115   1.15   thorpej  */
   2116   1.15   thorpej void
   2117   1.25  christos cryptoattach(int num)
   2118   1.15   thorpej {
   2119   1.96  christos 	int error;
   2120   1.96  christos 
   2121   1.80     skrll 	crypto_init();
   2122   1.80     skrll 
   2123   1.92  knakahar 	mutex_init(&cryptodev_mtx, MUTEX_DEFAULT, IPL_NONE);
   2124   1.89  knakahar 
   2125   1.29       tls 	pool_init(&fcrpl, sizeof(struct fcrypt), 0, 0, 0, "fcrpl",
   2126   1.42  christos 	    NULL, IPL_NET);	/* XXX IPL_NET ("splcrypto") */
   2127   1.29       tls 	pool_init(&csepl, sizeof(struct csession), 0, 0, 0, "csepl",
   2128   1.42  christos 	    NULL, IPL_NET);	/* XXX IPL_NET ("splcrypto") */
   2129   1.29       tls 
   2130   1.29       tls 	/*
   2131   1.29       tls 	 * Preallocate space for 64 users, with 5 sessions each.
   2132   1.29       tls 	 * (consider that a TLS protocol session requires at least
   2133   1.29       tls 	 * 3DES, MD5, and SHA1 (both hashes are used in the PRF) for
   2134   1.29       tls 	 * the negotiation, plus HMAC_SHA1 for the actual SSL records,
   2135   1.29       tls 	 * consuming one session here for each algorithm.
   2136   1.29       tls 	 */
   2137   1.96  christos 	if ((error = pool_prime(&fcrpl, 64)) != 0 ||
   2138   1.96  christos 	    (error = pool_prime(&csepl, 64 * 5)) != 0)
   2139   1.96  christos 		panic("%s: can't prime pool: %d", __func__, error);
   2140   1.15   thorpej }
   2141   1.70  pgoyette 
   2142   1.70  pgoyette void	crypto_attach(device_t, device_t, void *);
   2143   1.70  pgoyette 
   2144   1.70  pgoyette void
   2145   1.70  pgoyette crypto_attach(device_t parent, device_t self, void * opaque)
   2146   1.70  pgoyette {
   2147   1.70  pgoyette 
   2148   1.70  pgoyette 	cryptoattach(0);
   2149   1.70  pgoyette }
   2150   1.70  pgoyette 
   2151   1.70  pgoyette int	crypto_detach(device_t, int);
   2152   1.70  pgoyette 
   2153   1.70  pgoyette int
   2154   1.70  pgoyette crypto_detach(device_t self, int num)
   2155   1.70  pgoyette {
   2156   1.73  pgoyette 
   2157   1.70  pgoyette 	pool_destroy(&fcrpl);
   2158   1.70  pgoyette 	pool_destroy(&csepl);
   2159   1.70  pgoyette 
   2160   1.92  knakahar 	mutex_destroy(&cryptodev_mtx);
   2161   1.89  knakahar 
   2162   1.70  pgoyette 	return 0;
   2163   1.70  pgoyette }
   2164   1.70  pgoyette 
   2165   1.70  pgoyette int crypto_match(device_t, cfdata_t, void *);
   2166   1.70  pgoyette 
   2167   1.70  pgoyette int
   2168   1.70  pgoyette crypto_match(device_t parent, cfdata_t data, void *opaque)
   2169   1.70  pgoyette {
   2170   1.70  pgoyette 
   2171   1.70  pgoyette 	return 1;
   2172   1.70  pgoyette }
   2173   1.70  pgoyette 
   2174   1.71  pgoyette MODULE(MODULE_CLASS_DRIVER, crypto, "opencrypto");
   2175   1.70  pgoyette 
   2176   1.70  pgoyette CFDRIVER_DECL(crypto, DV_DULL, NULL);
   2177   1.70  pgoyette 
   2178   1.70  pgoyette CFATTACH_DECL2_NEW(crypto, 0, crypto_match, crypto_attach, crypto_detach,
   2179   1.70  pgoyette     NULL, NULL, NULL);
   2180   1.70  pgoyette 
   2181   1.71  pgoyette #ifdef _MODULE
   2182   1.77  pgoyette static int cryptoloc[] = { -1, -1 };
   2183   1.77  pgoyette 
   2184   1.77  pgoyette static struct cfdata crypto_cfdata[] = {
   2185   1.77  pgoyette 	{
   2186   1.77  pgoyette 		.cf_name = "crypto",
   2187   1.77  pgoyette 		.cf_atname = "crypto",
   2188   1.77  pgoyette 		.cf_unit = 0,
   2189   1.77  pgoyette 		.cf_fstate = 0,
   2190   1.77  pgoyette 		.cf_loc = cryptoloc,
   2191   1.77  pgoyette 		.cf_flags = 0,
   2192   1.77  pgoyette 		.cf_pspec = NULL,
   2193   1.77  pgoyette 	},
   2194   1.77  pgoyette 	{ NULL, NULL, 0, 0, NULL, 0, NULL }
   2195   1.77  pgoyette };
   2196   1.71  pgoyette #endif
   2197   1.70  pgoyette 
   2198   1.70  pgoyette static int
   2199   1.70  pgoyette crypto_modcmd(modcmd_t cmd, void *arg)
   2200   1.70  pgoyette {
   2201   1.71  pgoyette 	int error = 0;
   2202   1.71  pgoyette #ifdef _MODULE
   2203   1.70  pgoyette 	devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
   2204   1.71  pgoyette #endif
   2205   1.70  pgoyette 
   2206   1.70  pgoyette 	switch (cmd) {
   2207   1.70  pgoyette 	case MODULE_CMD_INIT:
   2208   1.71  pgoyette #ifdef _MODULE
   2209   1.77  pgoyette 
   2210   1.77  pgoyette 		error = config_cfdriver_attach(&crypto_cd);
   2211   1.77  pgoyette 		if (error) {
   2212   1.70  pgoyette 			return error;
   2213   1.77  pgoyette 		}
   2214   1.77  pgoyette 
   2215   1.77  pgoyette 		error = config_cfattach_attach(crypto_cd.cd_name, &crypto_ca);
   2216   1.77  pgoyette 		if (error) {
   2217   1.77  pgoyette 			config_cfdriver_detach(&crypto_cd);
   2218   1.77  pgoyette 			aprint_error("%s: unable to register cfattach\n",
   2219   1.77  pgoyette 				crypto_cd.cd_name);
   2220   1.77  pgoyette 
   2221   1.77  pgoyette 			return error;
   2222   1.77  pgoyette 		}
   2223   1.77  pgoyette 
   2224   1.77  pgoyette 		error = config_cfdata_attach(crypto_cfdata, 1);
   2225   1.77  pgoyette 		if (error) {
   2226   1.77  pgoyette 			config_cfattach_detach(crypto_cd.cd_name, &crypto_ca);
   2227   1.77  pgoyette 			config_cfdriver_detach(&crypto_cd);
   2228   1.77  pgoyette 			aprint_error("%s: unable to register cfdata\n",
   2229   1.77  pgoyette 				crypto_cd.cd_name);
   2230   1.77  pgoyette 
   2231   1.77  pgoyette 			return error;
   2232   1.77  pgoyette 		}
   2233   1.70  pgoyette 
   2234   1.70  pgoyette 		error = devsw_attach(crypto_cd.cd_name, NULL, &bmajor,
   2235   1.77  pgoyette 		    &crypto_cdevsw, &cmajor);
   2236   1.70  pgoyette 		if (error) {
   2237   1.77  pgoyette 			error = config_cfdata_detach(crypto_cfdata);
   2238   1.77  pgoyette 			if (error) {
   2239   1.77  pgoyette 				return error;
   2240   1.77  pgoyette 			}
   2241   1.77  pgoyette 			config_cfattach_detach(crypto_cd.cd_name, &crypto_ca);
   2242   1.77  pgoyette 			config_cfdriver_detach(&crypto_cd);
   2243   1.70  pgoyette 			aprint_error("%s: unable to register devsw\n",
   2244   1.70  pgoyette 				crypto_cd.cd_name);
   2245   1.70  pgoyette 
   2246   1.70  pgoyette 			return error;
   2247   1.70  pgoyette 		}
   2248   1.70  pgoyette 
   2249   1.77  pgoyette 		(void)config_attach_pseudo(crypto_cfdata);
   2250   1.71  pgoyette #endif
   2251   1.70  pgoyette 
   2252   1.71  pgoyette 		return error;
   2253   1.70  pgoyette 	case MODULE_CMD_FINI:
   2254   1.71  pgoyette #ifdef _MODULE
   2255  1.101  christos 		if (crypto_refcount != 0)
   2256  1.101  christos 			return EBUSY;
   2257   1.77  pgoyette 		error = config_cfdata_detach(crypto_cfdata);
   2258   1.70  pgoyette 		if (error) {
   2259   1.70  pgoyette 			return error;
   2260   1.70  pgoyette 		}
   2261   1.77  pgoyette 
   2262   1.77  pgoyette 		config_cfattach_detach(crypto_cd.cd_name, &crypto_ca);
   2263   1.77  pgoyette 		config_cfdriver_detach(&crypto_cd);
   2264   1.77  pgoyette 		devsw_detach(NULL, &crypto_cdevsw);
   2265   1.71  pgoyette #endif
   2266   1.70  pgoyette 
   2267   1.71  pgoyette 		return error;
   2268   1.74  pgoyette #ifdef _MODULE
   2269   1.74  pgoyette 	case MODULE_CMD_AUTOUNLOAD:
   2270   1.75  pgoyette #if 0	/*
   2271   1.75  pgoyette 	 * XXX Completely disable auto-unload for now, since there is still
   2272   1.75  pgoyette 	 * XXX a (small) window where in-module ref-counting doesn't help
   2273   1.75  pgoyette 	 */
   2274   1.74  pgoyette 		if (crypto_refcount != 0)
   2275   1.75  pgoyette #endif
   2276   1.74  pgoyette 			return EBUSY;
   2277   1.74  pgoyette 	/* FALLTHROUGH */
   2278   1.74  pgoyette #endif
   2279   1.70  pgoyette 	default:
   2280   1.70  pgoyette 		return ENOTTY;
   2281   1.70  pgoyette 	}
   2282   1.70  pgoyette }
   2283