net/smc/smc.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  *  Shared Memory Communications over RDMA (SMC-R) and RoCE
   4  *
   5  *  Definitions for the SMC module (socket related)
   6  *
   7  *  Copyright IBM Corp. 2016
   8  *
   9  *  Author(s):  Ursula Braun <[email protected]>
  10  */
  11 #ifndef __SMC_H
  12 #define __SMC_H
  13
  14 #include <linux/socket.h>
  15 #include <linux/types.h>
  16 #include <linux/compiler.h> /* __aligned */
  17 #include <net/sock.h>
  18
  19 #include "smc_ib.h"
  20
  21 #define SMC_V1          1               /* SMC version V1 */
  22 #define SMC_V2          2               /* SMC version V2 */
  23 #define SMC_RELEASE     0
  24
  25 #define SMCPROTO_SMC            0       /* SMC protocol, IPv4 */
  26 #define SMCPROTO_SMC6           1       /* SMC protocol, IPv6 */
  27
  28 #define SMC_MAX_ISM_DEVS        8       /* max # of proposed non-native ISM
  29                                          * devices
  30                                          */
  31
  32 extern struct proto smc_proto;
  33 extern struct proto smc_proto6;
  34
  35 #ifdef ATOMIC64_INIT
  36 #define KERNEL_HAS_ATOMIC64
  37 #endif
  38
  39 enum smc_state {                /* possible states of an SMC socket */
  40         SMC_ACTIVE      = 1,
  41         SMC_INIT        = 2,
  42         SMC_CLOSED      = 7,
  43         SMC_LISTEN      = 10,
  44         /* normal close */
  45         SMC_PEERCLOSEWAIT1      = 20,
  46         SMC_PEERCLOSEWAIT2      = 21,
  47         SMC_APPFINCLOSEWAIT     = 24,
  48         SMC_APPCLOSEWAIT1       = 22,
  49         SMC_APPCLOSEWAIT2       = 23,
  50         SMC_PEERFINCLOSEWAIT    = 25,
  51         /* abnormal close */
  52         SMC_PEERABORTWAIT       = 26,
  53         SMC_PROCESSABORT        = 27,
  54 };
  55
  56 struct smc_link_group;
  57
  58 struct smc_wr_rx_hdr {  /* common prefix part of LLC and CDC to demultiplex */
  59         union {
  60                 u8 type;
  61 #if defined(__BIG_ENDIAN_BITFIELD)
  62                 struct {
  63                         u8 llc_version:4,
  64                            llc_type:4;
  65                 };
  66 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  67                 struct {
  68                         u8 llc_type:4,
  69                            llc_version:4;
  70                 };
  71 #endif
  72         };
  73 } __aligned(1);
  74
  75 struct smc_cdc_conn_state_flags {
  76 #if defined(__BIG_ENDIAN_BITFIELD)
  77         u8      peer_done_writing : 1;  /* Sending done indicator */
  78         u8      peer_conn_closed : 1;   /* Peer connection closed indicator */
  79         u8      peer_conn_abort : 1;    /* Abnormal close indicator */
  80         u8      reserved : 5;
  81 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  82         u8      reserved : 5;
  83         u8      peer_conn_abort : 1;
  84         u8      peer_conn_closed : 1;
  85         u8      peer_done_writing : 1;
  86 #endif
  87 };
  88
  89 struct smc_cdc_producer_flags {
  90 #if defined(__BIG_ENDIAN_BITFIELD)
  91         u8      write_blocked : 1;      /* Writing Blocked, no rx buf space */
  92         u8      urg_data_pending : 1;   /* Urgent Data Pending */
  93         u8      urg_data_present : 1;   /* Urgent Data Present */
  94         u8      cons_curs_upd_req : 1;  /* cursor update requested */
  95         u8      failover_validation : 1;/* message replay due to failover */
  96         u8      reserved : 3;
  97 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  98         u8      reserved : 3;
  99         u8      failover_validation : 1;
 100         u8      cons_curs_upd_req : 1;
 101         u8      urg_data_present : 1;
 102         u8      urg_data_pending : 1;
 103         u8      write_blocked : 1;
 104 #endif
 105 };
 106
 107 /* in host byte order */
 108 union smc_host_cursor { /* SMC cursor - an offset in an RMBE */
 109         struct {
 110                 u16     reserved;
 111                 u16     wrap;           /* window wrap sequence number */
 112                 u32     count;          /* cursor (= offset) part */
 113         };
 114 #ifdef KERNEL_HAS_ATOMIC64
 115         atomic64_t              acurs;  /* for atomic processing */
 116 #else
 117         u64                     acurs;  /* for atomic processing */
 118 #endif
 119 } __aligned(8);
 120
 121 /* in host byte order, except for flag bitfields in network byte order */
 122 struct smc_host_cdc_msg {               /* Connection Data Control message */
 123         struct smc_wr_rx_hdr            common; /* .type = 0xFE */
 124         u8                              len;    /* length = 44 */
 125         u16                             seqno;  /* connection seq # */
 126         u32                             token;  /* alert_token */
 127         union smc_host_cursor           prod;           /* producer cursor */
 128         union smc_host_cursor           cons;           /* consumer cursor,
 129                                                          * piggy backed "ack"
 130                                                          */
 131         struct smc_cdc_producer_flags   prod_flags;     /* conn. tx/rx status */
 132         struct smc_cdc_conn_state_flags conn_state_flags; /* peer conn. status*/
 133         u8                              reserved[18];
 134 } __aligned(8);
 135
 136 enum smc_urg_state {
 137         SMC_URG_VALID   = 1,                    /* data present */
 138         SMC_URG_NOTYET  = 2,                    /* data pending */
 139         SMC_URG_READ    = 3,                    /* data was already read */
 140 };
 141
 142 struct smc_mark_woken {
 143         bool woken;
 144         void *key;
 145         wait_queue_entry_t wait_entry;
 146 };
 147
 148 struct smc_connection {
 149         struct rb_node          alert_node;
 150         struct smc_link_group   *lgr;           /* link group of connection */
 151         struct smc_link         *lnk;           /* assigned SMC-R link */
 152         u32                     alert_token_local; /* unique conn. id */
 153         u8                      peer_rmbe_idx;  /* from tcp handshake */
 154         int                     peer_rmbe_size; /* size of peer rx buffer */
 155         atomic_t                peer_rmbe_space;/* remaining free bytes in peer
 156                                                  * rmbe
 157                                                  */
 158         int                     rtoken_idx;     /* idx to peer RMB rkey/addr */
 159
 160         struct smc_buf_desc     *sndbuf_desc;   /* send buffer descriptor */
 161         struct smc_buf_desc     *rmb_desc;      /* RMBE descriptor */
 162         int                     rmbe_size_short;/* compressed notation */
 163         int                     rmbe_update_limit;
 164                                                 /* lower limit for consumer
 165                                                  * cursor update
 166                                                  */
 167
 168         struct smc_host_cdc_msg local_tx_ctrl;  /* host byte order staging
 169                                                  * buffer for CDC msg send
 170                                                  * .prod cf. TCP snd_nxt
 171                                                  * .cons cf. TCP sends ack
 172                                                  */
 173         union smc_host_cursor   local_tx_ctrl_fin;
 174                                                 /* prod crsr - confirmed by peer
 175                                                  */
 176         union smc_host_cursor   tx_curs_prep;   /* tx - prepared data
 177                                                  * snd_max..wmem_alloc
 178                                                  */
 179         union smc_host_cursor   tx_curs_sent;   /* tx - sent data
 180                                                  * snd_nxt ?
 181                                                  */
 182         union smc_host_cursor   tx_curs_fin;    /* tx - confirmed by peer
 183                                                  * snd-wnd-begin ?
 184                                                  */
 185         atomic_t                sndbuf_space;   /* remaining space in sndbuf */
 186         u16                     tx_cdc_seq;     /* sequence # for CDC send */
 187         u16                     tx_cdc_seq_fin; /* sequence # - tx completed */
 188         spinlock_t              send_lock;      /* protect wr_sends */
 189         atomic_t                cdc_pend_tx_wr; /* number of pending tx CDC wqe
 190                                                  * - inc when post wqe,
 191                                                  * - dec on polled tx cqe
 192                                                  */
 193         wait_queue_head_t       cdc_pend_tx_wq; /* wakeup on no cdc_pend_tx_wr*/
 194         struct delayed_work     tx_work;        /* retry of smc_cdc_msg_send */
 195         u32                     tx_off;         /* base offset in peer rmb */
 196
 197         struct smc_host_cdc_msg local_rx_ctrl;  /* filled during event_handl.
 198                                                  * .prod cf. TCP rcv_nxt
 199                                                  * .cons cf. TCP snd_una
 200                                                  */
 201         union smc_host_cursor   rx_curs_confirmed; /* confirmed to peer
 202                                                     * source of snd_una ?
 203                                                     */
 204         union smc_host_cursor   urg_curs;       /* points at urgent byte */
 205         enum smc_urg_state      urg_state;
 206         bool                    urg_tx_pend;    /* urgent data staged */
 207         bool                    urg_rx_skip_pend;
 208                                                 /* indicate urgent oob data
 209                                                  * read, but previous regular
 210                                                  * data still pending
 211                                                  */
 212         char                    urg_rx_byte;    /* urgent byte */
 213         atomic_t                bytes_to_rcv;   /* arrived data,
 214                                                  * not yet received
 215                                                  */
 216         atomic_t                splice_pending; /* number of spliced bytes
 217                                                  * pending processing
 218                                                  */
 219 #ifndef KERNEL_HAS_ATOMIC64
 220         spinlock_t              acurs_lock;     /* protect cursors */
 221 #endif
 222         struct work_struct      close_work;     /* peer sent some closing */
 223         struct work_struct      abort_work;     /* abort the connection */
 224         struct tasklet_struct   rx_tsklet;      /* Receiver tasklet for SMC-D */
 225         u8                      rx_off;         /* receive offset:
 226                                                  * 0 for SMC-R, 32 for SMC-D
 227                                                  */
 228         u64                     peer_token;     /* SMC-D token of peer */
 229         u8                      killed : 1;     /* abnormal termination */
 230         u8                      freed : 1;      /* normal termiation */
 231         u8                      out_of_sync : 1; /* out of sync with peer */
 232 };
 233
 234 struct smc_sock {                               /* smc sock container */
 235         struct sock             sk;
 236         struct socket           *clcsock;       /* internal tcp socket */
 237         void                    (*clcsk_state_change)(struct sock *sk);
 238                                                 /* original stat_change fct. */
 239         void                    (*clcsk_data_ready)(struct sock *sk);
 240                                                 /* original data_ready fct. */
 241         void                    (*clcsk_write_space)(struct sock *sk);
 242                                                 /* original write_space fct. */
 243         void                    (*clcsk_error_report)(struct sock *sk);
 244                                                 /* original error_report fct. */
 245         struct smc_connection   conn;           /* smc connection */
 246         struct smc_sock         *listen_smc;    /* listen parent */
 247         struct work_struct      connect_work;   /* handle non-blocking connect*/
 248         struct work_struct      tcp_listen_work;/* handle tcp socket accepts */
 249         struct work_struct      smc_listen_work;/* prepare new accept socket */
 250         struct list_head        accept_q;       /* sockets to be accepted */
 251         spinlock_t              accept_q_lock;  /* protects accept_q */
 252         bool                    use_fallback;   /* fallback to tcp */
 253         int                     fallback_rsn;   /* reason for fallback */
 254         u32                     peer_diagnosis; /* decline reason from peer */
 255         int                     sockopt_defer_accept;
 256                                                 /* sockopt TCP_DEFER_ACCEPT
 257                                                  * value
 258                                                  */
 259         u8                      wait_close_tx_prepared : 1;
 260                                                 /* shutdown wr or close
 261                                                  * started, waiting for unsent
 262                                                  * data to be sent
 263                                                  */
 264         u8                      connect_nonblock : 1;
 265                                                 /* non-blocking connect in
 266                                                  * flight
 267                                                  */
 268         struct mutex            clcsock_release_lock;
 269                                                 /* protects clcsock of a listen
 270                                                  * socket
 271                                                  * */
 272 };
 273
 274 static inline struct smc_sock *smc_sk(const struct sock *sk)
 275 {
 276         return (struct smc_sock *)sk;
 277 }
 278
 279 static inline struct smc_sock *smc_clcsock_user_data(struct sock *clcsk)
 280 {
 281         return (struct smc_sock *)
 282                ((uintptr_t)clcsk->sk_user_data & ~SK_USER_DATA_NOCOPY);
 283 }
 284
 285 extern struct workqueue_struct  *smc_hs_wq;     /* wq for handshake work */
 286 extern struct workqueue_struct  *smc_close_wq;  /* wq for close work */
 287
 288 #define SMC_SYSTEMID_LEN                8
 289
 290 extern u8       local_systemid[SMC_SYSTEMID_LEN]; /* unique system identifier */
 291
 292 #define ntohll(x) be64_to_cpu(x)
 293 #define htonll(x) cpu_to_be64(x)
 294
 295 /* convert an u32 value into network byte order, store it into a 3 byte field */
 296 static inline void hton24(u8 *net, u32 host)
 297 {
 298         __be32 t;
 299
 300         t = cpu_to_be32(host);
 301         memcpy(net, ((u8 *)&t) + 1, 3);
 302 }
 303
 304 /* convert a received 3 byte field into host byte order*/
 305 static inline u32 ntoh24(u8 *net)
 306 {
 307         __be32 t = 0;
 308
 309         memcpy(((u8 *)&t) + 1, net, 3);
 310         return be32_to_cpu(t);
 311 }
 312
 313 #ifdef CONFIG_XFRM
 314 static inline bool using_ipsec(struct smc_sock *smc)
 315 {
 316         return (smc->clcsock->sk->sk_policy[0] ||
 317                 smc->clcsock->sk->sk_policy[1]) ? true : false;
 318 }
 319 #else
 320 static inline bool using_ipsec(struct smc_sock *smc)
 321 {
 322         return false;
 323 }
 324 #endif
 325
 326 struct smc_gidlist;
 327
 328 struct sock *smc_accept_dequeue(struct sock *parent, struct socket *new_sock);
 329 void smc_close_non_accepted(struct sock *sk);
 330 void smc_fill_gid_list(struct smc_link_group *lgr,
 331                        struct smc_gidlist *gidlist,
 332                        struct smc_ib_device *known_dev, u8 *known_gid);
 333
 334 #endif  /* __SMC_H */