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