block/rnbd/rnbd-srv-sysfs.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * RDMA Network Block Driver
0004  *
0005  * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
0006  * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
0007  * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
0008  */
0009 #undef pr_fmt
0010 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
0011
0012 #include <uapi/linux/limits.h>
0013 #include <linux/kobject.h>
0014 #include <linux/sysfs.h>
0015 #include <linux/stat.h>
0016 #include <linux/list.h>
0017 #include <linux/moduleparam.h>
0018 #include <linux/device.h>
0019
0020 #include "rnbd-srv.h"
0021
0022 static struct device *rnbd_dev;
0023 static struct class *rnbd_dev_class;
0024 static struct kobject *rnbd_devs_kobj;
0025
0026 static void rnbd_srv_dev_release(struct kobject *kobj)
0027 {
0028     struct rnbd_srv_dev *dev;
0029
0030     dev = container_of(kobj, struct rnbd_srv_dev, dev_kobj);
0031
0032     kfree(dev);
0033 }
0034
0035 static struct kobj_type dev_ktype = {
0036     .sysfs_ops = &kobj_sysfs_ops,
0037     .release = rnbd_srv_dev_release
0038 };
0039
0040 int rnbd_srv_create_dev_sysfs(struct rnbd_srv_dev *dev,
0041                    struct block_device *bdev)
0042 {
0043     struct kobject *bdev_kobj;
0044     int ret;
0045
0046     ret = kobject_init_and_add(&dev->dev_kobj, &dev_ktype,
0047                    rnbd_devs_kobj, "%pg", bdev);
0048     if (ret) {
0049         kobject_put(&dev->dev_kobj);
0050         return ret;
0051     }
0052
0053     dev->dev_sessions_kobj = kobject_create_and_add("sessions",
0054                             &dev->dev_kobj);
0055     if (!dev->dev_sessions_kobj) {
0056         ret = -ENOMEM;
0057         goto free_dev_kobj;
0058     }
0059
0060     bdev_kobj = &disk_to_dev(bdev->bd_disk)->kobj;
0061     ret = sysfs_create_link(&dev->dev_kobj, bdev_kobj, "block_dev");
0062     if (ret)
0063         goto put_sess_kobj;
0064
0065     return 0;
0066
0067 put_sess_kobj:
0068     kobject_put(dev->dev_sessions_kobj);
0069 free_dev_kobj:
0070     kobject_del(&dev->dev_kobj);
0071     kobject_put(&dev->dev_kobj);
0072     return ret;
0073 }
0074
0075 void rnbd_srv_destroy_dev_sysfs(struct rnbd_srv_dev *dev)
0076 {
0077     sysfs_remove_link(&dev->dev_kobj, "block_dev");
0078     kobject_del(dev->dev_sessions_kobj);
0079     kobject_put(dev->dev_sessions_kobj);
0080     kobject_del(&dev->dev_kobj);
0081     kobject_put(&dev->dev_kobj);
0082 }
0083
0084 static ssize_t read_only_show(struct kobject *kobj, struct kobj_attribute *attr,
0085                   char *page)
0086 {
0087     struct rnbd_srv_sess_dev *sess_dev;
0088
0089     sess_dev = container_of(kobj, struct rnbd_srv_sess_dev, kobj);
0090
0091     return sysfs_emit(page, "%d\n",
0092               !(sess_dev->open_flags & FMODE_WRITE));
0093 }
0094
0095 static struct kobj_attribute rnbd_srv_dev_session_ro_attr =
0096     __ATTR_RO(read_only);
0097
0098 static ssize_t access_mode_show(struct kobject *kobj,
0099                 struct kobj_attribute *attr,
0100                 char *page)
0101 {
0102     struct rnbd_srv_sess_dev *sess_dev;
0103
0104     sess_dev = container_of(kobj, struct rnbd_srv_sess_dev, kobj);
0105
0106     return sysfs_emit(page, "%s\n",
0107               rnbd_access_mode_str(sess_dev->access_mode));
0108 }
0109
0110 static struct kobj_attribute rnbd_srv_dev_session_access_mode_attr =
0111     __ATTR_RO(access_mode);
0112
0113 static ssize_t mapping_path_show(struct kobject *kobj,
0114                  struct kobj_attribute *attr, char *page)
0115 {
0116     struct rnbd_srv_sess_dev *sess_dev;
0117
0118     sess_dev = container_of(kobj, struct rnbd_srv_sess_dev, kobj);
0119
0120     return sysfs_emit(page, "%s\n", sess_dev->pathname);
0121 }
0122
0123 static struct kobj_attribute rnbd_srv_dev_session_mapping_path_attr =
0124     __ATTR_RO(mapping_path);
0125
0126 static ssize_t rnbd_srv_dev_session_force_close_show(struct kobject *kobj,
0127                     struct kobj_attribute *attr, char *page)
0128 {
0129     return sysfs_emit(page, "Usage: echo 1 > %s\n",
0130               attr->attr.name);
0131 }
0132
0133 static ssize_t rnbd_srv_dev_session_force_close_store(struct kobject *kobj,
0134                     struct kobj_attribute *attr,
0135                     const char *buf, size_t count)
0136 {
0137     struct rnbd_srv_sess_dev *sess_dev;
0138
0139     sess_dev = container_of(kobj, struct rnbd_srv_sess_dev, kobj);
0140
0141     if (!sysfs_streq(buf, "1")) {
0142         rnbd_srv_err(sess_dev, "%s: invalid value: '%s'\n",
0143                   attr->attr.name, buf);
0144         return -EINVAL;
0145     }
0146
0147     rnbd_srv_info(sess_dev, "force close requested\n");
0148     rnbd_srv_sess_dev_force_close(sess_dev, attr);
0149
0150     return count;
0151 }
0152
0153 static struct kobj_attribute rnbd_srv_dev_session_force_close_attr =
0154     __ATTR(force_close, 0644,
0155            rnbd_srv_dev_session_force_close_show,
0156            rnbd_srv_dev_session_force_close_store);
0157
0158 static struct attribute *rnbd_srv_default_dev_sessions_attrs[] = {
0159     &rnbd_srv_dev_session_access_mode_attr.attr,
0160     &rnbd_srv_dev_session_ro_attr.attr,
0161     &rnbd_srv_dev_session_mapping_path_attr.attr,
0162     &rnbd_srv_dev_session_force_close_attr.attr,
0163     NULL,
0164 };
0165
0166 static struct attribute_group rnbd_srv_default_dev_session_attr_group = {
0167     .attrs = rnbd_srv_default_dev_sessions_attrs,
0168 };
0169
0170 void rnbd_srv_destroy_dev_session_sysfs(struct rnbd_srv_sess_dev *sess_dev)
0171 {
0172     sysfs_remove_group(&sess_dev->kobj,
0173                &rnbd_srv_default_dev_session_attr_group);
0174
0175     kobject_del(&sess_dev->kobj);
0176     kobject_put(&sess_dev->kobj);
0177 }
0178
0179 static void rnbd_srv_sess_dev_release(struct kobject *kobj)
0180 {
0181     struct rnbd_srv_sess_dev *sess_dev;
0182
0183     sess_dev = container_of(kobj, struct rnbd_srv_sess_dev, kobj);
0184     rnbd_destroy_sess_dev(sess_dev, sess_dev->keep_id);
0185 }
0186
0187 static struct kobj_type rnbd_srv_sess_dev_ktype = {
0188     .sysfs_ops  = &kobj_sysfs_ops,
0189     .release    = rnbd_srv_sess_dev_release,
0190 };
0191
0192 int rnbd_srv_create_dev_session_sysfs(struct rnbd_srv_sess_dev *sess_dev)
0193 {
0194     int ret;
0195
0196     ret = kobject_init_and_add(&sess_dev->kobj, &rnbd_srv_sess_dev_ktype,
0197                    sess_dev->dev->dev_sessions_kobj, "%s",
0198                    sess_dev->sess->sessname);
0199     if (ret) {
0200         kobject_put(&sess_dev->kobj);
0201         return ret;
0202     }
0203
0204     ret = sysfs_create_group(&sess_dev->kobj,
0205                  &rnbd_srv_default_dev_session_attr_group);
0206     if (ret) {
0207         kobject_del(&sess_dev->kobj);
0208         kobject_put(&sess_dev->kobj);
0209     }
0210
0211     return ret;
0212 }
0213
0214 int rnbd_srv_create_sysfs_files(void)
0215 {
0216     int err;
0217
0218     rnbd_dev_class = class_create(THIS_MODULE, "rnbd-server");
0219     if (IS_ERR(rnbd_dev_class))
0220         return PTR_ERR(rnbd_dev_class);
0221
0222     rnbd_dev = device_create(rnbd_dev_class, NULL,
0223                   MKDEV(0, 0), NULL, "ctl");
0224     if (IS_ERR(rnbd_dev)) {
0225         err = PTR_ERR(rnbd_dev);
0226         goto cls_destroy;
0227     }
0228     rnbd_devs_kobj = kobject_create_and_add("devices", &rnbd_dev->kobj);
0229     if (!rnbd_devs_kobj) {
0230         err = -ENOMEM;
0231         goto dev_destroy;
0232     }
0233
0234     return 0;
0235
0236 dev_destroy:
0237     device_destroy(rnbd_dev_class, MKDEV(0, 0));
0238 cls_destroy:
0239     class_destroy(rnbd_dev_class);
0240
0241     return err;
0242 }
0243
0244 void rnbd_srv_destroy_sysfs_files(void)
0245 {
0246     kobject_del(rnbd_devs_kobj);
0247     kobject_put(rnbd_devs_kobj);
0248     device_destroy(rnbd_dev_class, MKDEV(0, 0));
0249     class_destroy(rnbd_dev_class);
0250 }