RDMA/rtrs-srv: Rename rtrs_srv_sess to rtrs_srv_path

[ Upstream commit ae4c81644e9105d9f7f713bb0d444737bb6a0cf1 ]

rtrs_srv_sess is used for paths and not sessions on the server side. This
creates confusion so let's rename it to rtrs_srv_path. Also, rename
related variables and functions.

Coccinelle is used to do the transformations for most of the occurrences
and remaining ones were handled manually.

Link: https://lore.kernel.org/r/20220105180708.7774-3-jinpu.wang@ionos.com
Signed-off-by: Vaishali Thakkar <vaishali.thakkar@ionos.com>
Signed-off-by: Jack Wang <jinpu.wang@ionos.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/drivers/block/rnbd/rnbd-srv.c b/drivers/block/rnbd/rnbd-srv.c
index aafecfe..1ba1a93 100644 (file)
--- a/drivers/block/rnbd/rnbd-srv.c
+++ b/drivers/block/rnbd/rnbd-srv.c
@@ -266,12 +266,12 @@ out:
 static int create_sess(struct rtrs_srv *rtrs)
 {
        struct rnbd_srv_session *srv_sess;
-       char sessname[NAME_MAX];
+       char pathname[NAME_MAX];
        int err;
 
-       err = rtrs_srv_get_sess_name(rtrs, sessname, sizeof(sessname));
+       err = rtrs_srv_get_path_name(rtrs, pathname, sizeof(pathname));
        if (err) {
-               pr_err("rtrs_srv_get_sess_name(%s): %d\n", sessname, err);
+               pr_err("rtrs_srv_get_path_name(%s): %d\n", pathname, err);
 
                return err;
        }
@@ -284,8 +284,8 @@ static int create_sess(struct rtrs_srv *rtrs)
                          offsetof(struct rnbd_dev_blk_io, bio),
                          BIOSET_NEED_BVECS);
        if (err) {
-               pr_err("Allocating srv_session for session %s failed\n",
-                      sessname);
+               pr_err("Allocating srv_session for path %s failed\n",
+                      pathname);
                kfree(srv_sess);
                return err;
        }
@@ -298,7 +298,7 @@ static int create_sess(struct rtrs_srv *rtrs)
        mutex_unlock(&sess_lock);
 
        srv_sess->rtrs = rtrs;
-       strscpy(srv_sess->sessname, sessname, sizeof(srv_sess->sessname));
+       strscpy(srv_sess->sessname, pathname, sizeof(srv_sess->sessname));
 
        rtrs_srv_set_sess_priv(rtrs, srv_sess);
 

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-pri.h b/drivers/infiniband/ulp/rtrs/rtrs-pri.h
index fad06c7..412cf5c 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-pri.h
+++ b/drivers/infiniband/ulp/rtrs/rtrs-pri.h
@@ -234,7 +234,7 @@ struct rtrs_msg_conn_rsp {
  */
 struct rtrs_msg_info_req {
        __le16          type;
-       u8              sessname[NAME_MAX];
+       u8              pathname[NAME_MAX];
        u8              reserved[15];
 };
 

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c b/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
index aedddc4..3090801 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
@@ -15,10 +15,10 @@
 
 static void rtrs_srv_release(struct kobject *kobj)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
 
-       sess = container_of(kobj, struct rtrs_srv_sess, kobj);
-       kfree(sess);
+       srv_path = container_of(kobj, struct rtrs_srv_path, kobj);
+       kfree(srv_path);
 }
 
 static struct kobj_type ktype = {
@@ -36,24 +36,25 @@ static ssize_t rtrs_srv_disconnect_store(struct kobject *kobj,
                                          struct kobj_attribute *attr,
                                          const char *buf, size_t count)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        struct rtrs_path *s;
        char str[MAXHOSTNAMELEN];
 
-       sess = container_of(kobj, struct rtrs_srv_sess, kobj);
-       s = &sess->s;
+       srv_path = container_of(kobj, struct rtrs_srv_path, kobj);
+       s = &srv_path->s;
        if (!sysfs_streq(buf, "1")) {
                rtrs_err(s, "%s: invalid value: '%s'\n",
                          attr->attr.name, buf);
                return -EINVAL;
        }
 
-       sockaddr_to_str((struct sockaddr *)&sess->s.dst_addr, str, sizeof(str));
+       sockaddr_to_str((struct sockaddr *)&srv_path->s.dst_addr, str,
+                       sizeof(str));
 
        rtrs_info(s, "disconnect for path %s requested\n", str);
        /* first remove sysfs itself to avoid deadlock */
-       sysfs_remove_file_self(&sess->kobj, &attr->attr);
-       close_sess(sess);
+       sysfs_remove_file_self(&srv_path->kobj, &attr->attr);
+       close_path(srv_path);
 
        return count;
 }
@@ -66,11 +67,11 @@ static ssize_t rtrs_srv_hca_port_show(struct kobject *kobj,
                                       struct kobj_attribute *attr,
                                       char *page)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        struct rtrs_con *usr_con;
 
-       sess = container_of(kobj, typeof(*sess), kobj);
-       usr_con = sess->s.con[0];
+       srv_path = container_of(kobj, typeof(*srv_path), kobj);
+       usr_con = srv_path->s.con[0];
 
        return sysfs_emit(page, "%u\n", usr_con->cm_id->port_num);
 }
@@ -82,11 +83,11 @@ static ssize_t rtrs_srv_hca_name_show(struct kobject *kobj,
                                       struct kobj_attribute *attr,
                                       char *page)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
 
-       sess = container_of(kobj, struct rtrs_srv_sess, kobj);
+       srv_path = container_of(kobj, struct rtrs_srv_path, kobj);
 
-       return sysfs_emit(page, "%s\n", sess->s.dev->ib_dev->name);
+       return sysfs_emit(page, "%s\n", srv_path->s.dev->ib_dev->name);
 }
 
 static struct kobj_attribute rtrs_srv_hca_name_attr =
@@ -96,11 +97,11 @@ static ssize_t rtrs_srv_src_addr_show(struct kobject *kobj,
                                       struct kobj_attribute *attr,
                                       char *page)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        int cnt;
 
-       sess = container_of(kobj, struct rtrs_srv_sess, kobj);
-       cnt = sockaddr_to_str((struct sockaddr *)&sess->s.dst_addr,
+       srv_path = container_of(kobj, struct rtrs_srv_path, kobj);
+       cnt = sockaddr_to_str((struct sockaddr *)&srv_path->s.dst_addr,
                              page, PAGE_SIZE);
        return cnt + scnprintf(page + cnt, PAGE_SIZE - cnt, "\n");
 }
@@ -112,11 +113,11 @@ static ssize_t rtrs_srv_dst_addr_show(struct kobject *kobj,
                                       struct kobj_attribute *attr,
                                       char *page)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        int len;
 
