~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/smc/smc.h

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp