drivers/infiniband/ulp/rtrs/rtrs.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 #ifndef RTRS_H
  10 #define RTRS_H
  11
  12 #include <linux/socket.h>
  13 #include <linux/scatterlist.h>
  14
  15 struct rtrs_permit;
  16 struct rtrs_clt;
  17 struct rtrs_srv_ctx;
  18 struct rtrs_srv;
  19 struct rtrs_srv_op;
  20
  21 /*
  22  * RDMA transport (RTRS) client API
  23  */
  24
  25 /**
  26  * enum rtrs_clt_link_ev - Events about connectivity state of a client
  27  * @RTRS_CLT_LINK_EV_RECONNECTED        Client was reconnected.
  28  * @RTRS_CLT_LINK_EV_DISCONNECTED       Client was disconnected.
  29  */
  30 enum rtrs_clt_link_ev {
  31         RTRS_CLT_LINK_EV_RECONNECTED,
  32         RTRS_CLT_LINK_EV_DISCONNECTED,
  33 };
  34
  35 /**
  36  * Source and destination address of a path to be established
  37  */
  38 struct rtrs_addr {
  39         struct sockaddr_storage *src;
  40         struct sockaddr_storage *dst;
  41 };
  42
  43 /**
  44  * rtrs_clt_ops - it holds the link event callback and private pointer.
  45  * @priv: User supplied private data.
  46  * @link_ev: Event notification callback function for connection state changes
  47  *      @priv: User supplied data that was passed to rtrs_clt_open()
  48  *      @ev: Occurred event
  49  */
  50 struct rtrs_clt_ops {
  51         void    *priv;
  52         void    (*link_ev)(void *priv, enum rtrs_clt_link_ev ev);
  53 };
  54
  55 struct rtrs_clt *rtrs_clt_open(struct rtrs_clt_ops *ops,
  56                                  const char *sessname,
  57                                  const struct rtrs_addr *paths,
  58                                  size_t path_cnt, u16 port,
  59                                  size_t pdu_sz, u8 reconnect_delay_sec,
  60                                  u16 max_segments,
  61                                  size_t max_segment_size,
  62                                  s16 max_reconnect_attempts);
  63
  64 void rtrs_clt_close(struct rtrs_clt *sess);
  65
  66 /**
  67  * rtrs_permit_to_pdu() - converts rtrs_permit to opaque pdu pointer
  68  * @permit: RTRS permit pointer, it associates the memory allocation for future
  69  *          RDMA operation.
  70  */
  71 void *rtrs_permit_to_pdu(struct rtrs_permit *permit);
  72
  73 enum {
  74         RTRS_PERMIT_NOWAIT = 0,
  75         RTRS_PERMIT_WAIT   = 1,
  76 };
  77
  78 /**
  79  * enum rtrs_clt_con_type() type of ib connection to use with a given
  80  * rtrs_permit
  81  * @ADMIN_CON - use connection reserved for "service" messages
  82  * @IO_CON - use a connection reserved for IO
  83  */
  84 enum rtrs_clt_con_type {
  85         RTRS_ADMIN_CON,
  86         RTRS_IO_CON
  87 };
  88
  89 struct rtrs_permit *rtrs_clt_get_permit(struct rtrs_clt *sess,
  90                                     enum rtrs_clt_con_type con_type,
  91                                     int wait);
  92
  93 void rtrs_clt_put_permit(struct rtrs_clt *sess, struct rtrs_permit *permit);
  94
  95 /**
  96  * rtrs_clt_req_ops - it holds the request confirmation callback
  97  * and a private pointer.
  98  * @priv: User supplied private data.
  99  * @conf_fn:    callback function to be called as confirmation
 100  *      @priv:  User provided data, passed back with corresponding
 101  *              @(conf) confirmation.
 102  *      @errno: error number.
 103  */
 104 struct rtrs_clt_req_ops {
 105         void    *priv;
 106         void    (*conf_fn)(void *priv, int errno);
 107 };
 108
 109 int rtrs_clt_request(int dir, struct rtrs_clt_req_ops *ops,
 110                      struct rtrs_clt *sess, struct rtrs_permit *permit,
 111                      const struct kvec *vec, size_t nr, size_t len,
 112                      struct scatterlist *sg, unsigned int sg_cnt);
 113
 114 /**
 115  * rtrs_attrs - RTRS session attributes
 116  */
 117 struct rtrs_attrs {
 118         u32             queue_depth;
 119         u32             max_io_size;
 120         u8              sessname[NAME_MAX];
 121         struct kobject  *sess_kobj;
 122 };
 123
 124 int rtrs_clt_query(struct rtrs_clt *sess, struct rtrs_attrs *attr);
 125
 126 /*
 127  * Here goes RTRS server API
 128  */
 129
 130 /**
 131  * enum rtrs_srv_link_ev - Server link events
 132  * @RTRS_SRV_LINK_EV_CONNECTED: Connection from client established
 133  * @RTRS_SRV_LINK_EV_DISCONNECTED:      Connection was disconnected, all
 134  *                                      connection RTRS resources were freed.
 135  */
 136 enum rtrs_srv_link_ev {
 137         RTRS_SRV_LINK_EV_CONNECTED,
 138         RTRS_SRV_LINK_EV_DISCONNECTED,
 139 };
 140
 141 struct rtrs_srv_ops {
 142         /**
 143          * rdma_ev():           Event notification for RDMA operations
 144          *                      If the callback returns a value != 0, an error
 145          *                      message for the data transfer will be sent to
 146          *                      the client.
 147
 148          *      @sess:          Session
 149          *      @priv:          Private data set by rtrs_srv_set_sess_priv()
 150          *      @id:            internal RTRS operation id
 151          *      @dir:           READ/WRITE
 152          *      @data:          Pointer to (bidirectional) rdma memory area:
 153          *                      - in case of %RTRS_SRV_RDMA_EV_RECV contains
 154          *                      data sent by the client
 155          *                      - in case of %RTRS_SRV_RDMA_EV_WRITE_REQ points
 156          *                      to the memory area where the response is to be
 157          *                      written to
 158          *      @datalen:       Size of the memory area in @data
 159          *      @usr:           The extra user message sent by the client (%vec)
 160          *      @usrlen:        Size of the user message
 161          */
 162         int (*rdma_ev)(struct rtrs_srv *sess, void *priv,
 163                        struct rtrs_srv_op *id, int dir,
 164                        void *data, size_t datalen, const void *usr,
 165                        size_t usrlen);
 166         /**
 167          * link_ev():           Events about connectivity state changes
 168          *                      If the callback returns != 0 and the event
 169          *                      %RTRS_SRV_LINK_EV_CONNECTED the corresponding
 170          *                      session will be destroyed.
 171          *      @sess:          Session
 172          *      @ev:            event
 173          *      @priv:          Private data from user if previously set with
 174          *                      rtrs_srv_set_sess_priv()
 175          */
 176         int (*link_ev)(struct rtrs_srv *sess, enum rtrs_srv_link_ev ev,
 177                        void *priv);
 178 };
 179
 180 struct rtrs_srv_ctx *rtrs_srv_open(struct rtrs_srv_ops *ops, u16 port);
 181
 182 void rtrs_srv_close(struct rtrs_srv_ctx *ctx);
 183
 184 bool rtrs_srv_resp_rdma(struct rtrs_srv_op *id, int errno);
 185
 186 void rtrs_srv_set_sess_priv(struct rtrs_srv *sess, void *priv);
 187
 188 int rtrs_srv_get_sess_name(struct rtrs_srv *sess, char *sessname, size_t len);
 189
 190 int rtrs_srv_get_queue_depth(struct rtrs_srv *sess);
 191
 192 int rtrs_addr_to_sockaddr(const char *str, size_t len, u16 port,
 193                           struct rtrs_addr *addr);
 194
 195 int sockaddr_to_str(const struct sockaddr *addr, char *buf, size_t len);
 196 #endif