drivers/infiniband/ulp/rtrs/rtrs-clt.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * RDMA Transport Layer
   4  *
   5  * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
   6  * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
   7  * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
   8  */
   9
  10 #ifndef RTRS_CLT_H
  11 #define RTRS_CLT_H
  12
  13 #include <linux/device.h>
  14 #include "rtrs-pri.h"
  15
  16 /**
  17  * enum rtrs_clt_state - Client states.
  18  */
  19 enum rtrs_clt_state {
  20         RTRS_CLT_CONNECTING,
  21         RTRS_CLT_CONNECTING_ERR,
  22         RTRS_CLT_RECONNECTING,
  23         RTRS_CLT_CONNECTED,
  24         RTRS_CLT_CLOSING,
  25         RTRS_CLT_CLOSED,
  26         RTRS_CLT_DEAD,
  27 };
  28
  29 enum rtrs_mp_policy {
  30         MP_POLICY_RR,
  31         MP_POLICY_MIN_INFLIGHT,
  32 };
  33
  34 /* see Documentation/ABI/testing/sysfs-class-rtrs-client for details */
  35 struct rtrs_clt_stats_reconnects {
  36         int successful_cnt;
  37         int fail_cnt;
  38 };
  39
  40 /* see Documentation/ABI/testing/sysfs-class-rtrs-client for details */
  41 struct rtrs_clt_stats_cpu_migr {
  42         atomic_t from;
  43         int to;
  44 };
  45
  46 /* stats for Read and write operation.
  47  * see Documentation/ABI/testing/sysfs-class-rtrs-client for details
  48  */
  49 struct rtrs_clt_stats_rdma {
  50         struct {
  51                 u64 cnt;
  52                 u64 size_total;
  53         } dir[2];
  54
  55         u64 failover_cnt;
  56 };
  57
  58 struct rtrs_clt_stats_pcpu {
  59         struct rtrs_clt_stats_cpu_migr          cpu_migr;
  60         struct rtrs_clt_stats_rdma              rdma;
  61 };
  62
  63 struct rtrs_clt_stats {
  64         struct kobject                          kobj_stats;
  65         struct rtrs_clt_stats_pcpu    __percpu  *pcpu_stats;
  66         struct rtrs_clt_stats_reconnects        reconnects;
  67         atomic_t                                inflight;
  68 };
  69
  70 struct rtrs_clt_con {
  71         struct rtrs_con c;
  72         struct rtrs_iu          *rsp_ius;
  73         u32                     queue_size;
  74         unsigned int            cpu;
  75         struct mutex            con_mutex;
  76         atomic_t                io_cnt;
  77         int                     cm_err;
  78 };
  79
  80 /**
  81  * rtrs_permit - permits the memory allocation for future RDMA operation.
  82  *               Combine with irq pinning to keep IO on same CPU.
  83  */
  84 struct rtrs_permit {
  85         enum rtrs_clt_con_type con_type;
  86         unsigned int cpu_id;
  87         unsigned int mem_id;
  88         unsigned int mem_off;
  89 };
  90
  91 /**
  92  * rtrs_clt_io_req - describes one inflight IO request
  93  */
  94 struct rtrs_clt_io_req {
  95         struct list_head        list;
  96         struct rtrs_iu          *iu;
  97         struct scatterlist      *sglist; /* list holding user data */
  98         unsigned int            sg_cnt;
  99         unsigned int            sg_size;
 100         unsigned int            data_len;
 101         unsigned int            usr_len;
 102         void                    *priv;
 103         bool                    in_use;
 104         struct rtrs_clt_con     *con;
 105         struct rtrs_sg_desc     *desc;
 106         struct ib_sge           *sge;
 107         struct rtrs_permit      *permit;
 108         enum dma_data_direction dir;
 109         void                    (*conf)(void *priv, int errno);
 110         unsigned long           start_jiffies;
 111
 112         struct ib_mr            *mr;
 113         struct ib_cqe           inv_cqe;
 114         struct completion       inv_comp;
 115         int                     inv_errno;
 116         bool                    need_inv_comp;
 117         bool                    need_inv;
 118 };
 119
 120 struct rtrs_rbuf {
 121         u64 addr;
 122         u32 rkey;
 123 };
 124
 125 struct rtrs_clt_sess {
 126         struct rtrs_sess        s;
 127         struct rtrs_clt *clt;
 128         wait_queue_head_t       state_wq;
 129         enum rtrs_clt_state     state;
 130         atomic_t                connected_cnt;
 131         struct mutex            init_mutex;
 132         struct rtrs_clt_io_req  *reqs;
 133         struct delayed_work     reconnect_dwork;
 134         struct work_struct      close_work;
 135         unsigned int            reconnect_attempts;
 136         bool                    established;
 137         struct rtrs_rbuf        *rbufs;
 138         size_t                  max_io_size;
 139         u32                     max_hdr_size;
 140         u32                     chunk_size;
 141         size_t                  queue_depth;
 142         u32                     max_pages_per_mr;
 143         int                     max_send_sge;
 144         u32                     flags;
 145         struct kobject          kobj;
 146         struct rtrs_clt_stats   *stats;
 147         /* cache hca_port and hca_name to display in sysfs */
 148         u8                      hca_port;
 149         char                    hca_name[IB_DEVICE_NAME_MAX];
 150         struct list_head __percpu
 151                                 *mp_skip_entry;
 152 };
 153
 154 struct rtrs_clt {
 155         struct list_head        paths_list; /* rcu protected list */
 156         size_t                  paths_num;
 157         struct rtrs_clt_sess
 158         __rcu * __percpu        *pcpu_path;
 159         uuid_t                  paths_uuid;
 160         int                     paths_up;
 161         struct mutex            paths_mutex;
 162         struct mutex            paths_ev_mutex;
 163         char                    sessname[NAME_MAX];
 164         u16                     port;
 165         unsigned int            max_reconnect_attempts;
 166         unsigned int            reconnect_delay_sec;
 167         unsigned int            max_segments;
 168         size_t                  max_segment_size;
 169         void                    *permits;
 170         unsigned long           *permits_map;
 171         size_t                  queue_depth;
 172         size_t                  max_io_size;
 173         wait_queue_head_t       permits_wait;
 174         size_t                  pdu_sz;
 175         void                    *priv;
 176         void                    (*link_ev)(void *priv,
 177                                            enum rtrs_clt_link_ev ev);
 178         struct device           dev;
 179         struct kobject          *kobj_paths;
 180         enum rtrs_mp_policy     mp_policy;
 181 };
 182
 183 static inline struct rtrs_clt_con *to_clt_con(struct rtrs_con *c)
 184 {
 185         return container_of(c, struct rtrs_clt_con, c);
 186 }
 187
 188 static inline struct rtrs_clt_sess *to_clt_sess(struct rtrs_sess *s)
 189 {
 190         return container_of(s, struct rtrs_clt_sess, s);
 191 }
 192
 193 static inline int permit_size(struct rtrs_clt *clt)
 194 {
 195         return sizeof(struct rtrs_permit) + clt->pdu_sz;
 196 }
 197
 198 static inline struct rtrs_permit *get_permit(struct rtrs_clt *clt, int idx)
 199 {
 200         return (struct rtrs_permit *)(clt->permits + permit_size(clt) * idx);
 201 }
 202
 203 int rtrs_clt_reconnect_from_sysfs(struct rtrs_clt_sess *sess);
 204 int rtrs_clt_disconnect_from_sysfs(struct rtrs_clt_sess *sess);
 205 int rtrs_clt_create_path_from_sysfs(struct rtrs_clt *clt,
 206                                      struct rtrs_addr *addr);
 207 int rtrs_clt_remove_path_from_sysfs(struct rtrs_clt_sess *sess,
 208                                      const struct attribute *sysfs_self);
 209
 210 void rtrs_clt_set_max_reconnect_attempts(struct rtrs_clt *clt, int value);
 211 int rtrs_clt_get_max_reconnect_attempts(const struct rtrs_clt *clt);
 212 void free_sess(struct rtrs_clt_sess *sess);
 213
 214 /* rtrs-clt-stats.c */
 215
 216 int rtrs_clt_init_stats(struct rtrs_clt_stats *stats);
 217
 218 void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *s);
 219
 220 void rtrs_clt_update_wc_stats(struct rtrs_clt_con *con);
 221 void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir);
 222
 223 int rtrs_clt_reset_rdma_lat_distr_stats(struct rtrs_clt_stats *stats,
 224                                          bool enable);
 225 ssize_t rtrs_clt_stats_rdma_lat_distr_to_str(struct rtrs_clt_stats *stats,
 226                                               char *page, size_t len);
 227 int rtrs_clt_reset_cpu_migr_stats(struct rtrs_clt_stats *stats, bool enable);
 228 int rtrs_clt_stats_migration_cnt_to_str(struct rtrs_clt_stats *stats, char *buf,
 229                                          size_t len);
 230 int rtrs_clt_reset_reconnects_stat(struct rtrs_clt_stats *stats, bool enable);
 231 int rtrs_clt_stats_reconnects_to_str(struct rtrs_clt_stats *stats, char *buf,
 232                                       size_t len);
 233 int rtrs_clt_reset_wc_comp_stats(struct rtrs_clt_stats *stats, bool enable);
 234 int rtrs_clt_stats_wc_completion_to_str(struct rtrs_clt_stats *stats, char *buf,
 235                                          size_t len);
 236 int rtrs_clt_reset_rdma_stats(struct rtrs_clt_stats *stats, bool enable);
 237 ssize_t rtrs_clt_stats_rdma_to_str(struct rtrs_clt_stats *stats,
 238                                     char *page, size_t len);
 239 int rtrs_clt_reset_all_stats(struct rtrs_clt_stats *stats, bool enable);
 240 ssize_t rtrs_clt_reset_all_help(struct rtrs_clt_stats *stats,
 241                                  char *page, size_t len);
 242
 243 /* rtrs-clt-sysfs.c */
 244
 245 int rtrs_clt_create_sysfs_root_files(struct rtrs_clt *clt);
 246 void rtrs_clt_destroy_sysfs_root_folders(struct rtrs_clt *clt);
 247 void rtrs_clt_destroy_sysfs_root_files(struct rtrs_clt *clt);
 248
 249 int rtrs_clt_create_sess_files(struct rtrs_clt_sess *sess);
 250 void rtrs_clt_destroy_sess_files(struct rtrs_clt_sess *sess,
 251                                   const struct attribute *sysfs_self);
 252
 253 #endif /* RTRS_CLT_H */