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