History

Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next

Daniel Borkmann says: ==================== pull-request: bpf-next 2021-02-16 The following pull-request contains BPF updates for your *net-next* tree. There's a small merge conflict between 7eeba1706eba ("tcp: Add receive timestamp support for receive zerocopy.") from net-next tree and 9cacf81f8161 ("bpf: Remove extra lock_sock for TCP_ZEROCOPY_RECEIVE") from bpf-next tree. Resolve as follows: [...] lock_sock(sk); err = tcp_zerocopy_receive(sk, &zc, &tss); err = BPF_CGROUP_RUN_PROG_GETSOCKOPT_KERN(sk, level, optname, &zc, &len, err); release_sock(sk); [...] We've added 116 non-merge commits during the last 27 day(s) which contain a total of 156 files changed, 5662 insertions(+), 1489 deletions(-). The main changes are: 1) Adds support of pointers to types with known size among global function args to overcome the limit on max # of allowed args, from Dmitrii Banshchikov. 2) Add bpf_iter for task_vma which can be used to generate information similar to /proc/pid/maps, from Song Liu. 3) Enable bpf_{g,s}etsockopt() from all sock_addr related program hooks. Allow rewriting bind user ports from BPF side below the ip_unprivileged_port_start range, both from Stanislav Fomichev. 4) Prevent recursion on fentry/fexit & sleepable programs and allow map-in-map as well as per-cpu maps for the latter, from Alexei Starovoitov. 5) Add selftest script to run BPF CI locally. Also enable BPF ringbuffer for sleepable programs, both from KP Singh. 6) Extend verifier to enable variable offset read/write access to the BPF program stack, from Andrei Matei. 7) Improve tc & XDP MTU handling and add a new bpf_check_mtu() helper to query device MTU from programs, from Jesper Dangaard Brouer. 8) Allow bpf_get_socket_cookie() helper also be called from [sleepable] BPF tracing programs, from Florent Revest. 9) Extend x86 JIT to pad JMPs with NOPs for helping image to converge when otherwise too many passes are required, from Gary Lin. 10) Verifier fixes on atomics with BPF_FETCH as well as function-by-function verification both related to zero-extension handling, from Ilya Leoshkevich. 11) Better kernel build integration of resolve_btfids tool, from Jiri Olsa. 12) Batch of AF_XDP selftest cleanups and small performance improvement for libbpf's xsk map redirect for newer kernels, from Björn Töpel. 13) Follow-up BPF doc and verifier improvements around atomics with BPF_FETCH, from Brendan Jackman. 14) Permit zero-sized data sections e.g. if ELF .rodata section contains read-only data from local variables, from Yonghong Song. 15) veth driver skb bulk-allocation for ndo_xdp_xmit, from Lorenzo Bianconi. ====================

David S. Miller committed 5 years ago

Commit b8af4172 parents 9ec5eea 45159b2156 files · +5662 −1489Browse files

Showing the changes to tools/include/uapi (3 of 156 files). Show all

Unified · Split

3 files
  1. tools/include/uapi/linux/bpf.h +97 −6
  2. tools/include/uapi/linux/bpf_perf_event.h +1 −0
  3. tools/include/uapi/linux/tcp.h +357 −0
