Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
| 2 | /* |
| 3 | * Copyright 2021 Google LLC |
| 4 | * |
| 5 | * sysfs support for blk-crypto. This file contains the code which exports the |
| 6 | * crypto capabilities of devices via /sys/block/$disk/queue/crypto/. |
| 7 | */ |
| 8 | |
| 9 | #include <linux/blk-crypto-profile.h> |
| 10 | |
| 11 | #include "blk-crypto-internal.h" |
| 12 | |
| 13 | struct blk_crypto_kobj { |
| 14 | struct kobject kobj; |
| 15 | struct blk_crypto_profile *profile; |
| 16 | }; |
| 17 | |
| 18 | struct blk_crypto_attr { |
| 19 | struct attribute attr; |
| 20 | ssize_t (*show)(struct blk_crypto_profile *profile, |
| 21 | struct blk_crypto_attr *attr, char *page); |
| 22 | }; |
| 23 | |
| 24 | static struct blk_crypto_profile *kobj_to_crypto_profile(struct kobject *kobj) |
| 25 | { |
| 26 | return container_of(kobj, struct blk_crypto_kobj, kobj)->profile; |
| 27 | } |
| 28 | |
| 29 | static struct blk_crypto_attr *attr_to_crypto_attr(struct attribute *attr) |
| 30 | { |
| 31 | return container_of(attr, struct blk_crypto_attr, attr); |
| 32 | } |
| 33 | |
| 34 | static ssize_t max_dun_bits_show(struct blk_crypto_profile *profile, |
| 35 | struct blk_crypto_attr *attr, char *page) |
| 36 | { |
| 37 | return sysfs_emit(page, "%u\n", 8 * profile->max_dun_bytes_supported); |
| 38 | } |
| 39 | |
| 40 | static ssize_t num_keyslots_show(struct blk_crypto_profile *profile, |
| 41 | struct blk_crypto_attr *attr, char *page) |
| 42 | { |
| 43 | return sysfs_emit(page, "%u\n", profile->num_slots); |
| 44 | } |
| 45 | |
| 46 | #define BLK_CRYPTO_RO_ATTR(_name) \ |
| 47 | static struct blk_crypto_attr _name##_attr = __ATTR_RO(_name) |
| 48 | |
| 49 | BLK_CRYPTO_RO_ATTR(max_dun_bits); |
| 50 | BLK_CRYPTO_RO_ATTR(num_keyslots); |
| 51 | |
| 52 | static struct attribute *blk_crypto_attrs[] = { |
| 53 | &max_dun_bits_attr.attr, |
| 54 | &num_keyslots_attr.attr, |
| 55 | NULL, |
| 56 | }; |
| 57 | |
| 58 | static const struct attribute_group blk_crypto_attr_group = { |
| 59 | .attrs = blk_crypto_attrs, |
| 60 | }; |
| 61 | |
| 62 | /* |
| 63 | * The encryption mode attributes. To avoid hard-coding the list of encryption |
| 64 | * modes, these are initialized at boot time by blk_crypto_sysfs_init(). |
| 65 | */ |
| 66 | static struct blk_crypto_attr __blk_crypto_mode_attrs[BLK_ENCRYPTION_MODE_MAX]; |
| 67 | static struct attribute *blk_crypto_mode_attrs[BLK_ENCRYPTION_MODE_MAX + 1]; |
| 68 | |
| 69 | static umode_t blk_crypto_mode_is_visible(struct kobject *kobj, |
| 70 | struct attribute *attr, int n) |
| 71 | { |
| 72 | struct blk_crypto_profile *profile = kobj_to_crypto_profile(kobj); |
| 73 | struct blk_crypto_attr *a = attr_to_crypto_attr(attr); |
| 74 | int mode_num = a - __blk_crypto_mode_attrs; |
| 75 | |
| 76 | if (profile->modes_supported[mode_num]) |
| 77 | return 0444; |
| 78 | return 0; |
| 79 | } |
| 80 | |
| 81 | static ssize_t blk_crypto_mode_show(struct blk_crypto_profile *profile, |
| 82 | struct blk_crypto_attr *attr, char *page) |
| 83 | { |
| 84 | int mode_num = attr - __blk_crypto_mode_attrs; |
| 85 | |
| 86 | return sysfs_emit(page, "0x%x\n", profile->modes_supported[mode_num]); |
| 87 | } |
| 88 | |
| 89 | static const struct attribute_group blk_crypto_modes_attr_group = { |
| 90 | .name = "modes", |
| 91 | .attrs = blk_crypto_mode_attrs, |
| 92 | .is_visible = blk_crypto_mode_is_visible, |
| 93 | }; |
| 94 | |
| 95 | static const struct attribute_group *blk_crypto_attr_groups[] = { |
| 96 | &blk_crypto_attr_group, |
| 97 | &blk_crypto_modes_attr_group, |
| 98 | NULL, |
| 99 | }; |
| 100 | |
| 101 | static ssize_t blk_crypto_attr_show(struct kobject *kobj, |
| 102 | struct attribute *attr, char *page) |
| 103 | { |
| 104 | struct blk_crypto_profile *profile = kobj_to_crypto_profile(kobj); |
| 105 | struct blk_crypto_attr *a = attr_to_crypto_attr(attr); |
| 106 | |
| 107 | return a->show(profile, a, page); |
| 108 | } |
| 109 | |
| 110 | static const struct sysfs_ops blk_crypto_attr_ops = { |
| 111 | .show = blk_crypto_attr_show, |
| 112 | }; |
| 113 | |
| 114 | static void blk_crypto_release(struct kobject *kobj) |
| 115 | { |
| 116 | kfree(container_of(kobj, struct blk_crypto_kobj, kobj)); |
| 117 | } |
| 118 | |
Thomas Weißschuh | 5f62241 | 2023-02-08 04:01:22 +0000 | [diff] [blame] | 119 | static const struct kobj_type blk_crypto_ktype = { |
Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 120 | .default_groups = blk_crypto_attr_groups, |
| 121 | .sysfs_ops = &blk_crypto_attr_ops, |
| 122 | .release = blk_crypto_release, |
| 123 | }; |
| 124 | |
| 125 | /* |
| 126 | * If the request_queue has a blk_crypto_profile, create the "crypto" |
| 127 | * subdirectory in sysfs (/sys/block/$disk/queue/crypto/). |
| 128 | */ |
Christoph Hellwig | 450deb9 | 2022-11-14 05:26:33 +0100 | [diff] [blame] | 129 | int blk_crypto_sysfs_register(struct gendisk *disk) |
Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 130 | { |
Christoph Hellwig | 450deb9 | 2022-11-14 05:26:33 +0100 | [diff] [blame] | 131 | struct request_queue *q = disk->queue; |
Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 132 | struct blk_crypto_kobj *obj; |
| 133 | int err; |
| 134 | |
| 135 | if (!q->crypto_profile) |
| 136 | return 0; |
| 137 | |
| 138 | obj = kzalloc(sizeof(*obj), GFP_KERNEL); |
| 139 | if (!obj) |
| 140 | return -ENOMEM; |
| 141 | obj->profile = q->crypto_profile; |
| 142 | |
Christoph Hellwig | 2bd8522 | 2022-11-14 05:26:36 +0100 | [diff] [blame] | 143 | err = kobject_init_and_add(&obj->kobj, &blk_crypto_ktype, |
| 144 | &disk->queue_kobj, "crypto"); |
Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 145 | if (err) { |
| 146 | kobject_put(&obj->kobj); |
| 147 | return err; |
| 148 | } |
| 149 | q->crypto_kobject = &obj->kobj; |
| 150 | return 0; |
| 151 | } |
| 152 | |
Christoph Hellwig | 450deb9 | 2022-11-14 05:26:33 +0100 | [diff] [blame] | 153 | void blk_crypto_sysfs_unregister(struct gendisk *disk) |
Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 154 | { |
Christoph Hellwig | 450deb9 | 2022-11-14 05:26:33 +0100 | [diff] [blame] | 155 | kobject_put(disk->queue->crypto_kobject); |
Eric Biggers | 20f01f1 | 2022-01-24 13:59:38 -0800 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | static int __init blk_crypto_sysfs_init(void) |
| 159 | { |
| 160 | int i; |
| 161 | |
| 162 | BUILD_BUG_ON(BLK_ENCRYPTION_MODE_INVALID != 0); |
| 163 | for (i = 1; i < BLK_ENCRYPTION_MODE_MAX; i++) { |
| 164 | struct blk_crypto_attr *attr = &__blk_crypto_mode_attrs[i]; |
| 165 | |
| 166 | attr->attr.name = blk_crypto_modes[i].name; |
| 167 | attr->attr.mode = 0444; |
| 168 | attr->show = blk_crypto_mode_show; |
| 169 | blk_crypto_mode_attrs[i - 1] = &attr->attr; |
| 170 | } |
| 171 | return 0; |
| 172 | } |
| 173 | subsys_initcall(blk_crypto_sysfs_init); |