block/blk-crypto-sysfs.c

   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
 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(sizeof(*obj), GFP_KERNEL);
 139         if (!obj)
 140                 return -ENOMEM;
 141         obj->profile = q->crypto_profile;
 142
 143         err = kobject_init_and_add(&obj->kobj, &blk_crypto_ktype,
 144                                    &disk->queue_kobj, "crypto");
 145         if (err) {
 146                 kobject_put(&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(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);