src/vnet/tcp/tcp_debug.h

   1 /*
   2  * Copyright (c) 2017 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 #define TCP_DEBUG (1)
  22 #define TCP_DEBUG_SM (0)
  23 #define TCP_DEBUG_CC (1)
  24 #define TCP_DEBUG_CC_STAT (1)
  25
  26 #define foreach_tcp_dbg_evt             \
  27   _(INIT, "")                           \
  28   _(DEALLOC, "")                        \
  29   _(OPEN, "open")                       \
  30   _(CLOSE, "close")                     \
  31   _(BIND, "bind")                       \
  32   _(UNBIND, "unbind")                   \
  33   _(DELETE, "delete")                   \
  34   _(SYN_SENT, "SYN sent")               \
  35   _(SYNACK_SENT, "SYNACK sent")         \
  36   _(SYNACK_RCVD, "SYNACK rcvd")         \
  37   _(SYN_RXT, "SYN retransmit")          \
  38   _(FIN_SENT, "FIN sent")               \
  39   _(ACK_SENT, "ACK sent")               \
  40   _(DUPACK_SENT, "DUPACK sent")         \
  41   _(RST_SENT, "RST sent")               \
  42   _(SYN_RCVD, "SYN rcvd")               \
  43   _(ACK_RCVD, "ACK rcvd")               \
  44   _(DUPACK_RCVD, "DUPACK rcvd")         \
  45   _(FIN_RCVD, "FIN rcvd")               \
  46   _(RST_RCVD, "RST rcvd")               \
  47   _(STATE_CHANGE, "state change")       \
  48   _(PKTIZE, "packetize")                \
  49   _(INPUT, "in")                        \
  50   _(SND_WND, "snd_wnd update")          \
  51   _(OUTPUT, "output")                   \
  52   _(TIMER_POP, "timer pop")             \
  53   _(CC_RTX, "retransmit")               \
  54   _(CC_EVT, "cc event")                 \
  55   _(CC_PACK, "cc partial ack")          \
  56   _(CC_STAT, "cc stats")                \
  57   _(CC_RTO_STAT, "cc rto stats")        \
  58   _(SEG_INVALID, "invalid segment")     \
  59   _(PAWS_FAIL, "failed paws check")     \
  60   _(ACK_RCV_ERR, "invalid ack")         \
  61   _(RCV_WND_SHRUNK, "shrunk rcv_wnd")   \
  62
  63 typedef enum _tcp_dbg
  64 {
  65 #define _(sym, str) TCP_DBG_##sym,
  66   foreach_tcp_dbg_evt
  67 #undef _
  68 } tcp_dbg_e;
  69
  70 typedef enum _tcp_dbg_evt
  71 {
  72 #define _(sym, str) TCP_EVT_##sym,
  73   foreach_tcp_dbg_evt
  74 #undef _
  75 } tcp_dbg_evt_e;
  76
  77 #if TCP_DEBUG
  78
  79 #define TRANSPORT_DEBUG (1)
  80
  81 /*
  82  * Infra and evt track setup
  83  */
  84
  85 #define TCP_DBG(_tc, _evt, _args...)                                    \
  86 {                                                                       \
  87     u8 *_tmp = 0;                                                       \
  88     _tmp = format(_tmp, "%U", format_tcp_connection_verbose, _tc);      \
  89     clib_warning("%s", _tmp);                                           \
  90     vec_free(_tmp);                                                     \
  91 }
  92
  93 #define DECLARE_ETD(_tc, _e, _size)                                     \
  94   struct                                                                \
  95   {                                                                     \
  96     u32 data[_size];                                                    \
  97   } * ed;                                                               \
  98   ed = ELOG_TRACK_DATA (&vlib_global_main.elog_main,                    \
  99                         _e, _tc->c_elog_track)
 100
 101 #define TCP_DBG_IP_TAG_LCL(_tc)                                         \
 102 {                                                                       \
 103   if (_tc->c_is_ip4)                                                    \
 104     {                                                                   \
 105       ELOG_TYPE_DECLARE (_e) =                                          \
 106       {                                                                 \
 107         .format = "lcl: %d.%d.%d.%d:%d",                                \
 108         .format_args = "i4i4i4i4i4",                                    \
 109       };                                                                \
 110       DECLARE_ETD(_tc, _e, 5);                                          \
 111       ed->data[0] = _tc->c_lcl_ip.ip4.as_u8[0];                         \
 112       ed->data[1] = _tc->c_lcl_ip.ip4.as_u8[1];                         \
 113       ed->data[2] = _tc->c_lcl_ip.ip4.as_u8[2];                         \
 114       ed->data[3] = _tc->c_lcl_ip.ip4.as_u8[3];                         \
 115       ed->data[4] = clib_net_to_host_u16(_tc->c_lcl_port);              \
 116     }                                                                   \
 117 }
 118
 119 #define TCP_DBG_IP_TAG_RMT(_tc)                                         \
 120 {                                                                       \
 121   if (_tc->c_is_ip4)                                                    \
 122     {                                                                   \
 123       ELOG_TYPE_DECLARE (_e) =                                          \
 124       {                                                                 \
 125         .format = "rmt: %d.%d.%d.%d:%d",                                \
 126         .format_args = "i4i4i4i4i4",                                    \
 127       };                                                                \
 128       DECLARE_ETD(_tc, _e, 5);                                          \
 129       ed->data[0] = _tc->c_rmt_ip.ip4.as_u8[0];                         \
 130       ed->data[1] = _tc->c_rmt_ip.ip4.as_u8[1];                         \
 131       ed->data[2] = _tc->c_rmt_ip.ip4.as_u8[2];                         \
 132       ed->data[3] = _tc->c_rmt_ip.ip4.as_u8[3];                         \
 133       ed->data[4] = clib_net_to_host_u16(_tc->c_rmt_port);              \
 134     }                                                                   \
 135 }
 136
 137 #define TCP_EVT_INIT_HANDLER(_tc, _is_l, ...)                           \
 138 {                                                                       \
 139   char *_fmt = _is_l ? "l[%d].%d:%d%c" : "[%d].%d:%d->.%d:%d%c";        \
 140   if (_tc->c_is_ip4)                                                    \
 141     {                                                                   \
 142       _tc->c_elog_track.name =                                          \
 143         (char *) format (0, _fmt, _tc->c_thread_index,                  \
 144                          _tc->c_lcl_ip.ip4.as_u8[3],                    \
 145                          clib_net_to_host_u16(_tc->c_lcl_port),         \
 146                          _tc->c_rmt_ip.ip4.as_u8[3],                    \
 147                          clib_net_to_host_u16(_tc->c_rmt_port), 0);     \
 148     }                                                                   \
 149   else                                                                  \
 150       _tc->c_elog_track.name =                                          \
 151         (char *) format (0, _fmt, _tc->c_thread_index,                  \
 152                          _tc->c_lcl_ip.ip6.as_u8[15],                   \
 153                          clib_net_to_host_u16(_tc->c_lcl_port),         \
 154                          _tc->c_rmt_ip.ip6.as_u8[15],                   \
 155                          clib_net_to_host_u16(_tc->c_rmt_port), 0);     \
 156   elog_track_register (&vlib_global_main.elog_main, &_tc->c_elog_track);\
 157   TCP_DBG_IP_TAG_LCL(_tc);                                              \
 158   TCP_DBG_IP_TAG_RMT(_tc);                                              \
 159 }
 160
 161 #define TCP_EVT_DEALLOC_HANDLER(_tc, ...)                               \
 162 {                                                                       \
 163   vec_free (_tc->c_elog_track.name);                                    \
 164 }
 165
 166 #define TCP_EVT_OPEN_HANDLER(_tc, ...)                                  \
 167 {                                                                       \
 168   TCP_EVT_INIT_HANDLER(_tc, 0);                                         \
 169   ELOG_TYPE_DECLARE (_e) =                                              \
 170   {                                                                     \
 171     .format = "open: index %d",                                         \
 172     .format_args = "i4",                                                \
 173   };                                                                    \
 174   DECLARE_ETD(_tc, _e, 1);                                              \
 175   ed->data[0] = _tc->c_c_index;                                         \
 176 }
 177
 178 #define TCP_EVT_CLOSE_HANDLER(_tc, ...)                                 \
 179 {                                                                       \
 180   ELOG_TYPE_DECLARE (_e) =                                              \
 181   {                                                                     \
 182     .format = "close: %d",                                              \
 183     .format_args = "i4",                                                \
 184   };                                                                    \
 185   DECLARE_ETD(_tc, _e, 1);                                              \
 186   ed->data[0] = _tc->c_c_index;                                         \
 187 }
 188
 189 #define TCP_EVT_BIND_HANDLER(_tc, ...)                                  \
 190 {                                                                       \
 191   TCP_EVT_INIT_HANDLER(_tc, 1);                                         \
 192   ELOG_TYPE_DECLARE (_e) =                                              \
 193   {                                                                     \
 194     .format = "bind: listener %d",                                      \
 195   };                                                                    \
 196   DECLARE_ETD(_tc, _e, 1);                                              \
 197   ed->data[0] = _tc->c_c_index;                                         \
 198 }
 199
 200 #define TCP_EVT_SYN_RCVD_HANDLER(_tc,_init, ...)                                \
 201 {                                                                       \
 202   if (_init)                                                            \
 203     TCP_EVT_INIT_HANDLER(_tc, 0);                                       \
 204   ELOG_TYPE_DECLARE (_e) =                                              \
 205   {                                                                     \
 206     .format = "syn-rx: irs %u",                                         \
 207     .format_args = "i4",                                                \
 208   };                                                                    \
 209   DECLARE_ETD(_tc, _e, 1);                                              \
 210   ed->data[0] = _tc->irs;                                               \
 211   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 212 }
 213
 214 #define TCP_EVT_UNBIND_HANDLER(_tc, ...)                                \
 215 {                                                                       \
 216   TCP_EVT_DEALLOC_HANDLER(_tc);                                         \
 217   ELOG_TYPE_DECLARE (_e) =                                              \
 218   {                                                                     \
 219     .format = "unbind: listener %d",                                    \
 220   };                                                                    \
 221   DECLARE_ETD(_tc, _e, 1);                                              \
 222   ed->data[0] = _tc->c_c_index;                                         \
 223   TCP_EVT_DEALLOC_HANDLER(_tc);                                         \
 224 }
 225
 226 #define TCP_EVT_DELETE_HANDLER(_tc, ...)                                \
 227 {                                                                       \
 228   ELOG_TYPE_DECLARE (_e) =                                              \
 229   {                                                                     \
 230     .format = "delete: %d",                                             \
 231     .format_args = "i4",                                                \
 232   };                                                                    \
 233   DECLARE_ETD(_tc, _e, 1);                                              \
 234   ed->data[0] = _tc->c_c_index;                                         \
 235   TCP_EVT_DEALLOC_HANDLER(_tc);                                         \
 236 }
 237
 238 #define CONCAT_HELPER(_a, _b) _a##_b
 239 #define CC(_a, _b) CONCAT_HELPER(_a, _b)
 240 #define TCP_EVT_DBG(_evt, _args...) CC(_evt, _HANDLER)(_args)
 241 #else
 242 #define TCP_EVT_DBG(_evt, _args...)
 243 #endif
 244
 245 /*
 246  * State machine
 247  */
 248 #if TCP_DEBUG_SM
 249
 250 #define TCP_EVT_STATE_CHANGE_HANDLER(_tc, ...)                          \
 251 {                                                                       \
 252   ELOG_TYPE_DECLARE (_e) =                                              \
 253   {                                                                     \
 254     .format = "state: %s",                                              \
 255     .format_args = "t4",                                                \
 256     .n_enum_strings = 11,                                               \
 257     .enum_strings = {                                                   \
 258       "closed",                                                         \
 259       "listen",                                                         \
 260       "syn-sent",                                                       \
 261       "syn-rcvd",                                                       \
 262       "established",                                                    \
 263       "close_wait",                                                     \
 264       "fin-wait-1",                                                     \
 265       "last-ack",                                                       \
 266       "closing",                                                        \
 267       "fin-wait-2",                                                     \
 268       "time-wait",                                                      \
 269     },                                                                  \
 270   };                                                                    \
 271   DECLARE_ETD(_tc, _e, 1);                                              \
 272   ed->data[0] = _tc->state;                                             \
 273 }
 274
 275 #define TCP_EVT_SYN_SENT_HANDLER(_tc, ...)                              \
 276 {                                                                       \
 277   ELOG_TYPE_DECLARE (_e) =                                              \
 278   {                                                                     \
 279     .format = "syn-tx: iss %u snd_una %u snd_una_max %u snd_nxt %u",    \
 280     .format_args = "i4i4i4i4",                                          \
 281   };                                                                    \
 282   DECLARE_ETD(_tc, _e, 4);                                              \
 283   ed->data[0] = _tc->iss;                                               \
 284   ed->data[1] = _tc->snd_una - _tc->iss;                                        \
 285   ed->data[2] = _tc->snd_una_max - _tc->iss;                            \
 286   ed->data[3] = _tc->snd_nxt - _tc->iss;                                        \
 287   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 288 }
 289
 290 #define TCP_EVT_SYNACK_SENT_HANDLER(_tc, ...)                           \
 291 {                                                                       \
 292   ELOG_TYPE_DECLARE (_e) =                                              \
 293   {                                                                     \
 294     .format = "synack-tx: iss %u irs %u snd_una %u snd_nxt %u rcv_nxt %u",\
 295     .format_args = "i4i4i4i4i4",                                                \
 296   };                                                                    \
 297   DECLARE_ETD(_tc, _e, 5);                                              \
 298   ed->data[0] = _tc->iss;                                               \
 299   ed->data[1] = _tc->irs;                                               \
 300   ed->data[2] = _tc->snd_una - _tc->iss;                                        \
 301   ed->data[3] = _tc->snd_nxt - _tc->iss;                                        \
 302   ed->data[4] = _tc->rcv_nxt - _tc->irs;                                        \
 303 }
 304
 305 #define TCP_EVT_SYNACK_RCVD_HANDLER(_tc, ...)                           \
 306 {                                                                       \
 307   ELOG_TYPE_DECLARE (_e) =                                              \
 308   {                                                                     \
 309     .format = "synack-rx: iss %u irs %u snd_una %u snd_nxt %u rcv_nxt %u",\
 310     .format_args = "i4i4i4i4i4",                                                \
 311   };                                                                    \
 312   DECLARE_ETD(_tc, _e, 5);                                              \
 313   ed->data[0] = _tc->iss;                                               \
 314   ed->data[1] = _tc->irs;                                               \
 315   ed->data[2] = _tc->snd_una - _tc->iss;                                        \
 316   ed->data[3] = _tc->snd_nxt - _tc->iss;                                        \
 317   ed->data[4] = _tc->rcv_nxt - _tc->irs;                                        \
 318   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 319 }
 320
 321 #define TCP_EVT_FIN_SENT_HANDLER(_tc, ...)                              \
 322 {                                                                       \
 323   ELOG_TYPE_DECLARE (_e) =                                              \
 324   {                                                                     \
 325     .format = "fin-tx: snd_nxt %d rcv_nxt %d",                          \
 326     .format_args = "i4i4",                                              \
 327   };                                                                    \
 328   DECLARE_ETD(_tc, _e, 2);                                              \
 329   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 330   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 331 }
 332
 333 #define TCP_EVT_RST_SENT_HANDLER(_tc, ...)                              \
 334 {                                                                       \
 335   ELOG_TYPE_DECLARE (_e) =                                              \
 336   {                                                                     \
 337     .format = "rst-tx: snd_nxt %d rcv_nxt %d",                          \
 338     .format_args = "i4i4",                                              \
 339   };                                                                    \
 340   DECLARE_ETD(_tc, _e, 2);                                              \
 341   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 342   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 343   TCP_EVT_STATE_CHANGE_HANDLER(_tc);                                    \
 344 }
 345
 346 #define TCP_EVT_FIN_RCVD_HANDLER(_tc, ...)                              \
 347 {                                                                       \
 348   ELOG_TYPE_DECLARE (_e) =                                              \
 349   {                                                                     \
 350     .format = "fin-rx: snd_nxt %d rcv_nxt %d",                          \
 351     .format_args = "i4i4",                                              \
 352   };                                                                    \
 353   DECLARE_ETD(_tc, _e, 2);                                              \
 354   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 355   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 356 }
 357
 358 #define TCP_EVT_RST_RCVD_HANDLER(_tc, ...)                              \
 359 {                                                                       \
 360   ELOG_TYPE_DECLARE (_e) =                                              \
 361   {                                                                     \
 362     .format = "rst-rx: snd_nxt %d rcv_nxt %d",                          \
 363     .format_args = "i4i4",                                              \
 364   };                                                                    \
 365   DECLARE_ETD(_tc, _e, 2);                                              \
 366   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 367   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 368 }
 369
 370 #define TCP_EVT_SYN_RXT_HANDLER(_tc, _type, ...)                        \
 371 {                                                                       \
 372   ELOG_TYPE_DECLARE (_e) =                                              \
 373   {                                                                     \
 374     .format = "%s-rxt: iss %u irs %u snd_nxt %u rcv_nxt %u",            \
 375     .format_args = "t4i4i4i4i4",                                                \
 376     .n_enum_strings = 2,                                                \
 377     .enum_strings = {                                                   \
 378         "syn",                                                          \
 379         "syn-ack",                                                      \
 380     },                                                                  \
 381   };                                                                    \
 382   DECLARE_ETD(_tc, _e, 5);                                              \
 383   ed->data[0] = _type;                                                  \
 384   ed->data[1] = _tc->iss;                                               \
 385   ed->data[2] = _tc->irs;                                               \
 386   ed->data[3] = _tc->snd_nxt - _tc->iss;                                        \
 387   ed->data[4] = _tc->rcv_nxt - _tc->irs;                                        \
 388 }
 389
 390 #else
 391 #define TCP_EVT_SYN_SENT_HANDLER(_tc, ...)
 392 #define TCP_EVT_SYNACK_SENT_HANDLER(_tc, ...)
 393 #define TCP_EVT_SYNACK_RCVD_HANDLER(_tc, ...)
 394 #define TCP_EVT_SYN_RXT_HANDLER(_tc, ...)
 395 #define TCP_EVT_FIN_SENT_HANDLER(_tc, ...)
 396 #define TCP_EVT_RST_SENT_HANDLER(_tc, ...)
 397 #define TCP_EVT_FIN_RCVD_HANDLER(_tc, ...)
 398 #define TCP_EVT_RST_RCVD_HANDLER(_tc, ...)
 399 #define TCP_EVT_STATE_CHANGE_HANDLER(_tc, ...)
 400 #endif
 401
 402 #if TCP_DEBUG_SM > 1
 403
 404 #define TCP_EVT_ACK_SENT_HANDLER(_tc, ...)                              \
 405 {                                                                       \
 406   ELOG_TYPE_DECLARE (_e) =                                              \
 407   {                                                                     \
 408     .format = "ack-tx: acked %u rcv_nxt %u rcv_wnd %u snd_nxt %u snd_wnd %u",\
 409     .format_args = "i4i4i4i4i4",                                        \
 410   };                                                                    \
 411   DECLARE_ETD(_tc, _e, 5);                                              \
 412   ed->data[0] = _tc->rcv_nxt - _tc->rcv_las;                            \
 413   ed->data[1] = _tc->rcv_nxt - _tc->irs;                                \
 414   ed->data[2] = _tc->rcv_wnd;                                           \
 415   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 416   ed->data[4] = _tc->snd_wnd;                                           \
 417 }
 418
 419 #define TCP_EVT_DUPACK_SENT_HANDLER(_tc, ...)                           \
 420 {                                                                       \
 421   ELOG_TYPE_DECLARE (_e) =                                              \
 422   {                                                                     \
 423     .format = "dack-tx: rcv_nxt %u rcv_wnd %u snd_nxt %u av_wnd %u snd_wnd %u",\
 424     .format_args = "i4i4i4i4i4",                                        \
 425   };                                                                    \
 426   DECLARE_ETD(_tc, _e, 5);                                              \
 427   ed->data[0] = _tc->rcv_nxt - _tc->irs;                                \
 428   ed->data[1] = _tc->rcv_wnd;                                           \
 429   ed->data[2] = _tc->snd_nxt - _tc->iss;                                \
 430   ed->data[3] = tcp_available_snd_wnd(_tc);                             \
 431   ed->data[4] = _tc->snd_wnd;                                           \
 432 }
 433
 434 #define TCP_EVT_ACK_RCVD_HANDLER(_tc, ...)                              \
 435 {                                                                       \
 436   ELOG_TYPE_DECLARE (_e) =                                              \
 437   {                                                                     \
 438     .format = "ack-rx: %u snd_una %u snd_wnd %u cwnd %u inflight %u",   \
 439     .format_args = "i4i4i4i4i4",                                        \
 440   };                                                                    \
 441   DECLARE_ETD(_tc, _e, 5);                                              \
 442   ed->data[0] = _tc->bytes_acked;                                       \
 443   ed->data[1] = _tc->snd_una - _tc->iss;                                \
 444   ed->data[2] = _tc->snd_wnd;                                           \
 445   ed->data[3] = _tc->cwnd;                                              \
 446   ed->data[4] = tcp_flight_size(_tc);                                   \
 447 }
 448
 449 #define TCP_EVT_DUPACK_RCVD_HANDLER(_tc, ...)                           \
 450 {                                                                       \
 451   ELOG_TYPE_DECLARE (_e) =                                              \
 452   {                                                                     \
 453     .format = "dack-rx: snd_una %u cwnd %u snd_wnd %u flight %u rcv_wnd %u",\
 454     .format_args = "i4i4i4i4i4",                                        \
 455   };                                                                    \
 456   DECLARE_ETD(_tc, _e, 5);                                              \
 457   ed->data[0] = _tc->snd_una - _tc->iss;                                \
 458   ed->data[1] = _tc->cwnd;                                              \
 459   ed->data[2] = _tc->snd_wnd;                                           \
 460   ed->data[3] = tcp_flight_size(_tc);                                   \
 461   ed->data[4] = _tc->rcv_wnd;                                           \
 462 }
 463
 464 #define TCP_EVT_PKTIZE_HANDLER(_tc, ...)                                \
 465 {                                                                       \
 466   ELOG_TYPE_DECLARE (_e) =                                              \
 467   {                                                                     \
 468     .format = "tx: una %u snd_nxt %u space %u flight %u rcv_wnd %u",\
 469     .format_args = "i4i4i4i4i4",                                        \
 470   };                                                                    \
 471   DECLARE_ETD(_tc, _e, 5);                                              \
 472   ed->data[0] = _tc->snd_una - _tc->iss;                                \
 473   ed->data[1] = _tc->snd_nxt - _tc->iss;                                \
 474   ed->data[2] = tcp_available_output_snd_space (_tc);                   \
 475   ed->data[3] = tcp_flight_size (_tc);                                  \
 476   ed->data[4] = _tc->rcv_wnd;                                           \
 477 }
 478
 479 #define TCP_EVT_INPUT_HANDLER(_tc, _type, _len, _written, ...)          \
 480 {                                                                       \
 481   ELOG_TYPE_DECLARE (_e) =                                              \
 482   {                                                                     \
 483     .format = "in: %s len %u written %d rcv_nxt %u rcv_wnd(o) %d",      \
 484     .format_args = "t4i4i4i4i4",                                        \
 485     .n_enum_strings = 2,                                                \
 486     .enum_strings = {                                                   \
 487       "order",                                                          \
 488       "ooo",                                                            \
 489     },                                                                  \
 490   };                                                                    \
 491   DECLARE_ETD(_tc, _e, 5);                                              \
 492   ed->data[0] = _type;                                                  \
 493   ed->data[1] = _len;                                                   \
 494   ed->data[2] = _written;                                               \
 495   ed->data[3] = (_tc->rcv_nxt - _tc->irs) + _written;                   \
 496   ed->data[4] = _tc->rcv_wnd - (_tc->rcv_nxt - _tc->rcv_las);           \
 497 }
 498
 499 #define TCP_EVT_TIMER_POP_HANDLER(_tc_index, _timer_id, ...)            \
 500 {                                                                       \
 501   tcp_connection_t *_tc;                                                \
 502   if (_timer_id == TCP_TIMER_RETRANSMIT_SYN                             \
 503     || _timer_id == TCP_TIMER_ESTABLISH)                                \
 504     {                                                                   \
 505       _tc = tcp_half_open_connection_get (_tc_index);                   \
 506     }                                                                   \
 507   else                                                                  \
 508     {                                                                   \
 509       u32 _thread_index = vlib_get_thread_index ();                     \
 510       _tc = tcp_connection_get (_tc_index, _thread_index);              \
 511     }                                                                   \
 512   ELOG_TYPE_DECLARE (_e) =                                              \
 513   {                                                                     \
 514     .format = "timer-pop: %s (%d)",                                     \
 515     .format_args = "t4i4",                                              \
 516     .n_enum_strings = 7,                                                \
 517     .enum_strings = {                                                   \
 518       "retransmit",                                                     \
 519       "delack",                                                         \
 520       "persist",                                                        \
 521       "keep",                                                           \
 522       "waitclose",                                                      \
 523       "retransmit syn",                                                 \
 524       "establish",                                                      \
 525     },                                                                  \
 526   };                                                                    \
 527   if (_tc)                                                              \
 528     {                                                                   \
 529       DECLARE_ETD(_tc, _e, 2);                                          \
 530       ed->data[0] = _timer_id;                                          \
 531       ed->data[1] = _timer_id;                                          \
 532     }                                                                   \
 533   else                                                                  \
 534     {                                                                   \
 535       clib_warning ("pop %d for unexisting connection %d", _timer_id,   \
 536                     _tc_index);                                         \
 537     }                                                                   \
 538 }
 539
 540 #define TCP_EVT_SEG_INVALID_HANDLER(_tc, _seq, _end, ...)               \
 541 {                                                                       \
 542   ELOG_TYPE_DECLARE (_e) =                                              \
 543   {                                                                     \
 544     .format = "seg-inv: seq %u end %u rcv_las %u rcv_nxt %u rcv_wnd %u",\
 545     .format_args = "i4i4i4i4i4",                                        \
 546   };                                                                    \
 547   DECLARE_ETD(_tc, _e, 5);                                              \
 548   ed->data[0] = _seq - _tc->irs;                                        \
 549   ed->data[1] = _end - _tc->irs;                                        \
 550   ed->data[2] = _tc->rcv_las - _tc->irs;                                \
 551   ed->data[3] = _tc->rcv_nxt - _tc->irs;                                \
 552   ed->data[4] = _tc->rcv_wnd;                                           \
 553 }
 554
 555 #define TCP_EVT_PAWS_FAIL_HANDLER(_tc, _seq, _end, ...)                 \
 556 {                                                                       \
 557   ELOG_TYPE_DECLARE (_e) =                                              \
 558   {                                                                     \
 559     .format = "paws-err: seq %u end %u tsval %u tsval_recent %u",       \
 560     .format_args = "i4i4i4i4",                                          \
 561   };                                                                    \
 562   DECLARE_ETD(_tc, _e, 4);                                              \
 563   ed->data[0] = _seq - _tc->irs;                                        \
 564   ed->data[1] = _end - _tc->irs;                                        \
 565   ed->data[2] = _tc->rcv_opts.tsval;                                    \
 566   ed->data[3] = _tc->tsval_recent;                                      \
 567 }
 568
 569 #define TCP_EVT_ACK_RCV_ERR_HANDLER(_tc, _type, _ack, ...)              \
 570 {                                                                       \
 571   ELOG_TYPE_DECLARE (_e) =                                              \
 572   {                                                                     \
 573     .format = "ack-err: %s ack %u snd_una %u snd_nxt %u una_max %u",    \
 574     .format_args = "t4i4i4i4i4",                                        \
 575     .n_enum_strings = 3,                                                \
 576     .enum_strings = {                                                   \
 577       "invalid",                                                        \
 578       "old",                                                            \
 579       "future",                                                         \
 580     },                                                                  \
 581   };                                                                    \
 582   DECLARE_ETD(_tc, _e, 5);                                              \
 583   ed->data[0] = _type;                                                  \
 584   ed->data[1] = _ack - _tc->iss;                                        \
 585   ed->data[2] = _tc->snd_una - _tc->iss;                                \
 586   ed->data[3] = _tc->snd_nxt - _tc->iss;                                \
 587   ed->data[4] = _tc->snd_una_max - _tc->iss;                            \
 588 }
 589
 590 #define TCP_EVT_RCV_WND_SHRUNK_HANDLER(_tc, _obs, _av, ...)             \
 591 {                                                                       \
 592 if (_av > 0)                                                            \
 593 {                                                                       \
 594   ELOG_TYPE_DECLARE (_e) =                                              \
 595   {                                                                     \
 596     .format = "huh?: rcv_wnd %u obsd %u av %u rcv_nxt %u rcv_las %u",   \
 597     .format_args = "i4i4i4i4i4",                                        \
 598   };                                                                    \
 599   DECLARE_ETD(_tc, _e, 5);                                              \
 600   ed->data[0] = _tc->rcv_wnd;                                           \
 601   ed->data[1] = _obs;                                                   \
 602   ed->data[2] = _av;                                                    \
 603   ed->data[3] = _tc->rcv_nxt - _tc->irs;                                \
 604   ed->data[4] = _tc->rcv_las - _tc->irs;                                \
 605 }                                                                       \
 606 }
 607 #else
 608 #define TCP_EVT_ACK_SENT_HANDLER(_tc, ...)
 609 #define TCP_EVT_DUPACK_SENT_HANDLER(_tc, ...)
 610 #define TCP_EVT_ACK_RCVD_HANDLER(_tc, ...)
 611 #define TCP_EVT_DUPACK_RCVD_HANDLER(_tc, ...)
 612 #define TCP_EVT_PKTIZE_HANDLER(_tc, ...)
 613 #define TCP_EVT_INPUT_HANDLER(_tc, _type, _len, _written, ...)
 614 #define TCP_EVT_TIMER_POP_HANDLER(_tc_index, _timer_id, ...)
 615 #define TCP_EVT_SEG_INVALID_HANDLER(_tc, _seq, _end, ...)
 616 #define TCP_EVT_PAWS_FAIL_HANDLER(_tc, _seq, _end, ...)
 617 #define TCP_EVT_ACK_RCV_ERR_HANDLER(_tc, _type, _ack, ...)
 618 #define TCP_EVT_RCV_WND_SHRUNK_HANDLER(_tc, _obs, _av, ...)
 619 #endif
 620
 621 /*
 622  * State machine verbose
 623  */
 624 #if TCP_DEBUG_SM > 2
 625 #define TCP_EVT_SND_WND_HANDLER(_tc, ...)                               \
 626 {                                                                       \
 627   ELOG_TYPE_DECLARE (_e) =                                              \
 628   {                                                                     \
 629     .format = "snd-wnd update: %u ",                                    \
 630     .format_args = "i4",                                                \
 631   };                                                                    \
 632   DECLARE_ETD(_tc, _e, 1);                                              \
 633   ed->data[0] = _tc->snd_wnd;                                           \
 634 }
 635
 636 #define TCP_EVT_OUTPUT_HANDLER(_tc, flags, n_bytes,...)                 \
 637 {                                                                       \
 638   ELOG_TYPE_DECLARE (_e) =                                              \
 639   {                                                                     \
 640     .format = "out: flags %x, bytes %u",                                \
 641     .format_args = "i4i4",                                              \
 642   };                                                                    \
 643   DECLARE_ETD(_tc, _e, 2);                                              \
 644   ed->data[0] = flags;                                                  \
 645   ed->data[1] = n_bytes;                                                \
 646 }
 647 #else
 648 #define TCP_EVT_SND_WND_HANDLER(_tc, ...)
 649 #define TCP_EVT_OUTPUT_HANDLER(_tc, flags, n_bytes,...)
 650 #endif
 651
 652 /*
 653  * Congestion Control
 654  */
 655
 656 #if TCP_DEBUG_CC
 657 #define TCP_EVT_CC_RTX_HANDLER(_tc, offset, n_bytes, ...)               \
 658 {                                                                       \
 659   ELOG_TYPE_DECLARE (_e) =                                              \
 660   {                                                                     \
 661     .format = "rxt: snd_nxt %u offset %u snd %u rxt %u",                \
 662     .format_args = "i4i4i4i4",                                          \
 663   };                                                                    \
 664   DECLARE_ETD(_tc, _e, 4);                                              \
 665   ed->data[0] = _tc->snd_nxt - _tc->iss;                                \
 666   ed->data[1] = offset;                                                 \
 667   ed->data[2] = n_bytes;                                                \
 668   ed->data[3] = _tc->snd_rxt_bytes;                                     \
 669 }
 670
 671 #define TCP_EVT_CC_EVT_HANDLER(_tc, _sub_evt, ...)                      \
 672 {                                                                       \
 673   ELOG_TYPE_DECLARE (_e) =                                              \
 674   {                                                                     \
 675     .format = "cc: %s wnd %u snd_cong %u rxt_bytes %u",                 \
 676     .format_args = "t4i4i4i4",                                          \
 677     .n_enum_strings = 5,                                                \
 678     .enum_strings = {                                                   \
 679       "fast-rxt",                                                       \
 680       "rxt-timeout",                                                    \
 681       "first-rxt",                                                      \
 682       "recovered",                                                      \
 683       "congestion",                                                     \
 684     },                                                                  \
 685   };                                                                    \
 686   DECLARE_ETD(_tc, _e, 4);                                              \
 687   ed->data[0] = _sub_evt;                                               \
 688   ed->data[1] = tcp_available_snd_space (_tc);                          \
 689   ed->data[2] = _tc->snd_congestion - _tc->iss;                         \
 690   ed->data[3] = _tc->snd_rxt_bytes;                                     \
 691 }
 692
 693 #define TCP_EVT_CC_PACK_HANDLER(_tc, ...)                               \
 694 {                                                                       \
 695   ELOG_TYPE_DECLARE (_e) =                                              \
 696   {                                                                     \
 697     .format = "pack: snd_una %u snd_una_max %u",                        \
 698     .format_args = "i4i4",                                              \
 699   };                                                                    \
 700   DECLARE_ETD(_tc, _e, 2);                                              \
 701   ed->data[0] = _tc->snd_una - _tc->iss;                                \
 702   ed->data[1] = _tc->snd_una_max - _tc->iss;                            \
 703 }
 704
 705 /*
 706  * Congestion control stats
 707  */
 708 #if TCP_DEBUG_CC_STAT
 709
 710 #define STATS_INTERVAL 1
 711
 712 #define TCP_EVT_CC_RTO_STAT_HANDLER(_tc, ...)                           \
 713 {                                                                       \
 714 if (_tc->c_cc_stat_tstamp + STATS_INTERVAL < tcp_time_now())            \
 715 {                                                                       \
 716   ELOG_TYPE_DECLARE (_e) =                                              \
 717   {                                                                     \
 718     .format = "rto_stat: rto %u srtt %u rttvar %u ",                    \
 719     .format_args = "i4i4i4",                                            \
 720   };                                                                    \
 721   DECLARE_ETD(_tc, _e, 3);                                              \
 722   ed->data[0] = _tc->rto;                                               \
 723   ed->data[1] = _tc->srtt;                                              \
 724   ed->data[2] = _tc->rttvar;                                            \
 725 }                                                                       \
 726 }
 727
 728 #define TCP_EVT_CC_STAT_HANDLER(_tc, ...)                               \
 729 {                                                                       \
 730 if (_tc->c_cc_stat_tstamp + STATS_INTERVAL < tcp_time_now())            \
 731 {                                                                       \
 732   ELOG_TYPE_DECLARE (_e) =                                              \
 733   {                                                                     \
 734     .format = "cc_stat: cwnd %u flight %u space %u ssthresh %u snd_wnd %u",\
 735     .format_args = "i4i4i4i4i4",                                        \
 736   };                                                                    \
 737   DECLARE_ETD(_tc, _e, 5);                                              \
 738   ed->data[0] = _tc->cwnd;                                              \
 739   ed->data[1] = tcp_flight_size (_tc);                                  \
 740   ed->data[2] = tcp_snd_space (_tc);                                    \
 741   ed->data[3] = _tc->ssthresh;                                          \
 742   ed->data[4] = _tc->snd_wnd;                                           \
 743   TCP_EVT_CC_RTO_STAT_HANDLER (_tc);                                    \
 744   _tc->c_cc_stat_tstamp = tcp_time_now();                               \
 745 }                                                                       \
 746 }
 747
 748 #else
 749 #define TCP_EVT_CC_STAT_HANDLER(_tc, ...)
 750 #endif
 751
 752 #else
 753 #define TCP_EVT_CC_RTX_HANDLER(_tc, offset, n_bytes, ...)
 754 #define TCP_EVT_CC_EVT_HANDLER(_tc, _sub_evt, ...)
 755 #define TCP_EVT_CC_PACK_HANDLER(_tc, ...)
 756 #define TCP_EVT_CC_STAT_HANDLER(_tc, ...)
 757 #endif
 758
 759 #endif /* SRC_VNET_TCP_TCP_DEBUG_H_ */
 760 /*
 761  * fd.io coding-style-patch-verification: ON
 762  *
 763  * Local Variables:
 764  * eval: (c-set-style "gnu")
 765  * End:
 766  */