Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246/* SPDX-License-Identifier: GPL-2.0-or-later *//* * Key-agreement Protocol Primitives (KPP) * * Copyright (c) 2016, Intel Corporation * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com> */#ifndef _CRYPTO_KPP_INT_H#define _CRYPTO_KPP_INT_H#include <crypto/kpp.h>#include <crypto/algapi.h>
/** * struct kpp_instance - KPP template instance * @free: Callback getting invoked upon instance destruction. Must be set. * @s: Internal. Generic crypto core instance state properly layout * to alias with @alg as needed. * @alg: The &struct kpp_alg implementation provided by the instance. */struct kpp_instance { void (*free)(struct kpp_instance *inst); union { struct { char head[offsetof(struct kpp_alg, base)]; struct crypto_instance base; } s; struct kpp_alg alg; };};
/** * struct crypto_kpp_spawn - KPP algorithm spawn * @base: Internal. Generic crypto core spawn state. * * Template instances can get a hold on some inner KPP algorithm by * binding a &struct crypto_kpp_spawn via * crypto_grab_kpp(). Transforms may subsequently get instantiated * from the referenced inner &struct kpp_alg by means of * crypto_spawn_kpp(). */struct crypto_kpp_spawn { struct crypto_spawn base;};
/* * Transform internal helpers. */static inline void *kpp_request_ctx(struct kpp_request *req){ return req->__ctx;}
static inline void *kpp_request_ctx_dma(struct kpp_request *req){ unsigned int align = crypto_dma_align();
if (align <= crypto_tfm_ctx_alignment()) align = 1;
return PTR_ALIGN(kpp_request_ctx(req), align);}
static inline void kpp_set_reqsize(struct crypto_kpp *kpp, unsigned int reqsize){ kpp->reqsize = reqsize;}
static inline void kpp_set_reqsize_dma(struct crypto_kpp *kpp, unsigned int reqsize){ reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1); kpp->reqsize = reqsize;}
static inline void *kpp_tfm_ctx(struct crypto_kpp *tfm){ return crypto_tfm_ctx(&tfm->base);}
static inline void *kpp_tfm_ctx_dma(struct crypto_kpp *tfm){ return crypto_tfm_ctx_dma(&tfm->base);}
static inline void kpp_request_complete(struct kpp_request *req, int err){ crypto_request_complete(&req->base, err);}
static inline const char *kpp_alg_name(struct crypto_kpp *tfm){ return crypto_kpp_tfm(tfm)->__crt_alg->cra_name;}
/* * Template instance internal helpers. *//** * kpp_crypto_instance() - Cast a &struct kpp_instance to the corresponding * generic &struct crypto_instance. * @inst: Pointer to the &struct kpp_instance to be cast. * Return: A pointer to the &struct crypto_instance embedded in @inst. */static inline struct crypto_instance *kpp_crypto_instance( struct kpp_instance *inst){ return &inst->s.base;}
/** * kpp_instance() - Cast a generic &struct crypto_instance to the corresponding * &struct kpp_instance. * @inst: Pointer to the &struct crypto_instance to be cast. * Return: A pointer to the &struct kpp_instance @inst is embedded in. */static inline struct kpp_instance *kpp_instance(struct crypto_instance *inst){ return container_of(inst, struct kpp_instance, s.base);}
/** * kpp_alg_instance() - Get the &struct kpp_instance a given KPP transform has * been instantiated from. * @kpp: The KPP transform instantiated from some &struct kpp_instance. * Return: The &struct kpp_instance associated with @kpp. */static inline struct kpp_instance *kpp_alg_instance(struct crypto_kpp *kpp){ return kpp_instance(crypto_tfm_alg_instance(&kpp->base));}
/** * kpp_instance_ctx() - Get a pointer to a &struct kpp_instance's implementation * specific context data. * @inst: The &struct kpp_instance whose context data to access. * * A KPP template implementation may allocate extra memory beyond the * end of a &struct kpp_instance instantiated from &crypto_template.create(). * This function provides a means to obtain a pointer to this area. * * Return: A pointer to the implementation specific context data. */static inline void *kpp_instance_ctx(struct kpp_instance *inst){ return crypto_instance_ctx(kpp_crypto_instance(inst));}
/* * KPP algorithm (un)registration functions. *//** * crypto_register_kpp() -- Register key-agreement protocol primitives algorithm * * Function registers an implementation of a key-agreement protocol primitive * algorithm * * @alg: algorithm definition * * Return: zero on success; error code in case of error */int crypto_register_kpp(struct kpp_alg *alg);
/** * crypto_unregister_kpp() -- Unregister key-agreement protocol primitive * algorithm * * Function unregisters an implementation of a key-agreement protocol primitive * algorithm * * @alg: algorithm definition */void crypto_unregister_kpp(struct kpp_alg *alg);
/** * kpp_register_instance() - Register a KPP template instance. * @tmpl: The instantiating template. * @inst: The KPP template instance to be registered. * Return: %0 on success, negative error code otherwise. */int kpp_register_instance(struct crypto_template *tmpl, struct kpp_instance *inst);
/* * KPP spawn related functions. *//** * crypto_grab_kpp() - Look up a KPP algorithm and bind a spawn to it. * @spawn: The KPP spawn to bind. * @inst: The template instance owning @spawn. * @name: The KPP algorithm name to look up. * @type: The type bitset to pass on to the lookup. * @mask: The mask bismask to pass on to the lookup. * Return: %0 on success, a negative error code otherwise. */int crypto_grab_kpp(struct crypto_kpp_spawn *spawn, struct crypto_instance *inst, const char *name, u32 type, u32 mask);
/** * crypto_drop_kpp() - Release a spawn previously bound via crypto_grab_kpp(). * @spawn: The spawn to release. */static inline void crypto_drop_kpp(struct crypto_kpp_spawn *spawn){ crypto_drop_spawn(&spawn->base);}
/** * crypto_spawn_kpp_alg() - Get the algorithm a KPP spawn has been bound to. * @spawn: The spawn to get the referenced &struct kpp_alg for. * * This function as well as the returned result are safe to use only * after @spawn has been successfully bound via crypto_grab_kpp() and * up to until the template instance owning @spawn has either been * registered successfully or the spawn has been released again via * crypto_drop_spawn(). * * Return: A pointer to the &struct kpp_alg referenced from the spawn. */static inline struct kpp_alg *crypto_spawn_kpp_alg( struct crypto_kpp_spawn *spawn){ return container_of(spawn->base.alg, struct kpp_alg, base);}
/** * crypto_spawn_kpp() - Create a transform from a KPP spawn. * @spawn: The spawn previously bound to some &struct kpp_alg via * crypto_grab_kpp(). * * Once a &struct crypto_kpp_spawn has been successfully bound to a * &struct kpp_alg via crypto_grab_kpp(), transforms for the latter * may get instantiated from the former by means of this function. * * Return: A pointer to the freshly created KPP transform on success * or an ``ERR_PTR()`` otherwise. */static inline struct crypto_kpp *crypto_spawn_kpp( struct crypto_kpp_spawn *spawn){ return crypto_spawn_tfm2(&spawn->base);}
#endif