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 SMCPROTO_SMC            0       /* SMC protocol, IPv4 */
  22 #define SMCPROTO_SMC6           1       /* SMC protocol, IPv6 */
  23
  24 #define SMC_MAX_PORTS           2       /* Max # of ports */
  25
  26 extern struct proto smc_proto;
  27 extern struct proto smc_proto6;
  28
  29 #ifdef ATOMIC64_INIT
  30 #define KERNEL_HAS_ATOMIC64
  31 #endif
  32
  33 enum smc_state {                /* possible states of an SMC socket */
  34         SMC_ACTIVE      = 1,
  35         SMC_INIT        = 2,
  36         SMC_CLOSED      = 7,
  37         SMC_LISTEN      = 10,
  38         /* normal close */
  39         SMC_PEERCLOSEWAIT1      = 20,
  40         SMC_PEERCLOSEWAIT2      = 21,
  41         SMC_APPFINCLOSEWAIT     = 24,
  42         SMC_APPCLOSEWAIT1       = 22,
  43         SMC_APPCLOSEWAIT2       = 23,
  44         SMC_PEERFINCLOSEWAIT    = 25,
  45         /* abnormal close */
  46         SMC_PEERABORTWAIT       = 26,
  47         SMC_PROCESSABORT        = 27,
  48 };
  49
  50 struct smc_link_group;
  51
  52 struct smc_wr_rx_hdr {  /* common prefix part of LLC and CDC to demultiplex */
  53         u8                      type;
  54 } __aligned(1);
  55
  56 struct smc_cdc_conn_state_flags {
  57 #if defined(__BIG_ENDIAN_BITFIELD)
  58         u8      peer_done_writing : 1;  /* Sending done indicator */
  59         u8      peer_conn_closed : 1;   /* Peer connection closed indicator */
  60         u8      peer_conn_abort : 1;    /* Abnormal close indicator */
  61         u8      reserved : 5;
  62 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  63         u8      reserved : 5;
  64         u8      peer_conn_abort : 1;
  65         u8      peer_conn_closed : 1;
  66         u8      peer_done_writing : 1;
  67 #endif
  68 };
  69
  70 struct smc_cdc_producer_flags {
  71 #if defined(__BIG_ENDIAN_BITFIELD)
  72         u8      write_blocked : 1;      /* Writing Blocked, no rx buf space */
  73         u8      urg_data_pending : 1;   /* Urgent Data Pending */
  74         u8      urg_data_present : 1;   /* Urgent Data Present */
  75         u8      cons_curs_upd_req : 1;  /* cursor update requested */
  76         u8      failover_validation : 1;/* message replay due to failover */
  77         u8      reserved : 3;
  78 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  79         u8      reserved : 3;
  80         u8      failover_validation : 1;
  81         u8      cons_curs_upd_req : 1;
  82         u8      urg_data_present : 1;
  83         u8      urg_data_pending : 1;
  84         u8      write_blocked : 1;
  85 #endif
  86 };
  87
  88 /* in host byte order */
  89 union smc_host_cursor { /* SMC cursor - an offset in an RMBE */
  90         struct {
  91                 u16     reserved;
  92                 u16     wrap;           /* window wrap sequence number */
  93                 u32     count;          /* cursor (= offset) part */
  94         };
  95 #ifdef KERNEL_HAS_ATOMIC64
  96         atomic64_t              acurs;  /* for atomic processing */
  97 #else
  98         u64                     acurs;  /* for atomic processing */
  99 #endif
 100 } __aligned(8);
 101
 102 /* in host byte order, except for flag bitfields in network byte order */
 103 struct smc_host_cdc_msg {               /* Connection Data Control message */
 104         struct smc_wr_rx_hdr            common; /* .type = 0xFE */
 105         u8                              len;    /* length = 44 */
 106         u16                             seqno;  /* connection seq # */
 107         u32                             token;  /* alert_token */
 108         union smc_host_cursor           prod;           /* producer cursor */
 109         union smc_host_cursor           cons;           /* consumer cursor,
 110                                                          * piggy backed "ack"
 111                                                          */
 112         struct smc_cdc_producer_flags   prod_flags;     /* conn. tx/rx status */
 113         struct smc_cdc_conn_state_flags conn_state_flags; /* peer conn. status*/
 114         u8                              reserved[18];
 115 } __aligned(8);
 116
 117 enum smc_urg_state {
 118         SMC_URG_VALID,                  /* data present */
 119         SMC_URG_NOTYET,                 /* data pending */
 120         SMC_URG_READ                    /* data was already read */
 121 };
 122
 123 struct smc_connection {
 124         struct rb_node          alert_node;
 125         struct smc_link_group   *lgr;           /* link group of connection */
 126         u32                     alert_token_local; /* unique conn. id */
 127         u8                      peer_rmbe_idx;  /* from tcp handshake */
 128         int                     peer_rmbe_size; /* size of peer rx buffer */
 129         atomic_t                peer_rmbe_space;/* remaining free bytes in peer
 130                                                  * rmbe
 131                                                  */
 132         int                     rtoken_idx;     /* idx to peer RMB rkey/addr */
 133
 134         struct smc_buf_desc     *sndbuf_desc;   /* send buffer descriptor */
 135         struct smc_buf_desc     *rmb_desc;      /* RMBE descriptor */
 136         int                     rmbe_size_short;/* compressed notation */
 137         int                     rmbe_update_limit;
 138                                                 /* lower limit for consumer
 139                                                  * cursor update
 140                                                  */
 141
 142         struct smc_host_cdc_msg local_tx_ctrl;  /* host byte order staging
 143                                                  * buffer for CDC msg send
 144                                                  * .prod cf. TCP snd_nxt
 145                                                  * .cons cf. TCP sends ack
 146                                                  */
 147         union smc_host_cursor   tx_curs_prep;   /* tx - prepared data
 148                                                  * snd_max..wmem_alloc
 149                                                  */
 150         union smc_host_cursor   tx_curs_sent;   /* tx - sent data
 151                                                  * snd_nxt ?
 152                                                  */
 153         union smc_host_cursor   tx_curs_fin;    /* tx - confirmed by peer
 154                                                  * snd-wnd-begin ?
 155                                                  */
 156         atomic_t                sndbuf_space;   /* remaining space in sndbuf */
 157         u16                     tx_cdc_seq;     /* sequence # for CDC send */
 158         spinlock_t              send_lock;      /* protect wr_sends */
 159         struct delayed_work     tx_work;        /* retry of smc_cdc_msg_send */
 160         u32                     tx_off;         /* base offset in peer rmb */
 161
 162         struct smc_host_cdc_msg local_rx_ctrl;  /* filled during event_handl.
 163                                                  * .prod cf. TCP rcv_nxt
 164                                                  * .cons cf. TCP snd_una
 165                                                  */
 166         union smc_host_cursor   rx_curs_confirmed; /* confirmed to peer
 167                                                     * source of snd_una ?
 168                                                     */
 169         union smc_host_cursor   urg_curs;       /* points at urgent byte */
 170         enum smc_urg_state      urg_state;
 171         bool                    urg_tx_pend;    /* urgent data staged */
 172         bool                    urg_rx_skip_pend;
 173                                                 /* indicate urgent oob data
 174                                                  * read, but previous regular
 175                                                  * data still pending
 176                                                  */
 177         char                    urg_rx_byte;    /* urgent byte */
 178         atomic_t                bytes_to_rcv;   /* arrived data,
 179                                                  * not yet received
 180                                                  */
 181         atomic_t                splice_pending; /* number of spliced bytes
 182                                                  * pending processing
 183                                                  */
 184 #ifndef KERNEL_HAS_ATOMIC64
 185         spinlock_t              acurs_lock;     /* protect cursors */
 186 #endif
 187         struct work_struct      close_work;     /* peer sent some closing */
 188 };
 189
 190 struct smc_sock {                               /* smc sock container */
 191         struct sock             sk;
 192         struct socket           *clcsock;       /* internal tcp socket */
 193         struct smc_connection   conn;           /* smc connection */
 194         struct smc_sock         *listen_smc;    /* listen parent */
 195         struct work_struct      tcp_listen_work;/* handle tcp socket accepts */
 196         struct work_struct      smc_listen_work;/* prepare new accept socket */
 197         struct list_head        accept_q;       /* sockets to be accepted */
 198         spinlock_t              accept_q_lock;  /* protects accept_q */
 199         bool                    use_fallback;   /* fallback to tcp */
 200         int                     sockopt_defer_accept;
 201                                                 /* sockopt TCP_DEFER_ACCEPT
 202                                                  * value
 203                                                  */
 204         u8                      wait_close_tx_prepared : 1;
 205                                                 /* shutdown wr or close
 206                                                  * started, waiting for unsent
 207                                                  * data to be sent
 208                                                  */
 209 };
 210
 211 static inline struct smc_sock *smc_sk(const struct sock *sk)
 212 {
 213         return (struct smc_sock *)sk;
 214 }
 215
 216 #define SMC_SYSTEMID_LEN                8
 217
 218 extern u8       local_systemid[SMC_SYSTEMID_LEN]; /* unique system identifier */
 219
 220 /* convert an u32 value into network byte order, store it into a 3 byte field */
 221 static inline void hton24(u8 *net, u32 host)
 222 {
 223         __be32 t;
 224
 225         t = cpu_to_be32(host);
 226         memcpy(net, ((u8 *)&t) + 1, 3);
 227 }
 228
 229 /* convert a received 3 byte field into host byte order*/
 230 static inline u32 ntoh24(u8 *net)
 231 {
 232         __be32 t = 0;
 233
 234         memcpy(((u8 *)&t) + 1, net, 3);
 235         return be32_to_cpu(t);
 236 }
 237
 238 #ifdef CONFIG_XFRM
 239 static inline bool using_ipsec(struct smc_sock *smc)
 240 {
 241         return (smc->clcsock->sk->sk_policy[0] ||
 242                 smc->clcsock->sk->sk_policy[1]) ? true : false;
 243 }
 244 #else
 245 static inline bool using_ipsec(struct smc_sock *smc)
 246 {
 247         return false;
 248 }
 249 #endif
 250
 251 struct sock *smc_accept_dequeue(struct sock *parent, struct socket *new_sock);
 252 void smc_close_non_accepted(struct sock *sk);
 253
 254 #endif  /* __SMC_H */