1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Copyright 2019 Google LLC
6 #ifndef __LINUX_BLK_CRYPTO_INTERNAL_H
7 #define __LINUX_BLK_CRYPTO_INTERNAL_H
10 #include <linux/blk-mq.h>
12 /* Represents a crypto mode supported by blk-crypto */
13 struct blk_crypto_mode
{
14 const char *name
; /* name of this mode, shown in sysfs */
15 const char *cipher_str
; /* crypto API name (for fallback case) */
16 unsigned int keysize
; /* key size in bytes */
17 unsigned int ivsize
; /* iv size in bytes */
20 extern const struct blk_crypto_mode blk_crypto_modes
[];
22 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
24 int blk_crypto_sysfs_register(struct request_queue
*q
);
26 void blk_crypto_sysfs_unregister(struct request_queue
*q
);
28 void bio_crypt_dun_increment(u64 dun
[BLK_CRYPTO_DUN_ARRAY_SIZE
],
31 bool bio_crypt_rq_ctx_compatible(struct request
*rq
, struct bio
*bio
);
33 bool bio_crypt_ctx_mergeable(struct bio_crypt_ctx
*bc1
, unsigned int bc1_bytes
,
34 struct bio_crypt_ctx
*bc2
);
36 static inline bool bio_crypt_ctx_back_mergeable(struct request
*req
,
39 return bio_crypt_ctx_mergeable(req
->crypt_ctx
, blk_rq_bytes(req
),
40 bio
->bi_crypt_context
);
43 static inline bool bio_crypt_ctx_front_mergeable(struct request
*req
,
46 return bio_crypt_ctx_mergeable(bio
->bi_crypt_context
,
47 bio
->bi_iter
.bi_size
, req
->crypt_ctx
);
50 static inline bool bio_crypt_ctx_merge_rq(struct request
*req
,
53 return bio_crypt_ctx_mergeable(req
->crypt_ctx
, blk_rq_bytes(req
),
57 static inline void blk_crypto_rq_set_defaults(struct request
*rq
)
60 rq
->crypt_keyslot
= NULL
;
63 static inline bool blk_crypto_rq_is_encrypted(struct request
*rq
)
68 #else /* CONFIG_BLK_INLINE_ENCRYPTION */
70 static inline int blk_crypto_sysfs_register(struct request_queue
*q
)
75 static inline void blk_crypto_sysfs_unregister(struct request_queue
*q
) { }
77 static inline bool bio_crypt_rq_ctx_compatible(struct request
*rq
,
83 static inline bool bio_crypt_ctx_front_mergeable(struct request
*req
,
89 static inline bool bio_crypt_ctx_back_mergeable(struct request
*req
,
95 static inline bool bio_crypt_ctx_merge_rq(struct request
*req
,
101 static inline void blk_crypto_rq_set_defaults(struct request
*rq
) { }
103 static inline bool blk_crypto_rq_is_encrypted(struct request
*rq
)
108 #endif /* CONFIG_BLK_INLINE_ENCRYPTION */
110 void __bio_crypt_advance(struct bio
*bio
, unsigned int bytes
);
111 static inline void bio_crypt_advance(struct bio
*bio
, unsigned int bytes
)
113 if (bio_has_crypt_ctx(bio
))
114 __bio_crypt_advance(bio
, bytes
);
117 void __bio_crypt_free_ctx(struct bio
*bio
);
118 static inline void bio_crypt_free_ctx(struct bio
*bio
)
120 if (bio_has_crypt_ctx(bio
))
121 __bio_crypt_free_ctx(bio
);
124 static inline void bio_crypt_do_front_merge(struct request
*rq
,
127 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
128 if (bio_has_crypt_ctx(bio
))
129 memcpy(rq
->crypt_ctx
->bc_dun
, bio
->bi_crypt_context
->bc_dun
,
130 sizeof(rq
->crypt_ctx
->bc_dun
));
134 bool __blk_crypto_bio_prep(struct bio
**bio_ptr
);
135 static inline bool blk_crypto_bio_prep(struct bio
**bio_ptr
)
137 if (bio_has_crypt_ctx(*bio_ptr
))
138 return __blk_crypto_bio_prep(bio_ptr
);
142 blk_status_t
__blk_crypto_init_request(struct request
*rq
);
143 static inline blk_status_t
blk_crypto_init_request(struct request
*rq
)
145 if (blk_crypto_rq_is_encrypted(rq
))
146 return __blk_crypto_init_request(rq
);
150 void __blk_crypto_free_request(struct request
*rq
);
151 static inline void blk_crypto_free_request(struct request
*rq
)
153 if (blk_crypto_rq_is_encrypted(rq
))
154 __blk_crypto_free_request(rq
);
157 int __blk_crypto_rq_bio_prep(struct request
*rq
, struct bio
*bio
,
160 * blk_crypto_rq_bio_prep - Prepare a request's crypt_ctx when its first bio
162 * @rq: The request to prepare
163 * @bio: The first bio being inserted into the request
164 * @gfp_mask: Memory allocation flags
166 * Return: 0 on success, -ENOMEM if out of memory. -ENOMEM is only possible if
167 * @gfp_mask doesn't include %__GFP_DIRECT_RECLAIM.
169 static inline int blk_crypto_rq_bio_prep(struct request
*rq
, struct bio
*bio
,
172 if (bio_has_crypt_ctx(bio
))
173 return __blk_crypto_rq_bio_prep(rq
, bio
, gfp_mask
);
178 * blk_crypto_insert_cloned_request - Prepare a cloned request to be inserted
179 * into a request queue.
180 * @rq: the request being queued
182 * Return: BLK_STS_OK on success, nonzero on error.
184 static inline blk_status_t
blk_crypto_insert_cloned_request(struct request
*rq
)
187 if (blk_crypto_rq_is_encrypted(rq
))
188 return blk_crypto_init_request(rq
);
192 #ifdef CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK
194 int blk_crypto_fallback_start_using_mode(enum blk_crypto_mode_num mode_num
);
196 bool blk_crypto_fallback_bio_prep(struct bio
**bio_ptr
);
198 int blk_crypto_fallback_evict_key(const struct blk_crypto_key
*key
);
200 #else /* CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK */
203 blk_crypto_fallback_start_using_mode(enum blk_crypto_mode_num mode_num
)
205 pr_warn_once("crypto API fallback is disabled\n");
209 static inline bool blk_crypto_fallback_bio_prep(struct bio
**bio_ptr
)
211 pr_warn_once("crypto API fallback disabled; failing request.\n");
212 (*bio_ptr
)->bi_status
= BLK_STS_NOTSUPP
;
217 blk_crypto_fallback_evict_key(const struct blk_crypto_key
*key
)
222 #endif /* CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK */
224 #endif /* __LINUX_BLK_CRYPTO_INTERNAL_H */