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(buf: page, fmt: "%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(buf: page, fmt: "%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(buf: page, fmt: "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 | |
119 | static const struct kobj_type blk_crypto_ktype = { |
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 | */ |
129 | int blk_crypto_sysfs_register(struct gendisk *disk) |
130 | { |
131 | struct request_queue *q = disk->queue; |
132 | struct blk_crypto_kobj *obj; |
133 | int err; |
134 | |
135 | if (!q->crypto_profile) |
136 | return 0; |
137 | |
138 | obj = kzalloc(size: sizeof(*obj), GFP_KERNEL); |
139 | if (!obj) |
140 | return -ENOMEM; |
141 | obj->profile = q->crypto_profile; |
142 | |
143 | err = kobject_init_and_add(kobj: &obj->kobj, ktype: &blk_crypto_ktype, |
144 | parent: &disk->queue_kobj, fmt: "crypto" ); |
145 | if (err) { |
146 | kobject_put(kobj: &obj->kobj); |
147 | return err; |
148 | } |
149 | q->crypto_kobject = &obj->kobj; |
150 | return 0; |
151 | } |
152 | |
153 | void blk_crypto_sysfs_unregister(struct gendisk *disk) |
154 | { |
155 | kobject_put(kobj: disk->queue->crypto_kobject); |
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); |
174 | |