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#undef pr_fmt
10#define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
11
12#include <linux/module.h>
13#include <linux/blkdev.h>
14
15#include "rnbd-srv.h"
16#include "rnbd-srv-trace.h"
17
18MODULE_DESCRIPTION("RDMA Network Block Device Server");
19MODULE_LICENSE("GPL");
20
21static u16 port_nr = RTRS_PORT;
22
23module_param_named(port_nr, port_nr, ushort, 0444);
24MODULE_PARM_DESC(port_nr,
25 "The port number the server is listening on (default: "
26 __stringify(RTRS_PORT)")");
27
28#define DEFAULT_DEV_SEARCH_PATH "/"
29
30static char dev_search_path[PATH_MAX] = DEFAULT_DEV_SEARCH_PATH;
31
32static int dev_search_path_set(const char *val, const struct kernel_param *kp)
33{
34 const char *p = strrchr(val, '\n') ? : val + strlen(val);
35
36 if (strlen(val) >= sizeof(dev_search_path))
37 return -EINVAL;
38
39 snprintf(buf: dev_search_path, size: sizeof(dev_search_path), fmt: "%.*s",
40 (int)(p - val), val);
41
42 pr_info("dev_search_path changed to '%s'\n", dev_search_path);
43
44 return 0;
45}
46
47static struct kparam_string dev_search_path_kparam_str = {
48 .maxlen = sizeof(dev_search_path),
49 .string = dev_search_path
50};
51
52static const struct kernel_param_ops dev_search_path_ops = {
53 .set = dev_search_path_set,
54 .get = param_get_string,
55};
56
57module_param_cb(dev_search_path, &dev_search_path_ops,
58 &dev_search_path_kparam_str, 0444);
59MODULE_PARM_DESC(dev_search_path,
60 "Sets the dev_search_path. When a device is mapped this path is prepended to the device path from the map device operation. If %SESSNAME% is specified in a path, then device will be searched in a session namespace. (default: "
61 DEFAULT_DEV_SEARCH_PATH ")");
62
63static DEFINE_MUTEX(sess_lock);
64static DEFINE_SPINLOCK(dev_lock);
65
66static LIST_HEAD(sess_list);
67static LIST_HEAD(dev_list);
68
69struct rnbd_io_private {
70 struct rtrs_srv_op *id;
71 struct rnbd_srv_sess_dev *sess_dev;
72};
73
74static void rnbd_sess_dev_release(struct kref *kref)
75{
76 struct rnbd_srv_sess_dev *sess_dev;
77
78 sess_dev = container_of(kref, struct rnbd_srv_sess_dev, kref);
79 complete(sess_dev->destroy_comp);
80}
81
82static inline void rnbd_put_sess_dev(struct rnbd_srv_sess_dev *sess_dev)
83{
84 kref_put(kref: &sess_dev->kref, release: rnbd_sess_dev_release);
85}
86
87static struct rnbd_srv_sess_dev *
88rnbd_get_sess_dev(int dev_id, struct rnbd_srv_session *srv_sess)
89{
90 struct rnbd_srv_sess_dev *sess_dev;
91 int ret = 0;
92
93 rcu_read_lock();
94 sess_dev = xa_load(&srv_sess->index_idr, index: dev_id);
95 if (sess_dev)
96 ret = kref_get_unless_zero(kref: &sess_dev->kref);
97 rcu_read_unlock();
98
99 if (!ret)
100 return ERR_PTR(error: -ENXIO);
101
102 return sess_dev;
103}
104
105static void rnbd_dev_bi_end_io(struct bio *bio)
106{
107 struct rnbd_io_private *rnbd_priv = bio->bi_private;
108 struct rnbd_srv_sess_dev *sess_dev = rnbd_priv->sess_dev;
109
110 rnbd_put_sess_dev(sess_dev);
111 rtrs_srv_resp_rdma(id: rnbd_priv->id, errno: blk_status_to_errno(status: bio->bi_status));
112
113 kfree(objp: rnbd_priv);
114 bio_put(bio);
115}
116
117static int process_rdma(struct rnbd_srv_session *srv_sess,
118 struct rtrs_srv_op *id, void *data, u32 datalen,
119 const void *usr, size_t usrlen)
120{
121 const struct rnbd_msg_io *msg = usr;
122 struct rnbd_io_private *priv;
123 struct rnbd_srv_sess_dev *sess_dev;
124 u32 dev_id;
125 int err;
126 struct bio *bio;
127 short prio;
128
129 trace_process_rdma(srv: srv_sess, msg, id, datalen, usrlen);
130
131 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
132 if (!priv)
133 return -ENOMEM;
134
135 dev_id = le32_to_cpu(msg->device_id);
136
137 sess_dev = rnbd_get_sess_dev(dev_id, srv_sess);
138 if (IS_ERR(ptr: sess_dev)) {
139 pr_err_ratelimited("Got I/O request on session %s for unknown device id %d: %pe\n",
140 srv_sess->sessname, dev_id, sess_dev);
141 err = -ENOTCONN;
142 goto err;
143 }
144
145 priv->sess_dev = sess_dev;
146 priv->id = id;
147
148 bio = bio_alloc(bdev: file_bdev(bdev_file: sess_dev->bdev_file), nr_vecs: 1,
149 opf: rnbd_to_bio_flags(le32_to_cpu(msg->rw)), GFP_KERNEL);
150 bio_add_virt_nofail(bio, vaddr: data, len: datalen);
151
152 bio->bi_opf = rnbd_to_bio_flags(le32_to_cpu(msg->rw));
153 if (bio_has_data(bio) &&
154 bio->bi_iter.bi_size != le32_to_cpu(msg->bi_size)) {
155 rnbd_srv_err_rl(sess_dev, "Datalen mismatch: bio bi_size (%u), bi_size (%u)\n",
156 bio->bi_iter.bi_size, msg->bi_size);
157 err = -EINVAL;
158 goto bio_put;
159 }
160 bio->bi_end_io = rnbd_dev_bi_end_io;
161 bio->bi_private = priv;
162 bio->bi_iter.bi_sector = le64_to_cpu(msg->sector);
163 prio = srv_sess->ver < RNBD_PROTO_VER_MAJOR ||
164 usrlen < sizeof(*msg) ? 0 : le16_to_cpu(msg->prio);
165 bio->bi_ioprio = prio;
166
167 submit_bio(bio);
168
169 return 0;
170
171bio_put:
172 bio_put(bio);
173 rnbd_put_sess_dev(sess_dev);
174err:
175 kfree(objp: priv);
176 return err;
177}
178
179static void destroy_device(struct kref *kref)
180{
181 struct rnbd_srv_dev *dev = container_of(kref, struct rnbd_srv_dev, kref);
182
183 WARN_ONCE(!list_empty(&dev->sess_dev_list),
184 "Device %s is being destroyed but still in use!\n",
185 dev->name);
186
187 spin_lock(lock: &dev_lock);
188 list_del(entry: &dev->list);
189 spin_unlock(lock: &dev_lock);
190
191 mutex_destroy(lock: &dev->lock);
192 if (dev->dev_kobj.state_in_sysfs)
193 /*
194 * Destroy kobj only if it was really created.
195 */
196 rnbd_srv_destroy_dev_sysfs(dev);
197 else
198 kfree(objp: dev);
199}
200
201static void rnbd_put_srv_dev(struct rnbd_srv_dev *dev)
202{
203 kref_put(kref: &dev->kref, release: destroy_device);
204}
205
206void rnbd_destroy_sess_dev(struct rnbd_srv_sess_dev *sess_dev, bool keep_id)
207{
208 DECLARE_COMPLETION_ONSTACK(dc);
209
210 if (keep_id)
211 /* free the resources for the id but don't */
212 /* allow to re-use the id itself because it */
213 /* is still used by the client */
214 xa_cmpxchg(xa: &sess_dev->sess->index_idr, index: sess_dev->device_id,
215 old: sess_dev, NULL, gfp: 0);
216 else
217 xa_erase(&sess_dev->sess->index_idr, index: sess_dev->device_id);
218 synchronize_rcu();
219
220 sess_dev->destroy_comp = &dc;
221 rnbd_put_sess_dev(sess_dev);
222 wait_for_completion(&dc); /* wait for inflights to drop to zero */
223
224 fput(sess_dev->bdev_file);
225 mutex_lock(&sess_dev->dev->lock);
226 list_del(entry: &sess_dev->dev_list);
227 if (!sess_dev->readonly)
228 sess_dev->dev->open_write_cnt--;
229 mutex_unlock(lock: &sess_dev->dev->lock);
230
231 rnbd_put_srv_dev(dev: sess_dev->dev);
232
233 rnbd_srv_info(sess_dev, "Device closed\n");
234 kfree(objp: sess_dev);
235}
236
237static void destroy_sess(struct rnbd_srv_session *srv_sess)
238{
239 struct rnbd_srv_sess_dev *sess_dev;
240 unsigned long index;
241
242 if (xa_empty(xa: &srv_sess->index_idr))
243 goto out;
244
245 trace_destroy_sess(srv: srv_sess);
246
247 mutex_lock(&srv_sess->lock);
248 xa_for_each(&srv_sess->index_idr, index, sess_dev)
249 rnbd_srv_destroy_dev_session_sysfs(sess_dev);
250 mutex_unlock(lock: &srv_sess->lock);
251
252out:
253 xa_destroy(&srv_sess->index_idr);
254
255 pr_info("RTRS Session %s disconnected\n", srv_sess->sessname);
256
257 mutex_lock(&sess_lock);
258 list_del(entry: &srv_sess->list);
259 mutex_unlock(lock: &sess_lock);
260
261 mutex_destroy(lock: &srv_sess->lock);
262 kfree(objp: srv_sess);
263}
264
265static int create_sess(struct rtrs_srv_sess *rtrs)
266{
267 struct rnbd_srv_session *srv_sess;
268 char pathname[NAME_MAX];
269 int err;
270
271 err = rtrs_srv_get_path_name(sess: rtrs, pathname, len: sizeof(pathname));
272 if (err) {
273 pr_err("rtrs_srv_get_path_name(%s): %d\n", pathname, err);
274
275 return err;
276 }
277 srv_sess = kzalloc(sizeof(*srv_sess), GFP_KERNEL);
278 if (!srv_sess)
279 return -ENOMEM;
280
281 srv_sess->queue_depth = rtrs_srv_get_queue_depth(sess: rtrs);
282 xa_init_flags(xa: &srv_sess->index_idr, XA_FLAGS_ALLOC);
283 mutex_init(&srv_sess->lock);
284 mutex_lock(&sess_lock);
285 list_add(new: &srv_sess->list, head: &sess_list);
286 mutex_unlock(lock: &sess_lock);
287
288 srv_sess->rtrs = rtrs;
289 strscpy(srv_sess->sessname, pathname, sizeof(srv_sess->sessname));
290
291 rtrs_srv_set_sess_priv(sess: rtrs, priv: srv_sess);
292
293 trace_create_sess(srv: srv_sess);
294
295 return 0;
296}
297
298static int rnbd_srv_link_ev(struct rtrs_srv_sess *rtrs,
299 enum rtrs_srv_link_ev ev, void *priv)
300{
301 struct rnbd_srv_session *srv_sess = priv;
302
303 switch (ev) {
304 case RTRS_SRV_LINK_EV_CONNECTED:
305 return create_sess(rtrs);
306
307 case RTRS_SRV_LINK_EV_DISCONNECTED:
308 if (WARN_ON_ONCE(!srv_sess))
309 return -EINVAL;
310
311 destroy_sess(srv_sess);
312 return 0;
313
314 default:
315 pr_warn("Received unknown RTRS session event %d from session %s\n",
316 ev, srv_sess->sessname);
317 return -EINVAL;
318 }
319}
320
321void rnbd_srv_sess_dev_force_close(struct rnbd_srv_sess_dev *sess_dev,
322 struct kobj_attribute *attr)
323{
324 struct rnbd_srv_session *sess = sess_dev->sess;
325
326 /* It is already started to close by client's close message. */
327 if (!mutex_trylock(&sess->lock))
328 return;
329
330 sess_dev->keep_id = true;
331 /* first remove sysfs itself to avoid deadlock */
332 sysfs_remove_file_self(kobj: &sess_dev->kobj, attr: &attr->attr);
333 rnbd_srv_destroy_dev_session_sysfs(sess_dev);
334 mutex_unlock(lock: &sess->lock);
335}
336
337static void process_msg_close(struct rnbd_srv_session *srv_sess,
338 void *data, size_t datalen, const void *usr,
339 size_t usrlen)
340{
341 const struct rnbd_msg_close *close_msg = usr;
342 struct rnbd_srv_sess_dev *sess_dev;
343
344 trace_process_msg_close(srv: srv_sess, msg: close_msg);
345
346 sess_dev = rnbd_get_sess_dev(le32_to_cpu(close_msg->device_id),
347 srv_sess);
348 if (IS_ERR(ptr: sess_dev))
349 return;
350
351 rnbd_put_sess_dev(sess_dev);
352 mutex_lock(&srv_sess->lock);
353 rnbd_srv_destroy_dev_session_sysfs(sess_dev);
354 mutex_unlock(lock: &srv_sess->lock);
355}
356
357static int process_msg_open(struct rnbd_srv_session *srv_sess,
358 const void *msg, size_t len,
359 void *data, size_t datalen);
360
361static void process_msg_sess_info(struct rnbd_srv_session *srv_sess,
362 const void *msg, size_t len,
363 void *data, size_t datalen);
364
365static int rnbd_srv_rdma_ev(void *priv, struct rtrs_srv_op *id,
366 void *data, size_t datalen,
367 const void *usr, size_t usrlen)
368{
369 struct rnbd_srv_session *srv_sess = priv;
370 const struct rnbd_msg_hdr *hdr = usr;
371 int ret = 0;
372 u16 type;
373
374 if (WARN_ON_ONCE(!srv_sess))
375 return -ENODEV;
376
377 type = le16_to_cpu(hdr->type);
378
379 switch (type) {
380 case RNBD_MSG_IO:
381 return process_rdma(srv_sess, id, data, datalen, usr, usrlen);
382 case RNBD_MSG_CLOSE:
383 process_msg_close(srv_sess, data, datalen, usr, usrlen);
384 break;
385 case RNBD_MSG_OPEN:
386 ret = process_msg_open(srv_sess, msg: usr, len: usrlen, data, datalen);
387 break;
388 case RNBD_MSG_SESS_INFO:
389 process_msg_sess_info(srv_sess, msg: usr, len: usrlen, data, datalen);
390 break;
391 default:
392 pr_warn("Received unexpected message type %d from session %s\n",
393 type, srv_sess->sessname);
394 return -EINVAL;
395 }
396
397 /*
398 * Since ret is passed to rtrs to handle the failure case, we
399 * just return 0 at the end otherwise callers in rtrs would call
400 * send_io_resp_imm again to print redundant err message.
401 */
402 rtrs_srv_resp_rdma(id, errno: ret);
403 return 0;
404}
405
406static struct rnbd_srv_sess_dev
407*rnbd_sess_dev_alloc(struct rnbd_srv_session *srv_sess)
408{
409 struct rnbd_srv_sess_dev *sess_dev;
410 int error;
411
412 sess_dev = kzalloc(sizeof(*sess_dev), GFP_KERNEL);
413 if (!sess_dev)
414 return ERR_PTR(error: -ENOMEM);
415
416 error = xa_alloc(xa: &srv_sess->index_idr, id: &sess_dev->device_id, entry: sess_dev,
417 xa_limit_32b, GFP_NOWAIT);
418 if (error < 0) {
419 pr_warn("Allocating idr failed, err: %d\n", error);
420 kfree(objp: sess_dev);
421 return ERR_PTR(error);
422 }
423
424 return sess_dev;
425}
426
427static struct rnbd_srv_dev *rnbd_srv_init_srv_dev(struct block_device *bdev)
428{
429 struct rnbd_srv_dev *dev;
430
431 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
432 if (!dev)
433 return ERR_PTR(error: -ENOMEM);
434
435 snprintf(buf: dev->name, size: sizeof(dev->name), fmt: "%pg", bdev);
436 kref_init(kref: &dev->kref);
437 INIT_LIST_HEAD(list: &dev->sess_dev_list);
438 mutex_init(&dev->lock);
439
440 return dev;
441}
442
443static struct rnbd_srv_dev *
444rnbd_srv_find_or_add_srv_dev(struct rnbd_srv_dev *new_dev)
445{
446 struct rnbd_srv_dev *dev;
447
448 spin_lock(lock: &dev_lock);
449 list_for_each_entry(dev, &dev_list, list) {
450 if (!strncmp(dev->name, new_dev->name, sizeof(dev->name))) {
451 if (!kref_get_unless_zero(kref: &dev->kref))
452 /*
453 * We lost the race, device is almost dead.
454 * Continue traversing to find a valid one.
455 */
456 continue;
457 spin_unlock(lock: &dev_lock);
458 return dev;
459 }
460 }
461 list_add(new: &new_dev->list, head: &dev_list);
462 spin_unlock(lock: &dev_lock);
463
464 return new_dev;
465}
466
467static int rnbd_srv_check_update_open_perm(struct rnbd_srv_dev *srv_dev,
468 struct rnbd_srv_session *srv_sess,
469 enum rnbd_access_mode access_mode)
470{
471 int ret = 0;
472
473 mutex_lock(&srv_dev->lock);
474
475 switch (access_mode) {
476 case RNBD_ACCESS_RO:
477 break;
478 case RNBD_ACCESS_RW:
479 if (srv_dev->open_write_cnt == 0) {
480 srv_dev->open_write_cnt++;
481 } else {
482 pr_err("Mapping device '%s' for session %s with RW permissions failed. Device already opened as 'RW' by %d client(s), access mode %s.\n",
483 srv_dev->name, srv_sess->sessname,
484 srv_dev->open_write_cnt,
485 rnbd_access_modes[access_mode].str);
486 ret = -EPERM;
487 }
488 break;
489 case RNBD_ACCESS_MIGRATION:
490 if (srv_dev->open_write_cnt < 2) {
491 srv_dev->open_write_cnt++;
492 } else {
493 pr_err("Mapping device '%s' for session %s with migration permissions failed. Device already opened as 'RW' by %d client(s), access mode %s.\n",
494 srv_dev->name, srv_sess->sessname,
495 srv_dev->open_write_cnt,
496 rnbd_access_modes[access_mode].str);
497 ret = -EPERM;
498 }
499 break;
500 default:
501 pr_err("Received mapping request for device '%s' on session %s with invalid access mode: %d\n",
502 srv_dev->name, srv_sess->sessname, access_mode);
503 ret = -EINVAL;
504 }
505
506 mutex_unlock(lock: &srv_dev->lock);
507
508 return ret;
509}
510
511static struct rnbd_srv_dev *
512rnbd_srv_get_or_create_srv_dev(struct block_device *bdev,
513 struct rnbd_srv_session *srv_sess,
514 enum rnbd_access_mode access_mode)
515{
516 int ret;
517 struct rnbd_srv_dev *new_dev, *dev;
518
519 new_dev = rnbd_srv_init_srv_dev(bdev);
520 if (IS_ERR(ptr: new_dev))
521 return new_dev;
522
523 dev = rnbd_srv_find_or_add_srv_dev(new_dev);
524 if (dev != new_dev)
525 kfree(objp: new_dev);
526
527 ret = rnbd_srv_check_update_open_perm(srv_dev: dev, srv_sess, access_mode);
528 if (ret) {
529 rnbd_put_srv_dev(dev);
530 return ERR_PTR(error: ret);
531 }
532
533 return dev;
534}
535
536static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp,
537 struct rnbd_srv_sess_dev *sess_dev)
538{
539 struct block_device *bdev = file_bdev(bdev_file: sess_dev->bdev_file);
540
541 rsp->hdr.type = cpu_to_le16(RNBD_MSG_OPEN_RSP);
542 rsp->device_id = cpu_to_le32(sess_dev->device_id);
543 rsp->nsectors = cpu_to_le64(bdev_nr_sectors(bdev));
544 rsp->logical_block_size = cpu_to_le16(bdev_logical_block_size(bdev));
545 rsp->physical_block_size = cpu_to_le16(bdev_physical_block_size(bdev));
546 rsp->max_segments = cpu_to_le16(bdev_max_segments(bdev));
547 rsp->max_hw_sectors =
548 cpu_to_le32(queue_max_hw_sectors(bdev_get_queue(bdev)));
549 rsp->max_write_zeroes_sectors =
550 cpu_to_le32(bdev_write_zeroes_sectors(bdev));
551 rsp->max_discard_sectors = cpu_to_le32(bdev_max_discard_sectors(bdev));
552 rsp->discard_granularity = cpu_to_le32(bdev_discard_granularity(bdev));
553 rsp->discard_alignment = cpu_to_le32(bdev_discard_alignment(bdev));
554 rsp->secure_discard = cpu_to_le16(bdev_max_secure_erase_sectors(bdev));
555 rsp->cache_policy = 0;
556 if (bdev_write_cache(bdev))
557 rsp->cache_policy |= RNBD_WRITEBACK;
558 if (bdev_fua(bdev))
559 rsp->cache_policy |= RNBD_FUA;
560}
561
562static struct rnbd_srv_sess_dev *
563rnbd_srv_create_set_sess_dev(struct rnbd_srv_session *srv_sess,
564 const struct rnbd_msg_open *open_msg,
565 struct file *bdev_file, bool readonly,
566 struct rnbd_srv_dev *srv_dev)
567{
568 struct rnbd_srv_sess_dev *sdev = rnbd_sess_dev_alloc(srv_sess);
569
570 if (IS_ERR(ptr: sdev))
571 return sdev;
572
573 kref_init(kref: &sdev->kref);
574
575 strscpy(sdev->pathname, open_msg->dev_name, sizeof(sdev->pathname));
576
577 sdev->bdev_file = bdev_file;
578 sdev->sess = srv_sess;
579 sdev->dev = srv_dev;
580 sdev->readonly = readonly;
581 sdev->access_mode = open_msg->access_mode;
582
583 return sdev;
584}
585
586static char *rnbd_srv_get_full_path(struct rnbd_srv_session *srv_sess,
587 const char *dev_name)
588{
589 char *full_path;
590 char *a, *b;
591 int len;
592
593 full_path = kmalloc(PATH_MAX, GFP_KERNEL);
594 if (!full_path)
595 return ERR_PTR(error: -ENOMEM);
596
597 /*
598 * Replace %SESSNAME% with a real session name in order to
599 * create device namespace.
600 */
601 a = strnstr(dev_search_path, "%SESSNAME%", sizeof(dev_search_path));
602 if (a) {
603 len = a - dev_search_path;
604
605 len = snprintf(buf: full_path, PATH_MAX, fmt: "%.*s/%s/%s", len,
606 dev_search_path, srv_sess->sessname, dev_name);
607 } else {
608 len = snprintf(buf: full_path, PATH_MAX, fmt: "%s/%s",
609 dev_search_path, dev_name);
610 }
611 if (len >= PATH_MAX) {
612 pr_err("Too long path: %s, %s, %s\n",
613 dev_search_path, srv_sess->sessname, dev_name);
614 kfree(objp: full_path);
615 return ERR_PTR(error: -EINVAL);
616 }
617
618 /* eliminitate duplicated slashes */
619 a = strchr(full_path, '/');
620 b = a;
621 while (*b != '\0') {
622 if (*b == '/' && *a == '/') {
623 b++;
624 } else {
625 a++;
626 *a = *b;
627 b++;
628 }
629 }
630 a++;
631 *a = '\0';
632
633 return full_path;
634}
635
636static void process_msg_sess_info(struct rnbd_srv_session *srv_sess,
637 const void *msg, size_t len,
638 void *data, size_t datalen)
639{
640 const struct rnbd_msg_sess_info *sess_info_msg = msg;
641 struct rnbd_msg_sess_info_rsp *rsp = data;
642
643 srv_sess->ver = min_t(u8, sess_info_msg->ver, RNBD_PROTO_VER_MAJOR);
644
645 trace_process_msg_sess_info(srv: srv_sess, msg: sess_info_msg);
646
647 rsp->hdr.type = cpu_to_le16(RNBD_MSG_SESS_INFO_RSP);
648 rsp->ver = srv_sess->ver;
649}
650
651/**
652 * find_srv_sess_dev() - a dev is already opened by this name
653 * @srv_sess: the session to search.
654 * @dev_name: string containing the name of the device.
655 *
656 * Return struct rnbd_srv_sess_dev if srv_sess already opened the dev_name
657 * NULL if the session didn't open the device yet.
658 */
659static struct rnbd_srv_sess_dev *
660find_srv_sess_dev(struct rnbd_srv_session *srv_sess, const char *dev_name)
661{
662 struct rnbd_srv_sess_dev *sess_dev;
663 unsigned long index;
664
665 if (xa_empty(xa: &srv_sess->index_idr))
666 return NULL;
667
668 xa_for_each(&srv_sess->index_idr, index, sess_dev)
669 if (!strcmp(sess_dev->pathname, dev_name))
670 return sess_dev;
671
672 return NULL;
673}
674
675static int process_msg_open(struct rnbd_srv_session *srv_sess,
676 const void *msg, size_t len,
677 void *data, size_t datalen)
678{
679 int ret;
680 struct rnbd_srv_dev *srv_dev;
681 struct rnbd_srv_sess_dev *srv_sess_dev;
682 const struct rnbd_msg_open *open_msg = msg;
683 struct file *bdev_file;
684 blk_mode_t open_flags = BLK_OPEN_READ;
685 char *full_path;
686 struct rnbd_msg_open_rsp *rsp = data;
687
688 trace_process_msg_open(srv: srv_sess, msg: open_msg);
689
690 if (open_msg->access_mode != RNBD_ACCESS_RO)
691 open_flags |= BLK_OPEN_WRITE;
692
693 mutex_lock(&srv_sess->lock);
694
695 srv_sess_dev = find_srv_sess_dev(srv_sess, dev_name: open_msg->dev_name);
696 if (srv_sess_dev)
697 goto fill_response;
698
699 if ((strlen(dev_search_path) + strlen(open_msg->dev_name))
700 >= PATH_MAX) {
701 pr_err("Opening device for session %s failed, device path too long. '%s/%s' is longer than PATH_MAX (%d)\n",
702 srv_sess->sessname, dev_search_path, open_msg->dev_name,
703 PATH_MAX);
704 ret = -EINVAL;
705 goto reject;
706 }
707 if (strstr(open_msg->dev_name, "..")) {
708 pr_err("Opening device for session %s failed, device path %s contains relative path ..\n",
709 srv_sess->sessname, open_msg->dev_name);
710 ret = -EINVAL;
711 goto reject;
712 }
713 full_path = rnbd_srv_get_full_path(srv_sess, dev_name: open_msg->dev_name);
714 if (IS_ERR(ptr: full_path)) {
715 ret = PTR_ERR(ptr: full_path);
716 pr_err("Opening device '%s' for client %s failed, failed to get device full path, err: %pe\n",
717 open_msg->dev_name, srv_sess->sessname, full_path);
718 goto reject;
719 }
720
721 bdev_file = bdev_file_open_by_path(path: full_path, mode: open_flags, NULL, NULL);
722 if (IS_ERR(ptr: bdev_file)) {
723 ret = PTR_ERR(ptr: bdev_file);
724 pr_err("Opening device '%s' on session %s failed, failed to open the block device, err: %pe\n",
725 full_path, srv_sess->sessname, bdev_file);
726 goto free_path;
727 }
728
729 srv_dev = rnbd_srv_get_or_create_srv_dev(bdev: file_bdev(bdev_file), srv_sess,
730 access_mode: open_msg->access_mode);
731 if (IS_ERR(ptr: srv_dev)) {
732 pr_err("Opening device '%s' on session %s failed, creating srv_dev failed, err: %pe\n",
733 full_path, srv_sess->sessname, srv_dev);
734 ret = PTR_ERR(ptr: srv_dev);
735 goto blkdev_put;
736 }
737
738 srv_sess_dev = rnbd_srv_create_set_sess_dev(srv_sess, open_msg,
739 bdev_file,
740 readonly: open_msg->access_mode == RNBD_ACCESS_RO,
741 srv_dev);
742 if (IS_ERR(ptr: srv_sess_dev)) {
743 pr_err("Opening device '%s' on session %s failed, creating sess_dev failed, err: %pe\n",
744 full_path, srv_sess->sessname, srv_sess_dev);
745 ret = PTR_ERR(ptr: srv_sess_dev);
746 goto srv_dev_put;
747 }
748
749 /* Create the srv_dev sysfs files if they haven't been created yet. The
750 * reason to delay the creation is not to create the sysfs files before
751 * we are sure the device can be opened.
752 */
753 mutex_lock(&srv_dev->lock);
754 if (!srv_dev->dev_kobj.state_in_sysfs) {
755 ret = rnbd_srv_create_dev_sysfs(dev: srv_dev, bdev: file_bdev(bdev_file));
756 if (ret) {
757 mutex_unlock(lock: &srv_dev->lock);
758 rnbd_srv_err(srv_sess_dev,
759 "Opening device failed, failed to create device sysfs files, err: %d\n",
760 ret);
761 goto free_srv_sess_dev;
762 }
763 }
764
765 ret = rnbd_srv_create_dev_session_sysfs(sess_dev: srv_sess_dev);
766 if (ret) {
767 mutex_unlock(lock: &srv_dev->lock);
768 rnbd_srv_err(srv_sess_dev,
769 "Opening device failed, failed to create dev client sysfs files, err: %d\n",
770 ret);
771 goto free_srv_sess_dev;
772 }
773
774 list_add(new: &srv_sess_dev->dev_list, head: &srv_dev->sess_dev_list);
775 mutex_unlock(lock: &srv_dev->lock);
776
777 rnbd_srv_info(srv_sess_dev, "Opened device '%s'\n", srv_dev->name);
778
779 kfree(objp: full_path);
780
781fill_response:
782 rnbd_srv_fill_msg_open_rsp(rsp, sess_dev: srv_sess_dev);
783 mutex_unlock(lock: &srv_sess->lock);
784 return 0;
785
786free_srv_sess_dev:
787 xa_erase(&srv_sess->index_idr, index: srv_sess_dev->device_id);
788 synchronize_rcu();
789 kfree(objp: srv_sess_dev);
790srv_dev_put:
791 if (open_msg->access_mode != RNBD_ACCESS_RO) {
792 mutex_lock(&srv_dev->lock);
793 srv_dev->open_write_cnt--;
794 mutex_unlock(lock: &srv_dev->lock);
795 }
796 rnbd_put_srv_dev(dev: srv_dev);
797blkdev_put:
798 fput(bdev_file);
799free_path:
800 kfree(objp: full_path);
801reject:
802 mutex_unlock(lock: &srv_sess->lock);
803 return ret;
804}
805
806static struct rtrs_srv_ctx *rtrs_ctx;
807
808static struct rtrs_srv_ops rtrs_ops;
809static int __init rnbd_srv_init_module(void)
810{
811 int err = 0;
812
813 BUILD_BUG_ON(sizeof(struct rnbd_msg_hdr) != 4);
814 BUILD_BUG_ON(sizeof(struct rnbd_msg_sess_info) != 36);
815 BUILD_BUG_ON(sizeof(struct rnbd_msg_sess_info_rsp) != 36);
816 BUILD_BUG_ON(sizeof(struct rnbd_msg_open) != 264);
817 BUILD_BUG_ON(sizeof(struct rnbd_msg_close) != 8);
818 BUILD_BUG_ON(sizeof(struct rnbd_msg_open_rsp) != 56);
819 rtrs_ops = (struct rtrs_srv_ops) {
820 .rdma_ev = rnbd_srv_rdma_ev,
821 .link_ev = rnbd_srv_link_ev,
822 };
823 rtrs_ctx = rtrs_srv_open(ops: &rtrs_ops, port: port_nr);
824 if (IS_ERR(ptr: rtrs_ctx)) {
825 pr_err("rtrs_srv_open(), err: %pe\n", rtrs_ctx);
826 return PTR_ERR(ptr: rtrs_ctx);
827 }
828
829 err = rnbd_srv_create_sysfs_files();
830 if (err) {
831 pr_err("rnbd_srv_create_sysfs_files(), err: %d\n", err);
832 rtrs_srv_close(ctx: rtrs_ctx);
833 }
834
835 return err;
836}
837
838static void __exit rnbd_srv_cleanup_module(void)
839{
840 rtrs_srv_close(ctx: rtrs_ctx);
841 WARN_ON(!list_empty(&sess_list));
842 rnbd_srv_destroy_sysfs_files();
843}
844
845module_init(rnbd_srv_init_module);
846module_exit(rnbd_srv_cleanup_module);
847

source code of linux/drivers/block/rnbd/rnbd-srv.c