Searched refs:alg (Results 1 - 200 of 223) sorted by relevance

12

/linux-4.1.27/crypto/
H A Daead.c82 static unsigned int crypto_aead_ctxsize(struct crypto_alg *alg, u32 type, crypto_aead_ctxsize() argument
85 return alg->cra_ctxsize; crypto_aead_ctxsize()
95 struct aead_alg *alg = &tfm->__crt_alg->cra_aead; crypto_init_aead_ops() local
98 if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8) crypto_init_aead_ops()
102 alg->setkey : setkey; crypto_init_aead_ops()
103 crt->encrypt = alg->encrypt; crypto_init_aead_ops()
104 crt->decrypt = alg->decrypt; crypto_init_aead_ops()
105 crt->givencrypt = alg->givencrypt ?: no_givcrypt; crypto_init_aead_ops()
106 crt->givdecrypt = alg->givdecrypt ?: no_givcrypt; crypto_init_aead_ops()
108 crt->ivsize = alg->ivsize; crypto_init_aead_ops()
109 crt->authsize = alg->maxauthsize; crypto_init_aead_ops()
115 static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_aead_report() argument
118 struct aead_alg *aead = &alg->cra_aead; crypto_aead_report()
123 raead.blocksize = alg->cra_blocksize; crypto_aead_report()
136 static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_aead_report() argument
142 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
144 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg) crypto_aead_show() argument
146 struct aead_alg *aead = &alg->cra_aead; crypto_aead_show()
149 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_aead_show()
151 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_aead_show()
179 struct aead_alg *alg = &tfm->__crt_alg->cra_aead; crypto_init_nivaead_ops() local
182 if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8) crypto_init_nivaead_ops()
186 crt->encrypt = alg->encrypt; crypto_init_nivaead_ops()
187 crt->decrypt = alg->decrypt; crypto_init_nivaead_ops()
188 if (!alg->ivsize) { crypto_init_nivaead_ops()
193 crt->ivsize = alg->ivsize; crypto_init_nivaead_ops()
194 crt->authsize = alg->maxauthsize; crypto_init_nivaead_ops()
200 static int crypto_nivaead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_nivaead_report() argument
203 struct aead_alg *aead = &alg->cra_aead; crypto_nivaead_report()
208 raead.blocksize = alg->cra_blocksize; crypto_nivaead_report()
221 static int crypto_nivaead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_nivaead_report() argument
228 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg)
230 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg) crypto_nivaead_show() argument
232 struct aead_alg *aead = &alg->cra_aead; crypto_nivaead_show()
235 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_nivaead_show()
237 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_nivaead_show()
256 struct crypto_alg *alg; crypto_grab_nivaead() local
263 alg = crypto_alg_mod_lookup(name, type, mask); crypto_grab_nivaead()
264 if (IS_ERR(alg)) crypto_grab_nivaead()
265 return PTR_ERR(alg); crypto_grab_nivaead()
267 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_nivaead()
268 crypto_mod_put(alg); crypto_grab_nivaead()
280 struct crypto_alg *alg; aead_geniv_alloc() local
309 alg = crypto_aead_spawn_alg(spawn); aead_geniv_alloc()
312 if (!alg->cra_aead.ivsize) aead_geniv_alloc()
321 if (strcmp(tmpl->name, alg->cra_aead.geniv)) aead_geniv_alloc()
324 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); aead_geniv_alloc()
325 memcpy(inst->alg.cra_driver_name, alg->cra_driver_name, aead_geniv_alloc()
329 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, aead_geniv_alloc()
330 "%s(%s)", tmpl->name, alg->cra_name) >= aead_geniv_alloc()
333 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, aead_geniv_alloc()
334 "%s(%s)", tmpl->name, alg->cra_driver_name) >= aead_geniv_alloc()
339 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_GENIV; aead_geniv_alloc()
340 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; aead_geniv_alloc()
341 inst->alg.cra_priority = alg->cra_priority; aead_geniv_alloc()
342 inst->alg.cra_blocksize = alg->cra_blocksize; aead_geniv_alloc()
343 inst->alg.cra_alignmask = alg->cra_alignmask; aead_geniv_alloc()
344 inst->alg.cra_type = &crypto_aead_type; aead_geniv_alloc()
346 inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; aead_geniv_alloc()
347 inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; aead_geniv_alloc()
348 inst->alg.cra_aead.geniv = alg->cra_aead.geniv; aead_geniv_alloc()
350 inst->alg.cra_aead.setkey = alg->cra_aead.setkey; aead_geniv_alloc()
351 inst->alg.cra_aead.setauthsize = alg->cra_aead.setauthsize; aead_geniv_alloc()
352 inst->alg.cra_aead.encrypt = alg->cra_aead.encrypt; aead_geniv_alloc()
353 inst->alg.cra_aead.decrypt = alg->cra_aead.decrypt; aead_geniv_alloc()
396 static int crypto_nivaead_default(struct crypto_alg *alg, u32 type, u32 mask) crypto_nivaead_default() argument
413 larval = crypto_larval_lookup(alg->cra_driver_name, crypto_nivaead_default()
434 memcpy(palg.data.name, alg->cra_driver_name, CRYPTO_MAX_ALG_NAME); crypto_nivaead_default()
439 geniv = alg->cra_aead.geniv; crypto_nivaead_default()
467 crypto_mod_put(alg); crypto_nivaead_default()
473 struct crypto_alg *alg; crypto_lookup_aead() local
475 alg = crypto_alg_mod_lookup(name, type, mask); crypto_lookup_aead()
476 if (IS_ERR(alg)) crypto_lookup_aead()
477 return alg; crypto_lookup_aead()
479 if (alg->cra_type == &crypto_aead_type) crypto_lookup_aead()
480 return alg; crypto_lookup_aead()
482 if (!alg->cra_aead.ivsize) crypto_lookup_aead()
483 return alg; crypto_lookup_aead()
485 crypto_mod_put(alg); crypto_lookup_aead()
486 alg = crypto_alg_mod_lookup(name, type | CRYPTO_ALG_TESTED, crypto_lookup_aead()
488 if (IS_ERR(alg)) crypto_lookup_aead()
489 return alg; crypto_lookup_aead()
491 if (alg->cra_type == &crypto_aead_type) { crypto_lookup_aead()
492 if ((alg->cra_flags ^ type ^ ~mask) & CRYPTO_ALG_TESTED) { crypto_lookup_aead()
493 crypto_mod_put(alg); crypto_lookup_aead()
494 alg = ERR_PTR(-ENOENT); crypto_lookup_aead()
496 return alg; crypto_lookup_aead()
499 BUG_ON(!alg->cra_aead.ivsize); crypto_lookup_aead()
501 return ERR_PTR(crypto_nivaead_default(alg, type, mask)); crypto_lookup_aead()
508 struct crypto_alg *alg; crypto_grab_aead() local
516 alg = crypto_lookup_aead(name, type, mask); crypto_grab_aead()
517 if (IS_ERR(alg)) crypto_grab_aead()
518 return PTR_ERR(alg); crypto_grab_aead()
520 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_aead()
521 crypto_mod_put(alg); crypto_grab_aead()
537 struct crypto_alg *alg; crypto_alloc_aead() local
539 alg = crypto_lookup_aead(alg_name, type, mask); crypto_alloc_aead()
540 if (IS_ERR(alg)) { crypto_alloc_aead()
541 err = PTR_ERR(alg); crypto_alloc_aead()
545 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_alloc_aead()
549 crypto_mod_put(alg); crypto_alloc_aead()
H A Dapi.c37 static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg);
39 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg) crypto_mod_get() argument
41 return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL; crypto_mod_get()
45 void crypto_mod_put(struct crypto_alg *alg) crypto_mod_put() argument
47 struct module *module = alg->cra_module; crypto_mod_put()
49 crypto_alg_put(alg); crypto_mod_put()
56 return larval->alg.cra_driver_name[0]; crypto_is_test_larval()
62 struct crypto_alg *q, *alg = NULL; __crypto_alg_lookup() local
88 if (alg) __crypto_alg_lookup()
89 crypto_mod_put(alg); __crypto_alg_lookup()
90 alg = q; __crypto_alg_lookup()
96 return alg; __crypto_alg_lookup()
99 static void crypto_larval_destroy(struct crypto_alg *alg) crypto_larval_destroy() argument
101 struct crypto_larval *larval = (void *)alg; crypto_larval_destroy()
103 BUG_ON(!crypto_is_larval(alg)); crypto_larval_destroy()
118 larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type; crypto_larval_alloc()
119 larval->alg.cra_priority = -1; crypto_larval_alloc()
120 larval->alg.cra_destroy = crypto_larval_destroy; crypto_larval_alloc()
122 strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME); crypto_larval_alloc()
132 struct crypto_alg *alg; crypto_larval_add() local
139 atomic_set(&larval->alg.cra_refcnt, 2); crypto_larval_add()
142 alg = __crypto_alg_lookup(name, type, mask); crypto_larval_add()
143 if (!alg) { crypto_larval_add()
144 alg = &larval->alg; crypto_larval_add()
145 list_add(&alg->cra_list, &crypto_alg_list); crypto_larval_add()
149 if (alg != &larval->alg) { crypto_larval_add()
151 if (crypto_is_larval(alg)) crypto_larval_add()
152 alg = crypto_larval_wait(alg); crypto_larval_add()
155 return alg; crypto_larval_add()
158 void crypto_larval_kill(struct crypto_alg *alg) crypto_larval_kill() argument
160 struct crypto_larval *larval = (void *)alg; crypto_larval_kill()
163 list_del(&alg->cra_list); crypto_larval_kill()
166 crypto_alg_put(alg); crypto_larval_kill()
170 static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg) crypto_larval_wait() argument
172 struct crypto_larval *larval = (void *)alg; crypto_larval_wait()
178 alg = larval->adult; crypto_larval_wait()
180 alg = ERR_PTR(-EINTR); crypto_larval_wait()
182 alg = ERR_PTR(-ETIMEDOUT); crypto_larval_wait()
183 else if (!alg) crypto_larval_wait()
184 alg = ERR_PTR(-ENOENT); crypto_larval_wait()
186 !(alg->cra_flags & CRYPTO_ALG_TESTED)) crypto_larval_wait()
187 alg = ERR_PTR(-EAGAIN); crypto_larval_wait()
188 else if (!crypto_mod_get(alg)) crypto_larval_wait()
189 alg = ERR_PTR(-EAGAIN); crypto_larval_wait()
190 crypto_mod_put(&larval->alg); crypto_larval_wait()
192 return alg; crypto_larval_wait()
197 struct crypto_alg *alg; crypto_alg_lookup() local
200 alg = __crypto_alg_lookup(name, type, mask); crypto_alg_lookup()
203 return alg; crypto_alg_lookup()
209 struct crypto_alg *alg; crypto_larval_lookup() local
217 alg = crypto_alg_lookup(name, type, mask); crypto_larval_lookup()
218 if (!alg) { crypto_larval_lookup()
225 alg = crypto_alg_lookup(name, type, mask); crypto_larval_lookup()
228 if (alg) crypto_larval_lookup()
229 return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg; crypto_larval_lookup()
251 struct crypto_alg *alg; crypto_alg_mod_lookup() local
277 alg = crypto_larval_wait(larval); crypto_alg_mod_lookup()
280 alg = ERR_PTR(-ENOENT); crypto_alg_mod_lookup()
283 return alg; crypto_alg_mod_lookup()
333 static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask) crypto_ctxsize() argument
335 const struct crypto_type *type_obj = alg->cra_type; crypto_ctxsize()
338 len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1); crypto_ctxsize()
340 return len + type_obj->ctxsize(alg, type, mask); crypto_ctxsize()
342 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) { crypto_ctxsize()
347 len += crypto_cipher_ctxsize(alg); crypto_ctxsize()
351 len += crypto_compress_ctxsize(alg); crypto_ctxsize()
358 void crypto_shoot_alg(struct crypto_alg *alg) crypto_shoot_alg() argument
361 alg->cra_flags |= CRYPTO_ALG_DYING; crypto_shoot_alg()
366 struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type, __crypto_alloc_tfm() argument
373 tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask); __crypto_alloc_tfm()
378 tfm->__crt_alg = alg; __crypto_alloc_tfm()
384 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm))) __crypto_alloc_tfm()
393 crypto_shoot_alg(alg); __crypto_alloc_tfm()
430 struct crypto_alg *alg; crypto_alloc_base() local
432 alg = crypto_alg_mod_lookup(alg_name, type, mask); crypto_alloc_base()
433 if (IS_ERR(alg)) { crypto_alloc_base()
434 err = PTR_ERR(alg); crypto_alloc_base()
438 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_alloc_base()
442 crypto_mod_put(alg); crypto_alloc_base()
458 void *crypto_create_tfm(struct crypto_alg *alg, crypto_create_tfm() argument
468 total = tfmsize + sizeof(*tfm) + frontend->extsize(alg); crypto_create_tfm()
475 tfm->__crt_alg = alg; crypto_create_tfm()
481 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm))) crypto_create_tfm()
490 crypto_shoot_alg(alg); crypto_create_tfm()
547 struct crypto_alg *alg; crypto_alloc_tfm() local
549 alg = crypto_find_alg(alg_name, frontend, type, mask); crypto_alloc_tfm()
550 if (IS_ERR(alg)) { crypto_alloc_tfm()
551 err = PTR_ERR(alg); crypto_alloc_tfm()
555 tfm = crypto_create_tfm(alg, frontend); crypto_alloc_tfm()
559 crypto_mod_put(alg); crypto_alloc_tfm()
585 struct crypto_alg *alg; crypto_destroy_tfm() local
590 alg = tfm->__crt_alg; crypto_destroy_tfm()
592 if (!tfm->exit && alg->cra_exit) crypto_destroy_tfm()
593 alg->cra_exit(tfm); crypto_destroy_tfm()
595 crypto_mod_put(alg); crypto_destroy_tfm()
603 struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask); crypto_has_alg() local
605 if (!IS_ERR(alg)) { crypto_has_alg()
606 crypto_mod_put(alg); crypto_has_alg()
H A Dinternal.h43 struct crypto_alg alg; member in struct:crypto_larval
63 static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg) crypto_cipher_ctxsize() argument
65 return alg->cra_ctxsize; crypto_cipher_ctxsize()
68 static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg) crypto_compress_ctxsize() argument
70 return alg->cra_ctxsize; crypto_compress_ctxsize()
73 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg);
84 void crypto_larval_kill(struct crypto_alg *alg);
88 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
91 void crypto_shoot_alg(struct crypto_alg *alg);
92 struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
94 void *crypto_create_tfm(struct crypto_alg *alg,
106 static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg) crypto_alg_get() argument
108 atomic_inc(&alg->cra_refcnt); crypto_alg_get()
109 return alg; crypto_alg_get()
112 static inline void crypto_alg_put(struct crypto_alg *alg) crypto_alg_put() argument
114 if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy) crypto_alg_put()
115 alg->cra_destroy(alg); crypto_alg_put()
128 static inline int crypto_is_larval(struct crypto_alg *alg) crypto_is_larval() argument
130 return alg->cra_flags & CRYPTO_ALG_LARVAL; crypto_is_larval()
133 static inline int crypto_is_dead(struct crypto_alg *alg) crypto_is_dead() argument
135 return alg->cra_flags & CRYPTO_ALG_DEAD; crypto_is_dead()
138 static inline int crypto_is_moribund(struct crypto_alg *alg) crypto_is_moribund() argument
140 return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING); crypto_is_moribund()
H A Dalgapi.c27 static inline int crypto_set_driver_name(struct crypto_alg *alg) crypto_set_driver_name() argument
30 char *driver_name = alg->cra_driver_name; crypto_set_driver_name()
36 len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); crypto_set_driver_name()
54 static int crypto_check_alg(struct crypto_alg *alg) crypto_check_alg() argument
56 crypto_check_module_sig(alg->cra_module); crypto_check_alg()
58 if (alg->cra_alignmask & (alg->cra_alignmask + 1)) crypto_check_alg()
61 if (alg->cra_blocksize > PAGE_SIZE / 8) crypto_check_alg()
64 if (alg->cra_priority < 0) crypto_check_alg()
67 atomic_set(&alg->cra_refcnt, 1); crypto_check_alg()
69 return crypto_set_driver_name(alg); crypto_check_alg()
72 static void crypto_destroy_instance(struct crypto_alg *alg) crypto_destroy_instance() argument
74 struct crypto_instance *inst = (void *)alg; crypto_destroy_instance()
81 static struct list_head *crypto_more_spawns(struct crypto_alg *alg, crypto_more_spawns() argument
94 if (spawn->alg && &n->list != stack && !n->alg) crypto_more_spawns()
95 n->alg = (n->list.next == stack) ? alg : crypto_more_spawns()
97 list)->inst->alg; crypto_more_spawns()
101 return &n->list == stack ? top : &n->inst->alg.cra_users; crypto_more_spawns()
109 if (crypto_is_dead(&inst->alg)) crypto_remove_instance()
112 inst->alg.cra_flags |= CRYPTO_ALG_DEAD; crypto_remove_instance()
119 crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg); crypto_remove_instance()
120 list_move(&inst->alg.cra_list, list); crypto_remove_instance()
122 inst->alg.cra_destroy = crypto_destroy_instance; crypto_remove_instance()
124 BUG_ON(!list_empty(&inst->alg.cra_users)); crypto_remove_instance()
127 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list, crypto_remove_spawns() argument
130 u32 new_type = (nalg ?: alg)->cra_flags; crypto_remove_spawns()
137 spawns = &alg->cra_users; list_for_each_entry_safe()
139 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask) list_for_each_entry_safe()
154 BUG_ON(&inst->alg == alg);
158 if (&inst->alg == nalg)
161 spawn->alg = NULL;
162 spawns = &inst->alg.cra_users;
164 } while ((spawns = crypto_more_spawns(alg, &stack, &top,
168 if (spawn->alg)
169 list_move(&spawn->list, &spawn->alg->cra_users);
176 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg) __crypto_register_alg() argument
182 if (crypto_is_dead(alg)) __crypto_register_alg()
185 INIT_LIST_HEAD(&alg->cra_users); __crypto_register_alg()
188 alg->cra_flags &= ~CRYPTO_ALG_TESTED; __crypto_register_alg()
193 if (q == alg) __crypto_register_alg()
200 if (!strcmp(alg->cra_driver_name, q->cra_driver_name)) __crypto_register_alg()
205 if (!strcmp(q->cra_driver_name, alg->cra_name) || __crypto_register_alg()
206 !strcmp(q->cra_name, alg->cra_driver_name)) __crypto_register_alg()
210 larval = crypto_larval_alloc(alg->cra_name, __crypto_register_alg()
211 alg->cra_flags | CRYPTO_ALG_TESTED, 0); __crypto_register_alg()
216 larval->adult = crypto_mod_get(alg); __crypto_register_alg()
220 atomic_set(&larval->alg.cra_refcnt, 1); __crypto_register_alg()
221 memcpy(larval->alg.cra_driver_name, alg->cra_driver_name, __crypto_register_alg()
223 larval->alg.cra_priority = alg->cra_priority; __crypto_register_alg()
225 list_add(&alg->cra_list, &crypto_alg_list); __crypto_register_alg()
226 list_add(&larval->alg.cra_list, &crypto_alg_list); __crypto_register_alg()
241 struct crypto_alg *alg; crypto_alg_tested() local
256 printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err); crypto_alg_tested()
261 alg = test->adult; crypto_alg_tested()
262 if (err || list_empty(&alg->cra_list)) crypto_alg_tested()
265 alg->cra_flags |= CRYPTO_ALG_TESTED; crypto_alg_tested()
268 if (q == alg) crypto_alg_tested()
282 if (strcmp(alg->cra_name, q->cra_name) && crypto_alg_tested()
283 strcmp(alg->cra_driver_name, q->cra_name)) crypto_alg_tested()
288 if ((q->cra_flags ^ alg->cra_flags) & larval->mask) crypto_alg_tested()
290 if (!crypto_mod_get(alg)) crypto_alg_tested()
293 larval->adult = alg; crypto_alg_tested()
297 if (strcmp(alg->cra_name, q->cra_name)) crypto_alg_tested()
300 if (strcmp(alg->cra_driver_name, q->cra_driver_name) && crypto_alg_tested()
301 q->cra_priority > alg->cra_priority) crypto_alg_tested()
304 crypto_remove_spawns(q, &list, alg); crypto_alg_tested()
319 struct crypto_alg *alg; crypto_remove_final() local
322 list_for_each_entry_safe(alg, n, list, cra_list) { list_for_each_entry_safe()
323 list_del_init(&alg->cra_list); list_for_each_entry_safe()
324 crypto_alg_put(alg); list_for_each_entry_safe()
337 crypto_alg_tested(larval->alg.cra_driver_name, 0); crypto_wait_for_test()
344 crypto_larval_kill(&larval->alg); crypto_wait_for_test()
347 int crypto_register_alg(struct crypto_alg *alg) crypto_register_alg() argument
352 err = crypto_check_alg(alg); crypto_register_alg()
357 larval = __crypto_register_alg(alg); crypto_register_alg()
368 static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list) crypto_remove_alg() argument
370 if (unlikely(list_empty(&alg->cra_list))) crypto_remove_alg()
373 alg->cra_flags |= CRYPTO_ALG_DEAD; crypto_remove_alg()
375 crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg); crypto_remove_alg()
376 list_del_init(&alg->cra_list); crypto_remove_alg()
377 crypto_remove_spawns(alg, list, NULL); crypto_remove_alg()
382 int crypto_unregister_alg(struct crypto_alg *alg) crypto_unregister_alg() argument
388 ret = crypto_remove_alg(alg, &list); crypto_unregister_alg()
394 BUG_ON(atomic_read(&alg->cra_refcnt) != 1); crypto_unregister_alg()
395 if (alg->cra_destroy) crypto_unregister_alg()
396 alg->cra_destroy(alg); crypto_unregister_alg()
475 int err = crypto_remove_alg(&inst->alg, &users); hlist_for_each_entry()
485 BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1); hlist_for_each_entry_safe()
524 err = crypto_check_alg(&inst->alg); crypto_register_instance()
528 inst->alg.cra_module = tmpl->module; crypto_register_instance()
529 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE; crypto_register_instance()
531 if (unlikely(!crypto_mod_get(&inst->alg))) crypto_register_instance()
536 larval = __crypto_register_alg(&inst->alg); crypto_register_instance()
553 if (!(inst->alg.cra_flags & CRYPTO_ALG_TESTED)) crypto_register_instance()
558 crypto_mod_put(&inst->alg); crypto_register_instance()
569 crypto_remove_spawns(&inst->alg, &list, NULL); crypto_unregister_instance()
580 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, crypto_init_spawn() argument
589 if (!crypto_is_moribund(alg)) { crypto_init_spawn()
590 list_add(&spawn->list, &alg->cra_users); crypto_init_spawn()
591 spawn->alg = alg; crypto_init_spawn()
600 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg, crypto_init_spawn2() argument
606 if ((alg->cra_flags ^ frontend->type) & frontend->maskset) crypto_init_spawn2()
610 err = crypto_init_spawn(spawn, alg, inst, frontend->maskset); crypto_init_spawn2()
619 if (!spawn->alg) crypto_drop_spawn()
630 struct crypto_alg *alg; crypto_spawn_alg() local
634 alg = spawn->alg; crypto_spawn_alg()
635 alg2 = alg; crypto_spawn_alg()
641 if (alg) crypto_spawn_alg()
642 crypto_shoot_alg(alg); crypto_spawn_alg()
646 return alg; crypto_spawn_alg()
652 struct crypto_alg *alg; crypto_spawn_tfm() local
655 alg = crypto_spawn_alg(spawn); crypto_spawn_tfm()
656 if (IS_ERR(alg)) crypto_spawn_tfm()
657 return ERR_CAST(alg); crypto_spawn_tfm()
660 if (unlikely((alg->cra_flags ^ type) & mask)) crypto_spawn_tfm()
663 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_spawn_tfm()
670 crypto_mod_put(alg); crypto_spawn_tfm()
677 struct crypto_alg *alg; crypto_spawn_tfm2() local
680 alg = crypto_spawn_alg(spawn); crypto_spawn_tfm2()
681 if (IS_ERR(alg)) crypto_spawn_tfm2()
682 return ERR_CAST(alg); crypto_spawn_tfm2()
684 tfm = crypto_create_tfm(alg, spawn->frontend); crypto_spawn_tfm2()
691 crypto_mod_put(alg); crypto_spawn_tfm2()
791 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg, crypto_alloc_instance2() argument
806 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, crypto_alloc_instance2()
807 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) crypto_alloc_instance2()
810 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", crypto_alloc_instance2()
811 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) crypto_alloc_instance2()
823 struct crypto_alg *alg) crypto_alloc_instance()
829 inst = crypto_alloc_instance2(name, alg, 0); crypto_alloc_instance()
834 err = crypto_init_spawn(spawn, alg, inst, crypto_alloc_instance()
822 crypto_alloc_instance(const char *name, struct crypto_alg *alg) crypto_alloc_instance() argument
H A Dcrypto_user.c49 struct crypto_alg *q, *alg = NULL; crypto_alg_match() local
71 alg = q; crypto_alg_match()
77 return alg; crypto_alg_match()
80 static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg) crypto_report_cipher() argument
86 rcipher.blocksize = alg->cra_blocksize; crypto_report_cipher()
87 rcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_report_cipher()
88 rcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_report_cipher()
99 static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg) crypto_report_comp() argument
113 static int crypto_report_one(struct crypto_alg *alg, crypto_report_one() argument
116 strncpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name)); crypto_report_one()
117 strncpy(ualg->cru_driver_name, alg->cra_driver_name, crypto_report_one()
119 strncpy(ualg->cru_module_name, module_name(alg->cra_module), crypto_report_one()
124 ualg->cru_flags = alg->cra_flags; crypto_report_one()
125 ualg->cru_refcnt = atomic_read(&alg->cra_refcnt); crypto_report_one()
127 if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority)) crypto_report_one()
129 if (alg->cra_flags & CRYPTO_ALG_LARVAL) { crypto_report_one()
139 if (alg->cra_type && alg->cra_type->report) { crypto_report_one()
140 if (alg->cra_type->report(skb, alg)) crypto_report_one()
146 switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) { crypto_report_one()
148 if (crypto_report_cipher(skb, alg)) crypto_report_one()
153 if (crypto_report_comp(skb, alg)) crypto_report_one()
166 static int crypto_report_alg(struct crypto_alg *alg, crypto_report_alg() argument
184 err = crypto_report_one(alg, ualg, skb); crypto_report_alg()
200 struct crypto_alg *alg; crypto_report() local
208 alg = crypto_alg_match(p, 0); crypto_report()
209 if (!alg) crypto_report()
222 err = crypto_report_alg(alg, &info); crypto_report()
225 crypto_mod_put(alg); crypto_report()
235 struct crypto_alg *alg; crypto_dump_report() local
249 list_for_each_entry(alg, &crypto_alg_list, cra_list) { crypto_dump_report()
250 err = crypto_report_alg(alg, &info); crypto_dump_report()
269 struct crypto_alg *alg; crypto_update_alg() local
283 alg = crypto_alg_match(p, 1); crypto_update_alg()
284 if (!alg) crypto_update_alg()
289 crypto_remove_spawns(alg, &list, NULL); crypto_update_alg()
292 alg->cra_priority = nla_get_u32(priority); crypto_update_alg()
296 crypto_mod_put(alg); crypto_update_alg()
305 struct crypto_alg *alg; crypto_del_alg() local
315 alg = crypto_alg_match(p, 1); crypto_del_alg()
316 if (!alg) crypto_del_alg()
325 if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE)) crypto_del_alg()
329 if (atomic_read(&alg->cra_refcnt) > 2) crypto_del_alg()
332 err = crypto_unregister_instance((struct crypto_instance *)alg); crypto_del_alg()
335 crypto_mod_put(alg); crypto_del_alg()
343 struct crypto_alg *alg; crypto_user_skcipher_alg() local
349 alg = crypto_lookup_skcipher(name, type, mask); crypto_user_skcipher_alg()
350 if (!IS_ERR(alg)) crypto_user_skcipher_alg()
351 return alg; crypto_user_skcipher_alg()
353 err = PTR_ERR(alg); crypto_user_skcipher_alg()
369 struct crypto_alg *alg; crypto_user_aead_alg() local
377 alg = crypto_lookup_aead(name, type, mask); crypto_user_aead_alg()
378 if (!IS_ERR(alg)) crypto_user_aead_alg()
379 return alg; crypto_user_aead_alg()
381 err = PTR_ERR(alg); crypto_user_aead_alg()
398 struct crypto_alg *alg; crypto_add_alg() local
414 alg = crypto_alg_match(p, exact); crypto_add_alg()
415 if (alg) { crypto_add_alg()
416 crypto_mod_put(alg); crypto_add_alg()
427 alg = crypto_user_aead_alg(name, p->cru_type, p->cru_mask); crypto_add_alg()
432 alg = crypto_user_skcipher_alg(name, p->cru_type, p->cru_mask); crypto_add_alg()
435 alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask); crypto_add_alg()
438 if (IS_ERR(alg)) crypto_add_alg()
439 return PTR_ERR(alg); crypto_add_alg()
444 alg->cra_priority = nla_get_u32(priority); crypto_add_alg()
448 crypto_mod_put(alg); crypto_add_alg()
496 struct crypto_alg *alg; crypto_user_rcv_msg() local
503 list_for_each_entry(alg, &crypto_alg_list, cra_list) crypto_user_rcv_msg()
H A Dablkcipher.c346 static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type, crypto_ablkcipher_ctxsize() argument
349 return alg->cra_ctxsize; crypto_ablkcipher_ctxsize()
365 struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher; crypto_init_ablkcipher_ops() local
368 if (alg->ivsize > PAGE_SIZE / 8) crypto_init_ablkcipher_ops()
372 crt->encrypt = alg->encrypt; crypto_init_ablkcipher_ops()
373 crt->decrypt = alg->decrypt; crypto_init_ablkcipher_ops()
374 if (!alg->ivsize) { crypto_init_ablkcipher_ops()
379 crt->ivsize = alg->ivsize; crypto_init_ablkcipher_ops()
385 static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ablkcipher_report() argument
390 strncpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<default>", crypto_ablkcipher_report()
393 rblkcipher.blocksize = alg->cra_blocksize; crypto_ablkcipher_report()
394 rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize; crypto_ablkcipher_report()
395 rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize; crypto_ablkcipher_report()
396 rblkcipher.ivsize = alg->cra_ablkcipher.ivsize; crypto_ablkcipher_report()
407 static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ablkcipher_report() argument
413 static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
415 static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg) crypto_ablkcipher_show() argument
417 struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher; crypto_ablkcipher_show()
420 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_ablkcipher_show()
422 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_ablkcipher_show()
447 struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher; crypto_init_givcipher_ops() local
450 if (alg->ivsize > PAGE_SIZE / 8) crypto_init_givcipher_ops()
454 alg->setkey : setkey; crypto_init_givcipher_ops()
455 crt->encrypt = alg->encrypt; crypto_init_givcipher_ops()
456 crt->decrypt = alg->decrypt; crypto_init_givcipher_ops()
457 crt->givencrypt = alg->givencrypt; crypto_init_givcipher_ops()
458 crt->givdecrypt = alg->givdecrypt ?: no_givdecrypt; crypto_init_givcipher_ops()
460 crt->ivsize = alg->ivsize; crypto_init_givcipher_ops()
466 static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_givcipher_report() argument
471 strncpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<built-in>", crypto_givcipher_report()
474 rblkcipher.blocksize = alg->cra_blocksize; crypto_givcipher_report()
475 rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize; crypto_givcipher_report()
476 rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize; crypto_givcipher_report()
477 rblkcipher.ivsize = alg->cra_ablkcipher.ivsize; crypto_givcipher_report()
488 static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_givcipher_report() argument
494 static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg)
496 static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg) crypto_givcipher_show() argument
498 struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher; crypto_givcipher_show()
501 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_givcipher_show()
503 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_givcipher_show()
520 const char *crypto_default_geniv(const struct crypto_alg *alg) crypto_default_geniv() argument
522 if (((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_default_geniv()
523 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : crypto_default_geniv()
524 alg->cra_ablkcipher.ivsize) != crypto_default_geniv()
525 alg->cra_blocksize) crypto_default_geniv()
531 static int crypto_givcipher_default(struct crypto_alg *alg, u32 type, u32 mask) crypto_givcipher_default() argument
548 larval = crypto_larval_lookup(alg->cra_driver_name, crypto_givcipher_default()
570 memcpy(palg.data.name, alg->cra_driver_name, CRYPTO_MAX_ALG_NAME); crypto_givcipher_default()
575 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_givcipher_default()
577 geniv = alg->cra_blkcipher.geniv; crypto_givcipher_default()
579 geniv = alg->cra_ablkcipher.geniv; crypto_givcipher_default()
582 geniv = crypto_default_geniv(alg); crypto_givcipher_default()
610 crypto_mod_put(alg); crypto_givcipher_default()
616 struct crypto_alg *alg; crypto_lookup_skcipher() local
618 alg = crypto_alg_mod_lookup(name, type, mask); crypto_lookup_skcipher()
619 if (IS_ERR(alg)) crypto_lookup_skcipher()
620 return alg; crypto_lookup_skcipher()
622 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher()
624 return alg; crypto_lookup_skcipher()
626 if (!((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher()
627 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : crypto_lookup_skcipher()
628 alg->cra_ablkcipher.ivsize)) crypto_lookup_skcipher()
629 return alg; crypto_lookup_skcipher()
631 crypto_mod_put(alg); crypto_lookup_skcipher()
632 alg = crypto_alg_mod_lookup(name, type | CRYPTO_ALG_TESTED, crypto_lookup_skcipher()
634 if (IS_ERR(alg)) crypto_lookup_skcipher()
635 return alg; crypto_lookup_skcipher()
637 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher()
639 if ((alg->cra_flags ^ type ^ ~mask) & CRYPTO_ALG_TESTED) { crypto_lookup_skcipher()
640 crypto_mod_put(alg); crypto_lookup_skcipher()
641 alg = ERR_PTR(-ENOENT); crypto_lookup_skcipher()
643 return alg; crypto_lookup_skcipher()
646 BUG_ON(!((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher()
647 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : crypto_lookup_skcipher()
648 alg->cra_ablkcipher.ivsize)); crypto_lookup_skcipher()
650 return ERR_PTR(crypto_givcipher_default(alg, type, mask)); crypto_lookup_skcipher()
657 struct crypto_alg *alg; crypto_grab_skcipher() local
663 alg = crypto_lookup_skcipher(name, type, mask); crypto_grab_skcipher()
664 if (IS_ERR(alg)) crypto_grab_skcipher()
665 return PTR_ERR(alg); crypto_grab_skcipher()
667 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_skcipher()
668 crypto_mod_put(alg); crypto_grab_skcipher()
683 struct crypto_alg *alg; crypto_alloc_ablkcipher() local
685 alg = crypto_lookup_skcipher(alg_name, type, mask); crypto_alloc_ablkcipher()
686 if (IS_ERR(alg)) { crypto_alloc_ablkcipher()
687 err = PTR_ERR(alg); crypto_alloc_ablkcipher()
691 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_alloc_ablkcipher()
695 crypto_mod_put(alg); crypto_alloc_ablkcipher()
H A Dctr.c184 struct crypto_alg *alg; crypto_ctr_alloc() local
191 alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_CIPHER, crypto_ctr_alloc()
193 if (IS_ERR(alg)) crypto_ctr_alloc()
194 return ERR_CAST(alg); crypto_ctr_alloc()
198 if (alg->cra_blocksize < 4) crypto_ctr_alloc()
202 if (alg->cra_blocksize % 4) crypto_ctr_alloc()
205 inst = crypto_alloc_instance("ctr", alg); crypto_ctr_alloc()
209 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_ctr_alloc()
210 inst->alg.cra_priority = alg->cra_priority; crypto_ctr_alloc()
211 inst->alg.cra_blocksize = 1; crypto_ctr_alloc()
212 inst->alg.cra_alignmask = alg->cra_alignmask | (__alignof__(u32) - 1); crypto_ctr_alloc()
213 inst->alg.cra_type = &crypto_blkcipher_type; crypto_ctr_alloc()
215 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_ctr_alloc()
216 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_ctr_alloc()
217 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_ctr_alloc()
219 inst->alg.cra_ctxsize = sizeof(struct crypto_ctr_ctx); crypto_ctr_alloc()
221 inst->alg.cra_init = crypto_ctr_init_tfm; crypto_ctr_alloc()
222 inst->alg.cra_exit = crypto_ctr_exit_tfm; crypto_ctr_alloc()
224 inst->alg.cra_blkcipher.setkey = crypto_ctr_setkey; crypto_ctr_alloc()
225 inst->alg.cra_blkcipher.encrypt = crypto_ctr_crypt; crypto_ctr_alloc()
226 inst->alg.cra_blkcipher.decrypt = crypto_ctr_crypt; crypto_ctr_alloc()
228 inst->alg.cra_blkcipher.geniv = "chainiv"; crypto_ctr_alloc()
231 crypto_mod_put(alg); crypto_ctr_alloc()
340 struct crypto_alg *alg; crypto_rfc3686_alloc() local
369 alg = crypto_skcipher_spawn_alg(spawn); crypto_rfc3686_alloc()
373 if (alg->cra_ablkcipher.ivsize != CTR_RFC3686_BLOCK_SIZE) crypto_rfc3686_alloc()
377 if (alg->cra_blocksize != 1) crypto_rfc3686_alloc()
381 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "rfc3686(%s)", crypto_rfc3686_alloc()
382 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) crypto_rfc3686_alloc()
384 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc3686_alloc()
385 "rfc3686(%s)", alg->cra_driver_name) >= crypto_rfc3686_alloc()
389 inst->alg.cra_priority = alg->cra_priority; crypto_rfc3686_alloc()
390 inst->alg.cra_blocksize = 1; crypto_rfc3686_alloc()
391 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc3686_alloc()
393 inst->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | crypto_rfc3686_alloc()
394 (alg->cra_flags & CRYPTO_ALG_ASYNC); crypto_rfc3686_alloc()
395 inst->alg.cra_type = &crypto_ablkcipher_type; crypto_rfc3686_alloc()
397 inst->alg.cra_ablkcipher.ivsize = CTR_RFC3686_IV_SIZE; crypto_rfc3686_alloc()
398 inst->alg.cra_ablkcipher.min_keysize = crypto_rfc3686_alloc()
399 alg->cra_ablkcipher.min_keysize + CTR_RFC3686_NONCE_SIZE; crypto_rfc3686_alloc()
400 inst->alg.cra_ablkcipher.max_keysize = crypto_rfc3686_alloc()
401 alg->cra_ablkcipher.max_keysize + CTR_RFC3686_NONCE_SIZE; crypto_rfc3686_alloc()
403 inst->alg.cra_ablkcipher.geniv = "seqiv"; crypto_rfc3686_alloc()
405 inst->alg.cra_ablkcipher.setkey = crypto_rfc3686_setkey; crypto_rfc3686_alloc()
406 inst->alg.cra_ablkcipher.encrypt = crypto_rfc3686_crypt; crypto_rfc3686_alloc()
407 inst->alg.cra_ablkcipher.decrypt = crypto_rfc3686_crypt; crypto_rfc3686_alloc()
409 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc3686_ctx); crypto_rfc3686_alloc()
411 inst->alg.cra_init = crypto_rfc3686_init_tfm; crypto_rfc3686_alloc()
412 inst->alg.cra_exit = crypto_rfc3686_exit_tfm; crypto_rfc3686_alloc()
H A Dproc.c82 struct crypto_alg *alg = list_entry(p, struct crypto_alg, cra_list); c_show() local
84 seq_printf(m, "name : %s\n", alg->cra_name); c_show()
85 seq_printf(m, "driver : %s\n", alg->cra_driver_name); c_show()
86 seq_printf(m, "module : %s\n", module_name(alg->cra_module)); c_show()
87 seq_printf(m, "priority : %d\n", alg->cra_priority); c_show()
88 seq_printf(m, "refcnt : %d\n", atomic_read(&alg->cra_refcnt)); c_show()
90 (alg->cra_flags & CRYPTO_ALG_TESTED) ? c_show()
93 (alg->cra_flags & CRYPTO_ALG_INTERNAL) ? c_show()
96 if (alg->cra_flags & CRYPTO_ALG_LARVAL) { c_show()
98 seq_printf(m, "flags : 0x%x\n", alg->cra_flags); c_show()
102 if (alg->cra_type && alg->cra_type->show) { c_show()
103 alg->cra_type->show(m, alg); c_show()
107 switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) { c_show()
110 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); c_show()
112 alg->cra_cipher.cia_min_keysize); c_show()
114 alg->cra_cipher.cia_max_keysize); c_show()
H A Dtestmgr.c37 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) alg_test() argument
118 const char *alg; member in struct:alg_test_desc
121 int fips_allowed; /* set if alg is allowed in fips mode */
219 printk(KERN_ERR "alg: hash: Failed to allocate request for " __test_hash()
247 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n", __test_hash()
255 printk(KERN_ERR "alg: hash: setkey failed on " __test_hash()
266 pr_err("alg: hash: digest failed on test %d " __test_hash()
293 printk(KERN_ERR "alg: hash: Test %d failed for %s\n", __test_hash()
331 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n", __test_hash()
341 printk(KERN_ERR "alg: hash: setkey " __test_hash()
362 printk(KERN_ERR "alg: hash: digest failed " __test_hash()
370 printk(KERN_ERR "alg: hash: Chunking test %d " __test_hash()
475 pr_err("alg: aead%s: Failed to allocate request for %s\n", __test_aead()
514 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n", __test_aead()
524 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n", __test_aead()
533 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n", __test_aead()
562 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n", __test_aead()
582 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n", __test_aead()
589 pr_err("alg: aead%s: Test %d failed on %s for %s\n", __test_aead()
616 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n", __test_aead()
625 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n", __test_aead()
666 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n", __test_aead()
712 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n", __test_aead()
732 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n", __test_aead()
751 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n", __test_aead()
770 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n", __test_aead()
871 printk(KERN_ERR "alg: cipher: setkey failed " test_cipher()
890 printk(KERN_ERR "alg: cipher: Test %d failed " test_cipher()
945 pr_err("alg: skcipher%s: Failed to allocate request for %s\n", __test_skcipher()
979 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n", __test_skcipher()
1009 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n", __test_skcipher()
1016 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n", __test_skcipher()
1046 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n", __test_skcipher()
1103 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n", __test_skcipher()
1120 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n", __test_skcipher()
1130 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n", __test_skcipher()
1202 printk(KERN_ERR "alg: comp: compression failed " test_comp()
1209 printk(KERN_ERR "alg: comp: Compression test %d " test_comp()
1217 printk(KERN_ERR "alg: comp: Compression test %d " test_comp()
1235 printk(KERN_ERR "alg: comp: decompression failed " test_comp()
1242 printk(KERN_ERR "alg: comp: Decompression test %d " test_comp()
1250 printk(KERN_ERR "alg: comp: Decompression test %d " test_comp()
1281 pr_err("alg: pcomp: compression setup failed on test " test_pcomp()
1288 pr_err("alg: pcomp: compression init failed on test " test_pcomp()
1302 pr_err("alg: pcomp: compression update failed on test " test_pcomp()
1314 pr_err("alg: pcomp: compression update failed on test " test_pcomp()
1326 pr_err("alg: pcomp: compression final failed on test " test_pcomp()
1333 pr_err("alg: comp: Compression test %d failed for %s: " test_pcomp()
1341 pr_err("alg: comp: Compression test %d failed for %s: " test_pcomp()
1348 pr_err("alg: pcomp: Compression test %d failed for " test_pcomp()
1362 pr_err("alg: pcomp: decompression setup failed on " test_pcomp()
1369 pr_err("alg: pcomp: decompression init failed on test " test_pcomp()
1383 pr_err("alg: pcomp: decompression update failed on " test_pcomp()
1395 pr_err("alg: pcomp: decompression update failed on " test_pcomp()
1407 pr_err("alg: pcomp: decompression final failed on " test_pcomp()
1415 pr_err("alg: comp: Decompression test %d failed for " test_pcomp()
1423 pr_err("alg: comp: Decompression test %d failed for " test_pcomp()
1430 pr_err("alg: pcomp: Decompression test %d failed for " test_pcomp()
1453 printk(KERN_ERR "alg: cprng: Failed to allocate seed space " test_cprng()
1469 printk(KERN_ERR "alg: cprng: Failed to reset rng " test_cprng()
1478 printk(KERN_ERR "alg: cprng: Failed to obtain " test_cprng()
1489 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", test_cprng()
1510 printk(KERN_ERR "alg: aead: Failed to load transform for %s: " alg_test_aead()
1539 printk(KERN_ERR "alg: cipher: Failed to load transform for " alg_test_cipher()
1568 printk(KERN_ERR "alg: skcipher: Failed to load transform for " alg_test_skcipher()
1597 printk(KERN_ERR "alg: comp: Failed to load transform for %s: " alg_test_comp()
1619 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n", alg_test_pcomp()
1641 printk(KERN_ERR "alg: hash: Failed to load transform for %s: " alg_test_hash()
1669 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " alg_test_crc32c()
1685 printk(KERN_ERR "alg: crc32c: Operation failed for " alg_test_crc32c()
1691 printk(KERN_ERR "alg: crc32c: Test failed for %s: " alg_test_crc32c()
1711 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " alg_test_cprng()
1738 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " drbg_cavs_test()
1749 printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); drbg_cavs_test()
1763 printk(KERN_ERR "alg: drbg: could not obtain random data for " drbg_cavs_test()
1778 printk(KERN_ERR "alg: drbg: could not obtain random data for " drbg_cavs_test()
1807 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", alg_test_drbg()
1826 .alg = "__cbc-cast5-avx",
1829 .alg = "__cbc-cast6-avx",
1832 .alg = "__cbc-serpent-avx",
1835 .alg = "__cbc-serpent-avx2",
1838 .alg = "__cbc-serpent-sse2",
1841 .alg = "__cbc-twofish-avx",
1844 .alg = "__driver-cbc-aes-aesni",
1848 .alg = "__driver-cbc-camellia-aesni",
1851 .alg = "__driver-cbc-camellia-aesni-avx2",
1854 .alg = "__driver-cbc-cast5-avx",
1857 .alg = "__driver-cbc-cast6-avx",
1860 .alg = "__driver-cbc-serpent-avx",
1863 .alg = "__driver-cbc-serpent-avx2",
1866 .alg = "__driver-cbc-serpent-sse2",
1869 .alg = "__driver-cbc-twofish-avx",
1872 .alg = "__driver-ecb-aes-aesni",
1876 .alg = "__driver-ecb-camellia-aesni",
1879 .alg = "__driver-ecb-camellia-aesni-avx2",
1882 .alg = "__driver-ecb-cast5-avx",
1885 .alg = "__driver-ecb-cast6-avx",
1888 .alg = "__driver-ecb-serpent-avx",
1891 .alg = "__driver-ecb-serpent-avx2",
1894 .alg = "__driver-ecb-serpent-sse2",
1897 .alg = "__driver-ecb-twofish-avx",
1900 .alg = "__ghash-pclmulqdqni",
1904 .alg = "ansi_cprng",
1914 .alg = "authenc(hmac(md5),ecb(cipher_null))",
1930 .alg = "authenc(hmac(sha1),cbc(aes))",
1944 .alg = "authenc(hmac(sha1),cbc(des))",
1958 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
1972 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
1992 .alg = "authenc(hmac(sha224),cbc(des))",
2006 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
2020 .alg = "authenc(hmac(sha256),cbc(aes))",
2034 .alg = "authenc(hmac(sha256),cbc(des))",
2048 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
2062 .alg = "authenc(hmac(sha384),cbc(des))",
2076 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
2090 .alg = "authenc(hmac(sha512),cbc(aes))",
2104 .alg = "authenc(hmac(sha512),cbc(des))",
2118 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
2132 .alg = "cbc(aes)",
2148 .alg = "cbc(anubis)",
2163 .alg = "cbc(blowfish)",
2178 .alg = "cbc(camellia)",
2193 .alg = "cbc(cast5)",
2208 .alg = "cbc(cast6)",
2223 .alg = "cbc(des)",
2238 .alg = "cbc(des3_ede)",
2254 .alg = "cbc(serpent)",
2269 .alg = "cbc(twofish)",
2284 .alg = "ccm(aes)",
2300 .alg = "cmac(aes)",
2309 .alg = "cmac(des3_ede)",
2318 .alg = "compress_null",
2321 .alg = "crc32c",
2331 .alg = "crct10dif",
2341 .alg = "cryptd(__driver-cbc-aes-aesni)",
2345 .alg = "cryptd(__driver-cbc-camellia-aesni)",
2348 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2351 .alg = "cryptd(__driver-cbc-serpent-avx2)",
2354 .alg = "cryptd(__driver-ecb-aes-aesni)",
2358 .alg = "cryptd(__driver-ecb-camellia-aesni)",
2361 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2364 .alg = "cryptd(__driver-ecb-cast5-avx)",
2367 .alg = "cryptd(__driver-ecb-cast6-avx)",
2370 .alg = "cryptd(__driver-ecb-serpent-avx)",
2373 .alg = "cryptd(__driver-ecb-serpent-avx2)",
2376 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2379 .alg = "cryptd(__driver-ecb-twofish-avx)",
2382 .alg = "cryptd(__driver-gcm-aes-aesni)",
2386 .alg = "cryptd(__ghash-pclmulqdqni)",
2390 .alg = "ctr(aes)",
2406 .alg = "ctr(blowfish)",
2421 .alg = "ctr(camellia)",
2436 .alg = "ctr(cast5)",
2451 .alg = "ctr(cast6)",
2466 .alg = "ctr(des)",
2481 .alg = "ctr(des3_ede)",
2496 .alg = "ctr(serpent)",
2511 .alg = "ctr(twofish)",
2526 .alg = "cts(cbc(aes))",
2541 .alg = "deflate",
2557 .alg = "digest_null",
2560 .alg = "drbg_nopr_ctr_aes128",
2570 .alg = "drbg_nopr_ctr_aes192",
2580 .alg = "drbg_nopr_ctr_aes256",
2594 .alg = "drbg_nopr_hmac_sha1",
2598 .alg = "drbg_nopr_hmac_sha256",
2610 .alg = "drbg_nopr_hmac_sha384",
2614 .alg = "drbg_nopr_hmac_sha512",
2618 .alg = "drbg_nopr_sha1",
2622 .alg = "drbg_nopr_sha256",
2633 .alg = "drbg_nopr_sha384",
2637 .alg = "drbg_nopr_sha512",
2641 .alg = "drbg_pr_ctr_aes128",
2652 .alg = "drbg_pr_ctr_aes192",
2656 .alg = "drbg_pr_ctr_aes256",
2660 .alg = "drbg_pr_hmac_sha1",
2664 .alg = "drbg_pr_hmac_sha256",
2675 .alg = "drbg_pr_hmac_sha384",
2679 .alg = "drbg_pr_hmac_sha512",
2683 .alg = "drbg_pr_sha1",
2687 .alg = "drbg_pr_sha256",
2698 .alg = "drbg_pr_sha384",
2702 .alg = "drbg_pr_sha512",
2706 .alg = "ecb(__aes-aesni)",
2710 .alg = "ecb(aes)",
2726 .alg = "ecb(anubis)",
2741 .alg = "ecb(arc4)",
2756 .alg = "ecb(blowfish)",
2771 .alg = "ecb(camellia)",
2786 .alg = "ecb(cast5)",
2801 .alg = "ecb(cast6)",
2816 .alg = "ecb(cipher_null)",
2819 .alg = "ecb(des)",
2835 .alg = "ecb(des3_ede)",
2851 .alg = "ecb(fcrypt)",
2866 .alg = "ecb(khazad)",
2881 .alg = "ecb(seed)",
2896 .alg = "ecb(serpent)",
2911 .alg = "ecb(tea)",
2926 .alg = "ecb(tnepres)",
2941 .alg = "ecb(twofish)",
2956 .alg = "ecb(xeta)",
2971 .alg = "ecb(xtea)",
2986 .alg = "gcm(aes)",
3002 .alg = "ghash",
3012 .alg = "hmac(crc32)",
3021 .alg = "hmac(md5)",
3030 .alg = "hmac(rmd128)",
3039 .alg = "hmac(rmd160)",
3048 .alg = "hmac(sha1)",
3058 .alg = "hmac(sha224)",
3068 .alg = "hmac(sha256)",
3078 .alg = "hmac(sha384)",
3088 .alg = "hmac(sha512)",
3098 .alg = "lrw(aes)",
3113 .alg = "lrw(camellia)",
3128 .alg = "lrw(cast6)",
3143 .alg = "lrw(serpent)",
3158 .alg = "lrw(twofish)",
3173 .alg = "lz4",
3189 .alg = "lz4hc",
3205 .alg = "lzo",
3221 .alg = "md4",
3230 .alg = "md5",
3239 .alg = "michael_mic",
3248 .alg = "ofb(aes)",
3264 .alg = "pcbc(fcrypt)",
3279 .alg = "rfc3686(ctr(aes))",
3295 .alg = "rfc4106(gcm(aes))",
3311 .alg = "rfc4309(ccm(aes))",
3327 .alg = "rfc4543(gcm(aes))",
3342 .alg = "rmd128",
3351 .alg = "rmd160",
3360 .alg = "rmd256",
3369 .alg = "rmd320",
3378 .alg = "salsa20",
3389 .alg = "sha1",
3399 .alg = "sha224",
3409 .alg = "sha256",
3419 .alg = "sha384",
3429 .alg = "sha512",
3439 .alg = "tgr128",
3448 .alg = "tgr160",
3457 .alg = "tgr192",
3466 .alg = "vmac(aes)",
3475 .alg = "wp256",
3484 .alg = "wp384",
3493 .alg = "wp512",
3502 .alg = "xcbc(aes)",
3511 .alg = "xts(aes)",
3527 .alg = "xts(camellia)",
3542 .alg = "xts(cast6)",
3557 .alg = "xts(serpent)",
3572 .alg = "xts(twofish)",
3587 .alg = "zlib",
3618 int diff = strcmp(alg_test_descs[i - 1].alg, alg_test_descs_check_order()
3619 alg_test_descs[i].alg); alg_test_descs_check_order()
3623 alg_test_descs[i - 1].alg, alg_test_descs_check_order()
3624 alg_test_descs[i].alg); alg_test_descs_check_order()
3629 alg_test_descs[i].alg); alg_test_descs_check_order()
3634 static int alg_find_test(const char *alg) alg_find_test() argument
3641 int diff = strcmp(alg_test_descs[i].alg, alg); alg_find_test()
3659 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) alg_test() argument
3670 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= alg_test()
3685 i = alg_find_test(alg); alg_test()
3704 panic("%s: %s alg self test failed in fips mode!\n", driver, alg); alg_test()
3707 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg); alg_test()
3712 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); alg_test()
H A Decb.c121 struct crypto_alg *alg; crypto_ecb_alloc() local
128 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, crypto_ecb_alloc()
130 if (IS_ERR(alg)) crypto_ecb_alloc()
131 return ERR_CAST(alg); crypto_ecb_alloc()
133 inst = crypto_alloc_instance("ecb", alg); crypto_ecb_alloc()
137 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_ecb_alloc()
138 inst->alg.cra_priority = alg->cra_priority; crypto_ecb_alloc()
139 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_ecb_alloc()
140 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_ecb_alloc()
141 inst->alg.cra_type = &crypto_blkcipher_type; crypto_ecb_alloc()
143 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_ecb_alloc()
144 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_ecb_alloc()
146 inst->alg.cra_ctxsize = sizeof(struct crypto_ecb_ctx); crypto_ecb_alloc()
148 inst->alg.cra_init = crypto_ecb_init_tfm; crypto_ecb_alloc()
149 inst->alg.cra_exit = crypto_ecb_exit_tfm; crypto_ecb_alloc()
151 inst->alg.cra_blkcipher.setkey = crypto_ecb_setkey; crypto_ecb_alloc()
152 inst->alg.cra_blkcipher.encrypt = crypto_ecb_encrypt; crypto_ecb_alloc()
153 inst->alg.cra_blkcipher.decrypt = crypto_ecb_decrypt; crypto_ecb_alloc()
156 crypto_mod_put(alg); crypto_ecb_alloc()
H A Dcryptd.c298 static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head, cryptd_alloc_instance() argument
312 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, cryptd_alloc_instance()
313 "cryptd(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) cryptd_alloc_instance()
316 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); cryptd_alloc_instance()
318 inst->alg.cra_priority = alg->cra_priority + 50; cryptd_alloc_instance()
319 inst->alg.cra_blocksize = alg->cra_blocksize; cryptd_alloc_instance()
320 inst->alg.cra_alignmask = alg->cra_alignmask; cryptd_alloc_instance()
337 struct crypto_alg *alg; cryptd_create_blkcipher() local
344 alg = crypto_get_attr_alg(tb, type, mask); cryptd_create_blkcipher()
345 if (IS_ERR(alg)) cryptd_create_blkcipher()
346 return PTR_ERR(alg); cryptd_create_blkcipher()
348 inst = cryptd_alloc_instance(alg, 0, sizeof(*ctx)); cryptd_create_blkcipher()
356 err = crypto_init_spawn(&ctx->spawn, alg, inst, cryptd_create_blkcipher()
362 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) cryptd_create_blkcipher()
364 inst->alg.cra_flags = type; cryptd_create_blkcipher()
365 inst->alg.cra_type = &crypto_ablkcipher_type; cryptd_create_blkcipher()
367 inst->alg.cra_ablkcipher.ivsize = alg->cra_blkcipher.ivsize; cryptd_create_blkcipher()
368 inst->alg.cra_ablkcipher.min_keysize = alg->cra_blkcipher.min_keysize; cryptd_create_blkcipher()
369 inst->alg.cra_ablkcipher.max_keysize = alg->cra_blkcipher.max_keysize; cryptd_create_blkcipher()
371 inst->alg.cra_ablkcipher.geniv = alg->cra_blkcipher.geniv; cryptd_create_blkcipher()
373 inst->alg.cra_ctxsize = sizeof(struct cryptd_blkcipher_ctx); cryptd_create_blkcipher()
375 inst->alg.cra_init = cryptd_blkcipher_init_tfm; cryptd_create_blkcipher()
376 inst->alg.cra_exit = cryptd_blkcipher_exit_tfm; cryptd_create_blkcipher()
378 inst->alg.cra_ablkcipher.setkey = cryptd_blkcipher_setkey; cryptd_create_blkcipher()
379 inst->alg.cra_ablkcipher.encrypt = cryptd_blkcipher_encrypt_enqueue; cryptd_create_blkcipher()
380 inst->alg.cra_ablkcipher.decrypt = cryptd_blkcipher_decrypt_enqueue; cryptd_create_blkcipher()
390 crypto_mod_put(alg); cryptd_create_blkcipher()
599 struct crypto_alg *alg; cryptd_create_hash() local
610 alg = &salg->base; cryptd_create_hash()
611 inst = cryptd_alloc_instance(alg, ahash_instance_headroom(), cryptd_create_hash()
626 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) cryptd_create_hash()
628 inst->alg.halg.base.cra_flags = type; cryptd_create_hash()
630 inst->alg.halg.digestsize = salg->digestsize; cryptd_create_hash()
631 inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx); cryptd_create_hash()
633 inst->alg.halg.base.cra_init = cryptd_hash_init_tfm; cryptd_create_hash()
634 inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm; cryptd_create_hash()
636 inst->alg.init = cryptd_hash_init_enqueue; cryptd_create_hash()
637 inst->alg.update = cryptd_hash_update_enqueue; cryptd_create_hash()
638 inst->alg.final = cryptd_hash_final_enqueue; cryptd_create_hash()
639 inst->alg.finup = cryptd_hash_finup_enqueue; cryptd_create_hash()
640 inst->alg.export = cryptd_hash_export; cryptd_create_hash()
641 inst->alg.import = cryptd_hash_import; cryptd_create_hash()
642 inst->alg.setkey = cryptd_hash_setkey; cryptd_create_hash()
643 inst->alg.digest = cryptd_hash_digest_enqueue; cryptd_create_hash()
653 crypto_mod_put(alg); cryptd_create_hash()
748 struct crypto_alg *alg; cryptd_create_aead() local
755 alg = crypto_get_attr_alg(tb, type, mask); cryptd_create_aead()
756 if (IS_ERR(alg)) cryptd_create_aead()
757 return PTR_ERR(alg); cryptd_create_aead()
759 inst = cryptd_alloc_instance(alg, 0, sizeof(*ctx)); cryptd_create_aead()
767 err = crypto_init_spawn(&ctx->aead_spawn.base, alg, inst, cryptd_create_aead()
773 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) cryptd_create_aead()
775 inst->alg.cra_flags = type; cryptd_create_aead()
776 inst->alg.cra_type = alg->cra_type; cryptd_create_aead()
777 inst->alg.cra_ctxsize = sizeof(struct cryptd_aead_ctx); cryptd_create_aead()
778 inst->alg.cra_init = cryptd_aead_init_tfm; cryptd_create_aead()
779 inst->alg.cra_exit = cryptd_aead_exit_tfm; cryptd_create_aead()
780 inst->alg.cra_aead.setkey = alg->cra_aead.setkey; cryptd_create_aead()
781 inst->alg.cra_aead.setauthsize = alg->cra_aead.setauthsize; cryptd_create_aead()
782 inst->alg.cra_aead.geniv = alg->cra_aead.geniv; cryptd_create_aead()
783 inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; cryptd_create_aead()
784 inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; cryptd_create_aead()
785 inst->alg.cra_aead.encrypt = cryptd_aead_encrypt_enqueue; cryptd_create_aead()
786 inst->alg.cra_aead.decrypt = cryptd_aead_decrypt_enqueue; cryptd_create_aead()
787 inst->alg.cra_aead.givencrypt = alg->cra_aead.givencrypt; cryptd_create_aead()
788 inst->alg.cra_aead.givdecrypt = alg->cra_aead.givdecrypt; cryptd_create_aead()
797 crypto_mod_put(alg); cryptd_create_aead()
829 switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) { cryptd_free()
H A Dlrw.c329 struct crypto_alg *alg; alloc() local
336 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, alloc()
338 if (IS_ERR(alg)) alloc()
339 return ERR_CAST(alg); alloc()
341 inst = crypto_alloc_instance("lrw", alg); alloc()
345 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; alloc()
346 inst->alg.cra_priority = alg->cra_priority; alloc()
347 inst->alg.cra_blocksize = alg->cra_blocksize; alloc()
349 if (alg->cra_alignmask < 7) inst->alg.cra_alignmask = 7; alloc()
350 else inst->alg.cra_alignmask = alg->cra_alignmask; alloc()
351 inst->alg.cra_type = &crypto_blkcipher_type; alloc()
353 if (!(alg->cra_blocksize % 4)) alloc()
354 inst->alg.cra_alignmask |= 3; alloc()
355 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; alloc()
356 inst->alg.cra_blkcipher.min_keysize = alloc()
357 alg->cra_cipher.cia_min_keysize + alg->cra_blocksize; alloc()
358 inst->alg.cra_blkcipher.max_keysize = alloc()
359 alg->cra_cipher.cia_max_keysize + alg->cra_blocksize; alloc()
361 inst->alg.cra_ctxsize = sizeof(struct priv); alloc()
363 inst->alg.cra_init = init_tfm; alloc()
364 inst->alg.cra_exit = exit_tfm; alloc()
366 inst->alg.cra_blkcipher.setkey = setkey; alloc()
367 inst->alg.cra_blkcipher.encrypt = encrypt; alloc()
368 inst->alg.cra_blkcipher.decrypt = decrypt; alloc()
371 crypto_mod_put(alg); alloc()
H A Dpcompress.c41 static unsigned int crypto_pcomp_extsize(struct crypto_alg *alg) crypto_pcomp_extsize() argument
43 return alg->cra_ctxsize; crypto_pcomp_extsize()
52 static int crypto_pcomp_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_pcomp_report() argument
66 static int crypto_pcomp_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_pcomp_report() argument
72 static void crypto_pcomp_show(struct seq_file *m, struct crypto_alg *alg)
74 static void crypto_pcomp_show(struct seq_file *m, struct crypto_alg *alg) crypto_pcomp_show() argument
100 int crypto_register_pcomp(struct pcomp_alg *alg) crypto_register_pcomp() argument
102 struct crypto_alg *base = &alg->base; crypto_register_pcomp()
112 int crypto_unregister_pcomp(struct pcomp_alg *alg) crypto_unregister_pcomp() argument
114 return crypto_unregister_alg(&alg->base); crypto_unregister_pcomp()
H A Dblkcipher.c421 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; async_encrypt() local
429 return alg->encrypt(&desc, req->dst, req->src, req->nbytes); async_encrypt()
435 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; async_decrypt() local
442 return alg->decrypt(&desc, req->dst, req->src, req->nbytes); async_decrypt()
445 static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type, crypto_blkcipher_ctxsize() argument
448 struct blkcipher_alg *cipher = &alg->cra_blkcipher; crypto_blkcipher_ctxsize()
449 unsigned int len = alg->cra_ctxsize; crypto_blkcipher_ctxsize()
453 len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1); crypto_blkcipher_ctxsize()
463 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; crypto_init_blkcipher_ops_async() local
468 if (!alg->ivsize) { crypto_init_blkcipher_ops_async()
473 crt->ivsize = alg->ivsize; crypto_init_blkcipher_ops_async()
481 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; crypto_init_blkcipher_ops_sync() local
486 crt->encrypt = alg->encrypt; crypto_init_blkcipher_ops_sync()
487 crt->decrypt = alg->decrypt; crypto_init_blkcipher_ops_sync()
499 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; crypto_init_blkcipher_ops() local
501 if (alg->ivsize > PAGE_SIZE / 8) crypto_init_blkcipher_ops()
511 static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_blkcipher_report() argument
516 strncpy(rblkcipher.geniv, alg->cra_blkcipher.geniv ?: "<default>", crypto_blkcipher_report()
519 rblkcipher.blocksize = alg->cra_blocksize; crypto_blkcipher_report()
520 rblkcipher.min_keysize = alg->cra_blkcipher.min_keysize; crypto_blkcipher_report()
521 rblkcipher.max_keysize = alg->cra_blkcipher.max_keysize; crypto_blkcipher_report()
522 rblkcipher.ivsize = alg->cra_blkcipher.ivsize; crypto_blkcipher_report()
533 static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_blkcipher_report() argument
539 static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg)
541 static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg) crypto_blkcipher_show() argument
544 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_blkcipher_show()
545 seq_printf(m, "min keysize : %u\n", alg->cra_blkcipher.min_keysize); crypto_blkcipher_show()
546 seq_printf(m, "max keysize : %u\n", alg->cra_blkcipher.max_keysize); crypto_blkcipher_show()
547 seq_printf(m, "ivsize : %u\n", alg->cra_blkcipher.ivsize); crypto_blkcipher_show()
548 seq_printf(m, "geniv : %s\n", alg->cra_blkcipher.geniv ?: crypto_blkcipher_show()
565 struct crypto_alg *alg; crypto_grab_nivcipher() local
571 alg = crypto_alg_mod_lookup(name, type, mask); crypto_grab_nivcipher()
572 if (IS_ERR(alg)) crypto_grab_nivcipher()
573 return PTR_ERR(alg); crypto_grab_nivcipher()
575 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_nivcipher()
576 crypto_mod_put(alg); crypto_grab_nivcipher()
600 struct crypto_alg *alg; skcipher_geniv_alloc() local
629 alg = crypto_skcipher_spawn_alg(spawn); skcipher_geniv_alloc()
631 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == skcipher_geniv_alloc()
633 balg.ivsize = alg->cra_blkcipher.ivsize; skcipher_geniv_alloc()
634 balg.min_keysize = alg->cra_blkcipher.min_keysize; skcipher_geniv_alloc()
635 balg.max_keysize = alg->cra_blkcipher.max_keysize; skcipher_geniv_alloc()
641 balg.geniv = alg->cra_blkcipher.geniv; skcipher_geniv_alloc()
643 balg.ivsize = alg->cra_ablkcipher.ivsize; skcipher_geniv_alloc()
644 balg.min_keysize = alg->cra_ablkcipher.min_keysize; skcipher_geniv_alloc()
645 balg.max_keysize = alg->cra_ablkcipher.max_keysize; skcipher_geniv_alloc()
647 balg.setkey = alg->cra_ablkcipher.setkey; skcipher_geniv_alloc()
648 balg.encrypt = alg->cra_ablkcipher.encrypt; skcipher_geniv_alloc()
649 balg.decrypt = alg->cra_ablkcipher.decrypt; skcipher_geniv_alloc()
651 balg.geniv = alg->cra_ablkcipher.geniv; skcipher_geniv_alloc()
665 balg.geniv = crypto_default_geniv(alg); skcipher_geniv_alloc()
670 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); skcipher_geniv_alloc()
671 memcpy(inst->alg.cra_driver_name, alg->cra_driver_name, skcipher_geniv_alloc()
675 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, skcipher_geniv_alloc()
676 "%s(%s)", tmpl->name, alg->cra_name) >= skcipher_geniv_alloc()
679 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, skcipher_geniv_alloc()
680 "%s(%s)", tmpl->name, alg->cra_driver_name) >= skcipher_geniv_alloc()
685 inst->alg.cra_flags = CRYPTO_ALG_TYPE_GIVCIPHER | CRYPTO_ALG_GENIV; skcipher_geniv_alloc()
686 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; skcipher_geniv_alloc()
687 inst->alg.cra_priority = alg->cra_priority; skcipher_geniv_alloc()
688 inst->alg.cra_blocksize = alg->cra_blocksize; skcipher_geniv_alloc()
689 inst->alg.cra_alignmask = alg->cra_alignmask; skcipher_geniv_alloc()
690 inst->alg.cra_type = &crypto_givcipher_type; skcipher_geniv_alloc()
692 inst->alg.cra_ablkcipher.ivsize = balg.ivsize; skcipher_geniv_alloc()
693 inst->alg.cra_ablkcipher.min_keysize = balg.min_keysize; skcipher_geniv_alloc()
694 inst->alg.cra_ablkcipher.max_keysize = balg.max_keysize; skcipher_geniv_alloc()
695 inst->alg.cra_ablkcipher.geniv = balg.geniv; skcipher_geniv_alloc()
697 inst->alg.cra_ablkcipher.setkey = balg.setkey; skcipher_geniv_alloc()
698 inst->alg.cra_ablkcipher.encrypt = balg.encrypt; skcipher_geniv_alloc()
699 inst->alg.cra_ablkcipher.decrypt = balg.decrypt; skcipher_geniv_alloc()
H A Dcbc.c217 struct crypto_alg *alg; crypto_cbc_alloc() local
224 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, crypto_cbc_alloc()
226 if (IS_ERR(alg)) crypto_cbc_alloc()
227 return ERR_CAST(alg); crypto_cbc_alloc()
230 if (!is_power_of_2(alg->cra_blocksize)) crypto_cbc_alloc()
233 inst = crypto_alloc_instance("cbc", alg); crypto_cbc_alloc()
237 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_cbc_alloc()
238 inst->alg.cra_priority = alg->cra_priority; crypto_cbc_alloc()
239 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_cbc_alloc()
240 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_cbc_alloc()
241 inst->alg.cra_type = &crypto_blkcipher_type; crypto_cbc_alloc()
244 inst->alg.cra_alignmask |= __alignof__(u32) - 1; crypto_cbc_alloc()
246 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_cbc_alloc()
247 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_cbc_alloc()
248 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_cbc_alloc()
250 inst->alg.cra_ctxsize = sizeof(struct crypto_cbc_ctx); crypto_cbc_alloc()
252 inst->alg.cra_init = crypto_cbc_init_tfm; crypto_cbc_alloc()
253 inst->alg.cra_exit = crypto_cbc_exit_tfm; crypto_cbc_alloc()
255 inst->alg.cra_blkcipher.setkey = crypto_cbc_setkey; crypto_cbc_alloc()
256 inst->alg.cra_blkcipher.encrypt = crypto_cbc_encrypt; crypto_cbc_alloc()
257 inst->alg.cra_blkcipher.decrypt = crypto_cbc_decrypt; crypto_cbc_alloc()
260 crypto_mod_put(alg); crypto_cbc_alloc()
H A Dxts.c290 struct crypto_alg *alg; alloc() local
297 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, alloc()
299 if (IS_ERR(alg)) alloc()
300 return ERR_CAST(alg); alloc()
302 inst = crypto_alloc_instance("xts", alg); alloc()
306 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; alloc()
307 inst->alg.cra_priority = alg->cra_priority; alloc()
308 inst->alg.cra_blocksize = alg->cra_blocksize; alloc()
310 if (alg->cra_alignmask < 7) alloc()
311 inst->alg.cra_alignmask = 7; alloc()
313 inst->alg.cra_alignmask = alg->cra_alignmask; alloc()
315 inst->alg.cra_type = &crypto_blkcipher_type; alloc()
317 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; alloc()
318 inst->alg.cra_blkcipher.min_keysize = alloc()
319 2 * alg->cra_cipher.cia_min_keysize; alloc()
320 inst->alg.cra_blkcipher.max_keysize = alloc()
321 2 * alg->cra_cipher.cia_max_keysize; alloc()
323 inst->alg.cra_ctxsize = sizeof(struct priv); alloc()
325 inst->alg.cra_init = init_tfm; alloc()
326 inst->alg.cra_exit = exit_tfm; alloc()
328 inst->alg.cra_blkcipher.setkey = setkey; alloc()
329 inst->alg.cra_blkcipher.encrypt = encrypt; alloc()
330 inst->alg.cra_blkcipher.decrypt = decrypt; alloc()
333 crypto_mod_put(alg); alloc()
H A Dpcbc.c227 struct crypto_alg *alg; crypto_pcbc_alloc() local
234 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, crypto_pcbc_alloc()
236 if (IS_ERR(alg)) crypto_pcbc_alloc()
237 return ERR_CAST(alg); crypto_pcbc_alloc()
239 inst = crypto_alloc_instance("pcbc", alg); crypto_pcbc_alloc()
243 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_pcbc_alloc()
244 inst->alg.cra_priority = alg->cra_priority; crypto_pcbc_alloc()
245 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_pcbc_alloc()
246 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_pcbc_alloc()
247 inst->alg.cra_type = &crypto_blkcipher_type; crypto_pcbc_alloc()
250 inst->alg.cra_alignmask |= __alignof__(u32) - 1; crypto_pcbc_alloc()
252 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_pcbc_alloc()
253 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_pcbc_alloc()
254 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_pcbc_alloc()
256 inst->alg.cra_ctxsize = sizeof(struct crypto_pcbc_ctx); crypto_pcbc_alloc()
258 inst->alg.cra_init = crypto_pcbc_init_tfm; crypto_pcbc_alloc()
259 inst->alg.cra_exit = crypto_pcbc_exit_tfm; crypto_pcbc_alloc()
261 inst->alg.cra_blkcipher.setkey = crypto_pcbc_setkey; crypto_pcbc_alloc()
262 inst->alg.cra_blkcipher.encrypt = crypto_pcbc_encrypt; crypto_pcbc_alloc()
263 inst->alg.cra_blkcipher.decrypt = crypto_pcbc_decrypt; crypto_pcbc_alloc()
266 crypto_mod_put(alg); crypto_pcbc_alloc()
H A Dcmac.c228 struct crypto_alg *alg; cmac_create() local
236 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, cmac_create()
238 if (IS_ERR(alg)) cmac_create()
239 return PTR_ERR(alg); cmac_create()
241 switch (alg->cra_blocksize) { cmac_create()
249 inst = shash_alloc_instance("cmac", alg); cmac_create()
254 err = crypto_init_spawn(shash_instance_ctx(inst), alg, cmac_create()
260 alignmask = alg->cra_alignmask | (sizeof(long) - 1); cmac_create()
261 inst->alg.base.cra_alignmask = alignmask; cmac_create()
262 inst->alg.base.cra_priority = alg->cra_priority; cmac_create()
263 inst->alg.base.cra_blocksize = alg->cra_blocksize; cmac_create()
265 inst->alg.digestsize = alg->cra_blocksize; cmac_create()
266 inst->alg.descsize = cmac_create()
269 + alg->cra_blocksize * 2; cmac_create()
271 inst->alg.base.cra_ctxsize = cmac_create()
273 + alg->cra_blocksize * 2; cmac_create()
275 inst->alg.base.cra_init = cmac_init_tfm; cmac_create()
276 inst->alg.base.cra_exit = cmac_exit_tfm; cmac_create()
278 inst->alg.init = crypto_cmac_digest_init; cmac_create()
279 inst->alg.update = crypto_cmac_digest_update; cmac_create()
280 inst->alg.final = crypto_cmac_digest_final; cmac_create()
281 inst->alg.setkey = crypto_cmac_digest_setkey; cmac_create()
290 crypto_mod_put(alg); cmac_create()
H A Dxcbc.c202 struct crypto_alg *alg; xcbc_create() local
210 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, xcbc_create()
212 if (IS_ERR(alg)) xcbc_create()
213 return PTR_ERR(alg); xcbc_create()
215 switch(alg->cra_blocksize) { xcbc_create()
222 inst = shash_alloc_instance("xcbc", alg); xcbc_create()
227 err = crypto_init_spawn(shash_instance_ctx(inst), alg, xcbc_create()
233 alignmask = alg->cra_alignmask | 3; xcbc_create()
234 inst->alg.base.cra_alignmask = alignmask; xcbc_create()
235 inst->alg.base.cra_priority = alg->cra_priority; xcbc_create()
236 inst->alg.base.cra_blocksize = alg->cra_blocksize; xcbc_create()
238 inst->alg.digestsize = alg->cra_blocksize; xcbc_create()
239 inst->alg.descsize = ALIGN(sizeof(struct xcbc_desc_ctx), xcbc_create()
243 alg->cra_blocksize * 2; xcbc_create()
245 inst->alg.base.cra_ctxsize = ALIGN(sizeof(struct xcbc_tfm_ctx), xcbc_create()
247 alg->cra_blocksize * 2; xcbc_create()
248 inst->alg.base.cra_init = xcbc_init_tfm; xcbc_create()
249 inst->alg.base.cra_exit = xcbc_exit_tfm; xcbc_create()
251 inst->alg.init = crypto_xcbc_digest_init; xcbc_create()
252 inst->alg.update = crypto_xcbc_digest_update; xcbc_create()
253 inst->alg.final = crypto_xcbc_digest_final; xcbc_create()
254 inst->alg.setkey = crypto_xcbc_digest_setkey; xcbc_create()
263 crypto_mod_put(alg); xcbc_create()
H A Dhmac.c184 struct crypto_alg *alg; hmac_create() local
201 alg = &salg->base; hmac_create()
202 if (ds > alg->cra_blocksize || hmac_create()
203 ss < alg->cra_blocksize) hmac_create()
206 inst = shash_alloc_instance("hmac", alg); hmac_create()
216 inst->alg.base.cra_priority = alg->cra_priority; hmac_create()
217 inst->alg.base.cra_blocksize = alg->cra_blocksize; hmac_create()
218 inst->alg.base.cra_alignmask = alg->cra_alignmask; hmac_create()
220 ss = ALIGN(ss, alg->cra_alignmask + 1); hmac_create()
221 inst->alg.digestsize = ds; hmac_create()
222 inst->alg.statesize = ss; hmac_create()
224 inst->alg.base.cra_ctxsize = sizeof(struct hmac_ctx) + hmac_create()
227 inst->alg.base.cra_init = hmac_init_tfm; hmac_create()
228 inst->alg.base.cra_exit = hmac_exit_tfm; hmac_create()
230 inst->alg.init = hmac_init; hmac_create()
231 inst->alg.update = hmac_update; hmac_create()
232 inst->alg.final = hmac_final; hmac_create()
233 inst->alg.finup = hmac_finup; hmac_create()
234 inst->alg.export = hmac_export; hmac_create()
235 inst->alg.import = hmac_import; hmac_create()
236 inst->alg.setkey = hmac_setkey; hmac_create()
245 crypto_mod_put(alg); hmac_create()
H A Dalgboss.c41 } alg; member in union:cryptomgr_param::__anon3244
58 char alg[CRYPTO_MAX_ALG_NAME]; member in struct:crypto_test_param
90 crypto_alg_put(&param->larval->alg); cryptomgr_probe()
99 const char *name = larval->alg.cra_name; cryptomgr_schedule_probe()
151 param->attrs[i].alg.attr.rta_len = cryptomgr_schedule_probe()
152 sizeof(param->attrs[i].alg); cryptomgr_schedule_probe()
153 param->attrs[i].alg.attr.rta_type = CRYPTOA_ALG; cryptomgr_schedule_probe()
154 memcpy(param->attrs[i].alg.data.name, name, len); cryptomgr_schedule_probe()
183 param->type.data.type = larval->alg.cra_flags & ~CRYPTO_ALG_TESTED; cryptomgr_schedule_probe()
187 param->otype = larval->alg.cra_flags; cryptomgr_schedule_probe()
190 crypto_alg_get(&larval->alg); cryptomgr_schedule_probe()
202 crypto_alg_put(&larval->alg); cryptomgr_schedule_probe()
224 err = alg_test(param->driver, param->alg, type, CRYPTO_ALG_TESTED); cryptomgr_test()
233 static int cryptomgr_schedule_test(struct crypto_alg *alg) cryptomgr_schedule_test() argument
246 memcpy(param->driver, alg->cra_driver_name, sizeof(param->driver)); cryptomgr_schedule_test()
247 memcpy(param->alg, alg->cra_name, sizeof(param->alg)); cryptomgr_schedule_test()
248 type = alg->cra_flags; cryptomgr_schedule_test()
253 ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == cryptomgr_schedule_test()
254 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : cryptomgr_schedule_test()
255 alg->cra_ablkcipher.ivsize)) || cryptomgr_schedule_test()
257 alg->cra_type == &crypto_nivaead_type && alg->cra_aead.ivsize)) cryptomgr_schedule_test()
H A Dahash.c452 struct ahash_alg *alg = crypto_ahash_alg(hash); crypto_ahash_init_tfm() local
462 hash->init = alg->init; crypto_ahash_init_tfm()
463 hash->update = alg->update; crypto_ahash_init_tfm()
464 hash->final = alg->final; crypto_ahash_init_tfm()
465 hash->finup = alg->finup ?: ahash_def_finup; crypto_ahash_init_tfm()
466 hash->digest = alg->digest; crypto_ahash_init_tfm()
468 if (alg->setkey) { crypto_ahash_init_tfm()
469 hash->setkey = alg->setkey; crypto_ahash_init_tfm()
472 if (alg->export) crypto_ahash_init_tfm()
473 hash->export = alg->export; crypto_ahash_init_tfm()
474 if (alg->import) crypto_ahash_init_tfm()
475 hash->import = alg->import; crypto_ahash_init_tfm()
480 static unsigned int crypto_ahash_extsize(struct crypto_alg *alg) crypto_ahash_extsize() argument
482 if (alg->cra_type == &crypto_ahash_type) crypto_ahash_extsize()
483 return alg->cra_ctxsize; crypto_ahash_extsize()
489 static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ahash_report() argument
495 rhash.blocksize = alg->cra_blocksize; crypto_ahash_report()
496 rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize; crypto_ahash_report()
507 static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ahash_report() argument
513 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
515 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg) crypto_ahash_show() argument
518 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_ahash_show()
520 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_ahash_show()
522 __crypto_hash_alg_common(alg)->digestsize); crypto_ahash_show()
546 static int ahash_prepare_alg(struct ahash_alg *alg) ahash_prepare_alg() argument
548 struct crypto_alg *base = &alg->halg.base; ahash_prepare_alg()
550 if (alg->halg.digestsize > PAGE_SIZE / 8 || ahash_prepare_alg()
551 alg->halg.statesize > PAGE_SIZE / 8 || ahash_prepare_alg()
552 alg->halg.statesize == 0) ahash_prepare_alg()
562 int crypto_register_ahash(struct ahash_alg *alg) crypto_register_ahash() argument
564 struct crypto_alg *base = &alg->halg.base; crypto_register_ahash()
567 err = ahash_prepare_alg(alg); crypto_register_ahash()
575 int crypto_unregister_ahash(struct ahash_alg *alg) crypto_unregister_ahash() argument
577 return crypto_unregister_alg(&alg->halg.base); crypto_unregister_ahash()
586 err = ahash_prepare_alg(&inst->alg); ahash_register_instance()
602 struct hash_alg_common *alg, crypto_init_ahash_spawn()
605 return crypto_init_spawn2(&spawn->base, &alg->base, inst, crypto_init_ahash_spawn()
612 struct crypto_alg *alg; ahash_attr_alg() local
614 alg = crypto_attr_alg2(rta, &crypto_ahash_type, type, mask); ahash_attr_alg()
615 return IS_ERR(alg) ? ERR_CAST(alg) : __crypto_hash_alg_common(alg); ahash_attr_alg()
601 crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn, struct hash_alg_common *alg, struct crypto_instance *inst) crypto_init_ahash_spawn() argument
H A Drng.c54 struct rng_alg *alg = &tfm->__crt_alg->cra_rng; crypto_init_rng_ops() local
57 ops->rng_gen_random = alg->rng_make_random; crypto_init_rng_ops()
64 static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_rng_report() argument
70 rrng.seedsize = alg->cra_rng.seedsize; crypto_rng_report()
81 static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_rng_report() argument
87 static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
89 static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg) crypto_rng_show() argument
92 seq_printf(m, "seedsize : %u\n", alg->cra_rng.seedsize); crypto_rng_show()
95 static unsigned int crypto_rng_ctxsize(struct crypto_alg *alg, u32 type, crypto_rng_ctxsize() argument
98 return alg->cra_ctxsize; crypto_rng_ctxsize()
H A Dcts.c277 struct crypto_alg *alg; crypto_cts_alloc() local
284 alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_BLKCIPHER, crypto_cts_alloc()
286 if (IS_ERR(alg)) crypto_cts_alloc()
287 return ERR_CAST(alg); crypto_cts_alloc()
290 if (!is_power_of_2(alg->cra_blocksize)) crypto_cts_alloc()
293 if (strncmp(alg->cra_name, "cbc(", 4)) crypto_cts_alloc()
296 inst = crypto_alloc_instance("cts", alg); crypto_cts_alloc()
300 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_cts_alloc()
301 inst->alg.cra_priority = alg->cra_priority; crypto_cts_alloc()
302 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_cts_alloc()
303 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_cts_alloc()
304 inst->alg.cra_type = &crypto_blkcipher_type; crypto_cts_alloc()
307 inst->alg.cra_alignmask |= __alignof__(u32) - 1; crypto_cts_alloc()
309 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_cts_alloc()
310 inst->alg.cra_blkcipher.min_keysize = alg->cra_blkcipher.min_keysize; crypto_cts_alloc()
311 inst->alg.cra_blkcipher.max_keysize = alg->cra_blkcipher.max_keysize; crypto_cts_alloc()
313 inst->alg.cra_ctxsize = sizeof(struct crypto_cts_ctx); crypto_cts_alloc()
315 inst->alg.cra_init = crypto_cts_init_tfm; crypto_cts_alloc()
316 inst->alg.cra_exit = crypto_cts_exit_tfm; crypto_cts_alloc()
318 inst->alg.cra_blkcipher.setkey = crypto_cts_setkey; crypto_cts_alloc()
319 inst->alg.cra_blkcipher.encrypt = crypto_cts_encrypt; crypto_cts_alloc()
320 inst->alg.cra_blkcipher.decrypt = crypto_cts_decrypt; crypto_cts_alloc()
323 crypto_mod_put(alg); crypto_cts_alloc()
H A Dpcrypt.c309 static struct crypto_instance *pcrypt_alloc_instance(struct crypto_alg *alg) pcrypt_alloc_instance() argument
322 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, pcrypt_alloc_instance()
323 "pcrypt(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) pcrypt_alloc_instance()
326 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); pcrypt_alloc_instance()
329 err = crypto_init_spawn(&ctx->spawn, alg, inst, pcrypt_alloc_instance()
334 inst->alg.cra_priority = alg->cra_priority + 100; pcrypt_alloc_instance()
335 inst->alg.cra_blocksize = alg->cra_blocksize; pcrypt_alloc_instance()
336 inst->alg.cra_alignmask = alg->cra_alignmask; pcrypt_alloc_instance()
351 struct crypto_alg *alg; pcrypt_alloc_aead() local
353 alg = crypto_get_attr_alg(tb, type, (mask & CRYPTO_ALG_TYPE_MASK)); pcrypt_alloc_aead()
354 if (IS_ERR(alg)) pcrypt_alloc_aead()
355 return ERR_CAST(alg); pcrypt_alloc_aead()
357 inst = pcrypt_alloc_instance(alg); pcrypt_alloc_aead()
361 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC; pcrypt_alloc_aead()
362 inst->alg.cra_type = &crypto_aead_type; pcrypt_alloc_aead()
364 inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; pcrypt_alloc_aead()
365 inst->alg.cra_aead.geniv = alg->cra_aead.geniv; pcrypt_alloc_aead()
366 inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; pcrypt_alloc_aead()
368 inst->alg.cra_ctxsize = sizeof(struct pcrypt_aead_ctx); pcrypt_alloc_aead()
370 inst->alg.cra_init = pcrypt_aead_init_tfm; pcrypt_alloc_aead()
371 inst->alg.cra_exit = pcrypt_aead_exit_tfm; pcrypt_alloc_aead()
373 inst->alg.cra_aead.setkey = pcrypt_aead_setkey; pcrypt_alloc_aead()
374 inst->alg.cra_aead.setauthsize = pcrypt_aead_setauthsize; pcrypt_alloc_aead()
375 inst->alg.cra_aead.encrypt = pcrypt_aead_encrypt; pcrypt_alloc_aead()
376 inst->alg.cra_aead.decrypt = pcrypt_aead_decrypt; pcrypt_alloc_aead()
377 inst->alg.cra_aead.givencrypt = pcrypt_aead_givencrypt; pcrypt_alloc_aead()
380 crypto_mod_put(alg); pcrypt_alloc_aead()
H A Dmcryptd.c33 static void *mcryptd_alloc_instance(struct crypto_alg *alg, unsigned int head,
228 static void *mcryptd_alloc_instance(struct crypto_alg *alg, unsigned int head, mcryptd_alloc_instance() argument
242 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, mcryptd_alloc_instance()
243 "mcryptd(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) mcryptd_alloc_instance()
246 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); mcryptd_alloc_instance()
248 inst->alg.cra_priority = alg->cra_priority + 50; mcryptd_alloc_instance()
249 inst->alg.cra_blocksize = alg->cra_blocksize; mcryptd_alloc_instance()
250 inst->alg.cra_alignmask = alg->cra_alignmask; mcryptd_alloc_instance()
496 struct crypto_alg *alg; mcryptd_create_hash() local
507 alg = &salg->base; mcryptd_create_hash()
508 pr_debug("crypto: mcryptd hash alg: %s\n", alg->cra_name); mcryptd_create_hash()
509 inst = mcryptd_alloc_instance(alg, ahash_instance_headroom(), mcryptd_create_hash()
524 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) mcryptd_create_hash()
526 inst->alg.halg.base.cra_flags = type; mcryptd_create_hash()
528 inst->alg.halg.digestsize = salg->digestsize; mcryptd_create_hash()
529 inst->alg.halg.base.cra_ctxsize = sizeof(struct mcryptd_hash_ctx); mcryptd_create_hash()
531 inst->alg.halg.base.cra_init = mcryptd_hash_init_tfm; mcryptd_create_hash()
532 inst->alg.halg.base.cra_exit = mcryptd_hash_exit_tfm; mcryptd_create_hash()
534 inst->alg.init = mcryptd_hash_init_enqueue; mcryptd_create_hash()
535 inst->alg.update = mcryptd_hash_update_enqueue; mcryptd_create_hash()
536 inst->alg.final = mcryptd_hash_final_enqueue; mcryptd_create_hash()
537 inst->alg.finup = mcryptd_hash_finup_enqueue; mcryptd_create_hash()
538 inst->alg.export = mcryptd_hash_export; mcryptd_create_hash()
539 inst->alg.import = mcryptd_hash_import; mcryptd_create_hash()
540 inst->alg.setkey = mcryptd_hash_setkey; mcryptd_create_hash()
541 inst->alg.digest = mcryptd_hash_digest_enqueue; mcryptd_create_hash()
551 crypto_mod_put(alg); mcryptd_create_hash()
579 switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) { mcryptd_free()
H A Dshash.c335 struct shash_alg *alg = __crypto_shash_alg(calg); crypto_init_shash_ops_async() local
359 crt->has_setkey = alg->setkey != shash_no_setkey; crypto_init_shash_ops_async()
361 if (alg->export) crypto_init_shash_ops_async()
363 if (alg->import) crypto_init_shash_ops_async()
459 struct shash_alg *alg = __crypto_shash_alg(calg); crypto_init_shash_ops_compat() local
490 crt->digestsize = alg->digestsize; crypto_init_shash_ops_compat()
505 static unsigned int crypto_shash_ctxsize(struct crypto_alg *alg, u32 type, crypto_shash_ctxsize() argument
524 static unsigned int crypto_shash_extsize(struct crypto_alg *alg) crypto_shash_extsize() argument
526 return alg->cra_ctxsize; crypto_shash_extsize()
530 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_shash_report() argument
533 struct shash_alg *salg = __crypto_shash_alg(alg); crypto_shash_report()
537 rhash.blocksize = alg->cra_blocksize; crypto_shash_report()
549 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_shash_report() argument
555 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
557 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg) crypto_shash_show() argument
559 struct shash_alg *salg = __crypto_shash_alg(alg); crypto_shash_show()
562 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_shash_show()
588 static int shash_prepare_alg(struct shash_alg *alg) shash_prepare_alg() argument
590 struct crypto_alg *base = &alg->base; shash_prepare_alg()
592 if (alg->digestsize > PAGE_SIZE / 8 || shash_prepare_alg()
593 alg->descsize > PAGE_SIZE / 8 || shash_prepare_alg()
594 alg->statesize > PAGE_SIZE / 8) shash_prepare_alg()
601 if (!alg->finup) shash_prepare_alg()
602 alg->finup = shash_finup_unaligned; shash_prepare_alg()
603 if (!alg->digest) shash_prepare_alg()
604 alg->digest = shash_digest_unaligned; shash_prepare_alg()
605 if (!alg->export) { shash_prepare_alg()
606 alg->export = shash_default_export; shash_prepare_alg()
607 alg->import = shash_default_import; shash_prepare_alg()
608 alg->statesize = alg->descsize; shash_prepare_alg()
610 if (!alg->setkey) shash_prepare_alg()
611 alg->setkey = shash_no_setkey; shash_prepare_alg()
616 int crypto_register_shash(struct shash_alg *alg) crypto_register_shash() argument
618 struct crypto_alg *base = &alg->base; crypto_register_shash()
621 err = shash_prepare_alg(alg); crypto_register_shash()
629 int crypto_unregister_shash(struct shash_alg *alg) crypto_unregister_shash() argument
631 return crypto_unregister_alg(&alg->base); crypto_unregister_shash()
676 err = shash_prepare_alg(&inst->alg); shash_register_instance()
692 struct shash_alg *alg, crypto_init_shash_spawn()
695 return crypto_init_spawn2(&spawn->base, &alg->base, inst, crypto_init_shash_spawn()
702 struct crypto_alg *alg; shash_attr_alg() local
704 alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask); shash_attr_alg()
705 return IS_ERR(alg) ? ERR_CAST(alg) : shash_attr_alg()
706 container_of(alg, struct shash_alg, base); shash_attr_alg()
691 crypto_init_shash_spawn(struct crypto_shash_spawn *spawn, struct shash_alg *alg, struct crypto_instance *inst) crypto_init_shash_spawn() argument
H A Dgcm.c754 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_gcm_alloc_common()
760 memcpy(inst->alg.cra_name, full_name, CRYPTO_MAX_ALG_NAME); crypto_gcm_alloc_common()
762 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_gcm_alloc_common()
763 inst->alg.cra_flags |= ctr->cra_flags & CRYPTO_ALG_ASYNC; crypto_gcm_alloc_common()
764 inst->alg.cra_priority = ctr->cra_priority; crypto_gcm_alloc_common()
765 inst->alg.cra_blocksize = 1; crypto_gcm_alloc_common()
766 inst->alg.cra_alignmask = ctr->cra_alignmask | (__alignof__(u64) - 1); crypto_gcm_alloc_common()
767 inst->alg.cra_type = &crypto_aead_type; crypto_gcm_alloc_common()
768 inst->alg.cra_aead.ivsize = 16; crypto_gcm_alloc_common()
769 inst->alg.cra_aead.maxauthsize = 16; crypto_gcm_alloc_common()
770 inst->alg.cra_ctxsize = sizeof(struct crypto_gcm_ctx); crypto_gcm_alloc_common()
771 inst->alg.cra_init = crypto_gcm_init_tfm; crypto_gcm_alloc_common()
772 inst->alg.cra_exit = crypto_gcm_exit_tfm; crypto_gcm_alloc_common()
773 inst->alg.cra_aead.setkey = crypto_gcm_setkey; crypto_gcm_alloc_common()
774 inst->alg.cra_aead.setauthsize = crypto_gcm_setauthsize; crypto_gcm_alloc_common()
775 inst->alg.cra_aead.encrypt = crypto_gcm_encrypt; crypto_gcm_alloc_common()
776 inst->alg.cra_aead.decrypt = crypto_gcm_decrypt; crypto_gcm_alloc_common()
969 struct crypto_alg *alg; crypto_rfc4106_alloc() local
995 alg = crypto_aead_spawn_alg(spawn); crypto_rfc4106_alloc()
1000 if (alg->cra_aead.ivsize != 16) crypto_rfc4106_alloc()
1004 if (alg->cra_blocksize != 1) crypto_rfc4106_alloc()
1008 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4106_alloc()
1009 "rfc4106(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME || crypto_rfc4106_alloc()
1010 snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4106_alloc()
1011 "rfc4106(%s)", alg->cra_driver_name) >= crypto_rfc4106_alloc()
1015 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_rfc4106_alloc()
1016 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; crypto_rfc4106_alloc()
1017 inst->alg.cra_priority = alg->cra_priority; crypto_rfc4106_alloc()
1018 inst->alg.cra_blocksize = 1; crypto_rfc4106_alloc()
1019 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc4106_alloc()
1020 inst->alg.cra_type = &crypto_nivaead_type; crypto_rfc4106_alloc()
1022 inst->alg.cra_aead.ivsize = 8; crypto_rfc4106_alloc()
1023 inst->alg.cra_aead.maxauthsize = 16; crypto_rfc4106_alloc()
1025 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4106_ctx); crypto_rfc4106_alloc()
1027 inst->alg.cra_init = crypto_rfc4106_init_tfm; crypto_rfc4106_alloc()
1028 inst->alg.cra_exit = crypto_rfc4106_exit_tfm; crypto_rfc4106_alloc()
1030 inst->alg.cra_aead.setkey = crypto_rfc4106_setkey; crypto_rfc4106_alloc()
1031 inst->alg.cra_aead.setauthsize = crypto_rfc4106_setauthsize; crypto_rfc4106_alloc()
1032 inst->alg.cra_aead.encrypt = crypto_rfc4106_encrypt; crypto_rfc4106_alloc()
1033 inst->alg.cra_aead.decrypt = crypto_rfc4106_decrypt; crypto_rfc4106_alloc()
1035 inst->alg.cra_aead.geniv = "seqiv"; crypto_rfc4106_alloc()
1284 struct crypto_alg *alg; crypto_rfc4543_alloc() local
1312 alg = crypto_aead_spawn_alg(spawn); crypto_rfc4543_alloc()
1325 if (alg->cra_aead.ivsize != 16) crypto_rfc4543_alloc()
1329 if (alg->cra_blocksize != 1) crypto_rfc4543_alloc()
1333 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4543_alloc()
1334 "rfc4543(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME || crypto_rfc4543_alloc()
1335 snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4543_alloc()
1336 "rfc4543(%s)", alg->cra_driver_name) >= crypto_rfc4543_alloc()
1340 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_rfc4543_alloc()
1341 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; crypto_rfc4543_alloc()
1342 inst->alg.cra_priority = alg->cra_priority; crypto_rfc4543_alloc()
1343 inst->alg.cra_blocksize = 1; crypto_rfc4543_alloc()
1344 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc4543_alloc()
1345 inst->alg.cra_type = &crypto_nivaead_type; crypto_rfc4543_alloc()
1347 inst->alg.cra_aead.ivsize = 8; crypto_rfc4543_alloc()
1348 inst->alg.cra_aead.maxauthsize = 16; crypto_rfc4543_alloc()
1350 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4543_ctx); crypto_rfc4543_alloc()
1352 inst->alg.cra_init = crypto_rfc4543_init_tfm; crypto_rfc4543_alloc()
1353 inst->alg.cra_exit = crypto_rfc4543_exit_tfm; crypto_rfc4543_alloc()
1355 inst->alg.cra_aead.setkey = crypto_rfc4543_setkey; crypto_rfc4543_alloc()
1356 inst->alg.cra_aead.setauthsize = crypto_rfc4543_setauthsize; crypto_rfc4543_alloc()
1357 inst->alg.cra_aead.encrypt = crypto_rfc4543_encrypt; crypto_rfc4543_alloc()
1358 inst->alg.cra_aead.decrypt = crypto_rfc4543_decrypt; crypto_rfc4543_alloc()
1360 inst->alg.cra_aead.geniv = "seqiv"; crypto_rfc4543_alloc()
H A Dccm.c534 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_ccm_alloc_common()
539 memcpy(inst->alg.cra_name, full_name, CRYPTO_MAX_ALG_NAME); crypto_ccm_alloc_common()
541 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_ccm_alloc_common()
542 inst->alg.cra_flags |= ctr->cra_flags & CRYPTO_ALG_ASYNC; crypto_ccm_alloc_common()
543 inst->alg.cra_priority = cipher->cra_priority + ctr->cra_priority; crypto_ccm_alloc_common()
544 inst->alg.cra_blocksize = 1; crypto_ccm_alloc_common()
545 inst->alg.cra_alignmask = cipher->cra_alignmask | ctr->cra_alignmask | crypto_ccm_alloc_common()
547 inst->alg.cra_type = &crypto_aead_type; crypto_ccm_alloc_common()
548 inst->alg.cra_aead.ivsize = 16; crypto_ccm_alloc_common()
549 inst->alg.cra_aead.maxauthsize = 16; crypto_ccm_alloc_common()
550 inst->alg.cra_ctxsize = sizeof(struct crypto_ccm_ctx); crypto_ccm_alloc_common()
551 inst->alg.cra_init = crypto_ccm_init_tfm; crypto_ccm_alloc_common()
552 inst->alg.cra_exit = crypto_ccm_exit_tfm; crypto_ccm_alloc_common()
553 inst->alg.cra_aead.setkey = crypto_ccm_setkey; crypto_ccm_alloc_common()
554 inst->alg.cra_aead.setauthsize = crypto_ccm_setauthsize; crypto_ccm_alloc_common()
555 inst->alg.cra_aead.encrypt = crypto_ccm_encrypt; crypto_ccm_alloc_common()
556 inst->alg.cra_aead.decrypt = crypto_ccm_decrypt; crypto_ccm_alloc_common()
752 struct crypto_alg *alg; crypto_rfc4309_alloc() local
778 alg = crypto_aead_spawn_alg(spawn); crypto_rfc4309_alloc()
783 if (alg->cra_aead.ivsize != 16) crypto_rfc4309_alloc()
787 if (alg->cra_blocksize != 1) crypto_rfc4309_alloc()
791 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4309_alloc()
792 "rfc4309(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME || crypto_rfc4309_alloc()
793 snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4309_alloc()
794 "rfc4309(%s)", alg->cra_driver_name) >= crypto_rfc4309_alloc()
798 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_rfc4309_alloc()
799 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; crypto_rfc4309_alloc()
800 inst->alg.cra_priority = alg->cra_priority; crypto_rfc4309_alloc()
801 inst->alg.cra_blocksize = 1; crypto_rfc4309_alloc()
802 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc4309_alloc()
803 inst->alg.cra_type = &crypto_nivaead_type; crypto_rfc4309_alloc()
805 inst->alg.cra_aead.ivsize = 8; crypto_rfc4309_alloc()
806 inst->alg.cra_aead.maxauthsize = 16; crypto_rfc4309_alloc()
808 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4309_ctx); crypto_rfc4309_alloc()
810 inst->alg.cra_init = crypto_rfc4309_init_tfm; crypto_rfc4309_alloc()
811 inst->alg.cra_exit = crypto_rfc4309_exit_tfm; crypto_rfc4309_alloc()
813 inst->alg.cra_aead.setkey = crypto_rfc4309_setkey; crypto_rfc4309_alloc()
814 inst->alg.cra_aead.setauthsize = crypto_rfc4309_setauthsize; crypto_rfc4309_alloc()
815 inst->alg.cra_aead.encrypt = crypto_rfc4309_encrypt; crypto_rfc4309_alloc()
816 inst->alg.cra_aead.decrypt = crypto_rfc4309_decrypt; crypto_rfc4309_alloc()
818 inst->alg.cra_aead.geniv = "seqiv"; crypto_rfc4309_alloc()
H A Dseqiv.c270 if (inst->alg.cra_ablkcipher.ivsize < sizeof(u64)) { seqiv_ablkcipher_alloc()
276 inst->alg.cra_ablkcipher.givencrypt = seqiv_givencrypt_first; seqiv_ablkcipher_alloc()
278 inst->alg.cra_init = seqiv_init; seqiv_ablkcipher_alloc()
279 inst->alg.cra_exit = skcipher_geniv_exit; seqiv_ablkcipher_alloc()
281 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; seqiv_ablkcipher_alloc()
296 if (inst->alg.cra_aead.ivsize < sizeof(u64)) { seqiv_aead_alloc()
302 inst->alg.cra_aead.givencrypt = seqiv_aead_givencrypt_first; seqiv_aead_alloc()
304 inst->alg.cra_init = seqiv_aead_init; seqiv_aead_alloc()
305 inst->alg.cra_exit = aead_geniv_exit; seqiv_aead_alloc()
307 inst->alg.cra_ctxsize = inst->alg.cra_aead.ivsize; seqiv_aead_alloc()
335 inst->alg.cra_alignmask |= __alignof__(u32) - 1; seqiv_alloc()
336 inst->alg.cra_ctxsize += sizeof(struct seqiv_ctx); seqiv_alloc()
348 if ((inst->alg.cra_flags ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) seqiv_free()
H A Dsha1_generic.c62 static struct shash_alg alg = { variable in typeref:struct:shash_alg
80 return crypto_register_shash(&alg); sha1_generic_mod_init()
85 crypto_unregister_shash(&alg); sha1_generic_mod_fini()
H A Dchainiv.c305 inst->alg.cra_ablkcipher.givencrypt = chainiv_givencrypt_first; chainiv_alloc()
307 inst->alg.cra_init = chainiv_init; chainiv_alloc()
308 inst->alg.cra_exit = skcipher_geniv_exit; chainiv_alloc()
310 inst->alg.cra_ctxsize = sizeof(struct chainiv_ctx); chainiv_alloc()
313 inst->alg.cra_flags |= CRYPTO_ALG_ASYNC; chainiv_alloc()
315 inst->alg.cra_ablkcipher.givencrypt = chainiv_alloc()
318 inst->alg.cra_init = async_chainiv_init; chainiv_alloc()
319 inst->alg.cra_exit = async_chainiv_exit; chainiv_alloc()
321 inst->alg.cra_ctxsize = sizeof(struct async_chainiv_ctx); chainiv_alloc()
324 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; chainiv_alloc()
H A Dlzo.c83 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
97 return crypto_register_alg(&alg); lzo_mod_init()
102 crypto_unregister_alg(&alg); lzo_mod_fini()
H A Dvmac.c646 struct crypto_alg *alg; vmac_create() local
653 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, vmac_create()
655 if (IS_ERR(alg)) vmac_create()
656 return PTR_ERR(alg); vmac_create()
658 inst = shash_alloc_instance("vmac", alg); vmac_create()
663 err = crypto_init_spawn(shash_instance_ctx(inst), alg, vmac_create()
669 inst->alg.base.cra_priority = alg->cra_priority; vmac_create()
670 inst->alg.base.cra_blocksize = alg->cra_blocksize; vmac_create()
671 inst->alg.base.cra_alignmask = alg->cra_alignmask; vmac_create()
673 inst->alg.digestsize = sizeof(vmac_t); vmac_create()
674 inst->alg.base.cra_ctxsize = sizeof(struct vmac_ctx_t); vmac_create()
675 inst->alg.base.cra_init = vmac_init_tfm; vmac_create()
676 inst->alg.base.cra_exit = vmac_exit_tfm; vmac_create()
678 inst->alg.init = vmac_init; vmac_create()
679 inst->alg.update = vmac_update; vmac_create()
680 inst->alg.final = vmac_final; vmac_create()
681 inst->alg.setkey = vmac_setkey; vmac_create()
690 crypto_mod_put(alg); vmac_create()
H A Deseqiv.c220 if (inst->alg.cra_ablkcipher.ivsize != inst->alg.cra_blocksize) eseqiv_alloc()
223 inst->alg.cra_ablkcipher.givencrypt = eseqiv_givencrypt_first; eseqiv_alloc()
225 inst->alg.cra_init = eseqiv_init; eseqiv_alloc()
226 inst->alg.cra_exit = skcipher_geniv_exit; eseqiv_alloc()
228 inst->alg.cra_ctxsize = sizeof(struct eseqiv_ctx); eseqiv_alloc()
229 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; eseqiv_alloc()
H A Dblowfish_generic.c109 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
128 return crypto_register_alg(&alg); blowfish_mod_init()
133 crypto_unregister_alg(&alg); blowfish_mod_fini()
H A Dcrc32.c123 static struct shash_alg alg = { variable in typeref:struct:shash_alg
145 return crypto_register_shash(&alg); crc32_mod_init()
150 crypto_unregister_shash(&alg); crc32_mod_fini()
H A Dcrct10dif_generic.c91 static struct shash_alg alg = { variable in typeref:struct:shash_alg
112 ret = crypto_register_shash(&alg); crct10dif_mod_init()
118 crypto_unregister_shash(&alg); crct10dif_mod_fini()
H A Dmd5.c139 static struct shash_alg alg = { variable in typeref:struct:shash_alg
158 return crypto_register_shash(&alg); md5_mod_init()
163 crypto_unregister_shash(&alg); md5_mod_fini()
H A Dmichael_mic.c153 static struct shash_alg alg = { variable in typeref:struct:shash_alg
171 return crypto_register_shash(&alg); michael_mic_init()
177 crypto_unregister_shash(&alg); michael_mic_exit()
H A Dauthenc.c647 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_alloc()
652 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_alloc()
657 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_authenc_alloc()
658 inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC; crypto_authenc_alloc()
659 inst->alg.cra_priority = enc->cra_priority * crypto_authenc_alloc()
661 inst->alg.cra_blocksize = enc->cra_blocksize; crypto_authenc_alloc()
662 inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask; crypto_authenc_alloc()
663 inst->alg.cra_type = &crypto_aead_type; crypto_authenc_alloc()
665 inst->alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize; crypto_authenc_alloc()
666 inst->alg.cra_aead.maxauthsize = auth->digestsize; crypto_authenc_alloc()
668 inst->alg.cra_ctxsize = sizeof(struct crypto_authenc_ctx); crypto_authenc_alloc()
670 inst->alg.cra_init = crypto_authenc_init_tfm; crypto_authenc_alloc()
671 inst->alg.cra_exit = crypto_authenc_exit_tfm; crypto_authenc_alloc()
673 inst->alg.cra_aead.setkey = crypto_authenc_setkey; crypto_authenc_alloc()
674 inst->alg.cra_aead.encrypt = crypto_authenc_encrypt; crypto_authenc_alloc()
675 inst->alg.cra_aead.decrypt = crypto_authenc_decrypt; crypto_authenc_alloc()
676 inst->alg.cra_aead.givencrypt = crypto_authenc_givencrypt; crypto_authenc_alloc()
H A Dauthencesn.c739 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_esn_alloc()
744 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_esn_alloc()
749 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_authenc_esn_alloc()
750 inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC; crypto_authenc_esn_alloc()
751 inst->alg.cra_priority = enc->cra_priority * crypto_authenc_esn_alloc()
753 inst->alg.cra_blocksize = enc->cra_blocksize; crypto_authenc_esn_alloc()
754 inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask; crypto_authenc_esn_alloc()
755 inst->alg.cra_type = &crypto_aead_type; crypto_authenc_esn_alloc()
757 inst->alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize; crypto_authenc_esn_alloc()
758 inst->alg.cra_aead.maxauthsize = auth->digestsize; crypto_authenc_esn_alloc()
760 inst->alg.cra_ctxsize = sizeof(struct crypto_authenc_esn_ctx); crypto_authenc_esn_alloc()
762 inst->alg.cra_init = crypto_authenc_esn_init_tfm; crypto_authenc_esn_alloc()
763 inst->alg.cra_exit = crypto_authenc_esn_exit_tfm; crypto_authenc_esn_alloc()
765 inst->alg.cra_aead.setkey = crypto_authenc_esn_setkey; crypto_authenc_esn_alloc()
766 inst->alg.cra_aead.encrypt = crypto_authenc_esn_encrypt; crypto_authenc_esn_alloc()
767 inst->alg.cra_aead.decrypt = crypto_authenc_esn_decrypt; crypto_authenc_esn_alloc()
768 inst->alg.cra_aead.givencrypt = crypto_authenc_esn_givencrypt; crypto_authenc_esn_alloc()
H A D842.c155 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
170 return crypto_register_alg(&alg); nx842_mod_init()
175 crypto_unregister_alg(&alg); nx842_mod_exit()
H A Dcrc32c_generic.c136 static struct shash_alg alg = { variable in typeref:struct:shash_alg
159 return crypto_register_shash(&alg); crc32c_mod_init()
164 crypto_unregister_shash(&alg); crc32c_mod_fini()
H A Ddeflate.c197 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
211 return crypto_register_alg(&alg); deflate_mod_init()
216 crypto_unregister_alg(&alg); deflate_mod_fini()
H A Dmd4.c229 static struct shash_alg alg = { variable in typeref:struct:shash_alg
245 return crypto_register_shash(&alg); md4_mod_init()
250 crypto_unregister_shash(&alg); md4_mod_fini()
H A Dsalsa20_generic.c214 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
238 return crypto_register_alg(&alg); salsa20_generic_mod_init()
243 crypto_unregister_alg(&alg); salsa20_generic_mod_fini()
H A Dtcrypt.c60 static char *alg = NULL; variable
320 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo, test_aead_speed()
330 pr_err("alg: aead: Failed to allocate request for %s\n", test_aead_speed()
1213 printk("alg %s ", *name); test_available()
1220 static inline int tcrypt_test(const char *alg) tcrypt_test() argument
1224 ret = alg_test(alg, alg, 0, 0); tcrypt_test()
1231 static int do_test(const char *alg, u32 type, u32 mask, int m) do_test() argument
1238 if (alg) { do_test()
1239 if (!crypto_has_alg(alg, type, do_test()
1765 if (alg) { do_test()
1766 test_hash_speed(alg, sec, generic_hash_speed_template); do_test()
1856 if (alg) { do_test()
1857 test_ahash_speed(alg, sec, generic_hash_speed_template); do_test()
2161 err = do_test(alg, type, mask, mode); tcrypt_mod_init()
2194 module_param(alg, charp, 0);
H A Dcast6_generic.c260 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
281 return crypto_register_alg(&alg); cast6_mod_init()
286 crypto_unregister_alg(&alg); cast6_mod_fini()
H A Dtwofish_generic.c182 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
201 return crypto_register_alg(&alg); twofish_mod_init()
206 crypto_unregister_alg(&alg); twofish_mod_fini()
H A Ddrbg.c1892 static inline void __init drbg_fill_array(struct crypto_alg *alg, drbg_fill_array() argument
1898 memset(alg, 0, sizeof(struct crypto_alg)); drbg_fill_array()
1899 memcpy(alg->cra_name, "stdrng", 6); drbg_fill_array()
1901 memcpy(alg->cra_driver_name, "drbg_pr_", 8); drbg_fill_array()
1904 memcpy(alg->cra_driver_name, "drbg_nopr_", 10); drbg_fill_array()
1907 memcpy(alg->cra_driver_name + pos, core->cra_name, drbg_fill_array()
1910 alg->cra_priority = priority; drbg_fill_array()
1918 alg->cra_priority += 200; drbg_fill_array()
1920 alg->cra_flags = CRYPTO_ALG_TYPE_RNG; drbg_fill_array()
1921 alg->cra_ctxsize = sizeof(struct drbg_state); drbg_fill_array()
1922 alg->cra_type = &crypto_rng_type; drbg_fill_array()
1923 alg->cra_module = THIS_MODULE; drbg_fill_array()
1924 alg->cra_init = drbg_kcapi_init; drbg_fill_array()
1925 alg->cra_exit = drbg_kcapi_cleanup; drbg_fill_array()
1926 alg->cra_u.rng.rng_make_random = drbg_kcapi_random; drbg_fill_array()
1927 alg->cra_u.rng.rng_reset = drbg_kcapi_reset; drbg_fill_array()
1928 alg->cra_u.rng.seedsize = 0; drbg_fill_array()
H A Drmd128.c300 static struct shash_alg alg = { variable in typeref:struct:shash_alg
316 return crypto_register_shash(&alg); rmd128_mod_init()
321 crypto_unregister_shash(&alg); rmd128_mod_fini()
H A Drmd256.c319 static struct shash_alg alg = { variable in typeref:struct:shash_alg
335 return crypto_register_shash(&alg); rmd256_mod_init()
340 crypto_unregister_shash(&alg); rmd256_mod_fini()
H A Dcast5_generic.c517 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
539 return crypto_register_alg(&alg); cast5_mod_init()
544 crypto_unregister_alg(&alg); cast5_mod_fini()
H A Drmd160.c344 static struct shash_alg alg = { variable in typeref:struct:shash_alg
360 return crypto_register_shash(&alg); rmd160_mod_init()
365 crypto_unregister_shash(&alg); rmd160_mod_fini()
H A Drmd320.c368 static struct shash_alg alg = { variable in typeref:struct:shash_alg
384 return crypto_register_shash(&alg); rmd320_mod_init()
389 crypto_unregister_shash(&alg); rmd320_mod_fini()
/linux-4.1.27/arch/x86/crypto/
H A Dfpu.c105 struct crypto_alg *alg; crypto_fpu_alloc() local
112 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_BLKCIPHER, crypto_fpu_alloc()
114 if (IS_ERR(alg)) crypto_fpu_alloc()
115 return ERR_CAST(alg); crypto_fpu_alloc()
117 inst = crypto_alloc_instance("fpu", alg); crypto_fpu_alloc()
121 inst->alg.cra_flags = alg->cra_flags; crypto_fpu_alloc()
122 inst->alg.cra_priority = alg->cra_priority; crypto_fpu_alloc()
123 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_fpu_alloc()
124 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_fpu_alloc()
125 inst->alg.cra_type = alg->cra_type; crypto_fpu_alloc()
126 inst->alg.cra_blkcipher.ivsize = alg->cra_blkcipher.ivsize; crypto_fpu_alloc()
127 inst->alg.cra_blkcipher.min_keysize = alg->cra_blkcipher.min_keysize; crypto_fpu_alloc()
128 inst->alg.cra_blkcipher.max_keysize = alg->cra_blkcipher.max_keysize; crypto_fpu_alloc()
129 inst->alg.cra_ctxsize = sizeof(struct crypto_fpu_ctx); crypto_fpu_alloc()
130 inst->alg.cra_init = crypto_fpu_init_tfm; crypto_fpu_alloc()
131 inst->alg.cra_exit = crypto_fpu_exit_tfm; crypto_fpu_alloc()
132 inst->alg.cra_blkcipher.setkey = crypto_fpu_setkey; crypto_fpu_alloc()
133 inst->alg.cra_blkcipher.encrypt = crypto_fpu_encrypt; crypto_fpu_alloc()
134 inst->alg.cra_blkcipher.decrypt = crypto_fpu_decrypt; crypto_fpu_alloc()
137 crypto_mod_put(alg); crypto_fpu_alloc()
H A Dcrct10dif-pclmul_glue.c107 static struct shash_alg alg = { variable in typeref:struct:shash_alg
135 return crypto_register_shash(&alg); crct10dif_intel_mod_init()
140 crypto_unregister_shash(&alg); crct10dif_intel_mod_fini()
H A Dsalsa20_glue.c85 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
109 return crypto_register_alg(&alg); init()
114 crypto_unregister_alg(&alg); fini()
H A Dtwofish_glue.c64 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg
86 return crypto_register_alg(&alg); init()
91 crypto_unregister_alg(&alg); fini()
H A Dcrc32c-intel_glue.c230 static struct shash_alg alg = { variable in typeref:struct:shash_alg
262 alg.update = crc32c_pcl_intel_update; crc32c_intel_mod_init()
263 alg.finup = crc32c_pcl_intel_finup; crc32c_intel_mod_init()
264 alg.digest = crc32c_pcl_intel_digest; crc32c_intel_mod_init()
268 return crypto_register_shash(&alg); crc32c_intel_mod_init()
273 crypto_unregister_shash(&alg); crc32c_intel_mod_fini()
H A Dcrc32-pclmul_glue.c152 static struct shash_alg alg = { variable in typeref:struct:shash_alg
186 return crypto_register_shash(&alg); crc32_pclmul_mod_init()
191 crypto_unregister_shash(&alg); crc32_pclmul_mod_fini()
H A Dsha1_ssse3_glue.c106 static struct shash_alg alg = { variable in typeref:struct:shash_alg
180 return crypto_register_shash(&alg); sha1_ssse3_mod_init()
189 crypto_unregister_shash(&alg); sha1_ssse3_mod_fini()
H A Daesni-intel_glue.c1218 WARN_ONCE(1, "__gcm-aes-aesni alg used in invalid context"); helper_rfc4106_encrypt()
1233 WARN_ONCE(1, "__gcm-aes-aesni alg used in invalid context"); helper_rfc4106_decrypt()
/linux-4.1.27/include/crypto/internal/
H A Dhash.h38 struct ahash_alg alg; member in struct:ahash_instance
42 struct shash_alg alg; member in struct:shash_instance
80 int crypto_register_ahash(struct ahash_alg *alg);
81 int crypto_unregister_ahash(struct ahash_alg *alg);
87 struct hash_alg_common *alg,
97 int crypto_register_shash(struct shash_alg *alg);
98 int crypto_unregister_shash(struct shash_alg *alg);
106 struct shash_alg *alg,
136 static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg) __crypto_ahash_alg() argument
138 return container_of(__crypto_hash_alg_common(alg), struct ahash_alg, __crypto_ahash_alg()
151 return container_of(&inst->alg.halg.base, struct crypto_instance, alg); ahash_crypto_instance()
157 return container_of(&inst->alg, struct ahash_instance, alg.halg.base); ahash_instance()
171 const char *name, struct crypto_alg *alg) ahash_alloc_instance()
173 return crypto_alloc_instance2(name, alg, ahash_instance_headroom()); ahash_alloc_instance()
208 return container_of(&inst->alg.base, struct crypto_instance, alg); shash_crypto_instance()
214 return container_of(__crypto_shash_alg(&inst->alg), shash_instance()
215 struct shash_instance, alg); shash_instance()
224 const char *name, struct crypto_alg *alg) shash_alloc_instance()
226 return crypto_alloc_instance2(name, alg, shash_alloc_instance()
227 sizeof(struct shash_alg) - sizeof(*alg)); shash_alloc_instance()
170 ahash_alloc_instance( const char *name, struct crypto_alg *alg) ahash_alloc_instance() argument
223 shash_alloc_instance( const char *name, struct crypto_alg *alg) shash_alloc_instance() argument
H A Dcompress.h25 extern int crypto_register_pcomp(struct pcomp_alg *alg);
26 extern int crypto_unregister_pcomp(struct pcomp_alg *alg);
H A Dskcipher.h47 return spawn->base.alg; crypto_skcipher_spawn_alg()
60 const char *crypto_default_geniv(const struct crypto_alg *alg);
H A Daead.h47 return spawn->base.alg; crypto_aead_spawn_alg()
/linux-4.1.27/drivers/staging/rtl8192e/
H A Drtllib_crypt.c106 struct rtllib_crypto_alg *alg; rtllib_register_crypto_ops() local
111 alg = kzalloc(sizeof(*alg), GFP_KERNEL); rtllib_register_crypto_ops()
112 if (alg == NULL) rtllib_register_crypto_ops()
115 alg->ops = ops; rtllib_register_crypto_ops()
118 list_add(&alg->list, &hcrypt->algs); rtllib_register_crypto_ops()
139 struct rtllib_crypto_alg *alg = rtllib_unregister_crypto_ops() local
141 if (alg->ops == ops) { rtllib_unregister_crypto_ops()
142 list_del(&alg->list); rtllib_unregister_crypto_ops()
143 del_alg = alg; rtllib_unregister_crypto_ops()
171 struct rtllib_crypto_alg *alg = rtllib_get_crypto_ops() local
173 if (strcmp(alg->ops->name, name) == 0) { rtllib_get_crypto_ops()
174 found_alg = alg; rtllib_get_crypto_ops()
239 struct rtllib_crypto_alg *alg = rtllib_crypto_deinit() local
244 alg->ops->name); rtllib_crypto_deinit()
245 kfree(alg); rtllib_crypto_deinit()
H A Drtllib_wx.c534 const char *alg, *module; rtllib_wx_set_encode_ext() local
554 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) rtllib_wx_set_encode_ext()
564 ext->alg == IW_ENCODE_ALG_NONE) { rtllib_wx_set_encode_ext()
581 switch (ext->alg) { rtllib_wx_set_encode_ext()
583 alg = "R-WEP"; rtllib_wx_set_encode_ext()
587 alg = "R-TKIP"; rtllib_wx_set_encode_ext()
591 alg = "R-CCMP"; rtllib_wx_set_encode_ext()
595 RTLLIB_DEBUG_WX("%s: unknown crypto alg %d\n", rtllib_wx_set_encode_ext()
596 dev->name, ext->alg); rtllib_wx_set_encode_ext()
600 netdev_info(dev, "alg name:%s\n", alg); rtllib_wx_set_encode_ext()
602 ops = lib80211_get_crypto_ops(alg); rtllib_wx_set_encode_ext()
609 ops = lib80211_get_crypto_ops(alg); rtllib_wx_set_encode_ext()
612 netdev_info(dev, "========>unknown crypto alg %d\n", ext->alg); rtllib_wx_set_encode_ext()
652 if (ext->alg != IW_ENCODE_ALG_NONE) { rtllib_wx_set_encode_ext()
655 if (ext->alg == IW_ENCODE_ALG_WEP) { rtllib_wx_set_encode_ext()
658 } else if (ext->alg == IW_ENCODE_ALG_TKIP) { rtllib_wx_set_encode_ext()
661 } else if (ext->alg == IW_ENCODE_ALG_CCMP) { rtllib_wx_set_encode_ext()
705 (ext->alg != IW_ENCODE_ALG_WEP)) rtllib_wx_get_encode_ext()
715 ext->alg = IW_ENCODE_ALG_NONE; rtllib_wx_get_encode_ext()
720 ext->alg = IW_ENCODE_ALG_WEP; rtllib_wx_get_encode_ext()
722 ext->alg = IW_ENCODE_ALG_TKIP; rtllib_wx_get_encode_ext()
724 ext->alg = IW_ENCODE_ALG_CCMP; rtllib_wx_get_encode_ext()
731 (ext->alg == IW_ENCODE_ALG_TKIP || rtllib_wx_get_encode_ext()
732 ext->alg == IW_ENCODE_ALG_CCMP)) rtllib_wx_get_encode_ext()
H A Drtllib_softmac.c3367 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; rtllib_wpa_set_encryption()
3384 if (strcmp(param->u.crypt.alg, "none") == 0) { rtllib_wpa_set_encryption()
3398 strcmp(param->u.crypt.alg, "R-TKIP")) rtllib_wpa_set_encryption()
3401 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption()
3402 if (ops == NULL && strcmp(param->u.crypt.alg, "R-WEP") == 0) { rtllib_wpa_set_encryption()
3404 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption()
3405 } else if (ops == NULL && strcmp(param->u.crypt.alg, "R-TKIP") == 0) { rtllib_wpa_set_encryption()
3407 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption()
3408 } else if (ops == NULL && strcmp(param->u.crypt.alg, "R-CCMP") == 0) { rtllib_wpa_set_encryption()
3410 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption()
3413 netdev_info(ieee->dev, "unknown crypto alg '%s'\n", rtllib_wpa_set_encryption()
3414 param->u.crypt.alg); rtllib_wpa_set_encryption()
3462 if (param->u.crypt.alg != NULL) { rtllib_wpa_set_encryption()
3469 if (strcmp(param->u.crypt.alg, "R-WEP") == 0) { rtllib_wpa_set_encryption()
3472 } else if (strcmp(param->u.crypt.alg, "R-TKIP") == 0) { rtllib_wpa_set_encryption()
3475 } else if (strcmp(param->u.crypt.alg, "R-CCMP") == 0) { rtllib_wpa_set_encryption()
H A Drtllib_crypt_wep.c255 seq_printf(m, "key[%d] alg=WEP len=%d\n", wep->key_idx, wep->key_len); prism2_wep_print_stats()
H A Drtllib_crypt_ccmp.c418 "key[%d] alg=CCMP key_set=%d tx_pn=%pM rx_pn=%pM format_errors=%d replays=%d decrypt_errors=%d\n", rtllib_ccmp_print_stats()
H A Drtllib_crypt_tkip.c728 "key[%d] alg=TKIP key_set=%d tx_pn=%02x%02x%02x%02x%02x%02x rx_pn=%02x%02x%02x%02x%02x%02x replays=%d icv_errors=%d local_mic_failures=%d\n", rtllib_tkip_print_stats()
/linux-4.1.27/drivers/staging/rtl8192u/ieee80211/
H A Dieee80211_crypt.c105 struct ieee80211_crypto_alg *alg; ieee80211_register_crypto_ops() local
110 alg = kzalloc(sizeof(*alg), GFP_KERNEL); ieee80211_register_crypto_ops()
111 if (alg == NULL) ieee80211_register_crypto_ops()
114 alg->ops = ops; ieee80211_register_crypto_ops()
117 list_add(&alg->list, &hcrypt->algs); ieee80211_register_crypto_ops()
137 struct ieee80211_crypto_alg *alg = ieee80211_unregister_crypto_ops() local
139 if (alg->ops == ops) { ieee80211_unregister_crypto_ops()
140 list_del(&alg->list); ieee80211_unregister_crypto_ops()
141 del_alg = alg; ieee80211_unregister_crypto_ops()
168 struct ieee80211_crypto_alg *alg = ieee80211_get_crypto_ops() local
170 if (strcmp(alg->ops->name, name) == 0) { ieee80211_get_crypto_ops()
171 found_alg = alg; ieee80211_get_crypto_ops()
231 struct ieee80211_crypto_alg *alg = ieee80211_crypto_deinit() local
235 alg->ops->name); ieee80211_crypto_deinit()
236 kfree(alg); ieee80211_crypto_deinit()
H A Dieee80211_wx.c518 const char *alg, *module; ieee80211_wx_set_encode_ext() local
525 //printk("======>encoding flag:%x,ext flag:%x, ext alg:%d\n", encoding->flags,ext->ext_flags, ext->alg); ieee80211_wx_set_encode_ext()
541 //printk("not group key, flags:%x, ext->alg:%d\n", ext->ext_flags, ext->alg); ieee80211_wx_set_encode_ext()
542 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) ieee80211_wx_set_encode_ext()
554 ext->alg == IW_ENCODE_ALG_NONE) { ieee80211_wx_set_encode_ext()
576 switch (ext->alg) { ieee80211_wx_set_encode_ext()
578 alg = "WEP"; ieee80211_wx_set_encode_ext()
582 alg = "TKIP"; ieee80211_wx_set_encode_ext()
586 alg = "CCMP"; ieee80211_wx_set_encode_ext()
590 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n", ieee80211_wx_set_encode_ext()
591 dev->name, ext->alg); ieee80211_wx_set_encode_ext()
595 printk("alg name:%s\n",alg); ieee80211_wx_set_encode_ext()
597 ops = ieee80211_get_crypto_ops(alg); ieee80211_wx_set_encode_ext()
600 ops = ieee80211_get_crypto_ops(alg); ieee80211_wx_set_encode_ext()
603 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n", ieee80211_wx_set_encode_ext()
604 dev->name, ext->alg); ieee80211_wx_set_encode_ext()
605 printk("========>unknown crypto alg %d\n", ext->alg); ieee80211_wx_set_encode_ext()
648 if (ext->alg != IW_ENCODE_ALG_NONE) { ieee80211_wx_set_encode_ext()
652 if (ext->alg == IW_ENCODE_ALG_WEP) { ieee80211_wx_set_encode_ext()
656 } else if (ext->alg == IW_ENCODE_ALG_TKIP) { ieee80211_wx_set_encode_ext()
660 } else if (ext->alg == IW_ENCODE_ALG_CCMP) { ieee80211_wx_set_encode_ext()
705 ext->alg != IW_ENCODE_ALG_WEP) ieee80211_wx_get_encode_ext()
714 ext->alg = IW_ENCODE_ALG_NONE; ieee80211_wx_get_encode_ext()
719 ext->alg = IW_ENCODE_ALG_WEP; ieee80211_wx_get_encode_ext()
721 ext->alg = IW_ENCODE_ALG_TKIP; ieee80211_wx_get_encode_ext()
723 ext->alg = IW_ENCODE_ALG_CCMP; ieee80211_wx_get_encode_ext()
729 (ext->alg == IW_ENCODE_ALG_TKIP || ieee80211_wx_get_encode_ext()
730 ext->alg == IW_ENCODE_ALG_CCMP)) ieee80211_wx_get_encode_ext()
H A Dieee80211_softmac.c2970 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; ieee80211_wpa_set_encryption()
2987 if (strcmp(param->u.crypt.alg, "none") == 0) { ieee80211_wpa_set_encryption()
3005 strcmp(param->u.crypt.alg, "TKIP")) ieee80211_wpa_set_encryption()
3008 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption()
3009 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) { ieee80211_wpa_set_encryption()
3011 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption()
3013 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) { ieee80211_wpa_set_encryption()
3015 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption()
3016 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) { ieee80211_wpa_set_encryption()
3018 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption()
3021 printk("unknown crypto alg '%s'\n", param->u.crypt.alg); ieee80211_wpa_set_encryption()
3070 if (param->u.crypt.alg != NULL) { ieee80211_wpa_set_encryption()
3077 if (strcmp(param->u.crypt.alg, "WEP") == 0) { ieee80211_wpa_set_encryption()
3080 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { ieee80211_wpa_set_encryption()
3083 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { ieee80211_wpa_set_encryption()
H A Dieee80211_crypt_wep.c262 p += sprintf(p, "key[%d] alg=WEP len=%d\n", prism2_wep_print_stats()
H A Dieee80211_crypt_ccmp.c432 p += sprintf(p, "key[%d] alg=CCMP key_set=%d " ieee80211_ccmp_print_stats()
H A Dieee80211_crypt_tkip.c723 p += sprintf(p, "key[%d] alg=TKIP key_set=%d " ieee80211_tkip_print_stats()
/linux-4.1.27/net/wireless/
H A Dlib80211.c167 struct lib80211_crypto_alg *alg; lib80211_register_crypto_ops() local
169 alg = kzalloc(sizeof(*alg), GFP_KERNEL); lib80211_register_crypto_ops()
170 if (alg == NULL) lib80211_register_crypto_ops()
173 alg->ops = ops; lib80211_register_crypto_ops()
176 list_add(&alg->list, &lib80211_crypto_algs); lib80211_register_crypto_ops()
188 struct lib80211_crypto_alg *alg; lib80211_unregister_crypto_ops() local
192 list_for_each_entry(alg, &lib80211_crypto_algs, list) { lib80211_unregister_crypto_ops()
193 if (alg->ops == ops) lib80211_unregister_crypto_ops()
202 list_del(&alg->list); lib80211_unregister_crypto_ops()
204 kfree(alg); lib80211_unregister_crypto_ops()
211 struct lib80211_crypto_alg *alg; lib80211_get_crypto_ops() local
215 list_for_each_entry(alg, &lib80211_crypto_algs, list) { lib80211_get_crypto_ops()
216 if (strcmp(alg->ops->name, name) == 0) lib80211_get_crypto_ops()
224 return alg->ops; lib80211_get_crypto_ops()
H A Dlib80211_crypt_wep.c259 seq_printf(m, "key[%d] alg=WEP len=%d\n", wep->key_idx, wep->key_len); lib80211_wep_print_stats()
H A Dlib80211_crypt_ccmp.c438 "key[%d] alg=CCMP key_set=%d " lib80211_ccmp_print_stats()
H A Dlib80211_crypt_tkip.c710 "key[%d] alg=TKIP key_set=%d " lib80211_tkip_print_stats()
/linux-4.1.27/drivers/crypto/ccp/
H A Dccp-crypto-aes-xts.c229 struct crypto_alg *alg; ccp_register_aes_xts_alg() local
238 alg = &ccp_alg->alg; ccp_register_aes_xts_alg()
240 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name); ccp_register_aes_xts_alg()
241 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", ccp_register_aes_xts_alg()
243 alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC | ccp_register_aes_xts_alg()
246 alg->cra_blocksize = AES_BLOCK_SIZE; ccp_register_aes_xts_alg()
247 alg->cra_ctxsize = sizeof(struct ccp_ctx); ccp_register_aes_xts_alg()
248 alg->cra_priority = CCP_CRA_PRIORITY; ccp_register_aes_xts_alg()
249 alg->cra_type = &crypto_ablkcipher_type; ccp_register_aes_xts_alg()
250 alg->cra_ablkcipher.setkey = ccp_aes_xts_setkey; ccp_register_aes_xts_alg()
251 alg->cra_ablkcipher.encrypt = ccp_aes_xts_encrypt; ccp_register_aes_xts_alg()
252 alg->cra_ablkcipher.decrypt = ccp_aes_xts_decrypt; ccp_register_aes_xts_alg()
253 alg->cra_ablkcipher.min_keysize = AES_MIN_KEY_SIZE * 2; ccp_register_aes_xts_alg()
254 alg->cra_ablkcipher.max_keysize = AES_MAX_KEY_SIZE * 2; ccp_register_aes_xts_alg()
255 alg->cra_ablkcipher.ivsize = AES_BLOCK_SIZE; ccp_register_aes_xts_alg()
256 alg->cra_init = ccp_aes_xts_cra_init; ccp_register_aes_xts_alg()
257 alg->cra_exit = ccp_aes_xts_cra_exit; ccp_register_aes_xts_alg()
258 alg->cra_module = THIS_MODULE; ccp_register_aes_xts_alg()
260 ret = crypto_register_alg(alg); ccp_register_aes_xts_alg()
263 alg->cra_name, ret); ccp_register_aes_xts_alg()
H A Dccp-crypto-sha.c152 struct ccp_crypto_ahash_alg *alg = ccp_sha_init() local
159 rctx->type = alg->type; ccp_sha_init()
308 struct ccp_crypto_ahash_alg *alg = ccp_crypto_ahash_alg(tfm); ccp_hmac_sha_cra_init() local
311 hmac_tfm = crypto_alloc_shash(alg->child_alg, 0, 0); ccp_hmac_sha_cra_init()
314 alg->child_alg); ccp_hmac_sha_cra_init()
370 struct ahash_alg *alg; ccp_register_hmac_alg() local
385 alg = &ccp_alg->alg; ccp_register_hmac_alg()
386 alg->setkey = ccp_sha_setkey; ccp_register_hmac_alg()
388 halg = &alg->halg; ccp_register_hmac_alg()
397 ret = crypto_register_ahash(alg); ccp_register_hmac_alg()
414 struct ahash_alg *alg; ccp_register_sha_alg() local
427 alg = &ccp_alg->alg; ccp_register_sha_alg()
428 alg->init = ccp_sha_init; ccp_register_sha_alg()
429 alg->update = ccp_sha_update; ccp_register_sha_alg()
430 alg->final = ccp_sha_final; ccp_register_sha_alg()
431 alg->finup = ccp_sha_finup; ccp_register_sha_alg()
432 alg->digest = ccp_sha_digest; ccp_register_sha_alg()
433 alg->export = ccp_sha_export; ccp_register_sha_alg()
434 alg->import = ccp_sha_import; ccp_register_sha_alg()
436 halg = &alg->halg; ccp_register_sha_alg()
455 ret = crypto_register_ahash(alg); ccp_register_sha_alg()
H A Dccp-crypto.h34 struct crypto_alg alg; member in struct:ccp_crypto_ablkcipher_alg
47 struct ahash_alg alg; member in struct:ccp_crypto_ahash_alg
53 struct crypto_alg *alg = tfm->__crt_alg; ccp_crypto_ablkcipher_alg() local
55 return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg); ccp_crypto_ablkcipher_alg()
61 struct crypto_alg *alg = tfm->__crt_alg; ccp_crypto_ahash_alg() local
64 ahash_alg = container_of(alg, struct ahash_alg, halg.base); ccp_crypto_ahash_alg()
66 return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg); ccp_crypto_ahash_alg()
H A Dccp-crypto-aes.c44 struct ccp_crypto_ablkcipher_alg *alg = ccp_aes_setkey() local
61 ctx->u.aes.mode = alg->mode; ccp_aes_setkey()
324 struct crypto_alg *alg; ccp_register_aes_alg() local
336 alg = &ccp_alg->alg; ccp_register_aes_alg()
337 *alg = *def->alg_defaults; ccp_register_aes_alg()
338 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name); ccp_register_aes_alg()
339 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", ccp_register_aes_alg()
341 alg->cra_blocksize = def->blocksize; ccp_register_aes_alg()
342 alg->cra_ablkcipher.ivsize = def->ivsize; ccp_register_aes_alg()
344 ret = crypto_register_alg(alg); ccp_register_aes_alg()
347 alg->cra_name, ret); ccp_register_aes_alg()
H A Dccp-crypto-aes-cmac.c245 struct ccp_crypto_ahash_alg *alg = ccp_aes_cmac_setkey() local
266 ctx->u.aes.mode = alg->mode; ccp_aes_cmac_setkey()
355 struct ahash_alg *alg; ccp_register_aes_cmac_algs() local
367 alg = &ccp_alg->alg; ccp_register_aes_cmac_algs()
368 alg->init = ccp_aes_cmac_init; ccp_register_aes_cmac_algs()
369 alg->update = ccp_aes_cmac_update; ccp_register_aes_cmac_algs()
370 alg->final = ccp_aes_cmac_final; ccp_register_aes_cmac_algs()
371 alg->finup = ccp_aes_cmac_finup; ccp_register_aes_cmac_algs()
372 alg->digest = ccp_aes_cmac_digest; ccp_register_aes_cmac_algs()
373 alg->export = ccp_aes_cmac_export; ccp_register_aes_cmac_algs()
374 alg->import = ccp_aes_cmac_import; ccp_register_aes_cmac_algs()
375 alg->setkey = ccp_aes_cmac_setkey; ccp_register_aes_cmac_algs()
377 halg = &alg->halg; ccp_register_aes_cmac_algs()
395 ret = crypto_register_ahash(alg); ccp_register_aes_cmac_algs()
H A Dccp-crypto-main.c353 crypto_unregister_ahash(&ahash_alg->alg); ccp_unregister_algs()
359 crypto_unregister_alg(&ablk_alg->alg); ccp_unregister_algs()
/linux-4.1.27/drivers/crypto/qce/
H A Dablkcipher.c350 struct crypto_alg *alg; qce_ablkcipher_register_one() local
357 alg = &tmpl->alg.crypto; qce_ablkcipher_register_one()
359 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name); qce_ablkcipher_register_one()
360 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", qce_ablkcipher_register_one()
363 alg->cra_blocksize = def->blocksize; qce_ablkcipher_register_one()
364 alg->cra_ablkcipher.ivsize = def->ivsize; qce_ablkcipher_register_one()
365 alg->cra_ablkcipher.min_keysize = def->min_keysize; qce_ablkcipher_register_one()
366 alg->cra_ablkcipher.max_keysize = def->max_keysize; qce_ablkcipher_register_one()
367 alg->cra_ablkcipher.setkey = qce_ablkcipher_setkey; qce_ablkcipher_register_one()
368 alg->cra_ablkcipher.encrypt = qce_ablkcipher_encrypt; qce_ablkcipher_register_one()
369 alg->cra_ablkcipher.decrypt = qce_ablkcipher_decrypt; qce_ablkcipher_register_one()
371 alg->cra_priority = 300; qce_ablkcipher_register_one()
372 alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC | qce_ablkcipher_register_one()
374 alg->cra_ctxsize = sizeof(struct qce_cipher_ctx); qce_ablkcipher_register_one()
375 alg->cra_alignmask = 0; qce_ablkcipher_register_one()
376 alg->cra_type = &crypto_ablkcipher_type; qce_ablkcipher_register_one()
377 alg->cra_module = THIS_MODULE; qce_ablkcipher_register_one()
378 alg->cra_init = qce_ablkcipher_init; qce_ablkcipher_register_one()
379 alg->cra_exit = qce_ablkcipher_exit; qce_ablkcipher_register_one()
380 INIT_LIST_HEAD(&alg->cra_list); qce_ablkcipher_register_one()
387 ret = crypto_register_alg(alg); qce_ablkcipher_register_one()
390 dev_err(qce->dev, "%s registration failed\n", alg->cra_name); qce_ablkcipher_register_one()
395 dev_dbg(qce->dev, "%s is registered\n", alg->cra_name); qce_ablkcipher_register_one()
404 crypto_unregister_alg(&tmpl->alg.crypto); qce_ablkcipher_unregister()
H A Dcipher.h62 struct crypto_alg *alg = tfm->__crt_alg; to_cipher_tmpl() local
63 return container_of(alg, struct qce_alg_template, alg.crypto); to_cipher_tmpl()
H A Dsha.h73 struct ahash_alg *alg = container_of(crypto_hash_alg_common(ahash), to_ahash_tmpl() local
76 return container_of(alg, struct qce_alg_template, alg.ahash); to_ahash_tmpl()
H A Dsha.c503 struct ahash_alg *alg; qce_ahash_register_one() local
513 alg = &tmpl->alg.ahash; qce_ahash_register_one()
514 alg->init = qce_ahash_init; qce_ahash_register_one()
515 alg->update = qce_ahash_update; qce_ahash_register_one()
516 alg->final = qce_ahash_final; qce_ahash_register_one()
517 alg->digest = qce_ahash_digest; qce_ahash_register_one()
518 alg->export = qce_ahash_export; qce_ahash_register_one()
519 alg->import = qce_ahash_import; qce_ahash_register_one()
521 alg->setkey = qce_ahash_hmac_setkey; qce_ahash_register_one()
522 alg->halg.digestsize = def->digestsize; qce_ahash_register_one()
523 alg->halg.statesize = def->statesize; qce_ahash_register_one()
525 base = &alg->halg.base; qce_ahash_register_one()
544 ret = crypto_register_ahash(alg); qce_ahash_register_one()
561 crypto_unregister_ahash(&tmpl->alg.ahash); qce_ahash_unregister()
H A Dcommon.h92 } alg; member in struct:qce_alg_template
/linux-4.1.27/drivers/crypto/
H A Dpicoxcell_crypto.c141 struct crypto_alg alg; member in struct:spacc_alg
182 static inline struct spacc_alg *to_spacc_alg(struct crypto_alg *alg) to_spacc_alg() argument
184 return alg ? container_of(alg, struct spacc_alg, alg) : NULL; to_spacc_alg()
408 struct spacc_alg *alg = to_spacc_alg(req->req->tfm->__crt_alg); spacc_aead_free_ddts() local
411 unsigned ivsize = alg->alg.cra_aead.ivsize; spacc_aead_free_ddts()
497 struct spacc_alg *alg = to_spacc_alg(tfm->base.__crt_alg); spacc_aead_setkey() local
510 if ((alg->ctrl_default & SPACC_CRYPTO_ALG_MASK) == spacc_aead_setkey()
548 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_aead_need_fallback() local
549 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_aead_need_fallback()
599 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_aead_submit() local
600 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_aead_submit()
608 ctx->cipher_key_len, aead_req->iv, alg->cra_aead.ivsize, spacc_aead_submit()
684 struct crypto_alg *alg = req->base.tfm->__crt_alg; spacc_aead_setup() local
685 struct spacc_engine *engine = to_spacc_alg(alg)->engine; spacc_aead_setup()
732 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_aead_encrypt() local
734 return spacc_aead_setup(req, NULL, alg->type, 1); spacc_aead_encrypt()
742 struct spacc_alg *alg = to_spacc_alg(tfm->base.__crt_alg); spacc_aead_givencrypt() local
755 return spacc_aead_setup(&req->areq, req->giv, alg->type, 1); spacc_aead_givencrypt()
762 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_aead_decrypt() local
764 return spacc_aead_setup(req, NULL, alg->type, 0); spacc_aead_decrypt()
774 struct crypto_alg *alg = tfm->__crt_alg; spacc_aead_cra_init() local
775 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_aead_cra_init()
780 ctx->sw_cipher = crypto_alloc_aead(alg->cra_name, 0, spacc_aead_cra_init()
785 alg->cra_name); spacc_aead_cra_init()
914 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_ablk_need_fallback() local
915 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_ablk_need_fallback()
947 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_ablk_submit() local
948 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_ablk_submit()
953 ctx->key_len, ablk_req->info, alg->cra_ablkcipher.ivsize, spacc_ablk_submit()
1003 struct crypto_alg *alg = req->base.tfm->__crt_alg; spacc_ablk_setup() local
1004 struct spacc_engine *engine = to_spacc_alg(alg)->engine; spacc_ablk_setup()
1080 struct crypto_alg *alg = tfm->__crt_alg; spacc_ablk_cra_init() local
1081 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_ablk_cra_init()
1086 if (alg->cra_flags & CRYPTO_ALG_NEED_FALLBACK) { spacc_ablk_cra_init()
1087 ctx->sw_cipher = crypto_alloc_ablkcipher(alg->cra_name, 0, spacc_ablk_cra_init()
1091 alg->cra_name); spacc_ablk_cra_init()
1116 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_ablk_encrypt() local
1118 return spacc_ablk_setup(req, alg->type, 1); spacc_ablk_encrypt()
1125 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_ablk_decrypt() local
1127 return spacc_ablk_setup(req, alg->type, 0); spacc_ablk_decrypt()
1204 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_req_submit() local
1206 if (CRYPTO_ALG_TYPE_AEAD == (CRYPTO_ALG_TYPE_MASK & alg->cra_flags)) spacc_req_submit()
1304 .alg = {
1332 .alg = {
1358 .alg = {
1385 .alg = {
1411 .alg = {
1438 .alg = {
1465 .alg = {
1495 .alg = {
1524 .alg = {
1553 .alg = {
1583 .alg = {
1612 .alg = {
1644 .alg = {
1803 err = crypto_register_alg(&engine->algs[i].alg); spacc_probe()
1810 dev_err(engine->dev, "failed to register alg \"%s\"\n", spacc_probe()
1811 engine->algs[i].alg.cra_name); spacc_probe()
1813 dev_dbg(engine->dev, "registered alg \"%s\"\n", spacc_probe()
1814 engine->algs[i].alg.cra_name); spacc_probe()
1822 struct spacc_alg *alg, *next; spacc_remove() local
1828 list_for_each_entry_safe(alg, next, &engine->registered_algs, entry) { spacc_remove()
1829 list_del(&alg->entry); spacc_remove()
1830 crypto_unregister_alg(&alg->alg); spacc_remove()
H A Dn2_core.c250 struct ahash_alg alg; member in struct:n2_ahash_alg
255 struct crypto_alg *alg = tfm->__crt_alg; n2_ahash_alg() local
258 ahash_alg = container_of(alg, struct ahash_alg, halg.base); n2_ahash_alg()
260 return container_of(ahash_alg, struct n2_ahash_alg, alg); n2_ahash_alg()
270 struct crypto_alg *alg = tfm->__crt_alg; n2_hmac_alg() local
273 ahash_alg = container_of(alg, struct ahash_alg, halg.base); n2_hmac_alg()
275 return container_of(ahash_alg, struct n2_hmac_alg, derived.alg); n2_hmac_alg()
700 struct crypto_alg alg; member in struct:n2_cipher_alg
705 struct crypto_alg *alg = tfm->__crt_alg; n2_cipher_alg() local
707 return container_of(alg, struct n2_cipher_alg, alg); n2_cipher_alg()
1362 struct n2_ahash_alg *alg, *alg_tmp; __n2_unregister_algs() local
1366 crypto_unregister_alg(&cipher->alg); __n2_unregister_algs()
1371 crypto_unregister_ahash(&hmac->derived.alg); __n2_unregister_algs()
1375 list_for_each_entry_safe(alg, alg_tmp, &ahash_algs, entry) { __n2_unregister_algs()
1376 crypto_unregister_ahash(&alg->alg); __n2_unregister_algs()
1377 list_del(&alg->entry); __n2_unregister_algs()
1378 kfree(alg); __n2_unregister_algs()
1391 struct crypto_alg *alg; __n2_register_one_cipher() local
1397 alg = &p->alg; __n2_register_one_cipher()
1399 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", tmpl->name); __n2_register_one_cipher()
1400 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-n2", tmpl->drv_name); __n2_register_one_cipher()
1401 alg->cra_priority = N2_CRA_PRIORITY; __n2_register_one_cipher()
1402 alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | __n2_register_one_cipher()
1404 alg->cra_blocksize = tmpl->block_size; __n2_register_one_cipher()
1406 alg->cra_ctxsize = sizeof(struct n2_cipher_context); __n2_register_one_cipher()
1407 alg->cra_type = &crypto_ablkcipher_type; __n2_register_one_cipher()
1408 alg->cra_u.ablkcipher = tmpl->ablkcipher; __n2_register_one_cipher()
1409 alg->cra_init = n2_cipher_cra_init; __n2_register_one_cipher()
1410 alg->cra_module = THIS_MODULE; __n2_register_one_cipher()
1413 err = crypto_register_alg(alg); __n2_register_one_cipher()
1415 pr_err("%s alg registration failed\n", alg->cra_name); __n2_register_one_cipher()
1419 pr_info("%s alg registered\n", alg->cra_name); __n2_register_one_cipher()
1434 p->child_alg = n2ahash->alg.halg.base.cra_name; __n2_register_one_hmac()
1438 ahash = &p->derived.alg; __n2_register_one_hmac()
1453 pr_err("%s alg registration failed\n", base->cra_name); __n2_register_one_hmac()
1457 pr_info("%s alg registered\n", base->cra_name); __n2_register_one_hmac()
1480 ahash = &p->alg; __n2_register_one_ahash()
1506 pr_err("%s alg registration failed\n", base->cra_name); __n2_register_one_ahash()
1510 pr_info("%s alg registered\n", base->cra_name); __n2_register_one_ahash()
H A Dtalitos.c634 * crypto alg
1914 } alg; member in struct:talitos_alg_template
1921 .alg.crypto = {
1940 .alg.crypto = {
1960 .alg.crypto = {
1979 .alg.crypto = {
1999 .alg.crypto = {
2018 .alg.crypto = {
2038 .alg.crypto = {
2057 .alg.crypto = {
2077 .alg.crypto = {
2096 .alg.crypto = {
2116 .alg.crypto = {
2135 .alg.crypto = {
2156 .alg.crypto = {
2173 .alg.crypto = {
2192 .alg.hash = {
2207 .alg.hash = {
2222 .alg.hash = {
2237 .alg.hash = {
2252 .alg.hash = {
2267 .alg.hash = {
2282 .alg.hash = {
2297 .alg.hash = {
2312 .alg.hash = {
2327 .alg.hash = {
2342 .alg.hash = {
2357 .alg.hash = {
2381 struct crypto_alg *alg = tfm->__crt_alg; talitos_cra_init() local
2386 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH) talitos_cra_init()
2387 talitos_alg = container_of(__crypto_ahash_alg(alg), talitos_cra_init()
2389 algt.alg.hash); talitos_cra_init()
2391 talitos_alg = container_of(alg, struct talitos_crypto_alg, talitos_cra_init()
2392 algt.alg.crypto); talitos_cra_init()
2437 * given the alg's descriptor header template, determine whether descriptor
2467 crypto_unregister_alg(&t_alg->algt.alg.crypto); talitos_remove()
2470 crypto_unregister_ahash(&t_alg->algt.alg.hash); talitos_remove()
2508 struct crypto_alg *alg; talitos_alg_alloc() local
2518 alg = &t_alg->algt.alg.crypto; talitos_alg_alloc()
2519 alg->cra_init = talitos_cra_init; talitos_alg_alloc()
2520 alg->cra_type = &crypto_ablkcipher_type; talitos_alg_alloc()
2521 alg->cra_ablkcipher.setkey = ablkcipher_setkey; talitos_alg_alloc()
2522 alg->cra_ablkcipher.encrypt = ablkcipher_encrypt; talitos_alg_alloc()
2523 alg->cra_ablkcipher.decrypt = ablkcipher_decrypt; talitos_alg_alloc()
2524 alg->cra_ablkcipher.geniv = "eseqiv"; talitos_alg_alloc()
2527 alg = &t_alg->algt.alg.crypto; talitos_alg_alloc()
2528 alg->cra_init = talitos_cra_init_aead; talitos_alg_alloc()
2529 alg->cra_type = &crypto_aead_type; talitos_alg_alloc()
2530 alg->cra_aead.setkey = aead_setkey; talitos_alg_alloc()
2531 alg->cra_aead.setauthsize = aead_setauthsize; talitos_alg_alloc()
2532 alg->cra_aead.encrypt = aead_encrypt; talitos_alg_alloc()
2533 alg->cra_aead.decrypt = aead_decrypt; talitos_alg_alloc()
2534 alg->cra_aead.givencrypt = aead_givencrypt; talitos_alg_alloc()
2535 alg->cra_aead.geniv = "<built-in>"; talitos_alg_alloc()
2538 alg = &t_alg->algt.alg.hash.halg.base; talitos_alg_alloc()
2539 alg->cra_init = talitos_cra_init_ahash; talitos_alg_alloc()
2540 alg->cra_type = &crypto_ahash_type; talitos_alg_alloc()
2541 t_alg->algt.alg.hash.init = ahash_init; talitos_alg_alloc()
2542 t_alg->algt.alg.hash.update = ahash_update; talitos_alg_alloc()
2543 t_alg->algt.alg.hash.final = ahash_final; talitos_alg_alloc()
2544 t_alg->algt.alg.hash.finup = ahash_finup; talitos_alg_alloc()
2545 t_alg->algt.alg.hash.digest = ahash_digest; talitos_alg_alloc()
2546 t_alg->algt.alg.hash.setkey = ahash_setkey; talitos_alg_alloc()
2549 !strncmp(alg->cra_name, "hmac", 4)) { talitos_alg_alloc()
2554 (!strcmp(alg->cra_name, "sha224") || talitos_alg_alloc()
2555 !strcmp(alg->cra_name, "hmac(sha224)"))) { talitos_alg_alloc()
2556 t_alg->algt.alg.hash.init = ahash_init_sha224_swinit; talitos_alg_alloc()
2569 alg->cra_module = THIS_MODULE; talitos_alg_alloc()
2570 alg->cra_priority = TALITOS_CRA_PRIORITY; talitos_alg_alloc()
2571 alg->cra_alignmask = 0; talitos_alg_alloc()
2572 alg->cra_ctxsize = sizeof(struct talitos_ctx); talitos_alg_alloc()
2573 alg->cra_flags |= CRYPTO_ALG_KERN_DRIVER_ONLY; talitos_alg_alloc()
2768 &t_alg->algt.alg.crypto); talitos_probe()
2769 name = t_alg->algt.alg.crypto.cra_driver_name; talitos_probe()
2773 &t_alg->algt.alg.hash); talitos_probe()
2775 t_alg->algt.alg.hash.halg.base.cra_driver_name; talitos_probe()
2779 dev_err(dev, "%s alg registration failed\n", talitos_probe()
H A Dhifn_795x.c633 struct crypto_alg alg; member in struct:hifn_crypto_alg
663 #define crypto_alg_to_hifn(a) container_of(a, struct hifn_crypto_alg, alg)
2474 struct crypto_alg *alg = tfm->__crt_alg; hifn_cra_init() local
2475 struct hifn_crypto_alg *ha = crypto_alg_to_hifn(alg); hifn_cra_init()
2485 struct hifn_crypto_alg *alg; hifn_alg_alloc() local
2488 alg = kzalloc(sizeof(struct hifn_crypto_alg), GFP_KERNEL); hifn_alg_alloc()
2489 if (!alg) hifn_alg_alloc()
2492 snprintf(alg->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s", t->name); hifn_alg_alloc()
2493 snprintf(alg->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-%s", hifn_alg_alloc()
2496 alg->alg.cra_priority = 300; hifn_alg_alloc()
2497 alg->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | hifn_alg_alloc()
2499 alg->alg.cra_blocksize = t->bsize; hifn_alg_alloc()
2500 alg->alg.cra_ctxsize = sizeof(struct hifn_context); hifn_alg_alloc()
2501 alg->alg.cra_alignmask = 0; hifn_alg_alloc()
2502 alg->alg.cra_type = &crypto_ablkcipher_type; hifn_alg_alloc()
2503 alg->alg.cra_module = THIS_MODULE; hifn_alg_alloc()
2504 alg->alg.cra_u.ablkcipher = t->ablkcipher; hifn_alg_alloc()
2505 alg->alg.cra_init = hifn_cra_init; hifn_alg_alloc()
2507 alg->dev = dev; hifn_alg_alloc()
2509 list_add_tail(&alg->entry, &dev->alg_list); hifn_alg_alloc()
2511 err = crypto_register_alg(&alg->alg); hifn_alg_alloc()
2513 list_del(&alg->entry); hifn_alg_alloc()
2514 kfree(alg); hifn_alg_alloc()
2526 crypto_unregister_alg(&a->alg); hifn_unregister_alg()
H A Dmxs-dcp.c83 uint32_t alg; member in struct:dcp_async_ctx
532 desc->control1 = actx->alg; mxs_dcp_run_sha()
690 actx->alg = MXS_DCP_CONTROL1_HASH_SELECT_SHA1; dcp_sha_init()
692 actx->alg = MXS_DCP_CONTROL1_HASH_SELECT_SHA256; dcp_sha_init()
/linux-4.1.27/net/ceph/crush/
H A Dcrush.c13 const char *crush_bucket_alg_name(int alg) crush_bucket_alg_name() argument
15 switch (alg) { crush_bucket_alg_name()
35 switch (b->alg) { crush_get_bucket_item_weight()
93 switch (b->alg) { crush_destroy_bucket()
H A Dmapper.c341 switch (in->alg) { crush_bucket_choose()
358 dprintk("unknown bucket %d alg %d\n", in->id, in->alg); crush_bucket_choose()
632 if (in->alg == CRUSH_BUCKET_UNIFORM && crush_choose_indep()
/linux-4.1.27/arch/arm/crypto/
H A Dsha1-ce-glue.c66 static struct shash_alg alg = { variable in typeref:struct:shash_alg
87 return crypto_register_shash(&alg); sha1_ce_mod_init()
92 crypto_unregister_shash(&alg); sha1_ce_mod_fini()
H A Dsha1_glue.c59 static struct shash_alg alg = { variable in typeref:struct:shash_alg
79 return crypto_register_shash(&alg); sha1_mod_init()
85 crypto_unregister_shash(&alg); sha1_mod_fini()
H A Dsha1_neon_glue.c75 static struct shash_alg alg = { variable in typeref:struct:shash_alg
97 return crypto_register_shash(&alg); sha1_neon_mod_init()
102 crypto_unregister_shash(&alg); sha1_neon_mod_fini()
/linux-4.1.27/drivers/net/wireless/ipw2x00/
H A Dlibipw_wx.c527 const char *alg, *module; libipw_wx_set_encodeext() local
548 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) libipw_wx_set_encodeext()
558 ext->alg == IW_ENCODE_ALG_NONE) { libipw_wx_set_encodeext()
583 switch (ext->alg) { libipw_wx_set_encodeext()
585 alg = "WEP"; libipw_wx_set_encodeext()
589 alg = "TKIP"; libipw_wx_set_encodeext()
593 alg = "CCMP"; libipw_wx_set_encodeext()
597 LIBIPW_DEBUG_WX("%s: unknown crypto alg %d\n", libipw_wx_set_encodeext()
598 dev->name, ext->alg); libipw_wx_set_encodeext()
603 ops = lib80211_get_crypto_ops(alg); libipw_wx_set_encodeext()
606 ops = lib80211_get_crypto_ops(alg); libipw_wx_set_encodeext()
609 LIBIPW_DEBUG_WX("%s: unknown crypto alg %d\n", libipw_wx_set_encodeext()
610 dev->name, ext->alg); libipw_wx_set_encodeext()
651 if (ext->alg != IW_ENCODE_ALG_NONE) { libipw_wx_set_encodeext()
655 if (ext->alg == IW_ENCODE_ALG_WEP) { libipw_wx_set_encodeext()
659 } else if (ext->alg == IW_ENCODE_ALG_TKIP) { libipw_wx_set_encodeext()
663 } else if (ext->alg == IW_ENCODE_ALG_CCMP) { libipw_wx_set_encodeext()
701 ext->alg != IW_ENCODE_ALG_WEP) libipw_wx_get_encodeext()
709 ext->alg = IW_ENCODE_ALG_NONE; libipw_wx_get_encodeext()
714 ext->alg = IW_ENCODE_ALG_WEP; libipw_wx_get_encodeext()
716 ext->alg = IW_ENCODE_ALG_TKIP; libipw_wx_get_encodeext()
718 ext->alg = IW_ENCODE_ALG_CCMP; libipw_wx_get_encodeext()
726 (ext->alg == IW_ENCODE_ALG_TKIP || libipw_wx_get_encodeext()
727 ext->alg == IW_ENCODE_ALG_CCMP)) libipw_wx_get_encodeext()
/linux-4.1.27/arch/s390/crypto/
H A Dsha1_s390.c72 static struct shash_alg alg = { variable in typeref:struct:shash_alg
95 return crypto_register_shash(&alg); sha1_s390_init()
100 crypto_unregister_shash(&alg); sha1_s390_fini()
/linux-4.1.27/arch/arm64/crypto/
H A Dsha1-ce-glue.c86 static struct shash_alg alg = { variable in typeref:struct:shash_alg
105 return crypto_register_shash(&alg); sha1_ce_mod_init()
110 crypto_unregister_shash(&alg); sha1_ce_mod_fini()
/linux-4.1.27/include/crypto/
H A Dalgapi.h25 unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask);
26 unsigned int (*extsize)(struct crypto_alg *alg);
29 void (*show)(struct seq_file *m, struct crypto_alg *alg);
30 int (*report)(struct sk_buff *skb, struct crypto_alg *alg);
40 struct crypto_alg alg; member in struct:crypto_instance
62 struct crypto_alg *alg; member in struct:crypto_spawn
132 void crypto_mod_put(struct crypto_alg *alg);
142 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
144 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
173 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg,
176 struct crypto_alg *alg);
218 return container_of(tfm->__crt_alg, struct crypto_instance, alg); crypto_tfm_alg_instance()
H A Dcompress.h89 static inline struct pcomp_alg *__crypto_pcomp_alg(struct crypto_alg *alg) __crypto_pcomp_alg() argument
91 return container_of(alg, struct pcomp_alg, base); __crypto_pcomp_alg()
H A Dhash.h264 struct crypto_alg *alg) __crypto_hash_alg_common()
266 return container_of(alg, struct hash_alg_common, base); __crypto_hash_alg_common()
661 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg) __crypto_shash_alg() argument
663 return container_of(alg, struct shash_alg, base); __crypto_shash_alg()
716 * sizeof(struct shash_desc) + crypto_shash_descsize(alg)
263 __crypto_hash_alg_common( struct crypto_alg *alg) __crypto_hash_alg_common() argument
/linux-4.1.27/drivers/crypto/vmx/
H A Daes.c40 const char *alg; p8_aes_init() local
44 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_aes_init()
49 fallback = crypto_alloc_cipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_aes_init()
52 alg, PTR_ERR(fallback)); p8_aes_init()
H A Daes_cbc.c41 const char *alg; p8_aes_cbc_init() local
45 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_aes_cbc_init()
50 fallback = crypto_alloc_blkcipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_aes_cbc_init()
53 alg, PTR_ERR(fallback)); p8_aes_cbc_init()
H A Daes_ctr.c39 const char *alg; p8_aes_ctr_init() local
43 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_aes_ctr_init()
48 fallback = crypto_alloc_blkcipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_aes_ctr_init()
51 alg, PTR_ERR(fallback)); p8_aes_ctr_init()
H A Dghash.c58 const char *alg; p8_ghash_init_tfm() local
63 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_ghash_init_tfm()
68 fallback = crypto_alloc_shash(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_ghash_init_tfm()
71 alg, PTR_ERR(fallback)); p8_ghash_init_tfm()
/linux-4.1.27/sound/soc/codecs/
H A Dwmfw.h81 struct wmfw_alg_hdr alg; member in struct:wmfw_adsp1_alg_hdr
87 struct wmfw_alg_hdr alg; member in struct:wmfw_adsp2_alg_hdr
H A Dwm_adsp.c817 dsp->num, region_name, region->alg); wm_adsp_create_control()
886 void *alg, *buf; wm_adsp_setup_algs() local
935 region->alg = be32_to_cpu(adsp1_id.fw.id); wm_adsp_setup_algs()
943 region->alg = be32_to_cpu(adsp1_id.fw.id); wm_adsp_setup_algs()
976 region->alg = be32_to_cpu(adsp2_id.fw.id); wm_adsp_setup_algs()
984 region->alg = be32_to_cpu(adsp2_id.fw.id); wm_adsp_setup_algs()
992 region->alg = be32_to_cpu(adsp2_id.fw.id); wm_adsp_setup_algs()
1029 alg = kzalloc((term - pos) * 2, GFP_KERNEL | GFP_DMA); wm_adsp_setup_algs()
1030 if (!alg) wm_adsp_setup_algs()
1033 ret = regmap_raw_read(regmap, mem->base + pos, alg, (term - pos) * 2); wm_adsp_setup_algs()
1040 adsp1_alg = alg; wm_adsp_setup_algs()
1041 adsp2_alg = alg; wm_adsp_setup_algs()
1047 i, be32_to_cpu(adsp1_alg[i].alg.id), wm_adsp_setup_algs()
1048 (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff0000) >> 16, wm_adsp_setup_algs()
1049 (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff00) >> 8, wm_adsp_setup_algs()
1050 be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff, wm_adsp_setup_algs()
1060 region->alg = be32_to_cpu(adsp1_alg[i].alg.id); wm_adsp_setup_algs()
1071 be32_to_cpu(adsp1_alg[i].alg.id)); wm_adsp_setup_algs()
1080 region->alg = be32_to_cpu(adsp1_alg[i].alg.id); wm_adsp_setup_algs()
1091 be32_to_cpu(adsp1_alg[i].alg.id)); wm_adsp_setup_algs()
1098 i, be32_to_cpu(adsp2_alg[i].alg.id), wm_adsp_setup_algs()
1099 (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff0000) >> 16, wm_adsp_setup_algs()
1100 (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff00) >> 8, wm_adsp_setup_algs()
1101 be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff, wm_adsp_setup_algs()
1112 region->alg = be32_to_cpu(adsp2_alg[i].alg.id); wm_adsp_setup_algs()
1123 be32_to_cpu(adsp2_alg[i].alg.id)); wm_adsp_setup_algs()
1132 region->alg = be32_to_cpu(adsp2_alg[i].alg.id); wm_adsp_setup_algs()
1143 be32_to_cpu(adsp2_alg[i].alg.id)); wm_adsp_setup_algs()
1152 region->alg = be32_to_cpu(adsp2_alg[i].alg.id); wm_adsp_setup_algs()
1163 be32_to_cpu(adsp2_alg[i].alg.id)); wm_adsp_setup_algs()
1170 kfree(alg); wm_adsp_setup_algs()
1293 if (le32_to_cpu(blk->id) == alg_region->alg && wm_adsp_load_coeff()
H A Dwm_adsp.h30 unsigned int alg; member in struct:wm_adsp_alg_region
/linux-4.1.27/net/mac80211/
H A Drate.c34 struct rate_control_alg *alg; ieee80211_rate_control_register() local
40 list_for_each_entry(alg, &rate_ctrl_algs, list) { ieee80211_rate_control_register()
41 if (!strcmp(alg->ops->name, ops->name)) { ieee80211_rate_control_register()
49 alg = kzalloc(sizeof(*alg), GFP_KERNEL); ieee80211_rate_control_register()
50 if (alg == NULL) { ieee80211_rate_control_register()
54 alg->ops = ops; ieee80211_rate_control_register()
56 list_add_tail(&alg->list, &rate_ctrl_algs); ieee80211_rate_control_register()
65 struct rate_control_alg *alg; ieee80211_rate_control_unregister() local
68 list_for_each_entry(alg, &rate_ctrl_algs, list) { ieee80211_rate_control_unregister()
69 if (alg->ops == ops) { ieee80211_rate_control_unregister()
70 list_del(&alg->list); ieee80211_rate_control_unregister()
71 kfree(alg); ieee80211_rate_control_unregister()
82 struct rate_control_alg *alg; ieee80211_try_rate_control_ops_get() local
89 list_for_each_entry(alg, &rate_ctrl_algs, list) { ieee80211_try_rate_control_ops_get()
90 if (!strcmp(alg->ops->name, name)) { ieee80211_try_rate_control_ops_get()
91 ops = alg->ops; ieee80211_try_rate_control_ops_get()
114 /* try default if specific alg requested but not found */ ieee80211_rate_control_ops_get()
117 /* try built-in one if specific alg requested but not found */ ieee80211_rate_control_ops_get()
/linux-4.1.27/drivers/crypto/amcc/
H A Dcrypto4xx_core.c994 struct crypto_alg *alg = tfm->__crt_alg; crypto4xx_alg_init() local
995 struct crypto4xx_alg *amcc_alg = crypto_alg_to_crypto4xx_alg(alg); crypto4xx_alg_init()
1005 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) { crypto4xx_alg_init()
1030 struct crypto4xx_alg *alg; crypto4xx_register_alg() local
1035 alg = kzalloc(sizeof(struct crypto4xx_alg), GFP_KERNEL); crypto4xx_register_alg()
1036 if (!alg) crypto4xx_register_alg()
1039 alg->alg = crypto_alg[i]; crypto4xx_register_alg()
1040 alg->dev = sec_dev; crypto4xx_register_alg()
1042 switch (alg->alg.type) { crypto4xx_register_alg()
1044 rc = crypto_register_ahash(&alg->alg.u.hash); crypto4xx_register_alg()
1048 rc = crypto_register_alg(&alg->alg.u.cipher); crypto4xx_register_alg()
1053 list_del(&alg->entry); crypto4xx_register_alg()
1054 kfree(alg); crypto4xx_register_alg()
1056 list_add_tail(&alg->entry, &sec_dev->alg_list); crypto4xx_register_alg()
1065 struct crypto4xx_alg *alg, *tmp; crypto4xx_unregister_alg() local
1067 list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) { crypto4xx_unregister_alg()
1068 list_del(&alg->entry); crypto4xx_unregister_alg()
1069 switch (alg->alg.type) { crypto4xx_unregister_alg()
1071 crypto_unregister_ahash(&alg->alg.u.hash); crypto4xx_unregister_alg()
1075 crypto_unregister_alg(&alg->alg.u.cipher); crypto4xx_unregister_alg()
1077 kfree(alg); crypto4xx_unregister_alg()
H A Dcrypto4xx_core.h153 struct crypto4xx_alg_common alg; member in struct:crypto4xx_alg
163 struct crypto4xx_alg, alg.u.hash); crypto_alg_to_crypto4xx_alg()
166 return container_of(x, struct crypto4xx_alg, alg.u.cipher); crypto_alg_to_crypto4xx_alg()
H A Dcrypto4xx_alg.c185 struct crypto_alg *alg = tfm->__crt_alg; crypto4xx_hash_alg_init() local
186 struct crypto4xx_alg *my_alg = crypto_alg_to_crypto4xx_alg(alg); crypto4xx_hash_alg_init()
/linux-4.1.27/drivers/staging/lustre/lustre/obdclass/
H A Dcapa.c262 struct capa_hmac_alg *alg; capa_hmac() local
271 alg = &capa_hmac_algs[capa_alg(capa)]; capa_hmac()
273 tfm = crypto_alloc_hash(alg->ha_name, 0, 0); capa_hmac()
278 keylen = alg->ha_keylen; capa_hmac()
300 char alg[CRYPTO_MAX_ALG_NAME+1] = "aes"; capa_encrypt_id() local
304 tfm = crypto_alloc_blkcipher(alg, 0, 0); capa_encrypt_id()
353 char alg[CRYPTO_MAX_ALG_NAME+1] = "aes"; capa_decrypt_id() local
357 tfm = crypto_alloc_blkcipher(alg, 0, 0); capa_decrypt_id()
414 " capability@%p fid " DFID " opc %#llx uid %llu gid %llu flags %u alg %d keyid %u timeout %u expiry %u\n", _debug_capa()
/linux-4.1.27/drivers/staging/lustre/lustre/libcfs/linux/
H A Dlinux-crypto-adler.c112 static struct shash_alg alg = { variable in typeref:struct:shash_alg
135 return crypto_register_shash(&alg); cfs_crypto_adler32_register()
140 crypto_unregister_shash(&alg); cfs_crypto_adler32_unregister()
/linux-4.1.27/arch/sparc/crypto/
H A Dcrc32c_glue.c123 static struct shash_alg alg = { variable in typeref:struct:shash_alg
162 return crypto_register_shash(&alg); crc32c_sparc64_mod_init()
170 crypto_unregister_shash(&alg); crc32c_sparc64_mod_fini()
H A Dmd5_glue.c134 static struct shash_alg alg = { variable in typeref:struct:shash_alg
171 return crypto_register_shash(&alg); md5_sparc64_mod_init()
179 crypto_unregister_shash(&alg); md5_sparc64_mod_fini()
H A Dsha1_glue.c129 static struct shash_alg alg = { variable in typeref:struct:shash_alg
166 return crypto_register_shash(&alg); sha1_sparc64_mod_init()
174 crypto_unregister_shash(&alg); sha1_sparc64_mod_fini()
/linux-4.1.27/arch/powerpc/crypto/
H A Dmd5-glue.c129 static struct shash_alg alg = { variable in typeref:struct:shash_alg
150 return crypto_register_shash(&alg); ppc_md5_mod_init()
155 crypto_unregister_shash(&alg); ppc_md5_mod_fini()
H A Dsha1.c123 static struct shash_alg alg = { variable in typeref:struct:shash_alg
143 return crypto_register_shash(&alg); sha1_powerpc_mod_init()
148 crypto_unregister_shash(&alg); sha1_powerpc_mod_fini()
H A Dsha1-spe-glue.c174 static struct shash_alg alg = { variable in typeref:struct:shash_alg
195 return crypto_register_shash(&alg); ppc_spe_sha1_mod_init()
200 crypto_unregister_shash(&alg); ppc_spe_sha1_mod_fini()
/linux-4.1.27/drivers/crypto/qat/qat_common/
H A Dqat_algs.c66 #define QAT_AES_HW_CONFIG_CBC_ENC(alg) \
67 ICP_QAT_HW_CIPHER_CONFIG_BUILD(ICP_QAT_HW_CIPHER_CBC_MODE, alg, \
71 #define QAT_AES_HW_CONFIG_CBC_DEC(alg) \
72 ICP_QAT_HW_CIPHER_CONFIG_BUILD(ICP_QAT_HW_CIPHER_CBC_MODE, alg, \
282 int alg, qat_alg_aead_init_enc_session()
300 cipher->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_ENC(alg); qat_alg_aead_init_enc_session()
362 int alg, qat_alg_aead_init_dec_session()
385 cipher->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_DEC(alg); qat_alg_aead_init_dec_session()
475 int alg, const uint8_t *key, qat_alg_ablkcipher_init_enc()
484 enc_cd->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_ENC(alg); qat_alg_ablkcipher_init_enc()
488 int alg, const uint8_t *key, qat_alg_ablkcipher_init_dec()
497 dec_cd->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_DEC(alg); qat_alg_ablkcipher_init_dec()
500 static int qat_alg_validate_key(int key_len, int *alg) qat_alg_validate_key() argument
504 *alg = ICP_QAT_HW_CIPHER_ALGO_AES128; qat_alg_validate_key()
507 *alg = ICP_QAT_HW_CIPHER_ALGO_AES192; qat_alg_validate_key()
510 *alg = ICP_QAT_HW_CIPHER_ALGO_AES256; qat_alg_validate_key()
522 int alg; qat_alg_aead_init_sessions() local
530 if (qat_alg_validate_key(keys.enckeylen, &alg)) qat_alg_aead_init_sessions()
533 if (qat_alg_aead_init_enc_session(ctx, alg, &keys)) qat_alg_aead_init_sessions()
536 if (qat_alg_aead_init_dec_session(ctx, alg, &keys)) qat_alg_aead_init_sessions()
551 int alg; qat_alg_ablkcipher_init_sessions() local
553 if (qat_alg_validate_key(keylen, &alg)) qat_alg_ablkcipher_init_sessions()
556 qat_alg_ablkcipher_init_enc(ctx, alg, key, keylen); qat_alg_ablkcipher_init_sessions()
557 qat_alg_ablkcipher_init_dec(ctx, alg, key, keylen); qat_alg_ablkcipher_init_sessions()
281 qat_alg_aead_init_enc_session(struct qat_alg_aead_ctx *ctx, int alg, struct crypto_authenc_keys *keys) qat_alg_aead_init_enc_session() argument
361 qat_alg_aead_init_dec_session(struct qat_alg_aead_ctx *ctx, int alg, struct crypto_authenc_keys *keys) qat_alg_aead_init_dec_session() argument
474 qat_alg_ablkcipher_init_enc(struct qat_alg_ablkcipher_ctx *ctx, int alg, const uint8_t *key, unsigned int keylen) qat_alg_ablkcipher_init_enc() argument
487 qat_alg_ablkcipher_init_dec(struct qat_alg_ablkcipher_ctx *ctx, int alg, const uint8_t *key, unsigned int keylen) qat_alg_ablkcipher_init_dec() argument
/linux-4.1.27/drivers/staging/rtl8192u/
H A Dr8192U_wx.c756 u8 idx = 0, alg = 0, group = 0; r8192_wx_set_enc_ext() local
758 if ((encoding->flags & IW_ENCODE_DISABLED) || ext->alg == IW_ENCODE_ALG_NONE) r8192_wx_set_enc_ext()
763 alg = (ext->alg == IW_ENCODE_ALG_CCMP)?KEY_TYPE_CCMP:ext->alg; r8192_wx_set_enc_ext()
769 if ((!group) || (IW_MODE_ADHOC == ieee->iw_mode) || (alg == KEY_TYPE_WEP40)) { r8192_wx_set_enc_ext()
770 if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40)) r8192_wx_set_enc_ext()
771 alg = KEY_TYPE_WEP104; r8192_wx_set_enc_ext()
772 ieee->pairwise_key_type = alg; r8192_wx_set_enc_ext()
777 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) { r8192_wx_set_enc_ext()
782 alg, /* KeyType */ r8192_wx_set_enc_ext()
787 ieee->group_key_type = alg; r8192_wx_set_enc_ext()
791 alg, /* KeyType */ r8192_wx_set_enc_ext()
799 alg, /* KeyType */ r8192_wx_set_enc_ext()
H A Dr8192U_core.c3479 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) { rtl8192_ioctl()
3481 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) { rtl8192_ioctl()
3483 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl()
3503 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) { rtl8192_ioctl()
3505 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) { rtl8192_ioctl()
3507 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl()
/linux-4.1.27/arch/mips/cavium-octeon/crypto/
H A Docteon-md5.c172 static struct shash_alg alg = { variable in typeref:struct:shash_alg
195 return crypto_register_shash(&alg); md5_mod_init()
200 crypto_unregister_shash(&alg); md5_mod_fini()
/linux-4.1.27/drivers/staging/rtl8192e/rtl8192e/
H A Drtl_wx.c995 u8 idx = 0, alg = 0, group = 0; r8192_wx_set_enc_ext() local
998 ext->alg == IW_ENCODE_ALG_NONE) { r8192_wx_set_enc_ext()
1006 alg = (ext->alg == IW_ENCODE_ALG_CCMP) ? KEY_TYPE_CCMP : r8192_wx_set_enc_ext()
1007 ext->alg; r8192_wx_set_enc_ext()
1014 (alg == KEY_TYPE_WEP40)) { r8192_wx_set_enc_ext()
1015 if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40)) r8192_wx_set_enc_ext()
1016 alg = KEY_TYPE_WEP104; r8192_wx_set_enc_ext()
1017 ieee->pairwise_key_type = alg; r8192_wx_set_enc_ext()
1022 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) { r8192_wx_set_enc_ext()
1024 ieee->pairwise_key_type = alg = KEY_TYPE_WEP104; r8192_wx_set_enc_ext()
1025 setKey(dev, idx, idx, alg, zero, 0, key); r8192_wx_set_enc_ext()
1026 set_swcam(dev, idx, idx, alg, zero, 0, key, 0); r8192_wx_set_enc_ext()
1028 ieee->group_key_type = alg; r8192_wx_set_enc_ext()
1029 setKey(dev, idx, idx, alg, broadcast_addr, 0, key); r8192_wx_set_enc_ext()
1030 set_swcam(dev, idx, idx, alg, broadcast_addr, 0, r8192_wx_set_enc_ext()
1036 setKey(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, r8192_wx_set_enc_ext()
1038 set_swcam(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, r8192_wx_set_enc_ext()
H A Drtl_crypto.h122 int crypto_register_alg(struct crypto_alg *alg);
123 int crypto_unregister_alg(struct crypto_alg *alg);
225 struct crypto_alg *alg = tfm->__crt_alg; crypto_tfm_alg_modname() local
227 if (alg->cra_module) crypto_tfm_alg_modname()
228 return alg->cra_module->name; crypto_tfm_alg_modname()
H A Drtl_core.c2597 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) rtl8192_ioctl()
2599 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) rtl8192_ioctl()
2601 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl()
2645 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) rtl8192_ioctl()
2647 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) rtl8192_ioctl()
2649 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl()
/linux-4.1.27/arch/cris/include/arch-v32/arch/
H A Dcryptocop.h34 cryptocop_algorithm alg; member in struct:cryptocop_transform_init
40 cryptocop_csum_type csum_mode; /* cryptocop_csum_none is not allowed when alg==cryptocop_alg_csum */
/linux-4.1.27/drivers/staging/lustre/include/linux/libcfs/
H A Dlibcfs_crypto.h112 * @param alg id of hash algorithm
129 int cfs_crypto_hash_digest(unsigned char alg,
138 * @param alg algorithm id
146 cfs_crypto_hash_init(unsigned char alg,
/linux-4.1.27/arch/s390/kernel/vdso64/
H A Dgettimeofday.S36 alg %r1,__VDSO_XTIME_NSEC(%r5) /* + tk->xtime_nsec */
H A Dclock_gettime.S45 alg %r1,__VDSO_WTOM_NSEC(%r5)
90 alg %r1,__VDSO_XTIME_NSEC(%r5) /* + tk->xtime_nsec */
/linux-4.1.27/drivers/staging/media/davinci_vpfe/
H A Ddm365_ipipe.h49 enum vpfe_ipipe_otfdpc_alg alg; member in struct:ipipe_otfdpc_2_0
61 enum vpfe_ipipe_otfdpc_alg alg; member in struct:ipipe_otfdpc_3_0
H A Ddavinci_vpfe_user.h665 /* defect detection threshold for MIN_MAX2 method (DPC 2.0 alg) */
667 /* defect correction threshold for MIN_MAX2 method (DPC 2.0 alg) or
703 enum vpfe_ipipe_otfdpc_alg alg; member in struct:vpfe_ipipe_otfdpc
705 /* if alg is IPIPE_OTFDPC_2_0 */
707 /* if alg is IPIPE_OTFDPC_3_0 */
832 enum vpfe_ipipe_cfa_alg alg; member in struct:vpfe_ipipe_cfa
H A Ddm365_ipipe_hw.c484 val = (otfdpc->det_method << OTF_DET_METHOD_SHIFT) | otfdpc->alg; ipipe_set_otfdpc_regs()
498 if (otfdpc->alg == VPFE_IPIPE_OTFDPC_2_0) { ipipe_set_otfdpc_regs()
642 regw_ip(base_addr, cfa->alg, CFA_MODE); ipipe_set_cfa_regs()
H A Ddm365_ipipe.c142 if (dpc_param->alg == VPFE_IPIPE_OTFDPC_2_0) { ipipe_validate_otfdpc_params()
415 cfa->alg = VPFE_IPIPE_CFA_ALG_2DIRAC; ipipe_set_cfa_params()
/linux-4.1.27/include/linux/crush/
H A Dcrush.h109 extern const char *crush_bucket_alg_name(int alg);
114 __u8 alg; /* one of CRUSH_BUCKET_* */ member in struct:crush_bucket
/linux-4.1.27/drivers/crypto/caam/
H A Dcaamhash.c1754 struct ahash_alg *alg = caam_hash_cra_init() local
1757 container_of(alg, struct caam_hash_alg, ahash_alg); caam_hash_cra_init()
1843 struct crypto_alg *alg; caam_hash_alloc() local
1853 alg = &halg->halg.base; caam_hash_alloc()
1856 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc()
1858 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc()
1861 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc()
1863 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc()
1866 alg->cra_module = THIS_MODULE; caam_hash_alloc()
1867 alg->cra_init = caam_hash_cra_init; caam_hash_alloc()
1868 alg->cra_exit = caam_hash_cra_exit; caam_hash_alloc()
1869 alg->cra_ctxsize = sizeof(struct caam_hash_ctx); caam_hash_alloc()
1870 alg->cra_priority = CAAM_CRA_PRIORITY; caam_hash_alloc()
1871 alg->cra_blocksize = template->blocksize; caam_hash_alloc()
1872 alg->cra_alignmask = 0; caam_hash_alloc()
1873 alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_TYPE_AHASH; caam_hash_alloc()
1874 alg->cra_type = &crypto_ahash_type; caam_hash_alloc()
1918 /* TODO: check if h/w supports alg */ caam_algapi_hash_init()
1925 pr_warn("%s alg allocation failed\n", caam_algapi_hash_init()
1932 pr_warn("%s alg registration failed\n", caam_algapi_hash_init()
1942 pr_warn("%s alg allocation failed\n", caam_algapi_hash_init()
1949 pr_warn("%s alg registration failed\n", caam_algapi_hash_init()
H A Dcaamalg.c58 * crypto alg
4137 struct crypto_alg *alg = tfm->__crt_alg; caam_cra_init() local
4139 container_of(alg, struct caam_crypto_alg, crypto_alg); caam_cra_init()
4201 struct crypto_alg *alg; caam_alg_alloc() local
4209 alg = &t_alg->crypto_alg; caam_alg_alloc()
4211 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", template->name); caam_alg_alloc()
4212 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", caam_alg_alloc()
4214 alg->cra_module = THIS_MODULE; caam_alg_alloc()
4215 alg->cra_init = caam_cra_init; caam_alg_alloc()
4216 alg->cra_exit = caam_cra_exit; caam_alg_alloc()
4217 alg->cra_priority = CAAM_CRA_PRIORITY; caam_alg_alloc()
4218 alg->cra_blocksize = template->blocksize; caam_alg_alloc()
4219 alg->cra_alignmask = 0; caam_alg_alloc()
4220 alg->cra_ctxsize = sizeof(struct caam_ctx); caam_alg_alloc()
4221 alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY | caam_alg_alloc()
4225 alg->cra_type = &crypto_givcipher_type; caam_alg_alloc()
4226 alg->cra_ablkcipher = template->template_ablkcipher; caam_alg_alloc()
4229 alg->cra_type = &crypto_ablkcipher_type; caam_alg_alloc()
4230 alg->cra_ablkcipher = template->template_ablkcipher; caam_alg_alloc()
4233 alg->cra_type = &crypto_aead_type; caam_alg_alloc()
4234 alg->cra_aead = template->template_aead; caam_alg_alloc()
4282 /* TODO: check if h/w supports alg */ caam_algapi_init()
4288 pr_warn("%s alg allocation failed\n", caam_algapi_init()
4295 pr_warn("%s alg registration failed\n", caam_algapi_init()
/linux-4.1.27/drivers/staging/rtl8188eu/os_dep/
H A Dioctl_linux.c364 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; wpa_set_encryption()
383 if (strcmp(param->u.crypt.alg, "WEP") == 0) { wpa_set_encryption()
384 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n")); wpa_set_encryption()
385 DBG_88E("wpa_set_encryption, crypt.alg = WEP\n"); wpa_set_encryption()
450 if (strcmp(param->u.crypt.alg, "none") != 0) wpa_set_encryption()
460 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ wpa_set_encryption()
486 if (strcmp(param->u.crypt.alg, "none") != 0) wpa_set_encryption()
1910 switch (pext->alg) { rtw_wx_set_enc_ext()
1930 strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN); rtw_wx_set_enc_ext()
1938 if ((pext->alg != IW_ENCODE_ALG_WEP) && rtw_wx_set_enc_ext()
2148 static int set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid) set_group_key() argument
2174 psetkeyparm->algorithm = alg; set_group_key()
2178 switch (alg) { set_group_key()
2211 u8 alg; set_wep_key() local
2215 alg = _WEP40_; set_wep_key()
2218 alg = _WEP104_; set_wep_key()
2221 alg = _NO_PRIVACY_; set_wep_key()
2224 return set_group_key(padapter, key, alg, keyid); set_wep_key()
2240 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; rtw_set_encryption()
2260 if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) { rtw_set_encryption()
2266 if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) { rtw_set_encryption()
2267 DBG_88E("r871x_set_encryption, crypt.alg = WEP\n"); rtw_set_encryption()
2332 if (strcmp(param->u.crypt.alg, "WEP") == 0) { rtw_set_encryption()
2341 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { rtw_set_encryption()
2351 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { rtw_set_encryption()
2378 if (strcmp(param->u.crypt.alg, "WEP") == 0) { rtw_set_encryption()
2384 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { rtw_set_encryption()
2394 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { rtw_set_encryption()
2408 if (strcmp(param->u.crypt.alg, "WEP") == 0) { rtw_set_encryption()
2414 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { rtw_set_encryption()
2425 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { rtw_set_encryption()
/linux-4.1.27/drivers/net/wireless/hostap/
H A Dhostap_ioctl.c3212 const char *alg, *module; prism2_ioctl_siwencodeext() local
3247 ext->alg == IW_ENCODE_ALG_NONE) { prism2_ioctl_siwencodeext()
3253 switch (ext->alg) { prism2_ioctl_siwencodeext()
3255 alg = "WEP"; prism2_ioctl_siwencodeext()
3259 alg = "TKIP"; prism2_ioctl_siwencodeext()
3263 alg = "CCMP"; prism2_ioctl_siwencodeext()
3268 local->dev->name, ext->alg); prism2_ioctl_siwencodeext()
3273 ops = lib80211_get_crypto_ops(alg); prism2_ioctl_siwencodeext()
3276 ops = lib80211_get_crypto_ops(alg); prism2_ioctl_siwencodeext()
3279 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n", prism2_ioctl_siwencodeext()
3280 local->dev->name, alg); prism2_ioctl_siwencodeext()
3285 if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) { prism2_ioctl_siwencodeext()
3410 ext->alg = IW_ENCODE_ALG_NONE; prism2_ioctl_giwencodeext()
3415 ext->alg = IW_ENCODE_ALG_WEP; prism2_ioctl_giwencodeext()
3417 ext->alg = IW_ENCODE_ALG_TKIP; prism2_ioctl_giwencodeext()
3419 ext->alg = IW_ENCODE_ALG_CCMP; prism2_ioctl_giwencodeext()
3430 (ext->alg == IW_ENCODE_ALG_TKIP || prism2_ioctl_giwencodeext()
3431 ext->alg == IW_ENCODE_ALG_CCMP)) prism2_ioctl_giwencodeext()
3453 param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0'; prism2_ioctl_set_encryption()
3479 if (strcmp(param->u.crypt.alg, "none") == 0) { prism2_ioctl_set_encryption()
3485 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption()
3486 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) { prism2_ioctl_set_encryption()
3488 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption()
3489 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) { prism2_ioctl_set_encryption()
3491 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption()
3492 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) { prism2_ioctl_set_encryption()
3494 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption()
3497 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n", prism2_ioctl_set_encryption()
3498 local->dev->name, param->u.crypt.alg); prism2_ioctl_set_encryption()
3610 memcpy(param->u.crypt.alg, "none", 5); prism2_ioctl_get_encryption()
3614 strncpy(param->u.crypt.alg, (*crypt)->ops->name, prism2_ioctl_get_encryption()
H A Dhostap_common.h374 u8 alg[HOSTAP_CRYPT_ALG_NAME_LEN]; member in struct:prism2_hostapd_param::__anon7854::__anon7857
H A Dhostap_80211_tx.c412 * AP code if STA has own alg/key */ hostap_master_start_xmit()
/linux-4.1.27/drivers/net/wireless/orinoco/
H A Dwext.c31 enum orinoco_alg alg, const u8 *key, int key_len, orinoco_set_key()
59 switch (alg) { orinoco_set_key()
727 int idx, alg = ext->alg, set_key = 1; orinoco_ioctl_set_encodeext() local
744 alg = IW_ENCODE_ALG_NONE; orinoco_ioctl_set_encodeext()
746 if (priv->has_wpa && (alg != IW_ENCODE_ALG_TKIP)) { orinoco_ioctl_set_encodeext()
753 set_key = ((alg == IW_ENCODE_ALG_TKIP) || orinoco_ioctl_set_encodeext()
759 switch (alg) { orinoco_ioctl_set_encodeext()
846 ext->alg = IW_ENCODE_ALG_NONE; orinoco_ioctl_get_encodeext()
851 ext->alg = IW_ENCODE_ALG_WEP; orinoco_ioctl_get_encodeext()
857 ext->alg = IW_ENCODE_ALG_TKIP; orinoco_ioctl_get_encodeext()
1027 /* Looks like wl_lkm wants to check the auth alg, and orinoco_ioctl_set_genie()
30 orinoco_set_key(struct orinoco_private *priv, int index, enum orinoco_alg alg, const u8 *key, int key_len, const u8 *seq, int seq_len) orinoco_set_key() argument
/linux-4.1.27/drivers/staging/rtl8723au/include/
H A Drtw_security.h23 #define is_wep_enc(alg) (alg == WLAN_CIPHER_SUITE_WEP40 || \
24 alg == WLAN_CIPHER_SUITE_WEP104)
/linux-4.1.27/net/sunrpc/auth_gss/
H A Dgss_krb5_mech.c223 int alg; get_key() local
225 p = simple_get_bytes(p, end, &alg, sizeof(alg)); get_key()
229 switch (alg) { get_key()
234 alg = ENCTYPE_DES_CBC_RAW; get_key()
238 if (!supported_gss_krb5_enctype(alg)) { get_key()
240 "encryption key algorithm %d\n", alg); get_key()
/linux-4.1.27/drivers/staging/lustre/lustre/ptlrpc/
H A Dsec_bulk.c843 int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u8 alg, sptlrpc_get_bulk_checksum() argument
852 LASSERT(alg > BULK_HASH_ALG_NULL && alg < BULK_HASH_ALG_MAX); sptlrpc_get_bulk_checksum()
855 hdesc = cfs_crypto_hash_init(cfs_hash_alg_id[alg], NULL, 0); sptlrpc_get_bulk_checksum()
858 cfs_crypto_hash_name(cfs_hash_alg_id[alg])); sptlrpc_get_bulk_checksum()
862 hashsize = cfs_crypto_hash_digestsize(cfs_hash_alg_id[alg]); sptlrpc_get_bulk_checksum()
H A Dsec_config.c98 char *bulk, *alg; sptlrpc_parse_flavor() local
127 alg = strchr(bulk, ':'); sptlrpc_parse_flavor()
128 if (alg == NULL) sptlrpc_parse_flavor()
130 *alg++ = '\0'; sptlrpc_parse_flavor()
135 flvr->u_bulk.hash.hash_alg = sptlrpc_get_hash_alg(alg); sptlrpc_parse_flavor()
/linux-4.1.27/drivers/staging/rtl8188eu/include/
H A Drtw_security.h35 #define is_wep_enc(alg) (((alg) == _WEP40_) || ((alg) == _WEP104_))
/linux-4.1.27/include/net/netns/
H A Dsctp.h66 /* The namespace default hmac alg */
/linux-4.1.27/drivers/media/platform/davinci/
H A Disif.c79 .alg = ISIF_ALAW,
601 if (module_params->compress.alg == ISIF_ALAW) isif_config_raw()
608 if (module_params->compress.alg == ISIF_DPCM) { isif_config_raw()
747 if ((isif_cfg.bayer.config_params.compress.alg != isif_set_pixel_format()
749 (isif_cfg.bayer.config_params.compress.alg != isif_set_pixel_format()
757 isif_cfg.bayer.config_params.compress.alg = isif_set_pixel_format()
780 if (isif_cfg.bayer.config_params.compress.alg == ISIF_ALAW || isif_get_pixel_format()
781 isif_cfg.bayer.config_params.compress.alg == ISIF_DPCM) isif_get_pixel_format()
/linux-4.1.27/include/linux/
H A Dnfs4.h239 NFS4ERR_HASH_ALG_UNSUPP = 10072, /* hash alg. not supp. */
246 NFS4ERR_ENCR_ALG_UNSUPP = 10079, /* SSV alg mismatch */
H A Dcrypto.h567 void (*cra_destroy)(struct crypto_alg *alg);
575 int crypto_register_alg(struct crypto_alg *alg);
576 int crypto_unregister_alg(struct crypto_alg *alg);
759 int alg_test(const char *driver, const char *alg, u32 type, u32 mask);
/linux-4.1.27/arch/cris/arch-v32/drivers/
H A Dcryptocop.c452 if ((tc->tctx->init.alg == cryptocop_alg_aes) && (tc->tcfg->flags & CRYPTOCOP_DECRYPT)) { setup_key_dl_desc()
843 switch (tctx->init.alg){ cryptocop_setup_dma_list()
886 switch (tctx->init.alg){ cryptocop_setup_dma_list()
903 panic("cryptocop_setup_dma_list: impossible algorithm %d\n", tctx->init.alg); cryptocop_setup_dma_list()
918 switch (tctx->init.alg){ cryptocop_setup_dma_list()
946 DEBUG_API(printk("cryptocop_setup_dma_list: invalid algorithm %d specified in tfrm %d.\n", tctx->init.alg, tcfg->tid)); cryptocop_setup_dma_list()
953 if (cipher_ctx.tcfg && (cipher_ctx.tctx->init.alg != cryptocop_alg_mem2mem)){ cryptocop_setup_dma_list()
1450 switch (tinit->alg){ transform_ok()
1488 DEBUG_API(printk("transform_ok: no such algorithm %d\n", tinit->alg)); transform_ok()
1492 switch (tinit->alg){ transform_ok()
2606 cblocklen = tc->init.alg == cryptocop_alg_aes ? AES_BLOCK_LENGTH : DES_BLOCK_LENGTH; cryptocop_ioctl_process()
2651 digest_length = tc->init.alg == cryptocop_alg_md5 ? 16 : 20; cryptocop_ioctl_process()
3004 ti_cipher.alg = cryptocop_alg_des; cryptocop_ioctl_create_session()
3007 ti_cipher.alg = cryptocop_alg_3des; cryptocop_ioctl_create_session()
3010 ti_cipher.alg = cryptocop_alg_aes; cryptocop_ioctl_create_session()
3016 DEBUG(printk("setting cipher transform %d\n", ti_cipher.alg)); cryptocop_ioctl_create_session()
3052 ti_digest.alg = cryptocop_alg_md5; cryptocop_ioctl_create_session()
3055 ti_digest.alg = cryptocop_alg_sha1; cryptocop_ioctl_create_session()
3076 ti_csum.alg = cryptocop_alg_csum; cryptocop_ioctl_create_session()
/linux-4.1.27/security/integrity/ima/
H A Dima_template.c74 pr_err("template does not support hash alg\n"); ima_template_setup()
/linux-4.1.27/drivers/net/ethernet/toshiba/
H A Dps3_gelic_wireless.c1208 __u16 alg; gelic_wl_set_encodeext() local
1216 alg = ext->alg; gelic_wl_set_encodeext()
1242 if (alg == IW_ENCODE_ALG_NONE || (flags & IW_ENCODE_DISABLED)) { gelic_wl_set_encodeext()
1243 pr_debug("%s: alg disabled\n", __func__); gelic_wl_set_encodeext()
1248 } else if (alg == IW_ENCODE_ALG_WEP) { gelic_wl_set_encodeext()
1271 } else if (alg == IW_ENCODE_ALG_PMK) { gelic_wl_set_encodeext()
1326 ext->alg = IW_ENCODE_ALG_WEP; gelic_wl_get_encodeext()
1330 ext->alg = IW_ENCODE_ALG_TKIP; gelic_wl_get_encodeext()
1334 ext->alg = IW_ENCODE_ALG_CCMP; gelic_wl_get_encodeext()
1339 ext->alg = IW_ENCODE_ALG_NONE; gelic_wl_get_encodeext()
/linux-4.1.27/arch/s390/kernel/
H A Dswsusp.S78 alg %r0,__LC_SYSTEM_TIMER
83 alg %r0,__LC_STEAL_TIMER
H A Dentry.S141 alg \scratch,__LC_USER_TIMER
145 alg \scratch,__LC_SYSTEM_TIMER
877 alg %r15,__LC_USER_TIMER
884 alg %r15,__LC_SYSTEM_TIMER
963 alg %r9,__CLOCK_IDLE_ENTER(%r2)
968 alg %r9,__LC_LAST_UPDATE_TIMER
/linux-4.1.27/include/linux/mfd/
H A Dabx500.h245 * @interval_charging charge alg cycle period time when charging (sec)
246 * @interval_not_charging charge alg cycle period time when not charging (sec)
/linux-4.1.27/net/ceph/
H A Dosdmap.c199 u32 alg; crush_decode() local
202 ceph_decode_32_safe(p, end, alg, bad); crush_decode()
203 if (alg == 0) { crush_decode()
210 switch (alg) { crush_decode()
238 b->alg = ceph_decode_8(p); crush_decode()
258 switch (b->alg) { crush_decode()
/linux-4.1.27/include/net/
H A Dxfrm.h910 * Otherwise, both must have a context and the sids, doi, alg must match
1689 static inline int aead_len(struct xfrm_algo_aead *alg) aead_len() argument
1691 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8); aead_len()
1694 static inline int xfrm_alg_len(const struct xfrm_algo *alg) xfrm_alg_len() argument
1696 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8); xfrm_alg_len()
1699 static inline int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg) xfrm_alg_auth_len() argument
1701 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8); xfrm_alg_auth_len()
/linux-4.1.27/drivers/net/wireless/iwlwifi/mvm/
H A Drx.c194 /* packet was encrypted with unknown alg */ iwl_mvm_set_mac80211_rx_flag()
201 /* alg is CCM: check MIC only */ iwl_mvm_set_mac80211_rx_flag()
234 IWL_ERR(mvm, "Unhandled alg: 0x%x\n", rx_pkt_status); iwl_mvm_set_mac80211_rx_flag()
H A Dfw-api.h1131 * @RX_MPDU_RES_STATUS_MIC_OK: used for CCM alg only. TKIP MIC is checked
1134 * @RX_MPDU_RES_STATUS_MNG_FRAME_REPLAY_ERR: valid for alg = CCM_CMAC or
1135 * alg = CCM only. Checks replay attack for 11w frames. Relevant only if
/linux-4.1.27/include/linux/mfd/abx500/
H A Dab8500-bm.h418 * @interval_charging charge alg cycle period time when charging (sec)
419 * @interval_not_charging charge alg cycle period time when not charging (sec)
/linux-4.1.27/arch/mips/kernel/
H A Dsmp-mt.c44 /* set config to be the same as vpe0, particularly kseg0 coherency alg */ smvp_copy_vpe_config()
H A Dvpe-mt.c442 * particularly kseg0 coherency alg vpe_module_init()
/linux-4.1.27/drivers/crypto/ux500/hash/
H A Dhash_core.c1347 const u8 *key, unsigned int keylen, int alg) hash_setkey()
1358 __func__, alg); hash_setkey()
1498 struct crypto_alg *alg = tfm->__crt_alg; hash_cra_init() local
1501 hash_alg = container_of(__crypto_ahash_alg(alg), hash_cra_init()
1626 dev_err(device_data->dev, "%s: alg registration failed\n", ahash_algs_register_all()
1346 hash_setkey(struct crypto_ahash *tfm, const u8 *key, unsigned int keylen, int alg) hash_setkey() argument
/linux-4.1.27/drivers/net/wireless/rtlwifi/
H A Dcore.c1513 /* <1> get encryption alg */ rtl_op_set_key()
1518 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:WEP40\n"); rtl_op_set_key()
1521 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:WEP104\n"); rtl_op_set_key()
1526 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:TKIP\n"); rtl_op_set_key()
1530 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:CCMP\n"); rtl_op_set_key()
1537 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:CMAC\n"); rtl_op_set_key()
/linux-4.1.27/drivers/staging/rtl8712/
H A Drtl871x_ioctl_linux.c128 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ handle_pairwise_key()
403 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; wpa_set_encryption()
414 if (strcmp(param->u.crypt.alg, "WEP") == 0) { wpa_set_encryption()
415 netdev_info(dev, "r8712u: %s: crypt.alg = WEP\n", __func__); wpa_set_encryption()
1795 switch (pext->alg) { r871x_wx_set_enc_ext()
1819 strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN); r871x_wx_set_enc_ext()
H A Dieee80211.h110 u8 alg[IEEE_CRYPT_ALG_NAME_LEN]; member in struct:ieee_param::__anon10218::__anon10222
/linux-4.1.27/drivers/block/drbd/
H A Ddrbd_receiver.c3359 drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); receive_protocol()
3380 drbd_err(connection, "peer data-integrity-alg %s not supported\n", receive_protocol()
3423 drbd_info(connection, "peer data-integrity-alg: %s\n", receive_protocol()
3441 * input: alg name, feature name
3442 * return: NULL (alg name was "")
3446 const char *alg, const char *name) drbd_crypto_alloc_digest_safe()
3450 if (!alg[0]) drbd_crypto_alloc_digest_safe()
3453 tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); drbd_crypto_alloc_digest_safe()
3456 alg, name, PTR_ERR(tfm)); drbd_crypto_alloc_digest_safe()
3573 drbd_err(device, "verify-alg of wrong size, " receive_SyncParam()
3599 drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", receive_SyncParam()
3604 p->verify_alg, "verify-alg"); receive_SyncParam()
3613 drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", receive_SyncParam()
3618 p->csums_alg, "csums-alg"); receive_SyncParam()
3656 drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); receive_SyncParam()
3663 drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); receive_SyncParam()
4881 drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); drbd_do_auth()
3445 drbd_crypto_alloc_digest_safe(const struct drbd_device *device, const char *alg, const char *name) drbd_crypto_alloc_digest_safe() argument
/linux-4.1.27/security/keys/encrypted-keys/
H A Dencrypted.c324 static struct sdesc *alloc_sdesc(struct crypto_shash *alg) alloc_sdesc() argument
329 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); alloc_sdesc()
333 sdesc->shash.tfm = alg; alloc_sdesc()
/linux-4.1.27/security/keys/
H A Dtrusted.c45 static struct sdesc *init_sdesc(struct crypto_shash *alg) init_sdesc() argument
50 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); init_sdesc()
54 sdesc->shash.tfm = alg; init_sdesc()
/linux-4.1.27/drivers/net/wireless/prism54/
H A Disl_ioctl.c1545 int idx, alg = ext->alg, set_key = 1; prism54_set_encodeext() local
1566 alg = IW_ENCODE_ALG_NONE; prism54_set_encodeext()
1578 switch (alg) { prism54_set_encodeext()
1706 ext->alg = IW_ENCODE_ALG_NONE; prism54_get_encodeext()
1725 ext->alg = IW_ENCODE_ALG_TKIP; prism54_get_encodeext()
1729 ext->alg = IW_ENCODE_ALG_WEP; prism54_get_encodeext()
/linux-4.1.27/drivers/staging/rtl8723au/os_dep/
H A Dioctl_cfg80211.c423 u32 alg, u8 keyid) set_group_key()
450 if (is_wep_enc(alg)) set_group_key()
453 psetkeyparm->algorithm = alg; set_group_key()
497 DBG_8723A("r871x_set_encryption, crypt.alg = WEP\n"); rtw_cfg80211_ap_set_encryption()
732 "wpa_set_encryption, crypt.alg = WEP\n"); rtw_cfg80211_set_encryption()
733 DBG_8723A("wpa_set_encryption, crypt.alg = WEP\n"); rtw_cfg80211_set_encryption()
422 set_group_key(struct rtw_adapter *padapter, struct key_params *parms, u32 alg, u8 keyid) set_group_key() argument
/linux-4.1.27/drivers/mtd/nand/
H A Ddocg4.c213 #define DOCG4_T 4 /* BCH alg corrects up to 4 bit errors */
421 * data in a bit order that is the reverse of that of the bch alg, correct_data()
439 /* undo last step in BCH alg (modulo mirroring not needed) */ correct_data()
/linux-4.1.27/drivers/media/i2c/
H A Ds5k5baf.c652 static void s5k5baf_hw_set_alg(struct s5k5baf *state, u16 alg, bool enable) s5k5baf_hw_set_alg() argument
661 new_alg = enable ? (cur_alg | alg) : (cur_alg & ~alg); s5k5baf_hw_set_alg()
/linux-4.1.27/drivers/staging/lustre/lustre/include/
H A Ddt_object.h176 __u32 alg, struct lustre_capa_key *keys);
1422 __u32 alg, struct lustre_capa_key *keys) dt_init_capa_ctxt()
1428 timeout, alg, keys); dt_init_capa_ctxt()
1419 dt_init_capa_ctxt(const struct lu_env *env, struct dt_device *dev, int mode, unsigned long timeout, __u32 alg, struct lustre_capa_key *keys) dt_init_capa_ctxt() argument
/linux-4.1.27/drivers/crypto/ux500/cryp/
H A Dcryp_core.c1096 struct crypto_alg *alg = tfm->__crt_alg; cryp_cra_init() local
1097 struct cryp_algo_template *cryp_alg = container_of(alg, cryp_cra_init()
1379 pr_err("[%s] alg registration failed", cryp_algs_register_all()
/linux-4.1.27/drivers/net/wireless/
H A Datmel.c1854 int idx, key_len, alg = ext->alg, set_key = 1; atmel_set_encodeext() local
1866 alg = IW_ENCODE_ALG_NONE; atmel_set_encodeext()
1875 switch (alg) { atmel_set_encodeext()
1932 ext->alg = IW_ENCODE_ALG_NONE; atmel_get_encodeext()
1937 ext->alg = IW_ENCODE_ALG_WEP; atmel_get_encodeext()
2719 __le16 alg; member in struct:auth_body
2883 auth.alg = cpu_to_le16(system); send_authentication_request()
3053 u16 system = le16_to_cpu(auth->alg); authenticate()
H A Drndis_wlan.c2296 int ret, alg, length, chan = -1; rndis_join_ibss() local
2308 alg = RNDIS_WLAN_ALG_WEP; rndis_join_ibss()
2311 alg = RNDIS_WLAN_ALG_NONE; rndis_join_ibss()
2336 ret = set_encr_mode(usbdev, alg, RNDIS_WLAN_ALG_NONE); rndis_join_ibss()
/linux-4.1.27/include/media/davinci/
H A Disif.h407 __u8 alg; member in struct:isif_compress
/linux-4.1.27/net/sched/
H A Dcls_tcindex.c97 pr_debug("alg 0x%x\n", res->classid); tcindex_classify()
/linux-4.1.27/drivers/net/wireless/iwlwifi/dvm/
H A Drx.c808 /* packet was encrypted with unknown alg */ iwlagn_translate_rx_status()
821 /* alg is CCM: check MIC only */ iwlagn_translate_rx_status()
/linux-4.1.27/drivers/infiniband/hw/qib/
H A Dqib_file_ops.c1430 unsigned alg) get_a_ctxt()
1446 if (alg == QIB_PORT_ALG_ACROSS) { get_a_ctxt()
1612 unsigned swmajor, swminor, alg = QIB_PORT_ALG_ACROSS; qib_assign_ctxt() local
1630 alg = uinfo->spu_port_alg; qib_assign_ctxt()
1660 ret = get_a_ctxt(fp, uinfo, alg); qib_assign_ctxt()
1429 get_a_ctxt(struct file *fp, const struct qib_user_info *uinfo, unsigned alg) get_a_ctxt() argument
/linux-4.1.27/fs/ecryptfs/
H A Dkeystore.c2212 struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm); write_tag_3_packet() local
2215 "defaulting to [%d]\n", alg->max_keysize); write_tag_3_packet()
2217 alg->max_keysize; write_tag_3_packet()
/linux-4.1.27/include/uapi/linux/
H A Dwireless.h620 /* struct iw_encode_ext ->alg */
838 __u16 alg; /* IW_ENCODE_ALG_* */ member in struct:iw_encode_ext
/linux-4.1.27/drivers/staging/rtl8723au/core/
H A Drtw_mlme_ext.c942 DBG_8723A("auth alg =%x, seq =%X\n", algorithm, seq); OnAuth23a()
953 DBG_8723A("auth rejected due to bad alg [alg =%d, auth_mib " OnAuth23a()
5883 DBG_8723A_LEVEL(_drv_always_, "set group key to hw: alg:%d(WEP40-1 " setkey_hdl23a()
5917 DBG_8723A_LEVEL(_drv_always_, "set pairwise key to hw: alg:%d(WEP40-1 " set_stakey_hdl23a()
/linux-4.1.27/drivers/staging/rtl8188eu/core/
H A Drtw_mlme_ext.c677 DBG_88E("auth alg=%x, seq=%X\n", algorithm, seq); OnAuth()
685 DBG_88E("auth rejected due to bad alg [alg=%d, auth_mib=%d] %02X%02X%02X%02X%02X%02X\n", OnAuth()
5316 DBG_88E_LEVEL(_drv_info_, "set group key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) " setkey_hdl()
5346 DBG_88E_LEVEL(_drv_info_, "set pairwise key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) camid:%d\n", set_stakey_hdl()
/linux-4.1.27/drivers/scsi/aic7xxx/
H A Daic7xxx_osm.c1275 struct ahc_devinfo *devinfo, ahc_queue_alg alg) ahc_platform_set_tags()
1286 switch (alg) { ahc_platform_set_tags()
1324 } else if (alg == AHC_QUEUE_TAGGED) { ahc_platform_set_tags()
1274 ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev, struct ahc_devinfo *devinfo, ahc_queue_alg alg) ahc_platform_set_tags() argument
H A Daic79xx_osm.c1405 struct ahd_devinfo *devinfo, ahd_queue_alg alg) ahd_platform_set_tags()
1419 switch (alg) { ahd_platform_set_tags()
1457 } else if (alg == AHD_QUEUE_TAGGED) { ahd_platform_set_tags()
1404 ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev, struct ahd_devinfo *devinfo, ahd_queue_alg alg) ahd_platform_set_tags() argument

Completed in 6925 milliseconds

12