cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

internal.h (4376B)

      1/* SPDX-License-Identifier: GPL-2.0-or-later */
      2/*
      3 * Cryptographic API.
      4 *
      5 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
      6 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
      7 */
      8#ifndef _CRYPTO_INTERNAL_H
      9#define _CRYPTO_INTERNAL_H
     10
     11#include <crypto/algapi.h>
     12#include <linux/completion.h>
     13#include <linux/jump_label.h>
     14#include <linux/list.h>
     15#include <linux/module.h>
     16#include <linux/notifier.h>
     17#include <linux/numa.h>
     18#include <linux/refcount.h>
     19#include <linux/rwsem.h>
     20#include <linux/sched.h>
     21#include <linux/types.h>
     22
     23struct crypto_instance;
     24struct crypto_template;
     25
     26struct crypto_larval {
     27	struct crypto_alg alg;
     28	struct crypto_alg *adult;
     29	struct completion completion;
     30	u32 mask;
     31	bool test_started;
     32};
     33
     34enum {
     35	CRYPTOA_UNSPEC,
     36	CRYPTOA_ALG,
     37	CRYPTOA_TYPE,
     38	__CRYPTOA_MAX,
     39};
     40
     41#define CRYPTOA_MAX (__CRYPTOA_MAX - 1)
     42
     43/* Maximum number of (rtattr) parameters for each template. */
     44#define CRYPTO_MAX_ATTRS 32
     45
     46extern struct list_head crypto_alg_list;
     47extern struct rw_semaphore crypto_alg_sem;
     48extern struct blocking_notifier_head crypto_chain;
     49
     50DECLARE_STATIC_KEY_FALSE(crypto_boot_test_finished);
     51
     52#ifdef CONFIG_PROC_FS
     53void __init crypto_init_proc(void);
     54void __exit crypto_exit_proc(void);
     55#else
     56static inline void crypto_init_proc(void)
     57{ }
     58static inline void crypto_exit_proc(void)
     59{ }
     60#endif
     61
     62static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg)
     63{
     64	return alg->cra_ctxsize;
     65}
     66
     67static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg)
     68{
     69	return alg->cra_ctxsize;
     70}
     71
     72struct crypto_alg *crypto_mod_get(struct crypto_alg *alg);
     73struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask);
     74
     75struct crypto_larval *crypto_larval_alloc(const char *name, u32 type, u32 mask);
     76void crypto_larval_kill(struct crypto_alg *alg);
     77void crypto_wait_for_test(struct crypto_larval *larval);
     78void crypto_alg_tested(const char *name, int err);
     79
     80void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
     81			  struct crypto_alg *nalg);
     82void crypto_remove_final(struct list_head *list);
     83void crypto_shoot_alg(struct crypto_alg *alg);
     84struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
     85				      u32 mask);
     86void *crypto_create_tfm_node(struct crypto_alg *alg,
     87			const struct crypto_type *frontend, int node);
     88
     89static inline void *crypto_create_tfm(struct crypto_alg *alg,
     90			const struct crypto_type *frontend)
     91{
     92	return crypto_create_tfm_node(alg, frontend, NUMA_NO_NODE);
     93}
     94
     95struct crypto_alg *crypto_find_alg(const char *alg_name,
     96				   const struct crypto_type *frontend,
     97				   u32 type, u32 mask);
     98
     99void *crypto_alloc_tfm_node(const char *alg_name,
    100		       const struct crypto_type *frontend, u32 type, u32 mask,
    101		       int node);
    102
    103static inline void *crypto_alloc_tfm(const char *alg_name,
    104		       const struct crypto_type *frontend, u32 type, u32 mask)
    105{
    106	return crypto_alloc_tfm_node(alg_name, frontend, type, mask, NUMA_NO_NODE);
    107}
    108
    109int crypto_probing_notify(unsigned long val, void *v);
    110
    111unsigned int crypto_alg_extsize(struct crypto_alg *alg);
    112
    113int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,
    114			u32 type, u32 mask);
    115
    116static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
    117{
    118	refcount_inc(&alg->cra_refcnt);
    119	return alg;
    120}
    121
    122static inline void crypto_alg_put(struct crypto_alg *alg)
    123{
    124	if (refcount_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
    125		alg->cra_destroy(alg);
    126}
    127
    128static inline int crypto_tmpl_get(struct crypto_template *tmpl)
    129{
    130	return try_module_get(tmpl->module);
    131}
    132
    133static inline void crypto_tmpl_put(struct crypto_template *tmpl)
    134{
    135	module_put(tmpl->module);
    136}
    137
    138static inline int crypto_is_larval(struct crypto_alg *alg)
    139{
    140	return alg->cra_flags & CRYPTO_ALG_LARVAL;
    141}
    142
    143static inline int crypto_is_dead(struct crypto_alg *alg)
    144{
    145	return alg->cra_flags & CRYPTO_ALG_DEAD;
    146}
    147
    148static inline int crypto_is_moribund(struct crypto_alg *alg)
    149{
    150	return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING);
    151}
    152
    153static inline void crypto_notify(unsigned long val, void *v)
    154{
    155	blocking_notifier_call_chain(&crypto_chain, val, v);
    156}
    157
    158static inline void crypto_yield(u32 flags)
    159{
    160	if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)
    161		cond_resched();
    162}
    163
    164static inline int crypto_is_test_larval(struct crypto_larval *larval)
    165{
    166	return larval->alg.cra_driver_name[0];
    167}
    168
    169#endif	/* _CRYPTO_INTERNAL_H */
    170