a7534d19150da7bd18c932cb41c6678aac7c0694
[dragonfly.git] / sys / dev / disk / dm / dm_target_crypt.c
1 /*
2  * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Alex Hornung <ahornung@gmail.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34
35 /*
36  * This file implements initial version of device-mapper crypt target.
37  */
38 #include <sys/types.h>
39 #include <sys/param.h>
40
41 #include <sys/bio.h>
42 #include <sys/buf.h>
43 #include <sys/malloc.h>
44 #include <sys/md5.h>
45 #include <sys/vnode.h>
46 #include <crypto/sha1.h>
47 #include <crypto/sha2/sha2.h>
48 #include <opencrypto/cryptodev.h>
49 #include <opencrypto/rmd160.h>
50
51 #include "dm.h"
52 MALLOC_DEFINE(M_DMCRYPT, "dm_crypt", "Device Mapper Target Crypt");
53
54 struct target_crypt_config;
55 typedef void ivgen_t(struct target_crypt_config *, u_int8_t *, size_t, off_t);
56
57 typedef struct target_crypt_config {
58         size_t  params_len;
59         dm_pdev_t *pdev;
60         char    *status_str;
61         int     crypto_alg;
62         int     crypto_klen;
63         u_int8_t        crypto_key[512>>3];
64         u_int8_t        crypto_keyhash[SHA512_DIGEST_LENGTH];
65         u_int64_t       crypto_sid;
66         u_int64_t       block_offset;
67         u_int64_t       iv_offset;
68         SHA512_CTX      essivsha512_ctx;
69         struct cryptoini        crypto_session;
70         ivgen_t *crypto_ivgen;
71         /* XXX: uuid */
72 } dm_target_crypt_config_t;
73
74 struct dmtc_helper {
75         caddr_t free_addr;
76         caddr_t orig_buf;
77 };
78
79 static void dm_target_crypt_work(dm_target_crypt_config_t *priv, struct bio *bio);
80 static void dm_target_crypt_read_done(struct bio *bio);
81 static void dm_target_crypt_write_done(struct bio *bio);
82 static int dm_target_crypt_crypto_done_read(struct cryptop *crp);
83 static int dm_target_crypt_crypto_done_write(struct cryptop *crp);
84
85
86
87 static int
88 essiv_hash_mkey(dm_target_crypt_config_t *priv, char *iv_hash)
89 {
90         unsigned int klen;
91
92         klen = (priv->crypto_klen >> 3);
93
94         if (iv_hash == NULL)
95                 return EINVAL;
96
97         if (!strcmp(iv_hash, "sha1")) {
98                 SHA1_CTX ctx;
99
100                 if (klen != SHA1_RESULTLEN)
101                         return EINVAL;
102
103                 SHA1Init(&ctx);
104                 SHA1Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
105                 SHA1Final(priv->crypto_keyhash, &ctx);
106         } else if (!strcmp(iv_hash, "sha256")) {
107                 SHA256_CTX ctx;
108
109                 if (klen != SHA256_DIGEST_LENGTH)
110                         return EINVAL;
111
112                 SHA256_Init(&ctx);
113                 SHA256_Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
114                 SHA256_Final(priv->crypto_keyhash, &ctx);
115         } else if (!strcmp(iv_hash, "sha384")) {
116                 SHA384_CTX ctx;
117
118                 if (klen != SHA384_DIGEST_LENGTH)
119                         return EINVAL;
120
121                 SHA384_Init(&ctx);
122                 SHA384_Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
123                 SHA384_Final(priv->crypto_keyhash, &ctx);
124         } else if (!strcmp(iv_hash, "sha512")) {
125                 SHA512_CTX ctx;
126
127                 if (klen != SHA512_DIGEST_LENGTH)
128                         return EINVAL;
129
130                 SHA512_Init(&ctx);
131                 SHA512_Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
132                 SHA512_Final(priv->crypto_keyhash, &ctx);
133         } else if (!strcmp(iv_hash, "md5")) {
134                 MD5_CTX ctx;
135
136                 if (klen != MD5_DIGEST_LENGTH)
137                         return EINVAL;
138
139                 MD5Init(&ctx);
140                 MD5Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
141                 MD5Final(priv->crypto_keyhash, &ctx);
142         } else if (!strcmp(iv_hash, "rmd160") || !strcmp(iv_hash, "ripemd160")) {
143                 RMD160_CTX ctx;
144
145                 if (klen != (160/8))
146                         return EINVAL;
147
148                 RMD160Init(&ctx);
149                 RMD160Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
150                 RMD160Final(priv->crypto_keyhash, &ctx);
151         } else {
152                 return EINVAL;
153         }
154
155         return 0;
156 }
157
158 static int
159 essiv_ivgen_done(struct cryptop *crp)
160 {
161
162         if (crp->crp_etype == EAGAIN)
163                 return crypto_dispatch(crp);
164
165         if (crp->crp_etype != 0) {
166                 kprintf("dm_target_crypt: essiv_ivgen_done, crp->crp_etype = %d\n", crp->crp_etype);
167         }
168
169         atomic_add_int((int *)crp->crp_opaque, 1);
170         wakeup(crp->crp_opaque);
171         return 0;
172 }
173
174 static void
175 plain_ivgen(dm_target_crypt_config_t *priv, u_int8_t *iv, size_t iv_len, off_t sector)
176 {
177         bzero(iv, iv_len);
178         *((off_t *)iv) = sector + priv->iv_offset;
179 }
180
181 static void
182 essiv_ivgen(dm_target_crypt_config_t *priv, u_int8_t *iv, size_t iv_len, off_t sector)
183 {
184         struct cryptodesc crd;
185         struct cryptop crp;
186         int error, id;
187
188         id = 0;
189         bzero(iv, iv_len);
190         *((off_t *)iv) = sector + priv->iv_offset;
191         crp.crp_buf = (caddr_t)iv;
192
193         crp.crp_sid = priv->crypto_sid;
194         crp.crp_ilen = crp.crp_olen = iv_len;
195
196         crp.crp_opaque = (void *)&id;
197
198         crp.crp_callback = essiv_ivgen_done;
199
200         crp.crp_desc = &crd;
201         crp.crp_etype = 0;
202         crp.crp_flags = CRYPTO_F_CBIFSYNC | CRYPTO_F_REL;
203
204         crd.crd_alg = priv->crypto_alg;
205         crd.crd_key = (caddr_t)priv->crypto_keyhash;
206         crd.crd_klen = priv->crypto_klen;
207
208         bzero(crd.crd_iv, sizeof(crd.crd_iv));
209
210         crd.crd_skip = 0;
211         crd.crd_len = iv_len;
212         crd.crd_flags = CRD_F_KEY_EXPLICIT | CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
213         crd.crd_flags |= CRD_F_ENCRYPT;
214         crd.crd_next = NULL;
215
216         error = crypto_dispatch(&crp);
217         if (error)
218                 kprintf("dm_target_crypt: essiv_ivgen, error = %d\n", error);
219
220         /*
221          * id is modified in the callback, so that if crypto_dispatch finishes
222          * synchronously we don't tsleep() forever.
223          */
224         if (id == 0)
225                 tsleep((void *)&error, 0, "essivgen", 0);
226 }
227
228 #if 0
229 static void
230 geli_ivgen(dm_target_crypt_config_t *priv, u_int8_t *iv, size_t iv_len, off_t sector)
231 {
232
233         SHA512_CTX      ctx512;
234         u_int8_t        md[SHA512_DIGEST_LENGTH]; /* Max. Digest Size */
235
236         memcpy(&ctx512, &priv->essivsha512_ctx, sizeof(SHA512_CTX));
237         SHA512_Update(&ctx512, (u_int8_t*)&sector, sizeof(off_t));
238         SHA512_Final(md, &ctx512);
239
240         memcpy(iv, md, iv_len);
241 }
242 #endif
243
244 static void
245 dm_target_crypt_work(dm_target_crypt_config_t *priv, struct bio *bio)
246 {
247         struct dmtc_helper *dmtc;
248         struct cryptodesc *crd;
249         struct cryptop *crp;
250         struct cryptoini *cri;
251
252         int error, i, bytes, isector, sectors, write, sz;
253         u_char *ptr, *space, *data;
254
255         cri = &priv->crypto_session;
256
257         write = (bio->bio_buf->b_cmd == BUF_CMD_WRITE) ? 1 : 0;
258         bytes = bio->bio_buf->b_bcount; /* XXX: b_resid no good after reads... == 0 */
259         isector = bio->bio_offset/DEV_BSIZE;    /* Initial sector */
260         sectors = bytes/DEV_BSIZE;              /* Number of sectors affected by bio */
261         sz = sectors * (sizeof(*crp) + sizeof(*crd));
262
263         if (write) {
264                 space = kmalloc(sizeof(struct dmtc_helper) + sz + bytes, M_DMCRYPT, M_WAITOK);
265                 dmtc = (struct dmtc_helper *)space;
266                 dmtc->free_addr = space;
267                 dmtc->orig_buf = bio->bio_buf->b_data;
268                 space += sizeof(struct dmtc_helper);
269                 memcpy(space + sz, bio->bio_buf->b_data, bytes);
270                 bio->bio_caller_info2.ptr = dmtc;
271                 bio->bio_buf->b_data = data = space + sz;
272         } else {
273                 space = kmalloc(sz, M_DMCRYPT, M_WAITOK);
274                 data = bio->bio_buf->b_data;
275                 bio->bio_caller_info2.ptr = space;
276         }
277
278         ptr = space;
279         bio->bio_caller_info3.value = sectors;
280 #if 0
281         kprintf("Write? %d, bytes = %d (b_bcount), sectors = %d (bio = %p, b_cmd = %d)\n", write, bytes, sectors, bio, bio->bio_buf->b_cmd);
282 #endif
283         for (i = 0; i < sectors; i++) {
284                 crp = (struct cryptop *)ptr;
285                 ptr += sizeof(*crp);
286                 crd = (struct cryptodesc *)ptr;
287                 ptr += sizeof (*crd);
288
289                 crp->crp_buf = (data + i*DEV_BSIZE);
290
291                 crp->crp_sid = priv->crypto_sid;
292                 crp->crp_ilen = crp->crp_olen = DEV_BSIZE;
293
294                 crp->crp_opaque = (void *)bio;
295
296                 if (write)
297                         crp->crp_callback = dm_target_crypt_crypto_done_write;
298                 else
299                         crp->crp_callback = dm_target_crypt_crypto_done_read;
300                 crp->crp_desc = crd;
301                 crp->crp_etype = 0;
302                 crp->crp_flags = CRYPTO_F_CBIFSYNC | CRYPTO_F_REL;
303
304                 crd->crd_alg = priv->crypto_alg;
305                 crd->crd_key = (caddr_t)priv->crypto_key;
306                 crd->crd_klen = priv->crypto_klen;
307
308                 priv->crypto_ivgen(priv, crd->crd_iv, sizeof(crd->crd_iv), isector + i);
309
310                 crd->crd_skip = 0;
311                 crd->crd_len = DEV_BSIZE /* XXX */;
312                 crd->crd_flags = CRD_F_KEY_EXPLICIT | CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
313                 crd->crd_next = NULL;
314
315                 if (write)
316                         crd->crd_flags |= CRD_F_ENCRYPT;
317                 else
318                         crd->crd_flags &= ~CRD_F_ENCRYPT;
319
320                 error = crypto_dispatch(crp);
321         }
322 }
323
324 static void
325 dm_target_crypt_read_done(struct bio *bio)
326 {
327         dm_target_crypt_config_t *priv;
328
329         priv = bio->bio_caller_info1.ptr;
330
331         dm_target_crypt_work(priv, bio);
332 }
333
334 static void
335 dm_target_crypt_write_done(struct bio *bio)
336 {
337         struct dmtc_helper *dmtc;
338         struct bio *obio;
339
340         dmtc = bio->bio_caller_info2.ptr;
341         bio->bio_buf->b_data = dmtc->orig_buf;
342         kfree(dmtc->free_addr, M_DMCRYPT);
343         obio = pop_bio(bio);
344         biodone(obio);
345 }
346
347 static int
348 dm_target_crypt_crypto_done_read(struct cryptop *crp)
349 {
350         struct bio *bio, *obio;
351         int n;
352
353         if (crp->crp_etype == EAGAIN)
354                 return crypto_dispatch(crp);
355
356         bio = (struct bio *)crp->crp_opaque;
357         KKASSERT(bio != NULL);
358         
359         n = atomic_fetchadd_int(&bio->bio_caller_info3.value, -1);
360 #if 0
361         kprintf("dm_target_crypt_crypto_done_read %p, n = %d\n", bio, n);
362 #endif
363         if (crp->crp_etype != 0) {
364                 kprintf("dm_target_crypt: dm_target_crypt_crypto_done_read crp_etype = %d\n", crp->crp_etype);
365                 /* XXX: Print something out */
366                 bio->bio_buf->b_error = crp->crp_etype; 
367         }
368         if (n == 1) {
369                 kfree(bio->bio_caller_info2.ptr, M_DMCRYPT);
370                 /* This is the last chunk of the read */
371                 obio = pop_bio(bio);
372                 biodone(obio);
373         }
374
375         return 0;
376 }
377
378 static int
379 dm_target_crypt_crypto_done_write(struct cryptop *crp)
380 {
381         struct dmtc_helper *dmtc;
382         dm_target_crypt_config_t *priv;
383         struct bio *bio, *obio;
384         int n;
385
386         if (crp->crp_etype == EAGAIN)
387                 return crypto_dispatch(crp);
388
389         bio = (struct bio *)crp->crp_opaque;
390         KKASSERT(bio != NULL);
391         
392         n = atomic_fetchadd_int(&bio->bio_caller_info3.value, -1);
393 #if 0
394         kprintf("dm_target_crypt_crypto_done_write %p, n = %d\n", bio, n);
395 #endif
396         if (crp->crp_etype != 0) {
397                 kprintf("dm_target_crypt: dm_target_crypt_crypto_done_write crp_etype = %d\n", crp->crp_etype);
398                 /* XXX: Print something out */
399                 bio->bio_buf->b_error = crp->crp_etype; 
400         }
401         if (n == 1) {
402                 /* This is the last chunk of the write */
403                 if (bio->bio_buf->b_error != 0) {
404                         /* XXX */
405                         dmtc = bio->bio_caller_info2.ptr;
406                         bio->bio_buf->b_data = dmtc->orig_buf;
407                         kfree(dmtc->free_addr, M_DMCRYPT);
408                         obio = pop_bio(bio);
409                         biodone(obio);
410                 } else {
411                         priv = (dm_target_crypt_config_t *)bio->bio_caller_info1.ptr;
412                         vn_strategy(priv->pdev->pdev_vnode, bio);
413                 }
414         }
415
416         return 0;
417 }
418
419 /*
420 strategy -> read_done -> crypto_work -> crypto_done_read -> FINISH READ
421 strategy -> crypto_work -> crypto_done_write -> write dispatch -> write_done -> FINISH WRITE
422 */
423
424 #ifdef DM_TARGET_MODULE
425 /*
426  * Every target can be compiled directly to dm driver or as a
427  * separate module this part of target is used for loading targets
428  * to dm driver.
429  * Target can be unloaded from kernel only if there are no users of
430  * it e.g. there are no devices which uses that target.
431  */
432 #include <sys/kernel.h>
433 #include <sys/module.h>
434
435 static int
436 dm_target_crypt_modcmd(modcmd_t cmd, void *arg)
437 {
438         dm_target_t *dmt;
439         int r;
440         dmt = NULL;
441
442         switch (cmd) {
443         case MODULE_CMD_INIT:
444                 if ((dmt = dm_target_lookup("crypt")) != NULL) {
445                         dm_target_unbusy(dmt);
446                         return EEXIST;
447                 }
448                 dmt = dm_target_alloc("crypt");
449
450                 dmt->version[0] = 1;
451                 dmt->version[1] = 0;
452                 dmt->version[2] = 0;
453                 strlcpy(dmt->name, "crypt", DM_MAX_TYPE_NAME);
454                 dmt->init = &dm_target_crypt_init;
455                 dmt->status = &dm_target_crypt_status;
456                 dmt->strategy = &dm_target_crypt_strategy;
457                 dmt->deps = &dm_target_crypt_deps;
458                 dmt->destroy = &dm_target_crypt_destroy;
459                 dmt->upcall = &dm_target_crypt_upcall;
460
461                 r = dm_target_insert(dmt);
462
463                 break;
464
465         case MODULE_CMD_FINI:
466                 r = dm_target_rem("crypt");
467                 break;
468
469         case MODULE_CMD_STAT:
470                 return ENOTTY;
471
472         default:
473                 return ENOTTY;
474         }
475
476         return r;
477 }
478 #endif
479
480 /*
481  * Init function called from dm_table_load_ioctl.
482  * cryptsetup actually passes us this:
483  * aes-cbc-essiv:sha256 7997f8af... 0 /dev/ad0s0a 8
484  */
485
486 static int
487 hex2key(char *hex, size_t hex_length, u_int8_t *key)
488 {
489         char hex_buf[3];
490         size_t key_idx;
491
492         key_idx = 0;
493         bzero(hex_buf, sizeof(hex_buf));
494
495         for (; hex_length > 0; hex_length -= 2) {
496                 hex_buf[0] = *hex++;
497                 hex_buf[1] = *hex++;
498                 key[key_idx++] = (u_int8_t)strtoul(hex_buf, NULL, 16);
499         }
500
501         return 0;
502 }
503
504 int
505 dm_target_crypt_init(dm_dev_t * dmv, void **target_config, char *params)
506 {
507         dm_target_crypt_config_t *priv;
508         size_t len;
509         char **ap, *args[5];
510         char *crypto_alg, *crypto_mode, *iv_mode, *iv_opt, *key, *dev;
511         char *status_str;
512         int argc, klen, error;
513         uint64_t iv_offset, block_offset;
514
515         if (params == NULL)
516                 return EINVAL;
517
518         len = strlen(params) + 1;
519         argc = 0;
520
521         status_str = kstrdup(params, M_DMCRYPT);
522         /*
523          * Parse a string, containing tokens delimited by white space,
524          * into an argument vector
525          */
526         for (ap = args; ap < &args[5] &&
527             (*ap = strsep(&params, " \t")) != NULL;) {
528                 if (**ap != '\0') {
529                         argc++;
530                         ap++;
531                 }
532         }
533
534         if (argc != 5) {
535                 kprintf("dm_target_crypt: not enough arguments, need exactly 5\n");
536                 kfree(status_str, M_DMCRYPT);
537                 return ENOMEM; /* XXX */
538         }
539
540         crypto_alg = strsep(&args[0], "-");
541         crypto_mode = strsep(&args[0], "-");
542         iv_opt = strsep(&args[0], "-");
543         iv_mode = strsep(&iv_opt, ":");
544         key = args[1];
545         iv_offset = strtouq(args[2], NULL, 0);
546         dev = args[3];
547         block_offset = strtouq(args[4], NULL, 0);
548         /* bits / 8 = bytes, 1 byte = 2 hexa chars, so << 2 */
549         klen = strlen(key) << 2;
550
551         kprintf("dm_target_crypt: dev=%s, crypto_alg=%s, crypto_mode=%s, "
552                 "iv_mode=%s, iv_opt=%s, key=%s, iv_offset=%ju, block_offset=%ju\n",
553                 dev, crypto_alg, crypto_mode, iv_mode, iv_opt, key, iv_offset,
554                 block_offset);
555
556         if ((priv = kmalloc(sizeof(dm_target_crypt_config_t), M_DMCRYPT, M_NOWAIT))
557             == NULL) {
558                 kprintf("dm_target_crypt: could not allocate memory\n");
559                 kfree(status_str, M_DMCRYPT);
560                 return ENOMEM;
561         }
562
563         /* Insert dmp to global pdev list */
564         if ((priv->pdev = dm_pdev_insert(dev)) == NULL) {
565                 kprintf("dm_target_crypt: dm_pdev_insert failed\n");
566                 kfree(status_str, M_DMCRYPT);
567                 return ENOENT;
568         }
569
570         if (strcmp(crypto_mode, "cbc") != 0) {
571                 kprintf("dm_target_crypt: only support 'cbc' chaining mode, invalid mode '%s'\n", crypto_mode);         
572                 goto notsup;
573         }
574
575         if (!strcmp(crypto_alg, "aes")) {
576                 priv->crypto_alg = CRYPTO_AES_CBC;
577                 if (klen != 128 && klen != 192 && klen != 256)
578                         goto notsup;
579                 priv->crypto_klen = klen;
580
581         } else if (!strcmp(crypto_alg, "blowfish")) {
582                 priv->crypto_alg = CRYPTO_BLF_CBC;
583                 if (klen < 128 || klen > 448 || (klen % 8) != 0)
584                         goto notsup;
585                 priv->crypto_klen = klen;
586
587         } else if (!strcmp(crypto_alg, "3des") || !strncmp(crypto_alg, "des3", 4)) {
588                 priv->crypto_alg = CRYPTO_3DES_CBC;
589                 if (klen != 168)
590                         goto notsup;
591                 priv->crypto_klen = 168;
592
593         } else if (!strcmp(crypto_alg, "camellia")) {
594                 priv->crypto_alg = CRYPTO_CAMELLIA_CBC;
595                 if (klen != 128 && klen != 192 && klen != 256)
596                         goto notsup;
597                 priv->crypto_klen = klen;
598
599         } else if (!strcmp(crypto_alg, "skipjack")) {
600                 priv->crypto_alg = CRYPTO_SKIPJACK_CBC;
601                 if (klen != 80)
602                         goto notsup;
603                 priv->crypto_klen = 80;
604
605         } else if (!strcmp(crypto_alg, "cast5")) {
606                 priv->crypto_alg = CRYPTO_CAST_CBC;
607                 if (klen != 128)
608                         goto notsup;
609                 priv->crypto_klen = 128;
610
611         } else if (!strcmp(crypto_alg, "null")) {
612                 priv->crypto_alg = CRYPTO_NULL_CBC;
613                 if (klen != 128)
614                         goto notsup;
615                 priv->crypto_klen = 128;
616
617         } else {
618                 kprintf("dm_target_crypt: Unsupported crypto algorithm: %s\n", crypto_alg);
619                 goto notsup;
620         }
621
622         /* Save length of param string */
623         priv->params_len = len;
624         priv->block_offset = block_offset;
625         priv->iv_offset = iv_offset;
626
627         *target_config = priv;
628
629         dmv->dev_type = DM_CRYPTO_DEV;
630
631         priv->crypto_session.cri_alg = priv->crypto_alg;
632         priv->crypto_session.cri_klen = priv->crypto_klen;
633         priv->crypto_session.cri_mlen = 0;
634
635         error = hex2key(key, priv->crypto_klen >> 3, (u_int8_t *)priv->crypto_key);
636         if (error) {
637                 kprintf("dm_target_crypt: hex2key failed, invalid key format\n");
638                 goto notsup;
639         }
640
641
642         if (!strcmp(iv_mode, "essiv")) {
643                 error = essiv_hash_mkey(priv, iv_opt);
644                 if (error) {
645                         kprintf("dm_target_crypt: essiv_hash_mkey failed\n");
646                         goto notsup;            
647                 }
648                 priv->crypto_ivgen = essiv_ivgen;
649         } else if (!strcmp(iv_mode, "plain")) {
650                 priv->crypto_ivgen = plain_ivgen;
651         } else {
652                 kprintf("dm_target_crypt: only support iv_mode='essiv' and 'plain', iv_mode='%s' unsupported\n", iv_mode);
653         }
654
655         priv->crypto_session.cri_key = (u_int8_t *)priv->crypto_key;
656         priv->crypto_session.cri_next = NULL;
657
658         error = crypto_newsession(&priv->crypto_sid,
659                                   &priv->crypto_session,
660                                   CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_HARDWARE);
661         if (error) {
662                 kprintf("dm_target_crypt: Error during crypto_newsession, error = %d\n", error);
663                 goto notsup;
664         }
665
666         priv->status_str = status_str;
667         return 0;
668
669 notsup:
670         kprintf("dm_target_crypt: ENOTSUP\n");
671         kfree(status_str, M_DMCRYPT);
672         return ENOTSUP;
673 }
674
675 /* Status routine called to get params string. */
676 char *
677 dm_target_crypt_status(void *target_config)
678 {
679         dm_target_crypt_config_t *priv;
680         char *params;
681
682         priv = target_config;
683
684         if ((params = kmalloc(DM_MAX_PARAMS_SIZE, M_DMCRYPT, M_WAITOK)) == NULL)
685                 return NULL;
686
687         ksnprintf(params, DM_MAX_PARAMS_SIZE, "%s",
688             priv->status_str);
689
690         return params;
691 }
692
693 /* Strategy routine called from dm_strategy. */
694 /*
695  * Do IO operation, called from dmstrategy routine.
696  */
697 int
698 dm_target_crypt_strategy(dm_table_entry_t * table_en, struct buf * bp)
699 {
700         struct bio *bio;
701
702         dm_target_crypt_config_t *priv;
703         priv = table_en->target_config;
704
705         /* Get rid of stuff we can't really handle */
706         if ((bp->b_cmd == BUF_CMD_READ) || (bp->b_cmd == BUF_CMD_WRITE)) {
707                 if (((bp->b_bcount % DEV_BSIZE) != 0) || (bp->b_bcount == 0)) {
708                         kprintf("dm_target_crypt_strategy: can't really handle bp->b_bcount = %d\n", bp->b_bcount);
709                         bp->b_error = EINVAL;
710                         bp->b_flags |= B_ERROR | B_INVAL;
711                         biodone(&bp->b_bio1);
712                         return 0;
713                 }
714         }
715
716         switch (bp->b_cmd) {
717         case BUF_CMD_READ:
718                 bio = push_bio(&bp->b_bio1);
719                 bio->bio_offset = bp->b_bio1.bio_offset + priv->block_offset*DEV_BSIZE;
720                 bio->bio_caller_info1.ptr = priv;
721                 bio->bio_done = dm_target_crypt_read_done;
722                 vn_strategy(priv->pdev->pdev_vnode, bio);
723                 break;
724
725         case BUF_CMD_WRITE:
726                 bio = push_bio(&bp->b_bio1);
727                 bio->bio_offset = bp->b_bio1.bio_offset + priv->block_offset*DEV_BSIZE;
728                 bio->bio_caller_info1.ptr = priv;
729                 bio->bio_done = dm_target_crypt_write_done;
730                 dm_target_crypt_work(priv, bio);
731                 break;
732
733         default:
734                 vn_strategy(priv->pdev->pdev_vnode, &bp->b_bio1);               
735         }
736
737         return 0;
738
739 }
740
741 int
742 dm_target_crypt_destroy(dm_table_entry_t * table_en)
743 {
744         dm_target_crypt_config_t *priv;
745
746         priv = table_en->target_config;
747
748         if (priv == NULL)
749                 return 0;
750
751         dm_pdev_decr(priv->pdev);
752
753         /* Unbusy target so we can unload it */
754         dm_target_unbusy(table_en->target);
755
756         kfree(priv->status_str, M_DMCRYPT);
757         kfree(priv, M_DMCRYPT);
758
759         table_en->target_config = NULL;
760
761         return 0;
762 }
763
764 int
765 dm_target_crypt_deps(dm_table_entry_t * table_en, prop_array_t prop_array)
766 {
767         dm_target_crypt_config_t *priv;
768         struct vattr va;
769
770         int error;
771
772         if (table_en->target_config == NULL)
773                 return ENOENT;
774
775         priv = table_en->target_config;
776
777         if ((error = VOP_GETATTR(priv->pdev->pdev_vnode, &va)) != 0)
778                 return error;
779
780         prop_array_add_uint64(prop_array, (uint64_t) makeudev(va.va_rmajor, va.va_rminor));
781
782         return 0;
783 }
784
785 /* Unsupported for this target. */
786 int
787 dm_target_crypt_upcall(dm_table_entry_t * table_en, struct buf * bp)
788 {
789         return 0;
790 }