1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * RDMA Network Block Driver 4 * 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. 8 */ 9 10 #undef pr_fmt 11 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt 12 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> 18 #include <linux/fs.h> 19 #include <linux/uaccess.h> 20 #include <linux/device.h> 21 #include <rdma/ib.h> 22 #include <rdma/rdma_cm.h> 23 24 #include "rnbd-clt.h" 25 26 static struct device *rnbd_dev; 27 static const struct class rnbd_dev_class = { 28 .name = "rnbd-client", 29 }; 30 static struct kobject *rnbd_devs_kobj; 31 32 enum { 33 RNBD_OPT_ERR = 0, 34 RNBD_OPT_DEST_PORT = 1 << 0, 35 RNBD_OPT_PATH = 1 << 1, 36 RNBD_OPT_DEV_PATH = 1 << 2, 37 RNBD_OPT_ACCESS_MODE = 1 << 3, 38 RNBD_OPT_SESSNAME = 1 << 6, 39 RNBD_OPT_NR_POLL_QUEUES = 1 << 7, 40 }; 41 42 static const unsigned int rnbd_opt_mandatory[] = { 43 RNBD_OPT_DEV_PATH, 44 RNBD_OPT_SESSNAME, 45 }; 46 47 static const match_table_t rnbd_opt_tokens = { 48 {RNBD_OPT_PATH, "path=%s" }, 49 {RNBD_OPT_DEV_PATH, "device_path=%s" }, 50 {RNBD_OPT_DEST_PORT, "dest_port=%d" }, 51 {RNBD_OPT_ACCESS_MODE, "access_mode=%s" }, 52 {RNBD_OPT_SESSNAME, "sessname=%s" }, 53 {RNBD_OPT_NR_POLL_QUEUES, "nr_poll_queues=%d" }, 54 {RNBD_OPT_ERR, NULL }, 55 }; 56 57 struct rnbd_map_options { 58 char *sessname; 59 struct rtrs_addr *paths; 60 size_t *path_cnt; 61 char *pathname; 62 u16 *dest_port; 63 enum rnbd_access_mode *access_mode; 64 u32 *nr_poll_queues; 65 }; 66 67 static int rnbd_clt_parse_map_options(const char *buf, size_t max_path_cnt, 68 struct rnbd_map_options *opt) 69 { 70 char *options, *sep_opt; 71 char *p; 72 substring_t args[MAX_OPT_ARGS]; 73 int opt_mask = 0; 74 int token; 75 int ret = -EINVAL; 76 int nr_poll_queues = 0; 77 int dest_port = 0; 78 int p_cnt = 0; 79 int i; 80 81 options = kstrdup(buf, GFP_KERNEL); 82 if (!options) 83 return -ENOMEM; 84 85 sep_opt = strstrip(options); 86 while ((p = strsep(&sep_opt, " ")) != NULL) { 87 if (!*p) 88 continue; 89 90 token = match_token(p, rnbd_opt_tokens, args); 91 opt_mask |= token; 92 93 switch (token) { 94 case RNBD_OPT_SESSNAME: 95 p = match_strdup(args); 96 if (!p) { 97 ret = -ENOMEM; 98 goto out; 99 } 100 if (strlen(p) > NAME_MAX) { 101 pr_err("map_device: sessname too long\n"); 102 ret = -EINVAL; 103 kfree(p); 104 goto out; 105 } 106 strscpy(opt->sessname, p, NAME_MAX); 107 kfree(p); 108 break; 109 110 case RNBD_OPT_PATH: 111 if (p_cnt >= max_path_cnt) { 112 pr_err("map_device: too many (> %zu) paths provided\n", 113 max_path_cnt); 114 ret = -ENOMEM; 115 goto out; 116 } 117 p = match_strdup(args); 118 if (!p) { 119 ret = -ENOMEM; 120 goto out; 121 } 122 123 ret = rtrs_addr_to_sockaddr(p, strlen(p), 124 *opt->dest_port, 125 &opt->paths[p_cnt]); 126 if (ret) { 127 pr_err("Can't parse path %s: %d\n", p, ret); 128 kfree(p); 129 goto out; 130 } 131 132 p_cnt++; 133 134 kfree(p); 135 break; 136 137 case RNBD_OPT_DEV_PATH: 138 p = match_strdup(args); 139 if (!p) { 140 ret = -ENOMEM; 141 goto out; 142 } 143 if (strlen(p) > NAME_MAX) { 144 pr_err("map_device: Device path too long\n"); 145 ret = -EINVAL; 146 kfree(p); 147 goto out; 148 } 149 strscpy(opt->pathname, p, NAME_MAX); 150 kfree(p); 151 break; 152 153 case RNBD_OPT_DEST_PORT: 154 if (match_int(args, &dest_port) || dest_port < 0 || 155 dest_port > 65535) { 156 pr_err("bad destination port number parameter '%d'\n", 157 dest_port); 158 ret = -EINVAL; 159 goto out; 160 } 161 *opt->dest_port = dest_port; 162 break; 163 164 case RNBD_OPT_ACCESS_MODE: 165 p = match_strdup(args); 166 if (!p) { 167 ret = -ENOMEM; 168 goto out; 169 } 170 171 if (!strcmp(p, "ro")) { 172 *opt->access_mode = RNBD_ACCESS_RO; 173 } else if (!strcmp(p, "rw")) { 174 *opt->access_mode = RNBD_ACCESS_RW; 175 } else if (!strcmp(p, "migration")) { 176 *opt->access_mode = RNBD_ACCESS_MIGRATION; 177 } else { 178 pr_err("map_device: Invalid access_mode: '%s'\n", 179 p); 180 ret = -EINVAL; 181 kfree(p); 182 goto out; 183 } 184 185 kfree(p); 186 break; 187 188 case RNBD_OPT_NR_POLL_QUEUES: 189 if (match_int(args, &nr_poll_queues) || nr_poll_queues < -1 || 190 nr_poll_queues > (int)nr_cpu_ids) { 191 pr_err("bad nr_poll_queues parameter '%d'\n", 192 nr_poll_queues); 193 ret = -EINVAL; 194 goto out; 195 } 196 if (nr_poll_queues == -1) 197 nr_poll_queues = nr_cpu_ids; 198 *opt->nr_poll_queues = nr_poll_queues; 199 break; 200 201 default: 202 pr_err("map_device: Unknown parameter or missing value '%s'\n", 203 p); 204 ret = -EINVAL; 205 goto out; 206 } 207 } 208 209 for (i = 0; i < ARRAY_SIZE(rnbd_opt_mandatory); i++) { 210 if ((opt_mask & rnbd_opt_mandatory[i])) { 211 ret = 0; 212 } else { 213 pr_err("map_device: Parameters missing\n"); 214 ret = -EINVAL; 215 break; 216 } 217 } 218 219 out: 220 *opt->path_cnt = p_cnt; 221 kfree(options); 222 return ret; 223 } 224 225 static ssize_t state_show(struct kobject *kobj, 226 struct kobj_attribute *attr, char *page) 227 { 228 struct rnbd_clt_dev *dev; 229 230 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 231 232 switch (dev->dev_state) { 233 case DEV_STATE_INIT: 234 return sysfs_emit(page, "init\n"); 235 case DEV_STATE_MAPPED: 236 /* TODO fix cli tool before changing to proper state */ 237 return sysfs_emit(page, "open\n"); 238 case DEV_STATE_MAPPED_DISCONNECTED: 239 /* TODO fix cli tool before changing to proper state */ 240 return sysfs_emit(page, "closed\n"); 241 case DEV_STATE_UNMAPPED: 242 return sysfs_emit(page, "unmapped\n"); 243 default: 244 return sysfs_emit(page, "unknown\n"); 245 } 246 } 247 248 static struct kobj_attribute rnbd_clt_state_attr = __ATTR_RO(state); 249 250 static ssize_t nr_poll_queues_show(struct kobject *kobj, 251 struct kobj_attribute *attr, char *page) 252 { 253 struct rnbd_clt_dev *dev; 254 255 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 256 257 return sysfs_emit(page, "%d\n", dev->nr_poll_queues); 258 } 259 260 static struct kobj_attribute rnbd_clt_nr_poll_queues = 261 __ATTR_RO(nr_poll_queues); 262 263 static ssize_t mapping_path_show(struct kobject *kobj, 264 struct kobj_attribute *attr, char *page) 265 { 266 struct rnbd_clt_dev *dev; 267 268 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 269 270 return sysfs_emit(page, "%s\n", dev->pathname); 271 } 272 273 static struct kobj_attribute rnbd_clt_mapping_path_attr = 274 __ATTR_RO(mapping_path); 275 276 static ssize_t access_mode_show(struct kobject *kobj, 277 struct kobj_attribute *attr, char *page) 278 { 279 struct rnbd_clt_dev *dev; 280 281 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 282 283 return sysfs_emit(page, "%s\n", rnbd_access_modes[dev->access_mode].str); 284 } 285 286 static struct kobj_attribute rnbd_clt_access_mode = 287 __ATTR_RO(access_mode); 288 289 static ssize_t rnbd_clt_unmap_dev_show(struct kobject *kobj, 290 struct kobj_attribute *attr, char *page) 291 { 292 return sysfs_emit(page, "Usage: echo <normal|force> > %s\n", 293 attr->attr.name); 294 } 295 296 static ssize_t rnbd_clt_unmap_dev_store(struct kobject *kobj, 297 struct kobj_attribute *attr, 298 const char *buf, size_t count) 299 { 300 struct rnbd_clt_dev *dev; 301 char *opt, *options; 302 bool force; 303 int err; 304 305 opt = kstrdup(buf, GFP_KERNEL); 306 if (!opt) 307 return -ENOMEM; 308 309 options = strstrip(opt); 310 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 311 if (sysfs_streq(options, "normal")) { 312 force = false; 313 } else if (sysfs_streq(options, "force")) { 314 force = true; 315 } else { 316 rnbd_clt_err(dev, 317 "unmap_device: Invalid value: %s\n", 318 options); 319 err = -EINVAL; 320 goto out; 321 } 322 323 rnbd_clt_info(dev, "Unmapping device, option: %s.\n", 324 force ? "force" : "normal"); 325 326 /* 327 * We take explicit module reference only for one reason: do not 328 * race with lockless rnbd_destroy_sessions(). 329 */ 330 if (!try_module_get(THIS_MODULE)) { 331 err = -ENODEV; 332 goto out; 333 } 334 err = rnbd_clt_unmap_device(dev, force, &attr->attr); 335 if (err) { 336 if (err != -EALREADY) 337 rnbd_clt_err(dev, "unmap_device: %d\n", err); 338 goto module_put; 339 } 340 341 /* 342 * Here device can be vanished! 343 */ 344 345 err = count; 346 347 module_put: 348 module_put(THIS_MODULE); 349 out: 350 kfree(opt); 351 352 return err; 353 } 354 355 static struct kobj_attribute rnbd_clt_unmap_device_attr = 356 __ATTR(unmap_device, 0644, rnbd_clt_unmap_dev_show, 357 rnbd_clt_unmap_dev_store); 358 359 static ssize_t rnbd_clt_resize_dev_show(struct kobject *kobj, 360 struct kobj_attribute *attr, 361 char *page) 362 { 363 return sysfs_emit(page, "Usage: echo <new size in sectors> > %s\n", 364 attr->attr.name); 365 } 366 367 static ssize_t rnbd_clt_resize_dev_store(struct kobject *kobj, 368 struct kobj_attribute *attr, 369 const char *buf, size_t count) 370 { 371 int ret; 372 unsigned long sectors; 373 struct rnbd_clt_dev *dev; 374 375 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 376 377 ret = kstrtoul(buf, 0, §ors); 378 if (ret) 379 return ret; 380 381 ret = rnbd_clt_resize_disk(dev, sectors); 382 if (ret) 383 return ret; 384 385 return count; 386 } 387 388 static struct kobj_attribute rnbd_clt_resize_dev_attr = 389 __ATTR(resize, 0644, rnbd_clt_resize_dev_show, 390 rnbd_clt_resize_dev_store); 391 392 static ssize_t rnbd_clt_remap_dev_show(struct kobject *kobj, 393 struct kobj_attribute *attr, char *page) 394 { 395 return sysfs_emit(page, "Usage: echo <1> > %s\n", attr->attr.name); 396 } 397 398 static ssize_t rnbd_clt_remap_dev_store(struct kobject *kobj, 399 struct kobj_attribute *attr, 400 const char *buf, size_t count) 401 { 402 struct rnbd_clt_dev *dev; 403 char *opt, *options; 404 int err; 405 406 opt = kstrdup(buf, GFP_KERNEL); 407 if (!opt) 408 return -ENOMEM; 409 410 options = strstrip(opt); 411 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 412 if (!sysfs_streq(options, "1")) { 413 rnbd_clt_err(dev, 414 "remap_device: Invalid value: %s\n", 415 options); 416 err = -EINVAL; 417 goto out; 418 } 419 err = rnbd_clt_remap_device(dev); 420 if (likely(!err)) 421 err = count; 422 423 out: 424 kfree(opt); 425 426 return err; 427 } 428 429 static struct kobj_attribute rnbd_clt_remap_device_attr = 430 __ATTR(remap_device, 0644, rnbd_clt_remap_dev_show, 431 rnbd_clt_remap_dev_store); 432 433 static ssize_t session_show(struct kobject *kobj, struct kobj_attribute *attr, 434 char *page) 435 { 436 struct rnbd_clt_dev *dev; 437 438 dev = container_of(kobj, struct rnbd_clt_dev, kobj); 439 440 return sysfs_emit(page, "%s\n", dev->sess->sessname); 441 } 442 443 static struct kobj_attribute rnbd_clt_session_attr = 444 __ATTR_RO(session); 445 446 static struct attribute *rnbd_dev_attrs[] = { 447 &rnbd_clt_unmap_device_attr.attr, 448 &rnbd_clt_resize_dev_attr.attr, 449 &rnbd_clt_remap_device_attr.attr, 450 &rnbd_clt_mapping_path_attr.attr, 451 &rnbd_clt_state_attr.attr, 452 &rnbd_clt_session_attr.attr, 453 &rnbd_clt_access_mode.attr, 454 &rnbd_clt_nr_poll_queues.attr, 455 NULL, 456 }; 457 ATTRIBUTE_GROUPS(rnbd_dev); 458 459 void rnbd_clt_remove_dev_symlink(struct rnbd_clt_dev *dev) 460 { 461 /* 462 * The module unload rnbd_client_exit path is racing with unmapping of 463 * the last single device from the sysfs manually 464 * i.e. rnbd_clt_unmap_dev_store() leading to a sysfs warning because 465 * of sysfs link already was removed already. 466 */ 467 if (dev->blk_symlink_name) { 468 if (try_module_get(THIS_MODULE)) { 469 sysfs_remove_link(rnbd_devs_kobj, dev->blk_symlink_name); 470 module_put(THIS_MODULE); 471 } 472 /* It should be freed always. */ 473 kfree(dev->blk_symlink_name); 474 dev->blk_symlink_name = NULL; 475 } 476 } 477 478 static const struct kobj_type rnbd_dev_ktype = { 479 .sysfs_ops = &kobj_sysfs_ops, 480 .default_groups = rnbd_dev_groups, 481 }; 482 483 static int rnbd_clt_add_dev_kobj(struct rnbd_clt_dev *dev) 484 { 485 int ret; 486 struct kobject *gd_kobj = &disk_to_dev(dev->gd)->kobj; 487 488 ret = kobject_init_and_add(&dev->kobj, &rnbd_dev_ktype, gd_kobj, "%s", 489 "rnbd"); 490 if (ret) { 491 rnbd_clt_err(dev, "Failed to create device sysfs dir, err: %d\n", 492 ret); 493 kobject_put(&dev->kobj); 494 } 495 kobject_uevent(gd_kobj, KOBJ_ONLINE); 496 497 return ret; 498 } 499 500 static ssize_t rnbd_clt_map_device_show(struct kobject *kobj, 501 struct kobj_attribute *attr, 502 char *page) 503 { 504 return sysfs_emit(page, 505 "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>] [nr_poll_queues=<number of queues>]\" > %s\n\naddr ::= [ ip:<ipv4> | ip:<ipv6> | gid:<gid> ]\n", 506 attr->attr.name); 507 } 508 509 static int rnbd_clt_get_path_name(struct rnbd_clt_dev *dev, char *buf, 510 size_t len) 511 { 512 int ret; 513 char pathname[NAME_MAX], *s; 514 515 strscpy(pathname, dev->pathname, sizeof(pathname)); 516 while ((s = strchr(pathname, '/'))) 517 s[0] = '!'; 518 519 ret = snprintf(buf, len, "%s@%s", pathname, dev->sess->sessname); 520 if (ret >= len) 521 return -ENAMETOOLONG; 522 523 return 0; 524 } 525 526 static int rnbd_clt_add_dev_symlink(struct rnbd_clt_dev *dev) 527 { 528 struct kobject *gd_kobj = &disk_to_dev(dev->gd)->kobj; 529 int ret, len; 530 531 len = strlen(dev->pathname) + strlen(dev->sess->sessname) + 2; 532 dev->blk_symlink_name = kzalloc(len, GFP_KERNEL); 533 if (!dev->blk_symlink_name) { 534 rnbd_clt_err(dev, "Failed to allocate memory for blk_symlink_name\n"); 535 return -ENOMEM; 536 } 537 538 ret = rnbd_clt_get_path_name(dev, dev->blk_symlink_name, 539 len); 540 if (ret) { 541 rnbd_clt_err(dev, "Failed to get /sys/block symlink path, err: %d\n", 542 ret); 543 goto out_err; 544 } 545 546 ret = sysfs_create_link(rnbd_devs_kobj, gd_kobj, 547 dev->blk_symlink_name); 548 if (ret) { 549 rnbd_clt_err(dev, "Creating /sys/block symlink failed, err: %d\n", 550 ret); 551 goto out_err; 552 } 553 554 return 0; 555 556 out_err: 557 kfree(dev->blk_symlink_name); 558 dev->blk_symlink_name = NULL ; 559 return ret; 560 } 561 562 static ssize_t rnbd_clt_map_device_store(struct kobject *kobj, 563 struct kobj_attribute *attr, 564 const char *buf, size_t count) 565 { 566 struct rnbd_clt_dev *dev; 567 struct rnbd_map_options opt; 568 int ret; 569 char pathname[NAME_MAX]; 570 char sessname[NAME_MAX]; 571 enum rnbd_access_mode access_mode = RNBD_ACCESS_RW; 572 u16 port_nr = RTRS_PORT; 573 u32 nr_poll_queues = 0; 574 575 struct sockaddr_storage *addrs; 576 struct rtrs_addr paths[6]; 577 size_t path_cnt; 578 579 opt.sessname = sessname; 580 opt.paths = paths; 581 opt.path_cnt = &path_cnt; 582 opt.pathname = pathname; 583 opt.dest_port = &port_nr; 584 opt.access_mode = &access_mode; 585 opt.nr_poll_queues = &nr_poll_queues; 586 addrs = kcalloc(ARRAY_SIZE(paths) * 2, sizeof(*addrs), GFP_KERNEL); 587 if (!addrs) 588 return -ENOMEM; 589 590 for (path_cnt = 0; path_cnt < ARRAY_SIZE(paths); path_cnt++) { 591 paths[path_cnt].src = &addrs[path_cnt * 2]; 592 paths[path_cnt].dst = &addrs[path_cnt * 2 + 1]; 593 } 594 595 ret = rnbd_clt_parse_map_options(buf, ARRAY_SIZE(paths), &opt); 596 if (ret) 597 goto out; 598 599 pr_info("Mapping device %s on session %s, (access_mode: %s, nr_poll_queues: %d)\n", 600 pathname, sessname, 601 rnbd_access_modes[access_mode].str, 602 nr_poll_queues); 603 604 dev = rnbd_clt_map_device(sessname, paths, path_cnt, port_nr, pathname, 605 access_mode, nr_poll_queues); 606 if (IS_ERR(dev)) { 607 ret = PTR_ERR(dev); 608 goto out; 609 } 610 611 ret = rnbd_clt_add_dev_kobj(dev); 612 if (ret) 613 goto unmap_dev; 614 615 ret = rnbd_clt_add_dev_symlink(dev); 616 if (ret) 617 goto unmap_dev; 618 619 kfree(addrs); 620 return count; 621 622 unmap_dev: 623 rnbd_clt_unmap_device(dev, true, NULL); 624 out: 625 kfree(addrs); 626 return ret; 627 } 628 629 static struct kobj_attribute rnbd_clt_map_device_attr = 630 __ATTR(map_device, 0644, 631 rnbd_clt_map_device_show, rnbd_clt_map_device_store); 632 633 static struct attribute *default_attrs[] = { 634 &rnbd_clt_map_device_attr.attr, 635 NULL, 636 }; 637 638 static struct attribute_group default_attr_group = { 639 .attrs = default_attrs, 640 }; 641 642 static const struct attribute_group *default_attr_groups[] = { 643 &default_attr_group, 644 NULL, 645 }; 646 647 int rnbd_clt_create_sysfs_files(void) 648 { 649 int err; 650 651 err = class_register(&rnbd_dev_class); 652 if (err) 653 return err; 654 655 rnbd_dev = device_create_with_groups(&rnbd_dev_class, NULL, 656 MKDEV(0, 0), NULL, 657 default_attr_groups, "ctl"); 658 if (IS_ERR(rnbd_dev)) { 659 err = PTR_ERR(rnbd_dev); 660 goto cls_destroy; 661 } 662 rnbd_devs_kobj = kobject_create_and_add("devices", &rnbd_dev->kobj); 663 if (!rnbd_devs_kobj) { 664 err = -ENOMEM; 665 goto dev_destroy; 666 } 667 668 return 0; 669 670 dev_destroy: 671 device_destroy(&rnbd_dev_class, MKDEV(0, 0)); 672 cls_destroy: 673 class_unregister(&rnbd_dev_class); 674 675 return err; 676 } 677 678 void rnbd_clt_destroy_sysfs_files(void) 679 { 680 sysfs_remove_group(&rnbd_dev->kobj, &default_attr_group); 681 kobject_del(rnbd_devs_kobj); 682 kobject_put(rnbd_devs_kobj); 683 device_destroy(&rnbd_dev_class, MKDEV(0, 0)); 684 class_unregister(&rnbd_dev_class); 685 } 686