1/*
2 * Copyright (c) 2016-2017  Intel Corporation.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#ifndef _TCP_STREAM_H_
17#define _TCP_STREAM_H_
18
19#include <rte_vect.h>
20#include <tle_dring.h>
21#include <tle_memtank.h>
22#include <tle_tcp.h>
23#include <tle_event.h>
24
25#include "stream.h"
26#include "misc.h"
27#include "tcp_misc.h"
28
29#ifdef __cplusplus
30extern "C" {
31#endif
32
33enum {
34	TCP_ST_CLOSED,
35	TCP_ST_LISTEN,
36	TCP_ST_SYN_SENT,
37	TCP_ST_SYN_RCVD,
38	TCP_ST_ESTABLISHED,
39	TCP_ST_FIN_WAIT_1,
40	TCP_ST_FIN_WAIT_2,
41	TCP_ST_CLOSE_WAIT,
42	TCP_ST_CLOSING,
43	TCP_ST_LAST_ACK,
44	TCP_ST_TIME_WAIT,
45	TCP_ST_NUM
46};
47
48enum {
49	TCP_OP_LISTEN =  0x1,
50	TCP_OP_ACCEPT =  0x2,
51	TCP_OP_CONNECT = 0x4,
52	TCP_OP_CLOSE =   0x8,
53};
54
55struct tcb {
56	volatile uint16_t state;
57	volatile uint16_t uop; /* operations by user performed */
58	struct {
59		uint32_t nxt;
60		uint32_t irs; /* initial received sequence */
61		uint32_t wnd;
62		uint32_t ts;
63		struct {
64			uint32_t seq;
65			uint32_t on;
66		} frs;
67		uint32_t srtt;   /* smoothed round trip time (scaled by >> 3) */
68		uint32_t rttvar; /* rtt variance */
69		uint16_t mss;
70		uint8_t  wscale;
71		uint8_t  dupack;
72	} rcv;
73	struct {
74		uint64_t nxt;
75		uint64_t una;
76		uint64_t rcvr; /* recover RFC 6582 */
77		uint64_t fss;  /* FIN sequence # */
78		uint32_t fastack; /* # of partial acks in fast retransmit */
79		uint32_t wnd;
80		union wui wu; /* window update */
81		uint32_t ack; /* last sent ack */
82		uint32_t ts;
83		uint32_t cwnd;     /* congestion window */
84		uint32_t ssthresh; /* slow start threshold */
85		uint32_t rto;      /* retransmission timeout */
86		uint32_t rto_tw;   /* TIME_WAIT retransmission timeout */
87		uint32_t iss;      /* initial send sequence */
88		uint16_t mss;
89		uint8_t  wscale;
90		uint8_t nb_retx; /* number of retransmission */
91		uint8_t nb_retm; /**< max number of retx attempts. */
92	} snd;
93	struct syn_opts so; /* initial syn options. */
94};
95
96struct tle_tcp_stream {
97
98	struct tle_stream s;
99
100	uint32_t flags;
101	rte_atomic32_t use;
102
103	struct stbl_entry *ste;     /* entry in streams table. */
104	struct tcb tcb;
105
106	struct {
107		void *handle;
108	} timer;
109
110	struct {
111		struct tle_event *ev;
112		struct tle_stream_cb cb;
113	} err;
114
115	struct {
116		struct rte_ring *q;     /* listen (syn) queue */
117		struct ofo *ofo;
118		struct tle_event *ev;    /* user provided recv event. */
119		struct tle_stream_cb cb; /* user provided recv callback. */
120	} rx __rte_cache_aligned;
121
122	struct {
123		rte_atomic32_t arm;  /* when > 0 stream is in to-send queue */
124		struct {
125			uint32_t nb_elem;  /* number of objects per drb. */
126			uint32_t nb_max;   /* number of drbs per stream. */
127			struct rte_ring *r;
128		} drb;
129		struct rte_ring *q;  /* (re)tx queue */
130		struct tle_event *ev;
131		struct tle_stream_cb cb;
132		struct tle_dest dst;
133	} tx __rte_cache_aligned;
134
135} __rte_cache_aligned;
136
137#define TCP_STREAM(p)	\
138((struct tle_tcp_stream *)((uintptr_t)(p) - offsetof(struct tle_tcp_stream, s)))
139
140#define TCP_STREAM_TX_PENDING(s)	\
141	((s)->tx.drb.nb_max != rte_ring_count((s)->tx.drb.r))
142
143#define TCP_STREAM_TX_FINISHED(s)	\
144	((s)->tx.drb.nb_max == rte_ring_count((s)->tx.drb.r))
145
146#include "stream_table.h"
147
148struct sdr {
149	rte_spinlock_t lock;
150	STAILQ_HEAD(, tle_stream) fe;
151	STAILQ_HEAD(, tle_stream) be;
152};
153
154/* tempalte sizes/offsets/etc. for tcp stream */
155struct stream_szofs {
156	uint32_t size;
157	struct {
158		uint32_t ofs;
159		uint32_t nb_obj;
160		uint32_t nb_max;
161	} ofo;
162	struct {
163		uint32_t ofs;
164		uint32_t nb_obj;
165	} rxq, txq;
166	struct {
167		uint32_t ofs;
168		uint32_t blk_sz;
169		uint32_t rng_sz;
170		uint32_t nb_rng;
171		uint32_t nb_obj;
172		uint32_t nb_max;
173	} drb;
174};
175
176struct tcp_streams {
177	struct stbl st;
178	struct tle_timer_wheel *tmr; /* timer wheel */
179	struct rte_ring *tsq;        /* to-send streams queue */
180	struct tle_memtank *mts;     /* memtank to allocate streams from */
181	struct sdr dr;               /* death row for zombie streams */
182	struct stream_szofs szofs;   /* size and offsets for stream data */
183};
184
185#define CTX_TCP_STREAMS(ctx)	((struct tcp_streams *)(ctx)->streams.buf)
186#define CTX_TCP_STLB(ctx)	(&CTX_TCP_STREAMS(ctx)->st)
187#define CTX_TCP_TMWHL(ctx)	(CTX_TCP_STREAMS(ctx)->tmr)
188#define CTX_TCP_TSQ(ctx)	(CTX_TCP_STREAMS(ctx)->tsq)
189#define CTX_TCP_SDR(ctx)	(&CTX_TCP_STREAMS(ctx)->dr)
190#define CTX_TCP_MTS(ctx)	(CTX_TCP_STREAMS(ctx)->mts)
191
192#ifdef __cplusplus
193}
194#endif
195
196#endif /* _TCP_STREAM_H_ */
197