src/vnet/tcp/tcp_debug.h

   1 /*
   2  * Copyright (c) 2017-2019 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_DEBUG_H_
  17 #define SRC_VNET_TCP_TCP_DEBUG_H_
  18
  19 #include <vlib/vlib.h>
  20
  21 /**
  22  * Build debugging infra unconditionally. Debug components controlled via
  23  * debug configuration. Comes with some overhead so it's not recommended for
  24  * production/performance scenarios. Takes priority over TCP_DEBUG_ENABLE.
  25  */
  26 #define TCP_DEBUG_ALWAYS (0)
  27 /**
  28  * Build debugging infra only if enabled. Debug components controlled via
  29  * macros that follow.
  30  */
  31 #define TCP_DEBUG_ENABLE (0)
  32
  33 #define TCP_DEBUG_SM (0)
  34 #define TCP_DEBUG_CC (0)
  35 #define TCP_DEBUG_CS (0)
  36 #define TCP_DEBUG_LC (0 || TCP_DEBUG_SM || TCP_DEBUG_CC || TCP_DEBUG_CS)
  37
  38 #define TCP_DEBUG (TCP_DEBUG_ALWAYS || TCP_DEBUG_ENABLE)
  39 #define TCP_DEBUG_BUF_ALLOC (0)
  40
  41 #if TCP_DEBUG > 0
  42 #define TRANSPORT_DEBUG (1)
  43 #endif
  44
  45 #define TCP_CONCAT_HELPER(_a, _b) _a##_b
  46 #define TCP_CC(_a, _b) TCP_CONCAT_HELPER(_a, _b)
  47
  48 #define tcp_evt_lvl(_evt) TCP_CC(_evt, _LVL)
  49 #define tcp_evt_grp(_evt) TCP_CC(_evt, _GRP)
  50 #define tcp_evt_handler(_evt, _args...) TCP_CC(_evt, _HANDLER) (_args)
  51 #define tcp_evt_grp_dbg_lvl(_evt) tcp_dbg_main.grp_dbg_lvl[tcp_evt_grp (_evt)]
  52
  53 #define foreach_tcp_evt_grp                                     \
  54   _(LC, "life cycle")                                           \
  55   _(SM, "state machine")                                        \
  56   _(CC, "congestion control")                                   \
  57   _(CS, "cc stats")                                             \
  58
  59 typedef enum tcp_evt_grp_
  60 {
  61 #define _(sym, str) TCP_EVT_GRP_ ## sym,
  62   foreach_tcp_evt_grp
  63 #undef _
  64   TCP_EVT_N_GRP
  65 } tcp_evt_grp_e;
  66
  67 typedef struct tcp_dbg_main_
  68 {
  69   u8 grp_dbg_lvl[TCP_EVT_N_GRP];
  70   u32 *free_track_indices;
  71 } tcp_dbg_main_t;
  72
  73 extern tcp_dbg_main_t tcp_dbg_main;
  74
  75 #define foreach_tcp_dbg_evt                                     \
  76   _(INIT,               LC, 1, "init")                          \
  77   _(DEALLOC,            LC, 1, "dealloc")                       \
  78   _(OPEN,               LC, 1, "open")                          \
  79   _(CLOSE,              LC, 1, "close")                         \
  80   _(BIND,               LC, 1, "bind")                          \
  81   _(UNBIND,             LC, 1, "unbind")                        \
  82   _(DELETE,             LC, 1, "delete")                        \
  83   _(SYN_RCVD,           LC, 1, "SYN rcvd")                      \
  84   _(STATE_CHANGE,       LC, 1, "state change")                  \
  85   _(SYN_SENT,           SM, 1, "SYN sent")                      \
  86   _(SYN_RXT,            SM, 1, "SYN retransmit")                \
  87   _(SYNACK_SENT,        SM, 1, "SYNACK sent")                   \
  88   _(SYNACK_RCVD,        SM, 1, "SYNACK rcvd")                   \
  89   _(FIN_SENT,           SM, 1, "FIN sent")                      \
  90   _(FIN_RCVD,           SM, 1, "FIN rcvd")                      \
  91   _(RST_SENT,           SM, 1, "RST sent")                      \
  92   _(RST_RCVD,           SM, 1, "RST rcvd")                      \
  93   _(TIMER_POP,          SM, 1, "timer pop")                     \
  94   _(SEG_INVALID,        SM, 2, "invalid segment")               \
  95   _(PAWS_FAIL,          SM, 2, "failed paws check")             \
  96   _(ACK_RCV_ERR,        SM, 2, "invalid ack")                   \
  97   _(RCV_WND_SHRUNK,     SM, 2, "shrunk rcv_wnd")                \
  98   _(ACK_SENT,           SM, 3, "ACK sent")                      \
  99   _(ACK_RCVD,           SM, 3, "ACK rcvd")                      \
 100   _(PKTIZE,             SM, 3, "packetize")                     \
 101   _(INPUT,              SM, 3, "in")                            \
 102   _(OUTPUT,             SM, 4, "output")                        \
 103   _(SND_WND,            SM, 4, "snd_wnd update")                \
 104   _(CC_EVT,             CC, 1, "cc event")                      \
 105   _(CC_RTX,             CC, 2, "retransmit")                    \
 106   _(CC_PACK,            CC, 2, "cc partial ack")                \
 107   _(DUPACK_SENT,        CC, 2, "DUPACK sent")                   \
 108   _(DUPACK_RCVD,        CC, 2, "DUPACK rcvd")                   \
 109   _(CC_SCOREBOARD,      CC, 2, "scoreboard stats")              \
 110   _(CC_SACKS,           CC, 2, "snd sacks stats")               \
 111   _(CC_INPUT,           CC, 2, "ooo data delivered")            \
 112   _(CC_STAT,            CS, 1, "cc stats")                      \
 113   _(CC_RTO_STAT,        CS, 1, "cc rto stats")                  \
 114
 115 typedef enum tcp_evt_types_
 116 {
 117 #define _(sym, grp, lvl, str) TCP_EVT_##sym,
 118   foreach_tcp_dbg_evt
 119 #undef _
 120 } tcp_evt_types_e;
 121
 122 typedef enum tcp_evt_lvl_
 123 {
 124 #define _(sym, grp, lvl, str) TCP_EVT_## sym ## _LVL = lvl,
 125   foreach_tcp_dbg_evt
 126 #undef _
 127 } tcp_evt_lvl_e;
 128
 129 typedef enum tcp_evt_to_grp_
 130 {
 131 #define _(sym, grp, lvl, str) TCP_EVT_ ## sym ## _GRP = TCP_EVT_GRP_ ## grp,
 132   foreach_tcp_dbg_evt
 133 #undef _
 134 } tcp_evt_to_grp_e;
 135
 136 #if TCP_DEBUG_ALWAYS > 0
 137 #define TCP_EVT(_evt, _args...)                                         \
 138   if (PREDICT_FALSE (tcp_evt_grp_dbg_lvl (_evt) >= tcp_evt_lvl (_evt))) \
 139     tcp_evt_handler (_evt, _args)
 140 #define TCP_DBG(_fmt, _args...) clib_warning (_fmt, ##_args)
 141 #elif TCP_DEBUG_ENABLE > 0
 142 #define TCP_EVT(_evt, _args...) tcp_evt_handler(_evt, _args)
 143 #define TCP_DBG(_fmt, _args...) clib_warning (_fmt, ##_args)
 144 #else
 145 #define TCP_EVT(_evt, _args...)
 146 #define TCP_DBG(_fmt, _args...)
 147 #endif
 148
 149 void tcp_evt_track_register (elog_track_t * et);
 150 void tcp_debug_init (void);
 151
 152 #define TCP_DECLARE_ETD(_tc, _e, _size)                                 \
 153 struct                                                                  \
 154 {                                                                       \
 155   u32 data[_size];                                                      \
 156 } * ed;                                                                 \
 157 ed = ELOG_TRACK_DATA (&vlib_global_main.elog_main, _e,                  \
 158                       _tc->c_elog_track)                                \
 159
 160 /*
 161  * Event handlers definitions
 162  */
 163
 164 #if TCP_DEBUG_LC || TCP_DEBUG_ALWAYS
 165
 166 /*
 167  * Infra and evt track setup
 168  */
 169
 170 #define TCP_DBG_IP_TAG_LCL(_tc)                                         \
 171 {                                                                       \
 172   if (_tc->c_is_ip4)                                                    \
 173     {                                                                   \
 174       ELOG_TYPE_DECLARE (_e) =                                          \
 175       {                                                                 \
 176         .format = "lcl: %d.%d.%d.%d:%d",                                \
 177         .format_args = "i4i4i4i4i4",                                    \
 178       };                                                                \
 179       TCP_DECLARE_ETD(_tc, _e, 5);                                      \
 180       ed->data[0] = _tc->c_lcl_ip.ip4.as_u8[0];                         \
 181       ed->data[1] = _tc->c_lcl_ip.ip4.as_u8[1];                         \
 182       ed->data[2] = _tc->c_lcl_ip.ip4.as_u8[2];                         \
 183       ed->data[3] = _tc->c_lcl_ip.ip4.as_u8[3];                         \
 184       ed->data[4] = clib_net_to_host_u16(_tc->c_lcl_port);              \
 185     }                                                                   \
 186 }
 187
 188 #define TCP_DBG_IP_TAG_RMT(_tc)                                         \
 189 {                                                                       \
 190   if (_tc->c_is_ip4)                                                    \
 191     {                                                                   \
 192       ELOG_TYPE_DECLARE (_e) =                                          \
 193       {                                                                 \
 194         .format = "rmt: %d.%d.%d.%d:%d",                                \
 195         .format_args = "i4i4i4i4i4",                                    \
 196       };                                                                \
 197       TCP_DECLARE_ETD(_tc, _e, 5);                                      \
 198       ed->data[0] = _tc->c_rmt_ip.ip4.as_u8[0];                         \
 199       ed->data[1] = _tc->c_rmt_ip.ip4.as_u8[1];                         \
 200       ed->data[2] = _tc->c_rmt_ip.ip4.as_u8[2];                         \
 201       ed->data[3] = _tc->c_rmt_ip.ip4.as_u8[3];                         \
 202       ed->data[4] = clib_net_to_host_u16(_tc->c_rmt_port);              \
 203     }                                                                   \
 204 }
 205
 206 #define TCP_EVT_INIT_HANDLER(_tc, _is_l, ...)                           \
 207 {                                                                       \
 208   char *_fmt = _is_l ? "l[%d].%d:%d%c" : "[%d].%d:%d->.%d:%d%c";        \
 209   if (_tc->c_is_ip4)                                                    \
 210     {                                                                   \
 211       _tc->c_elog_track.name =                                          \
 212         (char *) format (0, _fmt, _tc->c_thread_index,                  \
 213                          _tc->c_lcl_ip.ip4.as_u8[3],                    \
 214                          clib_net_to_host_u16(_tc->c_lcl_port),         \
 215                          _tc->c_rmt_ip.ip4.as_u8[3],                    \
 216                          clib_net_to_host_u16(_tc->c_rmt_port), 0);     \
 217     }                                                                   \
 218   else                                                                  \
 219       _tc->c_elog_track.name =                                          \
 220         (char *) format (0, _fmt, _tc->c_thread_index,                  \
 221                          _tc->c_lcl_ip.ip6.as_u8[15],                   \
 222                          clib_net_to_host_u16(_tc->c_lcl_port),         \
 223                          _tc->c_rmt_ip.ip6.as_u8[15],                   \
 224                          clib_net_to_host_u16(_tc->c_rmt_port), 0);     \
 225   tcp_evt_track_register (&_tc->c_elog_track);                          \
 226   TCP_DBG_IP_TAG_LCL(_tc);                                              \
 227   TCP_DBG_IP_TAG_RMT(_tc);                                              \
 228 }
 229
 230 #define TCP_EVT_DEALLOC_HANDLER(_tc, ...)                               \
 231 {                                                                       \
 232   vec_free (_tc->c_elog_track.name);                                    \
 233   vec_add1 (tcp_dbg_main.free_track_indices,                            \
 234             _tc->c_elog_track.track_index_plus_one - 1);                \
 235 }
 236
 237 #define TCP_EVT_OPEN_HANDLER(_tc, ...)                                  \
 238 {                                                                       \
 239   TCP_EVT_INIT_HANDLER(_tc, 0);                                         \
 240   ELOG_TYPE_DECLARE (_e) =                                              \
 241   {                                                                     \
 242     .format = "open: index %d",                                         \
 243     .format_args = "i4",                                                \
 244   };                                                                    \
 245   TCP_DECLARE_ETD(_tc, _e, 1);                                          \
 246   ed->data[0] = _tc->c_c_index;                                         \
 247 }
 248
 249 #define TCP_EVT_CLOSE_HANDLER(_tc, ...)                                 \
 250 {                                                                       \
 251   ELOG_TYPE_DECLARE (_e) =                                              \
 252   {                                                                     \
 253     .format = "close: cidx %d",                                         \
 254     .format_args = "i4",                                                \
 255   };                                                                    \
 256   TCP_DECLARE_ETD(_tc, _e, 1);                                          \
 257   ed->data[0] = _tc->c_c_index;                                         \
 258 }
 259
 260 #define TCP_EVT_BIND_HANDLER(_tc, ...)                                  \
 261 {                                                                       \
 262   TCP_EVT_INIT_HANDLER(_tc, 1);                                         \
 263   ELOG_TYPE_DECLARE (_e) =                                              \
 264   {                                                                     \
 265     .format = "bind: listener %d",                                      \
 266   };                                                                    \
 267   TCP_DECLARE_ETD(_tc, _e, 1);                                          \
 268   ed->data[0] = _tc->c_c_index;                                         \
 269 }
 270
 271 #define TCP_EVT_SYN_RCVD_HANDLER(_tc,_init, ...)                        \
 272 {                                                                       \
 273   if (_init)                                                            \
 274     TCP_EVT_INIT_HANDLER(_tc, 0);                                       \
 275   ELOG_TYPE_DECLARE (_e) =                                              \
 276   {                                                                     \
 277     .format = "syn-rx: cidx %u sidx %u irs %u",                         \
 278     .format_args = "i4i4i4",                                            \
 279   };                                                                    \
 280   TCP_DECLARE_ETD(_tc, _e, 3);                                          \
 281   ed->data[0] = _tc->c_c_index;                                         \
 282   ed->data[1] = _tc->c_s_index;                                         \
 283   ed->data[2] = _tc->irs;                                               \
 284   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 285 }
 286
 287 #define TCP_EVT_UNBIND_HANDLER(_tc, ...)                                \
 288 {                                                                       \
 289   TCP_EVT_DEALLOC_HANDLER(_tc);                                         \
 290   ELOG_TYPE_DECLARE (_e) =                                              \
 291   {                                                                     \
 292     .format = "unbind: listener %d",                                    \
 293   };                                                                    \
 294   TCP_DECLARE_ETD(_tc, _e, 1);                                          \
 295   ed->data[0] = _tc->c_c_index;                                         \
 296   TCP_EVT_DEALLOC_HANDLER(_tc);                                         \
 297 }
 298
 299 #define TCP_EVT_DELETE_HANDLER(_tc, ...)                                \
 300 {                                                                       \
 301   ELOG_TYPE_DECLARE (_e) =                                              \
 302   {                                                                     \
 303     .format = "delete: cidx %d sidx %d",                                \
 304     .format_args = "i4i4",                                              \
 305   };                                                                    \
 306   TCP_DECLARE_ETD(_tc, _e, 2);                                          \
 307   ed->data[0] = _tc->c_c_index;                                         \
 308   ed->data[1] = _tc->c_s_index;                                         \
 309   TCP_EVT_DEALLOC_HANDLER(_tc);                                         \
 310 }
 311
 312 #endif
 313
 314 /*
 315  * State machine
 316  */
 317 #if TCP_DEBUG_SM > 0 || TCP_DEBUG_ALWAYS
 318
 319 #define TCP_EVT_STATE_CHANGE_HANDLER(_tc, ...)                          \
 320 {                                                                       \
 321   ELOG_TYPE_DECLARE (_e) =                                              \
 322   {                                                                     \
 323     .format = "state: %s",                                              \
 324     .format_args = "t4",                                                \
 325     .n_enum_strings = 11,                                               \
 326     .enum_strings = {                                                   \
 327       "closed",                                                         \
 328       "listen",                                                         \
 329       "syn-sent",                                                       \
 330       "syn-rcvd",                                                       \
 331       "established",                                                    \
 332       "close_wait",                                                     \
 333       "fin-wait-1",                                                     \
 334       "last-ack",                                                       \
 335       "closing",                                                        \
 336       "fin-wait-2",                                                     \
 337       "time-wait",                                                      \
 338     },                                                                  \
 339   };                                                                    \
 340   TCP_DECLARE_ETD(_tc, _e, 1);                                          \
 341   ed->data[0] = _tc->state;                                             \
 342 }
 343
 344 #define TCP_EVT_SYN_SENT_HANDLER(_tc, ...)                              \
 345 {                                                                       \
 346   ELOG_TYPE_DECLARE (_e) =                                              \
 347   {                                                                     \
 348     .format = "syn-tx: iss %u snd_una %u snd_una_max %u snd_nxt %u",    \
 349     .format_args = "i4i4i4i4",                                          \
 350   };                                                                    \
 351   TCP_DECLARE_ETD(_tc, _e, 4);                                          \
 352   ed->data[0] = _tc->iss;                                               \
 353   ed->data[1] = _tc->snd_una - _tc->iss;                                \
 354   ed->data[2] = _tc->snd_una_max - _tc->iss;                            \
 355   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 356   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 357 }
 358
 359 #define TCP_EVT_SYNACK_SENT_HANDLER(_tc, ...)                           \
 360 {                                                                       \
 361   ELOG_TYPE_DECLARE (_e) =                                              \
 362   {                                                                     \
 363     .format = "synack-tx: iss %u irs %u snd_una %u snd_nxt %u rcv_nxt %u",\
 364     .format_args = "i4i4i4i4i4",                                        \
 365   };                                                                    \
 366   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 367   ed->data[0] = _tc->iss;                                               \
 368   ed->data[1] = _tc->irs;                                               \
 369   ed->data[2] = _tc->snd_una - _tc->iss;                                \
 370   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 371   ed->data[4] = _tc->rcv_nxt - _tc->irs;                                \
 372 }
 373
 374 #define TCP_EVT_SYNACK_RCVD_HANDLER(_tc, ...)                           \
 375 {                                                                       \
 376   ELOG_TYPE_DECLARE (_e) =                                              \
 377   {                                                                     \
 378     .format = "synack-rx: iss %u irs %u snd_una %u snd_nxt %u rcv_nxt %u",\
 379     .format_args = "i4i4i4i4i4",                                        \
 380   };                                                                    \
 381   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 382   ed->data[0] = _tc->iss;                                               \
 383   ed->data[1] = _tc->irs;                                               \
 384   ed->data[2] = _tc->snd_una - _tc->iss;                                \
 385   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 386   ed->data[4] = _tc->rcv_nxt - _tc->irs;                                \
 387   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 388 }
 389
 390 #define TCP_EVT_FIN_SENT_HANDLER(_tc, ...)                              \
 391 {                                                                       \
 392   ELOG_TYPE_DECLARE (_e) =                                              \
 393   {                                                                     \
 394     .format = "fin-tx: snd_nxt %d rcv_nxt %d",                          \
 395     .format_args = "i4i4",                                              \
 396   };                                                                    \
 397   TCP_DECLARE_ETD(_tc, _e, 2);                                          \
 398   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 399   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 400 }
 401
 402 #define TCP_EVT_RST_SENT_HANDLER(_tc, ...)                              \
 403 {                                                                       \
 404 if (_tc)                                                                \
 405   {                                                                     \
 406     ELOG_TYPE_DECLARE (_e) =                                            \
 407     {                                                                   \
 408       .format = "rst-tx: snd_nxt %d rcv_nxt %d",                        \
 409       .format_args = "i4i4",                                            \
 410     };                                                                  \
 411     TCP_DECLARE_ETD(_tc, _e, 2);                                        \
 412     ed->data[0] = _tc->snd_nxt - _tc->iss;                              \
 413     ed->data[1] = _tc->rcv_nxt - _tc->irs;                              \
 414     TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                  \
 415   }                                                                     \
 416 }
 417
 418 #define TCP_EVT_FIN_RCVD_HANDLER(_tc, ...)                              \
 419 {                                                                       \
 420   ELOG_TYPE_DECLARE (_e) =                                              \
 421   {                                                                     \
 422     .format = "fin-rx: snd_nxt %d rcv_nxt %d",                          \
 423     .format_args = "i4i4",                                              \
 424   };                                                                    \
 425   TCP_DECLARE_ETD(_tc, _e, 2);                                          \
 426   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 427   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 428 }
 429
 430 #define TCP_EVT_RST_RCVD_HANDLER(_tc, ...)                              \
 431 {                                                                       \
 432   ELOG_TYPE_DECLARE (_e) =                                              \
 433   {                                                                     \
 434     .format = "rst-rx: snd_nxt %d rcv_nxt %d",                          \
 435     .format_args = "i4i4",                                              \
 436   };                                                                    \
 437   TCP_DECLARE_ETD(_tc, _e, 2);                                          \
 438   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 439   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 440 }
 441
 442 #define TCP_EVT_SYN_RXT_HANDLER(_tc, _type, ...)                        \
 443 {                                                                       \
 444   ELOG_TYPE_DECLARE (_e) =                                              \
 445   {                                                                     \
 446     .format = "%s-rxt: iss %u irs %u snd_nxt %u rcv_nxt %u",            \
 447     .format_args = "t4i4i4i4i4",                                        \
 448     .n_enum_strings = 2,                                                \
 449     .enum_strings = {                                                   \
 450         "syn",                                                          \
 451         "synack",                                                       \
 452     },                                                                  \
 453   };                                                                    \
 454   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 455   ed->data[0] = _type;                                                  \
 456   ed->data[1] = _tc->iss;                                               \
 457   ed->data[2] = _tc->irs;                                               \
 458   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 459   ed->data[4] = _tc->rcv_nxt - _tc->irs;                                \
 460 }
 461
 462 #define TCP_EVT_TIMER_POP_HANDLER(_tc_index, _timer_id, ...)            \
 463 {                                                                       \
 464   tcp_connection_t *_tc;                                                \
 465   if (_timer_id == TCP_TIMER_RETRANSMIT_SYN)                            \
 466     {                                                                   \
 467       _tc = tcp_half_open_connection_get (_tc_index);                   \
 468     }                                                                   \
 469   else                                                                  \
 470     {                                                                   \
 471       u32 _thread_index = vlib_get_thread_index ();                     \
 472       _tc = tcp_connection_get (_tc_index, _thread_index);              \
 473     }                                                                   \
 474   ELOG_TYPE_DECLARE (_e) =                                              \
 475   {                                                                     \
 476     .format = "timer-pop: %s cidx %u sidx %u",                          \
 477     .format_args = "t4i4i4",                                            \
 478     .n_enum_strings = 8,                                                \
 479     .enum_strings = {                                                   \
 480       "retransmit",                                                     \
 481       "delack",                                                         \
 482       "persist",                                                        \
 483       "keep",                                                           \
 484       "waitclose",                                                      \
 485       "retransmit syn",                                                 \
 486       "establish",                                                      \
 487       "establish-ao",                                                   \
 488     },                                                                  \
 489   };                                                                    \
 490   if (_tc)                                                              \
 491     {                                                                   \
 492       TCP_DECLARE_ETD(_tc, _e, 3);                                      \
 493       ed->data[0] = _timer_id;                                          \
 494       ed->data[1] = _tc->c_c_index;                                     \
 495       ed->data[2] = _tc->c_s_index;                                     \
 496     }                                                                   \
 497   else                                                                  \
 498     {                                                                   \
 499       clib_warning ("pop %d for unexisting connection %d", _timer_id,   \
 500                     _tc_index);                                         \
 501     }                                                                   \
 502 }
 503
 504 #else
 505 #define TCP_EVT_SYN_SENT_HANDLER(_tc, ...)
 506 #define TCP_EVT_SYNACK_SENT_HANDLER(_tc, ...)
 507 #define TCP_EVT_SYNACK_RCVD_HANDLER(_tc, ...)
 508 #define TCP_EVT_SYN_RXT_HANDLER(_tc, ...)
 509 #define TCP_EVT_FIN_SENT_HANDLER(_tc, ...)
 510 #define TCP_EVT_RST_SENT_HANDLER(_tc, ...)
 511 #define TCP_EVT_FIN_RCVD_HANDLER(_tc, ...)
 512 #define TCP_EVT_RST_RCVD_HANDLER(_tc, ...)
 513 #define TCP_EVT_STATE_CHANGE_HANDLER(_tc, ...)
 514 #define TCP_EVT_TIMER_POP_HANDLER(_tc_index, _timer_id, ...)
 515 #endif
 516
 517 #if TCP_DEBUG_SM > 1 || TCP_DEBUG_ALWAYS
 518 #define TCP_EVT_SEG_INVALID_HANDLER(_tc, _btcp, ...)                    \
 519 {                                                                       \
 520   ELOG_TYPE_DECLARE (_e) =                                              \
 521   {                                                                     \
 522     .format = "seg-inv: seq %u end %u rcv_las %u rcv_nxt %u rcv_wnd %u",\
 523     .format_args = "i4i4i4i4i4",                                        \
 524   };                                                                    \
 525   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 526   ed->data[0] = _btcp.seq_number - _tc->irs;                            \
 527   ed->data[1] = _btcp.seq_end - _tc->irs;                               \
 528   ed->data[2] = _tc->rcv_las - _tc->irs;                                \
 529   ed->data[3] = _tc->rcv_nxt - _tc->irs;                                \
 530   ed->data[4] = _tc->rcv_wnd;                                           \
 531 }
 532
 533 #define TCP_EVT_PAWS_FAIL_HANDLER(_tc, _seq, _end, ...)                 \
 534 {                                                                       \
 535   ELOG_TYPE_DECLARE (_e) =                                              \
 536   {                                                                     \
 537     .format = "paws-err: seq %u end %u tsval %u tsval_recent %u",       \
 538     .format_args = "i4i4i4i4",                                          \
 539   };                                                                    \
 540   TCP_DECLARE_ETD(_tc, _e, 4);                                          \
 541   ed->data[0] = _seq - _tc->irs;                                        \
 542   ed->data[1] = _end - _tc->irs;                                        \
 543   ed->data[2] = _tc->rcv_opts.tsval;                                    \
 544   ed->data[3] = _tc->tsval_recent;                                      \
 545 }
 546
 547 #define TCP_EVT_ACK_RCV_ERR_HANDLER(_tc, _type, _ack, ...)              \
 548 {                                                                       \
 549   ELOG_TYPE_DECLARE (_e) =                                              \
 550   {                                                                     \
 551     .format = "ack-err: %s ack %u snd_una %u snd_nxt %u una_max %u",    \
 552     .format_args = "t4i4i4i4i4",                                        \
 553     .n_enum_strings = 3,                                                \
 554     .enum_strings = {                                                   \
 555       "invalid",                                                        \
 556       "old",                                                            \
 557       "future",                                                         \
 558     },                                                                  \
 559   };                                                                    \
 560   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 561   ed->data[0] = _type;                                                  \
 562   ed->data[1] = _ack - _tc->iss;                                        \
 563   ed->data[2] = _tc->snd_una - _tc->iss;                                \
 564   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 565   ed->data[4] = _tc->snd_una_max - _tc->iss;                            \
 566 }
 567
 568 #define TCP_EVT_RCV_WND_SHRUNK_HANDLER(_tc, _obs, _av, ...)             \
 569 {                                                                       \
 570 if (_av > 0)                                                            \
 571 {                                                                       \
 572   ELOG_TYPE_DECLARE (_e) =                                              \
 573   {                                                                     \
 574     .format = "huh?: rcv_wnd %u obsd %u av %u rcv_nxt %u rcv_las %u",   \
 575     .format_args = "i4i4i4i4i4",                                        \
 576   };                                                                    \
 577   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 578   ed->data[0] = _tc->rcv_wnd;                                           \
 579   ed->data[1] = _obs;                                                   \
 580   ed->data[2] = _av;                                                    \
 581   ed->data[3] = _tc->rcv_nxt - _tc->irs;                                \
 582   ed->data[4] = _tc->rcv_las - _tc->irs;                                \
 583 }                                                                       \
 584 }
 585 #else
 586 #define TCP_EVT_SEG_INVALID_HANDLER(_tc, _btcp, ...)
 587 #define TCP_EVT_PAWS_FAIL_HANDLER(_tc, _seq, _end, ...)
 588 #define TCP_EVT_ACK_RCV_ERR_HANDLER(_tc, _type, _ack, ...)
 589 #define TCP_EVT_RCV_WND_SHRUNK_HANDLER(_tc, _obs, _av, ...)
 590 #endif
 591
 592 #if TCP_DEBUG_SM > 2 || TCP_DEBUG_ALWAYS
 593
 594 #define TCP_EVT_ACK_SENT_HANDLER(_tc, ...)                              \
 595 {                                                                       \
 596   ELOG_TYPE_DECLARE (_e) =                                              \
 597   {                                                                     \
 598     .format = "ack-tx: acked %u rcv_nxt %u rcv_wnd %u snd_nxt %u snd_wnd %u",\
 599     .format_args = "i4i4i4i4i4",                                        \
 600   };                                                                    \
 601   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 602   ed->data[0] = _tc->rcv_nxt - _tc->rcv_las;                            \
 603   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 604   ed->data[2] = _tc->rcv_wnd;                                           \
 605   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 606   ed->data[4] = _tc->snd_wnd;                                           \
 607 }
 608
 609 #define TCP_EVT_ACK_RCVD_HANDLER(_tc, ...)                              \
 610 {                                                                       \
 611   ELOG_TYPE_DECLARE (_e) =                                              \
 612   {                                                                     \
 613     .format = "ack-rx: %u snd_una %u snd_wnd %u cwnd %u inflight %u",   \
 614     .format_args = "i4i4i4i4i4",                                        \
 615   };                                                                    \
 616   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 617   ed->data[0] = _tc->bytes_acked;                                       \
 618   ed->data[1] = _tc->snd_una - _tc->iss;                                \
 619   ed->data[2] = _tc->snd_wnd;                                           \
 620   ed->data[3] = _tc->cwnd;                                              \
 621   ed->data[4] = tcp_flight_size(_tc);                                   \
 622 }
 623
 624 #define TCP_EVT_PKTIZE_HANDLER(_tc, ...)                                \
 625 {                                                                       \
 626   ELOG_TYPE_DECLARE (_e) =                                              \
 627   {                                                                     \
 628     .format = "tx: una %u snd_nxt %u space %u flight %u rcv_wnd %u",\
 629     .format_args = "i4i4i4i4i4",                                        \
 630   };                                                                    \
 631   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 632   ed->data[0] = _tc->snd_una - _tc->iss;                                \
 633   ed->data[1] = _tc->snd_nxt - _tc->iss;                                \
 634   ed->data[2] = tcp_available_output_snd_space (_tc);                   \
 635   ed->data[3] = tcp_flight_size (_tc);                                  \
 636   ed->data[4] = _tc->rcv_wnd;                                           \
 637 }
 638
 639 #define TCP_EVT_INPUT_HANDLER(_tc, _type, _len, _written, ...)          \
 640 {                                                                       \
 641   ELOG_TYPE_DECLARE (_e) =                                              \
 642   {                                                                     \
 643     .format = "in: %s len %u written %d rcv_nxt %u rcv_wnd(o) %d",      \
 644     .format_args = "t4i4i4i4i4",                                        \
 645     .n_enum_strings = 2,                                                \
 646     .enum_strings = {                                                   \
 647       "order",                                                          \
 648       "ooo",                                                            \
 649     },                                                                  \
 650   };                                                                    \
 651   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 652   ed->data[0] = _type;                                                  \
 653   ed->data[1] = _len;                                                   \
 654   ed->data[2] = _written;                                               \
 655   ed->data[3] = (_tc->rcv_nxt - _tc->irs) + _written;                   \
 656   ed->data[4] = _tc->rcv_wnd - (_tc->rcv_nxt - _tc->rcv_las);           \
 657 }
 658
 659 #else
 660 #define TCP_EVT_ACK_SENT_HANDLER(_tc, ...)
 661 #define TCP_EVT_ACK_RCVD_HANDLER(_tc, ...)
 662 #define TCP_EVT_PKTIZE_HANDLER(_tc, ...)
 663 #define TCP_EVT_INPUT_HANDLER(_tc, _type, _len, _written, ...)
 664 #endif
 665
 666 /*
 667  * State machine verbose
 668  */
 669 #if TCP_DEBUG_SM > 3 || TCP_DEBUG_ALWAYS
 670 #define TCP_EVT_SND_WND_HANDLER(_tc, ...)                               \
 671 {                                                                       \
 672   ELOG_TYPE_DECLARE (_e) =                                              \
 673   {                                                                     \
 674     .format = "snd-wnd update: %u ",                                    \
 675     .format_args = "i4",                                                \
 676   };                                                                    \
 677   TCP_DECLARE_ETD(_tc, _e, 1);                                          \
 678   ed->data[0] = _tc->snd_wnd;                                           \
 679 }
 680
 681 #define TCP_EVT_OUTPUT_HANDLER(_tc, flags, n_bytes,...)                 \
 682 {                                                                       \
 683   ELOG_TYPE_DECLARE (_e) =                                              \
 684   {                                                                     \
 685     .format = "out: flags %x, bytes %u",                                \
 686     .format_args = "i4i4",                                              \
 687   };                                                                    \
 688   TCP_DECLARE_ETD(_tc, _e, 2);                                          \
 689   ed->data[0] = flags;                                                  \
 690   ed->data[1] = n_bytes;                                                \
 691 }
 692 #else
 693 #define TCP_EVT_SND_WND_HANDLER(_tc, ...)
 694 #define TCP_EVT_OUTPUT_HANDLER(_tc, flags, n_bytes,...)
 695 #endif
 696
 697 /*
 698  * Congestion Control
 699  */
 700
 701 #if TCP_DEBUG_CC || TCP_DEBUG_ALWAYS
 702
 703 #define TCP_EVT_CC_EVT_PRINT(_tc, _sub_evt)                             \
 704 {                                                                       \
 705   ELOG_TYPE_DECLARE (_e) =                                              \
 706   {                                                                     \
 707     .format = "cc: %s snd_space %u snd_una %u out %u flight %u",        \
 708     .format_args = "t4i4i4i4i4",                                        \
 709     .n_enum_strings = 7,                                                \
 710     .enum_strings = {                                                   \
 711       "fast-rxt",                                                       \
 712       "first-rxt",                                                      \
 713       "rxt-timeout",                                                    \
 714       "recovered",                                                      \
 715       "congestion",                                                     \
 716       "undo",                                                           \
 717       "recovery",                                                       \
 718     },                                                                  \
 719   };                                                                    \
 720   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 721   ed->data[0] = _sub_evt;                                               \
 722   ed->data[1] = tcp_available_cc_snd_space (_tc);                       \
 723   ed->data[2] = _tc->snd_una - _tc->iss;                                \
 724   ed->data[3] = tcp_bytes_out(_tc);                                     \
 725   ed->data[4] = tcp_flight_size (_tc);                                  \
 726 }
 727
 728 #define TCP_EVT_CC_EVT_HANDLER(_tc, _sub_evt, ...)                      \
 729 {                                                                       \
 730   if (_tc->snd_una != _tc->iss)                                         \
 731     TCP_EVT_CC_STAT_PRINT (_tc);                                        \
 732   if ((_sub_evt <= 1 && TCP_DEBUG_CC > 1)                               \
 733       || (_sub_evt > 1 && TCP_DEBUG_CC > 0))                            \
 734       TCP_EVT_CC_EVT_PRINT (_tc, _sub_evt);                             \
 735 }
 736 #else
 737 #define TCP_EVT_CC_EVT_HANDLER(_tc, _sub_evt, ...)                      \
 738
 739 #endif
 740
 741 #if TCP_DEBUG_CC > 1 || TCP_DEBUG_ALWAYS
 742 #define TCP_EVT_CC_RTX_HANDLER(_tc, offset, n_bytes, ...)               \
 743 {                                                                       \
 744   ELOG_TYPE_DECLARE (_e) =                                              \
 745   {                                                                     \
 746     .format = "rxt: snd_nxt %u offset %u snd %u rxt %u",                \
 747     .format_args = "i4i4i4i4",                                          \
 748   };                                                                    \
 749   TCP_DECLARE_ETD(_tc, _e, 4);                                          \
 750   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 751   ed->data[1] = offset;                                                 \
 752   ed->data[2] = n_bytes;                                                \
 753   ed->data[3] = _tc->snd_rxt_bytes;                                     \
 754 }
 755
 756 #define TCP_EVT_DUPACK_SENT_HANDLER(_tc, _btcp, ...)                    \
 757 {                                                                       \
 758   ELOG_TYPE_DECLARE (_e) =                                              \
 759   {                                                                     \
 760     .format = "dack-tx: rcv_nxt %u seq %u rcv_wnd %u snd_nxt %u av_wnd %u",\
 761     .format_args = "i4i4i4i4i4",                                        \
 762   };                                                                    \
 763   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 764   ed->data[0] = _tc->rcv_nxt - _tc->irs;                                \
 765   ed->data[1] = _btcp.seq_number - _tc->irs;                            \
 766   ed->data[2] = _tc->rcv_wnd;                                           \
 767   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 768   ed->data[4] = tcp_available_snd_wnd(_tc);                             \
 769 }
 770
 771 #define TCP_EVT_DUPACK_RCVD_HANDLER(_tc, ...)                           \
 772 {                                                                       \
 773   ELOG_TYPE_DECLARE (_e) =                                              \
 774   {                                                                     \
 775     .format = "dack-rx: snd_una %u cwnd %u snd_wnd %u flight %u rcv_wnd %u",\
 776     .format_args = "i4i4i4i4i4",                                        \
 777   };                                                                    \
 778   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 779   ed->data[0] = _tc->snd_una - _tc->iss;                                \
 780   ed->data[1] = _tc->cwnd;                                              \
 781   ed->data[2] = _tc->snd_wnd;                                           \
 782   ed->data[3] = tcp_flight_size(_tc);                                   \
 783   ed->data[4] = _tc->rcv_wnd;                                           \
 784 }
 785
 786 #define TCP_EVT_CC_PACK_HANDLER(_tc, ...)                               \
 787 {                                                                       \
 788   ELOG_TYPE_DECLARE (_e) =                                              \
 789   {                                                                     \
 790     .format = "pack: snd_una %u snd_una_max %u",                        \
 791     .format_args = "i4i4",                                              \
 792   };                                                                    \
 793   TCP_DECLARE_ETD(_tc, _e, 2);                                          \
 794   ed->data[0] = _tc->snd_una - _tc->iss;                                \
 795   ed->data[1] = _tc->snd_una_max - _tc->iss;                            \
 796 }
 797 #define TCP_EVT_CC_SCOREBOARD_HANDLER(_tc, ...)                         \
 798 {                                                                       \
 799 if (TCP_DEBUG_CC > 1 && _tc->sack_sb.last_sacked_bytes)                 \
 800   {                                                                     \
 801     ELOG_TYPE_DECLARE (_e) =                                            \
 802     {                                                                   \
 803       .format = "sb1: holes %u lost %u sacked %u high %u highrxt %u",   \
 804       .format_args = "i4i4i4i4i4",                                      \
 805     };                                                                  \
 806     TCP_DECLARE_ETD(_tc, _e, 5);                                        \
 807     ed->data[0] = pool_elts(_tc->sack_sb.holes);                        \
 808     ed->data[1] = _tc->sack_sb.lost_bytes;                              \
 809     ed->data[2] = _tc->sack_sb.sacked_bytes;                            \
 810     ed->data[3] = _tc->sack_sb.high_sacked - _tc->iss;                  \
 811     ed->data[4] = _tc->sack_sb.high_rxt - _tc->iss;                     \
 812   }                                                                     \
 813 if (TCP_DEBUG_CC > 1 && _tc->sack_sb.last_sacked_bytes)                 \
 814   {                                                                     \
 815     sack_scoreboard_hole_t *hole;                                       \
 816     hole = scoreboard_first_hole (&_tc->sack_sb);                       \
 817     ELOG_TYPE_DECLARE (_e) =                                            \
 818     {                                                                   \
 819       .format = "sb2: first start: %u end %u last start %u end %u",     \
 820       .format_args = "i4i4i4i4",                                        \
 821     };                                                                  \
 822     TCP_DECLARE_ETD(_tc, _e, 4);                                        \
 823     ed->data[0] = hole ? hole->start - _tc->iss : 0;                    \
 824     ed->data[1] = hole ? hole->end - _tc->iss : 0;                      \
 825     hole = scoreboard_last_hole (&_tc->sack_sb);                        \
 826     ed->data[2] = hole ? hole->start - _tc->iss : 0;                    \
 827     ed->data[3] = hole ? hole->end - _tc->iss : 0;                      \
 828   }                                                                     \
 829 }
 830 #define TCP_EVT_CC_SACKS_HANDLER(_tc, ...)                              \
 831 {                                                                       \
 832 if (TCP_DEBUG_CC > 1)                                                   \
 833   {                                                                     \
 834     ELOG_TYPE_DECLARE (_e) =                                            \
 835     {                                                                   \
 836       .format = "sacks: blocks %u bytes %u",                            \
 837       .format_args = "i4i4",                                            \
 838     };                                                                  \
 839     TCP_DECLARE_ETD(_tc, _e, 2);                                        \
 840     ed->data[0] = vec_len (_tc->snd_sacks);                             \
 841     ed->data[1] = tcp_sack_list_bytes (_tc);                            \
 842   }                                                                     \
 843 }
 844 #define TCP_EVT_CC_INPUT_HANDLER(_tc, _len, _written, ...)              \
 845 {                                                                       \
 846   ELOG_TYPE_DECLARE (_e) =                                              \
 847   {                                                                     \
 848     .format = "cc input: len %u written %d rcv_nxt %u rcv_wnd(o) %d",   \
 849     .format_args = "i4i4i4i4",                                          \
 850   };                                                                    \
 851   TCP_DECLARE_ETD(_tc, _e, 4);                                          \
 852   ed->data[0] = _len;                                                   \
 853   ed->data[1] = _written;                                               \
 854   ed->data[2] = _tc->rcv_nxt - _tc->irs;                                \
 855   ed->data[3] = _tc->rcv_wnd - (_tc->rcv_nxt - _tc->rcv_las);           \
 856 }
 857 #else
 858 #define TCP_EVT_CC_RTX_HANDLER(_tc, offset, n_bytes, ...)
 859 #define TCP_EVT_DUPACK_SENT_HANDLER(_tc, _btcp, ...)
 860 #define TCP_EVT_DUPACK_RCVD_HANDLER(_tc, ...)
 861 #define TCP_EVT_CC_PACK_HANDLER(_tc, ...)
 862 #define TCP_EVT_CC_SCOREBOARD_HANDLER(_tc, ...)
 863 #define TCP_EVT_CC_SACKS_HANDLER(_tc, ...)
 864 #define TCP_EVT_CC_INPUT_HANDLER(_tc, _len, _written, ...)
 865 #endif
 866
 867 /*
 868  * Congestion control stats
 869  */
 870 #if TCP_DEBUG_CS || TCP_DEBUG_ALWAYS
 871
 872 #define STATS_INTERVAL 1
 873
 874 #define tcp_cc_time_to_print_stats(_tc)                                 \
 875   _tc->c_cc_stat_tstamp + STATS_INTERVAL < tcp_time_now()               \
 876   || tcp_in_fastrecovery (_tc)                                          \
 877
 878 #define TCP_EVT_CC_RTO_STAT_PRINT(_tc)                                  \
 879 {                                                                       \
 880   ELOG_TYPE_DECLARE (_e) =                                              \
 881   {                                                                     \
 882     .format = "rcv_stat: rto %u srtt %u mrtt-us %u rttvar %u",          \
 883     .format_args = "i4i4i4i4",                                          \
 884   };                                                                    \
 885   TCP_DECLARE_ETD(_tc, _e, 4);                                          \
 886   ed->data[0] = _tc->rto;                                               \
 887   ed->data[1] = _tc->srtt;                                              \
 888   ed->data[2] = (u32) (_tc->mrtt_us * 1e6);                             \
 889   ed->data[3] = _tc->rttvar;                                            \
 890 }
 891
 892 #define TCP_EVT_CC_RTO_STAT_HANDLER(_tc, ...)                           \
 893 {                                                                       \
 894 if (tcp_cc_time_to_print_stats (_tc))                                   \
 895 {                                                                       \
 896   TCP_EVT_CC_RTO_STAT_PRINT (_tc);                                      \
 897   _tc->c_cc_stat_tstamp = tcp_time_now ();                              \
 898 }                                                                       \
 899 }
 900
 901 #define TCP_EVT_CC_SND_STAT_PRINT(_tc)                                  \
 902 {                                                                       \
 903   ELOG_TYPE_DECLARE (_e) =                                              \
 904   {                                                                     \
 905     .format = "snd_stat: cc_space %u sacked %u lost %u out %u rxt %u",  \
 906     .format_args = "i4i4i4i4i4",                                        \
 907   };                                                                    \
 908   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 909   ed->data[0] = tcp_available_cc_snd_space (_tc);                       \
 910   ed->data[1] = _tc->sack_sb.sacked_bytes;                              \
 911   ed->data[2] = _tc->sack_sb.lost_bytes;                                \
 912   ed->data[3] = tcp_bytes_out (_tc);                                    \
 913   ed->data[3] = _tc->snd_rxt_bytes;                                     \
 914 }
 915
 916 #define TCP_EVT_CC_SND_STAT_HANDLER(_tc, ...)                           \
 917 {                                                                       \
 918 if (tcp_cc_time_to_print_stats (_tc))                                   \
 919 {                                                                       \
 920     TCP_EVT_CC_SND_STAT_PRINT(_tc);                                     \
 921     _tc->c_cc_stat_tstamp = tcp_time_now ();                            \
 922 }                                                                       \
 923 }
 924
 925 #define TCP_EVT_CC_STAT_PRINT(_tc)                                      \
 926 {                                                                       \
 927   ELOG_TYPE_DECLARE (_e) =                                              \
 928   {                                                                     \
 929     .format = "cc_stat: cwnd %u flight %u space %u ssthresh %u snd_wnd %u",\
 930     .format_args = "i4i4i4i4i4",                                        \
 931   };                                                                    \
 932   TCP_DECLARE_ETD(_tc, _e, 5);                                          \
 933   ed->data[0] = _tc->cwnd;                                              \
 934   ed->data[1] = tcp_flight_size (_tc);                                  \
 935   ed->data[2] = tcp_snd_space (_tc);                                    \
 936   ed->data[3] = _tc->ssthresh;                                          \
 937   ed->data[4] = _tc->snd_wnd;                                           \
 938   TCP_EVT_CC_RTO_STAT_PRINT (_tc);                                      \
 939   TCP_EVT_CC_SND_STAT_PRINT (_tc);                                      \
 940 }
 941
 942 #define TCP_EVT_CC_STAT_HANDLER(_tc, ...)                               \
 943 {                                                                       \
 944 if (tcp_cc_time_to_print_stats (_tc))                                   \
 945 {                                                                       \
 946   TCP_EVT_CC_STAT_PRINT (_tc);                                          \
 947   _tc->c_cc_stat_tstamp = tcp_time_now();                               \
 948 }                                                                       \
 949 }
 950 #else
 951 #define TCP_EVT_CC_STAT_HANDLER(_tc, ...)
 952 #define TCP_EVT_CC_STAT_PRINT(_tc)
 953 #endif
 954
 955 /*
 956  * Buffer allocation
 957  */
 958 #if TCP_DEBUG_BUF_ALLOC
 959
 960 #define TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL(thread_index)                   \
 961 {                                                                       \
 962   static u32 *buffer_fail_counters;                                     \
 963   if (PREDICT_FALSE (buffer_fail_counters == 0))                        \
 964     {                                                                   \
 965       u32 num_threads;                                                  \
 966       vlib_thread_main_t *vtm = vlib_get_thread_main ();                \
 967       num_threads = 1 /* main thread */  + vtm->n_threads;              \
 968       vec_validate (buffer_fail_counters, num_threads - 1);             \
 969     }                                                                   \
 970   if (PREDICT_FALSE (tcp_cfg.buffer_fail_fraction != 0.0))              \
 971     {                                                                   \
 972       if (PREDICT_TRUE (buffer_fail_counters[thread_index] > 0))        \
 973         {                                                               \
 974           if ((1.0 / (f32) (buffer_fail_counters[thread_index]))        \
 975               < tcp_cfg.buffer_fail_fraction)                           \
 976             {                                                           \
 977               buffer_fail_counters[thread_index] = 0.0000001;           \
 978               return -1;                                                \
 979             }                                                           \
 980         }                                                               \
 981       buffer_fail_counters[thread_index] ++;                            \
 982     }                                                                   \
 983 }
 984 #else
 985 #define TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL(thread_index)
 986 #endif
 987
 988 #endif /* SRC_VNET_TCP_TCP_DEBUG_H_ */
 989 /*
 990  * fd.io coding-style-patch-verification: ON
 991  *
 992  * Local Variables:
 993  * eval: (c-set-style "gnu")
 994  * End:
 995  */