~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/crypto/internal.h

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /crypto/internal.h (Version linux-6.12-rc7) and /crypto/internal.h (Version linux-5.4.285)


  1 /* SPDX-License-Identifier: GPL-2.0-or-later *      1 /* SPDX-License-Identifier: GPL-2.0-or-later */
  2 /*                                                  2 /*
  3  * Cryptographic API.                               3  * Cryptographic API.
  4  *                                                  4  *
  5  * Copyright (c) 2002 James Morris <jmorris@in      5  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
  6  * Copyright (c) 2005 Herbert Xu <herbert@gond      6  * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
  7  */                                                 7  */
  8 #ifndef _CRYPTO_INTERNAL_H                          8 #ifndef _CRYPTO_INTERNAL_H
  9 #define _CRYPTO_INTERNAL_H                          9 #define _CRYPTO_INTERNAL_H
 10                                                    10 
 11 #include <crypto/algapi.h>                         11 #include <crypto/algapi.h>
 12 #include <linux/completion.h>                      12 #include <linux/completion.h>
 13 #include <linux/err.h>                         !!  13 #include <linux/mm.h>
 14 #include <linux/jump_label.h>                  !!  14 #include <linux/highmem.h>
                                                   >>  15 #include <linux/interrupt.h>
                                                   >>  16 #include <linux/init.h>
 15 #include <linux/list.h>                            17 #include <linux/list.h>
 16 #include <linux/module.h>                          18 #include <linux/module.h>
                                                   >>  19 #include <linux/kernel.h>
 17 #include <linux/notifier.h>                        20 #include <linux/notifier.h>
 18 #include <linux/numa.h>                        << 
 19 #include <linux/refcount.h>                    << 
 20 #include <linux/rwsem.h>                           21 #include <linux/rwsem.h>
 21 #include <linux/scatterlist.h>                 !!  22 #include <linux/slab.h>
 22 #include <linux/sched.h>                       << 
 23 #include <linux/types.h>                       << 
 24                                                    23 
 25 struct akcipher_request;                       << 
 26 struct crypto_akcipher;                        << 
 27 struct crypto_instance;                            24 struct crypto_instance;
 28 struct crypto_template;                            25 struct crypto_template;
 29                                                    26 
 30 struct crypto_larval {                             27 struct crypto_larval {
 31         struct crypto_alg alg;                     28         struct crypto_alg alg;
 32         struct crypto_alg *adult;                  29         struct crypto_alg *adult;
 33         struct completion completion;              30         struct completion completion;
 34         u32 mask;                                  31         u32 mask;
 35         bool test_started;                     << 
 36 };                                                 32 };
 37                                                    33 
 38 struct crypto_akcipher_sync_data {             << 
 39         struct crypto_akcipher *tfm;           << 
 40         const void *src;                       << 
 41         void *dst;                             << 
 42         unsigned int slen;                     << 
 43         unsigned int dlen;                     << 
 44                                                << 
 45         struct akcipher_request *req;          << 
 46         struct crypto_wait cwait;              << 
 47         struct scatterlist sg;                 << 
 48         u8 *buf;                               << 
 49 };                                             << 
 50                                                << 
 51 enum {                                         << 
 52         CRYPTOA_UNSPEC,                        << 
 53         CRYPTOA_ALG,                           << 
 54         CRYPTOA_TYPE,                          << 
 55         __CRYPTOA_MAX,                         << 
 56 };                                             << 
 57                                                << 
 58 #define CRYPTOA_MAX (__CRYPTOA_MAX - 1)        << 
 59                                                << 
 60 /* Maximum number of (rtattr) parameters for e << 
 61 #define CRYPTO_MAX_ATTRS 32                    << 
 62                                                << 
 63 extern struct list_head crypto_alg_list;           34 extern struct list_head crypto_alg_list;
 64 extern struct rw_semaphore crypto_alg_sem;         35 extern struct rw_semaphore crypto_alg_sem;
 65 extern struct blocking_notifier_head crypto_ch     36 extern struct blocking_notifier_head crypto_chain;
 66                                                    37 
 67 int alg_test(const char *driver, const char *a << 
 68                                                << 
 69 #if !IS_BUILTIN(CONFIG_CRYPTO_ALGAPI) || \     << 
 70     IS_ENABLED(CONFIG_CRYPTO_MANAGER_DISABLE_T << 
 71 static inline bool crypto_boot_test_finished(v << 
 72 {                                              << 
 73         return true;                           << 
 74 }                                              << 
 75 static inline void set_crypto_boot_test_finish << 
 76 {                                              << 
 77 }                                              << 
 78 #else                                          << 
 79 DECLARE_STATIC_KEY_FALSE(__crypto_boot_test_fi << 
 80 static inline bool crypto_boot_test_finished(v << 
 81 {                                              << 
 82         return static_branch_likely(&__crypto_ << 
 83 }                                              << 
 84 static inline void set_crypto_boot_test_finish << 
 85 {                                              << 
 86         static_branch_enable(&__crypto_boot_te << 
 87 }                                              << 
 88 #endif /* !IS_BUILTIN(CONFIG_CRYPTO_ALGAPI) || << 
 89         * IS_ENABLED(CONFIG_CRYPTO_MANAGER_DIS << 
 90         */                                     << 
 91                                                << 
 92 #ifdef CONFIG_PROC_FS                              38 #ifdef CONFIG_PROC_FS
 93 void __init crypto_init_proc(void);                39 void __init crypto_init_proc(void);
 94 void __exit crypto_exit_proc(void);                40 void __exit crypto_exit_proc(void);
 95 #else                                              41 #else
 96 static inline void crypto_init_proc(void)          42 static inline void crypto_init_proc(void)
 97 { }                                                43 { }
 98 static inline void crypto_exit_proc(void)          44 static inline void crypto_exit_proc(void)
 99 { }                                                45 { }
