LXR linux/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
  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(page, "%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(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
  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(page, "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(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
 153void blk_crypto_sysfs_unregister(struct gendisk *disk)
 154{
 155        kobject_put(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