drivers/block/rnbd/rnbd-clt-sysfs.c

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