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 }
684