lib/libtle_l4p/tcp_stream.h

   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
  30 extern "C" {
  31 #endif
  32
  33 enum {
  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
  48 enum {
  49         TCP_OP_LISTEN =  0x1,
  50         TCP_OP_ACCEPT =  0x2,
  51         TCP_OP_CONNECT = 0x4,
  52         TCP_OP_CLOSE =   0x8,
  53 };
  54
  55 struct 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
  96 struct 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
 148 struct 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 */
 155 struct 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
 176 struct 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_ */