tools/include/uapi/linux/bpf.h+97−6
@@ -1656,22 +1656,30 @@ union bpf_attr { · 1655 unmodified lines
16561656 * networking traffic statistics as it provides a global socket
16571657 * identifier that can be assumed unique.
16581658 * Return
1659− * A 8-byte long non-decreasing number on success, or 0 if the
1660− * socket field is missing inside *skb*.
1659+ * A 8-byte long unique number on success, or 0 if the socket
1660+ * field is missing inside *skb*.
16611661 *
16621662 * u64 bpf_get_socket_cookie(struct bpf_sock_addr *ctx)
16631663 * Description
16641664 * Equivalent to bpf_get_socket_cookie() helper that accepts
16651665 * *skb*, but gets socket from **struct bpf_sock_addr** context.
16661666 * Return
1667− * A 8-byte long non-decreasing number.
1667+ * A 8-byte long unique number.
16681668 *
16691669 * u64 bpf_get_socket_cookie(struct bpf_sock_ops *ctx)
16701670 * Description
16711671 * Equivalent to **bpf_get_socket_cookie**\ () helper that accepts
16721672 * *skb*, but gets socket from **struct bpf_sock_ops** context.
16731673 * Return
1674− * A 8-byte long non-decreasing number.
1674+ * A 8-byte long unique number.
1675+ *
1676+ * u64 bpf_get_socket_cookie(struct sock *sk)
1677+ * Description
1678+ * Equivalent to **bpf_get_socket_cookie**\ () helper that accepts
1679+ * *sk*, but gets socket from a BTF **struct sock**. This helper
1680+ * also works for sleepable programs.
1681+ * Return
1682+ * A 8-byte long unique number or 0 if *sk* is NULL.
16751683 *
16761684 * u32 bpf_get_socket_uid(struct sk_buff *skb)
16771685 * Return
@@ -2231,6 +2239,9 @@ union bpf_attr { · 553 unmodified lines
22312239 * * > 0 one of **BPF_FIB_LKUP_RET_** codes explaining why the
22322240 * packet is not forwarded or needs assist from full stack
22332241 *
2242+ * If lookup fails with BPF_FIB_LKUP_RET_FRAG_NEEDED, then the MTU
2243+ * was exceeded and output params->mtu_result contains the MTU.
2244+ *
22342245 * long bpf_sock_hash_update(struct bpf_sock_ops *skops, struct bpf_map *map, void *key, u64 flags)
22352246 * Description
22362247 * Add an entry to, or update a sockhash *map* referencing sockets.
@@ -3836,6 +3847,69 @@ union bpf_attr { · 1599 unmodified lines
38363847 * Return
38373848 * A pointer to a struct socket on success or NULL if the file is
38383849 * not a socket.
3850+ *
3851+ * long bpf_check_mtu(void *ctx, u32 ifindex, u32 *mtu_len, s32 len_diff, u64 flags)
3852+ * Description
3853+
3854+ * Check ctx packet size against exceeding MTU of net device (based
3855+ * on *ifindex*). This helper will likely be used in combination
3856+ * with helpers that adjust/change the packet size.
3857+ *
3858+ * The argument *len_diff* can be used for querying with a planned
3859+ * size change. This allows to check MTU prior to changing packet
3860+ * ctx. Providing an *len_diff* adjustment that is larger than the
3861+ * actual packet size (resulting in negative packet size) will in
3862+ * principle not exceed the MTU, why it is not considered a
3863+ * failure. Other BPF-helpers are needed for performing the
3864+ * planned size change, why the responsability for catch a negative
3865+ * packet size belong in those helpers.
3866+ *
3867+ * Specifying *ifindex* zero means the MTU check is performed
3868+ * against the current net device. This is practical if this isn't
3869+ * used prior to redirect.
3870+ *
3871+ * The Linux kernel route table can configure MTUs on a more
3872+ * specific per route level, which is not provided by this helper.
3873+ * For route level MTU checks use the **bpf_fib_lookup**\ ()
3874+ * helper.
3875+ *
3876+ * *ctx* is either **struct xdp_md** for XDP programs or
3877+ * **struct sk_buff** for tc cls_act programs.
3878+ *
3879+ * The *flags* argument can be a combination of one or more of the
3880+ * following values:
3881+ *
3882+ * **BPF_MTU_CHK_SEGS**
3883+ * This flag will only works for *ctx* **struct sk_buff**.
3884+ * If packet context contains extra packet segment buffers
3885+ * (often knows as GSO skb), then MTU check is harder to
3886+ * check at this point, because in transmit path it is
3887+ * possible for the skb packet to get re-segmented
3888+ * (depending on net device features). This could still be
3889+ * a MTU violation, so this flag enables performing MTU
3890+ * check against segments, with a different violation
3891+ * return code to tell it apart. Check cannot use len_diff.
3892+ *
3893+ * On return *mtu_len* pointer contains the MTU value of the net
3894+ * device. Remember the net device configured MTU is the L3 size,
3895+ * which is returned here and XDP and TX length operate at L2.
3896+ * Helper take this into account for you, but remember when using
3897+ * MTU value in your BPF-code. On input *mtu_len* must be a valid
3898+ * pointer and be initialized (to zero), else verifier will reject
3899+ * BPF program.
3900+ *
3901+ * Return
3902+ * * 0 on success, and populate MTU value in *mtu_len* pointer.
3903+ *
3904+ * * < 0 if any input argument is invalid (*mtu_len* not updated)
3905+ *
3906+ * MTU violations return positive values, but also populate MTU
3907+ * value in *mtu_len* pointer, as this can be needed for
3908+ * implementing PMTU handing:
3909+ *
3910+ * * **BPF_MTU_CHK_RET_FRAG_NEEDED**
3911+ * * **BPF_MTU_CHK_RET_SEGS_TOOBIG**
3912+ *
38393913 */
38403914 #define __BPF_FUNC_MAPPER(FN) \
38413915 FN(unspec), \
@@ -4001,6 +4075,7 @@ union bpf_attr { · 159 unmodified lines
40014075 FN(ktime_get_coarse_ns), \
40024076 FN(ima_inode_hash), \
40034077 FN(sock_from_file), \
4078+ FN(check_mtu), \
40044079 /* */
40054080
40064081 /* integer value in 'imm' field of BPF_CALL instruction selects which helper
@@ -4501,6 +4576,7 @@ struct bpf_prog_info { · 494 unmodified lines
45014576 __aligned_u64 prog_tags;
45024577 __u64 run_time_ns;
45034578 __u64 run_cnt;
4579+ __u64 recursion_misses;
45044580 } __attribute__((aligned(8)));
45054581
45064582 struct bpf_map_info {
@@ -4981,9 +5057,13 @@ struct bpf_fib_lookup { · 474 unmodified lines
49815057 __be16 sport;
49825058 __be16 dport;
49835059
4984− /* total length of packet from network header - used for MTU check */
4985− __u16 tot_len;
5060+ union { /* used for MTU check */
5061+ /* input to lookup */
5062+ __u16 tot_len; /* L3 length from network hdr (iph->tot_len) */
49865063
5064+ /* output: MTU value */
5065+ __u16 mtu_result;
5066+ };
49875067 /* input: L3 device index for lookup
49885068 * output: device index from FIB lookup
49895069 */
@@ -5029,6 +5109,17 @@ struct bpf_redir_neigh { · 39 unmodified lines
50295109 };
50305110 };
50315111
5112+/* bpf_check_mtu flags*/
5113+enum bpf_check_mtu_flags {
5114+ BPF_MTU_CHK_SEGS = (1U << 0),
5115+};
5116+
5117+enum bpf_check_mtu_ret {
5118+ BPF_MTU_CHK_RET_SUCCESS, /* check and lookup successful */
5119+ BPF_MTU_CHK_RET_FRAG_NEEDED, /* fragmentation required to fwd */
5120+ BPF_MTU_CHK_RET_SEGS_TOOBIG, /* GSO re-segmentation needed to fwd */
5121+};
5122+
50325123 enum bpf_task_fd_type {
50335124 BPF_FD_TYPE_RAW_TRACEPOINT, /* tp name */
50345125 BPF_FD_TYPE_TRACEPOINT, /* tp name */
tools/include/uapi/linux/bpf_perf_event.h+1−0
@@ -13,6 +13,7 @@ · 12 unmodified lines
1313 struct bpf_perf_event_data {
1414 bpf_user_pt_regs_t regs;
1515 __u64 sample_period;
16+ __u64 addr;
1617 };
1718
1819 #endif /* _UAPI__LINUX_BPF_PERF_EVENT_H__ */
tools/include/uapi/linux/tcp.h+357−0
@@ -0,0 +1,357 @@
1+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
2+/*
3+ * INET An implementation of the TCP/IP protocol suite for the LINUX
4+ * operating system. INET is implemented using the BSD Socket
5+ * interface as the means of communication with the user level.
6+ *
7+ * Definitions for the TCP protocol.
8+ *
9+ * Version: @(#)tcp.h 1.0.2 04/28/93
10+ *
11+ * Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12+ *
13+ * This program is free software; you can redistribute it and/or
14+ * modify it under the terms of the GNU General Public License
15+ * as published by the Free Software Foundation; either version
16+ * 2 of the License, or (at your option) any later version.
17+ */
18+#ifndef _UAPI_LINUX_TCP_H
19+#define _UAPI_LINUX_TCP_H
20+
21+#include <linux/types.h>
22+#include <asm/byteorder.h>
23+#include <linux/socket.h>
24+
25+struct tcphdr {
26+ __be16 source;
27+ __be16 dest;
28+ __be32 seq;
29+ __be32 ack_seq;
30+#if defined(__LITTLE_ENDIAN_BITFIELD)
31+ __u16 res1:4,
32+ doff:4,
33+ fin:1,
34+ syn:1,
35+ rst:1,
36+ psh:1,
37+ ack:1,
38+ urg:1,
39+ ece:1,
40+ cwr:1;
41+#elif defined(__BIG_ENDIAN_BITFIELD)
42+ __u16 doff:4,
43+ res1:4,
44+ cwr:1,
45+ ece:1,
46+ urg:1,
47+ ack:1,
48+ psh:1,
49+ rst:1,
50+ syn:1,
51+ fin:1;
52+#else
53+#error "Adjust your <asm/byteorder.h> defines"
54+#endif
55+ __be16 window;
56+ __sum16 check;
57+ __be16 urg_ptr;
58+};
59+
60+/*
61+ * The union cast uses a gcc extension to avoid aliasing problems
62+ * (union is compatible to any of its members)
63+ * This means this part of the code is -fstrict-aliasing safe now.
64+ */
65+union tcp_word_hdr {
66+ struct tcphdr hdr;
67+ __be32 words[5];
68+};
69+
70+#define tcp_flag_word(tp) ( ((union tcp_word_hdr *)(tp))->words [3])
71+
72+enum {
73+ TCP_FLAG_CWR = __constant_cpu_to_be32(0x00800000),
74+ TCP_FLAG_ECE = __constant_cpu_to_be32(0x00400000),
75+ TCP_FLAG_URG = __constant_cpu_to_be32(0x00200000),
76+ TCP_FLAG_ACK = __constant_cpu_to_be32(0x00100000),
77+ TCP_FLAG_PSH = __constant_cpu_to_be32(0x00080000),
78+ TCP_FLAG_RST = __constant_cpu_to_be32(0x00040000),
79+ TCP_FLAG_SYN = __constant_cpu_to_be32(0x00020000),
80+ TCP_FLAG_FIN = __constant_cpu_to_be32(0x00010000),
81+ TCP_RESERVED_BITS = __constant_cpu_to_be32(0x0F000000),
82+ TCP_DATA_OFFSET = __constant_cpu_to_be32(0xF0000000)
83+};
84+
85+/*
86+ * TCP general constants
87+ */
88+#define TCP_MSS_DEFAULT 536U /* IPv4 (RFC1122, RFC2581) */
89+#define TCP_MSS_DESIRED 1220U /* IPv6 (tunneled), EDNS0 (RFC3226) */
90+
91+/* TCP socket options */
92+#define TCP_NODELAY 1 /* Turn off Nagle's algorithm. */
93+#define TCP_MAXSEG 2 /* Limit MSS */
94+#define TCP_CORK 3 /* Never send partially complete segments */
95+#define TCP_KEEPIDLE 4 /* Start keeplives after this period */
96+#define TCP_KEEPINTVL 5 /* Interval between keepalives */
97+#define TCP_KEEPCNT 6 /* Number of keepalives before death */
98+#define TCP_SYNCNT 7 /* Number of SYN retransmits */
99+#define TCP_LINGER2 8 /* Life time of orphaned FIN-WAIT-2 state */
100+#define TCP_DEFER_ACCEPT 9 /* Wake up listener only when data arrive */
101+#define TCP_WINDOW_CLAMP 10 /* Bound advertised window */
102+#define TCP_INFO 11 /* Information about this connection. */
103+#define TCP_QUICKACK 12 /* Block/reenable quick acks */
104+#define TCP_CONGESTION 13 /* Congestion control algorithm */
105+#define TCP_MD5SIG 14 /* TCP MD5 Signature (RFC2385) */
106+#define TCP_THIN_LINEAR_TIMEOUTS 16 /* Use linear timeouts for thin streams*/
107+#define TCP_THIN_DUPACK 17 /* Fast retrans. after 1 dupack */
108+#define TCP_USER_TIMEOUT 18 /* How long for loss retry before timeout */
109+#define TCP_REPAIR 19 /* TCP sock is under repair right now */
110+#define TCP_REPAIR_QUEUE 20
111+#define TCP_QUEUE_SEQ 21
112+#define TCP_REPAIR_OPTIONS 22
113+#define TCP_FASTOPEN 23 /* Enable FastOpen on listeners */
114+#define TCP_TIMESTAMP 24
115+#define TCP_NOTSENT_LOWAT 25 /* limit number of unsent bytes in write queue */
116+#define TCP_CC_INFO 26 /* Get Congestion Control (optional) info */
117+#define TCP_SAVE_SYN 27 /* Record SYN headers for new connections */
118+#define TCP_SAVED_SYN 28 /* Get SYN headers recorded for connection */
119+#define TCP_REPAIR_WINDOW 29 /* Get/set window parameters */
120+#define TCP_FASTOPEN_CONNECT 30 /* Attempt FastOpen with connect */
121+#define TCP_ULP 31 /* Attach a ULP to a TCP connection */
122+#define TCP_MD5SIG_EXT 32 /* TCP MD5 Signature with extensions */
123+#define TCP_FASTOPEN_KEY 33 /* Set the key for Fast Open (cookie) */
124+#define TCP_FASTOPEN_NO_COOKIE 34 /* Enable TFO without a TFO cookie */
125+#define TCP_ZEROCOPY_RECEIVE 35
126+#define TCP_INQ 36 /* Notify bytes available to read as a cmsg on read */
127+
128+#define TCP_CM_INQ TCP_INQ
129+
130+#define TCP_TX_DELAY 37 /* delay outgoing packets by XX usec */
131+
132+
133+#define TCP_REPAIR_ON 1
134+#define TCP_REPAIR_OFF 0
135+#define TCP_REPAIR_OFF_NO_WP -1 /* Turn off without window probes */
136+
137+struct tcp_repair_opt {
138+ __u32 opt_code;
139+ __u32 opt_val;
140+};
141+
142+struct tcp_repair_window {
143+ __u32 snd_wl1;
144+ __u32 snd_wnd;
145+ __u32 max_window;
146+
147+ __u32 rcv_wnd;
148+ __u32 rcv_wup;
149+};
150+
151+enum {
152+ TCP_NO_QUEUE,
153+ TCP_RECV_QUEUE,
154+ TCP_SEND_QUEUE,
155+ TCP_QUEUES_NR,
156+};
157+
158+/* why fastopen failed from client perspective */
159+enum tcp_fastopen_client_fail {
160+ TFO_STATUS_UNSPEC, /* catch-all */
161+ TFO_COOKIE_UNAVAILABLE, /* if not in TFO_CLIENT_NO_COOKIE mode */
162+ TFO_DATA_NOT_ACKED, /* SYN-ACK did not ack SYN data */
163+ TFO_SYN_RETRANSMITTED, /* SYN-ACK did not ack SYN data after timeout */
164+};
165+
166+/* for TCP_INFO socket option */
167+#define TCPI_OPT_TIMESTAMPS 1
168+#define TCPI_OPT_SACK 2
169+#define TCPI_OPT_WSCALE 4
170+#define TCPI_OPT_ECN 8 /* ECN was negociated at TCP session init */
171+#define TCPI_OPT_ECN_SEEN 16 /* we received at least one packet with ECT */
172+#define TCPI_OPT_SYN_DATA 32 /* SYN-ACK acked data in SYN sent or rcvd */
173+
174+/*
175+ * Sender's congestion state indicating normal or abnormal situations
176+ * in the last round of packets sent. The state is driven by the ACK
177+ * information and timer events.
178+ */
179+enum tcp_ca_state {
180+ /*
181+ * Nothing bad has been observed recently.
182+ * No apparent reordering, packet loss, or ECN marks.
183+ */
184+ TCP_CA_Open = 0,
185+#define TCPF_CA_Open (1<<TCP_CA_Open)
186+ /*
187+ * The sender enters disordered state when it has received DUPACKs or
188+ * SACKs in the last round of packets sent. This could be due to packet
189+ * loss or reordering but needs further information to confirm packets
190+ * have been lost.
191+ */
192+ TCP_CA_Disorder = 1,
193+#define TCPF_CA_Disorder (1<<TCP_CA_Disorder)
194+ /*
195+ * The sender enters Congestion Window Reduction (CWR) state when it
196+ * has received ACKs with ECN-ECE marks, or has experienced congestion
197+ * or packet discard on the sender host (e.g. qdisc).
198+ */
199+ TCP_CA_CWR = 2,
200+#define TCPF_CA_CWR (1<<TCP_CA_CWR)
201+ /*
202+ * The sender is in fast recovery and retransmitting lost packets,
203+ * typically triggered by ACK events.
204+ */
205+ TCP_CA_Recovery = 3,
206+#define TCPF_CA_Recovery (1<<TCP_CA_Recovery)
207+ /*
208+ * The sender is in loss recovery triggered by retransmission timeout.
209+ */
210+ TCP_CA_Loss = 4
211+#define TCPF_CA_Loss (1<<TCP_CA_Loss)
212+};
213+
214+struct tcp_info {
215+ __u8 tcpi_state;
216+ __u8 tcpi_ca_state;
217+ __u8 tcpi_retransmits;
218+ __u8 tcpi_probes;
219+ __u8 tcpi_backoff;
220+ __u8 tcpi_options;
221+ __u8 tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
222+ __u8 tcpi_delivery_rate_app_limited:1, tcpi_fastopen_client_fail:2;
223+
224+ __u32 tcpi_rto;
225+ __u32 tcpi_ato;
226+ __u32 tcpi_snd_mss;
227+ __u32 tcpi_rcv_mss;
228+
229+ __u32 tcpi_unacked;
230+ __u32 tcpi_sacked;
231+ __u32 tcpi_lost;
232+ __u32 tcpi_retrans;
233+ __u32 tcpi_fackets;
234+
235+ /* Times. */
236+ __u32 tcpi_last_data_sent;
237+ __u32 tcpi_last_ack_sent; /* Not remembered, sorry. */
238+ __u32 tcpi_last_data_recv;
239+ __u32 tcpi_last_ack_recv;
240+
241+ /* Metrics. */
242+ __u32 tcpi_pmtu;
243+ __u32 tcpi_rcv_ssthresh;
244+ __u32 tcpi_rtt;
245+ __u32 tcpi_rttvar;
246+ __u32 tcpi_snd_ssthresh;
247+ __u32 tcpi_snd_cwnd;
248+ __u32 tcpi_advmss;
249+ __u32 tcpi_reordering;
250+
251+ __u32 tcpi_rcv_rtt;
252+ __u32 tcpi_rcv_space;
253+
254+ __u32 tcpi_total_retrans;
255+
256+ __u64 tcpi_pacing_rate;
257+ __u64 tcpi_max_pacing_rate;
258+ __u64 tcpi_bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
259+ __u64 tcpi_bytes_received; /* RFC4898 tcpEStatsAppHCThruOctetsReceived */
260+ __u32 tcpi_segs_out; /* RFC4898 tcpEStatsPerfSegsOut */
261+ __u32 tcpi_segs_in; /* RFC4898 tcpEStatsPerfSegsIn */
262+
263+ __u32 tcpi_notsent_bytes;
264+ __u32 tcpi_min_rtt;
265+ __u32 tcpi_data_segs_in; /* RFC4898 tcpEStatsDataSegsIn */
266+ __u32 tcpi_data_segs_out; /* RFC4898 tcpEStatsDataSegsOut */
267+
268+ __u64 tcpi_delivery_rate;
269+
270+ __u64 tcpi_busy_time; /* Time (usec) busy sending data */
271+ __u64 tcpi_rwnd_limited; /* Time (usec) limited by receive window */
272+ __u64 tcpi_sndbuf_limited; /* Time (usec) limited by send buffer */
273+
274+ __u32 tcpi_delivered;
275+ __u32 tcpi_delivered_ce;
276+
277+ __u64 tcpi_bytes_sent; /* RFC4898 tcpEStatsPerfHCDataOctetsOut */
278+ __u64 tcpi_bytes_retrans; /* RFC4898 tcpEStatsPerfOctetsRetrans */
279+ __u32 tcpi_dsack_dups; /* RFC4898 tcpEStatsStackDSACKDups */
280+ __u32 tcpi_reord_seen; /* reordering events seen */
281+
282+ __u32 tcpi_rcv_ooopack; /* Out-of-order packets received */
283+
284+ __u32 tcpi_snd_wnd; /* peer's advertised receive window after
285+ * scaling (bytes)
286+ */
287+};
288+
289+/* netlink attributes types for SCM_TIMESTAMPING_OPT_STATS */
290+enum {
291+ TCP_NLA_PAD,
292+ TCP_NLA_BUSY, /* Time (usec) busy sending data */
293+ TCP_NLA_RWND_LIMITED, /* Time (usec) limited by receive window */
294+ TCP_NLA_SNDBUF_LIMITED, /* Time (usec) limited by send buffer */
295+ TCP_NLA_DATA_SEGS_OUT, /* Data pkts sent including retransmission */
296+ TCP_NLA_TOTAL_RETRANS, /* Data pkts retransmitted */
297+ TCP_NLA_PACING_RATE, /* Pacing rate in bytes per second */
298+ TCP_NLA_DELIVERY_RATE, /* Delivery rate in bytes per second */
299+ TCP_NLA_SND_CWND, /* Sending congestion window */
300+ TCP_NLA_REORDERING, /* Reordering metric */
301+ TCP_NLA_MIN_RTT, /* minimum RTT */
302+ TCP_NLA_RECUR_RETRANS, /* Recurring retransmits for the current pkt */
303+ TCP_NLA_DELIVERY_RATE_APP_LMT, /* delivery rate application limited ? */
304+ TCP_NLA_SNDQ_SIZE, /* Data (bytes) pending in send queue */
305+ TCP_NLA_CA_STATE, /* ca_state of socket */
306+ TCP_NLA_SND_SSTHRESH, /* Slow start size threshold */
307+ TCP_NLA_DELIVERED, /* Data pkts delivered incl. out-of-order */
308+ TCP_NLA_DELIVERED_CE, /* Like above but only ones w/ CE marks */
309+ TCP_NLA_BYTES_SENT, /* Data bytes sent including retransmission */
310+ TCP_NLA_BYTES_RETRANS, /* Data bytes retransmitted */
311+ TCP_NLA_DSACK_DUPS, /* DSACK blocks received */
312+ TCP_NLA_REORD_SEEN, /* reordering events seen */
313+ TCP_NLA_SRTT, /* smoothed RTT in usecs */
314+ TCP_NLA_TIMEOUT_REHASH, /* Timeout-triggered rehash attempts */
315+ TCP_NLA_BYTES_NOTSENT, /* Bytes in write queue not yet sent */
316+ TCP_NLA_EDT, /* Earliest departure time (CLOCK_MONOTONIC) */
317+};
318+
319+/* for TCP_MD5SIG socket option */
320+#define TCP_MD5SIG_MAXKEYLEN 80
321+
322+/* tcp_md5sig extension flags for TCP_MD5SIG_EXT */
323+#define TCP_MD5SIG_FLAG_PREFIX 0x1 /* address prefix length */
324+#define TCP_MD5SIG_FLAG_IFINDEX 0x2 /* ifindex set */
325+
326+struct tcp_md5sig {
327+ struct __kernel_sockaddr_storage tcpm_addr; /* address associated */
328+ __u8 tcpm_flags; /* extension flags */
329+ __u8 tcpm_prefixlen; /* address prefix */
330+ __u16 tcpm_keylen; /* key length */
331+ int tcpm_ifindex; /* device index for scope */
332+ __u8 tcpm_key[TCP_MD5SIG_MAXKEYLEN]; /* key (binary) */
333+};
334+
335+/* INET_DIAG_MD5SIG */
336+struct tcp_diag_md5sig {
337+ __u8 tcpm_family;
338+ __u8 tcpm_prefixlen;
339+ __u16 tcpm_keylen;
340+ __be32 tcpm_addr[4];
341+ __u8 tcpm_key[TCP_MD5SIG_MAXKEYLEN];
342+};
343+
344+/* setsockopt(fd, IPPROTO_TCP, TCP_ZEROCOPY_RECEIVE, ...) */
345+
346+#define TCP_RECEIVE_ZEROCOPY_FLAG_TLB_CLEAN_HINT 0x1
347+struct tcp_zerocopy_receive {
348+ __u64 address; /* in: address of mapping */
349+ __u32 length; /* in/out: number of bytes to map/mapped */
350+ __u32 recv_skip_hint; /* out: amount of bytes to skip */
351+ __u32 inq; /* out: amount of bytes in read queue */
352+ __s32 err; /* out: socket error */
353+ __u64 copybuf_address; /* in: copybuf address (small reads) */
354+ __s32 copybuf_len; /* in/out: copybuf bytes avail/used or error */
355+ __u32 flags; /* in: flags */
356+};
357+#endif /* _UAPI_LINUX_TCP_H */