PATH:
usr
/
src
/
linux-headers-5.4.0-215
/
include
/
linux
/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Scatterlist Cryptographic API. * * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> * Copyright (c) 2002 David S. Miller (davem@redhat.com) * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au> * * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no> * and Nettle, by Niels Möller. */ #ifndef _LINUX_CRYPTO_H #define _LINUX_CRYPTO_H #include <linux/atomic.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/bug.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/uaccess.h> #include <linux/completion.h> /* * Autoloaded crypto modules should only use a prefixed name to avoid allowing * arbitrary modules to be loaded. Loading from userspace may still need the * unprefixed names, so retains those aliases as well. * This uses __MODULE_INFO directly instead of MODULE_ALIAS because pre-4.3 * gcc (e.g. avr32 toolchain) uses __LINE__ for uniqueness, and this macro * expands twice on the same line. Instead, use a separate base name for the * alias. */ #define MODULE_ALIAS_CRYPTO(name) \ __MODULE_INFO(alias, alias_userspace, name); \ __MODULE_INFO(alias, alias_crypto, "crypto-" name) /* * Algorithm masks and types. */ #define CRYPTO_ALG_TYPE_MASK 0x0000000f #define CRYPTO_ALG_TYPE_CIPHER 0x00000001 #define CRYPTO_ALG_TYPE_COMPRESS 0x00000002 #define CRYPTO_ALG_TYPE_AEAD 0x00000003 #define CRYPTO_ALG_TYPE_BLKCIPHER 0x00000004 #define CRYPTO_ALG_TYPE_ABLKCIPHER 0x00000005 #define CRYPTO_ALG_TYPE_SKCIPHER 0x00000005 #define CRYPTO_ALG_TYPE_KPP 0x00000008 #define CRYPTO_ALG_TYPE_ACOMPRESS 0x0000000a #define CRYPTO_ALG_TYPE_SCOMPRESS 0x0000000b #define CRYPTO_ALG_TYPE_RNG 0x0000000c #define CRYPTO_ALG_TYPE_AKCIPHER 0x0000000d #define CRYPTO_ALG_TYPE_HASH 0x0000000e #define CRYPTO_ALG_TYPE_SHASH 0x0000000e #define CRYPTO_ALG_TYPE_AHASH 0x0000000f #define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e #define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e #define CRYPTO_ALG_TYPE_BLKCIPHER_MASK 0x0000000c #define CRYPTO_ALG_TYPE_ACOMPRESS_MASK 0x0000000e #define CRYPTO_ALG_LARVAL 0x00000010 #define CRYPTO_ALG_DEAD 0x00000020 #define CRYPTO_ALG_DYING 0x00000040 #define CRYPTO_ALG_ASYNC 0x00000080 /* * Set this bit if and only if the algorithm requires another algorithm of * the same type to handle corner cases. */ #define CRYPTO_ALG_NEED_FALLBACK 0x00000100 /* * Set if the algorithm has passed automated run-time testing. Note that * if there is no run-time testing for a given algorithm it is considered * to have passed. */ #define CRYPTO_ALG_TESTED 0x00000400 /* * Set if the algorithm is an instance that is built from templates. */ #define CRYPTO_ALG_INSTANCE 0x00000800 /* Set this bit if the algorithm provided is hardware accelerated but * not available to userspace via instruction set or so. */ #define CRYPTO_ALG_KERN_DRIVER_ONLY 0x00001000 /* * Mark a cipher as a service implementation only usable by another * cipher and never by a normal user of the kernel crypto API */ #define CRYPTO_ALG_INTERNAL 0x00002000 /* * Set if the algorithm has a ->setkey() method but can be used without * calling it first, i.e. there is a default key. */ #define CRYPTO_ALG_OPTIONAL_KEY 0x00004000 /* * Don't trigger module loading */ #define CRYPTO_NOLOAD 0x00008000 /* * Transform masks and values (for crt_flags). */ #define CRYPTO_TFM_NEED_KEY 0x00000001 #define CRYPTO_TFM_REQ_MASK 0x000fff00 #define CRYPTO_TFM_RES_MASK 0xfff00000 #define CRYPTO_TFM_REQ_FORBID_WEAK_KEYS 0x00000100 #define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200 #define CRYPTO_TFM_REQ_MAY_BACKLOG 0x00000400 #define CRYPTO_TFM_RES_WEAK_KEY 0x00100000 #define CRYPTO_TFM_RES_BAD_KEY_LEN 0x00200000 #define CRYPTO_TFM_RES_BAD_KEY_SCHED 0x00400000 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN 0x00800000 #define CRYPTO_TFM_RES_BAD_FLAGS 0x01000000 /* * Miscellaneous stuff. */ #define CRYPTO_MAX_ALG_NAME 128 /* * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual * declaration) is used to ensure that the crypto_tfm context structure is * aligned correctly for the given architecture so that there are no alignment * faults for C data types. On architectures that support non-cache coherent * DMA, such as ARM or arm64, it also takes into account the minimal alignment * that is required to ensure that the context struct member does not share any * cachelines with the rest of the struct. This is needed to ensure that cache * maintenance for non-coherent DMA (cache invalidation in particular) does not * affect data that may be accessed by the CPU concurrently. */ #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN))) struct scatterlist; struct crypto_ablkcipher; struct crypto_async_request; struct crypto_blkcipher; struct crypto_tfm; struct crypto_type; typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err); /** * DOC: Block Cipher Context Data Structures * * These data structures define the operating context for each block cipher * type. */ struct crypto_async_request { struct list_head list; crypto_completion_t complete; void *data; struct crypto_tfm *tfm; u32 flags; }; struct ablkcipher_request { struct crypto_async_request base; unsigned int nbytes; void *info; struct scatterlist *src; struct scatterlist *dst; void *__ctx[] CRYPTO_MINALIGN_ATTR; }; struct blkcipher_desc { struct crypto_blkcipher *tfm; void *info; u32 flags; }; /** * DOC: Block Cipher Algorithm Definitions * * These data structures define modular crypto algorithm implementations, * managed via crypto_register_alg() and crypto_unregister_alg(). */ /** * struct ablkcipher_alg - asynchronous block cipher definition * @min_keysize: Minimum key size supported by the transformation. This is the * smallest key length supported by this transformation algorithm. * This must be set to one of the pre-defined values as this is * not hardware specific. Possible values for this field can be * found via git grep "_MIN_KEY_SIZE" include/crypto/ * @max_keysize: Maximum key size supported by the transformation. This is the * largest key length supported by this transformation algorithm. * This must be set to one of the pre-defined values as this is * not hardware specific. Possible values for this field can be * found via git grep "_MAX_KEY_SIZE" include/crypto/ * @setkey: Set key for the transformation. This function is used to either * program a supplied key into the hardware or store the key in the * transformation context for programming it later. Note that this * function does modify the transformation context. This function can * be called multiple times during the existence of the transformation * object, so one must make sure the key is properly reprogrammed into * the hardware. This function is also responsible for checking the key * length for validity. In case a software fallback was put in place in * the @cra_init call, this function might need to use the fallback if * the algorithm doesn't support all of the key sizes. * @encrypt: Encrypt a scatterlist of blocks. This function is used to encrypt * the supplied scatterlist containing the blocks of data. The crypto * API consumer is responsible for aligning the entries of the * scatterlist properly and making sure the chunks are correctly * sized. In case a software fallback was put in place in the * @cra_init call, this function might need to use the fallback if * the algorithm doesn't support all of the key sizes. In case the * key was stored in transformation context, the key might need to be * re-programmed into the hardware in this function. This function * shall not modify the transformation context, as this function may * be called in parallel with the same transformation object. * @decrypt: Decrypt a single block. This is a reverse counterpart to @encrypt * and the conditions are exactly the same. * @ivsize: IV size applicable for transformation. The consumer must provide an * IV of exactly that size to perform the encrypt or decrypt operation. * * All fields except @ivsize are mandatory and must be filled. */ struct ablkcipher_alg { int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key, unsigned int keylen); int (*encrypt)(struct ablkcipher_request *req); int (*decrypt)(struct ablkcipher_request *req); unsigned int min_keysize; unsigned int max_keysize; unsigned int ivsize; }; /** * struct blkcipher_alg - synchronous block cipher definition * @min_keysize: see struct ablkcipher_alg * @max_keysize: see struct ablkcipher_alg * @setkey: see struct ablkcipher_alg * @encrypt: see struct ablkcipher_alg * @decrypt: see struct ablkcipher_alg * @ivsize: see struct ablkcipher_alg * * All fields except @ivsize are mandatory and must be filled. */ struct blkcipher_alg { int (*setkey)(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen); int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes); int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes); unsigned int min_keysize; unsigned int max_keysize; unsigned int ivsize; }; /** * struct cipher_alg - single-block symmetric ciphers definition * @cia_min_keysize: Minimum key size supported by the transformation. This is * the smallest key length supported by this transformation * algorithm. This must be set to one of the pre-defined * values as this is not hardware specific. Possible values * for this field can be found via git grep "_MIN_KEY_SIZE" * include/crypto/ * @cia_max_keysize: Maximum key size supported by the transformation. This is * the largest key length supported by this transformation * algorithm. This must be set to one of the pre-defined values * as this is not hardware specific. Possible values for this * field can be found via git grep "_MAX_KEY_SIZE" * include/crypto/ * @cia_setkey: Set key for the transformation. This function is used to either * program a supplied key into the hardware or store the key in the * transformation context for programming it later. Note that this * function does modify the transformation context. This function * can be called multiple times during the existence of the * transformation object, so one must make sure the key is properly * reprogrammed into the hardware. This function is also * responsible for checking the key length for validity. * @cia_encrypt: Encrypt a single block. This function is used to encrypt a * single block of data, which must be @cra_blocksize big. This * always operates on a full @cra_blocksize and it is not possible * to encrypt a block of smaller size. The supplied buffers must * therefore also be at least of @cra_blocksize size. Both the * input and output buffers are always aligned to @cra_alignmask. * In case either of the input or output buffer supplied by user * of the crypto API is not aligned to @cra_alignmask, the crypto * API will re-align the buffers. The re-alignment means that a * new buffer will be allocated, the data will be copied into the * new buffer, then the processing will happen on the new buffer, * then the data will be copied back into the original buffer and * finally the new buffer will be freed. In case a software * fallback was put in place in the @cra_init call, this function * might need to use the fallback if the algorithm doesn't support * all of the key sizes. In case the key was stored in * transformation context, the key might need to be re-programmed * into the hardware in this function. This function shall not * modify the transformation context, as this function may be * called in parallel with the same transformation object. * @cia_decrypt: Decrypt a single block. This is a reverse counterpart to * @cia_encrypt, and the conditions are exactly the same. * * All fields are mandatory and must be filled. */ struct cipher_alg { unsigned int cia_min_keysize; unsigned int cia_max_keysize; int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen); void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); }; /** * struct compress_alg - compression/decompression algorithm * @coa_compress: Compress a buffer of specified length, storing the resulting * data in the specified buffer. Return the length of the * compressed data in dlen. * @coa_decompress: Decompress the source buffer, storing the uncompressed * data in the specified buffer. The length of the data is * returned in dlen. * * All fields are mandatory. */ struct compress_alg { int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen); int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen); }; #ifdef CONFIG_CRYPTO_STATS /* * struct crypto_istat_aead - statistics for AEAD algorithm * @encrypt_cnt: number of encrypt requests * @encrypt_tlen: total data size handled by encrypt requests * @decrypt_cnt: number of decrypt requests * @decrypt_tlen: total data size handled by decrypt requests * @err_cnt: number of error for AEAD requests */ struct crypto_istat_aead { atomic64_t encrypt_cnt; atomic64_t encrypt_tlen; atomic64_t decrypt_cnt; atomic64_t decrypt_tlen; atomic64_t err_cnt; }; /* * struct crypto_istat_akcipher - statistics for akcipher algorithm * @encrypt_cnt: number of encrypt requests * @encrypt_tlen: total data size handled by encrypt requests * @decrypt_cnt: number of decrypt requests * @decrypt_tlen: total data size handled by decrypt requests * @verify_cnt: number of verify operation * @sign_cnt: number of sign requests * @err_cnt: number of error for akcipher requests */ struct crypto_istat_akcipher { atomic64_t encrypt_cnt; atomic64_t encrypt_tlen; atomic64_t decrypt_cnt; atomic64_t decrypt_tlen; atomic64_t verify_cnt; atomic64_t sign_cnt; atomic64_t err_cnt; }; /* * struct crypto_istat_cipher - statistics for cipher algorithm * @encrypt_cnt: number of encrypt requests * @encrypt_tlen: total data size handled by encrypt requests * @decrypt_cnt: number of decrypt requests * @decrypt_tlen: total data size handled by decrypt requests * @err_cnt: number of error for cipher requests */ struct crypto_istat_cipher { atomic64_t encrypt_cnt; atomic64_t encrypt_tlen; atomic64_t decrypt_cnt; atomic64_t decrypt_tlen; atomic64_t err_cnt; }; /* * struct crypto_istat_compress - statistics for compress algorithm * @compress_cnt: number of compress requests * @compress_tlen: total data size handled by compress requests * @decompress_cnt: number of decompress requests * @decompress_tlen: total data size handled by decompress requests * @err_cnt: number of error for compress requests */ struct crypto_istat_compress { atomic64_t compress_cnt; atomic64_t compress_tlen; atomic64_t decompress_cnt; atomic64_t decompress_tlen; atomic64_t err_cnt; }; /* * struct crypto_istat_hash - statistics for has algorithm * @hash_cnt: number of hash requests * @hash_tlen: total data size hashed * @err_cnt: number of error for hash requests */ struct crypto_istat_hash { atomic64_t hash_cnt; atomic64_t hash_tlen; atomic64_t err_cnt; }; /* * struct crypto_istat_kpp - statistics for KPP algorithm * @setsecret_cnt: number of setsecrey operation * @generate_public_key_cnt: number of generate_public_key operation * @compute_shared_secret_cnt: number of compute_shared_secret operation * @err_cnt: number of error for KPP requests */ struct crypto_istat_kpp { atomic64_t setsecret_cnt; atomic64_t generate_public_key_cnt; atomic64_t compute_shared_secret_cnt; atomic64_t err_cnt; }; /* * struct crypto_istat_rng: statistics for RNG algorithm * @generate_cnt: number of RNG generate requests * @generate_tlen: total data size of generated data by the RNG * @seed_cnt: number of times the RNG was seeded * @err_cnt: number of error for RNG requests */ struct crypto_istat_rng { atomic64_t generate_cnt; atomic64_t generate_tlen; atomic64_t seed_cnt; atomic64_t err_cnt; }; #endif /* CONFIG_CRYPTO_STATS */ #define cra_ablkcipher cra_u.ablkcipher #define cra_blkcipher cra_u.blkcipher #define cra_cipher cra_u.cipher #define cra_compress cra_u.compress /** * struct crypto_alg - definition of a cryptograpic cipher algorithm * @cra_flags: Flags describing this transformation. See include/linux/crypto.h * CRYPTO_ALG_* flags for the flags which go in here. Those are * used for fine-tuning the description of the transformation * algorithm. * @cra_blocksize: Minimum block size of this transformation. The size in bytes * of the smallest possible unit which can be transformed with * this algorithm. The users must respect this value. * In case of HASH transformation, it is possible for a smaller * block than @cra_blocksize to be passed to the crypto API for * transformation, in case of any other transformation type, an * error will be returned upon any attempt to transform smaller * than @cra_blocksize chunks. * @cra_ctxsize: Size of the operational context of the transformation. This * value informs the kernel crypto API about the memory size * needed to be allocated for the transformation context. * @cra_alignmask: Alignment mask for the input and output data buffer. The data * buffer containing the input data for the algorithm must be * aligned to this alignment mask. The data buffer for the * output data must be aligned to this alignment mask. Note that * the Crypto API will do the re-alignment in software, but * only under special conditions and there is a performance hit. * The re-alignment happens at these occasions for different * @cra_u types: cipher -- For both input data and output data * buffer; ahash -- For output hash destination buf; shash -- * For output hash destination buf. * This is needed on hardware which is flawed by design and * cannot pick data from arbitrary addresses. * @cra_priority: Priority of this transformation implementation. In case * multiple transformations with same @cra_name are available to * the Crypto API, the kernel will use the one with highest * @cra_priority. * @cra_name: Generic name (usable by multiple implementations) of the * transformation algorithm. This is the name of the transformation * itself. This field is used by the kernel when looking up the * providers of particular transformation. * @cra_driver_name: Unique name of the transformation provider. This is the * name of the provider of the transformation. This can be any * arbitrary value, but in the usual case, this contains the * name of the chip or provider and the name of the * transformation algorithm. * @cra_type: Type of the cryptographic transformation. This is a pointer to * struct crypto_type, which implements callbacks common for all * transformation types. There are multiple options: * &crypto_blkcipher_type, &crypto_ablkcipher_type, * &crypto_ahash_type, &crypto_rng_type. * This field might be empty. In that case, there are no common * callbacks. This is the case for: cipher, compress, shash. * @cra_u: Callbacks implementing the transformation. This is a union of * multiple structures. Depending on the type of transformation selected * by @cra_type and @cra_flags above, the associated structure must be * filled with callbacks. This field might be empty. This is the case * for ahash, shash. * @cra_init: Initialize the cryptographic transformation object. This function * is used to initialize the cryptographic transformation object. * This function is called only once at the instantiation time, right * after the transformation context was allocated. In case the * cryptographic hardware has some special requirements which need to * be handled by software, this function shall check for the precise * requirement of the transformation and put any software fallbacks * in place. * @cra_exit: Deinitialize the cryptographic transformation object. This is a * counterpart to @cra_init, used to remove various changes set in * @cra_init. * @cra_u.ablkcipher: Union member which contains an asynchronous block cipher * definition. See @struct @ablkcipher_alg. * @cra_u.blkcipher: Union member which contains a synchronous block cipher * definition See @struct @blkcipher_alg. * @cra_u.cipher: Union member which contains a single-block symmetric cipher * definition. See @struct @cipher_alg. * @cra_u.compress: Union member which contains a (de)compression algorithm. * See @struct @compress_alg. * @cra_module: Owner of this transformation implementation. Set to THIS_MODULE * @cra_list: internally used * @cra_users: internally used * @cra_refcnt: internally used * @cra_destroy: internally used * * @stats: union of all possible crypto_istat_xxx structures * @stats.aead: statistics for AEAD algorithm * @stats.akcipher: statistics for akcipher algorithm * @stats.cipher: statistics for cipher algorithm * @stats.compress: statistics for compress algorithm * @stats.hash: statistics for hash algorithm * @stats.rng: statistics for rng algorithm * @stats.kpp: statistics for KPP algorithm * * The struct crypto_alg describes a generic Crypto API algorithm and is common * for all of the transformations. Any variable not documented here shall not * be used by a cipher implementation as it is internal to the Crypto API. */ struct crypto_alg { struct list_head cra_list; struct list_head cra_users; u32 cra_flags; unsigned int cra_blocksize; unsigned int cra_ctxsize; unsigned int cra_alignmask; int cra_priority; refcount_t cra_refcnt; char cra_name[CRYPTO_MAX_ALG_NAME]; char cra_driver_name[CRYPTO_MAX_ALG_NAME]; const struct crypto_type *cra_type; union { struct ablkcipher_alg ablkcipher; struct blkcipher_alg blkcipher; struct cipher_alg cipher; struct compress_alg compress; } cra_u; int (*cra_init)(struct crypto_tfm *tfm); void (*cra_exit)(struct crypto_tfm *tfm); void (*cra_destroy)(struct crypto_alg *alg); struct module *cra_module; #ifdef CONFIG_CRYPTO_STATS union { struct crypto_istat_aead aead; struct crypto_istat_akcipher akcipher; struct crypto_istat_cipher cipher; struct crypto_istat_compress compress; struct crypto_istat_hash hash; struct crypto_istat_rng rng; struct crypto_istat_kpp kpp; } stats; #endif /* CONFIG_CRYPTO_STATS */ } CRYPTO_MINALIGN_ATTR; #ifdef CONFIG_CRYPTO_STATS void crypto_stats_init(struct crypto_alg *alg); void crypto_stats_get(struct crypto_alg *alg); void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg); void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg); void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret); void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret); void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg); void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg); void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg); void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg); void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg); void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg); void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg); void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg); void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret); void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret); void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret); void crypto_stats_rng_seed(struct crypto_alg *alg, int ret); void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret); void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg); void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg); #else static inline void crypto_stats_init(struct crypto_alg *alg) {} static inline void crypto_stats_get(struct crypto_alg *alg) {} static inline void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret) {} static inline void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret) {} static inline void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg) {} static inline void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg) {} static inline void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret) {} static inline void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret) {} static inline void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret) {} static inline void crypto_stats_rng_seed(struct crypto_alg *alg, int ret) {} static inline void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret) {} static inline void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg) {} static inline void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg) {} #endif /* * A helper struct for waiting for completion of async crypto ops */ struct crypto_wait { struct completion completion; int err; }; /* * Macro for declaring a crypto op async wait object on stack */ #define DECLARE_CRYPTO_WAIT(_wait) \ struct crypto_wait _wait = { \ COMPLETION_INITIALIZER_ONSTACK((_wait).completion), 0 } /* * Async ops completion helper functioons */ void crypto_req_done(struct crypto_async_request *req, int err); static inline int crypto_wait_req(int err, struct crypto_wait *wait) { switch (err) { case -EINPROGRESS: case -EBUSY: wait_for_completion(&wait->completion); reinit_completion(&wait->completion); err = wait->err; break; }; return err; } static inline void crypto_init_wait(struct crypto_wait *wait) { init_completion(&wait->completion); } /* * Algorithm registration interface. */ int crypto_register_alg(struct crypto_alg *alg); int crypto_unregister_alg(struct crypto_alg *alg); int crypto_register_algs(struct crypto_alg *algs, int count); int crypto_unregister_algs(struct crypto_alg *algs, int count); /* * Algorithm query interface. */ int crypto_has_alg(const char *name, u32 type, u32 mask); /* * Transforms: user-instantiated objects which encapsulate algorithms * and core processing logic. Managed via crypto_alloc_*() and * crypto_free_*(), as well as the various helpers below. */ struct ablkcipher_tfm { int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key, unsigned int keylen); int (*encrypt)(struct ablkcipher_request *req); int (*decrypt)(struct ablkcipher_request *req); struct crypto_ablkcipher *base; unsigned int ivsize; unsigned int reqsize; }; struct blkcipher_tfm { void *iv; int (*setkey)(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen); int (*encrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes); int (*decrypt)(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes); }; struct cipher_tfm { int (*cit_setkey)(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen); void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); }; struct compress_tfm { int (*cot_compress)(struct crypto_tfm *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen); int (*cot_decompress)(struct crypto_tfm *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen); }; #define crt_ablkcipher crt_u.ablkcipher #define crt_blkcipher crt_u.blkcipher #define crt_cipher crt_u.cipher #define crt_compress crt_u.compress struct crypto_tfm { u32 crt_flags; union { struct ablkcipher_tfm ablkcipher; struct blkcipher_tfm blkcipher; struct cipher_tfm cipher; struct compress_tfm compress; } crt_u; void (*exit)(struct crypto_tfm *tfm); struct crypto_alg *__crt_alg; void *__crt_ctx[] CRYPTO_MINALIGN_ATTR; }; struct crypto_ablkcipher { struct crypto_tfm base; }; struct crypto_blkcipher { struct crypto_tfm base; }; struct crypto_cipher { struct crypto_tfm base; }; struct crypto_comp { struct crypto_tfm base; }; enum { CRYPTOA_UNSPEC, CRYPTOA_ALG, CRYPTOA_TYPE, CRYPTOA_U32, __CRYPTOA_MAX, }; #define CRYPTOA_MAX (__CRYPTOA_MAX - 1) /* Maximum number of (rtattr) parameters for each template. */ #define CRYPTO_MAX_ATTRS 32 struct crypto_attr_alg { char name[CRYPTO_MAX_ALG_NAME]; }; struct crypto_attr_type { u32 type; u32 mask; }; struct crypto_attr_u32 { u32 num; }; /* * Transform user interface. */ struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask); void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm); static inline void crypto_free_tfm(struct crypto_tfm *tfm) { return crypto_destroy_tfm(tfm, tfm); } int alg_test(const char *driver, const char *alg, u32 type, u32 mask); /* * Transform helpers which query the underlying algorithm. */ static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm) { return tfm->__crt_alg->cra_name; } static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm) { return tfm->__crt_alg->cra_driver_name; } static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm) { return tfm->__crt_alg->cra_priority; } static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm) { return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK; } static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm) { return tfm->__crt_alg->cra_blocksize; } static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm) { return tfm->__crt_alg->cra_alignmask; } static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm) { return tfm->crt_flags; } static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags) { tfm->crt_flags |= flags; } static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags) { tfm->crt_flags &= ~flags; } static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm) { return tfm->__crt_ctx; } static inline unsigned int crypto_tfm_ctx_alignment(void) { struct crypto_tfm *tfm; return __alignof__(tfm->__crt_ctx); } /* * API wrappers. */ static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast( struct crypto_tfm *tfm) { return (struct crypto_ablkcipher *)tfm; } static inline u32 crypto_skcipher_type(u32 type) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_BLKCIPHER; return type; } static inline u32 crypto_skcipher_mask(u32 mask) { mask &= ~CRYPTO_ALG_TYPE_MASK; mask |= CRYPTO_ALG_TYPE_BLKCIPHER_MASK; return mask; } /** * DOC: Asynchronous Block Cipher API * * Asynchronous block cipher API is used with the ciphers of type * CRYPTO_ALG_TYPE_ABLKCIPHER (listed as type "ablkcipher" in /proc/crypto). * * Asynchronous cipher operations imply that the function invocation for a * cipher request returns immediately before the completion of the operation. * The cipher request is scheduled as a separate kernel thread and therefore * load-balanced on the different CPUs via the process scheduler. To allow * the kernel crypto API to inform the caller about the completion of a cipher * request, the caller must provide a callback function. That function is * invoked with the cipher handle when the request completes. * * To support the asynchronous operation, additional information than just the * cipher handle must be supplied to the kernel crypto API. That additional * information is given by filling in the ablkcipher_request data structure. * * For the asynchronous block cipher API, the state is maintained with the tfm * cipher handle. A single tfm can be used across multiple calls and in * parallel. For asynchronous block cipher calls, context data supplied and * only used by the caller can be referenced the request data structure in * addition to the IV used for the cipher request. The maintenance of such * state information would be important for a crypto driver implementer to * have, because when calling the callback function upon completion of the * cipher operation, that callback function may need some information about * which operation just finished if it invoked multiple in parallel. This * state information is unused by the kernel crypto API. */ static inline struct crypto_tfm *crypto_ablkcipher_tfm( struct crypto_ablkcipher *tfm) { return &tfm->base; } /** * crypto_free_ablkcipher() - zeroize and free cipher handle * @tfm: cipher handle to be freed */ static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm) { crypto_free_tfm(crypto_ablkcipher_tfm(tfm)); } /** * crypto_has_ablkcipher() - Search for the availability of an ablkcipher. * @alg_name: is the cra_name / name or cra_driver_name / driver name of the * ablkcipher * @type: specifies the type of the cipher * @mask: specifies the mask for the cipher * * Return: true when the ablkcipher is known to the kernel crypto API; false * otherwise */ static inline int crypto_has_ablkcipher(const char *alg_name, u32 type, u32 mask) { return crypto_has_alg(alg_name, crypto_skcipher_type(type), crypto_skcipher_mask(mask)); } static inline struct ablkcipher_tfm *crypto_ablkcipher_crt( struct crypto_ablkcipher *tfm) { return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher; } /** * crypto_ablkcipher_ivsize() - obtain IV size * @tfm: cipher handle * * The size of the IV for the ablkcipher referenced by the cipher handle is * returned. This IV size may be zero if the cipher does not need an IV. * * Return: IV size in bytes */ static inline unsigned int crypto_ablkcipher_ivsize( struct crypto_ablkcipher *tfm) { return crypto_ablkcipher_crt(tfm)->ivsize; } /** * crypto_ablkcipher_blocksize() - obtain block size of cipher * @tfm: cipher handle * * The block size for the ablkcipher referenced with the cipher handle is * returned. The caller may use that information to allocate appropriate * memory for the data returned by the encryption or decryption operation * * Return: block size of cipher */ static inline unsigned int crypto_ablkcipher_blocksize( struct crypto_ablkcipher *tfm) { return crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(tfm)); } static inline unsigned int crypto_ablkcipher_alignmask( struct crypto_ablkcipher *tfm) { return crypto_tfm_alg_alignmask(crypto_ablkcipher_tfm(tfm)); } static inline u32 crypto_ablkcipher_get_flags(struct crypto_ablkcipher *tfm) { return crypto_tfm_get_flags(crypto_ablkcipher_tfm(tfm)); } static inline void crypto_ablkcipher_set_flags(struct crypto_ablkcipher *tfm, u32 flags) { crypto_tfm_set_flags(crypto_ablkcipher_tfm(tfm), flags); } static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm, u32 flags) { crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags); } /** * crypto_ablkcipher_setkey() - set key for cipher * @tfm: cipher handle * @key: buffer holding the key * @keylen: length of the key in bytes * * The caller provided key is set for the ablkcipher referenced by the cipher * handle. * * Note, the key length determines the cipher type. Many block ciphers implement * different cipher modes depending on the key size, such as AES-128 vs AES-192 * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128 * is performed. * * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm, const u8 *key, unsigned int keylen) { struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(tfm); return crt->setkey(crt->base, key, keylen); } /** * crypto_ablkcipher_reqtfm() - obtain cipher handle from request * @req: ablkcipher_request out of which the cipher handle is to be obtained * * Return the crypto_ablkcipher handle when furnishing an ablkcipher_request * data structure. * * Return: crypto_ablkcipher handle */ static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm( struct ablkcipher_request *req) { return __crypto_ablkcipher_cast(req->base.tfm); } /** * crypto_ablkcipher_encrypt() - encrypt plaintext * @req: reference to the ablkcipher_request handle that holds all information * needed to perform the cipher operation * * Encrypt plaintext data using the ablkcipher_request handle. That data * structure and how it is filled with data is discussed with the * ablkcipher_request_* functions. * * Return: 0 if the cipher operation was successful; < 0 if an error occurred */ static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req) { struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req)); struct crypto_alg *alg = crt->base->base.__crt_alg; unsigned int nbytes = req->nbytes; int ret; crypto_stats_get(alg); ret = crt->encrypt(req); crypto_stats_ablkcipher_encrypt(nbytes, ret, alg); return ret; } /** * crypto_ablkcipher_decrypt() - decrypt ciphertext * @req: reference to the ablkcipher_request handle that holds all information * needed to perform the cipher operation * * Decrypt ciphertext data using the ablkcipher_request handle. That data * structure and how it is filled with data is discussed with the * ablkcipher_request_* functions. * * Return: 0 if the cipher operation was successful; < 0 if an error occurred */ static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req) { struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req)); struct crypto_alg *alg = crt->base->base.__crt_alg; unsigned int nbytes = req->nbytes; int ret; crypto_stats_get(alg); ret = crt->decrypt(req); crypto_stats_ablkcipher_decrypt(nbytes, ret, alg); return ret; } /** * DOC: Asynchronous Cipher Request Handle * * The ablkcipher_request data structure contains all pointers to data * required for the asynchronous cipher operation. This includes the cipher * handle (which can be used by multiple ablkcipher_request instances), pointer * to plaintext and ciphertext, asynchronous callback function, etc. It acts * as a handle to the ablkcipher_request_* API calls in a similar way as * ablkcipher handle to the crypto_ablkcipher_* API calls. */ /** * crypto_ablkcipher_reqsize() - obtain size of the request data structure * @tfm: cipher handle * * Return: number of bytes */ static inline unsigned int crypto_ablkcipher_reqsize( struct crypto_ablkcipher *tfm) { return crypto_ablkcipher_crt(tfm)->reqsize; } /** * ablkcipher_request_set_tfm() - update cipher handle reference in request * @req: request handle to be modified * @tfm: cipher handle that shall be added to the request handle * * Allow the caller to replace the existing ablkcipher handle in the request * data structure with a different one. */ static inline void ablkcipher_request_set_tfm( struct ablkcipher_request *req, struct crypto_ablkcipher *tfm) { req->base.tfm = crypto_ablkcipher_tfm(crypto_ablkcipher_crt(tfm)->base); } static inline struct ablkcipher_request *ablkcipher_request_cast( struct crypto_async_request *req) { return container_of(req, struct ablkcipher_request, base); } /** * ablkcipher_request_alloc() - allocate request data structure * @tfm: cipher handle to be registered with the request * @gfp: memory allocation flag that is handed to kmalloc by the API call. * * Allocate the request data structure that must be used with the ablkcipher * encrypt and decrypt API calls. During the allocation, the provided ablkcipher * handle is registered in the request data structure. * * Return: allocated request handle in case of success, or NULL if out of memory */ static inline struct ablkcipher_request *ablkcipher_request_alloc( struct crypto_ablkcipher *tfm, gfp_t gfp) { struct ablkcipher_request *req; req = kmalloc(sizeof(struct ablkcipher_request) + crypto_ablkcipher_reqsize(tfm), gfp); if (likely(req)) ablkcipher_request_set_tfm(req, tfm); return req; } /** * ablkcipher_request_free() - zeroize and free request data structure * @req: request data structure cipher handle to be freed */ static inline void ablkcipher_request_free(struct ablkcipher_request *req) { kzfree(req); } /** * ablkcipher_request_set_callback() - set asynchronous callback function * @req: request handle * @flags: specify zero or an ORing of the flags * CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and * increase the wait queue beyond the initial maximum size; * CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep * @compl: callback function pointer to be registered with the request handle * @data: The data pointer refers to memory that is not used by the kernel * crypto API, but provided to the callback function for it to use. Here, * the caller can provide a reference to memory the callback function can * operate on. As the callback function is invoked asynchronously to the * related functionality, it may need to access data structures of the * related functionality which can be referenced using this pointer. The * callback function can access the memory via the "data" field in the * crypto_async_request data structure provided to the callback function. * * This function allows setting the callback function that is triggered once the * cipher operation completes. * * The callback function is registered with the ablkcipher_request handle and * must comply with the following template:: * * void callback_function(struct crypto_async_request *req, int error) */ static inline void ablkcipher_request_set_callback( struct ablkcipher_request *req, u32 flags, crypto_completion_t compl, void *data) { req->base.complete = compl; req->base.data = data; req->base.flags = flags; } /** * ablkcipher_request_set_crypt() - set data buffers * @req: request handle * @src: source scatter / gather list * @dst: destination scatter / gather list * @nbytes: number of bytes to process from @src * @iv: IV for the cipher operation which must comply with the IV size defined * by crypto_ablkcipher_ivsize * * This function allows setting of the source data and destination data * scatter / gather lists. * * For encryption, the source is treated as the plaintext and the * destination is the ciphertext. For a decryption operation, the use is * reversed - the source is the ciphertext and the destination is the plaintext. */ static inline void ablkcipher_request_set_crypt( struct ablkcipher_request *req, struct scatterlist *src, struct scatterlist *dst, unsigned int nbytes, void *iv) { req->src = src; req->dst = dst; req->nbytes = nbytes; req->info = iv; } /** * DOC: Synchronous Block Cipher API * * The synchronous block cipher API is used with the ciphers of type * CRYPTO_ALG_TYPE_BLKCIPHER (listed as type "blkcipher" in /proc/crypto) * * Synchronous calls, have a context in the tfm. But since a single tfm can be * used in multiple calls and in parallel, this info should not be changeable * (unless a lock is used). This applies, for example, to the symmetric key. * However, the IV is changeable, so there is an iv field in blkcipher_tfm * structure for synchronous blkcipher api. So, its the only state info that can * be kept for synchronous calls without using a big lock across a tfm. * * The block cipher API allows the use of a complete cipher, i.e. a cipher * consisting of a template (a block chaining mode) and a single block cipher * primitive (e.g. AES). * * The plaintext data buffer and the ciphertext data buffer are pointed to * by using scatter/gather lists. The cipher operation is performed * on all segments of the provided scatter/gather lists. * * The kernel crypto API supports a cipher operation "in-place" which means that * the caller may provide the same scatter/gather list for the plaintext and * cipher text. After the completion of the cipher operation, the plaintext * data is replaced with the ciphertext data in case of an encryption and vice * versa for a decryption. The caller must ensure that the scatter/gather lists * for the output data point to sufficiently large buffers, i.e. multiples of * the block size of the cipher. */ static inline struct crypto_blkcipher *__crypto_blkcipher_cast( struct crypto_tfm *tfm) { return (struct crypto_blkcipher *)tfm; } static inline struct crypto_blkcipher *crypto_blkcipher_cast( struct crypto_tfm *tfm) { BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER); return __crypto_blkcipher_cast(tfm); } /** * crypto_alloc_blkcipher() - allocate synchronous block cipher handle * @alg_name: is the cra_name / name or cra_driver_name / driver name of the * blkcipher cipher * @type: specifies the type of the cipher * @mask: specifies the mask for the cipher * * Allocate a cipher handle for a block cipher. The returned struct * crypto_blkcipher is the cipher handle that is required for any subsequent * API invocation for that block cipher. * * Return: allocated cipher handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ static inline struct crypto_blkcipher *crypto_alloc_blkcipher( const char *alg_name, u32 type, u32 mask) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_BLKCIPHER; mask |= CRYPTO_ALG_TYPE_MASK; return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask)); } static inline struct crypto_tfm *crypto_blkcipher_tfm( struct crypto_blkcipher *tfm) { return &tfm->base; } /** * crypto_free_blkcipher() - zeroize and free the block cipher handle * @tfm: cipher handle to be freed */ static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm) { crypto_free_tfm(crypto_blkcipher_tfm(tfm)); } /** * crypto_has_blkcipher() - Search for the availability of a block cipher * @alg_name: is the cra_name / name or cra_driver_name / driver name of the * block cipher * @type: specifies the type of the cipher * @mask: specifies the mask for the cipher * * Return: true when the block cipher is known to the kernel crypto API; false * otherwise */ static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_BLKCIPHER; mask |= CRYPTO_ALG_TYPE_MASK; return crypto_has_alg(alg_name, type, mask); } /** * crypto_blkcipher_name() - return the name / cra_name from the cipher handle * @tfm: cipher handle * * Return: The character string holding the name of the cipher */ static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm) { return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm)); } static inline struct blkcipher_tfm *crypto_blkcipher_crt( struct crypto_blkcipher *tfm) { return &crypto_blkcipher_tfm(tfm)->crt_blkcipher; } static inline struct blkcipher_alg *crypto_blkcipher_alg( struct crypto_blkcipher *tfm) { return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher; } /** * crypto_blkcipher_ivsize() - obtain IV size * @tfm: cipher handle * * The size of the IV for the block cipher referenced by the cipher handle is * returned. This IV size may be zero if the cipher does not need an IV. * * Return: IV size in bytes */ static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm) { return crypto_blkcipher_alg(tfm)->ivsize; } /** * crypto_blkcipher_blocksize() - obtain block size of cipher * @tfm: cipher handle * * The block size for the block cipher referenced with the cipher handle is * returned. The caller may use that information to allocate appropriate * memory for the data returned by the encryption or decryption operation. * * Return: block size of cipher */ static inline unsigned int crypto_blkcipher_blocksize( struct crypto_blkcipher *tfm) { return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm)); } static inline unsigned int crypto_blkcipher_alignmask( struct crypto_blkcipher *tfm) { return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm)); } static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm) { return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm)); } static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm, u32 flags) { crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags); } static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm, u32 flags) { crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags); } /** * crypto_blkcipher_setkey() - set key for cipher * @tfm: cipher handle * @key: buffer holding the key * @keylen: length of the key in bytes * * The caller provided key is set for the block cipher referenced by the cipher * handle. * * Note, the key length determines the cipher type. Many block ciphers implement * different cipher modes depending on the key size, such as AES-128 vs AES-192 * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128 * is performed. * * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm, const u8 *key, unsigned int keylen) { return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm), key, keylen); } /** * crypto_blkcipher_encrypt() - encrypt plaintext * @desc: reference to the block cipher handle with meta data * @dst: scatter/gather list that is filled by the cipher operation with the * ciphertext * @src: scatter/gather list that holds the plaintext * @nbytes: number of bytes of the plaintext to encrypt. * * Encrypt plaintext data using the IV set by the caller with a preceding * call of crypto_blkcipher_set_iv. * * The blkcipher_desc data structure must be filled by the caller and can * reside on the stack. The caller must fill desc as follows: desc.tfm is filled * with the block cipher handle; desc.flags is filled with either * CRYPTO_TFM_REQ_MAY_SLEEP or 0. * * Return: 0 if the cipher operation was successful; < 0 if an error occurred */ static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes) { desc->info = crypto_blkcipher_crt(desc->tfm)->iv; return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes); } /** * crypto_blkcipher_encrypt_iv() - encrypt plaintext with dedicated IV * @desc: reference to the block cipher handle with meta data * @dst: scatter/gather list that is filled by the cipher operation with the * ciphertext * @src: scatter/gather list that holds the plaintext * @nbytes: number of bytes of the plaintext to encrypt. * * Encrypt plaintext data with the use of an IV that is solely used for this * cipher operation. Any previously set IV is not used. * * The blkcipher_desc data structure must be filled by the caller and can * reside on the stack. The caller must fill desc as follows: desc.tfm is filled * with the block cipher handle; desc.info is filled with the IV to be used for * the current operation; desc.flags is filled with either * CRYPTO_TFM_REQ_MAY_SLEEP or 0. * * Return: 0 if the cipher operation was successful; < 0 if an error occurred */ static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes) { return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes); } /** * crypto_blkcipher_decrypt() - decrypt ciphertext * @desc: reference to the block cipher handle with meta data * @dst: scatter/gather list that is filled by the cipher operation with the * plaintext * @src: scatter/gather list that holds the ciphertext * @nbytes: number of bytes of the ciphertext to decrypt. * * Decrypt ciphertext data using the IV set by the caller with a preceding * call of crypto_blkcipher_set_iv. * * The blkcipher_desc data structure must be filled by the caller as documented * for the crypto_blkcipher_encrypt call above. * * Return: 0 if the cipher operation was successful; < 0 if an error occurred * */ static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes) { desc->info = crypto_blkcipher_crt(desc->tfm)->iv; return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes); } /** * crypto_blkcipher_decrypt_iv() - decrypt ciphertext with dedicated IV * @desc: reference to the block cipher handle with meta data * @dst: scatter/gather list that is filled by the cipher operation with the * plaintext * @src: scatter/gather list that holds the ciphertext * @nbytes: number of bytes of the ciphertext to decrypt. * * Decrypt ciphertext data with the use of an IV that is solely used for this * cipher operation. Any previously set IV is not used. * * The blkcipher_desc data structure must be filled by the caller as documented * for the crypto_blkcipher_encrypt_iv call above. * * Return: 0 if the cipher operation was successful; < 0 if an error occurred */ static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes) { return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes); } /** * crypto_blkcipher_set_iv() - set IV for cipher * @tfm: cipher handle * @src: buffer holding the IV * @len: length of the IV in bytes * * The caller provided IV is set for the block cipher referenced by the cipher * handle. */ static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm, const u8 *src, unsigned int len) { memcpy(crypto_blkcipher_crt(tfm)->iv, src, len); } /** * crypto_blkcipher_get_iv() - obtain IV from cipher * @tfm: cipher handle * @dst: buffer filled with the IV * @len: length of the buffer dst * * The caller can obtain the IV set for the block cipher referenced by the * cipher handle and store it into the user-provided buffer. If the buffer * has an insufficient space, the IV is truncated to fit the buffer. */ static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm, u8 *dst, unsigned int len) { memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len); } /** * DOC: Single Block Cipher API * * The single block cipher API is used with the ciphers of type * CRYPTO_ALG_TYPE_CIPHER (listed as type "cipher" in /proc/crypto). * * Using the single block cipher API calls, operations with the basic cipher * primitive can be implemented. These cipher primitives exclude any block * chaining operations including IV handling. * * The purpose of this single block cipher API is to support the implementation * of templates or other concepts that only need to perform the cipher operation * on one block at a time. Templates invoke the underlying cipher primitive * block-wise and process either the input or the output data of these cipher * operations. */ static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm) { return (struct crypto_cipher *)tfm; } static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm) { BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER); return __crypto_cipher_cast(tfm); } /** * crypto_alloc_cipher() - allocate single block cipher handle * @alg_name: is the cra_name / name or cra_driver_name / driver name of the * single block cipher * @type: specifies the type of the cipher * @mask: specifies the mask for the cipher * * Allocate a cipher handle for a single block cipher. The returned struct * crypto_cipher is the cipher handle that is required for any subsequent API * invocation for that single block cipher. * * Return: allocated cipher handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name, u32 type, u32 mask) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_CIPHER; mask |= CRYPTO_ALG_TYPE_MASK; return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask)); } static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm) { return &tfm->base; } /** * crypto_free_cipher() - zeroize and free the single block cipher handle * @tfm: cipher handle to be freed */ static inline void crypto_free_cipher(struct crypto_cipher *tfm) { crypto_free_tfm(crypto_cipher_tfm(tfm)); } /** * crypto_has_cipher() - Search for the availability of a single block cipher * @alg_name: is the cra_name / name or cra_driver_name / driver name of the * single block cipher * @type: specifies the type of the cipher * @mask: specifies the mask for the cipher * * Return: true when the single block cipher is known to the kernel crypto API; * false otherwise */ static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_CIPHER; mask |= CRYPTO_ALG_TYPE_MASK; return crypto_has_alg(alg_name, type, mask); } static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm) { return &crypto_cipher_tfm(tfm)->crt_cipher; } /** * crypto_cipher_blocksize() - obtain block size for cipher * @tfm: cipher handle * * The block size for the single block cipher referenced with the cipher handle * tfm is returned. The caller may use that information to allocate appropriate * memory for the data returned by the encryption or decryption operation * * Return: block size of cipher */ static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm) { return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm)); } static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm) { return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm)); } static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm) { return crypto_tfm_get_flags(crypto_cipher_tfm(tfm)); } static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm, u32 flags) { crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags); } static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm, u32 flags) { crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags); } /** * crypto_cipher_setkey() - set key for cipher * @tfm: cipher handle * @key: buffer holding the key * @keylen: length of the key in bytes * * The caller provided key is set for the single block cipher referenced by the * cipher handle. * * Note, the key length determines the cipher type. Many block ciphers implement * different cipher modes depending on the key size, such as AES-128 vs AES-192 * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128 * is performed. * * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ static inline int crypto_cipher_setkey(struct crypto_cipher *tfm, const u8 *key, unsigned int keylen) { return crypto_cipher_crt(tfm)->cit_setkey(crypto_cipher_tfm(tfm), key, keylen); } /** * crypto_cipher_encrypt_one() - encrypt one block of plaintext * @tfm: cipher handle * @dst: points to the buffer that will be filled with the ciphertext * @src: buffer holding the plaintext to be encrypted * * Invoke the encryption operation of one block. The caller must ensure that * the plaintext and ciphertext buffers are at least one block in size. */ static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm, u8 *dst, const u8 *src) { crypto_cipher_crt(tfm)->cit_encrypt_one(crypto_cipher_tfm(tfm), dst, src); } /** * crypto_cipher_decrypt_one() - decrypt one block of ciphertext * @tfm: cipher handle * @dst: points to the buffer that will be filled with the plaintext * @src: buffer holding the ciphertext to be decrypted * * Invoke the decryption operation of one block. The caller must ensure that * the plaintext and ciphertext buffers are at least one block in size. */ static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm, u8 *dst, const u8 *src) { crypto_cipher_crt(tfm)->cit_decrypt_one(crypto_cipher_tfm(tfm), dst, src); } static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm) { return (struct crypto_comp *)tfm; } static inline struct crypto_comp *crypto_comp_cast(struct crypto_tfm *tfm) { BUG_ON((crypto_tfm_alg_type(tfm) ^ CRYPTO_ALG_TYPE_COMPRESS) & CRYPTO_ALG_TYPE_MASK); return __crypto_comp_cast(tfm); } static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name, u32 type, u32 mask) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_COMPRESS; mask |= CRYPTO_ALG_TYPE_MASK; return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask)); } static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm) { return &tfm->base; } static inline void crypto_free_comp(struct crypto_comp *tfm) { crypto_free_tfm(crypto_comp_tfm(tfm)); } static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask) { type &= ~CRYPTO_ALG_TYPE_MASK; type |= CRYPTO_ALG_TYPE_COMPRESS; mask |= CRYPTO_ALG_TYPE_MASK; return crypto_has_alg(alg_name, type, mask); } static inline const char *crypto_comp_name(struct crypto_comp *tfm) { return crypto_tfm_alg_name(crypto_comp_tfm(tfm)); } static inline struct compress_tfm *crypto_comp_crt(struct crypto_comp *tfm) { return &crypto_comp_tfm(tfm)->crt_compress; } static inline int crypto_comp_compress(struct crypto_comp *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen) { return crypto_comp_crt(tfm)->cot_compress(crypto_comp_tfm(tfm), src, slen, dst, dlen); } static inline int crypto_comp_decompress(struct crypto_comp *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen) { return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm), src, slen, dst, dlen); } #endif /* _LINUX_CRYPTO_H */
[+]
..
[-] rpmsg.h
[edit]
[-] tty_ldisc.h
[edit]
[-] io-64-nonatomic-hi-lo.h
[edit]
[-] fsl_devices.h
[edit]
[-] ipc_namespace.h
[edit]
[+]
avf
[-] kvm_irqfd.h
[edit]
[-] pwm.h
[edit]
[-] lz4.h
[edit]
[-] virtio_byteorder.h
[edit]
[-] icmp.h
[edit]
[-] sysfs.h
[edit]
[-] sync_file.h
[edit]
[-] elf-fdpic.h
[edit]
[-] pmu.h
[edit]
[-] dm-bufio.h
[edit]
[-] kernelcapi.h
[edit]
[-] if_tap.h
[edit]
[-] serial_bcm63xx.h
[edit]
[+]
decompress
[+]
dsa
[-] connector.h
[edit]
[-] rmap.h
[edit]
[-] ndctl.h
[edit]
[-] ktime.h
[edit]
[-] sh_intc.h
[edit]
[-] timer.h
[edit]
[-] win_minmax.h
[edit]
[-] rslib.h
[edit]
[-] gameport.h
[edit]
[-] hrtimer.h
[edit]
[-] irqreturn.h
[edit]
[-] compiler.h
[edit]
[+]
netfilter
[-] page_idle.h
[edit]
[-] swiotlb.h
[edit]
[-] falloc.h
[edit]
[-] fs_enet_pd.h
[edit]
[-] fd.h
[edit]
[-] assoc_array_priv.h
[edit]
[-] kern_levels.h
[edit]
[+]
unaligned
[-] openvswitch.h
[edit]
[-] nls.h
[edit]
[-] io-64-nonatomic-lo-hi.h
[edit]
[-] attribute_container.h
[edit]
[-] powercap.h
[edit]
[-] stmmac.h
[edit]
[-] bch.h
[edit]
[-] omapfb.h
[edit]
[-] dm-io.h
[edit]
[-] userfaultfd_k.h
[edit]
[-] hid-sensor-ids.h
[edit]
[-] vmalloc.h
[edit]
[-] mISDNhw.h
[edit]
[-] seq_file_net.h
[edit]
[-] pm.h
[edit]
[-] phy_led_triggers.h
[edit]
[-] container.h
[edit]
[+]
byteorder
[-] vmw_vmci_defs.h
[edit]
[-] apple-gmux.h
[edit]
[-] pda_power.h
[edit]
[-] uidgid.h
[edit]
[-] sysv_fs.h
[edit]
[-] seg6_genl.h
[edit]
[-] adfs_fs.h
[edit]
[-] mISDNif.h
[edit]
[-] mod_devicetable.h
[edit]
[-] if_macvlan.h
[edit]
[-] idle_inject.h
[edit]
[-] psci.h
[edit]
[-] rio_regs.h
[edit]
[-] fbcon.h
[edit]
[-] interconnect.h
[edit]
[-] thread_info.h
[edit]
[-] ecryptfs.h
[edit]
[-] sm501-regs.h
[edit]
[-] videodev2.h
[edit]
[-] crc16.h
[edit]
[-] rwlock_api_smp.h
[edit]
[-] netdev_features.h
[edit]
[-] efi-bgrt.h
[edit]
[-] pm_clock.h
[edit]
[-] nvme.h
[edit]
[-] dma-noncoherent.h
[edit]
[-] delay.h
[edit]
[-] dma-iommu.h
[edit]
[-] if_rmnet.h
[edit]
[-] netfilter_defs.h
[edit]
[-] netfilter_bridge.h
[edit]
[-] mv643xx.h
[edit]
[-] ssbi.h
[edit]
[-] of_dma.h
[edit]
[+]
soc
[-] mmiotrace.h
[edit]
[-] asn1_decoder.h
[edit]
[-] if_bridge.h
[edit]
[-] arm-smccc.h
[edit]
[-] coresight.h
[edit]
[-] dcookies.h
[edit]
[-] spinlock_up.h
[edit]
[-] of_address.h
[edit]
[-] isapnp.h
[edit]
[-] pstore_ram.h
[edit]
[-] msg.h
[edit]
[-] dtlk.h
[edit]
[-] mmdebug.h
[edit]
[-] blk-mq-rdma.h
[edit]
[-] tcp.h
[edit]
[-] dma-mapping.h
[edit]
[-] gfp.h
[edit]
[-] nd.h
[edit]
[-] kvm_host.h
[edit]
[+]
ceph
[+]
iio
[-] bpf_lirc.h
[edit]
[-] kdebug.h
[edit]
[-] mutex.h
[edit]
[-] pata_arasan_cf_data.h
[edit]
[-] blkpg.h
[edit]
[-] io-pgtable.h
[edit]
[-] overflow.h
[edit]
[-] genalloc.h
[edit]
[-] blkdev.h
[edit]
[-] atm_tcp.h
[edit]
[-] ppp-comp.h
[edit]
[-] kprobes.h
[edit]
[+]
mmc
[-] hw_breakpoint.h
[edit]
[-] via-core.h
[edit]
[-] semaphore.h
[edit]
[-] genl_magic_func.h
[edit]
[-] memcontrol.h
[edit]
[-] intel-svm.h
[edit]
[-] i2c-algo-bit.h
[edit]
[-] io.h
[edit]
[-] build-salt.h
[edit]
[-] ipmi.h
[edit]
[-] qnx6_fs.h
[edit]
[-] spinlock_api_up.h
[edit]
[-] mpage.h
[edit]
[+]
soundwire
[-] iommu.h
[edit]
[-] security.h
[edit]
[-] parport_pc.h
[edit]
[-] ptrace.h
[edit]
[-] getcpu.h
[edit]
[-] xattr.h
[edit]
[-] raid_class.h
[edit]
[-] mm_inline.h
[edit]
[-] node.h
[edit]
[-] inet_diag.h
[edit]
[-] goldfish.h
[edit]
[-] bitfield.h
[edit]
[-] memblock.h
[edit]
[-] bsearch.h
[edit]
[-] compiler_attributes.h
[edit]
[-] kexec.h
[edit]
[-] pci-ecam.h
[edit]
[-] via.h
[edit]
[-] cgroup.h
[edit]
[-] dma-debug.h
[edit]
[-] swap_cgroup.h
[edit]
[-] nospec.h
[edit]
[-] seg6_iptunnel.h
[edit]
[+]
i3c
[-] errno.h
[edit]
[-] if_eql.h
[edit]
[-] stackleak.h
[edit]
[-] leds-lp3952.h
[edit]
[-] icmpv6.h
[edit]
[+]
mailbox
[-] timerqueue.h
[edit]
[-] memremap.h
[edit]
[-] bsg.h
[edit]
[+]
firmware
[-] task_io_accounting_ops.h
[edit]
[-] uts.h
[edit]
[-] module.h
[edit]
[-] hashtable.h
[edit]
[-] sfi_acpi.h
[edit]
[-] iommu-helper.h
[edit]
[-] flex_proportions.h
[edit]
[-] srcutiny.h
[edit]
[-] posix-clock.h
[edit]
[+]
mlx4
[-] lcd.h
[edit]
[+]
wimax
[-] dm-dirty-log.h
[edit]
[-] dnotify.h
[edit]
[-] ipmi-fru.h
[edit]
[-] acpi_iort.h
[edit]
[-] mc6821.h
[edit]
[-] dm-kcopyd.h
[edit]
[-] backing-dev.h
[edit]
[-] edd.h
[edit]
[-] btree-128.h
[edit]
[-] scpi_protocol.h
[edit]
[-] nfsacl.h
[edit]
[-] stringify.h
[edit]
[-] init.h
[edit]
[-] integrity.h
[edit]
[-] bcm963xx_tag.h
[edit]
[+]
sched
[-] earlycpio.h
[edit]
[-] fec.h
[edit]
[-] dim.h
[edit]
[-] rio_drv.h
[edit]
[-] gpio-pxa.h
[edit]
[-] exportfs.h
[edit]
[-] pxa168_eth.h
[edit]
[-] stat.h
[edit]
[-] microchipphy.h
[edit]
[-] shrinker.h
[edit]
[-] kcov.h
[edit]
[-] olpc-ec.h
[edit]
[-] ns_common.h
[edit]
[-] netfilter.h
[edit]
[-] sm501.h
[edit]
[-] parser.h
[edit]
[-] cordic.h
[edit]
[-] restart_block.h
[edit]
[-] mroute_base.h
[edit]
[-] resource_ext.h
[edit]
[-] rndis.h
[edit]
[-] bit_spinlock.h
[edit]
[-] tboot.h
[edit]
[-] tracehook.h
[edit]
[-] ipack.h
[edit]
[-] err.h
[edit]
[-] fscrypt.h
[edit]
[-] syslog.h
[edit]
[-] mc146818rtc.h
[edit]
[-] seg6.h
[edit]
[-] skb_array.h
[edit]
[-] mISDNdsp.h
[edit]
[-] irq_sim.h
[edit]
[-] kasan-checks.h
[edit]
[-] pci_hotplug.h
[edit]
[-] gpio_keys.h
[edit]
[-] oprofile.h
[edit]
[-] arm_sdei.h
[edit]
[-] sunxi-rsb.h
[edit]
[-] ucb1400.h
[edit]
[-] stm.h
[edit]
[-] hardirq.h
[edit]
[-] xz.h
[edit]
[-] sys.h
[edit]
[-] lightnvm.h
[edit]
[-] mroute6.h
[edit]
[-] atmdev.h
[edit]
[-] sort.h
[edit]
[-] cpu_pm.h
[edit]
[-] mmu_notifier.h
[edit]
[-] z2_battery.h
[edit]
[-] types.h
[edit]
[-] rtmutex.h
[edit]
[-] purgatory.h
[edit]
[-] hil.h
[edit]
[-] printk.h
[edit]
[-] ide.h
[edit]
[-] mm-arch-hooks.h
[edit]
[-] sfi.h
[edit]
[-] devcoredump.h
[edit]
[-] ipmi_smi.h
[edit]
[-] bcm47xx_sprom.h
[edit]
[-] uaccess.h
[edit]
[-] dmar.h
[edit]
[-] kthread.h
[edit]
[-] journal-head.h
[edit]
[-] wm97xx.h
[edit]
[-] irqhandler.h
[edit]
[-] lockdep.h
[edit]
[-] fs_pin.h
[edit]
[-] kbuild.h
[edit]
[-] pstore.h
[edit]
[-] kernel.h
[edit]
[-] blktrace_api.h
[edit]
[-] consolemap.h
[edit]
[-] fsi-occ.h
[edit]
[-] poll.h
[edit]
[-] pvclock_gtod.h
[edit]
[-] lantiq.h
[edit]
[-] list_nulls.h
[edit]
[+]
power
[-] file.h
[edit]
[-] netdevice.h
[edit]
[-] host1x.h
[edit]
[-] eventpoll.h
[edit]
[-] vt_buffer.h
[edit]
[-] page_ref.h
[edit]
[-] ti_wilink_st.h
[edit]
[-] coda.h
[edit]
[-] hil_mlc.h
[edit]
[-] kconfig.h
[edit]
[-] rtc.h
[edit]
[-] rhashtable-types.h
[edit]
[-] workqueue.h
[edit]
[-] device.h
[edit]
[-] hdmi.h
[edit]
[-] intel-ish-client-if.h
[edit]
[-] osq_lock.h
[edit]
[-] buffer_head.h
[edit]
[-] firmware.h
[edit]
[-] ratelimit.h
[edit]
[-] jiffies.h
[edit]
[-] bpf.h
[edit]
[-] aio.h
[edit]
[-] bitops.h
[edit]
[-] cpumask.h
[edit]
[-] cpuset.h
[edit]
[-] cuda.h
[edit]
[-] nvme-fc-driver.h
[edit]
[-] apm_bios.h
[edit]
[-] eeprom_93cx6.h
[edit]
[-] lru_cache.h
[edit]
[-] export.h
[edit]
[-] apm-emulation.h
[edit]
[-] coresight-stm.h
[edit]
[-] crc32c.h
[edit]
[-] skmsg.h
[edit]
[-] leds-bd2802.h
[edit]
[-] acpi.h
[edit]
[-] auto_dev-ioctl.h
[edit]
[-] nfs4.h
[edit]
[-] cgroup-defs.h
[edit]
[-] gnss.h
[edit]
[-] jbd2.h
[edit]
[-] signal_types.h
[edit]
[-] topology.h
[edit]
[-] patchkey.h
[edit]
[-] sed-opal.h
[edit]
[-] timerfd.h
[edit]
[-] devfreq_cooling.h
[edit]
[-] stackprotector.h
[edit]
[-] pid_namespace.h
[edit]
[-] seq_buf.h
[edit]
[-] f2fs_fs.h
[edit]
[-] asn1.h
[edit]
[-] atmel_pdc.h
[edit]
[-] parman.h
[edit]
[-] intel_rapl.h
[edit]
[-] atomic-fallback.h
[edit]
[-] altera_uart.h
[edit]
[-] virtio_console.h
[edit]
[-] count_zeros.h
[edit]
[-] aer.h
[edit]
[-] bpf_types.h
[edit]
[-] mpls_iptunnel.h
[edit]
[-] zpool.h
[edit]
[-] serdev.h
[edit]
[-] scmi_protocol.h
[edit]
[-] context_tracking_state.h
[edit]
[-] rbtree.h
[edit]
[-] mcb.h
[edit]
[-] ksm.h
[edit]
[-] cpuhotplug.h
[edit]
[-] hpet.h
[edit]
[-] shm.h
[edit]
[-] b1pcmcia.h
[edit]
[-] inet.h
[edit]
[-] mount.h
[edit]
[-] btrfs.h
[edit]
[-] cache.h
[edit]
[-] cnt32_to_63.h
[edit]
[-] rcu_sync.h
[edit]
[-] agp_backend.h
[edit]
[-] console.h
[edit]
[-] compiler_types.h
[edit]
[-] if_phonet.h
[edit]
[-] module_signature.h
[edit]
[+]
rpmsg
[-] stmp_device.h
[edit]
[-] const.h
[edit]
[-] sungem_phy.h
[edit]
[-] svga.h
[edit]
[-] cleancache.h
[edit]
[-] stmp3xxx_rtc_wdt.h
[edit]
[-] bpf_trace.h
[edit]
[+]
netfilter_ipv6
[+]
hsi
[+]
greybus
[-] if_team.h
[edit]
[-] vme.h
[edit]
[-] sysrq.h
[edit]
[-] dca.h
[edit]
[+]
can
[-] flat.h
[edit]
[-] key-type.h
[edit]
[-] gcd.h
[edit]
[-] livepatch.h
[edit]
[-] sock_diag.h
[edit]
[-] math64.h
[edit]
[-] pagemap.h
[edit]
[-] bitmap.h
[edit]
[-] rational.h
[edit]
[-] set_memory.h
[edit]
[-] mm.h
[edit]
[-] irqchip.h
[edit]
[-] edac.h
[edit]
[-] balloon_compaction.h
[edit]
[-] pl353-smc.h
[edit]
[-] mdio-bitbang.h
[edit]
[-] llc.h
[edit]
[-] regset.h
[edit]
[-] mpls.h
[edit]
[-] bpf_verifier.h
[edit]
[-] init_ohci1394_dma.h
[edit]
[-] stddef.h
[edit]
[-] migrate_mode.h
[edit]
[-] trace.h
[edit]
[-] fcntl.h
[edit]
[-] of_iommu.h
[edit]
[-] average.h
[edit]
[-] ctype.h
[edit]
[-] w1.h
[edit]
[-] efs_vh.h
[edit]
[-] dma-fence.h
[edit]
[-] pci_ids.h
[edit]
[-] ahci-remap.h
[edit]
[-] leds-pca9532.h
[edit]
[-] micrel_phy.h
[edit]
[-] sync_core.h
[edit]
[-] ioc3.h
[edit]
[-] reboot.h
[edit]
[-] hwmon-sysfs.h
[edit]
[-] dma-direction.h
[edit]
[-] libgcc.h
[edit]
[-] mem_encrypt.h
[edit]
[-] leds-regulator.h
[edit]
[+]
sunrpc
[-] rodata_test.h
[edit]
[-] qcom-geni-se.h
[edit]
[-] of_mdio.h
[edit]
[-] serial_8250.h
[edit]
[-] i2c-dev.h
[edit]
[-] if_arp.h
[edit]
[-] net.h
[edit]
[-] inetdevice.h
[edit]
[-] virtio_net.h
[edit]
[-] smc91x.h
[edit]
[-] serial_s3c.h
[edit]
[-] genetlink.h
[edit]
[-] hid-debug.h
[edit]
[-] ipc.h
[edit]
[-] dqblk_qtree.h
[edit]
[-] prime_numbers.h
[edit]
[-] pnfs_osd_xdr.h
[edit]
[-] i8253.h
[edit]
[-] pci-p2pdma.h
[edit]
[-] zstd.h
[edit]
[-] netfilter_ingress.h
[edit]
[-] verification.h
[edit]
[-] lcm.h
[edit]
[-] tifm.h
[edit]
[-] of_graph.h
[edit]
[-] lsm_hooks.h
[edit]
[-] compiler-clang.h
[edit]
[-] crash_dump.h
[edit]
[-] dmi.h
[edit]
[-] seqno-fence.h
[edit]
[-] async_tx.h
[edit]
[-] spinlock_types.h
[edit]
[-] generic-radix-tree.h
[edit]
[-] isa.h
[edit]
[-] kvm_para.h
[edit]
[-] binfmts.h
[edit]
[-] igmp.h
[edit]
[-] mroute.h
[edit]
[-] spmi.h
[edit]
[-] ptp_classify.h
[edit]
[-] cn_proc.h
[edit]
[-] pl320-ipc.h
[edit]
[-] switchtec.h
[edit]
[-] a.out.h
[edit]
[-] ring_buffer.h
[edit]
[-] device-mapper.h
[edit]
[-] nfs.h
[edit]
[-] hid-sensor-hub.h
[edit]
[-] splice.h
[edit]
[-] counter_enum.h
[edit]
[-] sdb.h
[edit]
[-] seg6_hmac.h
[edit]
[-] nvme-rdma.h
[edit]
[-] clkdev.h
[edit]
[-] kcore.h
[edit]
[-] util_macros.h
[edit]
[-] audit.h
[edit]
[-] ext2_fs.h
[edit]
[-] hdlc.h
[edit]
[+]
bcma
[-] pm_opp.h
[edit]
[-] typecheck.h
[edit]
[-] dma-fence-chain.h
[edit]
[-] projid.h
[edit]
[-] sram.h
[edit]
[-] torture.h
[edit]
[-] lp.h
[edit]
[-] wait_bit.h
[edit]
[+]
qed
[-] perf_event.h
[edit]
[-] poison.h
[edit]
[-] seq_file.h
[edit]
[-] ip.h
[edit]
[-] cb710.h
[edit]
[-] seqlock.h
[edit]
[-] vermagic.h
[edit]
[-] digsig.h
[edit]
[-] crc32poly.h
[edit]
[-] mnt_namespace.h
[edit]
[+]
mtd
[-] lsm_audit.h
[edit]
[-] omap-iommu.h
[edit]
[-] plist.h
[edit]
[-] lzo.h
[edit]
[-] nl802154.h
[edit]
[-] elf.h
[edit]
[-] t10-pi.h
[edit]
[-] limits.h
[edit]
[-] intel-pti.h
[edit]
[-] hp_sdc.h
[edit]
[-] ras.h
[edit]
[-] fsi.h
[edit]
[-] pps_kernel.h
[edit]
[-] mailbox_controller.h
[edit]
[-] list_lru.h
[edit]
[-] once.h
[edit]
[-] cpuidle_haltpoll.h
[edit]
[-] pageblock-flags.h
[edit]
[-] remoteproc.h
[edit]
[-] hugetlb_cgroup.h
[edit]
[-] elfcore-compat.h
[edit]
[-] initrd.h
[edit]
[-] fsnotify.h
[edit]
[-] pm_runtime.h
[edit]
[-] rhashtable.h
[edit]
[-] mei_cl_bus.h
[edit]
[-] crc32.h
[edit]
[-] rculist_bl.h
[edit]
[-] posix_acl.h
[edit]
[-] fsl-diu-fb.h
[edit]
[-] random.h
[edit]
[-] sh_dma.h
[edit]
[-] zsmalloc.h
[edit]
[-] string.h
[edit]
[-] sonet.h
[edit]
[-] cgroup_rdma.h
[edit]
[-] kgdb.h
[edit]
[-] crc-itu-t.h
[edit]
[-] devfreq-event.h
[edit]
[-] cper.h
[edit]
[-] rtsx_common.h
[edit]
[-] alarmtimer.h
[edit]
[-] smp.h
[edit]
[-] preempt.h
[edit]
[+]
gpio
[-] uio.h
[edit]
[-] cfag12864b.h
[edit]
[-] tty.h
[edit]
[-] of_device.h
[edit]
[-] in.h
[edit]
[-] prefetch.h
[edit]
[-] proc_ns.h
[edit]
[-] htcpld.h
[edit]
[-] tracepoint.h
[edit]
[-] siphash.h
[edit]
[-] spinlock_api_smp.h
[edit]
[+]
mlx5
[-] netlink.h
[edit]
[-] f75375s.h
[edit]
[-] psi.h
[edit]
[-] bcm47xx_wdt.h
[edit]
[-] errseq.h
[edit]
[-] clockchips.h
[edit]
[-] ks8842.h
[edit]
[-] n_r3964.h
[edit]
[-] dynamic_queue_limits.h
[edit]
[-] percpu-rwsem.h
[edit]
[-] interconnect-provider.h
[edit]
[-] pm_wakeup.h
[edit]
[-] genl_magic_struct.h
[edit]
[-] tpm.h
[edit]
[+]
amba
[-] pipe_fs_i.h
[edit]
[-] rtsx_usb.h
[edit]
[-] lis3lv02d.h
[edit]
[-] vlynq.h
[edit]
[+]
spi
[-] serial_sci.h
[edit]
[+]
rtc
[-] isicom.h
[edit]
[-] vt.h
[edit]
[-] ata_platform.h
[edit]
[-] clocksource.h
[edit]
[-] hwmon-vid.h
[edit]
[-] reboot-mode.h
[edit]
[-] init_task.h
[edit]
[-] elevator.h
[edit]
[-] dma-direct.h
[edit]
[-] dma-buf.h
[edit]
[-] iova.h
[edit]
[-] debug_locks.h
[edit]
[-] sbitmap.h
[edit]
[-] hid-roccat.h
[edit]
[-] ieee80211.h
[edit]
[-] kref.h
[edit]
[-] lockref.h
[edit]
[-] error-injection.h
[edit]
[-] regmap.h
[edit]
[-] percpu-defs.h
[edit]
[-] fs_uart_pd.h
[edit]
[+]
input
[-] shmem_fs.h
[edit]
[-] debugfs.h
[edit]
[+]
mfd
[+]
extcon
[-] build_bug.h
[edit]
[-] dma-fence-array.h
[edit]
[-] sirfsoc_dma.h
[edit]
[+]
reset
[-] sh_clk.h
[edit]
[-] bitrev.h
[edit]
[-] range.h
[edit]
[-] mempolicy.h
[edit]
[-] l2tp.h
[edit]
[-] via-gpio.h
[edit]
[-] pe.h
[edit]
[-] moxtet.h
[edit]
[-] inotify.h
[edit]
[-] bottom_half.h
[edit]
[-] rmi.h
[edit]
[-] vga_switcheroo.h
[edit]
[-] virtio_vsock.h
[edit]
[-] rculist.h
[edit]
[-] arch_topology.h
[edit]
[-] keyboard.h
[edit]
[-] qcom_scm.h
[edit]
[-] rbtree_latch.h
[edit]
[-] bio.h
[edit]
[-] fwnode.h
[edit]
[-] srcu.h
[edit]
[-] jump_label.h
[edit]
[-] auxvec.h
[edit]
[-] irqbypass.h
[edit]
[-] asn1_ber_bytecode.h
[edit]
[-] crc-ccitt.h
[edit]
[-] wait.h
[edit]
[-] fs_stack.h
[edit]
[-] hrtimer_defs.h
[edit]
[-] vtime.h
[edit]
[-] pm-trace.h
[edit]
[-] kvm_types.h
[edit]
[-] bma150.h
[edit]
[-] logic_pio.h
[edit]
[-] sched_clock.h
[edit]
[-] capability.h
[edit]
[-] smscphy.h
[edit]
[-] blk-mq-virtio.h
[edit]
[-] ucs2_string.h
[edit]
[-] sxgbe_platform.h
[edit]
[-] tpm_command.h
[edit]
[-] pps-gpio.h
[edit]
[-] thunderbolt.h
[edit]
[-] nsproxy.h
[edit]
[-] dns_resolver.h
[edit]
[-] device_cgroup.h
[edit]
[-] scx200_gpio.h
[edit]
[-] atmel-ssc.h
[edit]
[-] configfs.h
[edit]
[-] huge_mm.h
[edit]
[-] futex.h
[edit]
[-] hid.h
[edit]
[-] ata.h
[edit]
[-] dcache.h
[edit]
[-] efi.h
[edit]
[-] textsearch.h
[edit]
[-] crash_core.h
[edit]
[-] i8042.h
[edit]
[-] rbtree_augmented.h
[edit]
[-] scatterlist.h
[edit]
[-] compiler-gcc.h
[edit]
[-] crc64.h
[edit]
[-] wl12xx.h
[edit]
[-] page_owner.h
[edit]
[-] usb.h
[edit]
[-] sched.h
[edit]
[-] securebits.h
[edit]
[-] siox.h
[edit]
[-] path.h
[edit]
[-] mic_bus.h
[edit]
[-] cred.h
[edit]
[-] wkup_m3_ipc.h
[edit]
[+]
perf
[-] console_struct.h
[edit]
[-] indirect_call_wrapper.h
[edit]
[-] fscache-cache.h
[edit]
[-] pci-epf.h
[edit]
[-] pm_wakeirq.h
[edit]
[-] fault-inject.h
[edit]
[-] llist.h
[edit]
[-] time.h
[edit]
[-] hugetlb_inline.h
[edit]
[-] counter.h
[edit]
[-] altera_jtaguart.h
[edit]
[-] iomap.h
[edit]
[-] atmel-mci.h
[edit]
[-] mman.h
[edit]
[-] nfs_iostat.h
[edit]
[-] thermal.h
[edit]
[-] pmbus.h
[edit]
[-] nvmem-consumer.h
[edit]
[-] zconf.h
[edit]
[-] reset-controller.h
[edit]
[-] task_io_accounting.h
[edit]
[-] delayed_call.h
[edit]
[-] sctp.h
[edit]
[-] vfs.h
[edit]
[-] rwlock.h
[edit]
[-] sony-laptop.h
[edit]
[-] ieee802154.h
[edit]
[-] fb.h
[edit]
[-] mbus.h
[edit]
[-] irqdesc.h
[edit]
[-] iopoll.h
[edit]
[-] mmzone.h
[edit]
[+]
irqchip
[-] acct.h
[edit]
[-] swab.h
[edit]
[-] fsl_ifc.h
[edit]
[-] hdlcdrv.h
[edit]
[-] ramfs.h
[edit]
[-] irq_cpustat.h
[edit]
[-] hwmon.h
[edit]
[-] umh.h
[edit]
[-] screen_info.h
[edit]
[-] netpoll.h
[edit]
[-] clk-provider.h
[edit]
[-] rcu_node_tree.h
[edit]
[-] s3c_adc_battery.h
[edit]
[-] filter.h
[edit]
[-] iscsi_boot_sysfs.h
[edit]
[-] threads.h
[edit]
[-] unicode.h
[edit]
[-] bcd.h
[edit]
[-] power_supply.h
[edit]
[-] syscalls.h
[edit]
[-] page_ext.h
[edit]
[-] yam.h
[edit]
[-] smpboot.h
[edit]
[+]
isdn
[-] 8250_pci.h
[edit]
[-] zutil.h
[edit]
[-] nubus.h
[edit]
[-] elfnote.h
[edit]
[-] acpi_pmtmr.h
[edit]
[-] bvec.h
[edit]
[-] tpm_eventlog.h
[edit]
[-] btree.h
[edit]
[-] circ_buf.h
[edit]
[-] seg6_local.h
[edit]
[-] sw842.h
[edit]
[-] i2c-smbus.h
[edit]
[-] cpu_rmap.h
[edit]
[-] namei.h
[edit]
[-] joystick.h
[edit]
[-] shdma-base.h
[edit]
[-] i2c-algo-pcf.h
[edit]
[-] quota.h
[edit]
[-] parport.h
[edit]
[-] cpufeature.h
[edit]
[-] string_helpers.h
[edit]
[-] padata.h
[edit]
[-] numa.h
[edit]
[-] io-mapping.h
[edit]
[-] seccomp.h
[edit]
[-] pti.h
[edit]
[-] kobject.h
[edit]
[-] compaction.h
[edit]
[-] cpu.h
[edit]
[-] pm2301_charger.h
[edit]
[-] max17040_battery.h
[edit]
[-] phonet.h
[edit]
[-] if_ether.h
[edit]
[-] udp.h
[edit]
[-] bcm963xx_nvram.h
[edit]
[+]
clk
[-] libfdt.h
[edit]
[-] tnum.h
[edit]
[-] log2.h
[edit]
[-] led-class-flash.h
[edit]
[-] cgroup_subsys.h
[edit]
[-] if_pppox.h
[edit]
[-] mdio-mux.h
[edit]
[-] sizes.h
[edit]
[-] netfilter_ipv6.h
[edit]
[-] usb_usual.h
[edit]
[-] ascii85.h
[edit]
[-] cma.h
[edit]
[+]
fsl
[-] tc.h
[edit]
[-] skbuff.h
[edit]
[-] mm_types.h
[edit]
[-] rcutiny.h
[edit]
[-] nvme-tcp.h
[edit]
[-] mdio-gpio.h
[edit]
[-] serio.h
[edit]
[-] intel_th.h
[edit]
[-] sfp.h
[edit]
[-] iscsi_ibft.h
[edit]
[-] rwsem.h
[edit]
[-] coredump.h
[edit]
[-] virtio_caif.h
[edit]
[-] linkage.h
[edit]
[-] keyctl.h
[edit]
[-] ds2782_battery.h
[edit]
[-] ftrace_irq.h
[edit]
[-] visorbus.h
[edit]
[-] pktcdvd.h
[edit]
[-] dynamic_debug.h
[edit]
[-] tty_flip.h
[edit]
[-] extable.h
[edit]
[-] swap_slots.h
[edit]
[-] brcmphy.h
[edit]
[-] errqueue.h
[edit]
[-] fsl_hypervisor.h
[edit]
[-] ipv6_route.h
[edit]
[-] hugetlb.h
[edit]
[+]
remoteproc
[-] nfs_fs_sb.h
[edit]
[-] rio.h
[edit]
[-] leds-tca6507.h
[edit]
[-] ethtool.h
[edit]
[-] cryptohash.h
[edit]
[-] sound.h
[edit]
[-] wmi.h
[edit]
[-] compiler-intel.h
[edit]
[-] led-lm3530.h
[edit]
[-] blk-mq-pci.h
[edit]
[-] libps2.h
[edit]
[-] extcon.h
[edit]
[-] slab.h
[edit]
[-] fsnotify_backend.h
[edit]
[-] smsc911x.h
[edit]
[-] mv643xx_eth.h
[edit]
[-] virtio.h
[edit]
[-] dmapool.h
[edit]
[-] rfkill.h
[edit]
[-] syscore_ops.h
[edit]
[-] async.h
[edit]
[-] hash.h
[edit]
[-] eeprom_93xx46.h
[edit]
[-] vexpress.h
[edit]
[-] timekeeping32.h
[edit]
[-] pkeys.h
[edit]
[-] nvmem-provider.h
[edit]
[-] kernel-page-flags.h
[edit]
[-] vmstat.h
[edit]
[-] iversion.h
[edit]
[-] bug.h
[edit]
[+]
lockd
[+]
usb
[-] crc7.h
[edit]
[-] u64_stats_sync.h
[edit]
[-] tty_driver.h
[edit]
[-] packing.h
[edit]
[-] if_tun.h
[edit]
[-] apple_bl.h
[edit]
[-] adxl.h
[edit]
[+]
phy
[-] swapfile.h
[edit]
[-] if_fddi.h
[edit]
[-] badblocks.h
[edit]
[-] firewire.h
[edit]
[-] blk-mq.h
[edit]
[-] jz4740-adc.h
[edit]
[-] etherdevice.h
[edit]
[+]
ssb
[-] pfn_t.h
[edit]
[-] interval_tree_generic.h
[edit]
[-] static_key.h
[edit]
[-] rculist_nulls.h
[edit]
[-] percpu_counter.h
[edit]
[-] cdev.h
[edit]
[-] psi_types.h
[edit]
[-] phylink.h
[edit]
[-] frontswap.h
[edit]
[-] dirent.h
[edit]
[-] spinlock_types_up.h
[edit]
[-] notifier.h
[edit]
[-] ptr_ring.h
[edit]
[-] hmm.h
[edit]
[+]
fpga
[-] anon_inodes.h
[edit]
[-] rtsx_pci.h
[edit]
[-] property.h
[edit]
[-] maple.h
[edit]
[-] hyperv.h
[edit]
[-] vbox_utils.h
[edit]
[-] gpio.h
[edit]
[-] jz4780-nemc.h
[edit]
[+]
netfilter_arp
[-] mii.h
[edit]
[-] elfcore.h
[edit]
[-] vmw_vmci_api.h
[edit]
[-] uio_driver.h
[edit]
[-] user.h
[edit]
[-] pagevec.h
[edit]
[-] srcutree.h
[edit]
[-] ioprio.h
[edit]
[-] greybus.h
[edit]
[-] list_bl.h
[edit]
[-] amd-iommu.h
[edit]
[-] statfs.h
[edit]
[-] user-return-notifier.h
[edit]
[-] w1-gpio.h
[edit]
[-] vm_sockets.h
[edit]
[-] delayacct.h
[edit]
[-] rcupdate_wait.h
[edit]
[-] via_i2c.h
[edit]
[+]
pinctrl
[-] timex.h
[edit]
[-] signal.h
[edit]
[-] slab_def.h
[edit]
[-] zorro.h
[edit]
[-] frame.h
[edit]
[-] proc_fs.h
[edit]
[-] ihex.h
[edit]
[-] i2c-mux.h
[edit]
[-] sonypi.h
[edit]
[-] cs5535.h
[edit]
[-] pm_domain.h
[edit]
[-] prandom.h
[edit]
[-] extcon-provider.h
[edit]
[-] nfs3.h
[edit]
[-] tfrc.h
[edit]
[-] pci-epc.h
[edit]
[-] i2c-pxa.h
[edit]
[-] virtio_config.h
[edit]
[-] socket.h
[edit]
[-] hypervisor.h
[edit]
[-] sunserialcore.h
[edit]
[-] tick.h
[edit]
[-] crypto.h
[edit]
[-] iocontext.h
[edit]
[-] arm-cci.h
[edit]
[-] highuid.h
[edit]
[-] libfdt_env.h
[edit]
[-] timb_dma.h
[edit]
[-] timecounter.h
[edit]
[-] memstick.h
[edit]
[-] serial_core.h
[edit]
[-] irq.h
[edit]
[-] crc8.h
[edit]
[+]
mdio
[-] pagewalk.h
[edit]
[-] bcm47xx_nvram.h
[edit]
[-] input.h
[edit]
[-] dmaengine.h
[edit]
[-] sh_eth.h
[edit]
[+]
mux
[-] cpu_cooling.h
[edit]
[-] component.h
[edit]
[+]
netfilter_bridge
[-] atomic.h
[edit]
[-] mempool.h
[edit]
[-] stringhash.h
[edit]
[-] utsname.h
[edit]
[-] rtnetlink.h
[edit]
[-] nsc_gpio.h
[edit]
[-] ftrace.h
[edit]
[-] pxa2xx_ssp.h
[edit]
[-] of_fdt.h
[edit]
[-] if_ltalk.h
[edit]
[-] alcor_pci.h
[edit]
[-] oid_registry.h
[edit]
[-] genhd.h
[edit]
[-] energy_model.h
[edit]
[-] idr.h
[edit]
[-] eisa.h
[edit]
[-] pim.h
[edit]
[-] drbd_genl.h
[edit]
[-] wireless.h
[edit]
[-] radix-tree.h
[edit]
[-] kbd_kern.h
[edit]
[-] atm.h
[edit]
[-] dma-contiguous.h
[edit]
[-] superhyway.h
[edit]
[-] posix_acl_xattr.h
[edit]
[-] stop_machine.h
[edit]
[-] fddidevice.h
[edit]
[-] ti-emif-sram.h
[edit]
[-] drbd.h
[edit]
[-] time32.h
[edit]
[+]
netfilter_ipv4
[-] bpf-cgroup.h
[edit]
[-] drbd_genl_api.h
[edit]
[-] fanotify.h
[edit]
[-] tca6416_keypad.h
[edit]
[-] vfio.h
[edit]
[-] compat.h
[edit]
[-] cyclades.h
[edit]
[-] c2port.h
[edit]
[-] swapops.h
[edit]
[-] objagg.h
[edit]
[-] vt_kern.h
[edit]
[-] sem.h
[edit]
[-] rio_ids.h
[edit]
[-] tracefs.h
[edit]
[-] i2c.h
[edit]
[-] fips.h
[edit]
[-] list.h
[edit]
[-] cacheinfo.h
[edit]
[+]
regulator
[-] blk-pm.h
[edit]
[-] if_tunnel.h
[edit]
[-] atalk.h
[edit]
[-] posix-timers.h
[edit]
[-] irq_work.h
[edit]
[-] dw_apb_timer.h
[edit]
[-] memory_hotplug.h
[edit]
[+]
ulpi
[-] kallsyms.h
[edit]
[-] coresight-pmu.h
[edit]
[-] irqdomain.h
[edit]
[-] cciss_ioctl.h
[edit]
[-] nvme-fc.h
[edit]
[-] memory.h
[edit]
[-] imx-media.h
[edit]
[-] root_dev.h
[edit]
[-] if_frad.h
[edit]
[-] crc4.h
[edit]
[-] agpgart.h
[edit]
[-] of_net.h
[edit]
[-] blk_types.h
[edit]
[-] omap-dma.h
[edit]
[-] ima.h
[edit]
[-] in6.h
[edit]
[-] i2c-algo-pca.h
[edit]
[-] phy.h
[edit]
[-] psp-sev.h
[edit]
[-] msdos_fs.h
[edit]
[-] pid.h
[edit]
[-] leds-lp3944.h
[edit]
[-] if_vlan.h
[edit]
[-] input-polldev.h
[edit]
[-] miscdevice.h
[edit]
[-] ptp_clock_kernel.h
[edit]
[-] interval_tree.h
[edit]
[+]
raid
[-] fsldma.h
[edit]
[-] nvram.h
[edit]
[-] mv643xx_i2c.h
[edit]
[-] kobject_ns.h
[edit]
[-] assoc_array.h
[edit]
[-] interrupt.h
[edit]
[-] lapb.h
[edit]
[-] clk.h
[edit]
[-] nfs_page.h
[edit]
[-] watchdog.h
[edit]
[-] timb_gpio.h
[edit]
[-] kobj_map.h
[edit]
[-] mmap_lock.h
[edit]
[-] pr.h
[edit]
[-] highmem.h
[edit]
[-] dax.h
[edit]
[-] klist.h
[edit]
[-] ipv6.h
[edit]
[-] kfifo.h
[edit]
[-] serial.h
[edit]
[-] leds_pwm.h
[edit]
[-] atm_suni.h
[edit]
[-] pnp.h
[edit]
[-] dqblk_v2.h
[edit]
[-] kmod.h
[edit]
[-] pci-ats.h
[edit]
[-] tsacct_kern.h
[edit]
[-] kasan.h
[edit]
[-] dlm_plock.h
[edit]
[-] kernel_stat.h
[edit]
[-] time64.h
[edit]
[-] smc911x.h
[edit]
[-] pwm_backlight.h
[edit]
[-] personality.h
[edit]
[-] ppp_channel.h
[edit]
[-] pch_dma.h
[edit]
[-] stacktrace.h
[edit]
[-] armada-37xx-rwtm-mailbox.h
[edit]
[-] intel-iommu.h
[edit]
[-] ppp_defs.h
[edit]
[-] ntb_transport.h
[edit]
[-] ath9k_platform.h
[edit]
[-] quotaops.h
[edit]
[-] cm4000_cs.h
[edit]
[-] user_namespace.h
[edit]
[-] of_pdt.h
[edit]
[-] nfs_fs.h
[edit]
[-] slimbus.h
[edit]
[-] pm_qos.h
[edit]
[-] kmemleak.h
[edit]
[-] serial_max3100.h
[edit]
[-] usbdevice_fs.h
[edit]
[-] blockgroup_lock.h
[edit]
[-] dio.h
[edit]
[-] elf-randomize.h
[edit]
[-] khugepaged.h
[edit]
[-] trace_events.h
[edit]
[-] processor.h
[edit]
[-] uuid.h
[edit]
[-] dlm.h
[edit]
[-] timekeeper_internal.h
[edit]
[-] mpi.h
[edit]
[-] vmacache.h
[edit]
[-] of_gpio.h
[edit]
[-] if_pppol2tp.h
[edit]
[-] virtio_ring.h
[edit]
[-] ks0108.h
[edit]
[-] vmpressure.h
[edit]
[-] freezer.h
[edit]
[-] pci-ep-cfs.h
[edit]
[-] davinci_emac.h
[edit]
[+]
crush
[-] mm_types_task.h
[edit]
[-] moduleparam.h
[edit]
[-] transport_class.h
[edit]
[-] tee_drv.h
[edit]
[-] xarray.h
[edit]
[-] hw_random.h
[edit]
[-] fcdevice.h
[edit]
[-] synclink.h
[edit]
[-] dma-resv.h
[edit]
[-] fsverity.h
[edit]
[-] adb.h
[edit]
[-] hippidevice.h
[edit]
[-] cpuidle.h
[edit]
[-] irq_poll.h
[edit]
[-] of.h
[edit]
[-] latencytop.h
[edit]
[-] mxm-wmi.h
[edit]
[-] cdrom.h
[edit]
[-] of_irq.h
[edit]
[-] vm_event_item.h
[edit]
[-] trace_clock.h
[edit]
[-] font.h
[edit]
[-] list_sort.h
[edit]
[-] omap-mailbox.h
[edit]
[+]
platform_data
[-] mmu_context.h
[edit]
[-] timekeeping.h
[edit]
[-] ww_mutex.h
[edit]
[-] dm-region-hash.h
[edit]
[-] task_work.h
[edit]
[-] leds-ti-lmu-common.h
[edit]
[-] bsg-lib.h
[edit]
[-] nfs_fs_i.h
[edit]
[-] bits.h
[edit]
[-] mailbox_client.h
[edit]
[-] signalfd.h
[edit]
[-] clock_cooling.h
[edit]
[-] fscache.h
[edit]
[-] bpfilter.h
[edit]
[+]
dma
[-] percpu.h
[edit]
[-] msi.h
[edit]
[-] evm.h
[edit]
[-] scif.h
[edit]
[-] profile.h
[edit]
[-] pci.h
[edit]
[-] enclosure.h
[edit]
[-] rwlock_types.h
[edit]
[-] pci-dma-compat.h
[edit]
[-] blk-cgroup.h
[edit]
[-] mvebu-pmsu.h
[edit]
[-] sys_soc.h
[edit]
[-] marvell_phy.h
[edit]
[-] xxhash.h
[edit]
[-] page_counter.h
[edit]
[-] percpu-refcount.h
[edit]
[-] linux_logo.h
[edit]
[-] rcuwait.h
[edit]
[-] oom.h
[edit]
[-] memfd.h
[edit]
[-] phy_fixed.h
[edit]
[-] reset.h
[edit]
[-] trace_seq.h
[edit]
[-] suspend.h
[edit]
[-] hiddev.h
[edit]
[-] tracepoint-defs.h
[edit]
[-] glob.h
[edit]
[-] of_platform.h
[edit]
[-] scc.h
[edit]
[-] acpi_dma.h
[edit]
[-] of_clk.h
[edit]
[-] migrate.h
[edit]
[-] kdb.h
[edit]
[-] of_reserved_mem.h
[edit]
[-] backing-dev-defs.h
[edit]
[-] page-isolation.h
[edit]
[-] nmi.h
[edit]
[-] fs_types.h
[edit]
[-] dqblk_v1.h
[edit]
[-] platform_device.h
[edit]
[-] uprobes.h
[edit]
[-] fs_context.h
[edit]
[-] pci-acpi.h
[edit]
[-] spinlock.h
[edit]
[-] drbd_limits.h
[edit]
[-] cmdline-parser.h
[edit]
[-] zbud.h
[edit]
[-] backlight.h
[edit]
[-] fs_parser.h
[edit]
[-] serial_pnx8xxx.h
[edit]
[-] kbd_diacr.h
[edit]
[-] mdio.h
[edit]
[-] libnvdimm.h
[edit]
[-] ioport.h
[edit]
[-] omap-gpmc.h
[edit]
[-] refcount.h
[edit]
[-] ntb.h
[edit]
[-] ccp.h
[edit]
[-] ks8851_mll.h
[edit]
[-] start_kernel.h
[edit]
[-] page-flags.h
[edit]
[-] pfn.h
[edit]
[-] firmware-map.h
[edit]
[-] context_tracking.h
[edit]
[-] kmsg_dump.h
[edit]
[-] kdev_t.h
[edit]
[-] fs_struct.h
[edit]
[-] resource.h
[edit]
[-] slub_def.h
[edit]
[-] completion.h
[edit]
[-] dccp.h
[edit]
[-] rcu_segcblist.h
[edit]
[-] mdev.h
[edit]
[-] dm9000.h
[edit]
[-] cpufreq.h
[edit]
[-] crc-t10dif.h
[edit]
[-] toshiba.h
[edit]
[-] btree-type.h
[edit]
[-] reciprocal_div.h
[edit]
[-] devpts_fs.h
[edit]
[-] fixp-arith.h
[edit]
[-] stackdepot.h
[edit]
[-] units.h
[edit]
[-] ahci_platform.h
[edit]
[-] key.h
[edit]
[-] if_link.h
[edit]
[-] fsi-sbefifo.h
[edit]
[-] soundcard.h
[edit]
[-] fs.h
[edit]
[-] mbcache.h
[edit]
[-] jump_label_ratelimit.h
[edit]
[-] nfs_xdr.h
[edit]
[-] nodemask.h
[edit]
[-] sysctl.h
[edit]
[-] scx200.h
[edit]
[-] fdtable.h
[edit]
[-] leds.h
[edit]
[-] writeback.h
[edit]
[-] irqflags.h
[edit]
[-] selection.h
[edit]
[-] textsearch_fsm.h
[edit]
[-] zlib.h
[edit]
[-] vringh.h
[edit]
[-] moduleloader.h
[edit]
[-] perf_regs.h
[edit]
[-] linkmode.h
[edit]
[-] rcupdate.h
[edit]
[-] debugobjects.h
[edit]
[-] swap.h
[edit]
[-] ts-nbus.h
[edit]
[-] btf.h
[edit]
[-] jhash.h
[edit]
[-] kernfs.h
[edit]
[-] hwspinlock.h
[edit]
[-] devfreq.h
[edit]
[-] taskstats_kern.h
[edit]
[-] relay.h
[edit]
[-] hidraw.h
[edit]
[-] eventfd.h
[edit]
[-] page-flags-layout.h
[edit]
[-] license.h
[edit]
[-] rcutree.h
[edit]
[-] sdla.h
[edit]
[-] pseudo_fs.h
[edit]
[-] libata.h
[edit]
[-] timeriomem-rng.h
[edit]
[-] sh_timer.h
[edit]
[-] irqnr.h
[edit]
[-] netfilter_ipv4.h
[edit]
[-] swait.h
[edit]
[-] of_pci.h
[edit]
[-] vgaarb.h
[edit]
[-] auto_fs.h
[edit]