![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dm-target.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / linux / kernel|
Return to dm-target.c CVS log | Up to [truecrypt] / truecrypt / linux / kernel |
1.1.1.5 root 1: /*
2: Copyright (c) TrueCrypt Foundation. All rights reserved.
1.1 root 3:
1.1.1.6 ! root 4: Covered by the TrueCrypt License 2.3 the full text of which is contained
1.1.1.5 root 5: in the file License.txt included in TrueCrypt binary and source code
6: distribution packages.
1.1 root 7: */
8:
9: #include <linux/bio.h>
1.1.1.4 root 10: #include <linux/blkdev.h>
1.1 root 11: #include <linux/ctype.h>
1.1.1.4 root 12: #include <linux/device-mapper.h>
1.1 root 13: #include <linux/init.h>
1.1.1.4 root 14: #include <linux/kdev_t.h>
1.1 root 15: #include <linux/module.h>
16: #include <linux/moduleparam.h>
17: #include <linux/version.h>
18: #include <linux/workqueue.h>
1.1.1.4 root 19: #include <dm.h>
1.1 root 20:
21: #include "Tcdefs.h"
22: #include "Crypto.h"
23: #include "Tests.h"
24: #include "Dm-target.h"
25:
26: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5)
27: #error Linux kernel 2.6.5 or later required
28: #endif
29:
30: int trace_level = 0;
31:
32: #define MSG_PREFIX "truecrypt: "
33: #define error(fmt, args...) printk(KERN_ERR MSG_PREFIX fmt, ## args)
34: #define trace(level, fmt, args...) level <= trace_level && printk(KERN_DEBUG MSG_PREFIX fmt, ## args)
35: #define dbg(fmt, args...) printk(KERN_DEBUG MSG_PREFIX fmt, ## args)
36:
37: #define MIN_POOL_SIZE 16
38:
1.1.1.4 root 39: #ifndef __GFP_NOMEMALLOC
40: #define __GFP_NOMEMALLOC 0
41: #endif
42:
1.1 root 43: struct target_ctx
44: {
45: struct dm_dev *dev;
46: sector_t start;
47: char *volume_path;
48: mempool_t *bio_ctx_pool;
49: mempool_t *pg_pool;
1.1.1.4 root 50: unsigned long long read_only_start;
51: unsigned long long read_only_end;
1.1.1.5 root 52: unsigned long long uid;
1.1.1.4 root 53: unsigned long long mtime;
54: unsigned long long atime;
1.1 root 55: int flags;
1.1.1.2 root 56: PCRYPTO_INFO ci;
1.1 root 57: };
58:
59: struct bio_ctx
60: {
61: struct dm_target *target;
62: struct bio *orig_bio;
63: atomic_t ref_count;
64: u64 crypto_sector;
65: int error;
66: struct work_struct work;
67: };
68:
69: static struct workqueue_struct *work_queue = NULL;
1.1.1.5 root 70:
71: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
72: static struct kmem_cache *bio_ctx_cache = NULL;
73: #else
1.1 root 74: static kmem_cache_t *bio_ctx_cache = NULL;
1.1.1.5 root 75: #endif
1.1 root 76:
1.1.1.4 root 77: #define READ_ONLY(tc) (tc->flags & TC_READ_ONLY)
78: #define HID_VOL_PROT(tc) (tc->flags & TC_HIDDEN_VOLUME_PROTECTION)
1.1 root 79:
80:
81: static int hex2bin (char *hex_string, u8 *byte_buf, int max_length)
82: {
83: int i = 0, n;
84: char s[3];
85: s[2] = 0;
86:
87: while (i < max_length
88: && (s[0] = *hex_string++)
89: && (s[1] = *hex_string++))
90: {
91: if (sscanf (s, "%x", &n) != 1)
92: return 0;
93: byte_buf[i++] = (u8) n;
94: }
95:
96: return i;
97: }
98:
1.1.1.5 root 99:
100: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
101: #define congestion_wait blk_congestion_wait
102: #endif
103:
1.1.1.4 root 104: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
105:
106: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
107: static void *mempool_alloc_pg (gfp_t gfp_mask, void *pool_data)
108: #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
1.1 root 109: static void *mempool_alloc_pg (unsigned int gfp_mask, void *pool_data)
110: #else
111: static void *mempool_alloc_pg (int gfp_mask, void *pool_data)
112: #endif
113: {
114: return alloc_page (gfp_mask);
115: }
116:
117: static void mempool_free_pg (void *element, void *pool_data)
118: {
119: __free_page (element);
120: }
121:
1.1.1.4 root 122: #endif // LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)
123:
124:
125: static void *malloc_wait (mempool_t *pool, int direction)
126: {
127: void *p;
128: while (1)
129: {
130: p = mempool_alloc (pool, GFP_NOIO | __GFP_NOMEMALLOC);
131:
132: if (p)
133: return p;
134:
1.1.1.5 root 135: congestion_wait (direction, HZ / 50);
1.1.1.4 root 136: }
137: }
138:
1.1 root 139:
1.1.1.2 root 140: static void wipe_args (unsigned int argc, char **argv)
141: {
142: int i;
143: for (i = 0; i < argc; i++)
144: {
145: if (argv[i] != NULL)
146: burn (argv[i], strlen (argv[i]));
147: }
148: }
149:
150:
1.1 root 151: static int truecrypt_ctr (struct dm_target *ti, unsigned int argc, char **argv)
152: {
153: struct target_ctx *tc;
154: int key_size;
155: int error = -EINVAL;
1.1.1.4 root 156: unsigned long long sector;
1.1 root 157:
1.1.1.4 root 158: if (argc != TC_LAST_ARG + 1)
1.1 root 159: {
1.1.1.2 root 160: ti->error = "truecrypt: Usage: <start_sector> <sector_count> truecrypt <EA> <mode> <key> <key2/IV> <host_device> <sector_offset> <read_only_start> <read_only_end> <mtime> <atime> <flags> <volume_path>";
1.1 root 161: return -EINVAL;
162: }
163:
164: tc = kmalloc (sizeof (*tc), GFP_KERNEL);
165: if (tc == NULL)
166: {
167: ti->error = "truecrypt: Cannot allocate target context";
168: error = -ENOMEM;
169: goto err;
170: }
171: memset (tc, 0, sizeof (*tc));
172:
1.1.1.2 root 173: tc->ci = crypto_open ();
174: if (tc == NULL)
175: {
176: ti->error = "truecrypt: Cannot allocate crypto_info";
177: error = -ENOMEM;
178: goto err;
179: }
180:
1.1.1.4 root 181: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
182: tc->bio_ctx_pool = mempool_create_slab_pool (MIN_POOL_SIZE, bio_ctx_cache);
183: #else
1.1 root 184: tc->bio_ctx_pool = mempool_create (MIN_POOL_SIZE, mempool_alloc_slab, mempool_free_slab, bio_ctx_cache);
1.1.1.4 root 185: #endif
186:
1.1 root 187: if (!tc->bio_ctx_pool)
188: {
189: ti->error = "truecrypt: Cannot create bio context memory pool";
190: error = -ENOMEM;
191: goto err;
192: }
193:
1.1.1.4 root 194: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
195: tc->pg_pool = mempool_create_page_pool (MIN_POOL_SIZE, 0);
196: #else
1.1 root 197: tc->pg_pool = mempool_create (MIN_POOL_SIZE, mempool_alloc_pg, mempool_free_pg, NULL);
1.1.1.4 root 198: #endif
1.1 root 199: if (!tc->pg_pool)
200: {
201: ti->error = "truecrypt: Cannot create page memory pool";
202: error = -ENOMEM;
203: goto err;
204: }
205:
1.1.1.4 root 206: if (sscanf (argv[TC_ARG_SEC], "%llu", §or) != 1)
1.1 root 207: {
208: ti->error = "truecrypt: Invalid device sector";
209: goto err;
210: }
1.1.1.4 root 211: tc->start = sector;
1.1 root 212:
1.1.1.4 root 213: if (dm_get_device (ti, argv[TC_ARG_DEV], tc->start, ti->len, dm_table_get_mode (ti->table), &tc->dev))
1.1 root 214: {
215: ti->error = "truecrypt: Device lookup failed";
216: goto err;
217: }
218:
219: // Encryption algorithm
1.1.1.2 root 220: tc->ci->ea = 0;
1.1.1.4 root 221: if (sscanf (argv[TC_ARG_EA], "%d", &tc->ci->ea) != 1
1.1.1.2 root 222: || tc->ci->ea < EAGetFirst ()
223: || tc->ci->ea > EAGetCount ())
1.1 root 224: {
225: ti->error = "truecrypt: Invalid encryption algorithm";
226: goto err;
227: }
228:
1.1.1.2 root 229: // Mode of operation
230: tc->ci->mode = 0;
1.1.1.4 root 231: if (sscanf (argv[TC_ARG_MODE], "%d", &tc->ci->mode) != 1
1.1.1.2 root 232: || tc->ci->mode < 1
233: || tc->ci->mode >= INVALID_MODE)
1.1 root 234: {
1.1.1.2 root 235: ti->error = "truecrypt: Invalid mode of operation";
1.1 root 236: goto err;
237: }
238:
1.1.1.2 root 239: // Key
240: key_size = EAGetKeySize (tc->ci->ea);
1.1.1.4 root 241: if (hex2bin (argv[TC_ARG_KEY], tc->ci->master_key, key_size) != key_size)
1.1 root 242: {
243: ti->error = "truecrypt: Invalid key";
244: goto err;
245: }
1.1.1.2 root 246:
247: // EA init
248: if (EAInit (tc->ci->ea, tc->ci->master_key, tc->ci->ks) == ERR_CIPHER_INIT_FAILURE)
1.1 root 249: {
1.1.1.2 root 250: ti->error = "truecrypt: Encryption algorithm initialization failed";
1.1 root 251: goto err;
252: }
253:
1.1.1.2 root 254: // Key2 / IV
1.1.1.4 root 255: if (hex2bin (argv[TC_ARG_IV], tc->ci->iv, sizeof (tc->ci->iv)) != sizeof (tc->ci->iv))
1.1 root 256: {
257: ti->error = "truecrypt: Invalid IV";
258: goto err;
259: }
260:
1.1.1.2 root 261: // Mode init
262: if (!EAInitMode (tc->ci))
263: {
264: ti->error = "truecrypt: Mode of operation initialization failed";
265: goto err;
266: }
267:
1.1 root 268: // Read-only start sector
1.1.1.4 root 269: if (sscanf (argv[TC_ARG_RO_START], "%llu", &tc->read_only_start) != 1)
1.1 root 270: {
271: ti->error = "truecrypt: Invalid read-only start sector";
272: goto err;
273: }
274:
275: // Read-only end sector
1.1.1.4 root 276: if (sscanf (argv[TC_ARG_RO_END], "%llu", &tc->read_only_end) != 1)
1.1 root 277: {
278: ti->error = "truecrypt: Invalid read-only end sector";
279: goto err;
280: }
281:
1.1.1.5 root 282: // User ID
283: if (sscanf (argv[TC_ARG_UID], "%llu", &tc->uid) != 1)
284: {
285: ti->error = "truecrypt: Invalid user ID";
286: goto err;
287: }
288:
1.1 root 289: // Modification time
1.1.1.4 root 290: if (sscanf (argv[TC_ARG_MTIME], "%llu", &tc->mtime) != 1)
1.1 root 291: {
292: ti->error = "truecrypt: Invalid modification time";
293: goto err;
294: }
295:
296: // Access time
1.1.1.4 root 297: if (sscanf (argv[TC_ARG_ATIME], "%llu", &tc->atime) != 1)
1.1 root 298: {
299: ti->error = "truecrypt: Invalid access time";
300: goto err;
301: }
302:
303: // Flags
1.1.1.4 root 304: if (sscanf (argv[TC_ARG_FLAGS], "%d", &tc->flags) != 1)
1.1 root 305: {
306: ti->error = "truecrypt: Invalid flags";
307: goto err;
308: }
309:
310: // Volume path
1.1.1.4 root 311: tc->volume_path = kmalloc (strlen (argv[TC_ARG_VOL]) + 1, GFP_KERNEL);
1.1 root 312: if (tc->volume_path == NULL)
313: {
314: ti->error = "truecrypt: Cannot allocate volume path buffer";
315: error = -ENOMEM;
316: goto err;
317: }
1.1.1.4 root 318: strcpy (tc->volume_path, argv[TC_ARG_VOL]);
1.1 root 319:
1.1.1.2 root 320: // Hidden volume
321: if (tc->start > 1)
322: {
323: tc->ci->hiddenVolume = TRUE;
324: tc->ci->hiddenVolumeOffset = tc->start * SECTOR_SIZE;
325: }
326:
1.1 root 327: ti->private = tc;
1.1.1.2 root 328:
329: wipe_args (argc, argv);
1.1 root 330: return 0;
331:
332: err:
333: if (tc)
334: {
1.1.1.2 root 335: if (tc->ci)
336: crypto_close (tc->ci);
1.1 root 337: if (tc->volume_path)
338: kfree (tc->volume_path);
339: if (tc->bio_ctx_pool)
340: mempool_destroy (tc->bio_ctx_pool);
341: if (tc->pg_pool)
342: mempool_destroy (tc->pg_pool);
343: kfree (tc);
344: }
345:
1.1.1.2 root 346: wipe_args (argc, argv);
1.1 root 347: return error;
348: }
349:
350:
351: static void truecrypt_dtr (struct dm_target *ti)
352: {
353: struct target_ctx *tc = (struct target_ctx *) ti->private;
354:
355: mempool_destroy (tc->bio_ctx_pool);
1.1.1.2 root 356: mempool_destroy (tc->pg_pool);
357: crypto_close (tc->ci);
1.1 root 358: kfree(tc->volume_path);
1.1.1.2 root 359: dm_put_device(ti, tc->dev);
1.1 root 360: kfree(tc);
361: }
362:
363:
364: // Checks if two regions overlap (borders are parts of regions)
1.1.1.4 root 365: static int RegionsOverlap (u64 start1, u64 end1, u64 start2, u64 end2)
1.1 root 366: {
367: return (start1 < start2) ? (end1 >= start2) : (start1 <= end2);
368: }
369:
370:
371: static void dereference_bio_ctx (struct bio_ctx *bc)
372: {
373: struct target_ctx *tc = (struct target_ctx *) bc->target->private;
374:
375: if (!atomic_dec_and_test (&bc->ref_count))
376: return;
377:
378: bio_endio (bc->orig_bio, bc->orig_bio->bi_size, bc->error);
379: mempool_free (bc, tc->bio_ctx_pool);
380: }
381:
382:
1.1.1.5 root 383: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
384: static void work_process (struct work_struct *qdata)
385: {
386: struct bio_ctx *bc = container_of(qdata, struct bio_ctx, work);
387: #else
1.1.1.4 root 388: static void work_process (void *qdata)
1.1 root 389: {
1.1.1.4 root 390: struct bio_ctx *bc = (struct bio_ctx *) qdata;
1.1.1.5 root 391: #endif
392:
1.1 root 393: struct target_ctx *tc = (struct target_ctx *) bc->target->private;
394: struct bio_vec *bv;
1.1.1.4 root 395: u64 sec_no = bc->crypto_sector;
1.1 root 396: int seg_no;
397: unsigned long flags;
398:
399: // Decrypt queued data
400: bio_for_each_segment (bv, bc->orig_bio, seg_no)
401: {
402: unsigned int secs = bv->bv_len / SECTOR_SIZE;
403: char *data = bvec_kmap_irq (bv, &flags);
404:
1.1.1.2 root 405: DecryptSectors ((unsigned __int32 *)data, sec_no, secs, tc->ci);
1.1 root 406:
407: sec_no += secs;
408:
409: flush_dcache_page (bv->bv_page);
410: bvec_kunmap_irq (data, &flags);
1.1.1.4 root 411:
412: if (seg_no + 1 < bc->orig_bio->bi_vcnt)
413: cond_resched ();
1.1 root 414: }
415:
416: dereference_bio_ctx (bc);
417: }
418:
419:
420: static int truecrypt_endio (struct bio *bio, unsigned int bytes_done, int error)
421: {
422: struct bio_ctx *bc = (struct bio_ctx *) bio->bi_private;
423: struct target_ctx *tc = (struct target_ctx *) bc->target->private;
424: struct bio_vec *bv;
425: int seg_no;
426:
1.1.1.4 root 427: trace (1, "end: sc=%llu fl=%ld rw=%ld sz=%d ix=%hd vc=%hd dn=%d er=%d\n",
428: (unsigned long long) bio->bi_sector, bio->bi_flags, bio->bi_rw, bio->bi_size, bio->bi_idx, bio->bi_vcnt, bytes_done, error);
1.1 root 429:
430: if (error != 0)
431: bc->error = error;
432:
433: if (bio->bi_size)
434: {
435: trace (2, "Outstanding IO: %d\n", bio->bi_size);
436: return 1;
437: }
438:
439: if (bio_data_dir (bio) == READ)
440: {
441: bio_put (bio);
442:
443: // Queue decryption to leave completion interrupt ASAP
1.1.1.5 root 444: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
445: INIT_WORK (&bc->work, work_process);
446: #else
1.1 root 447: INIT_WORK (&bc->work, work_process, bc);
1.1.1.5 root 448: #endif
1.1 root 449: queue_work (work_queue, &bc->work);
450: return error;
451: }
452:
453: // Free pages allocated for encryption
454: bio_for_each_segment (bv, bio, seg_no)
455: {
456: mempool_free (bv->bv_page, tc->pg_pool);
457: }
458:
459: bio_put (bio);
460: dereference_bio_ctx (bc);
461: return error;
462: }
463:
464:
465: static int truecrypt_map (struct dm_target *ti, struct bio *bio, union map_info *map_context)
466: {
467: struct target_ctx *tc = (struct target_ctx *) ti->private;
468: struct bio_ctx *bc;
469: struct bio *bion;
470: struct bio_vec *bv;
471: int seg_no;
472:
1.1.1.4 root 473: trace (1, "map: sc=%llu fl=%ld rw=%ld sz=%d ix=%hd vc=%hd\n",
474: (unsigned long long) bio->bi_sector, bio->bi_flags, bio->bi_rw, bio->bi_size, bio->bi_idx, bio->bi_vcnt);
1.1 root 475:
476: // Write protection
477: if (bio_data_dir (bio) == WRITE && READ_ONLY (tc))
478: return -EPERM;
479:
480: // Validate segment sizes
481: bio_for_each_segment (bv, bio, seg_no)
482: {
483: if (bv->bv_len & (SECTOR_SIZE - 1))
484: {
1.1.1.4 root 485: error ("unsupported bio segment size %d (%ld %d %hd %hd)\n",
1.1 root 486: bv->bv_len, bio->bi_rw, bio->bi_size, bio->bi_idx, bio->bi_vcnt);
487: return -EINVAL;
488: }
489: }
490:
491: // Bio context
1.1.1.4 root 492: bc = malloc_wait (tc->bio_ctx_pool, bio_data_dir (bio));
1.1 root 493: if (!bc)
494: {
495: error ("bio context allocation failed\n");
496: return -ENOMEM;
497: }
498:
499: atomic_set (&bc->ref_count, 1);
500: bc->orig_bio = bio;
501: bc->error = 0;
502: bc->target = ti;
503: bc->crypto_sector = tc->start + (bio->bi_sector - ti->begin);
504:
505: // New bio for encrypted device
1.1.1.4 root 506: while (!(bion = bio_alloc (GFP_NOIO | __GFP_NOMEMALLOC, bio_segments (bio))))
1.1 root 507: {
1.1.1.5 root 508: congestion_wait (bio_data_dir (bio), HZ / 50);
1.1 root 509: }
510:
511: bion->bi_bdev = tc->dev->bdev;
512: bion->bi_end_io = truecrypt_endio;
513: bion->bi_idx = 0;
514: bion->bi_private = bc;
515: bion->bi_rw = bio->bi_rw;
516: bion->bi_sector = bc->crypto_sector;
517: bion->bi_size = bio->bi_size;
518: bion->bi_vcnt = bio_segments (bio);
519:
520: if (bio_data_dir (bio) == READ)
521: {
522: // Buffers of originating bio can be used for decryption
523: memcpy (bion->bi_io_vec,
524: bio_iovec (bio),
525: bion->bi_vcnt * sizeof (struct bio_vec));
526: }
527: else
528: {
1.1.1.4 root 529: u64 sec_no = bc->crypto_sector;
530: int seg_no;
531:
1.1 root 532: // Encrypt data to be written
533: unsigned long flags, copyFlags;
534: char *data, *copy;
535:
536: memset (bion->bi_io_vec, 0, sizeof (struct bio_vec) * bion->bi_vcnt);
537:
538: bio_for_each_segment (bv, bio, seg_no)
539: {
540: struct bio_vec *cbv = bio_iovec_idx (bion, seg_no);
541: unsigned int secs = bv->bv_len / SECTOR_SIZE;
542:
543: // Hidden volume protection
544: if (!READ_ONLY (tc) && HID_VOL_PROT (tc)
545: && RegionsOverlap (sec_no, sec_no + secs - 1, tc->read_only_start, tc->read_only_end))
546: {
1.1.1.4 root 547: tc->flags |= TC_READ_ONLY | TC_PROTECTION_ACTIVATED;
1.1 root 548: }
549:
1.1.1.4 root 550: if (READ_ONLY (tc))
1.1 root 551: {
1.1.1.4 root 552: // Write not permitted
1.1 root 553: bio_for_each_segment (cbv, bion, seg_no)
554: {
555: if (cbv->bv_page != NULL)
556: mempool_free (cbv->bv_page, tc->pg_pool);
557: }
558:
559: bio_put (bion);
560: bc->error = READ_ONLY (tc) ? -EPERM : -ENOMEM;
561: dereference_bio_ctx (bc);
562: return 0;
563: }
1.1.1.4 root 564:
565: cbv->bv_page = malloc_wait (tc->pg_pool, bio_data_dir (bion));
1.1 root 566:
567: cbv->bv_offset = 0;
568: cbv->bv_len = bv->bv_len;
569:
570: copy = bvec_kmap_irq (cbv, ©Flags);
1.1.1.3 root 571: data = bvec_kmap_irq (bv, &flags);
1.1 root 572:
573: memcpy (copy, data, bv->bv_len);
574:
1.1.1.4 root 575: EncryptSectors ((unsigned __int32 *) copy, sec_no, secs, tc->ci);
1.1 root 576: sec_no += secs;
577:
1.1.1.4 root 578: bvec_kunmap_irq (data, &flags);
1.1 root 579: bvec_kunmap_irq (copy, ©Flags);
1.1.1.4 root 580: flush_dcache_page (bv->bv_page);
581: flush_dcache_page (cbv->bv_page);
582:
583: if (seg_no + 1 < bio->bi_vcnt)
584: cond_resched();
1.1 root 585: }
586: }
587:
588: atomic_inc (&bc->ref_count);
589: generic_make_request (bion);
590:
591: dereference_bio_ctx (bc);
592: return 0;
593: }
594:
595:
596: static int truecrypt_status (struct dm_target *ti, status_type_t type, char *result, unsigned int maxlen)
597: {
598: struct target_ctx *tc = (struct target_ctx *) ti->private;
599:
600: switch (type)
601: {
602: case STATUSTYPE_INFO:
603: result[0] = 0;
604: break;
605:
606: case STATUSTYPE_TABLE:
607: {
608: char name[32];
609: format_dev_t (name, tc->dev->bdev->bd_dev);
1.1.1.5 root 610: snprintf (result, maxlen, "%d %d 0 0 %s %llu %llu %llu %llu %llu %llu %d %s",
1.1.1.2 root 611: tc->ci->ea,
612: tc->ci->mode,
1.1 root 613: name,
1.1.1.4 root 614: (unsigned long long) tc->start,
1.1 root 615: tc->read_only_start,
616: tc->read_only_end,
1.1.1.5 root 617: tc->uid,
1.1 root 618: tc->mtime,
619: tc->atime,
620: tc->flags,
621: tc->volume_path);
622: }
623: break;
624: }
625:
626: return 0;
627: }
628:
629:
630: static struct target_type truecrypt_target = {
631: .name = "truecrypt",
1.1.1.4 root 632: .version= {TC_VERSION_NUM1, TC_VERSION_NUM2, TC_VERSION_NUM3},
1.1 root 633: .module = THIS_MODULE,
634: .ctr = truecrypt_ctr,
635: .dtr = truecrypt_dtr,
636: .map = truecrypt_map,
637: .status = truecrypt_status
638: };
639:
640:
641: int __init dm_truecrypt_init(void)
642: {
643: int r;
644:
645: if (!AutoTestAlgorithms ())
646: {
1.1.1.5 root 647: error ("self-test of algorithms failed");
1.1 root 648: return -ERANGE;
649: }
650:
651: work_queue = create_workqueue ("truecryptq");
652:
653: if (!work_queue)
654: {
1.1.1.5 root 655: error ("create_workqueue failed");
1.1 root 656: goto err;
657: }
658:
659: bio_ctx_cache = kmem_cache_create ("truecrypt-bioctx", sizeof (struct bio_ctx), 0, 0, NULL, NULL);
660: if (!bio_ctx_cache)
661: {
1.1.1.5 root 662: error ("kmem_cache_create failed");
1.1 root 663: goto err;
664: }
665:
666: r = dm_register_target (&truecrypt_target);
667: if (r < 0)
668: {
1.1.1.5 root 669: error ("register failed %d", r);
1.1 root 670: goto err;
671: }
672:
673: return r;
674:
675: err:
676: if (work_queue)
677: destroy_workqueue (work_queue);
678: if (bio_ctx_cache)
679: kmem_cache_destroy (bio_ctx_cache);
680:
681: return -ENOMEM;
682: }
683:
684:
685: void __exit dm_truecrypt_exit(void)
686: {
687: int r;
688:
689: r = dm_unregister_target (&truecrypt_target);
690:
691: if (r < 0)
1.1.1.5 root 692: error ("unregister failed %d", r);
1.1 root 693:
694: destroy_workqueue (work_queue);
695: kmem_cache_destroy (bio_ctx_cache);
696: }
697:
698:
699: module_init(dm_truecrypt_init);
700: module_exit(dm_truecrypt_exit);
701: module_param_named(trace, trace_level, int, 0);
702:
703: MODULE_AUTHOR("TrueCrypt Foundation");
1.1.1.5 root 704: MODULE_DESCRIPTION("device-mapper target for encryption and decryption of TrueCrypt volumes");
1.1 root 705: MODULE_PARM_DESC(trace, "Trace level");
1.1.1.5 root 706: MODULE_LICENSE("GPL and additional rights");
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.