100 #endif                                             46 #endif
101                                                    47 
102 static inline unsigned int crypto_cipher_ctxsi     48 static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg)
103 {                                                  49 {
104         return alg->cra_ctxsize;                   50         return alg->cra_ctxsize;
105 }                                                  51 }
106                                                    52 
107 static inline unsigned int crypto_compress_ctx     53 static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg)
108 {                                                  54 {
109         return alg->cra_ctxsize;                   55         return alg->cra_ctxsize;
110 }                                                  56 }
111                                                    57 
112 struct crypto_alg *crypto_mod_get(struct crypt     58 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg);
113 struct crypto_alg *crypto_alg_mod_lookup(const     59 struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask);
114                                                    60 
                                                   >>  61 int crypto_init_cipher_ops(struct crypto_tfm *tfm);
                                                   >>  62 int crypto_init_compress_ops(struct crypto_tfm *tfm);
                                                   >>  63 
115 struct crypto_larval *crypto_larval_alloc(cons     64 struct crypto_larval *crypto_larval_alloc(const char *name, u32 type, u32 mask);
116 void crypto_schedule_test(struct crypto_larval !!  65 void crypto_larval_kill(struct crypto_alg *alg);
117 void crypto_alg_tested(const char *name, int e     66 void crypto_alg_tested(const char *name, int err);
118                                                    67 
119 void crypto_remove_spawns(struct crypto_alg *a     68 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
120                           struct crypto_alg *n     69                           struct crypto_alg *nalg);
121 void crypto_remove_final(struct list_head *lis     70 void crypto_remove_final(struct list_head *list);
122 void crypto_shoot_alg(struct crypto_alg *alg); << 
123 struct crypto_tfm *__crypto_alloc_tfmgfp(struc << 
124                                          u32 m << 
125 struct crypto_tfm *__crypto_alloc_tfm(struct c     71 struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
126                                       u32 mask     72                                       u32 mask);
127 void *crypto_create_tfm_node(struct crypto_alg !!  73 void *crypto_create_tfm(struct crypto_alg *alg,
128                         const struct crypto_ty !!  74                         const struct crypto_type *frontend);
129 void *crypto_clone_tfm(const struct crypto_typ << 
130                        struct crypto_tfm *otfm << 
131                                                << 
132 int crypto_akcipher_sync_prep(struct crypto_ak << 
133 int crypto_akcipher_sync_post(struct crypto_ak << 
134 int crypto_init_akcipher_ops_sig(struct crypto << 
135                                                << 
136 static inline void *crypto_create_tfm(struct c << 
137                         const struct crypto_ty << 
138 {                                              << 
139         return crypto_create_tfm_node(alg, fro << 
140 }                                              << 
141                                                << 
142 struct crypto_alg *crypto_find_alg(const char      75 struct crypto_alg *crypto_find_alg(const char *alg_name,
143                                    const struc     76                                    const struct crypto_type *frontend,
144                                    u32 type, u     77                                    u32 type, u32 mask);
145                                                !!  78 void *crypto_alloc_tfm(const char *alg_name,
146 void *crypto_alloc_tfm_node(const char *alg_na !!  79                        const struct crypto_type *frontend, u32 type, u32 mask);
147                        const struct crypto_typ << 
148                        int node);              << 
149                                                << 
150 static inline void *crypto_alloc_tfm(const cha << 
151                        const struct crypto_typ << 
152 {                                              << 
153         return crypto_alloc_tfm_node(alg_name, << 
154 }                                              << 
155                                                    80 
156 int crypto_probing_notify(unsigned long val, v     81 int crypto_probing_notify(unsigned long val, void *v);
157                                                    82 
158 unsigned int crypto_alg_extsize(struct crypto_     83 unsigned int crypto_alg_extsize(struct crypto_alg *alg);
159                                                    84 
160 int crypto_type_has_alg(const char *name, cons     85 int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,
161                         u32 type, u32 mask);       86                         u32 type, u32 mask);
162                                                    87 
163 static inline struct crypto_alg *crypto_alg_ge     88 static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
164 {                                                  89 {
165         refcount_inc(&alg->cra_refcnt);            90         refcount_inc(&alg->cra_refcnt);
166         return alg;                                91         return alg;
167 }                                                  92 }
168                                                    93 
169 static inline void crypto_alg_put(struct crypt     94 static inline void crypto_alg_put(struct crypto_alg *alg)
170 {                                                  95 {
171         if (refcount_dec_and_test(&alg->cra_re     96         if (refcount_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
172                 alg->cra_destroy(alg);             97                 alg->cra_destroy(alg);
173 }                                                  98 }
174                                                    99 
175 static inline int crypto_tmpl_get(struct crypt    100 static inline int crypto_tmpl_get(struct crypto_template *tmpl)
176 {                                                 101 {
177         return try_module_get(tmpl->module);      102         return try_module_get(tmpl->module);
178 }                                                 103 }
179                                                   104 
180 static inline void crypto_tmpl_put(struct cryp    105 static inline void crypto_tmpl_put(struct crypto_template *tmpl)
181 {                                                 106 {
182         module_put(tmpl->module);                 107         module_put(tmpl->module);
183 }                                                 108 }
184                                                   109 
185 static inline int crypto_is_larval(struct cryp    110 static inline int crypto_is_larval(struct crypto_alg *alg)
186 {                                                 111 {
187         return alg->cra_flags & CRYPTO_ALG_LAR    112         return alg->cra_flags & CRYPTO_ALG_LARVAL;
188 }                                                 113 }
189                                                   114 
190 static inline int crypto_is_dead(struct crypto    115 static inline int crypto_is_dead(struct crypto_alg *alg)
191 {                                                 116 {
192         return alg->cra_flags & CRYPTO_ALG_DEA    117         return alg->cra_flags & CRYPTO_ALG_DEAD;
193 }                                                 118 }
194                                                   119 
195 static inline int crypto_is_moribund(struct cr    120 static inline int crypto_is_moribund(struct crypto_alg *alg)
196 {                                                 121 {
197         return alg->cra_flags & (CRYPTO_ALG_DE    122         return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING);
198 }                                                 123 }
199                                                   124 
200 static inline void crypto_notify(unsigned long    125 static inline void crypto_notify(unsigned long val, void *v)
201 {                                                 126 {
202         blocking_notifier_call_chain(&crypto_c    127         blocking_notifier_call_chain(&crypto_chain, val, v);
203 }                                              << 
204                                                << 
205 static inline void crypto_yield(u32 flags)     << 
206 {                                              << 
207         if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)  << 
208                 cond_resched();                << 
209 }                                              << 
210                                                << 
211 static inline int crypto_is_test_larval(struct << 
212 {                                              << 
213         return larval->alg.cra_driver_name[0]; << 
214 }                                              << 
215                                                << 
216 static inline struct crypto_tfm *crypto_tfm_ge << 
217 {                                              << 
218         return refcount_inc_not_zero(&tfm->ref << 
219 }                                                 128 }
220                                                   129 
221 #endif  /* _CRYPTO_INTERNAL_H */                  130 #endif  /* _CRYPTO_INTERNAL_H */
222                                                   131 
223                                                   132 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php