mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-11 00:06:39 +07:00
35a9ad8af0
Pull networking updates from David Miller: "Most notable changes in here: 1) By far the biggest accomplishment, thanks to a large range of contributors, is the addition of multi-send for transmit. This is the result of discussions back in Chicago, and the hard work of several individuals. Now, when the ->ndo_start_xmit() method of a driver sees skb->xmit_more as true, it can choose to defer the doorbell telling the driver to start processing the new TX queue entires. skb->xmit_more means that the generic networking is guaranteed to call the driver immediately with another SKB to send. There is logic added to the qdisc layer to dequeue multiple packets at a time, and the handling mis-predicted offloads in software is now done with no locks held. Finally, pktgen is extended to have a "burst" parameter that can be used to test a multi-send implementation. Several drivers have xmit_more support: i40e, igb, ixgbe, mlx4, virtio_net Adding support is almost trivial, so export more drivers to support this optimization soon. I want to thank, in no particular or implied order, Jesper Dangaard Brouer, Eric Dumazet, Alexander Duyck, Tom Herbert, Jamal Hadi Salim, John Fastabend, Florian Westphal, Daniel Borkmann, David Tat, Hannes Frederic Sowa, and Rusty Russell. 2) PTP and timestamping support in bnx2x, from Michal Kalderon. 3) Allow adjusting the rx_copybreak threshold for a driver via ethtool, and add rx_copybreak support to enic driver. From Govindarajulu Varadarajan. 4) Significant enhancements to the generic PHY layer and the bcm7xxx driver in particular (EEE support, auto power down, etc.) from Florian Fainelli. 5) Allow raw buffers to be used for flow dissection, allowing drivers to determine the optimal "linear pull" size for devices that DMA into pools of pages. The objective is to get exactly the necessary amount of headers into the linear SKB area pre-pulled, but no more. The new interface drivers use is eth_get_headlen(). From WANG Cong, with driver conversions (several had their own by-hand duplicated implementations) by Alexander Duyck and Eric Dumazet. 6) Support checksumming more smoothly and efficiently for encapsulations, and add "foo over UDP" facility. From Tom Herbert. 7) Add Broadcom SF2 switch driver to DSA layer, from Florian Fainelli. 8) eBPF now can load programs via a system call and has an extensive testsuite. Alexei Starovoitov and Daniel Borkmann. 9) Major overhaul of the packet scheduler to use RCU in several major areas such as the classifiers and rate estimators. From John Fastabend. 10) Add driver for Intel FM10000 Ethernet Switch, from Alexander Duyck. 11) Rearrange TCP_SKB_CB() to reduce cache line misses, from Eric Dumazet. 12) Add Datacenter TCP congestion control algorithm support, From Florian Westphal. 13) Reorganize sk_buff so that __copy_skb_header() is significantly faster. From Eric Dumazet" * git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1558 commits) netlabel: directly return netlbl_unlabel_genl_init() net: add netdev_txq_bql_{enqueue, complete}_prefetchw() helpers net: description of dma_cookie cause make xmldocs warning cxgb4: clean up a type issue cxgb4: potential shift wrapping bug i40e: skb->xmit_more support net: fs_enet: Add NAPI TX net: fs_enet: Remove non NAPI RX r8169:add support for RTL8168EP net_sched: copy exts->type in tcf_exts_change() wimax: convert printk to pr_foo() af_unix: remove 0 assignment on static ipv6: Do not warn for informational ICMP messages, regardless of type. Update Intel Ethernet Driver maintainers list bridge: Save frag_max_size between PRE_ROUTING and POST_ROUTING tipc: fix bug in multicast congestion handling net: better IFF_XMIT_DST_RELEASE support net/mlx4_en: remove NETDEV_TX_BUSY 3c59x: fix bad split of cpu_to_le32(pci_map_single()) net: bcmgenet: fix Tx ring priority programming ...
382 lines
12 KiB
C
382 lines
12 KiB
C
/*
|
|
* INET An implementation of the TCP/IP protocol suite for the LINUX
|
|
* operating system. INET is implemented using the BSD Socket
|
|
* interface as the means of communication with the user level.
|
|
*
|
|
* Definitions for the TCP protocol.
|
|
*
|
|
* Version: @(#)tcp.h 1.0.2 04/28/93
|
|
*
|
|
* Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
#ifndef _LINUX_TCP_H
|
|
#define _LINUX_TCP_H
|
|
|
|
|
|
#include <linux/skbuff.h>
|
|
#include <net/sock.h>
|
|
#include <net/inet_connection_sock.h>
|
|
#include <net/inet_timewait_sock.h>
|
|
#include <uapi/linux/tcp.h>
|
|
|
|
static inline struct tcphdr *tcp_hdr(const struct sk_buff *skb)
|
|
{
|
|
return (struct tcphdr *)skb_transport_header(skb);
|
|
}
|
|
|
|
static inline unsigned int tcp_hdrlen(const struct sk_buff *skb)
|
|
{
|
|
return tcp_hdr(skb)->doff * 4;
|
|
}
|
|
|
|
static inline struct tcphdr *inner_tcp_hdr(const struct sk_buff *skb)
|
|
{
|
|
return (struct tcphdr *)skb_inner_transport_header(skb);
|
|
}
|
|
|
|
static inline unsigned int inner_tcp_hdrlen(const struct sk_buff *skb)
|
|
{
|
|
return inner_tcp_hdr(skb)->doff * 4;
|
|
}
|
|
|
|
static inline unsigned int tcp_optlen(const struct sk_buff *skb)
|
|
{
|
|
return (tcp_hdr(skb)->doff - 5) * 4;
|
|
}
|
|
|
|
/* TCP Fast Open */
|
|
#define TCP_FASTOPEN_COOKIE_MIN 4 /* Min Fast Open Cookie size in bytes */
|
|
#define TCP_FASTOPEN_COOKIE_MAX 16 /* Max Fast Open Cookie size in bytes */
|
|
#define TCP_FASTOPEN_COOKIE_SIZE 8 /* the size employed by this impl. */
|
|
|
|
/* TCP Fast Open Cookie as stored in memory */
|
|
struct tcp_fastopen_cookie {
|
|
s8 len;
|
|
u8 val[TCP_FASTOPEN_COOKIE_MAX];
|
|
};
|
|
|
|
/* This defines a selective acknowledgement block. */
|
|
struct tcp_sack_block_wire {
|
|
__be32 start_seq;
|
|
__be32 end_seq;
|
|
};
|
|
|
|
struct tcp_sack_block {
|
|
u32 start_seq;
|
|
u32 end_seq;
|
|
};
|
|
|
|
/*These are used to set the sack_ok field in struct tcp_options_received */
|
|
#define TCP_SACK_SEEN (1 << 0) /*1 = peer is SACK capable, */
|
|
#define TCP_FACK_ENABLED (1 << 1) /*1 = FACK is enabled locally*/
|
|
#define TCP_DSACK_SEEN (1 << 2) /*1 = DSACK was received from peer*/
|
|
|
|
struct tcp_options_received {
|
|
/* PAWS/RTTM data */
|
|
long ts_recent_stamp;/* Time we stored ts_recent (for aging) */
|
|
u32 ts_recent; /* Time stamp to echo next */
|
|
u32 rcv_tsval; /* Time stamp value */
|
|
u32 rcv_tsecr; /* Time stamp echo reply */
|
|
u16 saw_tstamp : 1, /* Saw TIMESTAMP on last packet */
|
|
tstamp_ok : 1, /* TIMESTAMP seen on SYN packet */
|
|
dsack : 1, /* D-SACK is scheduled */
|
|
wscale_ok : 1, /* Wscale seen on SYN packet */
|
|
sack_ok : 4, /* SACK seen on SYN packet */
|
|
snd_wscale : 4, /* Window scaling received from sender */
|
|
rcv_wscale : 4; /* Window scaling to send to receiver */
|
|
u8 num_sacks; /* Number of SACK blocks */
|
|
u16 user_mss; /* mss requested by user in ioctl */
|
|
u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
|
|
};
|
|
|
|
static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
|
|
{
|
|
rx_opt->tstamp_ok = rx_opt->sack_ok = 0;
|
|
rx_opt->wscale_ok = rx_opt->snd_wscale = 0;
|
|
}
|
|
|
|
/* This is the max number of SACKS that we'll generate and process. It's safe
|
|
* to increase this, although since:
|
|
* size = TCPOLEN_SACK_BASE_ALIGNED (4) + n * TCPOLEN_SACK_PERBLOCK (8)
|
|
* only four options will fit in a standard TCP header */
|
|
#define TCP_NUM_SACKS 4
|
|
|
|
struct tcp_request_sock_ops;
|
|
|
|
struct tcp_request_sock {
|
|
struct inet_request_sock req;
|
|
const struct tcp_request_sock_ops *af_specific;
|
|
struct sock *listener; /* needed for TFO */
|
|
u32 rcv_isn;
|
|
u32 snt_isn;
|
|
u32 snt_synack; /* synack sent time */
|
|
u32 rcv_nxt; /* the ack # by SYNACK. For
|
|
* FastOpen it's the seq#
|
|
* after data-in-SYN.
|
|
*/
|
|
};
|
|
|
|
static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
|
|
{
|
|
return (struct tcp_request_sock *)req;
|
|
}
|
|
|
|
struct tcp_sock {
|
|
/* inet_connection_sock has to be the first member of tcp_sock */
|
|
struct inet_connection_sock inet_conn;
|
|
u16 tcp_header_len; /* Bytes of tcp header to send */
|
|
u16 xmit_size_goal_segs; /* Goal for segmenting output packets */
|
|
|
|
/*
|
|
* Header prediction flags
|
|
* 0x5?10 << 16 + snd_wnd in net byte order
|
|
*/
|
|
__be32 pred_flags;
|
|
|
|
/*
|
|
* RFC793 variables by their proper names. This means you can
|
|
* read the code and the spec side by side (and laugh ...)
|
|
* See RFC793 and RFC1122. The RFC writes these in capitals.
|
|
*/
|
|
u32 rcv_nxt; /* What we want to receive next */
|
|
u32 copied_seq; /* Head of yet unread data */
|
|
u32 rcv_wup; /* rcv_nxt on last window update sent */
|
|
u32 snd_nxt; /* Next sequence we send */
|
|
|
|
u32 snd_una; /* First byte we want an ack for */
|
|
u32 snd_sml; /* Last byte of the most recently transmitted small packet */
|
|
u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */
|
|
u32 lsndtime; /* timestamp of last sent data packet (for restart window) */
|
|
|
|
u32 tsoffset; /* timestamp offset */
|
|
|
|
struct list_head tsq_node; /* anchor in tsq_tasklet.head list */
|
|
unsigned long tsq_flags;
|
|
|
|
/* Data for direct copy to user */
|
|
struct {
|
|
struct sk_buff_head prequeue;
|
|
struct task_struct *task;
|
|
struct iovec *iov;
|
|
int memory;
|
|
int len;
|
|
} ucopy;
|
|
|
|
u32 snd_wl1; /* Sequence for window update */
|
|
u32 snd_wnd; /* The window we expect to receive */
|
|
u32 max_window; /* Maximal window ever seen from peer */
|
|
u32 mss_cache; /* Cached effective mss, not including SACKS */
|
|
|
|
u32 window_clamp; /* Maximal window to advertise */
|
|
u32 rcv_ssthresh; /* Current window clamp */
|
|
|
|
u16 advmss; /* Advertised MSS */
|
|
u8 unused;
|
|
u8 nonagle : 4,/* Disable Nagle algorithm? */
|
|
thin_lto : 1,/* Use linear timeouts for thin streams */
|
|
thin_dupack : 1,/* Fast retransmit on first dupack */
|
|
repair : 1,
|
|
frto : 1;/* F-RTO (RFC5682) activated in CA_Loss */
|
|
u8 repair_queue;
|
|
u8 do_early_retrans:1,/* Enable RFC5827 early-retransmit */
|
|
syn_data:1, /* SYN includes data */
|
|
syn_fastopen:1, /* SYN includes Fast Open option */
|
|
syn_data_acked:1,/* data in SYN is acked by SYN-ACK */
|
|
is_cwnd_limited:1;/* forward progress limited by snd_cwnd? */
|
|
u32 tlp_high_seq; /* snd_nxt at the time of TLP retransmit. */
|
|
|
|
/* RTT measurement */
|
|
u32 srtt_us; /* smoothed round trip time << 3 in usecs */
|
|
u32 mdev_us; /* medium deviation */
|
|
u32 mdev_max_us; /* maximal mdev for the last rtt period */
|
|
u32 rttvar_us; /* smoothed mdev_max */
|
|
u32 rtt_seq; /* sequence number to update rttvar */
|
|
|
|
u32 packets_out; /* Packets which are "in flight" */
|
|
u32 retrans_out; /* Retransmitted packets out */
|
|
u32 max_packets_out; /* max packets_out in last window */
|
|
u32 max_packets_seq; /* right edge of max_packets_out flight */
|
|
|
|
u16 urg_data; /* Saved octet of OOB data and control flags */
|
|
u8 ecn_flags; /* ECN status bits. */
|
|
u8 reordering; /* Packet reordering metric. */
|
|
u32 snd_up; /* Urgent pointer */
|
|
|
|
u8 keepalive_probes; /* num of allowed keep alive probes */
|
|
/*
|
|
* Options received (usually on last packet, some only on SYN packets).
|
|
*/
|
|
struct tcp_options_received rx_opt;
|
|
|
|
/*
|
|
* Slow start and congestion control (see also Nagle, and Karn & Partridge)
|
|
*/
|
|
u32 snd_ssthresh; /* Slow start size threshold */
|
|
u32 snd_cwnd; /* Sending congestion window */
|
|
u32 snd_cwnd_cnt; /* Linear increase counter */
|
|
u32 snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */
|
|
u32 snd_cwnd_used;
|
|
u32 snd_cwnd_stamp;
|
|
u32 prior_cwnd; /* Congestion window at start of Recovery. */
|
|
u32 prr_delivered; /* Number of newly delivered packets to
|
|
* receiver in Recovery. */
|
|
u32 prr_out; /* Total number of pkts sent during Recovery. */
|
|
|
|
u32 rcv_wnd; /* Current receiver window */
|
|
u32 write_seq; /* Tail(+1) of data held in tcp send buffer */
|
|
u32 notsent_lowat; /* TCP_NOTSENT_LOWAT */
|
|
u32 pushed_seq; /* Last pushed seq, required to talk to windows */
|
|
u32 lost_out; /* Lost packets */
|
|
u32 sacked_out; /* SACK'd packets */
|
|
u32 fackets_out; /* FACK'd packets */
|
|
u32 tso_deferred;
|
|
|
|
/* from STCP, retrans queue hinting */
|
|
struct sk_buff* lost_skb_hint;
|
|
struct sk_buff *retransmit_skb_hint;
|
|
|
|
/* OOO segments go in this list. Note that socket lock must be held,
|
|
* as we do not use sk_buff_head lock.
|
|
*/
|
|
struct sk_buff_head out_of_order_queue;
|
|
|
|
/* SACKs data, these 2 need to be together (see tcp_options_write) */
|
|
struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
|
|
struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
|
|
|
|
struct tcp_sack_block recv_sack_cache[4];
|
|
|
|
struct sk_buff *highest_sack; /* skb just after the highest
|
|
* skb with SACKed bit set
|
|
* (validity guaranteed only if
|
|
* sacked_out > 0)
|
|
*/
|
|
|
|
int lost_cnt_hint;
|
|
u32 retransmit_high; /* L-bits may be on up to this seqno */
|
|
|
|
u32 lost_retrans_low; /* Sent seq after any rxmit (lowest) */
|
|
|
|
u32 prior_ssthresh; /* ssthresh saved at recovery start */
|
|
u32 high_seq; /* snd_nxt at onset of congestion */
|
|
|
|
u32 retrans_stamp; /* Timestamp of the last retransmit,
|
|
* also used in SYN-SENT to remember stamp of
|
|
* the first SYN. */
|
|
u32 undo_marker; /* snd_una upon a new recovery episode. */
|
|
int undo_retrans; /* number of undoable retransmissions. */
|
|
u32 total_retrans; /* Total retransmits for entire connection */
|
|
|
|
u32 urg_seq; /* Seq of received urgent pointer */
|
|
unsigned int keepalive_time; /* time before keep alive takes place */
|
|
unsigned int keepalive_intvl; /* time interval between keep alive probes */
|
|
|
|
int linger2;
|
|
|
|
/* Receiver side RTT estimation */
|
|
struct {
|
|
u32 rtt;
|
|
u32 seq;
|
|
u32 time;
|
|
} rcv_rtt_est;
|
|
|
|
/* Receiver queue space */
|
|
struct {
|
|
int space;
|
|
u32 seq;
|
|
u32 time;
|
|
} rcvq_space;
|
|
|
|
/* TCP-specific MTU probe information. */
|
|
struct {
|
|
u32 probe_seq_start;
|
|
u32 probe_seq_end;
|
|
} mtu_probe;
|
|
u32 mtu_info; /* We received an ICMP_FRAG_NEEDED / ICMPV6_PKT_TOOBIG
|
|
* while socket was owned by user.
|
|
*/
|
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
/* TCP AF-Specific parts; only used by MD5 Signature support so far */
|
|
const struct tcp_sock_af_ops *af_specific;
|
|
|
|
/* TCP MD5 Signature Option information */
|
|
struct tcp_md5sig_info __rcu *md5sig_info;
|
|
#endif
|
|
|
|
/* TCP fastopen related information */
|
|
struct tcp_fastopen_request *fastopen_req;
|
|
/* fastopen_rsk points to request_sock that resulted in this big
|
|
* socket. Used to retransmit SYNACKs etc.
|
|
*/
|
|
struct request_sock *fastopen_rsk;
|
|
};
|
|
|
|
enum tsq_flags {
|
|
TSQ_THROTTLED,
|
|
TSQ_QUEUED,
|
|
TCP_TSQ_DEFERRED, /* tcp_tasklet_func() found socket was owned */
|
|
TCP_WRITE_TIMER_DEFERRED, /* tcp_write_timer() found socket was owned */
|
|
TCP_DELACK_TIMER_DEFERRED, /* tcp_delack_timer() found socket was owned */
|
|
TCP_MTU_REDUCED_DEFERRED, /* tcp_v{4|6}_err() could not call
|
|
* tcp_v{4|6}_mtu_reduced()
|
|
*/
|
|
};
|
|
|
|
static inline struct tcp_sock *tcp_sk(const struct sock *sk)
|
|
{
|
|
return (struct tcp_sock *)sk;
|
|
}
|
|
|
|
struct tcp_timewait_sock {
|
|
struct inet_timewait_sock tw_sk;
|
|
u32 tw_rcv_nxt;
|
|
u32 tw_snd_nxt;
|
|
u32 tw_rcv_wnd;
|
|
u32 tw_ts_offset;
|
|
u32 tw_ts_recent;
|
|
long tw_ts_recent_stamp;
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
struct tcp_md5sig_key *tw_md5_key;
|
|
#endif
|
|
};
|
|
|
|
static inline struct tcp_timewait_sock *tcp_twsk(const struct sock *sk)
|
|
{
|
|
return (struct tcp_timewait_sock *)sk;
|
|
}
|
|
|
|
static inline bool tcp_passive_fastopen(const struct sock *sk)
|
|
{
|
|
return (sk->sk_state == TCP_SYN_RECV &&
|
|
tcp_sk(sk)->fastopen_rsk != NULL);
|
|
}
|
|
|
|
extern void tcp_sock_destruct(struct sock *sk);
|
|
|
|
static inline int fastopen_init_queue(struct sock *sk, int backlog)
|
|
{
|
|
struct request_sock_queue *queue =
|
|
&inet_csk(sk)->icsk_accept_queue;
|
|
|
|
if (queue->fastopenq == NULL) {
|
|
queue->fastopenq = kzalloc(
|
|
sizeof(struct fastopen_queue),
|
|
sk->sk_allocation);
|
|
if (queue->fastopenq == NULL)
|
|
return -ENOMEM;
|
|
|
|
sk->sk_destruct = tcp_sock_destruct;
|
|
spin_lock_init(&queue->fastopenq->lock);
|
|
}
|
|
queue->fastopenq->max_qlen = backlog;
|
|
return 0;
|
|
}
|
|
|
|
#endif /* _LINUX_TCP_H */
|