1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * RDMA Network Block Driver
5 * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
6 * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
7 * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
11 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
13 #include <linux/types.h>
14 #include <linux/ctype.h>
15 #include <linux/parser.h>
16 #include <linux/module.h>
17 #include <linux/in6.h>
19 #include <linux/uaccess.h>
20 #include <linux/device.h>
22 #include <rdma/rdma_cm.h>
26 static struct device *rnbd_dev;
27 static struct class *rnbd_dev_class;
28 static struct kobject *rnbd_devs_kobj;
32 RNBD_OPT_DEST_PORT = 1 << 0,
33 RNBD_OPT_PATH = 1 << 1,
34 RNBD_OPT_DEV_PATH = 1 << 2,
35 RNBD_OPT_ACCESS_MODE = 1 << 3,
36 RNBD_OPT_SESSNAME = 1 << 6,
39 static const unsigned int rnbd_opt_mandatory[] = {
45 static const match_table_t rnbd_opt_tokens = {
46 {RNBD_OPT_PATH, "path=%s" },
47 {RNBD_OPT_DEV_PATH, "device_path=%s"},
48 {RNBD_OPT_DEST_PORT, "dest_port=%d" },
49 {RNBD_OPT_ACCESS_MODE, "access_mode=%s"},
50 {RNBD_OPT_SESSNAME, "sessname=%s" },
51 {RNBD_OPT_ERR, NULL },
54 struct rnbd_map_options {
56 struct rtrs_addr *paths;
60 enum rnbd_access_mode *access_mode;
63 static int rnbd_clt_parse_map_options(const char *buf, size_t max_path_cnt,
64 struct rnbd_map_options *opt)
66 char *options, *sep_opt;
68 substring_t args[MAX_OPT_ARGS];
75 options = kstrdup(buf, GFP_KERNEL);
79 sep_opt = strstrip(options);
80 while ((p = strsep(&sep_opt, " ")) != NULL) {
84 token = match_token(p, rnbd_opt_tokens, args);
88 case RNBD_OPT_SESSNAME:
89 p = match_strdup(args);
94 if (strlen(p) > NAME_MAX) {
95 pr_err("map_device: sessname too long\n");
100 strlcpy(opt->sessname, p, NAME_MAX);
105 if (p_cnt >= max_path_cnt) {
106 pr_err("map_device: too many (> %zu) paths provided\n",
111 p = match_strdup(args);
117 ret = rtrs_addr_to_sockaddr(p, strlen(p),
121 pr_err("Can't parse path %s: %d\n", p, ret);
131 case RNBD_OPT_DEV_PATH:
132 p = match_strdup(args);
137 if (strlen(p) > NAME_MAX) {
138 pr_err("map_device: Device path too long\n");
143 strlcpy(opt->pathname, p, NAME_MAX);
147 case RNBD_OPT_DEST_PORT:
148 if (match_int(args, &dest_port) || dest_port < 0 ||
150 pr_err("bad destination port number parameter '%d'\n",
155 *opt->dest_port = dest_port;
158 case RNBD_OPT_ACCESS_MODE:
159 p = match_strdup(args);
165 if (!strcmp(p, "ro")) {
166 *opt->access_mode = RNBD_ACCESS_RO;
167 } else if (!strcmp(p, "rw")) {
168 *opt->access_mode = RNBD_ACCESS_RW;
169 } else if (!strcmp(p, "migration")) {
170 *opt->access_mode = RNBD_ACCESS_MIGRATION;
172 pr_err("map_device: Invalid access_mode: '%s'\n",
183 pr_err("map_device: Unknown parameter or missing value '%s'\n",
190 for (i = 0; i < ARRAY_SIZE(rnbd_opt_mandatory); i++) {
191 if ((opt_mask & rnbd_opt_mandatory[i])) {
194 pr_err("map_device: Parameters missing\n");
201 *opt->path_cnt = p_cnt;
206 static ssize_t state_show(struct kobject *kobj,
207 struct kobj_attribute *attr, char *page)
209 struct rnbd_clt_dev *dev;
211 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
213 switch (dev->dev_state) {
215 return snprintf(page, PAGE_SIZE, "init\n");
216 case DEV_STATE_MAPPED:
217 /* TODO fix cli tool before changing to proper state */
218 return snprintf(page, PAGE_SIZE, "open\n");
219 case DEV_STATE_MAPPED_DISCONNECTED:
220 /* TODO fix cli tool before changing to proper state */
221 return snprintf(page, PAGE_SIZE, "closed\n");
222 case DEV_STATE_UNMAPPED:
223 return snprintf(page, PAGE_SIZE, "unmapped\n");
225 return snprintf(page, PAGE_SIZE, "unknown\n");
229 static struct kobj_attribute rnbd_clt_state_attr = __ATTR_RO(state);
231 static ssize_t mapping_path_show(struct kobject *kobj,
232 struct kobj_attribute *attr, char *page)
234 struct rnbd_clt_dev *dev;
236 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
238 return scnprintf(page, PAGE_SIZE, "%s\n", dev->pathname);
241 static struct kobj_attribute rnbd_clt_mapping_path_attr =
242 __ATTR_RO(mapping_path);
244 static ssize_t access_mode_show(struct kobject *kobj,
245 struct kobj_attribute *attr, char *page)
247 struct rnbd_clt_dev *dev;
249 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
251 return snprintf(page, PAGE_SIZE, "%s\n",
252 rnbd_access_mode_str(dev->access_mode));
255 static struct kobj_attribute rnbd_clt_access_mode =
256 __ATTR_RO(access_mode);
258 static ssize_t rnbd_clt_unmap_dev_show(struct kobject *kobj,
259 struct kobj_attribute *attr, char *page)
261 return scnprintf(page, PAGE_SIZE, "Usage: echo <normal|force> > %s\n",
265 static ssize_t rnbd_clt_unmap_dev_store(struct kobject *kobj,
266 struct kobj_attribute *attr,
267 const char *buf, size_t count)
269 struct rnbd_clt_dev *dev;
274 opt = kstrdup(buf, GFP_KERNEL);
278 options = strstrip(opt);
279 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
280 if (sysfs_streq(options, "normal")) {
282 } else if (sysfs_streq(options, "force")) {
286 "unmap_device: Invalid value: %s\n",
292 rnbd_clt_info(dev, "Unmapping device, option: %s.\n",
293 force ? "force" : "normal");
296 * We take explicit module reference only for one reason: do not
297 * race with lockless rnbd_destroy_sessions().
299 if (!try_module_get(THIS_MODULE)) {
303 err = rnbd_clt_unmap_device(dev, force, &attr->attr);
305 if (err != -EALREADY)
306 rnbd_clt_err(dev, "unmap_device: %d\n", err);
311 * Here device can be vanished!
317 module_put(THIS_MODULE);
324 static struct kobj_attribute rnbd_clt_unmap_device_attr =
325 __ATTR(unmap_device, 0644, rnbd_clt_unmap_dev_show,
326 rnbd_clt_unmap_dev_store);
328 static ssize_t rnbd_clt_resize_dev_show(struct kobject *kobj,
329 struct kobj_attribute *attr,
332 return scnprintf(page, PAGE_SIZE,
333 "Usage: echo <new size in sectors> > %s\n",
337 static ssize_t rnbd_clt_resize_dev_store(struct kobject *kobj,
338 struct kobj_attribute *attr,
339 const char *buf, size_t count)
342 unsigned long sectors;
343 struct rnbd_clt_dev *dev;
345 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
347 ret = kstrtoul(buf, 0, §ors);
351 ret = rnbd_clt_resize_disk(dev, (size_t)sectors);
358 static struct kobj_attribute rnbd_clt_resize_dev_attr =
359 __ATTR(resize, 0644, rnbd_clt_resize_dev_show,
360 rnbd_clt_resize_dev_store);
362 static ssize_t rnbd_clt_remap_dev_show(struct kobject *kobj,
363 struct kobj_attribute *attr, char *page)
365 return scnprintf(page, PAGE_SIZE, "Usage: echo <1> > %s\n",
369 static ssize_t rnbd_clt_remap_dev_store(struct kobject *kobj,
370 struct kobj_attribute *attr,
371 const char *buf, size_t count)
373 struct rnbd_clt_dev *dev;
377 opt = kstrdup(buf, GFP_KERNEL);
381 options = strstrip(opt);
382 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
383 if (!sysfs_streq(options, "1")) {
385 "remap_device: Invalid value: %s\n",
390 err = rnbd_clt_remap_device(dev);
400 static struct kobj_attribute rnbd_clt_remap_device_attr =
401 __ATTR(remap_device, 0644, rnbd_clt_remap_dev_show,
402 rnbd_clt_remap_dev_store);
404 static ssize_t session_show(struct kobject *kobj, struct kobj_attribute *attr,
407 struct rnbd_clt_dev *dev;
409 dev = container_of(kobj, struct rnbd_clt_dev, kobj);
411 return scnprintf(page, PAGE_SIZE, "%s\n", dev->sess->sessname);
414 static struct kobj_attribute rnbd_clt_session_attr =
417 static struct attribute *rnbd_dev_attrs[] = {
418 &rnbd_clt_unmap_device_attr.attr,
419 &rnbd_clt_resize_dev_attr.attr,
420 &rnbd_clt_remap_device_attr.attr,
421 &rnbd_clt_mapping_path_attr.attr,
422 &rnbd_clt_state_attr.attr,
423 &rnbd_clt_session_attr.attr,
424 &rnbd_clt_access_mode.attr,
428 void rnbd_clt_remove_dev_symlink(struct rnbd_clt_dev *dev)
431 * The module unload rnbd_client_exit path is racing with unmapping of
432 * the last single device from the sysfs manually
433 * i.e. rnbd_clt_unmap_dev_store() leading to a sysfs warning because
434 * of sysfs link already was removed already.
436 if (dev->blk_symlink_name) {
437 if (try_module_get(THIS_MODULE)) {
438 sysfs_remove_link(rnbd_devs_kobj, dev->blk_symlink_name);
439 module_put(THIS_MODULE);
441 /* It should be freed always. */
442 kfree(dev->blk_symlink_name);
443 dev->blk_symlink_name = NULL;
447 static struct kobj_type rnbd_dev_ktype = {
448 .sysfs_ops = &kobj_sysfs_ops,
449 .default_attrs = rnbd_dev_attrs,
452 static int rnbd_clt_add_dev_kobj(struct rnbd_clt_dev *dev)
455 struct kobject *gd_kobj = &disk_to_dev(dev->gd)->kobj;
457 ret = kobject_init_and_add(&dev->kobj, &rnbd_dev_ktype, gd_kobj, "%s",
460 rnbd_clt_err(dev, "Failed to create device sysfs dir, err: %d\n",
466 static ssize_t rnbd_clt_map_device_show(struct kobject *kobj,
467 struct kobj_attribute *attr,
470 return scnprintf(page, PAGE_SIZE,
471 "Usage: echo \"[dest_port=server port number] sessname=<name of the rtrs session> path=<[srcaddr@]dstaddr> [path=<[srcaddr@]dstaddr>] device_path=<full path on remote side> [access_mode=<ro|rw|migration>]\" > %s\n\naddr ::= [ ip:<ipv4> | ip:<ipv6> | gid:<gid> ]\n",
475 static int rnbd_clt_get_path_name(struct rnbd_clt_dev *dev, char *buf,
479 char pathname[NAME_MAX], *s;
481 strlcpy(pathname, dev->pathname, sizeof(pathname));
482 while ((s = strchr(pathname, '/')))
485 ret = snprintf(buf, len, "%s", pathname);
487 return -ENAMETOOLONG;
492 static int rnbd_clt_add_dev_symlink(struct rnbd_clt_dev *dev)
494 struct kobject *gd_kobj = &disk_to_dev(dev->gd)->kobj;
497 len = strlen(dev->pathname) + strlen(dev->sess->sessname) + 2;
498 dev->blk_symlink_name = kzalloc(len, GFP_KERNEL);
499 if (!dev->blk_symlink_name) {
500 rnbd_clt_err(dev, "Failed to allocate memory for blk_symlink_name\n");
504 ret = rnbd_clt_get_path_name(dev, dev->blk_symlink_name,
507 rnbd_clt_err(dev, "Failed to get /sys/block symlink path, err: %d\n",
512 ret = sysfs_create_link(rnbd_devs_kobj, gd_kobj,
513 dev->blk_symlink_name);
515 rnbd_clt_err(dev, "Creating /sys/block symlink failed, err: %d\n",
523 kfree(dev->blk_symlink_name);
524 dev->blk_symlink_name = NULL ;
528 static ssize_t rnbd_clt_map_device_store(struct kobject *kobj,
529 struct kobj_attribute *attr,
530 const char *buf, size_t count)
532 struct rnbd_clt_dev *dev;
533 struct rnbd_map_options opt;
535 char pathname[NAME_MAX];
536 char sessname[NAME_MAX];
537 enum rnbd_access_mode access_mode = RNBD_ACCESS_RW;
538 u16 port_nr = RTRS_PORT;
540 struct sockaddr_storage *addrs;
541 struct rtrs_addr paths[6];
544 opt.sessname = sessname;
546 opt.path_cnt = &path_cnt;
547 opt.pathname = pathname;
548 opt.dest_port = &port_nr;
549 opt.access_mode = &access_mode;
550 addrs = kcalloc(ARRAY_SIZE(paths) * 2, sizeof(*addrs), GFP_KERNEL);
554 for (path_cnt = 0; path_cnt < ARRAY_SIZE(paths); path_cnt++) {
555 paths[path_cnt].src = &addrs[path_cnt * 2];
556 paths[path_cnt].dst = &addrs[path_cnt * 2 + 1];
559 ret = rnbd_clt_parse_map_options(buf, ARRAY_SIZE(paths), &opt);
563 pr_info("Mapping device %s on session %s, (access_mode: %s)\n",
565 rnbd_access_mode_str(access_mode));
567 dev = rnbd_clt_map_device(sessname, paths, path_cnt, port_nr, pathname,
574 ret = rnbd_clt_add_dev_kobj(dev);
578 ret = rnbd_clt_add_dev_symlink(dev);
586 rnbd_clt_unmap_device(dev, true, NULL);
592 static struct kobj_attribute rnbd_clt_map_device_attr =
593 __ATTR(map_device, 0644,
594 rnbd_clt_map_device_show, rnbd_clt_map_device_store);
596 static struct attribute *default_attrs[] = {
597 &rnbd_clt_map_device_attr.attr,
601 static struct attribute_group default_attr_group = {
602 .attrs = default_attrs,
605 static const struct attribute_group *default_attr_groups[] = {
610 int rnbd_clt_create_sysfs_files(void)
614 rnbd_dev_class = class_create(THIS_MODULE, "rnbd-client");
615 if (IS_ERR(rnbd_dev_class))
616 return PTR_ERR(rnbd_dev_class);
618 rnbd_dev = device_create_with_groups(rnbd_dev_class, NULL,
620 default_attr_groups, "ctl");
621 if (IS_ERR(rnbd_dev)) {
622 err = PTR_ERR(rnbd_dev);
625 rnbd_devs_kobj = kobject_create_and_add("devices", &rnbd_dev->kobj);
626 if (!rnbd_devs_kobj) {
634 device_destroy(rnbd_dev_class, MKDEV(0, 0));
636 class_destroy(rnbd_dev_class);
641 void rnbd_clt_destroy_default_group(void)
643 sysfs_remove_group(&rnbd_dev->kobj, &default_attr_group);
646 void rnbd_clt_destroy_sysfs_files(void)
648 kobject_del(rnbd_devs_kobj);
649 kobject_put(rnbd_devs_kobj);
650 device_destroy(rnbd_dev_class, MKDEV(0, 0));
651 class_destroy(rnbd_dev_class);