-       sess = container_of(kobj, struct rtrs_srv_sess, kobj);
-       len = sockaddr_to_str((struct sockaddr *)&sess->s.src_addr, page,
+       srv_path = container_of(kobj, struct rtrs_srv_path, kobj);
+       len = sockaddr_to_str((struct sockaddr *)&srv_path->s.src_addr, page,
                              PAGE_SIZE);
        len += sysfs_emit_at(page, len, "\n");
        return len;
@@ -125,7 +126,7 @@ static ssize_t rtrs_srv_dst_addr_show(struct kobject *kobj,
 static struct kobj_attribute rtrs_srv_dst_addr_attr =
        __ATTR(dst_addr, 0444, rtrs_srv_dst_addr_show, NULL);
 
-static struct attribute *rtrs_srv_sess_attrs[] = {
+static struct attribute *rtrs_srv_path_attrs[] = {
        &rtrs_srv_hca_name_attr.attr,
        &rtrs_srv_hca_port_attr.attr,
        &rtrs_srv_src_addr_attr.attr,
@@ -134,8 +135,8 @@ static struct attribute *rtrs_srv_sess_attrs[] = {
        NULL,
 };
 
-static const struct attribute_group rtrs_srv_sess_attr_group = {
-       .attrs = rtrs_srv_sess_attrs,
+static const struct attribute_group rtrs_srv_path_attr_group = {
+       .attrs = rtrs_srv_path_attrs,
 };
 
 STAT_ATTR(struct rtrs_srv_stats, rdma,
@@ -151,9 +152,9 @@ static const struct attribute_group rtrs_srv_stats_attr_group = {
        .attrs = rtrs_srv_stats_attrs,
 };
 
-static int rtrs_srv_create_once_sysfs_root_folders(struct rtrs_srv_sess *sess)
+static int rtrs_srv_create_once_sysfs_root_folders(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
        int err = 0;
 
        mutex_lock(&srv->paths_mutex);
@@ -164,7 +165,7 @@ static int rtrs_srv_create_once_sysfs_root_folders(struct rtrs_srv_sess *sess)
                goto unlock;
        }
        srv->dev.class = rtrs_dev_class;
-       err = dev_set_name(&srv->dev, "%s", sess->s.sessname);
+       err = dev_set_name(&srv->dev, "%s", srv_path->s.sessname);
        if (err)
                goto unlock;
 
@@ -196,9 +197,9 @@ unlock:
 }
 
 static void
-rtrs_srv_destroy_once_sysfs_root_folders(struct rtrs_srv_sess *sess)
+rtrs_srv_destroy_once_sysfs_root_folders(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
 
        mutex_lock(&srv->paths_mutex);
        if (!--srv->dev_ref) {
@@ -213,7 +214,7 @@ rtrs_srv_destroy_once_sysfs_root_folders(struct rtrs_srv_sess *sess)
        }
 }
 
-static void rtrs_srv_sess_stats_release(struct kobject *kobj)
+static void rtrs_srv_path_stats_release(struct kobject *kobj)
 {
        struct rtrs_srv_stats *stats;
 
@@ -224,22 +225,22 @@ static void rtrs_srv_sess_stats_release(struct kobject *kobj)
 
 static struct kobj_type ktype_stats = {
        .sysfs_ops = &kobj_sysfs_ops,
-       .release = rtrs_srv_sess_stats_release,
+       .release = rtrs_srv_path_stats_release,
 };
 
-static int rtrs_srv_create_stats_files(struct rtrs_srv_sess *sess)
+static int rtrs_srv_create_stats_files(struct rtrs_srv_path *srv_path)
 {
        int err;
-       struct rtrs_path *s = &sess->s;
+       struct rtrs_path *s = &srv_path->s;
 
-       err = kobject_init_and_add(&sess->stats->kobj_stats, &ktype_stats,
-                                  &sess->kobj, "stats");
+       err = kobject_init_and_add(&srv_path->stats->kobj_stats, &ktype_stats,
+                                  &srv_path->kobj, "stats");
        if (err) {
                rtrs_err(s, "kobject_init_and_add(): %d\n", err);
-               kobject_put(&sess->stats->kobj_stats);
+               kobject_put(&srv_path->stats->kobj_stats);
                return err;
        }
-       err = sysfs_create_group(&sess->stats->kobj_stats,
+       err = sysfs_create_group(&srv_path->stats->kobj_stats,
                                 &rtrs_srv_stats_attr_group);
        if (err) {
                rtrs_err(s, "sysfs_create_group(): %d\n", err);
@@ -249,64 +250,64 @@ static int rtrs_srv_create_stats_files(struct rtrs_srv_sess *sess)
        return 0;
 
 err:
-       kobject_del(&sess->stats->kobj_stats);
-       kobject_put(&sess->stats->kobj_stats);
+       kobject_del(&srv_path->stats->kobj_stats);
+       kobject_put(&srv_path->stats->kobj_stats);
 
        return err;
 }
 
-int rtrs_srv_create_sess_files(struct rtrs_srv_sess *sess)
+int rtrs_srv_create_path_files(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
-       struct rtrs_path *s = &sess->s;
+       struct rtrs_srv *srv = srv_path->srv;
+       struct rtrs_path *s = &srv_path->s;
        char str[NAME_MAX];
        int err;
        struct rtrs_addr path = {
-               .src = &sess->s.dst_addr,
-               .dst = &sess->s.src_addr,
+               .src = &srv_path->s.dst_addr,
+               .dst = &srv_path->s.src_addr,
        };
 
        rtrs_addr_to_str(&path, str, sizeof(str));
-       err = rtrs_srv_create_once_sysfs_root_folders(sess);
+       err = rtrs_srv_create_once_sysfs_root_folders(srv_path);
        if (err)
                return err;
 
-       err = kobject_init_and_add(&sess->kobj, &ktype, srv->kobj_paths,
+       err = kobject_init_and_add(&srv_path->kobj, &ktype, srv->kobj_paths,
                                   "%s", str);
        if (err) {
                rtrs_err(s, "kobject_init_and_add(): %d\n", err);
                goto destroy_root;
        }
-       err = sysfs_create_group(&sess->kobj, &rtrs_srv_sess_attr_group);
+       err = sysfs_create_group(&srv_path->kobj, &rtrs_srv_path_attr_group);
        if (err) {
                rtrs_err(s, "sysfs_create_group(): %d\n", err);
                goto put_kobj;
        }
-       err = rtrs_srv_create_stats_files(sess);
+       err = rtrs_srv_create_stats_files(srv_path);
        if (err)
                goto remove_group;
 
        return 0;
 
 remove_group:
-       sysfs_remove_group(&sess->kobj, &rtrs_srv_sess_attr_group);
+       sysfs_remove_group(&srv_path->kobj, &rtrs_srv_path_attr_group);
 put_kobj:
-       kobject_del(&sess->kobj);
+       kobject_del(&srv_path->kobj);
 destroy_root:
-       kobject_put(&sess->kobj);
-       rtrs_srv_destroy_once_sysfs_root_folders(sess);
+       kobject_put(&srv_path->kobj);
+       rtrs_srv_destroy_once_sysfs_root_folders(srv_path);
 
        return err;
 }
 
-void rtrs_srv_destroy_sess_files(struct rtrs_srv_sess *sess)
+void rtrs_srv_destroy_path_files(struct rtrs_srv_path *srv_path)
 {
-       if (sess->kobj.state_in_sysfs) {
-               kobject_del(&sess->stats->kobj_stats);
-               kobject_put(&sess->stats->kobj_stats);
-               sysfs_remove_group(&sess->kobj, &rtrs_srv_sess_attr_group);
-               kobject_put(&sess->kobj);
+       if (srv_path->kobj.state_in_sysfs) {
+               kobject_del(&srv_path->stats->kobj_stats);
+               kobject_put(&srv_path->stats->kobj_stats);
+               sysfs_remove_group(&srv_path->kobj, &rtrs_srv_path_attr_group);
+               kobject_put(&srv_path->kobj);
 
-               rtrs_srv_destroy_once_sysfs_root_folders(sess);
+               rtrs_srv_destroy_once_sysfs_root_folders(srv_path);
        }
 }

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv.c b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
index de4f214..1ca31b9 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-srv.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
@@ -62,19 +62,19 @@ static inline struct rtrs_srv_con *to_srv_con(struct rtrs_con *c)
        return container_of(c, struct rtrs_srv_con, c);
 }
 
-static inline struct rtrs_srv_sess *to_srv_sess(struct rtrs_path *s)
+static inline struct rtrs_srv_path *to_srv_path(struct rtrs_path *s)
 {
-       return container_of(s, struct rtrs_srv_sess, s);
+       return container_of(s, struct rtrs_srv_path, s);
 }
 
-static bool rtrs_srv_change_state(struct rtrs_srv_sess *sess,
+static bool rtrs_srv_change_state(struct rtrs_srv_path *srv_path,
                                  enum rtrs_srv_state new_state)
 {
        enum rtrs_srv_state old_state;
        bool changed = false;
 
-       spin_lock_irq(&sess->state_lock);
-       old_state = sess->state;
+       spin_lock_irq(&srv_path->state_lock);
+       old_state = srv_path->state;
        switch (new_state) {
        case RTRS_SRV_CONNECTED:
                if (old_state == RTRS_SRV_CONNECTING)
@@ -93,8 +93,8 @@ static bool rtrs_srv_change_state(struct rtrs_srv_sess *sess,
                break;
        }
        if (changed)
-               sess->state = new_state;
-       spin_unlock_irq(&sess->state_lock);
+               srv_path->state = new_state;
+       spin_unlock_irq(&srv_path->state_lock);
 
        return changed;
 }
@@ -106,16 +106,16 @@ static void free_id(struct rtrs_srv_op *id)
        kfree(id);
 }
 
-static void rtrs_srv_free_ops_ids(struct rtrs_srv_sess *sess)
+static void rtrs_srv_free_ops_ids(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
        int i;
 
-       if (sess->ops_ids) {
+       if (srv_path->ops_ids) {
                for (i = 0; i < srv->queue_depth; i++)
-                       free_id(sess->ops_ids[i]);
-               kfree(sess->ops_ids);
-               sess->ops_ids = NULL;
+                       free_id(srv_path->ops_ids[i]);
+               kfree(srv_path->ops_ids);
+               srv_path->ops_ids = NULL;
        }
 }
 
@@ -127,21 +127,24 @@ static struct ib_cqe io_comp_cqe = {
 
 static inline void rtrs_srv_inflight_ref_release(struct percpu_ref *ref)
 {
-       struct rtrs_srv_sess *sess = container_of(ref, struct rtrs_srv_sess, ids_inflight_ref);
+       struct rtrs_srv_path *srv_path = container_of(ref,
+                                                     struct rtrs_srv_path,
+                                                     ids_inflight_ref);
 
-       percpu_ref_exit(&sess->ids_inflight_ref);
-       complete(&sess->complete_done);
+       percpu_ref_exit(&srv_path->ids_inflight_ref);
+       complete(&srv_path->complete_done);
 }
 
-static int rtrs_srv_alloc_ops_ids(struct rtrs_srv_sess *sess)
+static int rtrs_srv_alloc_ops_ids(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
        struct rtrs_srv_op *id;
        int i, ret;
 
-       sess->ops_ids = kcalloc(srv->queue_depth, sizeof(*sess->ops_ids),
-                               GFP_KERNEL);
-       if (!sess->ops_ids)
+       srv_path->ops_ids = kcalloc(srv->queue_depth,
+                                   sizeof(*srv_path->ops_ids),
+                                   GFP_KERNEL);
+       if (!srv_path->ops_ids)
                goto err;
 
        for (i = 0; i < srv->queue_depth; ++i) {
@@ -149,44 +152,44 @@ static int rtrs_srv_alloc_ops_ids(struct rtrs_srv_sess *sess)
                if (!id)
                        goto err;
 
-               sess->ops_ids[i] = id;
+               srv_path->ops_ids[i] = id;
        }
 
-       ret = percpu_ref_init(&sess->ids_inflight_ref,
+       ret = percpu_ref_init(&srv_path->ids_inflight_ref,
                              rtrs_srv_inflight_ref_release, 0, GFP_KERNEL);
        if (ret) {
                pr_err("Percpu reference init failed\n");
                goto err;
        }
-       init_completion(&sess->complete_done);
+       init_completion(&srv_path->complete_done);
 
        return 0;
 
 err:
-       rtrs_srv_free_ops_ids(sess);
+       rtrs_srv_free_ops_ids(srv_path);
        return -ENOMEM;
 }
 
-static inline void rtrs_srv_get_ops_ids(struct rtrs_srv_sess *sess)
+static inline void rtrs_srv_get_ops_ids(struct rtrs_srv_path *srv_path)
 {
-       percpu_ref_get(&sess->ids_inflight_ref);
+       percpu_ref_get(&srv_path->ids_inflight_ref);
 }
 
-static inline void rtrs_srv_put_ops_ids(struct rtrs_srv_sess *sess)
+static inline void rtrs_srv_put_ops_ids(struct rtrs_srv_path *srv_path)
 {
-       percpu_ref_put(&sess->ids_inflight_ref);
+       percpu_ref_put(&srv_path->ids_inflight_ref);
 }
 
 static void rtrs_srv_reg_mr_done(struct ib_cq *cq, struct ib_wc *wc)
 {
        struct rtrs_srv_con *con = to_srv_con(wc->qp->qp_context);
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
 
        if (wc->status != IB_WC_SUCCESS) {
                rtrs_err(s, "REG MR failed: %s\n",
                          ib_wc_status_msg(wc->status));
-               close_sess(sess);
+               close_path(srv_path);
                return;
        }
 }
@@ -198,8 +201,8 @@ static struct ib_cqe local_reg_cqe = {
 static int rdma_write_sg(struct rtrs_srv_op *id)
 {
        struct rtrs_path *s = id->con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
-       dma_addr_t dma_addr = sess->dma_addr[id->msg_id];
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
+       dma_addr_t dma_addr = srv_path->dma_addr[id->msg_id];
        struct rtrs_srv_mr *srv_mr;
        struct ib_send_wr inv_wr;
        struct ib_rdma_wr imm_wr;
@@ -233,7 +236,7 @@ static int rdma_write_sg(struct rtrs_srv_op *id)
                return -EINVAL;
        }
 
-       plist->lkey = sess->s.dev->ib_pd->local_dma_lkey;
+       plist->lkey = srv_path->s.dev->ib_pd->local_dma_lkey;
        offset += plist->length;
 
        wr->wr.sg_list  = plist;
@@ -284,7 +287,7 @@ static int rdma_write_sg(struct rtrs_srv_op *id)
        if (always_invalidate) {
                struct rtrs_msg_rkey_rsp *msg;
 
-               srv_mr = &sess->mrs[id->msg_id];
+               srv_mr = &srv_path->mrs[id->msg_id];
                rwr.wr.opcode = IB_WR_REG_MR;
                rwr.wr.wr_cqe = &local_reg_cqe;
                rwr.wr.num_sge = 0;
@@ -300,11 +303,11 @@ static int rdma_write_sg(struct rtrs_srv_op *id)
 
                list.addr   = srv_mr->iu->dma_addr;
                list.length = sizeof(*msg);
-               list.lkey   = sess->s.dev->ib_pd->local_dma_lkey;
+               list.lkey   = srv_path->s.dev->ib_pd->local_dma_lkey;
                imm_wr.wr.sg_list = &list;
                imm_wr.wr.num_sge = 1;
                imm_wr.wr.opcode = IB_WR_SEND_WITH_IMM;
-               ib_dma_sync_single_for_device(sess->s.dev->ib_dev,
+               ib_dma_sync_single_for_device(srv_path->s.dev->ib_dev,
                                              srv_mr->iu->dma_addr,
                                              srv_mr->iu->size, DMA_TO_DEVICE);
        } else {
@@ -317,7 +320,7 @@ static int rdma_write_sg(struct rtrs_srv_op *id)
                                                             0, need_inval));
 
        imm_wr.wr.wr_cqe   = &io_comp_cqe;
-       ib_dma_sync_single_for_device(sess->s.dev->ib_dev, dma_addr,
+       ib_dma_sync_single_for_device(srv_path->s.dev->ib_dev, dma_addr,
                                      offset, DMA_BIDIRECTIONAL);
 
        err = ib_post_send(id->con->c.qp, &id->tx_wr.wr, NULL);
@@ -342,7 +345,7 @@ static int send_io_resp_imm(struct rtrs_srv_con *con, struct rtrs_srv_op *id,
                            int errno)
 {
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
        struct ib_send_wr inv_wr, *wr = NULL;
        struct ib_rdma_wr imm_wr;
        struct ib_reg_wr rwr;
@@ -402,7 +405,7 @@ static int send_io_resp_imm(struct rtrs_srv_con *con, struct rtrs_srv_op *id,
                struct ib_sge list;
                struct rtrs_msg_rkey_rsp *msg;
 
-               srv_mr = &sess->mrs[id->msg_id];
+               srv_mr = &srv_path->mrs[id->msg_id];
                rwr.wr.next = &imm_wr.wr;
                rwr.wr.opcode = IB_WR_REG_MR;
                rwr.wr.wr_cqe = &local_reg_cqe;
@@ -419,11 +422,11 @@ static int send_io_resp_imm(struct rtrs_srv_con *con, struct rtrs_srv_op *id,
 
                list.addr   = srv_mr->iu->dma_addr;
                list.length = sizeof(*msg);
-               list.lkey   = sess->s.dev->ib_pd->local_dma_lkey;
+               list.lkey   = srv_path->s.dev->ib_pd->local_dma_lkey;
                imm_wr.wr.sg_list = &list;
                imm_wr.wr.num_sge = 1;
                imm_wr.wr.opcode = IB_WR_SEND_WITH_IMM;
-               ib_dma_sync_single_for_device(sess->s.dev->ib_dev,
+               ib_dma_sync_single_for_device(srv_path->s.dev->ib_dev,
                                              srv_mr->iu->dma_addr,
                                              srv_mr->iu->size, DMA_TO_DEVICE);
        } else {
@@ -444,11 +447,11 @@ static int send_io_resp_imm(struct rtrs_srv_con *con, struct rtrs_srv_op *id,
        return err;
 }
 
-void close_sess(struct rtrs_srv_sess *sess)
+void close_path(struct rtrs_srv_path *srv_path)
 {
-       if (rtrs_srv_change_state(sess, RTRS_SRV_CLOSING))
-               queue_work(rtrs_wq, &sess->close_work);
-       WARN_ON(sess->state != RTRS_SRV_CLOSING);
+       if (rtrs_srv_change_state(srv_path, RTRS_SRV_CLOSING))
+               queue_work(rtrs_wq, &srv_path->close_work);
+       WARN_ON(srv_path->state != RTRS_SRV_CLOSING);
 }
 
 static inline const char *rtrs_srv_state_str(enum rtrs_srv_state state)
@@ -480,7 +483,7 @@ static inline const char *rtrs_srv_state_str(enum rtrs_srv_state state)
  */
 bool rtrs_srv_resp_rdma(struct rtrs_srv_op *id, int status)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        struct rtrs_srv_con *con;
        struct rtrs_path *s;
        int err;
@@ -490,25 +493,25 @@ bool rtrs_srv_resp_rdma(struct rtrs_srv_op *id, int status)
 
        con = id->con;
        s = con->c.path;
-       sess = to_srv_sess(s);
+       srv_path = to_srv_path(s);
 
        id->status = status;
 
-       if (sess->state != RTRS_SRV_CONNECTED) {
+       if (srv_path->state != RTRS_SRV_CONNECTED) {
                rtrs_err_rl(s,
-                           "Sending I/O response failed,  session %s is disconnected, sess state %s\n",
-                           kobject_name(&sess->kobj),
-                           rtrs_srv_state_str(sess->state));
+                           "Sending I/O response failed,  server path %s is disconnected, path state %s\n",
+                           kobject_name(&srv_path->kobj),
+                           rtrs_srv_state_str(srv_path->state));
                goto out;
        }
        if (always_invalidate) {
-               struct rtrs_srv_mr *mr = &sess->mrs[id->msg_id];
+               struct rtrs_srv_mr *mr = &srv_path->mrs[id->msg_id];
 
                ib_update_fast_reg_key(mr->mr, ib_inc_rkey(mr->mr->rkey));
        }
        if (atomic_sub_return(1, &con->c.sq_wr_avail) < 0) {
-               rtrs_err(s, "IB send queue full: sess=%s cid=%d\n",
-                        kobject_name(&sess->kobj),
+               rtrs_err(s, "IB send queue full: srv_path=%s cid=%d\n",
+                        kobject_name(&srv_path->kobj),
                         con->c.cid);
                atomic_add(1, &con->c.sq_wr_avail);
                spin_lock(&con->rsp_wr_wait_lock);
@@ -523,12 +526,12 @@ bool rtrs_srv_resp_rdma(struct rtrs_srv_op *id, int status)
                err = rdma_write_sg(id);
 
        if (err) {
-               rtrs_err_rl(s, "IO response failed: %d: sess=%s\n", err,
-                           kobject_name(&sess->kobj));
-               close_sess(sess);
+               rtrs_err_rl(s, "IO response failed: %d: srv_path=%s\n", err,
+                           kobject_name(&srv_path->kobj));
+               close_path(srv_path);
        }
 out:
-       rtrs_srv_put_ops_ids(sess);
+       rtrs_srv_put_ops_ids(srv_path);
        return true;
 }
 EXPORT_SYMBOL(rtrs_srv_resp_rdma);
@@ -544,27 +547,27 @@ void rtrs_srv_set_sess_priv(struct rtrs_srv *srv, void *priv)
 }
 EXPORT_SYMBOL(rtrs_srv_set_sess_priv);
 
-static void unmap_cont_bufs(struct rtrs_srv_sess *sess)
+static void unmap_cont_bufs(struct rtrs_srv_path *srv_path)
 {
        int i;
 
-       for (i = 0; i < sess->mrs_num; i++) {
+       for (i = 0; i < srv_path->mrs_num; i++) {
                struct rtrs_srv_mr *srv_mr;
 
-               srv_mr = &sess->mrs[i];
-               rtrs_iu_free(srv_mr->iu, sess->s.dev->ib_dev, 1);
+               srv_mr = &srv_path->mrs[i];
+               rtrs_iu_free(srv_mr->iu, srv_path->s.dev->ib_dev, 1);
                ib_dereg_mr(srv_mr->mr);
-               ib_dma_unmap_sg(sess->s.dev->ib_dev, srv_mr->sgt.sgl,
+               ib_dma_unmap_sg(srv_path->s.dev->ib_dev, srv_mr->sgt.sgl,
                                srv_mr->sgt.nents, DMA_BIDIRECTIONAL);
                sg_free_table(&srv_mr->sgt);
        }
-       kfree(sess->mrs);
+       kfree(srv_path->mrs);
 }
 
-static int map_cont_bufs(struct rtrs_srv_sess *sess)
+static int map_cont_bufs(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
-       struct rtrs_path *ss = &sess->s;
+       struct rtrs_srv *srv = srv_path->srv;
+       struct rtrs_path *ss = &srv_path->s;
        int i, mri, err, mrs_num;
        unsigned int chunk_bits;
        int chunks_per_mr = 1;
@@ -581,19 +584,19 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
                mrs_num = srv->queue_depth;
        } else {
                chunks_per_mr =
-                       sess->s.dev->ib_dev->attrs.max_fast_reg_page_list_len;
+                       srv_path->s.dev->ib_dev->attrs.max_fast_reg_page_list_len;
                mrs_num = DIV_ROUND_UP(srv->queue_depth, chunks_per_mr);
                chunks_per_mr = DIV_ROUND_UP(srv->queue_depth, mrs_num);
        }
 
-       sess->mrs = kcalloc(mrs_num, sizeof(*sess->mrs), GFP_KERNEL);
-       if (!sess->mrs)
+       srv_path->mrs = kcalloc(mrs_num, sizeof(*srv_path->mrs), GFP_KERNEL);
+       if (!srv_path->mrs)
                return -ENOMEM;
 
-       sess->mrs_num = mrs_num;
+       srv_path->mrs_num = mrs_num;
 
        for (mri = 0; mri < mrs_num; mri++) {
-               struct rtrs_srv_mr *srv_mr = &sess->mrs[mri];
+               struct rtrs_srv_mr *srv_mr = &srv_path->mrs[mri];
                struct sg_table *sgt = &srv_mr->sgt;
                struct scatterlist *s;
                struct ib_mr *mr;
@@ -612,13 +615,13 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
                        sg_set_page(s, srv->chunks[chunks + i],
                                    max_chunk_size, 0);
 
-               nr = ib_dma_map_sg(sess->s.dev->ib_dev, sgt->sgl,
+               nr = ib_dma_map_sg(srv_path->s.dev->ib_dev, sgt->sgl,
                                   sgt->nents, DMA_BIDIRECTIONAL);
                if (nr < sgt->nents) {
                        err = nr < 0 ? nr : -EINVAL;
                        goto free_sg;
                }
-               mr = ib_alloc_mr(sess->s.dev->ib_pd, IB_MR_TYPE_MEM_REG,
+               mr = ib_alloc_mr(srv_path->s.dev->ib_pd, IB_MR_TYPE_MEM_REG,
                                 sgt->nents);
                if (IS_ERR(mr)) {
                        err = PTR_ERR(mr);
@@ -634,7 +637,7 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
                if (always_invalidate) {
                        srv_mr->iu = rtrs_iu_alloc(1,
                                        sizeof(struct rtrs_msg_rkey_rsp),
-                                       GFP_KERNEL, sess->s.dev->ib_dev,
+                                       GFP_KERNEL, srv_path->s.dev->ib_dev,
                                        DMA_TO_DEVICE, rtrs_srv_rdma_done);
                        if (!srv_mr->iu) {
                                err = -ENOMEM;
@@ -644,7 +647,7 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
                }
                /* Eventually dma addr for each chunk can be cached */
                for_each_sg(sgt->sgl, s, sgt->orig_nents, i)
-                       sess->dma_addr[chunks + i] = sg_dma_address(s);
+                       srv_path->dma_addr[chunks + i] = sg_dma_address(s);
 
                ib_update_fast_reg_key(mr, ib_inc_rkey(mr->rkey));
                srv_mr->mr = mr;
@@ -652,75 +655,75 @@ static int map_cont_bufs(struct rtrs_srv_sess *sess)
                continue;
 err:
                while (mri--) {
-                       srv_mr = &sess->mrs[mri];
+                       srv_mr = &srv_path->mrs[mri];
                        sgt = &srv_mr->sgt;
                        mr = srv_mr->mr;
-                       rtrs_iu_free(srv_mr->iu, sess->s.dev->ib_dev, 1);
+                       rtrs_iu_free(srv_mr->iu, srv_path->s.dev->ib_dev, 1);
 dereg_mr:
                        ib_dereg_mr(mr);
 unmap_sg:
-                       ib_dma_unmap_sg(sess->s.dev->ib_dev, sgt->sgl,
+                       ib_dma_unmap_sg(srv_path->s.dev->ib_dev, sgt->sgl,
                                        sgt->nents, DMA_BIDIRECTIONAL);
 free_sg:
                        sg_free_table(sgt);
                }
-               kfree(sess->mrs);
+               kfree(srv_path->mrs);
 
                return err;
        }
 
        chunk_bits = ilog2(srv->queue_depth - 1) + 1;
-       sess->mem_bits = (MAX_IMM_PAYL_BITS - chunk_bits);
+       srv_path->mem_bits = (MAX_IMM_PAYL_BITS - chunk_bits);
 
        return 0;
 }
 
 static void rtrs_srv_hb_err_handler(struct rtrs_con *c)
 {
-       close_sess(to_srv_sess(c->path));
+       close_path(to_srv_path(c->path));
 }
 
-static void rtrs_srv_init_hb(struct rtrs_srv_sess *sess)
+static void rtrs_srv_init_hb(struct rtrs_srv_path *srv_path)
 {
-       rtrs_init_hb(&sess->s, &io_comp_cqe,
+       rtrs_init_hb(&srv_path->s, &io_comp_cqe,
                      RTRS_HB_INTERVAL_MS,
                      RTRS_HB_MISSED_MAX,
                      rtrs_srv_hb_err_handler,
                      rtrs_wq);
 }
 
-static void rtrs_srv_start_hb(struct rtrs_srv_sess *sess)
+static void rtrs_srv_start_hb(struct rtrs_srv_path *srv_path)
 {
-       rtrs_start_hb(&sess->s);
+       rtrs_start_hb(&srv_path->s);
 }
 
-static void rtrs_srv_stop_hb(struct rtrs_srv_sess *sess)
+static void rtrs_srv_stop_hb(struct rtrs_srv_path *srv_path)
 {
-       rtrs_stop_hb(&sess->s);
+       rtrs_stop_hb(&srv_path->s);
 }
 
 static void rtrs_srv_info_rsp_done(struct ib_cq *cq, struct ib_wc *wc)
 {
        struct rtrs_srv_con *con = to_srv_con(wc->qp->qp_context);
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
        struct rtrs_iu *iu;
 
        iu = container_of(wc->wr_cqe, struct rtrs_iu, cqe);
-       rtrs_iu_free(iu, sess->s.dev->ib_dev, 1);
+       rtrs_iu_free(iu, srv_path->s.dev->ib_dev, 1);
 
        if (wc->status != IB_WC_SUCCESS) {
                rtrs_err(s, "Sess info response send failed: %s\n",
                          ib_wc_status_msg(wc->status));
-               close_sess(sess);
+               close_path(srv_path);
                return;
        }
        WARN_ON(wc->opcode != IB_WC_SEND);
 }
 
-static void rtrs_srv_sess_up(struct rtrs_srv_sess *sess)
+static void rtrs_srv_path_up(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
        struct rtrs_srv_ctx *ctx = srv->ctx;
        int up;
 
@@ -731,18 +734,18 @@ static void rtrs_srv_sess_up(struct rtrs_srv_sess *sess)
        mutex_unlock(&srv->paths_ev_mutex);
 
        /* Mark session as established */
-       sess->established = true;
+       srv_path->established = true;
 }
 
-static void rtrs_srv_sess_down(struct rtrs_srv_sess *sess)
+static void rtrs_srv_path_down(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
        struct rtrs_srv_ctx *ctx = srv->ctx;
 
-       if (!sess->established)
+       if (!srv_path->established)
                return;
 
-       sess->established = false;
+       srv_path->established = false;
        mutex_lock(&srv->paths_ev_mutex);
        WARN_ON(!srv->paths_up);
        if (--srv->paths_up == 0)
@@ -750,11 +753,11 @@ static void rtrs_srv_sess_down(struct rtrs_srv_sess *sess)
        mutex_unlock(&srv->paths_ev_mutex);
 }
 
-static bool exist_sessname(struct rtrs_srv_ctx *ctx,
-                          const char *sessname, const uuid_t *path_uuid)
+static bool exist_pathname(struct rtrs_srv_ctx *ctx,
+                          const char *pathname, const uuid_t *path_uuid)
 {
        struct rtrs_srv *srv;
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        bool found = false;
 
        mutex_lock(&ctx->srv_mutex);
@@ -767,9 +770,9 @@ static bool exist_sessname(struct rtrs_srv_ctx *ctx,
                        continue;
                }
 
-               list_for_each_entry(sess, &srv->paths_list, s.entry) {
-                       if (strlen(sess->s.sessname) == strlen(sessname) &&
-                           !strcmp(sess->s.sessname, sessname)) {
+               list_for_each_entry(srv_path, &srv->paths_list, s.entry) {
+                       if (strlen(srv_path->s.sessname) == strlen(pathname) &&
+                           !strcmp(srv_path->s.sessname, pathname)) {
                                found = true;
                                break;
                        }
@@ -782,14 +785,14 @@ static bool exist_sessname(struct rtrs_srv_ctx *ctx,
        return found;
 }
 
-static int post_recv_sess(struct rtrs_srv_sess *sess);
+static int post_recv_path(struct rtrs_srv_path *srv_path);
 static int rtrs_rdma_do_reject(struct rdma_cm_id *cm_id, int errno);
 
 static int process_info_req(struct rtrs_srv_con *con,
                            struct rtrs_msg_info_req *msg)
 {
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
        struct ib_send_wr *reg_wr = NULL;
        struct rtrs_msg_info_rsp *rsp;
        struct rtrs_iu *tx_iu;
@@ -797,31 +800,32 @@ static int process_info_req(struct rtrs_srv_con *con,
        int mri, err;
        size_t tx_sz;
 
-       err = post_recv_sess(sess);
+       err = post_recv_path(srv_path);
        if (err) {
-               rtrs_err(s, "post_recv_sess(), err: %d\n", err);
+               rtrs_err(s, "post_recv_path(), err: %d\n", err);
                return err;
        }
 
-       if (strchr(msg->sessname, '/') || strchr(msg->sessname, '.')) {
-               rtrs_err(s, "sessname cannot contain / and .\n");
+       if (strchr(msg->pathname, '/') || strchr(msg->pathname, '.')) {
+               rtrs_err(s, "pathname cannot contain / and .\n");
                return -EINVAL;
        }
 
-       if (exist_sessname(sess->srv->ctx,
-                          msg->sessname, &sess->srv->paths_uuid)) {
-               rtrs_err(s, "sessname is duplicated: %s\n", msg->sessname);
+       if (exist_pathname(srv_path->srv->ctx,
+                          msg->pathname, &srv_path->srv->paths_uuid)) {
+               rtrs_err(s, "pathname is duplicated: %s\n", msg->pathname);
                return -EPERM;
        }
-       strscpy(sess->s.sessname, msg->sessname, sizeof(sess->s.sessname));
+       strscpy(srv_path->s.sessname, msg->pathname,
+               sizeof(srv_path->s.sessname));
 
-       rwr = kcalloc(sess->mrs_num, sizeof(*rwr), GFP_KERNEL);
+       rwr = kcalloc(srv_path->mrs_num, sizeof(*rwr), GFP_KERNEL);
        if (!rwr)
                return -ENOMEM;
 
        tx_sz  = sizeof(*rsp);
-       tx_sz += sizeof(rsp->desc[0]) * sess->mrs_num;
-       tx_iu = rtrs_iu_alloc(1, tx_sz, GFP_KERNEL, sess->s.dev->ib_dev,
+       tx_sz += sizeof(rsp->desc[0]) * srv_path->mrs_num;
+       tx_iu = rtrs_iu_alloc(1, tx_sz, GFP_KERNEL, srv_path->s.dev->ib_dev,
                               DMA_TO_DEVICE, rtrs_srv_info_rsp_done);
        if (!tx_iu) {
                err = -ENOMEM;
@@ -830,10 +834,10 @@ static int process_info_req(struct rtrs_srv_con *con,
 
        rsp = tx_iu->buf;
        rsp->type = cpu_to_le16(RTRS_MSG_INFO_RSP);
-       rsp->sg_cnt = cpu_to_le16(sess->mrs_num);
+       rsp->sg_cnt = cpu_to_le16(srv_path->mrs_num);
 
-       for (mri = 0; mri < sess->mrs_num; mri++) {
-               struct ib_mr *mr = sess->mrs[mri].mr;
+       for (mri = 0; mri < srv_path->mrs_num; mri++) {
+               struct ib_mr *mr = srv_path->mrs[mri].mr;
 
                rsp->desc[mri].addr = cpu_to_le64(mr->iova);
                rsp->desc[mri].key  = cpu_to_le32(mr->rkey);
@@ -854,13 +858,13 @@ static int process_info_req(struct rtrs_srv_con *con,
                reg_wr = &rwr[mri].wr;
        }
 
-       err = rtrs_srv_create_sess_files(sess);
+       err = rtrs_srv_create_path_files(srv_path);
        if (err)
                goto iu_free;
-       kobject_get(&sess->kobj);
-       get_device(&sess->srv->dev);
-       rtrs_srv_change_state(sess, RTRS_SRV_CONNECTED);
-       rtrs_srv_start_hb(sess);
+       kobject_get(&srv_path->kobj);
+       get_device(&srv_path->srv->dev);
+       rtrs_srv_change_state(srv_path, RTRS_SRV_CONNECTED);
+       rtrs_srv_start_hb(srv_path);
 
        /*
         * We do not account number of established connections at the current
@@ -868,9 +872,10 @@ static int process_info_req(struct rtrs_srv_con *con,
         * all connections are successfully established.  Thus, simply notify
         * listener with a proper event if we are the first path.
         */
-       rtrs_srv_sess_up(sess);
+       rtrs_srv_path_up(srv_path);
 
-       ib_dma_sync_single_for_device(sess->s.dev->ib_dev, tx_iu->dma_addr,
+       ib_dma_sync_single_for_device(srv_path->s.dev->ib_dev,
+                                     tx_iu->dma_addr,
                                      tx_iu->size, DMA_TO_DEVICE);
 
        /* Send info response */
@@ -878,7 +883,7 @@ static int process_info_req(struct rtrs_srv_con *con,
        if (err) {
                rtrs_err(s, "rtrs_iu_post_send(), err: %d\n", err);
 iu_free:
-               rtrs_iu_free(tx_iu, sess->s.dev->ib_dev, 1);
+               rtrs_iu_free(tx_iu, srv_path->s.dev->ib_dev, 1);
        }
 rwr_free:
        kfree(rwr);
@@ -890,7 +895,7 @@ static void rtrs_srv_info_req_done(struct ib_cq *cq, struct ib_wc *wc)
 {
        struct rtrs_srv_con *con = to_srv_con(wc->qp->qp_context);
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
        struct rtrs_msg_info_req *msg;
        struct rtrs_iu *iu;
        int err;
@@ -910,7 +915,7 @@ static void rtrs_srv_info_req_done(struct ib_cq *cq, struct ib_wc *wc)
                          wc->byte_len);
                goto close;
        }
-       ib_dma_sync_single_for_cpu(sess->s.dev->ib_dev, iu->dma_addr,
+       ib_dma_sync_single_for_cpu(srv_path->s.dev->ib_dev, iu->dma_addr,
                                   iu->size, DMA_FROM_DEVICE);
        msg = iu->buf;
        if (le16_to_cpu(msg->type) != RTRS_MSG_INFO_REQ) {
@@ -923,22 +928,22 @@ static void rtrs_srv_info_req_done(struct ib_cq *cq, struct ib_wc *wc)
                goto close;
 
 out:
-       rtrs_iu_free(iu, sess->s.dev->ib_dev, 1);
+       rtrs_iu_free(iu, srv_path->s.dev->ib_dev, 1);
        return;
 close:
-       close_sess(sess);
+       close_path(srv_path);
        goto out;
 }
 
 static int post_recv_info_req(struct rtrs_srv_con *con)
 {
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
        struct rtrs_iu *rx_iu;
        int err;
 
        rx_iu = rtrs_iu_alloc(1, sizeof(struct rtrs_msg_info_req),
-                              GFP_KERNEL, sess->s.dev->ib_dev,
+                              GFP_KERNEL, srv_path->s.dev->ib_dev,
                               DMA_FROM_DEVICE, rtrs_srv_info_req_done);
        if (!rx_iu)
                return -ENOMEM;
@@ -946,7 +951,7 @@ static int post_recv_info_req(struct rtrs_srv_con *con)
        err = rtrs_iu_post_recv(&con->c, rx_iu);
        if (err) {
                rtrs_err(s, "rtrs_iu_post_recv(), err: %d\n", err);
-               rtrs_iu_free(rx_iu, sess->s.dev->ib_dev, 1);
+               rtrs_iu_free(rx_iu, srv_path->s.dev->ib_dev, 1);
                return err;
        }
 
@@ -966,20 +971,20 @@ static int post_recv_io(struct rtrs_srv_con *con, size_t q_size)
        return 0;
 }
 
-static int post_recv_sess(struct rtrs_srv_sess *sess)
+static int post_recv_path(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
-       struct rtrs_path *s = &sess->s;
+       struct rtrs_srv *srv = srv_path->srv;
+       struct rtrs_path *s = &srv_path->s;
        size_t q_size;
        int err, cid;
 
-       for (cid = 0; cid < sess->s.con_num; cid++) {
+       for (cid = 0; cid < srv_path->s.con_num; cid++) {
                if (cid == 0)
                        q_size = SERVICE_CON_QUEUE_DEPTH;
                else
                        q_size = srv->queue_depth;
 
-               err = post_recv_io(to_srv_con(sess->s.con[cid]), q_size);
+               err = post_recv_io(to_srv_con(srv_path->s.con[cid]), q_size);
                if (err) {
                        rtrs_err(s, "post_recv_io(), err: %d\n", err);
                        return err;
@@ -994,8 +999,8 @@ static void process_read(struct rtrs_srv_con *con,
                         u32 buf_id, u32 off)
 {
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
+       struct rtrs_srv *srv = srv_path->srv;
        struct rtrs_srv_ctx *ctx = srv->ctx;
        struct rtrs_srv_op *id;
 
@@ -1003,10 +1008,10 @@ static void process_read(struct rtrs_srv_con *con,
        void *data;
        int ret;
 
-       if (sess->state != RTRS_SRV_CONNECTED) {
+       if (srv_path->state != RTRS_SRV_CONNECTED) {
                rtrs_err_rl(s,
                             "Processing read request failed,  session is disconnected, sess state %s\n",
-                            rtrs_srv_state_str(sess->state));
+                            rtrs_srv_state_str(srv_path->state));
                return;
        }
        if (msg->sg_cnt != 1 && msg->sg_cnt != 0) {
@@ -1014,9 +1019,9 @@ static void process_read(struct rtrs_srv_con *con,
                            "Processing read request failed, invalid message\n");
                return;
        }
-       rtrs_srv_get_ops_ids(sess);
-       rtrs_srv_update_rdma_stats(sess->stats, off, READ);
-       id = sess->ops_ids[buf_id];
+       rtrs_srv_get_ops_ids(srv_path);
+       rtrs_srv_update_rdma_stats(srv_path->stats, off, READ);
+       id = srv_path->ops_ids[buf_id];
        id->con         = con;
        id->dir         = READ;
        id->msg_id      = buf_id;
@@ -1042,9 +1047,9 @@ send_err_msg:
                rtrs_err_rl(s,
                             "Sending err msg for failed RDMA-Write-Req failed, msg_id %d, err: %d\n",
                             buf_id, ret);
-               close_sess(sess);
+               close_path(srv_path);
        }
-       rtrs_srv_put_ops_ids(sess);
+       rtrs_srv_put_ops_ids(srv_path);
 }
 
 static void process_write(struct rtrs_srv_con *con,
@@ -1052,8 +1057,8 @@ static void process_write(struct rtrs_srv_con *con,
                          u32 buf_id, u32 off)
 {
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
+       struct rtrs_srv *srv = srv_path->srv;
        struct rtrs_srv_ctx *ctx = srv->ctx;
        struct rtrs_srv_op *id;
 
@@ -1061,15 +1066,15 @@ static void process_write(struct rtrs_srv_con *con,
        void *data;
        int ret;
 
-       if (sess->state != RTRS_SRV_CONNECTED) {
+       if (srv_path->state != RTRS_SRV_CONNECTED) {
                rtrs_err_rl(s,
                             "Processing write request failed,  session is disconnected, sess state %s\n",
-                            rtrs_srv_state_str(sess->state));
+                            rtrs_srv_state_str(srv_path->state));
                return;
        }
-       rtrs_srv_get_ops_ids(sess);
-       rtrs_srv_update_rdma_stats(sess->stats, off, WRITE);
-       id = sess->ops_ids[buf_id];
+       rtrs_srv_get_ops_ids(srv_path);
+       rtrs_srv_update_rdma_stats(srv_path->stats, off, WRITE);
+       id = srv_path->ops_ids[buf_id];
        id->con    = con;
        id->dir    = WRITE;
        id->msg_id = buf_id;
@@ -1094,20 +1099,21 @@ send_err_msg:
                rtrs_err_rl(s,
                             "Processing write request failed, sending I/O response failed, msg_id %d, err: %d\n",
                             buf_id, ret);
-               close_sess(sess);
+               close_path(srv_path);
        }
-       rtrs_srv_put_ops_ids(sess);
+       rtrs_srv_put_ops_ids(srv_path);
 }
 
 static void process_io_req(struct rtrs_srv_con *con, void *msg,
                           u32 id, u32 off)
 {
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
        struct rtrs_msg_rdma_hdr *hdr;
        unsigned int type;
 
-       ib_dma_sync_single_for_cpu(sess->s.dev->ib_dev, sess->dma_addr[id],
+       ib_dma_sync_single_for_cpu(srv_path->s.dev->ib_dev,
+                                  srv_path->dma_addr[id],
                                   max_chunk_size, DMA_BIDIRECTIONAL);
        hdr = msg;
        type = le16_to_cpu(hdr->type);
@@ -1129,7 +1135,7 @@ static void process_io_req(struct rtrs_srv_con *con, void *msg,
        return;
 
 err:
-       close_sess(sess);
+       close_path(srv_path);
 }
 
 static void rtrs_srv_inv_rkey_done(struct ib_cq *cq, struct ib_wc *wc)
@@ -1138,15 +1144,15 @@ static void rtrs_srv_inv_rkey_done(struct ib_cq *cq, struct ib_wc *wc)
                container_of(wc->wr_cqe, typeof(*mr), inv_cqe);
        struct rtrs_srv_con *con = to_srv_con(wc->qp->qp_context);
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
+       struct rtrs_srv *srv = srv_path->srv;
        u32 msg_id, off;
        void *data;
 
        if (wc->status != IB_WC_SUCCESS) {
                rtrs_err(s, "Failed IB_WR_LOCAL_INV: %s\n",
                          ib_wc_status_msg(wc->status));
-               close_sess(sess);
+               close_path(srv_path);
        }
        msg_id = mr->msg_id;
        off = mr->msg_off;
@@ -1195,8 +1201,8 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
 {
        struct rtrs_srv_con *con = to_srv_con(wc->qp->qp_context);
        struct rtrs_path *s = con->c.path;
-       struct rtrs_srv_sess *sess = to_srv_sess(s);
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv_path *srv_path = to_srv_path(s);
+       struct rtrs_srv *srv = srv_path->srv;
        u32 imm_type, imm_payload;
        int err;
 
@@ -1206,7 +1212,7 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                                  "%s (wr_cqe: %p, type: %d, vendor_err: 0x%x, len: %u)\n",
                                  ib_wc_status_msg(wc->status), wc->wr_cqe,
                                  wc->opcode, wc->vendor_err, wc->byte_len);
-                       close_sess(sess);
+                       close_path(srv_path);
                }
                return;
        }
@@ -1222,7 +1228,7 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                err = rtrs_post_recv_empty(&con->c, &io_comp_cqe);
                if (err) {
                        rtrs_err(s, "rtrs_post_recv(), err: %d\n", err);
-                       close_sess(sess);
+                       close_path(srv_path);
                        break;
                }
                rtrs_from_imm(be32_to_cpu(wc->ex.imm_data),
@@ -1231,16 +1237,16 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                        u32 msg_id, off;
                        void *data;
 
-                       msg_id = imm_payload >> sess->mem_bits;
-                       off = imm_payload & ((1 << sess->mem_bits) - 1);
+                       msg_id = imm_payload >> srv_path->mem_bits;
+                       off = imm_payload & ((1 << srv_path->mem_bits) - 1);
                        if (msg_id >= srv->queue_depth || off >= max_chunk_size) {
                                rtrs_err(s, "Wrong msg_id %u, off %u\n",
                                          msg_id, off);
-                               close_sess(sess);
+                               close_path(srv_path);
                                return;
                        }
                        if (always_invalidate) {
-                               struct rtrs_srv_mr *mr = &sess->mrs[msg_id];
+                               struct rtrs_srv_mr *mr = &srv_path->mrs[msg_id];
 
                                mr->msg_off = off;
                                mr->msg_id = msg_id;
@@ -1248,7 +1254,7 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                                if (err) {
                                        rtrs_err(s, "rtrs_post_recv(), err: %d\n",
                                                  err);
-                                       close_sess(sess);
+                                       close_path(srv_path);
                                        break;
                                }
                        } else {
@@ -1257,10 +1263,10 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                        }
                } else if (imm_type == RTRS_HB_MSG_IMM) {
                        WARN_ON(con->c.cid);
-                       rtrs_send_hb_ack(&sess->s);
+                       rtrs_send_hb_ack(&srv_path->s);
                } else if (imm_type == RTRS_HB_ACK_IMM) {
                        WARN_ON(con->c.cid);
-                       sess->s.hb_missed_cnt = 0;
+                       srv_path->s.hb_missed_cnt = 0;
                } else {
                        rtrs_wrn(s, "Unknown IMM type %u\n", imm_type);
                }
@@ -1284,22 +1290,23 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
 }
 
 /**
- * rtrs_srv_get_sess_name() - Get rtrs_srv peer hostname.
+ * rtrs_srv_get_path_name() - Get rtrs_srv peer hostname.
  * @srv:       Session
- * @sessname:  Sessname buffer
+ * @pathname:  Pathname buffer
  * @len:       Length of sessname buffer
  */
-int rtrs_srv_get_sess_name(struct rtrs_srv *srv, char *sessname, size_t len)
+int rtrs_srv_get_path_name(struct rtrs_srv *srv, char *pathname,
+                          size_t len)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        int err = -ENOTCONN;
 
        mutex_lock(&srv->paths_mutex);
-       list_for_each_entry(sess, &srv->paths_list, s.entry) {
-               if (sess->state != RTRS_SRV_CONNECTED)
+       list_for_each_entry(srv_path, &srv->paths_list, s.entry) {
+               if (srv_path->state != RTRS_SRV_CONNECTED)
                        continue;
-               strscpy(sessname, sess->s.sessname,
-                      min_t(size_t, sizeof(sess->s.sessname), len));
+               strscpy(pathname, srv_path->s.sessname,
+                       min_t(size_t, sizeof(srv_path->s.sessname), len));
                err = 0;
                break;
        }
@@ -1307,7 +1314,7 @@ int rtrs_srv_get_sess_name(struct rtrs_srv *srv, char *sessname, size_t len)
 
        return err;
 }
-EXPORT_SYMBOL(rtrs_srv_get_sess_name);
+EXPORT_SYMBOL(rtrs_srv_get_path_name);
 
 /**
  * rtrs_srv_get_queue_depth() - Get rtrs_srv qdepth.
@@ -1319,22 +1326,22 @@ int rtrs_srv_get_queue_depth(struct rtrs_srv *srv)
 }
 EXPORT_SYMBOL(rtrs_srv_get_queue_depth);
 
-static int find_next_bit_ring(struct rtrs_srv_sess *sess)
+static int find_next_bit_ring(struct rtrs_srv_path *srv_path)
 {
-       struct ib_device *ib_dev = sess->s.dev->ib_dev;
+       struct ib_device *ib_dev = srv_path->s.dev->ib_dev;
        int v;
 
-       v = cpumask_next(sess->cur_cq_vector, &cq_affinity_mask);
+       v = cpumask_next(srv_path->cur_cq_vector, &cq_affinity_mask);
        if (v >= nr_cpu_ids || v >= ib_dev->num_comp_vectors)
                v = cpumask_first(&cq_affinity_mask);
        return v;
 }
 
-static int rtrs_srv_get_next_cq_vector(struct rtrs_srv_sess *sess)
+static int rtrs_srv_get_next_cq_vector(struct rtrs_srv_path *srv_path)
 {
-       sess->cur_cq_vector = find_next_bit_ring(sess);
+       srv_path->cur_cq_vector = find_next_bit_ring(srv_path);
 
-       return sess->cur_cq_vector;
+       return srv_path->cur_cq_vector;
 }
 
 static void rtrs_srv_dev_release(struct device *dev)
@@ -1439,22 +1446,22 @@ static void put_srv(struct rtrs_srv *srv)
 }
 
 static void __add_path_to_srv(struct rtrs_srv *srv,
-                             struct rtrs_srv_sess *sess)
+                             struct rtrs_srv_path *srv_path)
 {
-       list_add_tail(&sess->s.entry, &srv->paths_list);
+       list_add_tail(&srv_path->s.entry, &srv->paths_list);
        srv->paths_num++;
        WARN_ON(srv->paths_num >= MAX_PATHS_NUM);
 }
 
-static void del_path_from_srv(struct rtrs_srv_sess *sess)
+static void del_path_from_srv(struct rtrs_srv_path *srv_path)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
 
        if (WARN_ON(!srv))
                return;
 
        mutex_lock(&srv->paths_mutex);
-       list_del(&sess->s.entry);
+       list_del(&srv_path->s.entry);
        WARN_ON(!srv->paths_num);
        srv->paths_num--;
        mutex_unlock(&srv->paths_mutex);
@@ -1487,44 +1494,44 @@ static int sockaddr_cmp(const struct sockaddr *a, const struct sockaddr *b)
 static bool __is_path_w_addr_exists(struct rtrs_srv *srv,
                                    struct rdma_addr *addr)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
 
-       list_for_each_entry(sess, &srv->paths_list, s.entry)
-               if (!sockaddr_cmp((struct sockaddr *)&sess->s.dst_addr,
+       list_for_each_entry(srv_path, &srv->paths_list, s.entry)
+               if (!sockaddr_cmp((struct sockaddr *)&srv_path->s.dst_addr,
                                  (struct sockaddr *)&addr->dst_addr) &&
-                   !sockaddr_cmp((struct sockaddr *)&sess->s.src_addr,
+                   !sockaddr_cmp((struct sockaddr *)&srv_path->s.src_addr,
                                  (struct sockaddr *)&addr->src_addr))
                        return true;
 
        return false;
 }
 
-static void free_sess(struct rtrs_srv_sess *sess)
+static void free_path(struct rtrs_srv_path *srv_path)
 {
-       if (sess->kobj.state_in_sysfs) {
-               kobject_del(&sess->kobj);
-               kobject_put(&sess->kobj);
+       if (srv_path->kobj.state_in_sysfs) {
+               kobject_del(&srv_path->kobj);
+               kobject_put(&srv_path->kobj);
        } else {
-               kfree(sess->stats);
-               kfree(sess);
+               kfree(srv_path->stats);
+               kfree(srv_path);
        }
 }
 
 static void rtrs_srv_close_work(struct work_struct *work)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        struct rtrs_srv_con *con;
        int i;
 
-       sess = container_of(work, typeof(*sess), close_work);
+       srv_path = container_of(work, typeof(*srv_path), close_work);
 
-       rtrs_srv_destroy_sess_files(sess);
-       rtrs_srv_stop_hb(sess);
+       rtrs_srv_destroy_path_files(srv_path);
+       rtrs_srv_stop_hb(srv_path);
 
-       for (i = 0; i < sess->s.con_num; i++) {
-               if (!sess->s.con[i])
+       for (i = 0; i < srv_path->s.con_num; i++) {
+               if (!srv_path->s.con[i])
                        continue;
-               con = to_srv_con(sess->s.con[i]);
+               con = to_srv_con(srv_path->s.con[i]);
                rdma_disconnect(con->c.cm_id);
                ib_drain_qp(con->c.qp);
        }
@@ -1533,41 +1540,41 @@ static void rtrs_srv_close_work(struct work_struct *work)
         * Degrade ref count to the usual model with a single shared
         * atomic_t counter
         */
-       percpu_ref_kill(&sess->ids_inflight_ref);
+       percpu_ref_kill(&srv_path->ids_inflight_ref);
 
        /* Wait for all completion */
-       wait_for_completion(&sess->complete_done);
+       wait_for_completion(&srv_path->complete_done);
 
        /* Notify upper layer if we are the last path */
-       rtrs_srv_sess_down(sess);
+       rtrs_srv_path_down(srv_path);
 
-       unmap_cont_bufs(sess);
-       rtrs_srv_free_ops_ids(sess);
+       unmap_cont_bufs(srv_path);
+       rtrs_srv_free_ops_ids(srv_path);
 
-       for (i = 0; i < sess->s.con_num; i++) {
-               if (!sess->s.con[i])
+       for (i = 0; i < srv_path->s.con_num; i++) {
+               if (!srv_path->s.con[i])
                        continue;
-               con = to_srv_con(sess->s.con[i]);
+               con = to_srv_con(srv_path->s.con[i]);
                rtrs_cq_qp_destroy(&con->c);
                rdma_destroy_id(con->c.cm_id);
                kfree(con);
        }
-       rtrs_ib_dev_put(sess->s.dev);
+       rtrs_ib_dev_put(srv_path->s.dev);
 
-       del_path_from_srv(sess);
-       put_srv(sess->srv);
-       sess->srv = NULL;
-       rtrs_srv_change_state(sess, RTRS_SRV_CLOSED);
+       del_path_from_srv(srv_path);
+       put_srv(srv_path->srv);
+       srv_path->srv = NULL;
+       rtrs_srv_change_state(srv_path, RTRS_SRV_CLOSED);
 
-       kfree(sess->dma_addr);
-       kfree(sess->s.con);
-       free_sess(sess);
+       kfree(srv_path->dma_addr);
+       kfree(srv_path->s.con);
+       free_path(srv_path);
 }
 
-static int rtrs_rdma_do_accept(struct rtrs_srv_sess *sess,
+static int rtrs_rdma_do_accept(struct rtrs_srv_path *srv_path,
                               struct rdma_cm_id *cm_id)
 {
-       struct rtrs_srv *srv = sess->srv;
+       struct rtrs_srv *srv = srv_path->srv;
        struct rtrs_msg_conn_rsp msg;
        struct rdma_conn_param param;
        int err;
@@ -1615,25 +1622,25 @@ static int rtrs_rdma_do_reject(struct rdma_cm_id *cm_id, int errno)
        return errno;
 }
 
-static struct rtrs_srv_sess *
-__find_sess(struct rtrs_srv *srv, const uuid_t *sess_uuid)
+static struct rtrs_srv_path *
+__find_path(struct rtrs_srv *srv, const uuid_t *sess_uuid)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
 
-       list_for_each_entry(sess, &srv->paths_list, s.entry) {
-               if (uuid_equal(&sess->s.uuid, sess_uuid))
-                       return sess;
+       list_for_each_entry(srv_path, &srv->paths_list, s.entry) {
+               if (uuid_equal(&srv_path->s.uuid, sess_uuid))
+                       return srv_path;
        }
 
        return NULL;
 }
 
-static int create_con(struct rtrs_srv_sess *sess,
+static int create_con(struct rtrs_srv_path *srv_path,
                      struct rdma_cm_id *cm_id,
                      unsigned int cid)
 {
-       struct rtrs_srv *srv = sess->srv;
-       struct rtrs_path *s = &sess->s;
+       struct rtrs_srv *srv = srv_path->srv;
+       struct rtrs_path *s = &srv_path->s;
        struct rtrs_srv_con *con;
 
        u32 cq_num, max_send_wr, max_recv_wr, wr_limit;
@@ -1648,10 +1655,10 @@ static int create_con(struct rtrs_srv_sess *sess,
        spin_lock_init(&con->rsp_wr_wait_lock);
        INIT_LIST_HEAD(&con->rsp_wr_wait_list);
        con->c.cm_id = cm_id;
-       con->c.path = &sess->s;
+       con->c.path = &srv_path->s;
        con->c.cid = cid;
        atomic_set(&con->c.wr_cnt, 1);
-       wr_limit = sess->s.dev->ib_dev->attrs.max_qp_wr;
+       wr_limit = srv_path->s.dev->ib_dev->attrs.max_qp_wr;
 
        if (con->c.cid == 0) {
                /*
@@ -1684,10 +1691,10 @@ static int create_con(struct rtrs_srv_sess *sess,
        }
        cq_num = max_send_wr + max_recv_wr;
        atomic_set(&con->c.sq_wr_avail, max_send_wr);
-       cq_vector = rtrs_srv_get_next_cq_vector(sess);
+       cq_vector = rtrs_srv_get_next_cq_vector(srv_path);
 
        /* TODO: SOFTIRQ can be faster, but be careful with softirq context */
-       err = rtrs_cq_qp_create(&sess->s, &con->c, 1, cq_vector, cq_num,
+       err = rtrs_cq_qp_create(&srv_path->s, &con->c, 1, cq_vector, cq_num,
                                 max_send_wr, max_recv_wr,
                                 IB_POLL_WORKQUEUE);
        if (err) {
@@ -1699,8 +1706,8 @@ static int create_con(struct rtrs_srv_sess *sess,
                if (err)
                        goto free_cqqp;
        }
-       WARN_ON(sess->s.con[cid]);
-       sess->s.con[cid] = &con->c;
+       WARN_ON(srv_path->s.con[cid]);
+       srv_path->s.con[cid] = &con->c;
 
        /*
         * Change context from server to current connection.  The other
@@ -1719,13 +1726,13 @@ err:
        return err;
 }
 
-static struct rtrs_srv_sess *__alloc_sess(struct rtrs_srv *srv,
+static struct rtrs_srv_path *__alloc_path(struct rtrs_srv *srv,
                                           struct rdma_cm_id *cm_id,
                                           unsigned int con_num,
                                           unsigned int recon_cnt,
                                           const uuid_t *uuid)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        int err = -ENOMEM;
        char str[NAME_MAX];
        struct rtrs_addr path;
@@ -1739,74 +1746,76 @@ static struct rtrs_srv_sess *__alloc_sess(struct rtrs_srv *srv,
                pr_err("Path with same addr exists\n");
                goto err;
        }
-       sess = kzalloc(sizeof(*sess), GFP_KERNEL);
-       if (!sess)
+       srv_path = kzalloc(sizeof(*srv_path), GFP_KERNEL);
+       if (!srv_path)
                goto err;
 
-       sess->stats = kzalloc(sizeof(*sess->stats), GFP_KERNEL);
-       if (!sess->stats)
+       srv_path->stats = kzalloc(sizeof(*srv_path->stats), GFP_KERNEL);
+       if (!srv_path->stats)
                goto err_free_sess;
 
-       sess->stats->sess = sess;
+       srv_path->stats->srv_path = srv_path;
 
-       sess->dma_addr = kcalloc(srv->queue_depth, sizeof(*sess->dma_addr),
-                                GFP_KERNEL);
-       if (!sess->dma_addr)
+       srv_path->dma_addr = kcalloc(srv->queue_depth,
+                                    sizeof(*srv_path->dma_addr),
+                                    GFP_KERNEL);
+       if (!srv_path->dma_addr)
                goto err_free_stats;
 
-       sess->s.con = kcalloc(con_num, sizeof(*sess->s.con), GFP_KERNEL);
-       if (!sess->s.con)
+       srv_path->s.con = kcalloc(con_num, sizeof(*srv_path->s.con),
+                                 GFP_KERNEL);
+       if (!srv_path->s.con)
                goto err_free_dma_addr;
 
-       sess->state = RTRS_SRV_CONNECTING;
-       sess->srv = srv;
-       sess->cur_cq_vector = -1;
-       sess->s.dst_addr = cm_id->route.addr.dst_addr;
-       sess->s.src_addr = cm_id->route.addr.src_addr;
+       srv_path->state = RTRS_SRV_CONNECTING;
+       srv_path->srv = srv;
+       srv_path->cur_cq_vector = -1;
+       srv_path->s.dst_addr = cm_id->route.addr.dst_addr;
+       srv_path->s.src_addr = cm_id->route.addr.src_addr;
 
        /* temporary until receiving session-name from client */
-       path.src = &sess->s.src_addr;
-       path.dst = &sess->s.dst_addr;
+       path.src = &srv_path->s.src_addr;
+       path.dst = &srv_path->s.dst_addr;
        rtrs_addr_to_str(&path, str, sizeof(str));
-       strscpy(sess->s.sessname, str, sizeof(sess->s.sessname));
-
-       sess->s.con_num = con_num;
-       sess->s.irq_con_num = con_num;
-       sess->s.recon_cnt = recon_cnt;
-       uuid_copy(&sess->s.uuid, uuid);
-       spin_lock_init(&sess->state_lock);
-       INIT_WORK(&sess->close_work, rtrs_srv_close_work);
-       rtrs_srv_init_hb(sess);
-
-       sess->s.dev = rtrs_ib_dev_find_or_add(cm_id->device, &dev_pd);
-       if (!sess->s.dev) {
+       strscpy(srv_path->s.sessname, str, sizeof(srv_path->s.sessname));
+
+       srv_path->s.con_num = con_num;
+       srv_path->s.irq_con_num = con_num;
+       srv_path->s.recon_cnt = recon_cnt;
+       uuid_copy(&srv_path->s.uuid, uuid);
+       spin_lock_init(&srv_path->state_lock);
+       INIT_WORK(&srv_path->close_work, rtrs_srv_close_work);
+       rtrs_srv_init_hb(srv_path);
+
+       srv_path->s.dev = rtrs_ib_dev_find_or_add(cm_id->device, &dev_pd);
+       if (!srv_path->s.dev) {
                err = -ENOMEM;
                goto err_free_con;
        }
-       err = map_cont_bufs(sess);
+       err = map_cont_bufs(srv_path);
        if (err)
                goto err_put_dev;
 
-       err = rtrs_srv_alloc_ops_ids(sess);
+       err = rtrs_srv_alloc_ops_ids(srv_path);
        if (err)
                goto err_unmap_bufs;
 
-       __add_path_to_srv(srv, sess);
+       __add_path_to_srv(srv, srv_path);
 
-       return sess;
+       return srv_path;
 
 err_unmap_bufs:
-       unmap_cont_bufs(sess);
+       unmap_cont_bufs(srv_path);
 err_put_dev:
-       rtrs_ib_dev_put(sess->s.dev);
+       rtrs_ib_dev_put(srv_path->s.dev);
 err_free_con:
-       kfree(sess->s.con);
+       kfree(srv_path->s.con);
 err_free_dma_addr:
-       kfree(sess->dma_addr);
+       kfree(srv_path->dma_addr);
 err_free_stats:
-       kfree(sess->stats);
+       kfree(srv_path->stats);
 err_free_sess:
-       kfree(sess);
+       kfree(srv_path);
 err:
        return ERR_PTR(err);
 }
@@ -1816,7 +1825,7 @@ static int rtrs_rdma_connect(struct rdma_cm_id *cm_id,
                              size_t len)
 {
        struct rtrs_srv_ctx *ctx = cm_id->context;
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
        struct rtrs_srv *srv;
 
        u16 version, con_num, cid;
@@ -1857,16 +1866,16 @@ static int rtrs_rdma_connect(struct rdma_cm_id *cm_id,
                goto reject_w_err;
        }
        mutex_lock(&srv->paths_mutex);
-       sess = __find_sess(srv, &msg->sess_uuid);
-       if (sess) {
-               struct rtrs_path *s = &sess->s;
+       srv_path = __find_path(srv, &msg->sess_uuid);
+       if (srv_path) {
+               struct rtrs_path *s = &srv_path->s;
 
                /* Session already holds a reference */
                put_srv(srv);
 
-               if (sess->state != RTRS_SRV_CONNECTING) {
+               if (srv_path->state != RTRS_SRV_CONNECTING) {
                        rtrs_err(s, "Session in wrong state: %s\n",
-                                 rtrs_srv_state_str(sess->state));
+                                 rtrs_srv_state_str(srv_path->state));
                        mutex_unlock(&srv->paths_mutex);
                        goto reject_w_err;
                }
@@ -1886,19 +1895,19 @@ static int rtrs_rdma_connect(struct rdma_cm_id *cm_id,
                        goto reject_w_err;
                }
        } else {
-               sess = __alloc_sess(srv, cm_id, con_num, recon_cnt,
+               srv_path = __alloc_path(srv, cm_id, con_num, recon_cnt,
                                    &msg->sess_uuid);
-               if (IS_ERR(sess)) {
+               if (IS_ERR(srv_path)) {
                        mutex_unlock(&srv->paths_mutex);
                        put_srv(srv);
-                       err = PTR_ERR(sess);
+                       err = PTR_ERR(srv_path);
                        pr_err("RTRS server session allocation failed: %d\n", err);
                        goto reject_w_err;
                }
        }
-       err = create_con(sess, cm_id, cid);
+       err = create_con(srv_path, cm_id, cid);
        if (err) {
-               rtrs_err((&sess->s), "create_con(), error %d\n", err);
+               rtrs_err((&srv_path->s), "create_con(), error %d\n", err);
                rtrs_rdma_do_reject(cm_id, err);
                /*
                 * Since session has other connections we follow normal way
@@ -1907,9 +1916,9 @@ static int rtrs_rdma_connect(struct rdma_cm_id *cm_id,
                 */
                goto close_and_return_err;
        }
-       err = rtrs_rdma_do_accept(sess, cm_id);
+       err = rtrs_rdma_do_accept(srv_path, cm_id);
        if (err) {
-               rtrs_err((&sess->s), "rtrs_rdma_do_accept(), error %d\n", err);
+               rtrs_err((&srv_path->s), "rtrs_rdma_do_accept(), error %d\n", err);
                rtrs_rdma_do_reject(cm_id, err);
                /*
                 * Since current connection was successfully added to the
@@ -1929,7 +1938,7 @@ reject_w_err:
 
 close_and_return_err:
        mutex_unlock(&srv->paths_mutex);
-       close_sess(sess);
+       close_path(srv_path);
 
        return err;
 }
@@ -1937,14 +1946,14 @@ close_and_return_err:
 static int rtrs_srv_rdma_cm_handler(struct rdma_cm_id *cm_id,
                                     struct rdma_cm_event *ev)
 {
-       struct rtrs_srv_sess *sess = NULL;
+       struct rtrs_srv_path *srv_path = NULL;
        struct rtrs_path *s = NULL;
 
        if (ev->event != RDMA_CM_EVENT_CONNECT_REQUEST) {
                struct rtrs_con *c = cm_id->context;
 
                s = c->path;
-               sess = to_srv_sess(s);
+               srv_path = to_srv_path(s);
        }
 
        switch (ev->event) {
@@ -1968,7 +1977,7 @@ static int rtrs_srv_rdma_cm_handler(struct rdma_cm_id *cm_id,
        case RDMA_CM_EVENT_ADDR_CHANGE:
        case RDMA_CM_EVENT_TIMEWAIT_EXIT:
        case RDMA_CM_EVENT_DEVICE_REMOVAL:
-               close_sess(sess);
+               close_path(srv_path);
                break;
        default:
                pr_err("Ignoring unexpected CM event %s, err %d\n",
@@ -2176,13 +2185,13 @@ struct rtrs_srv_ctx *rtrs_srv_open(struct rtrs_srv_ops *ops, u16 port)
 }
 EXPORT_SYMBOL(rtrs_srv_open);
 
-static void close_sessions(struct rtrs_srv *srv)
+static void close_paths(struct rtrs_srv *srv)
 {
-       struct rtrs_srv_sess *sess;
+       struct rtrs_srv_path *srv_path;
 
        mutex_lock(&srv->paths_mutex);
-       list_for_each_entry(sess, &srv->paths_list, s.entry)
-               close_sess(sess);
+       list_for_each_entry(srv_path, &srv->paths_list, s.entry)
+               close_path(srv_path);
        mutex_unlock(&srv->paths_mutex);
 }
 
@@ -2192,7 +2201,7 @@ static void close_ctx(struct rtrs_srv_ctx *ctx)
 
        mutex_lock(&ctx->srv_mutex);
        list_for_each_entry(srv, &ctx->srv_list, ctx_list)
-               close_sessions(srv);
+               close_paths(srv);
        mutex_unlock(&ctx->srv_mutex);
        flush_workqueue(rtrs_wq);
 }

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv.h b/drivers/infiniband/ulp/rtrs/rtrs-srv.h
index f0fbd8b..ee3578b 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-srv.h
+++ b/drivers/infiniband/ulp/rtrs/rtrs-srv.h
@@ -37,7 +37,7 @@ struct rtrs_srv_stats_rdma_stats {
 struct rtrs_srv_stats {
        struct kobject                          kobj_stats;
        struct rtrs_srv_stats_rdma_stats        rdma_stats;
-       struct rtrs_srv_sess                    *sess;
+       struct rtrs_srv_path                    *srv_path;
 };
 
 struct rtrs_srv_con {
@@ -71,7 +71,7 @@ struct rtrs_srv_mr {
        struct rtrs_iu  *iu;            /* send buffer for new rkey msg */
 };
 
-struct rtrs_srv_sess {
+struct rtrs_srv_path {
        struct rtrs_path        s;
        struct rtrs_srv *srv;
        struct work_struct      close_work;
@@ -125,7 +125,7 @@ struct rtrs_srv_ib_ctx {
 
 extern struct class *rtrs_dev_class;
 
-void close_sess(struct rtrs_srv_sess *sess);
+void close_path(struct rtrs_srv_path *srv_path);
 
 static inline void rtrs_srv_update_rdma_stats(struct rtrs_srv_stats *s,
                                              size_t size, int d)
@@ -143,7 +143,7 @@ ssize_t rtrs_srv_reset_all_help(struct rtrs_srv_stats *stats,
                                 char *page, size_t len);
 
 /* functions which are implemented in rtrs-srv-sysfs.c */
-int rtrs_srv_create_sess_files(struct rtrs_srv_sess *sess);
-void rtrs_srv_destroy_sess_files(struct rtrs_srv_sess *sess);
+int rtrs_srv_create_path_files(struct rtrs_srv_path *srv_path);
+void rtrs_srv_destroy_path_files(struct rtrs_srv_path *srv_path);
 
 #endif /* RTRS_SRV_H */

diff --git a/drivers/infiniband/ulp/rtrs/rtrs.h b/drivers/infiniband/ulp/rtrs/rtrs.h
index 859c796..9da9202 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs.h
+++ b/drivers/infiniband/ulp/rtrs/rtrs.h
@@ -175,7 +175,8 @@ bool rtrs_srv_resp_rdma(struct rtrs_srv_op *id, int errno);
 
 void rtrs_srv_set_sess_priv(struct rtrs_srv *sess, void *priv);
 
-int rtrs_srv_get_sess_name(struct rtrs_srv *sess, char *sessname, size_t len);
+int rtrs_srv_get_path_name(struct rtrs_srv *sess, char *pathname,
+                          size_t len);
 
 int rtrs_srv_get_queue_depth(struct rtrs_srv *sess);