Commit | Line | Data |
---|---|---|
1b262839 ST |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Copyright 2019 Google LLC | |
4 | */ | |
5 | ||
6 | /** | |
cb77cb5a | 7 | * DOC: blk-crypto profiles |
1b262839 | 8 | * |
cb77cb5a EB |
9 | * 'struct blk_crypto_profile' contains all generic inline encryption-related |
10 | * state for a particular inline encryption device. blk_crypto_profile serves | |
11 | * as the way that drivers for inline encryption hardware expose their crypto | |
12 | * capabilities and certain functions (e.g., functions to program and evict | |
13 | * keys) to upper layers. Device drivers that want to support inline encryption | |
14 | * construct a crypto profile, then associate it with the disk's request_queue. | |
1b262839 | 15 | * |
cb77cb5a EB |
16 | * If the device has keyslots, then its blk_crypto_profile also handles managing |
17 | * these keyslots in a device-independent way, using the driver-provided | |
18 | * functions to program and evict keys as needed. This includes keeping track | |
19 | * of which key and how many I/O requests are using each keyslot, getting | |
20 | * keyslots for I/O requests, and handling key eviction requests. | |
1b262839 | 21 | * |
cb77cb5a | 22 | * For more information, see Documentation/block/inline-encryption.rst. |
1b262839 | 23 | */ |
d145dc23 ST |
24 | |
25 | #define pr_fmt(fmt) "blk-crypto: " fmt | |
26 | ||
1e8d44bd | 27 | #include <linux/blk-crypto-profile.h> |
5851d3b0 | 28 | #include <linux/device.h> |
1b262839 ST |
29 | #include <linux/atomic.h> |
30 | #include <linux/mutex.h> | |
31 | #include <linux/pm_runtime.h> | |
32 | #include <linux/wait.h> | |
33 | #include <linux/blkdev.h> | |
fe45e630 | 34 | #include <linux/blk-integrity.h> |
1b262839 | 35 | |
cb77cb5a | 36 | struct blk_crypto_keyslot { |
1b262839 ST |
37 | atomic_t slot_refs; |
38 | struct list_head idle_slot_node; | |
39 | struct hlist_node hash_node; | |
40 | const struct blk_crypto_key *key; | |
cb77cb5a | 41 | struct blk_crypto_profile *profile; |
1b262839 ST |
42 | }; |
43 | ||
cb77cb5a | 44 | static inline void blk_crypto_hw_enter(struct blk_crypto_profile *profile) |
1b262839 ST |
45 | { |
46 | /* | |
cb77cb5a | 47 | * Calling into the driver requires profile->lock held and the device |
1b262839 | 48 | * resumed. But we must resume the device first, since that can acquire |
cb77cb5a | 49 | * and release profile->lock via blk_crypto_reprogram_all_keys(). |
1b262839 | 50 | */ |
cb77cb5a EB |
51 | if (profile->dev) |
52 | pm_runtime_get_sync(profile->dev); | |
53 | down_write(&profile->lock); | |
1b262839 ST |
54 | } |
55 | ||
cb77cb5a | 56 | static inline void blk_crypto_hw_exit(struct blk_crypto_profile *profile) |
1b262839 | 57 | { |
cb77cb5a EB |
58 | up_write(&profile->lock); |
59 | if (profile->dev) | |
60 | pm_runtime_put_sync(profile->dev); | |
7bdcc48f ST |
61 | } |
62 | ||
1b262839 | 63 | /** |
cb77cb5a EB |
64 | * blk_crypto_profile_init() - Initialize a blk_crypto_profile |
65 | * @profile: the blk_crypto_profile to initialize | |
66 | * @num_slots: the number of keyslots | |
1b262839 | 67 | * |
cb77cb5a EB |
68 | * Storage drivers must call this when starting to set up a blk_crypto_profile, |
69 | * before filling in additional fields. | |
1b262839 ST |
70 | * |
71 | * Return: 0 on success, or else a negative error code. | |
72 | */ | |
cb77cb5a EB |
73 | int blk_crypto_profile_init(struct blk_crypto_profile *profile, |
74 | unsigned int num_slots) | |
1b262839 ST |
75 | { |
76 | unsigned int slot; | |
77 | unsigned int i; | |
78 | unsigned int slot_hashtable_size; | |
79 | ||
cb77cb5a EB |
80 | memset(profile, 0, sizeof(*profile)); |
81 | init_rwsem(&profile->lock); | |
1b262839 ST |
82 | |
83 | if (num_slots == 0) | |
cb77cb5a | 84 | return 0; |
1b262839 | 85 | |
cb77cb5a | 86 | /* Initialize keyslot management data. */ |
1b262839 | 87 | |
cb77cb5a EB |
88 | profile->slots = kvcalloc(num_slots, sizeof(profile->slots[0]), |
89 | GFP_KERNEL); | |
90 | if (!profile->slots) | |
91 | return -ENOMEM; | |
1b262839 | 92 | |
cb77cb5a | 93 | profile->num_slots = num_slots; |
1b262839 | 94 | |
cb77cb5a EB |
95 | init_waitqueue_head(&profile->idle_slots_wait_queue); |
96 | INIT_LIST_HEAD(&profile->idle_slots); | |
1b262839 ST |
97 | |
98 | for (slot = 0; slot < num_slots; slot++) { | |
cb77cb5a EB |
99 | profile->slots[slot].profile = profile; |
100 | list_add_tail(&profile->slots[slot].idle_slot_node, | |
101 | &profile->idle_slots); | |
1b262839 ST |
102 | } |
103 | ||
cb77cb5a | 104 | spin_lock_init(&profile->idle_slots_lock); |
1b262839 ST |
105 | |
106 | slot_hashtable_size = roundup_pow_of_two(num_slots); | |
47a84653 EB |
107 | /* |
108 | * hash_ptr() assumes bits != 0, so ensure the hash table has at least 2 | |
109 | * buckets. This only makes a difference when there is only 1 keyslot. | |
110 | */ | |
111 | if (slot_hashtable_size < 2) | |
112 | slot_hashtable_size = 2; | |
113 | ||
cb77cb5a EB |
114 | profile->log_slot_ht_size = ilog2(slot_hashtable_size); |
115 | profile->slot_hashtable = | |
116 | kvmalloc_array(slot_hashtable_size, | |
117 | sizeof(profile->slot_hashtable[0]), GFP_KERNEL); | |
118 | if (!profile->slot_hashtable) | |
119 | goto err_destroy; | |
1b262839 | 120 | for (i = 0; i < slot_hashtable_size; i++) |
cb77cb5a | 121 | INIT_HLIST_HEAD(&profile->slot_hashtable[i]); |
1b262839 ST |
122 | |
123 | return 0; | |
124 | ||
cb77cb5a EB |
125 | err_destroy: |
126 | blk_crypto_profile_destroy(profile); | |
1b262839 ST |
127 | return -ENOMEM; |
128 | } | |
cb77cb5a | 129 | EXPORT_SYMBOL_GPL(blk_crypto_profile_init); |
1b262839 | 130 | |
cb77cb5a | 131 | static void blk_crypto_profile_destroy_callback(void *profile) |
5851d3b0 | 132 | { |
cb77cb5a | 133 | blk_crypto_profile_destroy(profile); |
5851d3b0 EB |
134 | } |
135 | ||
136 | /** | |
cb77cb5a EB |
137 | * devm_blk_crypto_profile_init() - Resource-managed blk_crypto_profile_init() |
138 | * @dev: the device which owns the blk_crypto_profile | |
139 | * @profile: the blk_crypto_profile to initialize | |
140 | * @num_slots: the number of keyslots | |
5851d3b0 | 141 | * |
cb77cb5a EB |
142 | * Like blk_crypto_profile_init(), but causes blk_crypto_profile_destroy() to be |
143 | * called automatically on driver detach. | |
5851d3b0 EB |
144 | * |
145 | * Return: 0 on success, or else a negative error code. | |
146 | */ | |
cb77cb5a EB |
147 | int devm_blk_crypto_profile_init(struct device *dev, |
148 | struct blk_crypto_profile *profile, | |
149 | unsigned int num_slots) | |
5851d3b0 | 150 | { |
cb77cb5a | 151 | int err = blk_crypto_profile_init(profile, num_slots); |
5851d3b0 EB |
152 | |
153 | if (err) | |
154 | return err; | |
155 | ||
cb77cb5a EB |
156 | return devm_add_action_or_reset(dev, |
157 | blk_crypto_profile_destroy_callback, | |
158 | profile); | |
5851d3b0 | 159 | } |
cb77cb5a | 160 | EXPORT_SYMBOL_GPL(devm_blk_crypto_profile_init); |
5851d3b0 | 161 | |
1b262839 | 162 | static inline struct hlist_head * |
cb77cb5a EB |
163 | blk_crypto_hash_bucket_for_key(struct blk_crypto_profile *profile, |
164 | const struct blk_crypto_key *key) | |
1b262839 | 165 | { |
cb77cb5a EB |
166 | return &profile->slot_hashtable[ |
167 | hash_ptr(key, profile->log_slot_ht_size)]; | |
1b262839 ST |
168 | } |
169 | ||
cb77cb5a EB |
170 | static void |
171 | blk_crypto_remove_slot_from_lru_list(struct blk_crypto_keyslot *slot) | |
1b262839 | 172 | { |
cb77cb5a | 173 | struct blk_crypto_profile *profile = slot->profile; |
1b262839 ST |
174 | unsigned long flags; |
175 | ||
cb77cb5a | 176 | spin_lock_irqsave(&profile->idle_slots_lock, flags); |
1b262839 | 177 | list_del(&slot->idle_slot_node); |
cb77cb5a | 178 | spin_unlock_irqrestore(&profile->idle_slots_lock, flags); |
1b262839 ST |
179 | } |
180 | ||
cb77cb5a EB |
181 | static struct blk_crypto_keyslot * |
182 | blk_crypto_find_keyslot(struct blk_crypto_profile *profile, | |
183 | const struct blk_crypto_key *key) | |
1b262839 | 184 | { |
cb77cb5a EB |
185 | const struct hlist_head *head = |
186 | blk_crypto_hash_bucket_for_key(profile, key); | |
187 | struct blk_crypto_keyslot *slotp; | |
1b262839 ST |
188 | |
189 | hlist_for_each_entry(slotp, head, hash_node) { | |
190 | if (slotp->key == key) | |
191 | return slotp; | |
192 | } | |
193 | return NULL; | |
194 | } | |
195 | ||
cb77cb5a EB |
196 | static struct blk_crypto_keyslot * |
197 | blk_crypto_find_and_grab_keyslot(struct blk_crypto_profile *profile, | |
198 | const struct blk_crypto_key *key) | |
1b262839 | 199 | { |
cb77cb5a | 200 | struct blk_crypto_keyslot *slot; |
1b262839 | 201 | |
cb77cb5a | 202 | slot = blk_crypto_find_keyslot(profile, key); |
1b262839 ST |
203 | if (!slot) |
204 | return NULL; | |
205 | if (atomic_inc_return(&slot->slot_refs) == 1) { | |
206 | /* Took first reference to this slot; remove it from LRU list */ | |
cb77cb5a | 207 | blk_crypto_remove_slot_from_lru_list(slot); |
1b262839 ST |
208 | } |
209 | return slot; | |
210 | } | |
211 | ||
cb77cb5a EB |
212 | /** |
213 | * blk_crypto_keyslot_index() - Get the index of a keyslot | |
214 | * @slot: a keyslot that blk_crypto_get_keyslot() returned | |
215 | * | |
216 | * Return: the 0-based index of the keyslot within the device's keyslots. | |
217 | */ | |
218 | unsigned int blk_crypto_keyslot_index(struct blk_crypto_keyslot *slot) | |
1b262839 | 219 | { |
cb77cb5a | 220 | return slot - slot->profile->slots; |
1b262839 | 221 | } |
cb77cb5a | 222 | EXPORT_SYMBOL_GPL(blk_crypto_keyslot_index); |
1b262839 ST |
223 | |
224 | /** | |
cb77cb5a EB |
225 | * blk_crypto_get_keyslot() - Get a keyslot for a key, if needed. |
226 | * @profile: the crypto profile of the device the key will be used on | |
227 | * @key: the key that will be used | |
228 | * @slot_ptr: If a keyslot is allocated, an opaque pointer to the keyslot struct | |
229 | * will be stored here; otherwise NULL will be stored here. | |
230 | * | |
231 | * If the device has keyslots, this gets a keyslot that's been programmed with | |
232 | * the specified key. If the key is already in a slot, this reuses it; | |
233 | * otherwise this waits for a slot to become idle and programs the key into it. | |
1b262839 | 234 | * |
cb77cb5a | 235 | * This must be paired with a call to blk_crypto_put_keyslot(). |
1b262839 | 236 | * |
cb77cb5a EB |
237 | * Context: Process context. Takes and releases profile->lock. |
238 | * Return: BLK_STS_OK on success, meaning that either a keyslot was allocated or | |
239 | * one wasn't needed; or a blk_status_t error on failure. | |
1b262839 | 240 | */ |
cb77cb5a EB |
241 | blk_status_t blk_crypto_get_keyslot(struct blk_crypto_profile *profile, |
242 | const struct blk_crypto_key *key, | |
243 | struct blk_crypto_keyslot **slot_ptr) | |
1b262839 | 244 | { |
cb77cb5a | 245 | struct blk_crypto_keyslot *slot; |
1b262839 ST |
246 | int slot_idx; |
247 | int err; | |
248 | ||
249 | *slot_ptr = NULL; | |
7bdcc48f | 250 | |
cb77cb5a EB |
251 | /* |
252 | * If the device has no concept of "keyslots", then there is no need to | |
253 | * get one. | |
254 | */ | |
255 | if (profile->num_slots == 0) | |
7bdcc48f ST |
256 | return BLK_STS_OK; |
257 | ||
cb77cb5a EB |
258 | down_read(&profile->lock); |
259 | slot = blk_crypto_find_and_grab_keyslot(profile, key); | |
260 | up_read(&profile->lock); | |
1b262839 ST |
261 | if (slot) |
262 | goto success; | |
263 | ||
264 | for (;;) { | |
cb77cb5a EB |
265 | blk_crypto_hw_enter(profile); |
266 | slot = blk_crypto_find_and_grab_keyslot(profile, key); | |
1b262839 | 267 | if (slot) { |
cb77cb5a | 268 | blk_crypto_hw_exit(profile); |
1b262839 ST |
269 | goto success; |
270 | } | |
271 | ||
272 | /* | |
273 | * If we're here, that means there wasn't a slot that was | |
274 | * already programmed with the key. So try to program it. | |
275 | */ | |
cb77cb5a | 276 | if (!list_empty(&profile->idle_slots)) |
1b262839 ST |
277 | break; |
278 | ||
cb77cb5a EB |
279 | blk_crypto_hw_exit(profile); |
280 | wait_event(profile->idle_slots_wait_queue, | |
281 | !list_empty(&profile->idle_slots)); | |
1b262839 ST |
282 | } |
283 | ||
cb77cb5a | 284 | slot = list_first_entry(&profile->idle_slots, struct blk_crypto_keyslot, |
1b262839 | 285 | idle_slot_node); |
cb77cb5a | 286 | slot_idx = blk_crypto_keyslot_index(slot); |
1b262839 | 287 | |
cb77cb5a | 288 | err = profile->ll_ops.keyslot_program(profile, key, slot_idx); |
1b262839 | 289 | if (err) { |
cb77cb5a EB |
290 | wake_up(&profile->idle_slots_wait_queue); |
291 | blk_crypto_hw_exit(profile); | |
1b262839 ST |
292 | return errno_to_blk_status(err); |
293 | } | |
294 | ||
295 | /* Move this slot to the hash list for the new key. */ | |
296 | if (slot->key) | |
297 | hlist_del(&slot->hash_node); | |
298 | slot->key = key; | |
cb77cb5a EB |
299 | hlist_add_head(&slot->hash_node, |
300 | blk_crypto_hash_bucket_for_key(profile, key)); | |
1b262839 ST |
301 | |
302 | atomic_set(&slot->slot_refs, 1); | |
303 | ||
cb77cb5a | 304 | blk_crypto_remove_slot_from_lru_list(slot); |
1b262839 | 305 | |
cb77cb5a | 306 | blk_crypto_hw_exit(profile); |
1b262839 ST |
307 | success: |
308 | *slot_ptr = slot; | |
309 | return BLK_STS_OK; | |
310 | } | |
311 | ||
312 | /** | |
cb77cb5a EB |
313 | * blk_crypto_put_keyslot() - Release a reference to a keyslot |
314 | * @slot: The keyslot to release the reference of (may be NULL). | |
1b262839 ST |
315 | * |
316 | * Context: Any context. | |
317 | */ | |
cb77cb5a | 318 | void blk_crypto_put_keyslot(struct blk_crypto_keyslot *slot) |
1b262839 | 319 | { |
cb77cb5a | 320 | struct blk_crypto_profile *profile; |
1b262839 ST |
321 | unsigned long flags; |
322 | ||
323 | if (!slot) | |
324 | return; | |
325 | ||
cb77cb5a | 326 | profile = slot->profile; |
1b262839 ST |
327 | |
328 | if (atomic_dec_and_lock_irqsave(&slot->slot_refs, | |
cb77cb5a EB |
329 | &profile->idle_slots_lock, flags)) { |
330 | list_add_tail(&slot->idle_slot_node, &profile->idle_slots); | |
331 | spin_unlock_irqrestore(&profile->idle_slots_lock, flags); | |
332 | wake_up(&profile->idle_slots_wait_queue); | |
1b262839 ST |
333 | } |
334 | } | |
335 | ||
336 | /** | |
cb77cb5a EB |
337 | * __blk_crypto_cfg_supported() - Check whether the given crypto profile |
338 | * supports the given crypto configuration. | |
339 | * @profile: the crypto profile to check | |
340 | * @cfg: the crypto configuration to check for | |
1b262839 | 341 | * |
cb77cb5a | 342 | * Return: %true if @profile supports the given @cfg. |
1b262839 | 343 | */ |
cb77cb5a EB |
344 | bool __blk_crypto_cfg_supported(struct blk_crypto_profile *profile, |
345 | const struct blk_crypto_config *cfg) | |
1b262839 | 346 | { |
cb77cb5a | 347 | if (!profile) |
1b262839 | 348 | return false; |
cb77cb5a | 349 | if (!(profile->modes_supported[cfg->crypto_mode] & cfg->data_unit_size)) |
1b262839 | 350 | return false; |
cb77cb5a | 351 | if (profile->max_dun_bytes_supported < cfg->dun_bytes) |
1b262839 ST |
352 | return false; |
353 | return true; | |
354 | } | |
355 | ||
356 | /** | |
cb77cb5a EB |
357 | * __blk_crypto_evict_key() - Evict a key from a device. |
358 | * @profile: the crypto profile of the device | |
359 | * @key: the key to evict. It must not still be used in any I/O. | |
360 | * | |
361 | * If the device has keyslots, this finds the keyslot (if any) that contains the | |
362 | * specified key and calls the driver's keyslot_evict function to evict it. | |
1b262839 | 363 | * |
cb77cb5a EB |
364 | * Otherwise, this just calls the driver's keyslot_evict function if it is |
365 | * implemented, passing just the key (without any particular keyslot). This | |
366 | * allows layered devices to evict the key from their underlying devices. | |
1b262839 | 367 | * |
cb77cb5a | 368 | * Context: Process context. Takes and releases profile->lock. |
1b262839 ST |
369 | * Return: 0 on success or if there's no keyslot with the specified key, -EBUSY |
370 | * if the keyslot is still in use, or another -errno value on other | |
371 | * error. | |
372 | */ | |
cb77cb5a EB |
373 | int __blk_crypto_evict_key(struct blk_crypto_profile *profile, |
374 | const struct blk_crypto_key *key) | |
1b262839 | 375 | { |
cb77cb5a | 376 | struct blk_crypto_keyslot *slot; |
1b262839 ST |
377 | int err = 0; |
378 | ||
cb77cb5a EB |
379 | if (profile->num_slots == 0) { |
380 | if (profile->ll_ops.keyslot_evict) { | |
381 | blk_crypto_hw_enter(profile); | |
382 | err = profile->ll_ops.keyslot_evict(profile, key, -1); | |
383 | blk_crypto_hw_exit(profile); | |
7bdcc48f ST |
384 | return err; |
385 | } | |
386 | return 0; | |
387 | } | |
388 | ||
cb77cb5a EB |
389 | blk_crypto_hw_enter(profile); |
390 | slot = blk_crypto_find_keyslot(profile, key); | |
1b262839 ST |
391 | if (!slot) |
392 | goto out_unlock; | |
393 | ||
394 | if (WARN_ON_ONCE(atomic_read(&slot->slot_refs) != 0)) { | |
395 | err = -EBUSY; | |
396 | goto out_unlock; | |
397 | } | |
cb77cb5a EB |
398 | err = profile->ll_ops.keyslot_evict(profile, key, |
399 | blk_crypto_keyslot_index(slot)); | |
1b262839 ST |
400 | if (err) |
401 | goto out_unlock; | |
402 | ||
403 | hlist_del(&slot->hash_node); | |
404 | slot->key = NULL; | |
405 | err = 0; | |
406 | out_unlock: | |
cb77cb5a | 407 | blk_crypto_hw_exit(profile); |
1b262839 ST |
408 | return err; |
409 | } | |
410 | ||
411 | /** | |
cb77cb5a EB |
412 | * blk_crypto_reprogram_all_keys() - Re-program all keyslots. |
413 | * @profile: The crypto profile | |
1b262839 ST |
414 | * |
415 | * Re-program all keyslots that are supposed to have a key programmed. This is | |
416 | * intended only for use by drivers for hardware that loses its keys on reset. | |
417 | * | |
cb77cb5a | 418 | * Context: Process context. Takes and releases profile->lock. |
1b262839 | 419 | */ |
cb77cb5a | 420 | void blk_crypto_reprogram_all_keys(struct blk_crypto_profile *profile) |
1b262839 ST |
421 | { |
422 | unsigned int slot; | |
423 | ||
cb77cb5a | 424 | if (profile->num_slots == 0) |
7bdcc48f ST |
425 | return; |
426 | ||
1b262839 | 427 | /* This is for device initialization, so don't resume the device */ |
cb77cb5a EB |
428 | down_write(&profile->lock); |
429 | for (slot = 0; slot < profile->num_slots; slot++) { | |
430 | const struct blk_crypto_key *key = profile->slots[slot].key; | |
1b262839 ST |
431 | int err; |
432 | ||
433 | if (!key) | |
434 | continue; | |
435 | ||
cb77cb5a | 436 | err = profile->ll_ops.keyslot_program(profile, key, slot); |
1b262839 ST |
437 | WARN_ON(err); |
438 | } | |
cb77cb5a | 439 | up_write(&profile->lock); |
1b262839 | 440 | } |
cb77cb5a | 441 | EXPORT_SYMBOL_GPL(blk_crypto_reprogram_all_keys); |
1b262839 | 442 | |
cb77cb5a | 443 | void blk_crypto_profile_destroy(struct blk_crypto_profile *profile) |
1b262839 | 444 | { |
cb77cb5a | 445 | if (!profile) |
1b262839 | 446 | return; |
cb77cb5a EB |
447 | kvfree(profile->slot_hashtable); |
448 | kvfree_sensitive(profile->slots, | |
449 | sizeof(profile->slots[0]) * profile->num_slots); | |
450 | memzero_explicit(profile, sizeof(*profile)); | |
1b262839 | 451 | } |
cb77cb5a | 452 | EXPORT_SYMBOL_GPL(blk_crypto_profile_destroy); |
d145dc23 | 453 | |
cb77cb5a EB |
454 | bool blk_crypto_register(struct blk_crypto_profile *profile, |
455 | struct request_queue *q) | |
d145dc23 ST |
456 | { |
457 | if (blk_integrity_queue_supports_integrity(q)) { | |
458 | pr_warn("Integrity and hardware inline encryption are not supported together. Disabling hardware inline encryption.\n"); | |
459 | return false; | |
460 | } | |
cb77cb5a | 461 | q->crypto_profile = profile; |
d145dc23 ST |
462 | return true; |
463 | } | |
cb77cb5a | 464 | EXPORT_SYMBOL_GPL(blk_crypto_register); |
d145dc23 | 465 | |
d3b17a24 | 466 | /** |
cb77cb5a EB |
467 | * blk_crypto_intersect_capabilities() - restrict supported crypto capabilities |
468 | * by child device | |
469 | * @parent: the crypto profile for the parent device | |
470 | * @child: the crypto profile for the child device, or NULL | |
d3b17a24 | 471 | * |
cb77cb5a EB |
472 | * This clears all crypto capabilities in @parent that aren't set in @child. If |
473 | * @child is NULL, then this clears all parent capabilities. | |
d3b17a24 | 474 | * |
cb77cb5a EB |
475 | * Only use this when setting up the crypto profile for a layered device, before |
476 | * it's been exposed yet. | |
d3b17a24 | 477 | */ |
cb77cb5a EB |
478 | void blk_crypto_intersect_capabilities(struct blk_crypto_profile *parent, |
479 | const struct blk_crypto_profile *child) | |
d3b17a24 ST |
480 | { |
481 | if (child) { | |
482 | unsigned int i; | |
483 | ||
484 | parent->max_dun_bytes_supported = | |
485 | min(parent->max_dun_bytes_supported, | |
486 | child->max_dun_bytes_supported); | |
cb77cb5a EB |
487 | for (i = 0; i < ARRAY_SIZE(child->modes_supported); i++) |
488 | parent->modes_supported[i] &= child->modes_supported[i]; | |
d3b17a24 ST |
489 | } else { |
490 | parent->max_dun_bytes_supported = 0; | |
cb77cb5a EB |
491 | memset(parent->modes_supported, 0, |
492 | sizeof(parent->modes_supported)); | |
d3b17a24 ST |
493 | } |
494 | } | |
cb77cb5a | 495 | EXPORT_SYMBOL_GPL(blk_crypto_intersect_capabilities); |
d3b17a24 ST |
496 | |
497 | /** | |
cb77cb5a EB |
498 | * blk_crypto_has_capabilities() - Check whether @target supports at least all |
499 | * the crypto capabilities that @reference does. | |
500 | * @target: the target profile | |
501 | * @reference: the reference profile | |
d3b17a24 | 502 | * |
cb77cb5a | 503 | * Return: %true if @target supports all the crypto capabilities of @reference. |
d3b17a24 | 504 | */ |
cb77cb5a EB |
505 | bool blk_crypto_has_capabilities(const struct blk_crypto_profile *target, |
506 | const struct blk_crypto_profile *reference) | |
d3b17a24 ST |
507 | { |
508 | int i; | |
509 | ||
cb77cb5a | 510 | if (!reference) |
d3b17a24 ST |
511 | return true; |
512 | ||
cb77cb5a | 513 | if (!target) |
d3b17a24 ST |
514 | return false; |
515 | ||
cb77cb5a EB |
516 | for (i = 0; i < ARRAY_SIZE(target->modes_supported); i++) { |
517 | if (reference->modes_supported[i] & ~target->modes_supported[i]) | |
d3b17a24 | 518 | return false; |
d3b17a24 ST |
519 | } |
520 | ||
cb77cb5a EB |
521 | if (reference->max_dun_bytes_supported > |
522 | target->max_dun_bytes_supported) | |
d3b17a24 | 523 | return false; |
d3b17a24 ST |
524 | |
525 | return true; | |
526 | } | |
cb77cb5a | 527 | EXPORT_SYMBOL_GPL(blk_crypto_has_capabilities); |
d3b17a24 ST |
528 | |
529 | /** | |
cb77cb5a EB |
530 | * blk_crypto_update_capabilities() - Update the capabilities of a crypto |
531 | * profile to match those of another crypto | |
532 | * profile. | |
533 | * @dst: The crypto profile whose capabilities to update. | |
534 | * @src: The crypto profile whose capabilities this function will update @dst's | |
535 | * capabilities to. | |
d3b17a24 ST |
536 | * |
537 | * Blk-crypto requires that crypto capabilities that were | |
538 | * advertised when a bio was created continue to be supported by the | |
539 | * device until that bio is ended. This is turn means that a device cannot | |
540 | * shrink its advertised crypto capabilities without any explicit | |
541 | * synchronization with upper layers. So if there's no such explicit | |
cb77cb5a EB |
542 | * synchronization, @src must support all the crypto capabilities that |
543 | * @dst does (i.e. we need blk_crypto_has_capabilities(@src, @dst)). | |
d3b17a24 ST |
544 | * |
545 | * Note also that as long as the crypto capabilities are being expanded, the | |
546 | * order of updates becoming visible is not important because it's alright | |
547 | * for blk-crypto to see stale values - they only cause blk-crypto to | |
548 | * believe that a crypto capability isn't supported when it actually is (which | |
549 | * might result in blk-crypto-fallback being used if available, or the bio being | |
550 | * failed). | |
551 | */ | |
cb77cb5a EB |
552 | void blk_crypto_update_capabilities(struct blk_crypto_profile *dst, |
553 | const struct blk_crypto_profile *src) | |
d3b17a24 | 554 | { |
cb77cb5a EB |
555 | memcpy(dst->modes_supported, src->modes_supported, |
556 | sizeof(dst->modes_supported)); | |
d3b17a24 | 557 | |
cb77cb5a | 558 | dst->max_dun_bytes_supported = src->max_dun_bytes_supported; |
7bdcc48f | 559 | } |
cb77cb5a | 560 | EXPORT_SYMBOL_GPL(blk_crypto_update_capabilities); |