Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * RDMA Network Block Driver
0004  *
0005  * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
0006  * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
0007  * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
0008  */
0009 #undef pr_fmt
0010 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
0011 
0012 #include <linux/module.h>
0013 #include <linux/blkdev.h>
0014 
0015 #include "rnbd-srv.h"
0016 #include "rnbd-srv-dev.h"
0017 
0018 MODULE_DESCRIPTION("RDMA Network Block Device Server");
0019 MODULE_LICENSE("GPL");
0020 
0021 static u16 port_nr = RTRS_PORT;
0022 
0023 module_param_named(port_nr, port_nr, ushort, 0444);
0024 MODULE_PARM_DESC(port_nr,
0025          "The port number the server is listening on (default: "
0026          __stringify(RTRS_PORT)")");
0027 
0028 #define DEFAULT_DEV_SEARCH_PATH "/"
0029 
0030 static char dev_search_path[PATH_MAX] = DEFAULT_DEV_SEARCH_PATH;
0031 
0032 static int dev_search_path_set(const char *val, const struct kernel_param *kp)
0033 {
0034     const char *p = strrchr(val, '\n') ? : val + strlen(val);
0035 
0036     if (strlen(val) >= sizeof(dev_search_path))
0037         return -EINVAL;
0038 
0039     snprintf(dev_search_path, sizeof(dev_search_path), "%.*s",
0040          (int)(p - val), val);
0041 
0042     pr_info("dev_search_path changed to '%s'\n", dev_search_path);
0043 
0044     return 0;
0045 }
0046 
0047 static struct kparam_string dev_search_path_kparam_str = {
0048     .maxlen = sizeof(dev_search_path),
0049     .string = dev_search_path
0050 };
0051 
0052 static const struct kernel_param_ops dev_search_path_ops = {
0053     .set    = dev_search_path_set,
0054     .get    = param_get_string,
0055 };
0056 
0057 module_param_cb(dev_search_path, &dev_search_path_ops,
0058         &dev_search_path_kparam_str, 0444);
0059 MODULE_PARM_DESC(dev_search_path,
0060          "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: "
0061          DEFAULT_DEV_SEARCH_PATH ")");
0062 
0063 static DEFINE_MUTEX(sess_lock);
0064 static DEFINE_SPINLOCK(dev_lock);
0065 
0066 static LIST_HEAD(sess_list);
0067 static LIST_HEAD(dev_list);
0068 
0069 struct rnbd_io_private {
0070     struct rtrs_srv_op      *id;
0071     struct rnbd_srv_sess_dev    *sess_dev;
0072 };
0073 
0074 static void rnbd_sess_dev_release(struct kref *kref)
0075 {
0076     struct rnbd_srv_sess_dev *sess_dev;
0077 
0078     sess_dev = container_of(kref, struct rnbd_srv_sess_dev, kref);
0079     complete(sess_dev->destroy_comp);
0080 }
0081 
0082 static inline void rnbd_put_sess_dev(struct rnbd_srv_sess_dev *sess_dev)
0083 {
0084     kref_put(&sess_dev->kref, rnbd_sess_dev_release);
0085 }
0086 
0087 void rnbd_endio(void *priv, int error)
0088 {
0089     struct rnbd_io_private *rnbd_priv = priv;
0090     struct rnbd_srv_sess_dev *sess_dev = rnbd_priv->sess_dev;
0091 
0092     rnbd_put_sess_dev(sess_dev);
0093 
0094     rtrs_srv_resp_rdma(rnbd_priv->id, error);
0095 
0096     kfree(priv);
0097 }
0098 
0099 static struct rnbd_srv_sess_dev *
0100 rnbd_get_sess_dev(int dev_id, struct rnbd_srv_session *srv_sess)
0101 {
0102     struct rnbd_srv_sess_dev *sess_dev;
0103     int ret = 0;
0104 
0105     rcu_read_lock();
0106     sess_dev = xa_load(&srv_sess->index_idr, dev_id);
0107     if (sess_dev)
0108         ret = kref_get_unless_zero(&sess_dev->kref);
0109     rcu_read_unlock();
0110 
0111     if (!sess_dev || !ret)
0112         return ERR_PTR(-ENXIO);
0113 
0114     return sess_dev;
0115 }
0116 
0117 static void rnbd_dev_bi_end_io(struct bio *bio)
0118 {
0119     rnbd_endio(bio->bi_private, blk_status_to_errno(bio->bi_status));
0120     bio_put(bio);
0121 }
0122 
0123 static int process_rdma(struct rnbd_srv_session *srv_sess,
0124             struct rtrs_srv_op *id, void *data, u32 datalen,
0125             const void *usr, size_t usrlen)
0126 {
0127     const struct rnbd_msg_io *msg = usr;
0128     struct rnbd_io_private *priv;
0129     struct rnbd_srv_sess_dev *sess_dev;
0130     u32 dev_id;
0131     int err;
0132     struct bio *bio;
0133     short prio;
0134 
0135     priv = kmalloc(sizeof(*priv), GFP_KERNEL);
0136     if (!priv)
0137         return -ENOMEM;
0138 
0139     dev_id = le32_to_cpu(msg->device_id);
0140 
0141     sess_dev = rnbd_get_sess_dev(dev_id, srv_sess);
0142     if (IS_ERR(sess_dev)) {
0143         pr_err_ratelimited("Got I/O request on session %s for unknown device id %d\n",
0144                    srv_sess->sessname, dev_id);
0145         err = -ENOTCONN;
0146         goto err;
0147     }
0148 
0149     priv->sess_dev = sess_dev;
0150     priv->id = id;
0151 
0152     bio = bio_alloc(sess_dev->rnbd_dev->bdev, 1,
0153             rnbd_to_bio_flags(le32_to_cpu(msg->rw)), GFP_KERNEL);
0154     if (bio_add_page(bio, virt_to_page(data), datalen,
0155             offset_in_page(data)) != datalen) {
0156         rnbd_srv_err(sess_dev, "Failed to map data to bio\n");
0157         err = -EINVAL;
0158         goto bio_put;
0159     }
0160 
0161     bio->bi_end_io = rnbd_dev_bi_end_io;
0162     bio->bi_private = priv;
0163     bio->bi_iter.bi_sector = le64_to_cpu(msg->sector);
0164     bio->bi_iter.bi_size = le32_to_cpu(msg->bi_size);
0165     prio = srv_sess->ver < RNBD_PROTO_VER_MAJOR ||
0166            usrlen < sizeof(*msg) ? 0 : le16_to_cpu(msg->prio);
0167     bio_set_prio(bio, prio);
0168 
0169     submit_bio(bio);
0170 
0171     return 0;
0172 
0173 bio_put:
0174     bio_put(bio);
0175     rnbd_put_sess_dev(sess_dev);
0176 err:
0177     kfree(priv);
0178     return err;
0179 }
0180 
0181 static void destroy_device(struct kref *kref)
0182 {
0183     struct rnbd_srv_dev *dev = container_of(kref, struct rnbd_srv_dev, kref);
0184 
0185     WARN_ONCE(!list_empty(&dev->sess_dev_list),
0186           "Device %s is being destroyed but still in use!\n",
0187           dev->id);
0188 
0189     spin_lock(&dev_lock);
0190     list_del(&dev->list);
0191     spin_unlock(&dev_lock);
0192 
0193     mutex_destroy(&dev->lock);
0194     if (dev->dev_kobj.state_in_sysfs)
0195         /*
0196          * Destroy kobj only if it was really created.
0197          */
0198         rnbd_srv_destroy_dev_sysfs(dev);
0199     else
0200         kfree(dev);
0201 }
0202 
0203 static void rnbd_put_srv_dev(struct rnbd_srv_dev *dev)
0204 {
0205     kref_put(&dev->kref, destroy_device);
0206 }
0207 
0208 void rnbd_destroy_sess_dev(struct rnbd_srv_sess_dev *sess_dev, bool keep_id)
0209 {
0210     DECLARE_COMPLETION_ONSTACK(dc);
0211 
0212     if (keep_id)
0213         /* free the resources for the id but don't  */
0214         /* allow to re-use the id itself because it */
0215         /* is still used by the client              */
0216         xa_cmpxchg(&sess_dev->sess->index_idr, sess_dev->device_id,
0217                sess_dev, NULL, 0);
0218     else
0219         xa_erase(&sess_dev->sess->index_idr, sess_dev->device_id);
0220     synchronize_rcu();
0221 
0222     sess_dev->destroy_comp = &dc;
0223     rnbd_put_sess_dev(sess_dev);
0224     wait_for_completion(&dc); /* wait for inflights to drop to zero */
0225 
0226     rnbd_dev_close(sess_dev->rnbd_dev);
0227     mutex_lock(&sess_dev->dev->lock);
0228     list_del(&sess_dev->dev_list);
0229     if (sess_dev->open_flags & FMODE_WRITE)
0230         sess_dev->dev->open_write_cnt--;
0231     mutex_unlock(&sess_dev->dev->lock);
0232 
0233     rnbd_put_srv_dev(sess_dev->dev);
0234 
0235     rnbd_srv_info(sess_dev, "Device closed\n");
0236     kfree(sess_dev);
0237 }
0238 
0239 static void destroy_sess(struct rnbd_srv_session *srv_sess)
0240 {
0241     struct rnbd_srv_sess_dev *sess_dev;
0242     unsigned long index;
0243 
0244     if (xa_empty(&srv_sess->index_idr))
0245         goto out;
0246 
0247     mutex_lock(&srv_sess->lock);
0248     xa_for_each(&srv_sess->index_idr, index, sess_dev)
0249         rnbd_srv_destroy_dev_session_sysfs(sess_dev);
0250     mutex_unlock(&srv_sess->lock);
0251 
0252 out:
0253     xa_destroy(&srv_sess->index_idr);
0254 
0255     pr_info("RTRS Session %s disconnected\n", srv_sess->sessname);
0256 
0257     mutex_lock(&sess_lock);
0258     list_del(&srv_sess->list);
0259     mutex_unlock(&sess_lock);
0260 
0261     mutex_destroy(&srv_sess->lock);
0262     kfree(srv_sess);
0263 }
0264 
0265 static int create_sess(struct rtrs_srv_sess *rtrs)
0266 {
0267     struct rnbd_srv_session *srv_sess;
0268     char pathname[NAME_MAX];
0269     int err;
0270 
0271     err = rtrs_srv_get_path_name(rtrs, pathname, sizeof(pathname));
0272     if (err) {
0273         pr_err("rtrs_srv_get_path_name(%s): %d\n", pathname, err);
0274 
0275         return err;
0276     }
0277     srv_sess = kzalloc(sizeof(*srv_sess), GFP_KERNEL);
0278     if (!srv_sess)
0279         return -ENOMEM;
0280 
0281     srv_sess->queue_depth = rtrs_srv_get_queue_depth(rtrs);
0282     xa_init_flags(&srv_sess->index_idr, XA_FLAGS_ALLOC);
0283     mutex_init(&srv_sess->lock);
0284     mutex_lock(&sess_lock);
0285     list_add(&srv_sess->list, &sess_list);
0286     mutex_unlock(&sess_lock);
0287 
0288     srv_sess->rtrs = rtrs;
0289     strscpy(srv_sess->sessname, pathname, sizeof(srv_sess->sessname));
0290 
0291     rtrs_srv_set_sess_priv(rtrs, srv_sess);
0292 
0293     return 0;
0294 }
0295 
0296 static int rnbd_srv_link_ev(struct rtrs_srv_sess *rtrs,
0297                  enum rtrs_srv_link_ev ev, void *priv)
0298 {
0299     struct rnbd_srv_session *srv_sess = priv;
0300 
0301     switch (ev) {
0302     case RTRS_SRV_LINK_EV_CONNECTED:
0303         return create_sess(rtrs);
0304 
0305     case RTRS_SRV_LINK_EV_DISCONNECTED:
0306         if (WARN_ON_ONCE(!srv_sess))
0307             return -EINVAL;
0308 
0309         destroy_sess(srv_sess);
0310         return 0;
0311 
0312     default:
0313         pr_warn("Received unknown RTRS session event %d from session %s\n",
0314             ev, srv_sess->sessname);
0315         return -EINVAL;
0316     }
0317 }
0318 
0319 void rnbd_srv_sess_dev_force_close(struct rnbd_srv_sess_dev *sess_dev,
0320                    struct kobj_attribute *attr)
0321 {
0322     struct rnbd_srv_session *sess = sess_dev->sess;
0323 
0324     /* It is already started to close by client's close message. */
0325     if (!mutex_trylock(&sess->lock))
0326         return;
0327 
0328     sess_dev->keep_id = true;
0329     /* first remove sysfs itself to avoid deadlock */
0330     sysfs_remove_file_self(&sess_dev->kobj, &attr->attr);
0331     rnbd_srv_destroy_dev_session_sysfs(sess_dev);
0332     mutex_unlock(&sess->lock);
0333 }
0334 
0335 static int process_msg_close(struct rnbd_srv_session *srv_sess,
0336                  void *data, size_t datalen, const void *usr,
0337                  size_t usrlen)
0338 {
0339     const struct rnbd_msg_close *close_msg = usr;
0340     struct rnbd_srv_sess_dev *sess_dev;
0341 
0342     sess_dev = rnbd_get_sess_dev(le32_to_cpu(close_msg->device_id),
0343                       srv_sess);
0344     if (IS_ERR(sess_dev))
0345         return 0;
0346 
0347     rnbd_put_sess_dev(sess_dev);
0348     mutex_lock(&srv_sess->lock);
0349     rnbd_srv_destroy_dev_session_sysfs(sess_dev);
0350     mutex_unlock(&srv_sess->lock);
0351     return 0;
0352 }
0353 
0354 static int process_msg_open(struct rnbd_srv_session *srv_sess,
0355                 const void *msg, size_t len,
0356                 void *data, size_t datalen);
0357 
0358 static int process_msg_sess_info(struct rnbd_srv_session *srv_sess,
0359                  const void *msg, size_t len,
0360                  void *data, size_t datalen);
0361 
0362 static int rnbd_srv_rdma_ev(void *priv,
0363                 struct rtrs_srv_op *id, int dir,
0364                 void *data, size_t datalen, const void *usr,
0365                 size_t usrlen)
0366 {
0367     struct rnbd_srv_session *srv_sess = priv;
0368     const struct rnbd_msg_hdr *hdr = usr;
0369     int ret = 0;
0370     u16 type;
0371 
0372     if (WARN_ON_ONCE(!srv_sess))
0373         return -ENODEV;
0374 
0375     type = le16_to_cpu(hdr->type);
0376 
0377     switch (type) {
0378     case RNBD_MSG_IO:
0379         return process_rdma(srv_sess, id, data, datalen, usr, usrlen);
0380     case RNBD_MSG_CLOSE:
0381         ret = process_msg_close(srv_sess, data, datalen, usr, usrlen);
0382         break;
0383     case RNBD_MSG_OPEN:
0384         ret = process_msg_open(srv_sess, usr, usrlen, data, datalen);
0385         break;
0386     case RNBD_MSG_SESS_INFO:
0387         ret = process_msg_sess_info(srv_sess, usr, usrlen, data,
0388                         datalen);
0389         break;
0390     default:
0391         pr_warn("Received unexpected message type %d with dir %d from session %s\n",
0392             type, dir, srv_sess->sessname);
0393         return -EINVAL;
0394     }
0395 
0396     rtrs_srv_resp_rdma(id, ret);
0397     return 0;
0398 }
0399 
0400 static struct rnbd_srv_sess_dev
0401 *rnbd_sess_dev_alloc(struct rnbd_srv_session *srv_sess)
0402 {
0403     struct rnbd_srv_sess_dev *sess_dev;
0404     int error;
0405 
0406     sess_dev = kzalloc(sizeof(*sess_dev), GFP_KERNEL);
0407     if (!sess_dev)
0408         return ERR_PTR(-ENOMEM);
0409 
0410     error = xa_alloc(&srv_sess->index_idr, &sess_dev->device_id, sess_dev,
0411              xa_limit_32b, GFP_NOWAIT);
0412     if (error < 0) {
0413         pr_warn("Allocating idr failed, err: %d\n", error);
0414         kfree(sess_dev);
0415         return ERR_PTR(error);
0416     }
0417 
0418     return sess_dev;
0419 }
0420 
0421 static struct rnbd_srv_dev *rnbd_srv_init_srv_dev(struct block_device *bdev)
0422 {
0423     struct rnbd_srv_dev *dev;
0424 
0425     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
0426     if (!dev)
0427         return ERR_PTR(-ENOMEM);
0428 
0429     snprintf(dev->id, sizeof(dev->id), "%pg", bdev);
0430     kref_init(&dev->kref);
0431     INIT_LIST_HEAD(&dev->sess_dev_list);
0432     mutex_init(&dev->lock);
0433 
0434     return dev;
0435 }
0436 
0437 static struct rnbd_srv_dev *
0438 rnbd_srv_find_or_add_srv_dev(struct rnbd_srv_dev *new_dev)
0439 {
0440     struct rnbd_srv_dev *dev;
0441 
0442     spin_lock(&dev_lock);
0443     list_for_each_entry(dev, &dev_list, list) {
0444         if (!strncmp(dev->id, new_dev->id, sizeof(dev->id))) {
0445             if (!kref_get_unless_zero(&dev->kref))
0446                 /*
0447                  * We lost the race, device is almost dead.
0448                  *  Continue traversing to find a valid one.
0449                  */
0450                 continue;
0451             spin_unlock(&dev_lock);
0452             return dev;
0453         }
0454     }
0455     list_add(&new_dev->list, &dev_list);
0456     spin_unlock(&dev_lock);
0457 
0458     return new_dev;
0459 }
0460 
0461 static int rnbd_srv_check_update_open_perm(struct rnbd_srv_dev *srv_dev,
0462                         struct rnbd_srv_session *srv_sess,
0463                         enum rnbd_access_mode access_mode)
0464 {
0465     int ret = -EPERM;
0466 
0467     mutex_lock(&srv_dev->lock);
0468 
0469     switch (access_mode) {
0470     case RNBD_ACCESS_RO:
0471         ret = 0;
0472         break;
0473     case RNBD_ACCESS_RW:
0474         if (srv_dev->open_write_cnt == 0)  {
0475             srv_dev->open_write_cnt++;
0476             ret = 0;
0477         } else {
0478             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",
0479                    srv_dev->id, srv_sess->sessname,
0480                    srv_dev->open_write_cnt,
0481                    rnbd_access_mode_str(access_mode));
0482         }
0483         break;
0484     case RNBD_ACCESS_MIGRATION:
0485         if (srv_dev->open_write_cnt < 2) {
0486             srv_dev->open_write_cnt++;
0487             ret = 0;
0488         } else {
0489             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",
0490                    srv_dev->id, srv_sess->sessname,
0491                    srv_dev->open_write_cnt,
0492                    rnbd_access_mode_str(access_mode));
0493         }
0494         break;
0495     default:
0496         pr_err("Received mapping request for device '%s' on session %s with invalid access mode: %d\n",
0497                srv_dev->id, srv_sess->sessname, access_mode);
0498         ret = -EINVAL;
0499     }
0500 
0501     mutex_unlock(&srv_dev->lock);
0502 
0503     return ret;
0504 }
0505 
0506 static struct rnbd_srv_dev *
0507 rnbd_srv_get_or_create_srv_dev(struct rnbd_dev *rnbd_dev,
0508                 struct rnbd_srv_session *srv_sess,
0509                 enum rnbd_access_mode access_mode)
0510 {
0511     int ret;
0512     struct rnbd_srv_dev *new_dev, *dev;
0513 
0514     new_dev = rnbd_srv_init_srv_dev(rnbd_dev->bdev);
0515     if (IS_ERR(new_dev))
0516         return new_dev;
0517 
0518     dev = rnbd_srv_find_or_add_srv_dev(new_dev);
0519     if (dev != new_dev)
0520         kfree(new_dev);
0521 
0522     ret = rnbd_srv_check_update_open_perm(dev, srv_sess, access_mode);
0523     if (ret) {
0524         rnbd_put_srv_dev(dev);
0525         return ERR_PTR(ret);
0526     }
0527 
0528     return dev;
0529 }
0530 
0531 static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp,
0532                     struct rnbd_srv_sess_dev *sess_dev)
0533 {
0534     struct rnbd_dev *rnbd_dev = sess_dev->rnbd_dev;
0535 
0536     rsp->hdr.type = cpu_to_le16(RNBD_MSG_OPEN_RSP);
0537     rsp->device_id =
0538         cpu_to_le32(sess_dev->device_id);
0539     rsp->nsectors =
0540         cpu_to_le64(get_capacity(rnbd_dev->bdev->bd_disk));
0541     rsp->logical_block_size =
0542         cpu_to_le16(bdev_logical_block_size(rnbd_dev->bdev));
0543     rsp->physical_block_size =
0544         cpu_to_le16(bdev_physical_block_size(rnbd_dev->bdev));
0545     rsp->max_segments =
0546         cpu_to_le16(rnbd_dev_get_max_segs(rnbd_dev));
0547     rsp->max_hw_sectors =
0548         cpu_to_le32(rnbd_dev_get_max_hw_sects(rnbd_dev));
0549     rsp->max_write_same_sectors = 0;
0550     rsp->max_discard_sectors =
0551         cpu_to_le32(rnbd_dev_get_max_discard_sects(rnbd_dev));
0552     rsp->discard_granularity =
0553         cpu_to_le32(rnbd_dev_get_discard_granularity(rnbd_dev));
0554     rsp->discard_alignment =
0555         cpu_to_le32(rnbd_dev_get_discard_alignment(rnbd_dev));
0556     rsp->secure_discard =
0557         cpu_to_le16(rnbd_dev_get_secure_discard(rnbd_dev));
0558     rsp->cache_policy = 0;
0559     if (bdev_write_cache(rnbd_dev->bdev))
0560         rsp->cache_policy |= RNBD_WRITEBACK;
0561     if (bdev_fua(rnbd_dev->bdev))
0562         rsp->cache_policy |= RNBD_FUA;
0563 }
0564 
0565 static struct rnbd_srv_sess_dev *
0566 rnbd_srv_create_set_sess_dev(struct rnbd_srv_session *srv_sess,
0567                   const struct rnbd_msg_open *open_msg,
0568                   struct rnbd_dev *rnbd_dev, fmode_t open_flags,
0569                   struct rnbd_srv_dev *srv_dev)
0570 {
0571     struct rnbd_srv_sess_dev *sdev = rnbd_sess_dev_alloc(srv_sess);
0572 
0573     if (IS_ERR(sdev))
0574         return sdev;
0575 
0576     kref_init(&sdev->kref);
0577 
0578     strscpy(sdev->pathname, open_msg->dev_name, sizeof(sdev->pathname));
0579 
0580     sdev->rnbd_dev      = rnbd_dev;
0581     sdev->sess      = srv_sess;
0582     sdev->dev       = srv_dev;
0583     sdev->open_flags    = open_flags;
0584     sdev->access_mode   = open_msg->access_mode;
0585 
0586     return sdev;
0587 }
0588 
0589 static char *rnbd_srv_get_full_path(struct rnbd_srv_session *srv_sess,
0590                      const char *dev_name)
0591 {
0592     char *full_path;
0593     char *a, *b;
0594 
0595     full_path = kmalloc(PATH_MAX, GFP_KERNEL);
0596     if (!full_path)
0597         return ERR_PTR(-ENOMEM);
0598 
0599     /*
0600      * Replace %SESSNAME% with a real session name in order to
0601      * create device namespace.
0602      */
0603     a = strnstr(dev_search_path, "%SESSNAME%", sizeof(dev_search_path));
0604     if (a) {
0605         int len = a - dev_search_path;
0606 
0607         len = snprintf(full_path, PATH_MAX, "%.*s/%s/%s", len,
0608                    dev_search_path, srv_sess->sessname, dev_name);
0609         if (len >= PATH_MAX) {
0610             pr_err("Too long path: %s, %s, %s\n",
0611                    dev_search_path, srv_sess->sessname, dev_name);
0612             kfree(full_path);
0613             return ERR_PTR(-EINVAL);
0614         }
0615     } else {
0616         snprintf(full_path, PATH_MAX, "%s/%s",
0617              dev_search_path, dev_name);
0618     }
0619 
0620     /* eliminitate duplicated slashes */
0621     a = strchr(full_path, '/');
0622     b = a;
0623     while (*b != '\0') {
0624         if (*b == '/' && *a == '/') {
0625             b++;
0626         } else {
0627             a++;
0628             *a = *b;
0629             b++;
0630         }
0631     }
0632     a++;
0633     *a = '\0';
0634 
0635     return full_path;
0636 }
0637 
0638 static int process_msg_sess_info(struct rnbd_srv_session *srv_sess,
0639                  const void *msg, size_t len,
0640                  void *data, size_t datalen)
0641 {
0642     const struct rnbd_msg_sess_info *sess_info_msg = msg;
0643     struct rnbd_msg_sess_info_rsp *rsp = data;
0644 
0645     srv_sess->ver = min_t(u8, sess_info_msg->ver, RNBD_PROTO_VER_MAJOR);
0646     pr_debug("Session %s using protocol version %d (client version: %d, server version: %d)\n",
0647          srv_sess->sessname, srv_sess->ver,
0648          sess_info_msg->ver, RNBD_PROTO_VER_MAJOR);
0649 
0650     rsp->hdr.type = cpu_to_le16(RNBD_MSG_SESS_INFO_RSP);
0651     rsp->ver = srv_sess->ver;
0652 
0653     return 0;
0654 }
0655 
0656 /**
0657  * find_srv_sess_dev() - a dev is already opened by this name
0658  * @srv_sess:   the session to search.
0659  * @dev_name:   string containing the name of the device.
0660  *
0661  * Return struct rnbd_srv_sess_dev if srv_sess already opened the dev_name
0662  * NULL if the session didn't open the device yet.
0663  */
0664 static struct rnbd_srv_sess_dev *
0665 find_srv_sess_dev(struct rnbd_srv_session *srv_sess, const char *dev_name)
0666 {
0667     struct rnbd_srv_sess_dev *sess_dev;
0668     unsigned long index;
0669 
0670     if (xa_empty(&srv_sess->index_idr))
0671         return NULL;
0672 
0673     xa_for_each(&srv_sess->index_idr, index, sess_dev)
0674         if (!strcmp(sess_dev->pathname, dev_name))
0675             return sess_dev;
0676 
0677     return NULL;
0678 }
0679 
0680 static int process_msg_open(struct rnbd_srv_session *srv_sess,
0681                 const void *msg, size_t len,
0682                 void *data, size_t datalen)
0683 {
0684     int ret;
0685     struct rnbd_srv_dev *srv_dev;
0686     struct rnbd_srv_sess_dev *srv_sess_dev;
0687     const struct rnbd_msg_open *open_msg = msg;
0688     fmode_t open_flags;
0689     char *full_path;
0690     struct rnbd_dev *rnbd_dev;
0691     struct rnbd_msg_open_rsp *rsp = data;
0692 
0693     pr_debug("Open message received: session='%s' path='%s' access_mode=%d\n",
0694          srv_sess->sessname, open_msg->dev_name,
0695          open_msg->access_mode);
0696     open_flags = FMODE_READ;
0697     if (open_msg->access_mode != RNBD_ACCESS_RO)
0698         open_flags |= FMODE_WRITE;
0699 
0700     mutex_lock(&srv_sess->lock);
0701 
0702     srv_sess_dev = find_srv_sess_dev(srv_sess, open_msg->dev_name);
0703     if (srv_sess_dev)
0704         goto fill_response;
0705 
0706     if ((strlen(dev_search_path) + strlen(open_msg->dev_name))
0707         >= PATH_MAX) {
0708         pr_err("Opening device for session %s failed, device path too long. '%s/%s' is longer than PATH_MAX (%d)\n",
0709                srv_sess->sessname, dev_search_path, open_msg->dev_name,
0710                PATH_MAX);
0711         ret = -EINVAL;
0712         goto reject;
0713     }
0714     if (strstr(open_msg->dev_name, "..")) {
0715         pr_err("Opening device for session %s failed, device path %s contains relative path ..\n",
0716                srv_sess->sessname, open_msg->dev_name);
0717         ret = -EINVAL;
0718         goto reject;
0719     }
0720     full_path = rnbd_srv_get_full_path(srv_sess, open_msg->dev_name);
0721     if (IS_ERR(full_path)) {
0722         ret = PTR_ERR(full_path);
0723         pr_err("Opening device '%s' for client %s failed, failed to get device full path, err: %d\n",
0724                open_msg->dev_name, srv_sess->sessname, ret);
0725         goto reject;
0726     }
0727 
0728     rnbd_dev = rnbd_dev_open(full_path, open_flags);
0729     if (IS_ERR(rnbd_dev)) {
0730         pr_err("Opening device '%s' on session %s failed, failed to open the block device, err: %ld\n",
0731                full_path, srv_sess->sessname, PTR_ERR(rnbd_dev));
0732         ret = PTR_ERR(rnbd_dev);
0733         goto free_path;
0734     }
0735 
0736     srv_dev = rnbd_srv_get_or_create_srv_dev(rnbd_dev, srv_sess,
0737                           open_msg->access_mode);
0738     if (IS_ERR(srv_dev)) {
0739         pr_err("Opening device '%s' on session %s failed, creating srv_dev failed, err: %ld\n",
0740                full_path, srv_sess->sessname, PTR_ERR(srv_dev));
0741         ret = PTR_ERR(srv_dev);
0742         goto rnbd_dev_close;
0743     }
0744 
0745     srv_sess_dev = rnbd_srv_create_set_sess_dev(srv_sess, open_msg,
0746                              rnbd_dev, open_flags,
0747                              srv_dev);
0748     if (IS_ERR(srv_sess_dev)) {
0749         pr_err("Opening device '%s' on session %s failed, creating sess_dev failed, err: %ld\n",
0750                full_path, srv_sess->sessname, PTR_ERR(srv_sess_dev));
0751         ret = PTR_ERR(srv_sess_dev);
0752         goto srv_dev_put;
0753     }
0754 
0755     /* Create the srv_dev sysfs files if they haven't been created yet. The
0756      * reason to delay the creation is not to create the sysfs files before
0757      * we are sure the device can be opened.
0758      */
0759     mutex_lock(&srv_dev->lock);
0760     if (!srv_dev->dev_kobj.state_in_sysfs) {
0761         ret = rnbd_srv_create_dev_sysfs(srv_dev, rnbd_dev->bdev);
0762         if (ret) {
0763             mutex_unlock(&srv_dev->lock);
0764             rnbd_srv_err(srv_sess_dev,
0765                       "Opening device failed, failed to create device sysfs files, err: %d\n",
0766                       ret);
0767             goto free_srv_sess_dev;
0768         }
0769     }
0770 
0771     ret = rnbd_srv_create_dev_session_sysfs(srv_sess_dev);
0772     if (ret) {
0773         mutex_unlock(&srv_dev->lock);
0774         rnbd_srv_err(srv_sess_dev,
0775                   "Opening device failed, failed to create dev client sysfs files, err: %d\n",
0776                   ret);
0777         goto free_srv_sess_dev;
0778     }
0779 
0780     list_add(&srv_sess_dev->dev_list, &srv_dev->sess_dev_list);
0781     mutex_unlock(&srv_dev->lock);
0782 
0783     rnbd_srv_info(srv_sess_dev, "Opened device '%s'\n", srv_dev->id);
0784 
0785     kfree(full_path);
0786 
0787 fill_response:
0788     rnbd_srv_fill_msg_open_rsp(rsp, srv_sess_dev);
0789     mutex_unlock(&srv_sess->lock);
0790     return 0;
0791 
0792 free_srv_sess_dev:
0793     xa_erase(&srv_sess->index_idr, srv_sess_dev->device_id);
0794     synchronize_rcu();
0795     kfree(srv_sess_dev);
0796 srv_dev_put:
0797     if (open_msg->access_mode != RNBD_ACCESS_RO) {
0798         mutex_lock(&srv_dev->lock);
0799         srv_dev->open_write_cnt--;
0800         mutex_unlock(&srv_dev->lock);
0801     }
0802     rnbd_put_srv_dev(srv_dev);
0803 rnbd_dev_close:
0804     rnbd_dev_close(rnbd_dev);
0805 free_path:
0806     kfree(full_path);
0807 reject:
0808     mutex_unlock(&srv_sess->lock);
0809     return ret;
0810 }
0811 
0812 static struct rtrs_srv_ctx *rtrs_ctx;
0813 
0814 static struct rtrs_srv_ops rtrs_ops;
0815 static int __init rnbd_srv_init_module(void)
0816 {
0817     int err;
0818 
0819     BUILD_BUG_ON(sizeof(struct rnbd_msg_hdr) != 4);
0820     BUILD_BUG_ON(sizeof(struct rnbd_msg_sess_info) != 36);
0821     BUILD_BUG_ON(sizeof(struct rnbd_msg_sess_info_rsp) != 36);
0822     BUILD_BUG_ON(sizeof(struct rnbd_msg_open) != 264);
0823     BUILD_BUG_ON(sizeof(struct rnbd_msg_close) != 8);
0824     BUILD_BUG_ON(sizeof(struct rnbd_msg_open_rsp) != 56);
0825     rtrs_ops = (struct rtrs_srv_ops) {
0826         .rdma_ev = rnbd_srv_rdma_ev,
0827         .link_ev = rnbd_srv_link_ev,
0828     };
0829     rtrs_ctx = rtrs_srv_open(&rtrs_ops, port_nr);
0830     if (IS_ERR(rtrs_ctx)) {
0831         err = PTR_ERR(rtrs_ctx);
0832         pr_err("rtrs_srv_open(), err: %d\n", err);
0833         return err;
0834     }
0835 
0836     err = rnbd_srv_create_sysfs_files();
0837     if (err) {
0838         pr_err("rnbd_srv_create_sysfs_files(), err: %d\n", err);
0839         rtrs_srv_close(rtrs_ctx);
0840         return err;
0841     }
0842 
0843     return 0;
0844 }
0845 
0846 static void __exit rnbd_srv_cleanup_module(void)
0847 {
0848     rtrs_srv_close(rtrs_ctx);
0849     WARN_ON(!list_empty(&sess_list));
0850     rnbd_srv_destroy_sysfs_files();
0851 }
0852 
0853 module_init(rnbd_srv_init_module);
0854 module_exit(rnbd_srv_cleanup_module);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!