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
13struct blk_crypto_kobj {
14 struct kobject kobj;
15 struct blk_crypto_profile *profile;
16};
17
18struct 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
24static 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
29static struct blk_crypto_attr *attr_to_crypto_attr(struct attribute *attr)
30{
31 return container_of(attr, struct blk_crypto_attr, attr);
32}
33
34static 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
40static 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
49BLK_CRYPTO_RO_ATTR(max_dun_bits);
50BLK_CRYPTO_RO_ATTR(num_keyslots);
51
52static struct attribute *blk_crypto_attrs[] = {
53 &max_dun_bits_attr.attr,
54 &num_keyslots_attr.attr,
55 NULL,
56};
57
58static 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 */
66static struct blk_crypto_attr __blk_crypto_mode_attrs[BLK_ENCRYPTION_MODE_MAX];
67static struct attribute *blk_crypto_mode_attrs[BLK_ENCRYPTION_MODE_MAX + 1];
68
69static 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
81static 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
89static 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
95static const struct attribute_group *blk_crypto_attr_groups[] = {
96 &blk_crypto_attr_group,
97 &blk_crypto_modes_attr_group,
98 NULL,
99};
100
101static 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
110static const struct sysfs_ops blk_crypto_attr_ops = {
111 .show = blk_crypto_attr_show,
112};
113
114static void blk_crypto_release(struct kobject *kobj)
115{
116 kfree(container_of(kobj, struct blk_crypto_kobj, kobj));
117}
118
119static 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 */
129int 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
153void blk_crypto_sysfs_unregister(struct gendisk *disk)
154{
155 kobject_put(kobj: disk->queue->crypto_kobject);
156}
157
158static 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}
173subsys_initcall(blk_crypto_sysfs_init);
174

source code of linux/block/blk-crypto-sysfs.c