xref: /freebsd/sys/netinet/tcp_log_buf.h (revision a91a246563dffa876a52f53a98de4af9fa364c52)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2016-2020 Netflix, Inc.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 #ifndef __tcp_log_buf_h__
29 #define __tcp_log_buf_h__
30 
31 #define	TCP_LOG_REASON_LEN	32
32 #define	TCP_LOG_TAG_LEN		32
33 #define	TCP_LOG_BUF_VER		(9)
34 
35 /*
36  * Because the (struct tcp_log_buffer) includes 8-byte uint64_t's, it requires
37  * 8-byte alignment to work properly on all platforms. Therefore, we will
38  * enforce 8-byte alignment for all the structures that may appear by
39  * themselves (instead of being embedded in another structure) in a data
40  * stream.
41  */
42 #define	ALIGN_TCP_LOG		__aligned(8)
43 
44 /* Information about the socketbuffer state. */
45 struct tcp_log_sockbuf
46 {
47 	uint32_t	tls_sb_acc;	/* available chars (sb->sb_acc) */
48 	uint32_t	tls_sb_ccc;	/* claimed chars (sb->sb_ccc) */
49 	uint32_t	tls_sb_spare;	/* spare */
50 };
51 
52 /* Optional, verbose information that may be appended to an event log. */
53 struct tcp_log_verbose
54 {
55 #define	TCP_FUNC_LEN	32
56 	char		tlv_snd_frm[TCP_FUNC_LEN]; /* tcp_output() caller */
57 	char		tlv_trace_func[TCP_FUNC_LEN]; /* Function that
58 							 generated trace */
59 	uint32_t	tlv_trace_line;	/* Line number that generated trace */
60 	uint8_t		_pad[4];
61 } ALIGN_TCP_LOG;
62 
63 /* Internal RACK state variables. */
64 struct tcp_log_rack
65 {
66 	uint32_t	tlr_rack_rtt;		/* rc_rack_rtt */
67 	uint8_t		tlr_state;		/* Internal RACK state */
68 	uint8_t		_pad[3];		/* Padding */
69 };
70 
71 struct tcp_log_bbr {
72 	uint64_t cur_del_rate;
73 	uint64_t delRate;
74 	uint64_t rttProp;
75 	uint64_t bw_inuse;
76 	uint32_t inflight;
77 	uint32_t applimited;
78 	uint32_t delivered;
79 	uint32_t timeStamp;
80 	uint32_t epoch;
81 	uint32_t lt_epoch;
82 	uint32_t pkts_out;
83 	uint32_t flex1;
84 	uint32_t flex2;
85 	uint32_t flex3;
86 	uint32_t flex4;
87 	uint32_t flex5;
88 	uint32_t flex6;
89 	uint32_t lost;
90 	uint16_t pacing_gain;
91 	uint16_t cwnd_gain;
92 	uint16_t flex7;
93 	uint8_t bbr_state;
94 	uint8_t bbr_substate;
95 	uint8_t inhpts;
96 	uint8_t __spare;
97 	uint8_t use_lt_bw;
98 	uint8_t flex8;
99 	uint32_t pkt_epoch;
100 };
101 
102 /* shadows tcp_log_bbr struct element sizes */
103 struct tcp_log_raw {
104 	uint64_t u64_flex[4];
105 	uint32_t u32_flex[14];
106 	uint16_t u16_flex[3];
107 	uint8_t u8_flex[6];
108 	uint32_t u32_flex2[1];
109 };
110 
111 struct tcp_log_uint64 {
112 	uint64_t u64_flex[13];
113 };
114 
115 struct tcp_log_sendfile {
116 	uint64_t offset;
117 	uint64_t length;
118 	uint32_t flags;
119 };
120 
121 /*
122  * tcp_log_stackspecific is currently being used as "event specific" log
123  * info by all stacks (i.e. struct tcp_log_bbr is used for generic event
124  * logging). Until this is cleaned up more generically and throughout,
125  * allow events to use the same space in the union.
126  */
127 union tcp_log_stackspecific
128 {
129 	struct tcp_log_rack u_rack;
130 	struct tcp_log_bbr u_bbr;
131 	struct tcp_log_sendfile u_sf;
132 	struct tcp_log_raw u_raw;	/* "raw" log access */
133 	struct tcp_log_uint64 u64_raw;	/* just u64's - used by process info */
134 };
135 
136 typedef union tcp_log_stackspecific tcp_log_eventspecific_t;
137 
138 struct tcp_log_buffer
139 {
140 	/* Event basics */
141 	struct timeval	tlb_tv;		/* Timestamp of trace */
142 	uint32_t	tlb_ticks;	/* Timestamp of trace */
143 	uint32_t	tlb_sn;		/* Serial number */
144 	uint8_t		tlb_stackid;	/* Stack ID */
145 	uint8_t		tlb_eventid;	/* Event ID */
146 	uint16_t	tlb_eventflags;	/* Flags for the record */
147 #define	TLB_FLAG_RXBUF		0x0001	/* Includes receive buffer info */
148 #define	TLB_FLAG_TXBUF		0x0002	/* Includes send buffer info */
149 #define	TLB_FLAG_HDR		0x0004	/* Includes a TCP header */
150 #define	TLB_FLAG_VERBOSE	0x0008	/* Includes function/line numbers */
151 #define	TLB_FLAG_STACKINFO	0x0010	/* Includes stack-specific info */
152 	int		tlb_errno;	/* Event error (if any) */
153 
154 	/* Internal session state */
155 	struct tcp_log_sockbuf tlb_rxbuf; /* Receive buffer */
156 	struct tcp_log_sockbuf tlb_txbuf; /* Send buffer */
157 
158 	int		tlb_state;	/* TCPCB t_state */
159 	uint32_t	tlb_starttime;	/* TCPCB t_starttime */
160 	uint32_t	tlb_iss;	/* TCPCB iss */
161 	uint32_t	tlb_flags;	/* TCPCB flags */
162 	uint32_t	tlb_snd_una;	/* TCPCB snd_una */
163 	uint32_t	tlb_snd_max;	/* TCPCB snd_max */
164 	uint32_t	tlb_snd_cwnd;	/* TCPCB snd_cwnd */
165 	uint32_t	tlb_snd_nxt;	/* TCPCB snd_nxt */
166 	uint32_t	tlb_snd_recover;/* TCPCB snd_recover */
167 	uint32_t	tlb_snd_wnd;	/* TCPCB snd_wnd */
168 	uint32_t	tlb_snd_ssthresh; /* TCPCB snd_ssthresh */
169 	uint32_t	tlb_srtt;	/* TCPCB t_srtt */
170 	uint32_t	tlb_rttvar;	/* TCPCB t_rttvar */
171 	uint32_t	tlb_rcv_up;	/* TCPCB rcv_up */
172 	uint32_t	tlb_rcv_adv;	/* TCPCB rcv_adv */
173 	uint32_t	tlb_flags2;	/* TCPCB t_flags2 */
174 	uint32_t	tlb_rcv_nxt;	/* TCPCB rcv_nxt */
175 	uint32_t	tlb_rcv_wnd;	/* TCPCB rcv_wnd */
176 	uint32_t	tlb_dupacks;	/* TCPCB t_dupacks */
177 	int		tlb_segqlen;	/* TCPCB segqlen */
178 	int		tlb_snd_numholes; /* TCPCB snd_numholes */
179 	uint32_t	tlb_flex1;	/* Event specific information */
180 	uint32_t	tlb_flex2;	/* Event specific information */
181 	uint32_t	tlb_fbyte_in;	/* TCPCB first byte in time */
182 	uint32_t	tlb_fbyte_out;	/* TCPCB first byte out time */
183 	uint8_t		tlb_snd_scale:4, /* TCPCB snd_scale */
184 			tlb_rcv_scale:4; /* TCPCB rcv_scale */
185 	uint8_t		_pad[3];	/* Padding */
186 	/* Per-stack info */
187 	union tcp_log_stackspecific tlb_stackinfo;
188 #define	tlb_rack	tlb_stackinfo.u_rack
189 
190 	/* The packet */
191 	uint32_t	tlb_len;	/* The packet's data length */
192 	struct tcphdr	tlb_th;		/* The TCP header */
193 	uint8_t		tlb_opts[TCP_MAXOLEN]; /* The TCP options */
194 
195 	/* Verbose information (optional) */
196 	struct tcp_log_verbose tlb_verbose[0];
197 } ALIGN_TCP_LOG;
198 
199 enum tcp_log_events {
200 	TCP_LOG_IN = 1,		/* Incoming packet                   1 */
201 	TCP_LOG_OUT,		/* Transmit (without other event)    2 */
202 	TCP_LOG_RTO,		/* Retransmit timeout                3 */
203 	TCP_LOG_SB_WAKE,	/* Awaken socket buffer              4 */
204 	TCP_LOG_BAD_RETRAN,	/* Detected bad retransmission       5 */
205 	TCP_LOG_PRR,		/* Doing PRR                         6 */
206 	TCP_LOG_REORDER,	/* Detected reorder                  7 */
207 	TCP_LOG_HPTS,		/* Hpts sending a packet             8 */
208 	BBR_LOG_BBRUPD,		/* We updated BBR info               9 */
209 	BBR_LOG_BBRSND,		/* We did a slot calculation and sending is done 10 */
210 	BBR_LOG_ACKCLEAR,	/* A ack clears all outstanding     11 */
211 	BBR_LOG_INQUEUE,	/* The tcb had a packet input to it 12 */
212 	BBR_LOG_TIMERSTAR,	/* Start a timer                    13 */
213 	BBR_LOG_TIMERCANC,	/* Cancel a timer                   14 */
214 	BBR_LOG_ENTREC,		/* Entered recovery                 15 */
215 	BBR_LOG_EXITREC,	/* Exited recovery                  16 */
216 	BBR_LOG_CWND,		/* Cwnd change                      17 */
217 	BBR_LOG_BWSAMP,		/* LT B/W sample has been made      18 */
218 	BBR_LOG_MSGSIZE,	/* We received a EMSGSIZE error     19 */
219 	BBR_LOG_BBRRTT,		/* BBR RTT is updated               20 */
220 	BBR_LOG_JUSTRET,	/* We just returned out of output   21 */
221 	BBR_LOG_STATE,		/* A BBR state change occurred      22 */
222 	BBR_LOG_PKT_EPOCH,      /* A BBR packet epoch occurred      23 */
223 	BBR_LOG_PERSIST,        /* BBR changed to/from a persists   24 */
224 	TCP_LOG_FLOWEND,        /* End of a flow                    25 */
225 	BBR_LOG_RTO,            /* BBR's timeout includes BBR info  26 */
226 	BBR_LOG_DOSEG_DONE,     /* hpts do_segment completes        27 */
227 	BBR_LOG_EXIT_GAIN,      /* hpts do_segment completes        28 */
228 	BBR_LOG_THRESH_CALC,    /* Doing threshold calculation      29 */
229 	TCP_LOG_MAPCHG,		/* Map Changes to the sendmap       30 */
230 	TCP_LOG_USERSEND, 	/* User level sends data            31 */
231 	BBR_RSM_CLEARED,	/* RSM cleared of ACK flags         32 */
232 	BBR_LOG_STATE_TARGET, 	/* Log of target at state           33 */
233 	BBR_LOG_TIME_EPOCH, 	/* A timed based Epoch occurred     34 */
234 	BBR_LOG_TO_PROCESS,	/* A to was processed               35 */
235 	BBR_LOG_BBRTSO,		/* TSO update                       36 */
236 	BBR_LOG_HPTSDIAG,	/* Hpts diag insert                 37 */
237 	BBR_LOG_LOWGAIN,	/* Low gain accounting              38 */
238 	BBR_LOG_PROGRESS,	/* Progress timer event             39 */
239 	TCP_LOG_SOCKET_OPT,	/* A socket option is set           40 */
240 	BBR_LOG_TIMERPREP,	/* A BBR var to debug out TLP issues  41 */
241 	BBR_LOG_ENOBUF_JMP,	/* We had a enobuf jump             42 */
242 	BBR_LOG_HPTSI_CALC,	/* calc the hptsi time              43 */
243 	BBR_LOG_RTT_SHRINKS,	/* We had a log reduction of rttProp 44 */
244 	BBR_LOG_BW_RED_EV,	/* B/W reduction events             45 */
245 	BBR_LOG_REDUCE,		/* old bbr log reduce for 4.1 and earlier 46*/
246 	TCP_LOG_RTT,		/* A rtt (in useconds) is being sampled and applied to the srtt algo 47 */
247 	BBR_LOG_SETTINGS_CHG,	/* Settings changed for loss response 48 */
248 	BBR_LOG_SRTT_GAIN_EVENT, /* SRTT gaining -- now not used    49 */
249 	TCP_LOG_REASS,		/* Reassembly buffer logging        50 */
250 	TCP_HDWR_PACE_SIZE,	/*  TCP pacing size set (rl and rack uses this)  51 */
251 	BBR_LOG_HDWR_PACE,	/* TCP Hardware pacing log          52 */
252 	BBR_LOG_TSTMP_VAL,	/* Temp debug timestamp validation  53 */
253 	TCP_LOG_CONNEND,	/* End of connection                54 */
254 	TCP_LOG_LRO,		/* LRO entry                        55 */
255 	TCP_SACK_FILTER_RES,	/* Results of SACK Filter           56 */
256 	TCP_SAD_DETECT,		/* Sack Attack Detection            57 */
257 	TCP_TIMELY_WORK,	/* Logs regarding Timely CC tweaks  58 */
258 	TCP_LOG_USER_EVENT,	/* User space event data            59 */
259 	TCP_LOG_SENDFILE,	/* sendfile() logging for TCP connections 60 */
260 	TCP_LOG_REQ_T,		/* logging of request tracking 61 */
261 	TCP_LOG_ACCOUNTING,	/* Log of TCP Accounting data 62 */
262 	TCP_LOG_FSB,		/* FSB information 63 */
263 	RACK_DSACK_HANDLING,	/* Handling of DSACK in rack for reordering window 64 */
264 	TCP_HYSTART,		/* TCP Hystart logging 65 */
265 	TCP_CHG_QUERY,		/* Change query during fnc_init() 66 */
266 	TCP_RACK_LOG_COLLAPSE,	/* Window collapse by peer 67 */
267 	TCP_RACK_TP_TRIGGERED,	/* A rack tracepoint is triggered 68 */
268 	TCP_HYBRID_PACING_LOG,	/* Hybrid pacing log 69 */
269 	TCP_LOG_PRU,		/* TCP protocol user request        70 */
270 	TCP_POLICER_DET,	/* TCP Policer detectionn 71 */
271 	TCP_PCM_MEASURE,	/* TCP Path Capacity Measurement 72 */
272 	TCP_LOG_END		/* End (keep at end)                72 */
273 };
274 
275 enum tcp_log_states {
276 	TCP_LOG_STATE_RATIO_OFF = -2,	/* Log ratio evaluation yielded an OFF
277 					   result. Only used for tlb_logstate */
278 	TCP_LOG_STATE_CLEAR = -1,	/* Deactivate and clear tracing. Passed
279 					   to tcp_log_state_change() but never
280 					   stored in any logstate variable */
281 	TCP_LOG_STATE_OFF = 0,		/* Pause */
282 
283 	/* Positively numbered states represent active logging modes */
284 	TCP_LOG_STATE_TAIL=1,		/* Keep the trailing events */
285 	TCP_LOG_STATE_HEAD=2,		/* Keep the leading events */
286 	TCP_LOG_STATE_HEAD_AUTO=3,	/* Keep the leading events, and
287 					   automatically dump them to the
288 					   device  */
289 	TCP_LOG_STATE_CONTINUAL=4,	/* Continually dump the data when full */
290 	TCP_LOG_STATE_TAIL_AUTO=5,	/* Keep the trailing events, and
291 					   automatically dump them when the
292 					   session ends */
293 	TCP_LOG_VIA_BBPOINTS=6		/* Log only if the BB point has been configured */
294 };
295 
296 /* Use this if we don't know whether the operation succeeded. */
297 #define	ERRNO_UNK	(-1)
298 
299 /*
300  * If the user included dev/tcp_log/tcp_log_dev.h, then include our private
301  * headers. Otherwise, there is no reason to pollute all the files with an
302  * additional include.
303  *
304  * This structure is aligned to an 8-byte boundary to match the alignment
305  * requirements of (struct tcp_log_buffer).
306  */
307 #ifdef __tcp_log_dev_h__
308 struct tcp_log_header {
309 	struct tcp_log_common_header tlh_common;
310 #define	tlh_version	tlh_common.tlch_version
311 #define	tlh_type	tlh_common.tlch_type
312 #define	tlh_length	tlh_common.tlch_length
313 	struct in_endpoints	tlh_ie;
314 	struct timeval		tlh_offset;	/* Uptime -> UTC offset */
315 	char			tlh_id[TCP_LOG_ID_LEN];
316 	char			tlh_reason[TCP_LOG_REASON_LEN];
317 	char			tlh_tag[TCP_LOG_TAG_LEN];
318 	uint8_t		tlh_af;
319 	uint8_t		_pad[7];
320 } ALIGN_TCP_LOG;
321 
322 #ifdef _KERNEL
323 struct tcp_log_dev_log_queue {
324 	struct tcp_log_dev_queue tldl_common;
325 	char			tldl_id[TCP_LOG_ID_LEN];
326 	char			tldl_reason[TCP_LOG_REASON_LEN];
327 	char			tldl_tag[TCP_LOG_TAG_LEN];
328 	struct in_endpoints	tldl_ie;
329 	struct tcp_log_stailq	tldl_entries;
330 	int			tldl_count;
331 	uint8_t			tldl_af;
332 };
333 #endif /* _KERNEL */
334 #endif /* __tcp_log_dev_h__ */
335 
336 /*
337  * Defined BBPOINTS that can be used
338  * with TCP_LOG_VIA_BBPOINTS.
339  */
340 #define TCP_BBPOINT_NONE		0
341 #define TCP_BBPOINT_REQ_LEVEL_LOGGING	1
342 
343 /*********************/
344 /* TCP Trace points */
345 /*********************/
346 /*
347  * TCP trace points are interesting points within
348  * the TCP code that the author/debugger may want
349  * to have BB logging enabled if we hit that point.
350  * In order to enable a trace point you set the
351  * sysctl var net.inet.tcp.bb.tp.number to
352  * one of the numbers listed below. You also
353  * must make sure net.inet.tcp.bb.tp.bbmode is
354  * non-zero, the default is 4 for continuous tracing.
355  * You also set in the number of connections you want
356  * have get BB logs in net.inet.tcp.bb.tp.count.
357  *
358  * Count will decrement every time BB logging is assigned
359  * to a connection that hit your tracepoint.
360  *
361  * You can enable all trace points by setting the number
362  * to 0xffffffff. You can disable all trace points by
363  * setting number to zero (or count to 0).
364  *
365  * Below are the enumerated list of tracepoints that
366  * have currently been defined in the code. Add more
367  * as you add a call to rack_trace_point(rack, <name>);
368  * where <name> is defined below.
369  */
370 #define TCP_TP_HWENOBUF		0x00000001	/* When we are doing hardware pacing and hit enobufs */
371 #define TCP_TP_ENOBUF		0x00000002	/* When we hit enobufs with software pacing */
372 #define TCP_TP_COLLAPSED_WND	0x00000003	/* When a peer to collapses its rwnd on us */
373 #define TCP_TP_COLLAPSED_RXT	0x00000004	/* When we actually retransmit a collapsed window rsm */
374 #define TCP_TP_REQ_LOG_FAIL	0x00000005	/* We tried to allocate a Request log but had no space */
375 #define TCP_TP_RESET_RCV	0x00000006	/* Triggers when we receive a RST */
376 #define TCP_TP_POLICER_DET	0x00000007	/* When we detect a policer */
377 #define TCP_TP_EXCESS_RXT	TCP_TP_POLICER_DET	/* alias */
378 #define TCP_TP_SAD_TRIGGERED	0x00000008	/* Sack Attack Detection triggers */
379 #define TCP_TP_SAD_SUSPECT	0x0000000a	/* A sack has supicious information in it */
380 #define TCP_TP_PACED_BOTTOM	0x0000000b	/* We have paced at the bottom */
381 
382 #ifdef _KERNEL
383 
384 extern uint32_t tcp_trace_point_config;
385 extern uint32_t tcp_trace_point_bb_mode;
386 extern int32_t tcp_trace_point_count;
387 
388 /*
389  * Returns true if any sort of BB logging is enabled,
390  * commonly used throughout the codebase.
391  */
392 static inline int
393 tcp_bblogging_on(struct tcpcb *tp)
394 {
395 	if (tp->_t_logstate <= TCP_LOG_STATE_OFF)
396 		return (0);
397 	if (tp->_t_logstate == TCP_LOG_VIA_BBPOINTS)
398 		return (0);
399 	return (1);
400 }
401 
402 /*
403  * Returns true if we match a specific bbpoint when
404  * in TCP_LOG_VIA_BBPOINTS, but also returns true
405  * for all the other logging states.
406  */
407 static inline int
408 tcp_bblogging_point_on(struct tcpcb *tp, uint8_t bbpoint)
409 {
410 	if (tp->_t_logstate <= TCP_LOG_STATE_OFF)
411 		return (0);
412 	if ((tp->_t_logstate == TCP_LOG_VIA_BBPOINTS) &&
413 	    (tp->_t_logpoint == bbpoint))
414 		return (1);
415 	else if (tp->_t_logstate == TCP_LOG_VIA_BBPOINTS)
416 		return (0);
417 	return (1);
418 }
419 
420 static inline void
421 tcp_set_bblog_state(struct tcpcb *tp, uint8_t ls, uint8_t bbpoint)
422 {
423 	if ((ls == TCP_LOG_VIA_BBPOINTS) &&
424 	    (tp->_t_logstate <= TCP_LOG_STATE_OFF)){
425 		/*
426 		 * We don't allow a BBPOINTS set to override
427 		 * other types of BB logging set by other means such
428 		 * as the bb_ratio/bb_state URL parameters. In other
429 		 * words BBlogging must be *off* in order to turn on
430 		 * a BBpoint.
431 		 */
432 		tp->_t_logpoint = bbpoint;
433 		tp->_t_logstate = ls;
434 	} else if (ls != TCP_LOG_VIA_BBPOINTS) {
435 		tp->_t_logpoint = 0;
436 		if ((ls >= TCP_LOG_STATE_OFF) &&
437 		    (ls < TCP_LOG_VIA_BBPOINTS))
438 			tp->_t_logstate = ls;
439 	}
440 }
441 
442 static inline uint32_t
443 tcp_get_bblog_state(struct tcpcb *tp)
444 {
445 	return (tp->_t_logstate);
446 }
447 
448 static inline void
449 tcp_trace_point(struct tcpcb *tp, int num)
450 {
451 #ifdef TCP_BLACKBOX
452 	if (((tcp_trace_point_config == num)  ||
453 	     (tcp_trace_point_config == 0xffffffff)) &&
454 	    (tcp_trace_point_bb_mode != 0) &&
455 	    (tcp_trace_point_count > 0) &&
456 	    (tcp_bblogging_on(tp) == 0)) {
457 		int res;
458 		res = atomic_fetchadd_int(&tcp_trace_point_count, -1);
459 		if (res > 0) {
460 			tcp_set_bblog_state(tp, tcp_trace_point_bb_mode, TCP_BBPOINT_NONE);
461 		} else {
462 			/* Loss a race assure its zero now */
463 			tcp_trace_point_count = 0;
464 		}
465 	}
466 #endif
467 }
468 
469 #define	TCP_LOG_BUF_DEFAULT_SESSION_LIMIT	5000
470 #define	TCP_LOG_BUF_DEFAULT_GLOBAL_LIMIT	5000000
471 
472 /*
473  * TCP_LOG_EVENT_VERBOSE: The same as TCP_LOG_EVENT, except it always
474  * tries to record verbose information.
475  */
476 #define	TCP_LOG_EVENT_VERBOSE(tp, th, rxbuf, txbuf, eventid, errornum, len, stackinfo, th_hostorder, tv) \
477 	do {								\
478 		if (tcp_bblogging_on(tp)) \
479 			tcp_log_event(tp, th, rxbuf, txbuf, eventid,	\
480 			    errornum, len, stackinfo, th_hostorder,	\
481 			    tp->t_output_caller, __func__, __LINE__, tv);\
482 	} while (0)
483 
484 /*
485  * TCP_LOG_EVENT: This is a macro so we can capture function/line
486  * information when needed. You can use the macro when you are not
487  * doing a lot of prep in the stack specific information i.e. you
488  * don't add extras (stackinfo). If you are adding extras which
489  * means filling out a stack variable instead use the tcp_log_event()
490  * function but enclose the call to the log (and all the setup) in a
491  * if (tcp_bblogging_on(tp)) {
492  *   ... setup and logging call ...
493  * }
494  *
495  * Always use the macro tcp_bblogging_on() since sometimes the defintions
496  * do change.
497  *
498  * BBlogging also supports the concept of a BBpoint. The idea behind this
499  * is that when you set a specific BBpoint on and turn the logging into
500  * the BBpoint mode (TCP_LOG_VIA_BBPOINTS) you will be defining very very
501  * few of these points to come out. The point is specific to a code you
502  * want tied to that one BB logging. This allows you to turn on a much broader
503  * scale set of limited logging on more connections without overwhelming the
504  * I/O system with too much BBlogs. This of course means you need to be quite
505  * careful on how many BBlogs go with each point, but you can have multiple points
506  * only one of which is active at a time.
507  *
508  * To define a point you add it above under the define for TCP_BBPOINT_NONE (which
509  * is the default i.e. no point is defined. You then, for your point use the
510  * tcp_bblogging_point_on(struct tcpcb *tp, uint8_t bbpoint) inline to enclose
511  * your call to tcp_log_event.  Do not use one of the TCP_LOGGING macros else
512  * your point will never come out. You specify your defined point in the bbpoint
513  * side of the inline. An example of this you can find in rack where the
514  * TCP_BBPOINT_REQ_LEVEL_LOGGING is used. There a specific set of logs are generated
515  * for each request that tcp is tracking.
516  *
517  * When turning on BB logging use the inline:
518  * tcp_set_bblog_state(struct tcpcb *tp, uint8_t ls, uint8_t bbpoint)
519  * the ls field is the logging state TCP_LOG_STATE_CONTINUAL etc. The
520  * bbpoint field is ignored unless the ls field is set to TCP_LOG_VIA_BBPOINTS.
521  * Currently there is only a socket option that turns on the non-BBPOINT
522  * logging.
523  *
524  * Prototype:
525  * TCP_LOG_EVENT(struct tcpcb *tp, struct tcphdr *th, struct sockbuf *rxbuf,
526  *     struct sockbuf *txbuf, uint8_t eventid, int errornum,
527  *     union tcp_log_stackspecific *stackinfo)
528  *
529  * tp is mandatory and must be write locked.
530  * th is optional; if present, it will appear in the record.
531  * rxbuf and txbuf are optional; if present, they will appear in the record.
532  * eventid is mandatory.
533  * errornum is mandatory (it indicates the success or failure of the
534  *     operation associated with the event).
535  * len indicates the length of the packet. If no packet, use 0.
536  * stackinfo is optional; if present, it will appear in the record.
537  */
538 struct tcpcb;
539 #ifdef TCP_LOG_FORCEVERBOSE
540 #define	TCP_LOG_EVENT	TCP_LOG_EVENT_VERBOSE
541 #else
542 #define	TCP_LOG_EVENT(tp, th, rxbuf, txbuf, eventid, errornum, len, stackinfo, th_hostorder) \
543 	do {								\
544 		if (tcp_log_verbose)					\
545 			TCP_LOG_EVENT_VERBOSE(tp, th, rxbuf, txbuf,	\
546 			    eventid, errornum, len, stackinfo,		\
547 			    th_hostorder, NULL);			\
548 		else if (tcp_bblogging_on(tp))				\
549 			tcp_log_event(tp, th, rxbuf, txbuf, eventid,	\
550 			    errornum, len, stackinfo, th_hostorder,	\
551 			    NULL, NULL, 0, NULL);			\
552 	} while (0)
553 #endif /* TCP_LOG_FORCEVERBOSE */
554 #define	TCP_LOG_EVENTP(tp, th, rxbuf, txbuf, eventid, errornum, len, stackinfo, th_hostorder, tv) \
555 	do {								\
556 		if (tcp_bblogging_on(tp))				\
557 			tcp_log_event(tp, th, rxbuf, txbuf, eventid,	\
558 			    errornum, len, stackinfo, th_hostorder,	\
559 			    NULL, NULL, 0, tv);				\
560 	} while (0)
561 
562 #ifdef TCP_BLACKBOX
563 extern bool tcp_log_verbose;
564 void tcp_log_drain(struct tcpcb *tp);
565 int tcp_log_dump_tp_logbuf(struct tcpcb *tp, char *reason, int how, bool force);
566 void tcp_log_dump_tp_bucket_logbufs(struct tcpcb *tp, char *reason);
567 struct tcp_log_buffer *tcp_log_event(struct tcpcb *tp, struct tcphdr *th, struct sockbuf *rxbuf,
568     struct sockbuf *txbuf, uint8_t eventid, int errornum, uint32_t len,
569     union tcp_log_stackspecific *stackinfo, int th_hostorder,
570     const char *output_caller, const char *func, int line, const struct timeval *tv);
571 size_t tcp_log_get_id(struct tcpcb *tp, char *buf);
572 size_t tcp_log_get_tag(struct tcpcb *tp, char *buf);
573 u_int tcp_log_get_id_cnt(struct tcpcb *tp);
574 int tcp_log_getlogbuf(struct sockopt *sopt, struct tcpcb *tp);
575 void tcp_log_init(void);
576 int tcp_log_set_id(struct tcpcb *tp, char *id);
577 int tcp_log_set_tag(struct tcpcb *tp, char *tag);
578 int tcp_log_state_change(struct tcpcb *tp, int state);
579 void tcp_log_tcpcbinit(struct tcpcb *tp);
580 void tcp_log_tcpcbfini(struct tcpcb *tp);
581 void tcp_log_flowend(struct tcpcb *tp);
582 void tcp_log_sendfile(struct socket *so, off_t offset, size_t nbytes,
583     int flags);
584 int tcp_log_apply_ratio(struct tcpcb *tp, int ratio);
585 #else /* !TCP_BLACKBOX */
586 #define tcp_log_verbose	(false)
587 
588 static inline struct tcp_log_buffer *
589 tcp_log_event(struct tcpcb *tp, struct tcphdr *th, struct sockbuf *rxbuf,
590     struct sockbuf *txbuf, uint8_t eventid, int errornum, uint32_t len,
591     union tcp_log_stackspecific *stackinfo, int th_hostorder,
592     const char *output_caller, const char *func, int line,
593     const struct timeval *tv)
594 {
595 
596 	return (NULL);
597 }
598 #endif /* TCP_BLACKBOX */
599 
600 #endif	/* _KERNEL */
601 #endif	/* __tcp_log_buf_h__ */
602