kernel: Use NULL for DRIVER_MODULE()'s evh & arg (which are pointers).
[dragonfly.git] / sys / dev / crypto / aesni / aesni.c
1 /*-
2  * Copyright (c) 2005-2008 Pawel Jakub Dawidek <pjd@FreeBSD.org>
3  * Copyright (c) 2010 Konstantin Belousov <kib@FreeBSD.org>
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *
27  * $FreeBSD: src/sys/crypto/aesni/aesni.c,v 1.3 2010/09/23 11:57:25 pjd Exp $
28  */
29
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/kobj.h>
34 #include <sys/libkern.h>
35 #include <sys/lock.h>
36 #include <sys/module.h>
37 #include <sys/malloc.h>
38 #include <sys/spinlock.h>
39 #include <sys/spinlock2.h>
40 #include <sys/bus.h>
41 #include <sys/uio.h>
42 #include <dev/crypto/aesni/aesni.h>
43 #include "cryptodev_if.h"
44
45 struct aesni_softc {
46         int32_t cid;
47         uint32_t sid;
48         TAILQ_HEAD(aesni_sessions_head, aesni_session) sessions;
49         struct spinlock lock;
50 };
51
52 static int aesni_newsession(device_t, uint32_t *sidp, struct cryptoini *cri);
53 static int aesni_freesession(device_t, uint64_t tid);
54 static void aesni_freesession_locked(struct aesni_softc *sc,
55     struct aesni_session *ses);
56
57 MALLOC_DEFINE(M_AESNI, "aesni_data", "AESNI Data");
58
59 static void
60 aesni_identify(driver_t *drv, device_t parent)
61 {
62
63         /* NB: order 10 is so we get attached after h/w devices */
64         if (device_find_child(parent, "aesni", -1) == NULL &&
65             BUS_ADD_CHILD(parent, parent, 10, "aesni", -1) == 0)
66                 panic("aesni: could not attach");
67 }
68
69 static int
70 aesni_probe(device_t dev)
71 {
72
73         if ((cpu_feature2 & CPUID2_AESNI) == 0) {
74                 device_printf(dev, "No AESNI support.\n");
75                 return (EINVAL);
76         }
77         device_set_desc_copy(dev, "AES-CBC,AES-XTS");
78         return (0);
79 }
80
81 static int
82 aesni_attach(device_t dev)
83 {
84         struct aesni_softc *sc;
85
86         sc = device_get_softc(dev);
87         TAILQ_INIT(&sc->sessions);
88         sc->sid = 1;
89         sc->cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE);
90         if (sc->cid < 0) {
91                 device_printf(dev, "Could not get crypto driver id.\n");
92                 return (ENOMEM);
93         }
94
95         spin_init(&sc->lock);
96         crypto_register(sc->cid, CRYPTO_AES_CBC, 0, 0);
97         crypto_register(sc->cid, CRYPTO_AES_XTS, 0, 0);
98         return (0);
99 }
100
101 static int
102 aesni_detach(device_t dev)
103 {
104         struct aesni_softc *sc;
105         struct aesni_session *ses;
106
107         sc = device_get_softc(dev);
108         spin_lock(&sc->lock);
109         TAILQ_FOREACH(ses, &sc->sessions, next) {
110                 if (ses->used) {
111                         spin_unlock(&sc->lock);
112                         device_printf(dev,
113                             "Cannot detach, sessions still active.\n");
114                         return (EBUSY);
115                 }
116         }
117         while ((ses = TAILQ_FIRST(&sc->sessions)) != NULL) {
118                 TAILQ_REMOVE(&sc->sessions, ses, next);
119                 kfree(ses->freeaddr, M_AESNI);
120         }
121         spin_unlock(&sc->lock);
122         spin_uninit(&sc->lock);
123         crypto_unregister_all(sc->cid);
124         return (0);
125 }
126
127 static int
128 aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
129 {
130         struct aesni_softc *sc;
131         struct aesni_session *ases, *ses;
132         struct cryptoini *encini;
133         int error;
134
135         if (sidp == NULL || cri == NULL)
136                 return (EINVAL);
137
138         sc = device_get_softc(dev);
139         ses = NULL;
140         encini = NULL;
141         for (; cri != NULL; cri = cri->cri_next) {
142                 switch (cri->cri_alg) {
143                 case CRYPTO_AES_CBC:
144                 case CRYPTO_AES_XTS:
145                         if (encini != NULL)
146                                 return (EINVAL);
147                         encini = cri;
148                         break;
149                 default:
150                         return (EINVAL);
151                 }
152         }
153         if (encini == NULL)
154                 return (EINVAL);
155
156         spin_lock(&sc->lock);
157         /*
158          * Free sessions goes first, so if first session is used, we need to
159          * allocate one.
160          */
161         ses = TAILQ_FIRST(&sc->sessions);
162         if (ses == NULL || ses->used) {
163                 ses = kmalloc(sizeof(*ses) + 16, M_AESNI, M_NOWAIT | M_ZERO);
164                 if (ses == NULL) {
165                         spin_unlock(&sc->lock);
166                         return (ENOMEM);
167                 }
168                 /* Check if 'ses' is 16-byte aligned. If not, align it. */
169                 if (((uintptr_t)ses & 0xf) != 0) {
170                         ases = AESNI_ALIGN(ses);
171                         ases->freeaddr = ses;
172                         ses = ases;
173                 } else {
174                         ses->freeaddr = ses;
175                 }
176                 ses->id = sc->sid++;
177         } else {
178                 TAILQ_REMOVE(&sc->sessions, ses, next);
179         }
180         ses->used = 1;
181         TAILQ_INSERT_TAIL(&sc->sessions, ses, next);
182         spin_unlock(&sc->lock);
183         ses->algo = encini->cri_alg;
184
185         error = aesni_cipher_setup(ses, encini);
186         if (error != 0) {
187                 spin_lock(&sc->lock);
188                 aesni_freesession_locked(sc, ses);
189                 spin_unlock(&sc->lock);
190                 return (error);
191         }
192
193         *sidp = ses->id;
194         return (0);
195 }
196
197 static void
198 aesni_freesession_locked(struct aesni_softc *sc, struct aesni_session *ses)
199 {
200         uint32_t sid;
201         void *freeaddr;
202
203         sid = ses->id;
204         TAILQ_REMOVE(&sc->sessions, ses, next);
205         freeaddr = ses->freeaddr;
206         bzero(ses, sizeof(*ses));
207         ses->freeaddr = freeaddr;
208         ses->id = sid;
209         TAILQ_INSERT_HEAD(&sc->sessions, ses, next);
210 }
211
212 static int
213 aesni_freesession(device_t dev, uint64_t tid)
214 {
215         struct aesni_softc *sc;
216         struct aesni_session *ses;
217         uint32_t sid;
218
219         sc = device_get_softc(dev);
220         sid = ((uint32_t)tid) & 0xffffffff;
221         spin_lock(&sc->lock);
222         TAILQ_FOREACH_REVERSE(ses, &sc->sessions, aesni_sessions_head, next) {
223                 if (ses->id == sid)
224                         break;
225         }
226         if (ses == NULL) {
227                 spin_unlock(&sc->lock);
228                 return (EINVAL);
229         }
230         aesni_freesession_locked(sc, ses);
231         spin_unlock(&sc->lock);
232         return (0);
233 }
234
235 static int
236 aesni_process(device_t dev, struct cryptop *crp, int hint __unused)
237 {
238         struct aesni_softc *sc = device_get_softc(dev);
239         struct aesni_session *ses = NULL;
240         struct cryptodesc *crd, *enccrd;
241         int error;
242
243         error = 0;
244         enccrd = NULL;
245
246         /* Sanity check. */
247         if (crp == NULL)
248                 return (EINVAL);
249
250         if (crp->crp_callback == NULL || crp->crp_desc == NULL) {
251                 error = EINVAL;
252                 goto out;
253         }
254
255         for (crd = crp->crp_desc; crd != NULL; crd = crd->crd_next) {
256                 switch (crd->crd_alg) {
257                 case CRYPTO_AES_CBC:
258                 case CRYPTO_AES_XTS:
259                         if (enccrd != NULL) {
260                                 error = EINVAL;
261                                 goto out;
262                         }
263                         enccrd = crd;
264                         break;
265                 default:
266                         return (EINVAL);
267                 }
268         }
269         if (enccrd == NULL || (enccrd->crd_len % AES_BLOCK_LEN) != 0) {
270                 error = EINVAL;
271                 goto out;
272         }
273
274         spin_lock(&sc->lock); /* XXX: was rd lock */
275         TAILQ_FOREACH_REVERSE(ses, &sc->sessions, aesni_sessions_head, next) {
276                 if (ses->id == (crp->crp_sid & 0xffffffff))
277                         break;
278         }
279         spin_unlock(&sc->lock); /* XXX: was rd lock */
280         if (ses == NULL) {
281                 error = EINVAL;
282                 goto out;
283         }
284
285         error = aesni_cipher_process(ses, enccrd, crp);
286         if (error != 0)
287                 goto out;
288
289 out:
290         crp->crp_etype = error;
291         crypto_done(crp);
292         return (error);
293 }
294
295 uint8_t *
296 aesni_cipher_alloc(struct cryptodesc *enccrd, struct cryptop *crp,
297     int *allocated)
298 {
299         struct uio *uio;
300         struct iovec *iov;
301         uint8_t *addr;
302
303         if (crp->crp_flags & CRYPTO_F_IMBUF)
304                 goto alloc;
305         else if (crp->crp_flags & CRYPTO_F_IOV) {
306                 uio = (struct uio *)crp->crp_buf;
307                 if (uio->uio_iovcnt != 1)
308                         goto alloc;
309                 iov = uio->uio_iov;
310                 addr = (u_char *)iov->iov_base + enccrd->crd_skip;
311         } else
312                 addr = (u_char *)crp->crp_buf;
313         *allocated = 0;
314         return (addr);
315
316 alloc:
317         addr = kmalloc(enccrd->crd_len, M_AESNI, M_NOWAIT);
318         if (addr != NULL) {
319                 *allocated = 1;
320                 crypto_copydata(crp->crp_flags, crp->crp_buf, enccrd->crd_skip,
321                     enccrd->crd_len, addr);
322         } else
323                 *allocated = 0;
324         return (addr);
325 }
326
327 static device_method_t aesni_methods[] = {
328         DEVMETHOD(device_identify, aesni_identify),
329         DEVMETHOD(device_probe, aesni_probe),
330         DEVMETHOD(device_attach, aesni_attach),
331         DEVMETHOD(device_detach, aesni_detach),
332
333         DEVMETHOD(cryptodev_newsession, aesni_newsession),
334         DEVMETHOD(cryptodev_freesession, aesni_freesession),
335         DEVMETHOD(cryptodev_process, aesni_process),
336
337         {0, 0},
338 };
339
340 static driver_t aesni_driver = {
341         "aesni",
342         aesni_methods,
343         sizeof(struct aesni_softc),
344 };
345 static devclass_t aesni_devclass;
346
347 DRIVER_MODULE(aesni, nexus, aesni_driver, aesni_devclass, NULL, NULL);
348 MODULE_VERSION(aesni, 1);
349 MODULE_DEPEND(aesni, crypto, 1, 1, 1);