sys/netinet/tcp_log_buf.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2016-2018
   5  *      Netflix Inc.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #ifndef __tcp_log_buf_h__
  32 #define __tcp_log_buf_h__
  33
  34 #define TCP_LOG_REASON_LEN      32
  35 #define TCP_LOG_BUF_VER         (6)
  36
  37 /*
  38  * Because the (struct tcp_log_buffer) includes 8-byte uint64_t's, it requires
  39  * 8-byte alignment to work properly on all platforms. Therefore, we will
  40  * enforce 8-byte alignment for all the structures that may appear by
  41  * themselves (instead of being embedded in another structure) in a data
  42  * stream.
  43  */
  44 #define ALIGN_TCP_LOG           __aligned(8)
  45
  46 /* Information about the socketbuffer state. */
  47 struct tcp_log_sockbuf
  48 {
  49         uint32_t        tls_sb_acc;     /* available chars (sb->sb_acc) */
  50         uint32_t        tls_sb_ccc;     /* claimed chars (sb->sb_ccc) */
  51         uint32_t        tls_sb_spare;   /* spare */
  52 };
  53
  54 /* Optional, verbose information that may be appended to an event log. */
  55 struct tcp_log_verbose
  56 {
  57 #define TCP_FUNC_LEN    32
  58         char            tlv_snd_frm[TCP_FUNC_LEN]; /* tcp_output() caller */
  59         char            tlv_trace_func[TCP_FUNC_LEN]; /* Function that
  60                                                          generated trace */
  61         uint32_t        tlv_trace_line; /* Line number that generated trace */
  62         uint8_t         _pad[4];
  63 } ALIGN_TCP_LOG;
  64
  65 /* Internal RACK state variables. */
  66 struct tcp_log_rack
  67 {
  68         uint32_t        tlr_rack_rtt;           /* rc_rack_rtt */
  69         uint8_t         tlr_state;              /* Internal RACK state */
  70         uint8_t         _pad[3];                /* Padding */
  71 };
  72
  73 struct tcp_log_bbr {
  74         uint64_t cur_del_rate;
  75         uint64_t delRate;
  76         uint64_t rttProp;
  77         uint64_t bw_inuse;
  78         uint32_t inflight;
  79         uint32_t applimited;
  80         uint32_t delivered;
  81         uint32_t timeStamp;
  82         uint32_t epoch;
  83         uint32_t lt_epoch;
  84         uint32_t pkts_out;
  85         uint32_t flex1;
  86         uint32_t flex2;
  87         uint32_t flex3;
  88         uint32_t flex4;
  89         uint32_t flex5;
  90         uint32_t flex6;
  91         uint32_t lost;
  92         uint16_t pacing_gain;
  93         uint16_t cwnd_gain;
  94         uint16_t flex7;
  95         uint8_t bbr_state;
  96         uint8_t bbr_substate;
  97         uint8_t inhpts;
  98         uint8_t ininput;
  99         uint8_t use_lt_bw;
 100         uint8_t flex8;
 101         uint32_t pkt_epoch;
 102 };
 103
 104 /* Per-stack stack-specific info. */
 105 union tcp_log_stackspecific
 106 {
 107         struct tcp_log_rack u_rack;
 108         struct tcp_log_bbr u_bbr;
 109 };
 110
 111 struct tcp_log_buffer
 112 {
 113         /* Event basics */
 114         struct timeval  tlb_tv;         /* Timestamp of trace */
 115         uint32_t        tlb_ticks;      /* Timestamp of trace */
 116         uint32_t        tlb_sn;         /* Serial number */
 117         uint8_t         tlb_stackid;    /* Stack ID */
 118         uint8_t         tlb_eventid;    /* Event ID */
 119         uint16_t        tlb_eventflags; /* Flags for the record */
 120 #define TLB_FLAG_RXBUF          0x0001  /* Includes receive buffer info */
 121 #define TLB_FLAG_TXBUF          0x0002  /* Includes send buffer info */
 122 #define TLB_FLAG_HDR            0x0004  /* Includes a TCP header */
 123 #define TLB_FLAG_VERBOSE        0x0008  /* Includes function/line numbers */
 124 #define TLB_FLAG_STACKINFO      0x0010  /* Includes stack-specific info */
 125         int             tlb_errno;      /* Event error (if any) */
 126
 127         /* Internal session state */
 128         struct tcp_log_sockbuf tlb_rxbuf; /* Receive buffer */
 129         struct tcp_log_sockbuf tlb_txbuf; /* Send buffer */
 130
 131         int             tlb_state;      /* TCPCB t_state */
 132         uint32_t        tlb_starttime;  /* TCPCB t_starttime */
 133         uint32_t        tlb_iss;                /* TCPCB iss */
 134         uint32_t        tlb_flags;      /* TCPCB flags */
 135         uint32_t        tlb_snd_una;    /* TCPCB snd_una */
 136         uint32_t        tlb_snd_max;    /* TCPCB snd_max */
 137         uint32_t        tlb_snd_cwnd;   /* TCPCB snd_cwnd */
 138         uint32_t        tlb_snd_nxt;    /* TCPCB snd_nxt */
 139         uint32_t        tlb_snd_recover;/* TCPCB snd_recover */
 140         uint32_t        tlb_snd_wnd;    /* TCPCB snd_wnd */
 141         uint32_t        tlb_snd_ssthresh; /* TCPCB snd_ssthresh */
 142         uint32_t        tlb_srtt;       /* TCPCB t_srtt */
 143         uint32_t        tlb_rttvar;     /* TCPCB t_rttvar */
 144         uint32_t        tlb_rcv_up;     /* TCPCB rcv_up */
 145         uint32_t        tlb_rcv_adv;    /* TCPCB rcv_adv */
 146         uint32_t        tlb_rcv_nxt;    /* TCPCB rcv_nxt */
 147         tcp_seq         tlb_sack_newdata; /* TCPCB sack_newdata */
 148         uint32_t        tlb_rcv_wnd;    /* TCPCB rcv_wnd */
 149         uint32_t        tlb_dupacks;    /* TCPCB t_dupacks */
 150         int             tlb_segqlen;    /* TCPCB segqlen */
 151         int             tlb_snd_numholes; /* TCPCB snd_numholes */
 152         uint32_t        tlb_flex1; /* Event specific information */
 153         uint32_t        tlb_flex2; /* Event specific information */
 154         uint8_t         tlb_snd_scale:4, /* TCPCB snd_scale */
 155                         tlb_rcv_scale:4; /* TCPCB rcv_scale */
 156         uint8_t         _pad[3];        /* Padding */
 157
 158         /* Per-stack info */
 159         union tcp_log_stackspecific tlb_stackinfo;
 160 #define tlb_rack        tlb_stackinfo.u_rack
 161
 162         /* The packet */
 163         uint32_t        tlb_len;        /* The packet's data length */
 164         struct tcphdr   tlb_th;         /* The TCP header */
 165         uint8_t         tlb_opts[TCP_MAXOLEN]; /* The TCP options */
 166
 167         /* Verbose information (optional) */
 168         struct tcp_log_verbose tlb_verbose[0];
 169 } ALIGN_TCP_LOG;
 170
 171 enum tcp_log_events {
 172         TCP_LOG_IN = 1, /* Incoming packet                 1 */
 173         TCP_LOG_OUT,    /* Transmit (without other event)  2 */
 174         TCP_LOG_RTO,    /* Retransmit timeout              3 */
 175         TCP_LOG_TF_ACK, /* Transmit due to TF_ACK          4 */
 176         TCP_LOG_BAD_RETRAN, /* Detected bad retransmission 5 */
 177         TCP_LOG_PRR,    /* Doing PRR                       6 */
 178         TCP_LOG_REORDER,/* Detected reorder                7 */
 179         TCP_LOG_PACER,  /* Pacer sending a packet          8 */
 180         BBR_LOG_BBRUPD,         /* We updated BBR info     9 */
 181         BBR_LOG_BBRSND,         /* We did a slot calculation and sending is done 10 */
 182         BBR_LOG_ACKCLEAR,       /* A ack clears all outstanding     11 */
 183         BBR_LOG_INQUEUE,        /* The tcb had a packet input to it 12 */
 184         BBR_LOG_TIMERSTAR,      /* Start a timer                    13 */
 185         BBR_LOG_TIMERCANC,      /* Cancel a timer                   14 */
 186         BBR_LOG_ENTREC,         /* Entered recovery                 15 */
 187         BBR_LOG_EXITREC,        /* Exited recovery                  16 */
 188         BBR_LOG_CWND,           /* Cwnd change                      17 */
 189         BBR_LOG_BWSAMP,         /* LT B/W sample has been made      18 */
 190         BBR_LOG_MSGSIZE,        /* We received a EMSGSIZE error     19 */
 191         BBR_LOG_BBRRTT,         /* BBR RTT is updated               20 */
 192         BBR_LOG_JUSTRET,        /* We just returned out of output   21 */
 193         BBR_LOG_STATE,          /* A BBR state change occured       22 */
 194         BBR_LOG_PKT_EPOCH,      /* A BBR packet epoch occured       23 */
 195         BBR_LOG_PERSIST,        /* BBR changed to/from a persists   24 */
 196         TCP_LOG_FLOWEND,        /* End of a flow                    25 */
 197         BBR_LOG_RTO,            /* BBR's timeout includes BBR info  26 */
 198         BBR_LOG_DOSEG_DONE,     /* pacer do_segment completes       27 */
 199         BBR_LOG_EXIT_GAIN,      /* pacer do_segment completes       28 */
 200         BBR_LOG_THRESH_CALC,    /* Doing threshold calculation      29 */
 201         BBR_LOG_EXTRACWNDGAIN,  /* Removed                          30 */
 202         TCP_LOG_USERSEND,       /* User level sends data            31 */
 203         UNUSED_32,              /* Unused                           32 */
 204         UNUSED_33,              /* Unused                           33 */
 205         BBR_LOG_TIME_EPOCH,     /* A timed based Epoch occured      34 */
 206         BBR_LOG_TO_PROCESS,     /* A to was processed               35 */
 207         BBR_LOG_BBRTSO,         /* TSO update                       36 */
 208         BBR_LOG_PACERDIAG,      /* Pacer diag insert                37 */
 209         BBR_LOG_LOWGAIN,        /* Low gain accounting              38 */
 210         BBR_LOG_PROGRESS,       /* Progress timer event             39 */
 211         TCP_LOG_SOCKET_OPT,     /* A socket option is set           40 */
 212         BBR_LOG_TIMERPREP,      /* A BBR var to debug out TLP issues  41 */
 213         BBR_LOG_ENOBUF_JMP,     /* We had a enobuf jump 42 */
 214         BBR_LOG_PACING_CALC,    /* calc the pacing time 43 */
 215         BBR_LOG_RTT_SHRINKS,    /* We had a log reduction of rttProp 44 */
 216         BBR_LOG_BW_RED_EV,      /* B/W reduction events 45 */
 217         BBR_LOG_REDUCE,         /* old bbr log reduce for 4.1 and earlier 46*/
 218         TCP_LOG_RTT,            /* A rtt (in useconds) is being sampled and applied to the srtt algo 47 */
 219         BBR_LOG_SETTINGS_CHG,   /* Settings changed for loss response 48 */
 220         BBR_LOG_SRTT_GAIN_EVENT, /* SRTT gaining 49 */
 221         TCP_LOG_REASS,          /* Reassembly buffer logging 50 */
 222         TCP_LOG_END             /* End (keep at end)                51 */
 223 };
 224
 225 enum tcp_log_states {
 226         TCP_LOG_STATE_CLEAR = -1,       /* Deactivate and clear tracing */
 227         TCP_LOG_STATE_OFF = 0,          /* Pause */
 228         TCP_LOG_STATE_TAIL=1,           /* Keep the trailing events */
 229         TCP_LOG_STATE_HEAD=2,           /* Keep the leading events */
 230         TCP_LOG_STATE_HEAD_AUTO=3,      /* Keep the leading events, and
 231                                            automatically dump them to the
 232                                            device  */
 233         TCP_LOG_STATE_CONTINUAL=4,      /* Continually dump the data when full */
 234         TCP_LOG_STATE_TAIL_AUTO=5,      /* Keep the trailing events, and
 235                                            automatically dump them when the
 236                                            session ends */
 237 };
 238
 239 /* Use this if we don't know whether the operation succeeded. */
 240 #define ERRNO_UNK       (-1)
 241
 242 /*
 243  * If the user included dev/tcp_log/tcp_log_dev.h, then include our private
 244  * headers. Otherwise, there is no reason to pollute all the files with an
 245  * additional include.
 246  *
 247  * This structure is aligned to an 8-byte boundary to match the alignment
 248  * requirements of (struct tcp_log_buffer).
 249  */
 250 #ifdef __tcp_log_dev_h__
 251 struct tcp_log_header {
 252         struct tcp_log_common_header tlh_common;
 253 #define tlh_version     tlh_common.tlch_version
 254 #define tlh_type        tlh_common.tlch_type
 255 #define tlh_length      tlh_common.tlch_length
 256         struct in_endpoints     tlh_ie;
 257         struct timeval          tlh_offset;     /* Uptime -> UTC offset */
 258         char                    tlh_id[TCP_LOG_ID_LEN];
 259         char                    tlh_reason[TCP_LOG_REASON_LEN];
 260         uint8_t         tlh_af;
 261         uint8_t         _pad[7];
 262 } ALIGN_TCP_LOG;
 263
 264 #ifdef _KERNEL
 265 struct tcp_log_dev_log_queue {
 266         struct tcp_log_dev_queue tldl_common;
 267         char                    tldl_id[TCP_LOG_ID_LEN];
 268         char                    tldl_reason[TCP_LOG_REASON_LEN];
 269         struct in_endpoints     tldl_ie;
 270         struct tcp_log_stailq   tldl_entries;
 271         int                     tldl_count;
 272         uint8_t                 tldl_af;
 273 };
 274 #endif /* _KERNEL */
 275 #endif /* __tcp_log_dev_h__ */
 276
 277 #ifdef _KERNEL
 278
 279 #define TCP_LOG_BUF_DEFAULT_SESSION_LIMIT       10000
 280 #define TCP_LOG_BUF_DEFAULT_GLOBAL_LIMIT        1000000
 281
 282 /*
 283  * TCP_LOG_EVENT_VERBOSE: The same as TCP_LOG_EVENT, except it always
 284  * tries to record verbose information.
 285  */
 286 #define TCP_LOG_EVENT_VERBOSE(tp, th, rxbuf, txbuf, eventid, errornum, len, stackinfo, th_hostorder, tv) \
 287         do {                                                            \
 288                 if (tp->t_logstate != TCP_LOG_STATE_OFF)                \
 289                         tcp_log_event_(tp, th, rxbuf, txbuf, eventid,   \
 290                         errornum, len, stackinfo, th_hostorder,         \
 291                         tp->t_output_caller, __func__, __LINE__, tv);   \
 292         } while (0)
 293
 294 /*
 295  * TCP_LOG_EVENT: This is a macro so we can capture function/line
 296  * information when needed.
 297  *
 298  * Prototype:
 299  * TCP_LOG_EVENT(struct tcpcb *tp, struct tcphdr *th, struct sockbuf *rxbuf,
 300  *     struct sockbuf *txbuf, uint8_t eventid, int errornum,
 301  *     union tcp_log_stackspecific *stackinfo)
 302  *
 303  * tp is mandatory and must be write locked.
 304  * th is optional; if present, it will appear in the record.
 305  * rxbuf and txbuf are optional; if present, they will appear in the record.
 306  * eventid is mandatory.
 307  * errornum is mandatory (it indicates the success or failure of the
 308  *     operation associated with the event).
 309  * len indicates the length of the packet. If no packet, use 0.
 310  * stackinfo is optional; if present, it will appear in the record.
 311  */
 312 #ifdef TCP_LOG_FORCEVERBOSE
 313 #define TCP_LOG_EVENT   TCP_LOG_EVENT_VERBOSE
 314 #else
 315 #define TCP_LOG_EVENT(tp, th, rxbuf, txbuf, eventid, errornum, len, stackinfo, th_hostorder) \
 316         do {                                                            \
 317                 if (tcp_log_verbose)                                    \
 318                         TCP_LOG_EVENT_VERBOSE(tp, th, rxbuf, txbuf,     \
 319                             eventid, errornum, len, stackinfo,          \
 320                             th_hostorder, NULL);                                \
 321                 else if (tp->t_logstate != TCP_LOG_STATE_OFF)           \
 322                         tcp_log_event_(tp, th, rxbuf, txbuf, eventid,   \
 323                             errornum, len, stackinfo, th_hostorder,     \
 324                             NULL, NULL, 0, NULL);                               \
 325         } while (0)
 326 #endif /* TCP_LOG_FORCEVERBOSE */
 327 #define TCP_LOG_EVENTP(tp, th, rxbuf, txbuf, eventid, errornum, len, stackinfo, th_hostorder, tv) \
 328         do {                                                            \
 329                 if (tp->t_logstate != TCP_LOG_STATE_OFF)                \
 330                         tcp_log_event_(tp, th, rxbuf, txbuf, eventid,   \
 331                             errornum, len, stackinfo, th_hostorder,     \
 332                             NULL, NULL, 0, tv);                         \
 333         } while (0)
 334
 335
 336 #ifdef TCP_BLACKBOX
 337 extern bool tcp_log_verbose;
 338 void tcp_log_drain(struct tcpcb *tp);
 339 int tcp_log_dump_tp_logbuf(struct tcpcb *tp, char *reason, int how, bool force);
 340 void tcp_log_dump_tp_bucket_logbufs(struct tcpcb *tp, char *reason);
 341 struct tcp_log_buffer *tcp_log_event_(struct tcpcb *tp, struct tcphdr *th, struct sockbuf *rxbuf,
 342     struct sockbuf *txbuf, uint8_t eventid, int errornum, uint32_t len,
 343     union tcp_log_stackspecific *stackinfo, int th_hostorder,
 344     const char *output_caller, const char *func, int line, const struct timeval *tv);
 345 size_t tcp_log_get_id(struct tcpcb *tp, char *buf);
 346 u_int tcp_log_get_id_cnt(struct tcpcb *tp);
 347 int tcp_log_getlogbuf(struct sockopt *sopt, struct tcpcb *tp);
 348 void tcp_log_init(void);
 349 int tcp_log_set_id(struct tcpcb *tp, char *id);
 350 int tcp_log_state_change(struct tcpcb *tp, int state);
 351 void tcp_log_tcpcbinit(struct tcpcb *tp);
 352 void tcp_log_tcpcbfini(struct tcpcb *tp);
 353 void tcp_log_flowend(struct tcpcb *tp);
 354 #else /* !TCP_BLACKBOX */
 355 #define tcp_log_verbose (false)
 356
 357 static inline struct tcp_log_buffer *
 358 tcp_log_event_(struct tcpcb *tp, struct tcphdr *th, struct sockbuf *rxbuf,
 359     struct sockbuf *txbuf, uint8_t eventid, int errornum, uint32_t len,
 360     union tcp_log_stackspecific *stackinfo, int th_hostorder,
 361     const char *output_caller, const char *func, int line,
 362     const struct timeval *tv)
 363 {
 364
 365         return (NULL);
 366 }
 367 #endif /* TCP_BLACKBOX */
 368
 369 #endif  /* _KERNEL */
 370 #endif  /* __tcp_log_buf_h__ */