cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

blk-crypto-sysfs.c (4505B)

      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 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 request_queue *q)
    130{
    131	struct blk_crypto_kobj *obj;
    132	int err;
    133
    134	if (!q->crypto_profile)
    135		return 0;
    136
    137	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
    138	if (!obj)
    139		return -ENOMEM;
    140	obj->profile = q->crypto_profile;
    141
    142	err = kobject_init_and_add(&obj->kobj, &blk_crypto_ktype, &q->kobj,
    143				   "crypto");
    144	if (err) {
    145		kobject_put(&obj->kobj);
    146		return err;
    147	}
    148	q->crypto_kobject = &obj->kobj;
    149	return 0;
    150}
    151
    152void blk_crypto_sysfs_unregister(struct request_queue *q)
    153{
    154	kobject_put(q->crypto_kobject);
    155}
    156
    157static int __init blk_crypto_sysfs_init(void)
    158{
    159	int i;
    160
    161	BUILD_BUG_ON(BLK_ENCRYPTION_MODE_INVALID != 0);
    162	for (i = 1; i < BLK_ENCRYPTION_MODE_MAX; i++) {
    163		struct blk_crypto_attr *attr = &__blk_crypto_mode_attrs[i];
    164
    165		attr->attr.name = blk_crypto_modes[i].name;
    166		attr->attr.mode = 0444;
    167		attr->show = blk_crypto_mode_show;
    168		blk_crypto_mode_attrs[i - 1] = &attr->attr;
    169	}
    170	return 0;
    171}
    172subsys_initcall(blk_crypto_sysfs_init);