2 * Software async crypto daemon.
4 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
13 #include <crypto/algapi.h>
14 #include <linux/err.h>
15 #include <linux/init.h>
16 #include <linux/kernel.h>
17 #include <linux/kthread.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/mutex.h>
21 #include <linux/scatterlist.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
24 #include <linux/spinlock.h>
26 #define CRYPTD_MAX_QLEN 100
31 struct crypto_queue queue
;
32 struct task_struct
*task
;
35 struct cryptd_instance_ctx
{
36 struct crypto_spawn spawn
;
37 struct cryptd_state
*state
;
40 struct cryptd_blkcipher_ctx
{
41 struct crypto_blkcipher
*child
;
44 struct cryptd_blkcipher_request_ctx
{
45 crypto_completion_t complete
;
49 static inline struct cryptd_state
*cryptd_get_state(struct crypto_tfm
*tfm
)
51 struct crypto_instance
*inst
= crypto_tfm_alg_instance(tfm
);
52 struct cryptd_instance_ctx
*ictx
= crypto_instance_ctx(inst
);
56 static int cryptd_blkcipher_setkey(struct crypto_ablkcipher
*parent
,
57 const u8
*key
, unsigned int keylen
)
59 struct cryptd_blkcipher_ctx
*ctx
= crypto_ablkcipher_ctx(parent
);
60 struct crypto_blkcipher
*child
= ctx
->child
;
63 crypto_blkcipher_clear_flags(child
, CRYPTO_TFM_REQ_MASK
);
64 crypto_blkcipher_set_flags(child
, crypto_ablkcipher_get_flags(parent
) &
66 err
= crypto_blkcipher_setkey(child
, key
, keylen
);
67 crypto_ablkcipher_set_flags(parent
, crypto_blkcipher_get_flags(child
) &
72 static void cryptd_blkcipher_crypt(struct ablkcipher_request
*req
,
73 struct crypto_blkcipher
*child
,
75 int (*crypt
)(struct blkcipher_desc
*desc
,
76 struct scatterlist
*dst
,
77 struct scatterlist
*src
,
80 struct cryptd_blkcipher_request_ctx
*rctx
;
81 struct blkcipher_desc desc
;
83 rctx
= ablkcipher_request_ctx(req
);
85 if (unlikely(err
== -EINPROGRESS
))
89 desc
.info
= req
->info
;
90 desc
.flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
92 err
= crypt(&desc
, req
->dst
, req
->src
, req
->nbytes
);
94 req
->base
.complete
= rctx
->complete
;
98 rctx
->complete(&req
->base
, err
);
102 static void cryptd_blkcipher_encrypt(struct crypto_async_request
*req
, int err
)
104 struct cryptd_blkcipher_ctx
*ctx
= crypto_tfm_ctx(req
->tfm
);
105 struct crypto_blkcipher
*child
= ctx
->child
;
107 cryptd_blkcipher_crypt(ablkcipher_request_cast(req
), child
, err
,
108 crypto_blkcipher_crt(child
)->encrypt
);
111 static void cryptd_blkcipher_decrypt(struct crypto_async_request
*req
, int err
)
113 struct cryptd_blkcipher_ctx
*ctx
= crypto_tfm_ctx(req
->tfm
);
114 struct crypto_blkcipher
*child
= ctx
->child
;
116 cryptd_blkcipher_crypt(ablkcipher_request_cast(req
), child
, err
,
117 crypto_blkcipher_crt(child
)->decrypt
);
120 static int cryptd_blkcipher_enqueue(struct ablkcipher_request
*req
,
121 crypto_completion_t complete
)
123 struct cryptd_blkcipher_request_ctx
*rctx
= ablkcipher_request_ctx(req
);
124 struct crypto_ablkcipher
*tfm
= crypto_ablkcipher_reqtfm(req
);
125 struct cryptd_state
*state
=
126 cryptd_get_state(crypto_ablkcipher_tfm(tfm
));
129 rctx
->complete
= req
->base
.complete
;
130 req
->base
.complete
= complete
;
132 spin_lock_bh(&state
->lock
);
133 err
= ablkcipher_enqueue_request(&state
->queue
, req
);
134 spin_unlock_bh(&state
->lock
);
136 wake_up_process(state
->task
);
140 static int cryptd_blkcipher_encrypt_enqueue(struct ablkcipher_request
*req
)
142 return cryptd_blkcipher_enqueue(req
, cryptd_blkcipher_encrypt
);
145 static int cryptd_blkcipher_decrypt_enqueue(struct ablkcipher_request
*req
)
147 return cryptd_blkcipher_enqueue(req
, cryptd_blkcipher_decrypt
);
150 static int cryptd_blkcipher_init_tfm(struct crypto_tfm
*tfm
)
152 struct crypto_instance
*inst
= crypto_tfm_alg_instance(tfm
);
153 struct cryptd_instance_ctx
*ictx
= crypto_instance_ctx(inst
);
154 struct crypto_spawn
*spawn
= &ictx
->spawn
;
155 struct cryptd_blkcipher_ctx
*ctx
= crypto_tfm_ctx(tfm
);
156 struct crypto_blkcipher
*cipher
;
158 cipher
= crypto_spawn_blkcipher(spawn
);
160 return PTR_ERR(cipher
);
163 tfm
->crt_ablkcipher
.reqsize
=
164 sizeof(struct cryptd_blkcipher_request_ctx
);
168 static void cryptd_blkcipher_exit_tfm(struct crypto_tfm
*tfm
)
170 struct cryptd_blkcipher_ctx
*ctx
= crypto_tfm_ctx(tfm
);
171 struct cryptd_state
*state
= cryptd_get_state(tfm
);
174 mutex_lock(&state
->mutex
);
175 active
= ablkcipher_tfm_in_queue(&state
->queue
,
176 __crypto_ablkcipher_cast(tfm
));
177 mutex_unlock(&state
->mutex
);
181 crypto_free_blkcipher(ctx
->child
);
184 static struct crypto_instance
*cryptd_alloc_instance(struct crypto_alg
*alg
,
185 struct cryptd_state
*state
)
187 struct crypto_instance
*inst
;
188 struct cryptd_instance_ctx
*ctx
;
191 inst
= kzalloc(sizeof(*inst
) + sizeof(*ctx
), GFP_KERNEL
);
193 inst
= ERR_PTR(-ENOMEM
);
198 if (snprintf(inst
->alg
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
199 "cryptd(%s)", alg
->cra_driver_name
) >= CRYPTO_MAX_ALG_NAME
)
202 ctx
= crypto_instance_ctx(inst
);
203 err
= crypto_init_spawn(&ctx
->spawn
, alg
, inst
,
204 CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_ASYNC
);
210 memcpy(inst
->alg
.cra_name
, alg
->cra_name
, CRYPTO_MAX_ALG_NAME
);
212 inst
->alg
.cra_priority
= alg
->cra_priority
+ 50;
213 inst
->alg
.cra_blocksize
= alg
->cra_blocksize
;
214 inst
->alg
.cra_alignmask
= alg
->cra_alignmask
;
225 static struct crypto_instance
*cryptd_alloc_blkcipher(
226 struct rtattr
**tb
, struct cryptd_state
*state
)
228 struct crypto_instance
*inst
;
229 struct crypto_alg
*alg
;
231 alg
= crypto_get_attr_alg(tb
, CRYPTO_ALG_TYPE_BLKCIPHER
,
232 CRYPTO_ALG_TYPE_MASK
);
234 return ERR_CAST(alg
);
236 inst
= cryptd_alloc_instance(alg
, state
);
240 inst
->alg
.cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
| CRYPTO_ALG_ASYNC
;
241 inst
->alg
.cra_type
= &crypto_ablkcipher_type
;
243 inst
->alg
.cra_ablkcipher
.ivsize
= alg
->cra_blkcipher
.ivsize
;
244 inst
->alg
.cra_ablkcipher
.min_keysize
= alg
->cra_blkcipher
.min_keysize
;
245 inst
->alg
.cra_ablkcipher
.max_keysize
= alg
->cra_blkcipher
.max_keysize
;
247 inst
->alg
.cra_ablkcipher
.geniv
= alg
->cra_blkcipher
.geniv
;
249 inst
->alg
.cra_ctxsize
= sizeof(struct cryptd_blkcipher_ctx
);
251 inst
->alg
.cra_init
= cryptd_blkcipher_init_tfm
;
252 inst
->alg
.cra_exit
= cryptd_blkcipher_exit_tfm
;
254 inst
->alg
.cra_ablkcipher
.setkey
= cryptd_blkcipher_setkey
;
255 inst
->alg
.cra_ablkcipher
.encrypt
= cryptd_blkcipher_encrypt_enqueue
;
256 inst
->alg
.cra_ablkcipher
.decrypt
= cryptd_blkcipher_decrypt_enqueue
;
263 static struct cryptd_state state
;
265 static struct crypto_instance
*cryptd_alloc(struct rtattr
**tb
)
267 struct crypto_attr_type
*algt
;
269 algt
= crypto_get_attr_type(tb
);
271 return ERR_CAST(algt
);
273 switch (algt
->type
& algt
->mask
& CRYPTO_ALG_TYPE_MASK
) {
274 case CRYPTO_ALG_TYPE_BLKCIPHER
:
275 return cryptd_alloc_blkcipher(tb
, &state
);
278 return ERR_PTR(-EINVAL
);
281 static void cryptd_free(struct crypto_instance
*inst
)
283 struct cryptd_instance_ctx
*ctx
= crypto_instance_ctx(inst
);
285 crypto_drop_spawn(&ctx
->spawn
);
289 static struct crypto_template cryptd_tmpl
= {
291 .alloc
= cryptd_alloc
,
293 .module
= THIS_MODULE
,
296 static inline int cryptd_create_thread(struct cryptd_state
*state
,
297 int (*fn
)(void *data
), const char *name
)
299 spin_lock_init(&state
->lock
);
300 mutex_init(&state
->mutex
);
301 crypto_init_queue(&state
->queue
, CRYPTD_MAX_QLEN
);
303 state
->task
= kthread_run(fn
, state
, name
);
304 if (IS_ERR(state
->task
))
305 return PTR_ERR(state
->task
);
310 static inline void cryptd_stop_thread(struct cryptd_state
*state
)
312 BUG_ON(state
->queue
.qlen
);
313 kthread_stop(state
->task
);
316 static int cryptd_thread(void *data
)
318 struct cryptd_state
*state
= data
;
321 current
->flags
|= PF_NOFREEZE
;
324 struct crypto_async_request
*req
, *backlog
;
326 mutex_lock(&state
->mutex
);
327 __set_current_state(TASK_INTERRUPTIBLE
);
329 spin_lock_bh(&state
->lock
);
330 backlog
= crypto_get_backlog(&state
->queue
);
331 req
= crypto_dequeue_request(&state
->queue
);
332 spin_unlock_bh(&state
->lock
);
334 stop
= kthread_should_stop();
337 __set_current_state(TASK_RUNNING
);
340 backlog
->complete(backlog
,
342 req
->complete(req
, 0);
346 mutex_unlock(&state
->mutex
);
354 static int __init
cryptd_init(void)
358 err
= cryptd_create_thread(&state
, cryptd_thread
, "cryptd");
362 err
= crypto_register_template(&cryptd_tmpl
);
364 kthread_stop(state
.task
);
369 static void __exit
cryptd_exit(void)
371 cryptd_stop_thread(&state
);
372 crypto_unregister_template(&cryptd_tmpl
);
375 module_init(cryptd_init
);
376 module_exit(cryptd_exit
);
378 MODULE_LICENSE("GPL");
379 MODULE_DESCRIPTION("Software async crypto daemon");