src/vnet/tcp/tcp_inlines.h

   1 /*
   2  * Copyright (c) 2020 Cisco and/or its affiliates.
   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 SRC_VNET_TCP_TCP_INLINES_H_
  17 #define SRC_VNET_TCP_TCP_INLINES_H_
  18
  19 #include <vnet/tcp/tcp.h>
  20
  21 always_inline tcp_header_t *
  22 tcp_buffer_hdr (vlib_buffer_t * b)
  23 {
  24   ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
  25   return (tcp_header_t *) (b->data + b->current_data
  26                            + vnet_buffer (b)->tcp.hdr_offset);
  27 }
  28
  29 always_inline tcp_connection_t *
  30 tcp_connection_get (u32 conn_index, u32 thread_index)
  31 {
  32   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
  33   if (PREDICT_FALSE (pool_is_free_index (wrk->connections, conn_index)))
  34     return 0;
  35   return pool_elt_at_index (wrk->connections, conn_index);
  36 }
  37
  38 always_inline tcp_connection_t *
  39 tcp_connection_get_if_valid (u32 conn_index, u32 thread_index)
  40 {
  41   tcp_worker_ctx_t *wrk;
  42   if (thread_index >= vec_len (tcp_main.wrk_ctx))
  43     return 0;
  44   wrk = tcp_get_worker (thread_index);
  45   if (pool_is_free_index (wrk->connections, conn_index))
  46     return 0;
  47   return pool_elt_at_index (wrk->connections, conn_index);
  48 }
  49
  50 always_inline void
  51 tcp_connection_set_state (tcp_connection_t * tc, tcp_state_t state)
  52 {
  53   tc->state = state;
  54   TCP_EVT (TCP_EVT_STATE_CHANGE, tc);
  55 }
  56
  57 always_inline tcp_connection_t *
  58 tcp_listener_get (u32 tli)
  59 {
  60   tcp_connection_t *tc = 0;
  61   if (!pool_is_free_index (tcp_main.listener_pool, tli))
  62     tc = pool_elt_at_index (tcp_main.listener_pool, tli);
  63   return tc;
  64 }
  65
  66 always_inline tcp_connection_t *
  67 tcp_half_open_connection_get (u32 conn_index)
  68 {
  69   tcp_connection_t *tc = 0;
  70   clib_spinlock_lock_if_init (&tcp_main.half_open_lock);
  71   if (!pool_is_free_index (tcp_main.half_open_connections, conn_index))
  72     tc = pool_elt_at_index (tcp_main.half_open_connections, conn_index);
  73   clib_spinlock_unlock_if_init (&tcp_main.half_open_lock);
  74   return tc;
  75 }
  76
  77 /**
  78  * Our estimate of the number of bytes that have left the network
  79  */
  80 always_inline u32
  81 tcp_bytes_out (const tcp_connection_t * tc)
  82 {
  83   if (tcp_opts_sack_permitted (&tc->rcv_opts))
  84     return tc->sack_sb.sacked_bytes + tc->sack_sb.lost_bytes;
  85   else
  86     return clib_min (tc->rcv_dupacks * tc->snd_mss,
  87                      tc->snd_nxt - tc->snd_una);
  88 }
  89
  90 /**
  91  * Our estimate of the number of bytes in flight (pipe size)
  92  */
  93 always_inline u32
  94 tcp_flight_size (const tcp_connection_t * tc)
  95 {
  96   int flight_size;
  97
  98   flight_size = (int) (tc->snd_nxt - tc->snd_una) - tcp_bytes_out (tc)
  99     + tc->snd_rxt_bytes - tc->rxt_delivered;
 100
 101   ASSERT (flight_size >= 0);
 102
 103   return flight_size;
 104 }
 105
 106 /**
 107  * Initial cwnd as per RFC5681
 108  */
 109 always_inline u32
 110 tcp_initial_cwnd (const tcp_connection_t * tc)
 111 {
 112   if (tcp_cfg.initial_cwnd_multiplier > 0)
 113     return tcp_cfg.initial_cwnd_multiplier * tc->snd_mss;
 114
 115   if (tc->snd_mss > 2190)
 116     return 2 * tc->snd_mss;
 117   else if (tc->snd_mss > 1095)
 118     return 3 * tc->snd_mss;
 119   else
 120     return 4 * tc->snd_mss;
 121 }
 122
 123 /*
 124  * Accumulate acked bytes for cwnd increase
 125  *
 126  * Once threshold bytes are accumulated, snd_mss bytes are added
 127  * to the cwnd.
 128  */
 129 always_inline void
 130 tcp_cwnd_accumulate (tcp_connection_t * tc, u32 thresh, u32 bytes)
 131 {
 132   tc->cwnd_acc_bytes += bytes;
 133   if (tc->cwnd_acc_bytes >= thresh)
 134     {
 135       u32 inc = tc->cwnd_acc_bytes / thresh;
 136       tc->cwnd_acc_bytes -= inc * thresh;
 137       tc->cwnd += inc * tc->snd_mss;
 138       tc->cwnd = clib_min (tc->cwnd, tc->tx_fifo_size);
 139     }
 140 }
 141
 142 always_inline u32
 143 tcp_loss_wnd (const tcp_connection_t * tc)
 144 {
 145   /* Whatever we have in flight + the packet we're about to send */
 146   return tcp_flight_size (tc) + tc->snd_mss;
 147 }
 148
 149 always_inline u32
 150 tcp_available_snd_wnd (const tcp_connection_t * tc)
 151 {
 152   return clib_min (tc->cwnd, tc->snd_wnd);
 153 }
 154
 155 always_inline u32
 156 tcp_available_output_snd_space (const tcp_connection_t * tc)
 157 {
 158   u32 available_wnd = tcp_available_snd_wnd (tc);
 159   int flight_size = (int) (tc->snd_nxt - tc->snd_una);
 160
 161   if (available_wnd <= flight_size)
 162     return 0;
 163
 164   return available_wnd - flight_size;
 165 }
 166
 167 /**
 168  * Estimate of how many bytes we can still push into the network
 169  */
 170 always_inline u32
 171 tcp_available_cc_snd_space (const tcp_connection_t * tc)
 172 {
 173   u32 available_wnd = tcp_available_snd_wnd (tc);
 174   u32 flight_size = tcp_flight_size (tc);
 175
 176   if (available_wnd <= flight_size)
 177     return 0;
 178
 179   return available_wnd - flight_size;
 180 }
 181
 182 always_inline u8
 183 tcp_is_lost_fin (tcp_connection_t * tc)
 184 {
 185   if ((tc->flags & TCP_CONN_FINSNT) && (tc->snd_una_max - tc->snd_una == 1))
 186     return 1;
 187   return 0;
 188 }
 189
 190 always_inline u32
 191 tcp_time_now (void)
 192 {
 193   return tcp_main.wrk_ctx[vlib_get_thread_index ()].time_now;
 194 }
 195
 196 always_inline u32
 197 tcp_time_now_w_thread (u32 thread_index)
 198 {
 199   return tcp_main.wrk_ctx[thread_index].time_now;
 200 }
 201
 202 /**
 203  * Generate timestamp for tcp connection
 204  */
 205 always_inline u32
 206 tcp_tstamp (tcp_connection_t * tc)
 207 {
 208   return (tcp_main.wrk_ctx[tc->c_thread_index].time_now -
 209           tc->timestamp_delta);
 210 }
 211
 212 always_inline f64
 213 tcp_time_now_us (u32 thread_index)
 214 {
 215   return transport_time_now (thread_index);
 216 }
 217
 218 always_inline u32
 219 tcp_set_time_now (tcp_worker_ctx_t * wrk)
 220 {
 221   wrk->time_now = clib_cpu_time_now () * tcp_main.tstamp_ticks_per_clock;
 222   return wrk->time_now;
 223 }
 224
 225 always_inline tcp_connection_t *
 226 tcp_input_lookup_buffer (vlib_buffer_t * b, u8 thread_index, u32 * error,
 227                          u8 is_ip4, u8 is_nolookup)
 228 {
 229   u32 fib_index = vnet_buffer (b)->ip.fib_index;
 230   int n_advance_bytes, n_data_bytes;
 231   transport_connection_t *tc;
 232   tcp_header_t *tcp;
 233   u8 result = 0;
 234
 235   if (is_ip4)
 236     {
 237       ip4_header_t *ip4 = vlib_buffer_get_current (b);
 238       int ip_hdr_bytes = ip4_header_bytes (ip4);
 239       if (PREDICT_FALSE (b->current_length < ip_hdr_bytes + sizeof (*tcp)))
 240         {
 241           *error = TCP_ERROR_LENGTH;
 242           return 0;
 243         }
 244       tcp = ip4_next_header (ip4);
 245       vnet_buffer (b)->tcp.hdr_offset = (u8 *) tcp - (u8 *) ip4;
 246       n_advance_bytes = (ip_hdr_bytes + tcp_header_bytes (tcp));
 247       n_data_bytes = clib_net_to_host_u16 (ip4->length) - n_advance_bytes;
 248
 249       /* Length check. Checksum computed by ipx_local no need to compute again */
 250       if (PREDICT_FALSE (n_data_bytes < 0))
 251         {
 252           *error = TCP_ERROR_LENGTH;
 253           return 0;
 254         }
 255
 256       if (!is_nolookup)
 257         tc = session_lookup_connection_wt4 (fib_index, &ip4->dst_address,
 258                                             &ip4->src_address, tcp->dst_port,
 259                                             tcp->src_port,
 260                                             TRANSPORT_PROTO_TCP, thread_index,
 261                                             &result);
 262     }
 263   else
 264     {
 265       ip6_header_t *ip6 = vlib_buffer_get_current (b);
 266       if (PREDICT_FALSE (b->current_length < sizeof (*ip6) + sizeof (*tcp)))
 267         {
 268           *error = TCP_ERROR_LENGTH;
 269           return 0;
 270         }
 271       tcp = ip6_next_header (ip6);
 272       vnet_buffer (b)->tcp.hdr_offset = (u8 *) tcp - (u8 *) ip6;
 273       n_advance_bytes = tcp_header_bytes (tcp);
 274       n_data_bytes = clib_net_to_host_u16 (ip6->payload_length)
 275         - n_advance_bytes;
 276       n_advance_bytes += sizeof (ip6[0]);
 277
 278       if (PREDICT_FALSE (n_data_bytes < 0))
 279         {
 280           *error = TCP_ERROR_LENGTH;
 281           return 0;
 282         }
 283
 284       if (!is_nolookup)
 285         {
 286           if (PREDICT_FALSE
 287               (ip6_address_is_link_local_unicast (&ip6->dst_address)))
 288             {
 289               ip4_main_t *im = &ip4_main;
 290               fib_index = vec_elt (im->fib_index_by_sw_if_index,
 291                                    vnet_buffer (b)->sw_if_index[VLIB_RX]);
 292             }
 293
 294           tc = session_lookup_connection_wt6 (fib_index, &ip6->dst_address,
 295                                               &ip6->src_address,
 296                                               tcp->dst_port, tcp->src_port,
 297                                               TRANSPORT_PROTO_TCP,
 298                                               thread_index, &result);
 299         }
 300     }
 301
 302   if (is_nolookup)
 303     tc =
 304       (transport_connection_t *) tcp_connection_get (vnet_buffer (b)->
 305                                                      tcp.connection_index,
 306                                                      thread_index);
 307
 308   vnet_buffer (b)->tcp.seq_number = clib_net_to_host_u32 (tcp->seq_number);
 309   vnet_buffer (b)->tcp.ack_number = clib_net_to_host_u32 (tcp->ack_number);
 310   vnet_buffer (b)->tcp.data_offset = n_advance_bytes;
 311   vnet_buffer (b)->tcp.data_len = n_data_bytes;
 312   vnet_buffer (b)->tcp.seq_end = vnet_buffer (b)->tcp.seq_number
 313     + n_data_bytes;
 314   vnet_buffer (b)->tcp.flags = 0;
 315
 316   *error = result ? TCP_ERROR_NONE + result : *error;
 317
 318   return tcp_get_connection_from_transport (tc);
 319 }
 320
 321 /**
 322  * Initialize connection by gleaning network and rcv params from buffer
 323  *
 324  * @param tc            connection to initialize
 325  * @param b             buffer whose current data is pointing at ip
 326  * @param is_ip4        flag set to 1 if using ip4
 327  */
 328 always_inline void
 329 tcp_init_w_buffer (tcp_connection_t * tc, vlib_buffer_t * b, u8 is_ip4)
 330 {
 331   tcp_header_t *th = tcp_buffer_hdr (b);
 332
 333   tc->c_lcl_port = th->dst_port;
 334   tc->c_rmt_port = th->src_port;
 335   tc->c_is_ip4 = is_ip4;
 336
 337   if (is_ip4)
 338     {
 339       ip4_header_t *ip4 = vlib_buffer_get_current (b);
 340       tc->c_lcl_ip4.as_u32 = ip4->dst_address.as_u32;
 341       tc->c_rmt_ip4.as_u32 = ip4->src_address.as_u32;
 342     }
 343   else
 344     {
 345       ip6_header_t *ip6 = vlib_buffer_get_current (b);
 346       clib_memcpy_fast (&tc->c_lcl_ip6, &ip6->dst_address,
 347                         sizeof (ip6_address_t));
 348       clib_memcpy_fast (&tc->c_rmt_ip6, &ip6->src_address,
 349                         sizeof (ip6_address_t));
 350     }
 351
 352   tc->irs = vnet_buffer (b)->tcp.seq_number;
 353   tc->rcv_nxt = vnet_buffer (b)->tcp.seq_number + 1;
 354   tc->rcv_las = tc->rcv_nxt;
 355   tc->sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
 356   tc->snd_wl1 = vnet_buffer (b)->tcp.seq_number;
 357   tc->snd_wl2 = vnet_buffer (b)->tcp.ack_number;
 358
 359   /* RFC1323: TSval timestamps sent on {SYN} and {SYN,ACK}
 360    * segments are used to initialize PAWS. */
 361   if (tcp_opts_tstamp (&tc->rcv_opts))
 362     {
 363       tc->tsval_recent = tc->rcv_opts.tsval;
 364       tc->tsval_recent_age = tcp_time_now ();
 365     }
 366
 367   if (tcp_opts_wscale (&tc->rcv_opts))
 368     tc->snd_wscale = tc->rcv_opts.wscale;
 369
 370   tc->snd_wnd = clib_net_to_host_u16 (th->window) << tc->snd_wscale;
 371 }
 372
 373 always_inline void
 374 tcp_update_rto (tcp_connection_t * tc)
 375 {
 376   tc->rto = clib_min (tc->srtt + (tc->rttvar << 2), TCP_RTO_MAX);
 377   tc->rto = clib_max (tc->rto, TCP_RTO_MIN);
 378 }
 379
 380 always_inline u8
 381 tcp_is_descheduled (tcp_connection_t * tc)
 382 {
 383   return (transport_connection_is_descheduled (&tc->connection) ? 1 : 0);
 384 }
 385
 386 /**
 387  * Push TCP header to buffer
 388  *
 389  * @param vm - vlib_main
 390  * @param b - buffer to write the header to
 391  * @param sp_net - source port net order
 392  * @param dp_net - destination port net order
 393  * @param seq - sequence number net order
 394  * @param ack - ack number net order
 395  * @param tcp_hdr_opts_len - header and options length in bytes
 396  * @param flags - header flags
 397  * @param wnd - window size
 398  *
 399  * @return - pointer to start of TCP header
 400  */
 401 always_inline void *
 402 vlib_buffer_push_tcp_net_order (vlib_buffer_t * b, u16 sp, u16 dp, u32 seq,
 403                                 u32 ack, u8 tcp_hdr_opts_len, u8 flags,
 404                                 u16 wnd)
 405 {
 406   tcp_header_t *th;
 407
 408   th = vlib_buffer_push_uninit (b, tcp_hdr_opts_len);
 409
 410   th->src_port = sp;
 411   th->dst_port = dp;
 412   th->seq_number = seq;
 413   th->ack_number = ack;
 414   th->data_offset_and_reserved = (tcp_hdr_opts_len >> 2) << 4;
 415   th->flags = flags;
 416   th->window = wnd;
 417   th->checksum = 0;
 418   th->urgent_pointer = 0;
 419   vnet_buffer (b)->l4_hdr_offset = (u8 *) th - b->data;
 420   b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
 421   return th;
 422 }
 423
 424 /**
 425  * Push TCP header to buffer
 426  *
 427  * @param b - buffer to write the header to
 428  * @param sp_net - source port net order
 429  * @param dp_net - destination port net order
 430  * @param seq - sequence number host order
 431  * @param ack - ack number host order
 432  * @param tcp_hdr_opts_len - header and options length in bytes
 433  * @param flags - header flags
 434  * @param wnd - window size
 435  *
 436  * @return - pointer to start of TCP header
 437  */
 438 always_inline void *
 439 vlib_buffer_push_tcp (vlib_buffer_t * b, u16 sp_net, u16 dp_net, u32 seq,
 440                       u32 ack, u8 tcp_hdr_opts_len, u8 flags, u16 wnd)
 441 {
 442   return vlib_buffer_push_tcp_net_order (b, sp_net, dp_net,
 443                                          clib_host_to_net_u32 (seq),
 444                                          clib_host_to_net_u32 (ack),
 445                                          tcp_hdr_opts_len, flags,
 446                                          clib_host_to_net_u16 (wnd));
 447 }
 448
 449 #endif /* SRC_VNET_TCP_TCP_INLINES_H_ */
 450
 451 /*
 452  * fd.io coding-style-patch-verification: ON
 453  *
 454  * Local Variables:
 455  * eval: (c-set-style "gnu")
 456  * End:
 457  */