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_num;
  75         unsigned int            cpu;
  76         struct mutex            con_mutex;
  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         enum rtrs_mp_policy     mp_policy;
 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         refcount_t              ref;
 120 };
 121
 122 struct rtrs_rbuf {
 123         u64 addr;
 124         u32 rkey;
 125 };
 126
 127 struct rtrs_clt_path {
 128         struct rtrs_path        s;
 129         struct rtrs_clt_sess    *clt;
 130         wait_queue_head_t       state_wq;
 131         enum rtrs_clt_state     state;
 132         atomic_t                connected_cnt;
 133         struct mutex            init_mutex;
 134         struct rtrs_clt_io_req  *reqs;
 135         struct delayed_work     reconnect_dwork;
 136         struct work_struct      close_work;
 137         struct work_struct      err_recovery_work;
 138         unsigned int            reconnect_attempts;
 139         bool                    established;
 140         struct rtrs_rbuf        *rbufs;
 141         size_t                  max_io_size;
 142         u32                     max_hdr_size;
 143         u32                     chunk_size;
 144         size_t                  queue_depth;
 145         u32                     max_pages_per_mr;
 146         u32                     flags;
 147         struct kobject          kobj;
 148         u8                      for_new_clt;
 149         struct rtrs_clt_stats   *stats;
 150         /* cache hca_port and hca_name to display in sysfs */
 151         u8                      hca_port;
 152         char                    hca_name[IB_DEVICE_NAME_MAX];
 153         struct list_head __percpu
 154                                 *mp_skip_entry;
 155 };
 156
 157 struct rtrs_clt_sess {
 158         struct list_head        paths_list; /* rcu protected list */
 159         size_t                  paths_num;
 160         struct rtrs_clt_path
 161         __rcu * __percpu        *pcpu_path;
 162         uuid_t                  paths_uuid;
 163         int                     paths_up;
 164         struct mutex            paths_mutex;
 165         struct mutex            paths_ev_mutex;
 166         char                    sessname[NAME_MAX];
 167         u16                     port;
 168         unsigned int            max_reconnect_attempts;
 169         unsigned int            reconnect_delay_sec;
 170         unsigned int            max_segments;
 171         void                    *permits;
 172         unsigned long           *permits_map;
 173         size_t                  queue_depth;
 174         size_t                  max_io_size;
 175         wait_queue_head_t       permits_wait;
 176         size_t                  pdu_sz;
 177         void                    *priv;
 178         void                    (*link_ev)(void *priv,
 179                                            enum rtrs_clt_link_ev ev);
 180         struct device           dev;
 181         struct kobject          *kobj_paths;
 182         enum rtrs_mp_policy     mp_policy;
 183 };
 184
 185 static inline struct rtrs_clt_con *to_clt_con(struct rtrs_con *c)
 186 {
 187         return container_of(c, struct rtrs_clt_con, c);
 188 }
 189
 190 static inline struct rtrs_clt_path *to_clt_path(struct rtrs_path *s)
 191 {
 192         return container_of(s, struct rtrs_clt_path, s);
 193 }
 194
 195 static inline int permit_size(struct rtrs_clt_sess *clt)
 196 {
 197         return sizeof(struct rtrs_permit) + clt->pdu_sz;
 198 }
 199
 200 static inline struct rtrs_permit *get_permit(struct rtrs_clt_sess *clt,
 201                                              int idx)
 202 {
 203         return (struct rtrs_permit *)(clt->permits + permit_size(clt) * idx);
 204 }
 205
 206 int rtrs_clt_reconnect_from_sysfs(struct rtrs_clt_path *path);
 207 void rtrs_clt_close_conns(struct rtrs_clt_path *clt_path, bool wait);
 208 int rtrs_clt_create_path_from_sysfs(struct rtrs_clt_sess *clt,
 209                                      struct rtrs_addr *addr);
 210 int rtrs_clt_remove_path_from_sysfs(struct rtrs_clt_path *path,
 211                                      const struct attribute *sysfs_self);
 212
 213 void rtrs_clt_set_max_reconnect_attempts(struct rtrs_clt_sess *clt, int value);
 214 int rtrs_clt_get_max_reconnect_attempts(const struct rtrs_clt_sess *clt);
 215 void free_path(struct rtrs_clt_path *clt_path);
 216
 217 /* rtrs-clt-stats.c */
 218
 219 int rtrs_clt_init_stats(struct rtrs_clt_stats *stats);
 220
 221 void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *s);
 222
 223 void rtrs_clt_update_wc_stats(struct rtrs_clt_con *con);
 224 void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir);
 225
 226 int rtrs_clt_reset_rdma_lat_distr_stats(struct rtrs_clt_stats *stats,
 227                                          bool enable);
 228 ssize_t rtrs_clt_stats_rdma_lat_distr_to_str(struct rtrs_clt_stats *stats,
 229                                               char *page);
 230 int rtrs_clt_reset_cpu_migr_stats(struct rtrs_clt_stats *stats, bool enable);
 231 int rtrs_clt_stats_migration_from_cnt_to_str(struct rtrs_clt_stats *stats, char *buf);
 232 int rtrs_clt_stats_migration_to_cnt_to_str(struct rtrs_clt_stats *stats, char *buf);
 233 int rtrs_clt_reset_reconnects_stat(struct rtrs_clt_stats *stats, bool enable);
 234 int rtrs_clt_stats_reconnects_to_str(struct rtrs_clt_stats *stats, char *buf);
 235 int rtrs_clt_reset_rdma_stats(struct rtrs_clt_stats *stats, bool enable);
 236 ssize_t rtrs_clt_stats_rdma_to_str(struct rtrs_clt_stats *stats,
 237                                     char *page);
 238 int rtrs_clt_reset_all_stats(struct rtrs_clt_stats *stats, bool enable);
 239 ssize_t rtrs_clt_reset_all_help(struct rtrs_clt_stats *stats,
 240                                  char *page);
 241
 242 /* rtrs-clt-sysfs.c */
 243
 244 int rtrs_clt_create_sysfs_root_files(struct rtrs_clt_sess *clt);
 245 void rtrs_clt_destroy_sysfs_root(struct rtrs_clt_sess *clt);
 246
 247 int rtrs_clt_create_path_files(struct rtrs_clt_path *clt_path);
 248 void rtrs_clt_destroy_path_files(struct rtrs_clt_path *clt_path,
 249                                   const struct attribute *sysfs_self);
 250
 251 #endif /* RTRS_CLT_H */