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_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         refcount_t              ref;
 119 };
 120
 121 struct rtrs_rbuf {
 122         u64 addr;
 123         u32 rkey;
 124 };
 125
 126 struct rtrs_clt_path {
 127         struct rtrs_path        s;
 128         struct rtrs_clt_sess    *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         struct work_struct      err_recovery_work;
 137         unsigned int            reconnect_attempts;
 138         bool                    established;
 139         struct rtrs_rbuf        *rbufs;
 140         size_t                  max_io_size;
 141         u32                     max_hdr_size;
 142         u32                     chunk_size;
 143         size_t                  queue_depth;
 144         u32                     max_pages_per_mr;
 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_sess {
 157         struct list_head        paths_list; /* rcu protected list */
 158         size_t                  paths_num;
 159         struct rtrs_clt_path
 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_path *to_clt_path(struct rtrs_path *s)
 190 {
 191         return container_of(s, struct rtrs_clt_path, s);
 192 }
 193
 194 static inline int permit_size(struct rtrs_clt_sess *clt)
 195 {
 196         return sizeof(struct rtrs_permit) + clt->pdu_sz;
 197 }
 198
 199 static inline struct rtrs_permit *get_permit(struct rtrs_clt_sess *clt,
 200                                              int idx)
 201 {
 202         return (struct rtrs_permit *)(clt->permits + permit_size(clt) * idx);
 203 }
 204
 205 int rtrs_clt_reconnect_from_sysfs(struct rtrs_clt_path *path);
 206 void rtrs_clt_close_conns(struct rtrs_clt_path *clt_path, bool wait);
 207 int rtrs_clt_create_path_from_sysfs(struct rtrs_clt_sess *clt,
 208                                      struct rtrs_addr *addr);
 209 int rtrs_clt_remove_path_from_sysfs(struct rtrs_clt_path *path,
 210                                      const struct attribute *sysfs_self);
 211
 212 void rtrs_clt_set_max_reconnect_attempts(struct rtrs_clt_sess *clt, int value);
 213 int rtrs_clt_get_max_reconnect_attempts(const struct rtrs_clt_sess *clt);
 214 void free_path(struct rtrs_clt_path *clt_path);
 215 void rtrs_clt_ib_event_handler(struct ib_event_handler *handler,
 216                                struct ib_event *ibevent);
 217
 218 /* rtrs-clt-stats.c */
 219
 220 int rtrs_clt_init_stats(struct rtrs_clt_stats *stats);
 221
 222 void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *s);
 223
 224 void rtrs_clt_update_wc_stats(struct rtrs_clt_con *con);
 225 void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir);
 226
 227 int rtrs_clt_reset_rdma_lat_distr_stats(struct rtrs_clt_stats *stats,
 228                                          bool enable);
 229 ssize_t rtrs_clt_stats_rdma_lat_distr_to_str(struct rtrs_clt_stats *stats,
 230                                               char *page);
 231 int rtrs_clt_reset_cpu_migr_stats(struct rtrs_clt_stats *stats, bool enable);
 232 int rtrs_clt_stats_migration_from_cnt_to_str(struct rtrs_clt_stats *stats, char *buf);
 233 int rtrs_clt_stats_migration_to_cnt_to_str(struct rtrs_clt_stats *stats, char *buf);
 234 int rtrs_clt_reset_reconnects_stat(struct rtrs_clt_stats *stats, bool enable);
 235 int rtrs_clt_stats_reconnects_to_str(struct rtrs_clt_stats *stats, char *buf);
 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);
 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);
 242
 243 /* rtrs-clt-sysfs.c */
 244
 245 int rtrs_clt_create_sysfs_root_files(struct rtrs_clt_sess *clt);
 246 void rtrs_clt_destroy_sysfs_root(struct rtrs_clt_sess *clt);
 247
 248 int rtrs_clt_create_path_files(struct rtrs_clt_path *clt_path);
 249 void rtrs_clt_destroy_path_files(struct rtrs_clt_path *clt_path,
 250                                   const struct attribute *sysfs_self);
 251
 252 #endif /* RTRS_CLT_H */