Commit | Line | Data |
---|---|---|
20f01f16 EB |
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 | ||
5f622417 | 119 | static const struct kobj_type blk_crypto_ktype = { |
20f01f16 EB |
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 | */ | |
450deb93 | 129 | int blk_crypto_sysfs_register(struct gendisk *disk) |
20f01f16 | 130 | { |
450deb93 | 131 | struct request_queue *q = disk->queue; |
20f01f16 EB |
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 | ||
2bd85221 CH |
143 | err = kobject_init_and_add(&obj->kobj, &blk_crypto_ktype, |
144 | &disk->queue_kobj, "crypto"); | |
20f01f16 EB |
145 | if (err) { |
146 | kobject_put(&obj->kobj); | |
147 | return err; | |
148 | } | |
149 | q->crypto_kobject = &obj->kobj; | |
150 | return 0; | |
151 | } | |
152 | ||
450deb93 | 153 | void blk_crypto_sysfs_unregister(struct gendisk *disk) |
20f01f16 | 154 | { |
450deb93 | 155 | kobject_put(disk->queue->crypto_kobject); |
20f01f16 EB |
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); |