Hello, starting a technical review of this set. Please see inline: On 22/02/18 - 15:49:53, rao.shoaib(a)oracle.com wrote: it is important to explain (in the commit-message) for each of these callbacks why they are needed for an MPTCP implementation and why it can't be done without them. This is important to allow people to understand why the change is necessary and where it is leading to. Ignoring potential performance hits for a moment, callbacks also increase the code-maintenance overhead and thus each of them will need to justified. Christoph

Hi - Also beginning a review, see inline.... On Thu, 2018-02-22 at 15:49 -0800, rao.shoaib(a)oracle.com wrote: This structure looks like a facility to have different processing for MPTCP for each of these states. Peaking at the patch for the mptcp side shows only synsent being re-implemented. If it is not necessary to rework all of these it would be less impact to TCP code to just address the synsent case directly and do away with this. Peter. > +extern struct tcp_operational_ops *tcp_default_op_ops; > +extern struct tcp_state_ops *tcp_default_state_ops; > + > struct tcp_request_sock_ops { > u16 mss_clamp; > #ifdef CONFIG_TCP_MD5SIG > diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c > index a6b48f6..be81be4 100644 > --- a/net/ipv4/tcp_input.c > +++ b/net/ipv4/tcp_input.c > @@ -1093,19 +1093,6 @@ static bool tcp_check_dsack(struct sock *sk, > const struct sk_buff *ack_skb, > return dup_sack; > } > > -struct tcp_sacktag_state { > - u32 reord; > - /* Timestamps for earliest and latest never-retransmitted > segment > - * that was SACKed. RTO needs the earliest RTT to stay > conservative, > - * but congestion control should still get an accurate delay > signal. > - */ > - u64 first_sackt; > - u64 last_sackt; > - struct rate_sample *rate; > - int flag; > - unsigned int mss_now; > -}; > - > /* Check if skb is fully within the SACK block. In presence of GSO > skbs, > * the incoming SACK may not exactly match but we can find smaller > MSS > * aligned portion of it that matches. Therefore we might need to > fragment > diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c > index e9f985e..777c8b5 100644 > --- a/net/ipv4/tcp_output.c > +++ b/net/ipv4/tcp_output.c > @@ -420,17 +420,6 @@ static void smc_options_write(__be32 *ptr, u16 > *options) > #endif > } > > -struct tcp_out_options { > - u16 options; /* bit field of OPTION_* */ > - u16 mss; /* 0 to disable */ > - u8 ws; /* window scale, 0 to disable > */ > - u8 num_sack_blocks; /* number of SACK blocks to > include */ > - u8 hash_size; /* bytes in hash_location */ > - __u8 *hash_location; /* temporary pointer, overloaded > */ > - __u32 tsval, tsecr; /* need to include OPTION_TS */ > - struct tcp_fastopen_cookie *fastopen_cookie; /* Fast > open cookie */ > -}; > - > /* Write previously computed TCP options to the packet. > * > * Beware: Something in the Internet is very sensitive to the > ordering of

From: Rao Shoaib <rao.shoaib(a)oracle.com&gt; Signed-off-by: Rao Shoaib <rao.shoaib(a)oracle.com&gt; --- include/net/inet_sock.h | 6 ++++-- include/net/sock.h | 1 + include/net/tcp.h | 19 ++++++++++++++++--- include/uapi/linux/tcp.h | 1 + 4 files changed, 22 insertions(+), 5 deletions(-) diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h index 0a671c3..8961273 100644 --- a/include/net/inet_sock.h +++ b/include/net/inet_sock.h @@ -83,7 +83,7 @@ struct inet_request_sock { #define ireq_state req.__req_common.skc_state #define ireq_family req.__req_common.skc_family - u16 snd_wscale : 4, + u32 snd_wscale : 4, rcv_wscale : 4, tstamp_ok : 1, sack_ok : 1, @@ -91,7 +91,9 @@ struct inet_request_sock { ecn_ok : 1, acked : 1, no_srccheck: 1, - smc_ok : 1; + smc_ok : 1, + mptcp_rqsk : 1, /* set if the syn had MP_CAP */ + saw_mpc : 1; u32 ir_mark; union { struct ip_options_rcu __rcu *ireq_opt; diff --git a/include/net/sock.h b/include/net/sock.h index 3aa7b7d..10e00d7 100644 --- a/include/net/sock.h +++ b/include/net/sock.h @@ -777,6 +777,7 @@ enum sock_flags { SOCK_FILTER_LOCKED, /* Filter cannot be changed anymore */ SOCK_SELECT_ERR_QUEUE, /* Wake select on error queue */ SOCK_RCU_FREE, /* wait rcu grace period in sk_destruct() */ + SOCK_MPTCP, /* MPTCP set on this socket */ }; #define SK_FLAGS_TIMESTAMP ((1UL << SOCK_TIMESTAMP) | (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE)) diff --git a/include/net/tcp.h b/include/net/tcp.h index 8bc724f..e9f7582 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -52,6 +52,9 @@ extern struct inet_hashinfo tcp_hashinfo; extern struct percpu_counter tcp_orphan_count; void tcp_time_wait(struct sock *sk, int state, int timeo); +typedef int (*process_unclaimed)(const struct sock *sk, struct sk_buff *skb); +extern process_unclaimed tcp_process_unclaimed; + #define MAX_TCP_HEADER (128 + MAX_HEADER) #define MAX_TCP_OPTION_SPACE 40 @@ -182,6 +185,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo); #define TCPOPT_SACK 5 /* SACK Block */ #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ +#define TCPOPT_MPTCP 30 /* MPTCP (RFC6824) */ #define TCPOPT_FASTOPEN 34 /* Fast open (RFC7413) */ #define TCPOPT_EXP 254 /* Experimental */ /* Magic number to be after the option value for sharing TCP @@ -312,7 +316,6 @@ static inline bool tcp_too_many_orphans(struct sock *sk, int shift) bool tcp_check_oom(struct sock *sk, int shift); - extern struct proto tcp_prot; #define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field) @@ -800,12 +803,22 @@ struct tcp_skb_cb { #define TCPCB_RETRANS (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS| \ TCPCB_REPAIRED) - __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */ + union { + __u8 ip_dsfield; /* IPv4 tos or IPv6 dsfield */ + /* ip_dstfield is only used on the Rx side. It's value + * is consumed by the time MPTCP starts processing. + */ + __u8 mptcp_flags; + }; __u8 txstamp_ack:1, /* Record TX timestamp for ack? */ eor:1, /* Is skb MSG_EOR marked? */ has_rxtstamp:1, /* SKB has a RX timestamp */ unused:5; - __u32 ack_seq; /* Sequence number ACK'd */ + union { + __u32 ack_seq; /* Sequence number ACK'd */ + __u32 mptcp_data_seq; /* Used on Tx subskb */ + __u32 mptcp_path_mask; /* Used on orig skb */ + }; union { struct { /* There is space for up to 24 bytes */ diff --git a/include/uapi/linux/tcp.h b/include/uapi/linux/tcp.h index b4a4f64..c1a5e5d 100644 --- a/include/uapi/linux/tcp.h +++ b/include/uapi/linux/tcp.h @@ -122,6 +122,7 @@ enum { #define TCP_MD5SIG_EXT 32 /* TCP MD5 Signature with extensions */ #define TCP_FASTOPEN_KEY 33 /* Set the key for Fast Open (cookie) */ #define TCP_FASTOPEN_NO_COOKIE 34 /* Enable TFO without a TFO cookie */ +#define MPTCP_ENABLED 42 struct tcp_repair_opt { __u32 opt_code; -- 2.7.4

On 03/27/2018 02:38 AM, Christoph Paasch wrote: It is not currently used. I should have removed it my bad. I  used 42 because I believe the MPTCP implementation I used was using 42. There is no rule that I have to use 35, but if that makes you happy we can. Shoaib

On 22/02/18 - 15:49:55, rao.shoaib(a)oracle.com wrote: Can we somehow reduce the number of elements added to tcp_sock? ->mpcb can probably be reached through ->mptcp. Same, for the meta_sk. tk_table, mptcp_loc_token and mptcp_loc_key are only used on the meta-socket, if I'm not mistaken. And the meta-socket is only using a very small portion of struct tcp_sock. It might be better to use an entirely different data-structure for the meta-socket. That way you don't have to add tk_table, mptcp_loc_token and mptcp_loc_key to struct tcp_sock. Christoph

From: Rao Shoaib <rao.shoaib(a)oracle.com&gt; Signed-off-by: Rao Shoaib <rao.shoaib(a)oracle.com&gt; --- include/net/tcp.h | 33 ++++++++++++++++++++++++++- net/ipv4/tcp.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++--- net/ipv4/tcp_input.c | 47 +++++++++++++++++++------------------- net/ipv4/tcp_output.c | 19 +++++++--------- 4 files changed, 122 insertions(+), 39 deletions(-) diff --git a/include/net/tcp.h b/include/net/tcp.h index e9f7582..f952d97 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -560,14 +560,44 @@ void tcp_send_loss_probe(struct sock *sk); bool tcp_schedule_loss_probe(struct sock *sk, bool advancing_rto); void tcp_skb_collapse_tstamp(struct sk_buff *skb, const struct sk_buff *next_skb); +u16 tcp_select_window(struct sock *sk); +int select_size(const struct sock *sk, bool sg, bool first_skb, bool zc); +bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, + int push_one, gfp_t gfp); +void tcp_cwnd_validate(struct sock *sk, bool is_cwnd_limited); +void tcp_connect_init(struct sock *sk); +int tcp_send_mss(struct sock *sk, int *size_goal, int flags); +int tcp_mtu_probe(struct sock *sk); +void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to, int space); /* tcp_input.c */ void tcp_rearm_rto(struct sock *sk); void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req); void tcp_reset(struct sock *sk); +void tcp_set_rto(struct sock *sk); void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb); void tcp_fin(struct sock *sk); - +bool tcp_should_expand_sndbuf(const struct sock *sk); +bool tcp_prune_ofo_queue(struct sock *sk); + +void tcp_sndbuf_expand(struct sock *sk); +void tcp_grow_window(struct sock *sk, const struct sk_buff *skb); +int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb, + unsigned int size); +int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, + const struct tcphdr *th); +struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb, + struct sk_buff_head *list, + struct rb_root *root); +void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th); +struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb, + struct tcp_sacktag_state *state, + u32 start_seq, u32 end_seq, + bool dup_sack); +bool tcp_try_coalesce(struct sock *sk, struct sk_buff *to, + struct sk_buff *from, bool *fragstolen); +bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, + struct tcp_fastopen_cookie *cookie); /* tcp_timer.c */ void tcp_init_xmit_timers(struct sock *); static inline void tcp_clear_xmit_timers(struct sock *sk) @@ -604,6 +634,7 @@ static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize) /* tcp.c */ void tcp_get_info(struct sock *, struct tcp_info *); +void tcp_cleanup_rbuf(struct sock *sk, int copied); /* Read 'sendfile()'-style from a TCP socket */ int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index 48636ae..a6ff25c 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -399,6 +399,62 @@ static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp) return rate64; } +static bool tcp_can_send(struct sock *sk) +{ + bool ret = true; + + if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && + !tcp_passive_fastopen(sk)) + ret = false; + return ret; +} + +static const struct tcp_operational_ops __tcp_default_op_ops = { + .__select_window = __tcp_select_window, + .select_window = tcp_select_window, + .select_initial_window = tcp_select_initial_window, + .select_size = select_size, + .init_buffer_space = tcp_init_buffer_space, + .set_rto = tcp_set_rto, + .should_expand_sndbuf = tcp_should_expand_sndbuf, + .send_fin = tcp_send_fin, + .write_xmit = tcp_write_xmit, + .send_active_reset = tcp_send_active_reset, + .write_wakeup = tcp_write_wakeup, + .prune_ofo_queue = tcp_prune_ofo_queue, + .retransmit_timer = tcp_retransmit_timer, + .time_wait = tcp_time_wait, + .cleanup_rbuf = tcp_cleanup_rbuf, + .cwnd_validate = tcp_cwnd_validate, + .sndbuf_expand = tcp_sndbuf_expand, + .shift_skb_data = tcp_shift_skb_data, + .grow_window = tcp_grow_window, + .try_coalesce = tcp_try_coalesce, + .try_rmem_schedule = tcp_try_rmem_schedule, + .collapse_one = tcp_collapse_one, + .trim_head = tcp_trim_head, + .urg = tcp_urg, + .can_send = tcp_can_send, + .connect_init = tcp_connect_init, + .send_mss = tcp_send_mss, + .mtu_probe = tcp_mtu_probe, + .retrans_try_collapse = tcp_retrans_try_collapse, + .fastopen_synack = tcp_rcv_fastopen_synack, + .sendpage_locked = tcp_sendpage_locked, + .get_cookie_sock = tcp_get_cookie_sock, +}; + +struct tcp_operational_ops *tcp_default_op_ops = + (struct tcp_operational_ops *)&__tcp_default_op_ops; + +const struct tcp_state_ops __tcp_default_state_ops = { + .rcv_state_process = tcp_rcv_state_process, + .synsent = tcp_rcv_synsent_state_process, +}; + +struct tcp_state_ops *tcp_default_state_ops = + (struct tcp_state_ops *)&__tcp_default_state_ops; + /* Address-family independent initialization for a tcp_sock. * * NOTE: A lot of things set to zero explicitly by call to @@ -916,7 +972,7 @@ static unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now, return max(size_goal, mss_now); } -static int tcp_send_mss(struct sock *sk, int *size_goal, int flags) +int tcp_send_mss(struct sock *sk, int *size_goal, int flags) { int mss_now; @@ -1102,7 +1158,7 @@ static int linear_payload_sz(bool first_skb) return 0; } -static int select_size(const struct sock *sk, bool sg, bool first_skb, bool zc) +int select_size(const struct sock *sk, bool sg, bool first_skb, bool zc) { const struct tcp_sock *tp = tcp_sk(sk); int tmp = tp->mss_cache; @@ -1547,7 +1603,7 @@ static int tcp_peek_sndq(struct sock *sk, struct msghdr *msg, int len) * calculation of whether or not we must ACK for the sake of * a window update. */ -static void tcp_cleanup_rbuf(struct sock *sk, int copied) +void tcp_cleanup_rbuf(struct sock *sk, int copied) { struct tcp_sock *tp = tcp_sk(sk); bool time_to_ack = false; diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c index be81be4..5d6eb58 100644 --- a/net/ipv4/tcp_input.c +++ b/net/ipv4/tcp_input.c @@ -293,7 +293,7 @@ static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr * 1. Tuning sk->sk_sndbuf, when connection enters established state. */ -static void tcp_sndbuf_expand(struct sock *sk) +void tcp_sndbuf_expand(struct sock *sk) { const struct tcp_sock *tp = tcp_sk(sk); const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops; @@ -367,7 +367,7 @@ static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb) return 0; } -static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb) +void tcp_grow_window(struct sock *sk, const struct sk_buff *skb) { struct tcp_sock *tp = tcp_sk(sk); @@ -803,7 +803,7 @@ static void tcp_update_pacing_rate(struct sock *sk) /* Calculate rto without backoff. This is the second half of Van Jacobson's * routine referred to above. */ -static void tcp_set_rto(struct sock *sk) +void tcp_set_rto(struct sock *sk) { const struct tcp_sock *tp = tcp_sk(sk); /* Old crap is replaced with new one. 8) @@ -1333,10 +1333,10 @@ static int skb_can_shift(const struct sk_buff *skb) /* Try collapsing SACK blocks spanning across multiple skbs to a single * skb. */ -static struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb, - struct tcp_sacktag_state *state, - u32 start_seq, u32 end_seq, - bool dup_sack) +struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb, + struct tcp_sacktag_state *state, + u32 start_seq, u32 end_seq, + bool dup_sack) { struct tcp_sock *tp = tcp_sk(sk); struct sk_buff *prev; @@ -4259,10 +4259,10 @@ static void tcp_sack_remove(struct tcp_sock *tp) * Better try to coalesce them right now to avoid future collapses. * Returns true if caller should free @from instead of queueing it */ -static bool tcp_try_coalesce(struct sock *sk, - struct sk_buff *to, - struct sk_buff *from, - bool *fragstolen) +bool tcp_try_coalesce(struct sock *sk, + struct sk_buff *to, + struct sk_buff *from, + bool *fragstolen) { int delta; @@ -4350,11 +4350,10 @@ static void tcp_ofo_queue(struct sock *sk) } } -static bool tcp_prune_ofo_queue(struct sock *sk); static int tcp_prune_queue(struct sock *sk); -static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb, - unsigned int size) +int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb, + unsigned int size) { if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || !sk_rmem_schedule(sk, skb, size)) { @@ -4681,9 +4680,9 @@ static struct sk_buff *tcp_skb_next(struct sk_buff *skb, struct sk_buff_head *li return skb_rb_next(skb); } -static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb, - struct sk_buff_head *list, - struct rb_root *root) +struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb, + struct sk_buff_head *list, + struct rb_root *root) { struct sk_buff *next = tcp_skb_next(skb, list); @@ -4868,7 +4867,7 @@ static void tcp_collapse_ofo_queue(struct sock *sk) * * Return true if queue has shrunk. */ -static bool tcp_prune_ofo_queue(struct sock *sk) +bool tcp_prune_ofo_queue(struct sock *sk) { struct tcp_sock *tp = tcp_sk(sk); struct rb_node *node, *prev; @@ -4950,7 +4949,7 @@ static int tcp_prune_queue(struct sock *sk) return -1; } -static bool tcp_should_expand_sndbuf(const struct sock *sk) +bool tcp_should_expand_sndbuf(const struct sock *sk) { const struct tcp_sock *tp = tcp_sk(sk); @@ -5124,7 +5123,7 @@ static void tcp_check_urg(struct sock *sk, const struct tcphdr *th) } /* This is the 'fast' part of urgent handling. */ -static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th) +void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th) { struct tcp_sock *tp = tcp_sk(sk); @@ -5502,8 +5501,8 @@ void tcp_finish_connect(struct sock *sk, struct sk_buff *skb) tp->pred_flags = 0; } -static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, - struct tcp_fastopen_cookie *cookie) +bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, + struct tcp_fastopen_cookie *cookie) { struct tcp_sock *tp = tcp_sk(sk); struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL; @@ -5570,8 +5569,8 @@ static void smc_check_reset_syn(struct tcp_sock *tp) #endif } -static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, - const struct tcphdr *th) +int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, + const struct tcphdr *th) { struct inet_connection_sock *icsk = inet_csk(sk); struct tcp_sock *tp = tcp_sk(sk); diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c index 777c8b5..9f5be16 100644 --- a/net/ipv4/tcp_output.c +++ b/net/ipv4/tcp_output.c @@ -45,9 +45,6 @@ #include <trace/events/tcp.h> -static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, - int push_one, gfp_t gfp); - /* Account for new data that has been sent to the network. */ static void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb) { @@ -245,7 +242,7 @@ EXPORT_SYMBOL(tcp_select_initial_window); * value can be stuffed directly into th->window for an outgoing * frame. */ -static u16 tcp_select_window(struct sock *sk) +u16 tcp_select_window(struct sock *sk) { struct tcp_sock *tp = tcp_sk(sk); u32 old_win = tp->rcv_wnd; @@ -1621,7 +1618,7 @@ static void tcp_cwnd_application_limited(struct sock *sk) tp->snd_cwnd_stamp = tcp_jiffies32; } -static void tcp_cwnd_validate(struct sock *sk, bool is_cwnd_limited) +void tcp_cwnd_validate(struct sock *sk, bool is_cwnd_limited) { const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops; struct tcp_sock *tp = tcp_sk(sk); @@ -2025,7 +2022,7 @@ static inline void tcp_mtu_check_reprobe(struct sock *sk) * 1 if a probe was sent, * -1 otherwise */ -static int tcp_mtu_probe(struct sock *sk) +int tcp_mtu_probe(struct sock *sk) { struct inet_connection_sock *icsk = inet_csk(sk); struct tcp_sock *tp = tcp_sk(sk); @@ -2270,8 +2267,8 @@ void tcp_chrono_stop(struct sock *sk, const enum tcp_chrono type) * Returns true, if no segments are in flight and we have queued segments, * but cannot send anything now because of SWS or another problem. */ -static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, - int push_one, gfp_t gfp) +bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, + int push_one, gfp_t gfp) { struct tcp_sock *tp = tcp_sk(sk); struct sk_buff *skb; @@ -2758,8 +2755,8 @@ static bool tcp_can_collapse(const struct sock *sk, const struct sk_buff *skb) /* Collapse packets in the retransmit queue to make to create * less packets on the wire. This is only done on retransmission. */ -static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to, - int space) +void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to, + int space) { struct tcp_sock *tp = tcp_sk(sk); struct sk_buff *skb = to, *tmp; @@ -3274,7 +3271,7 @@ static void tcp_ca_dst_init(struct sock *sk, const struct dst_entry *dst) } /* Do all connect socket setups that can be done AF independent. */ -static void tcp_connect_init(struct sock *sk) +void tcp_connect_init(struct sock *sk) { const struct dst_entry *dst = __sk_dst_get(sk); struct tcp_sock *tp = tcp_sk(sk); -- 2.7.4

See inline ... On Thu, 2018-02-22 at 15:49 -0800, rao.shoaib(a)oracle.com wrote: Looking at the MPTCP patch tcp_default_op_ops.sock_init() is initialized to mptcp_init_tcp_sock(), so it is called regardless of the actual TCP vs. MPTCP nature of this tcp_sock. It seems mptcp_init_tcp_sock() could be called directly instead of through pointer and the sock_init element is not necessary. Peter. > sk_sockets_allocated_inc(sk); > } > EXPORT_SYMBOL(tcp_init_sock); > > void tcp_init_transfer(struct sock *sk, int bpf_op) > { > + const struct tcp_sock *tp = tcp_sk(sk); > struct inet_connection_sock *icsk = inet_csk(sk); > > tcp_mtup_init(sk); > @@ -521,7 +533,7 @@ void tcp_init_transfer(struct sock *sk, int bpf_op) > tcp_init_metrics(sk); > tcp_call_bpf(sk, bpf_op, 0, NULL); > tcp_init_congestion_control(sk); > - tcp_init_buffer_space(sk); > + tp->op_ops->init_buffer_space(sk); > } > > static void tcp_tx_timestamp(struct sock *sk, u16 tsflags) > @@ -1004,7 +1016,7 @@ ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, > > sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk); > > - mss_now = tcp_send_mss(sk, &size_goal, flags); > + mss_now = tp->op_ops->send_mss(sk, &size_goal, flags); > copied = 0; > > err = -EPIPE; > @@ -1090,7 +1102,7 @@ ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, > if (err != 0) > goto do_error; > > - mss_now = tcp_send_mss(sk, &size_goal, flags); > + mss_now = tp->op_ops->send_mss(sk, &size_goal, flags); > } > > out: > @@ -1134,7 +1146,8 @@ int tcp_sendpage(struct sock *sk, struct page *page, int offset, > int ret; > > lock_sock(sk); > - ret = tcp_sendpage_locked(sk, page, offset, size, flags); > + ret = tcp_sk(sk)->op_ops->sendpage_locked(sk, page, offset, > + size, flags); > release_sock(sk); > > return ret; > @@ -1282,8 +1295,7 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size) > * (passive side) where data is allowed to be sent before a connection > * is fully established. > */ > - if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && > - !tcp_passive_fastopen(sk)) { > + if (!tp->op_ops->can_send(sk)) { > err = sk_stream_wait_connect(sk, &timeo); > if (err != 0) > goto do_error; > @@ -1318,7 +1330,7 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size) > copied = 0; > > restart: > - mss_now = tcp_send_mss(sk, &size_goal, flags); > + mss_now = tp->op_ops->send_mss(sk, &size_goal, flags); > > err = -EPIPE; > if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) > @@ -1353,7 +1365,7 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size) > goto restart; > } > first_skb = tcp_rtx_and_write_queues_empty(sk); > - linear = select_size(sk, sg, first_skb, zc); > + linear = tp->op_ops->select_size(sk, sg, first_skb, zc); > skb = sk_stream_alloc_skb(sk, linear, sk->sk_allocation, > first_skb); > if (!skb) > @@ -1473,7 +1485,7 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size) > if (err != 0) > goto do_error; > > - mss_now = tcp_send_mss(sk, &size_goal, flags); > + mss_now = tp->op_ops->send_mss(sk, &size_goal, flags); > } > > out: > @@ -1762,7 +1774,7 @@ int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, > /* Clean up data we have read: This will do ACK frames. */ > if (copied > 0) { > tcp_recv_skb(sk, seq, &offset); > - tcp_cleanup_rbuf(sk, copied); > + tp->op_ops->cleanup_rbuf(sk, copied); > } > return copied; > } > @@ -1982,7 +1994,7 @@ int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, > } > } > > - tcp_cleanup_rbuf(sk, copied); > + tp->op_ops->cleanup_rbuf(sk, copied); > > if (copied >= target) { > /* Do not sleep, just process backlog. */ > @@ -2075,7 +2087,7 @@ int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, > tcp_recv_timestamp(msg, sk, &tss); > > /* Clean up data we have read: This will do ACK frames. */ > - tcp_cleanup_rbuf(sk, copied); > + tp->op_ops->cleanup_rbuf(sk, copied); > > release_sock(sk); > return copied; > @@ -2876,7 +2888,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level, > (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) && > inet_csk_ack_scheduled(sk)) { > icsk->icsk_ack.pending |= ICSK_ACK_PUSHED; > - tcp_cleanup_rbuf(sk, 1); > + tp->op_ops->cleanup_rbuf(sk, 1); > if (!(val & 1)) > icsk->icsk_ack.pingpong = 1; > } > diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c > index 5d6eb58..8cc48bb 100644 > --- a/net/ipv4/tcp_input.c > +++ b/net/ipv4/tcp_input.c > @@ -425,7 +425,7 @@ void tcp_init_buffer_space(struct sock *sk) > if (!(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) > tcp_fixup_rcvbuf(sk); > if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) > - tcp_sndbuf_expand(sk); > + tp->op_ops->sndbuf_expand(sk); > > tp->rcvq_space.space = tp->rcv_wnd; > tcp_mstamp_refresh(tp); > @@ -690,7 +690,7 @@ static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb) > tcp_ecn_check_ce(tp, skb); > > if (skb->len >= 128) > - tcp_grow_window(sk, skb); > + tp->op_ops->grow_window(sk, skb); > } > > /* Called to compute a smoothed rtt estimate. The data fed to this > @@ -1504,7 +1504,7 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk, > * so not even _safe variant of the loop is enough. > */ > if (in_sack <= 0) { > - tmp = tcp_shift_skb_data(sk, skb, state, > + tmp = tp->op_ops->shift_skb_data(sk, skb, state, > start_seq, end_seq, dup_sack); > if (tmp) { > if (tmp != skb) { > @@ -2974,7 +2974,7 @@ static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb) > BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una)); > > packets_acked = tcp_skb_pcount(skb); > - if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq)) > + if (tp->op_ops->trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq)) > return 0; > packets_acked -= tcp_skb_pcount(skb); > > @@ -4362,7 +4362,7 @@ int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb, > return -1; > > while (!sk_rmem_schedule(sk, skb, size)) { > - if (!tcp_prune_ofo_queue(sk)) > + if (!tcp_sk(sk)->op_ops->prune_ofo_queue(sk)) > return -1; > } > } > @@ -4741,7 +4741,8 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root, > > /* No new bits? It is possible on ofo queue. */ > if (!before(start, TCP_SKB_CB(skb)->end_seq)) { > - skb = tcp_collapse_one(sk, skb, list, root); > + skb = tcp_sk(sk)->op_ops->collapse_one(sk, skb, > + list, root); > if (!skb) > break; > goto restart; > @@ -4805,7 +4806,9 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root, > start += size; > } > if (!before(start, TCP_SKB_CB(skb)->end_seq)) { > - skb = tcp_collapse_one(sk, skb, list, root); > + skb = > + tcp_sk(sk)->op_ops->collapse_one(sk, skb, list, > + root); > if (!skb || > skb == tail || > (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN))) > @@ -4933,7 +4936,7 @@ static int tcp_prune_queue(struct sock *sk) > /* Collapsing did not help, destructive actions follow. > * This must not ever occur. */ > > - tcp_prune_ofo_queue(sk); > + tp->op_ops->prune_ofo_queue(sk); > > if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf) > return 0; > @@ -4985,7 +4988,7 @@ static void tcp_new_space(struct sock *sk) > struct tcp_sock *tp = tcp_sk(sk); > > if (tcp_should_expand_sndbuf(sk)) { > - tcp_sndbuf_expand(sk); > + tp->op_ops->sndbuf_expand(sk); > tp->snd_cwnd_stamp = tcp_jiffies32; > } > > @@ -5454,7 +5457,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb, > tcp_rcv_rtt_measure_ts(sk, skb); > > /* Process urgent data. */ > - tcp_urg(sk, skb, th); > + tp->op_ops->urg(sk, skb, th); > > /* step 7: process the segment text */ > tcp_data_queue(sk, skb); > @@ -5846,7 +5849,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb) > return queued; > > /* Do step6 onward by hand. */ > - tcp_urg(sk, skb, th); > + tp->op_ops->urg(sk, skb, th); > __kfree_skb(skb); > tcp_data_snd_check(sk); > return 0; > @@ -6011,7 +6014,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb) > } > > /* step 6: check the URG bit */ > - tcp_urg(sk, skb, th); > + tp->op_ops->urg(sk, skb, th); > > /* step 7: process the segment text */ > switch (sk->sk_state) { > diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c > index f3e52bc..482ca15 100644 > --- a/net/ipv4/tcp_ipv4.c > +++ b/net/ipv4/tcp_ipv4.c > @@ -1885,12 +1885,8 @@ static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = { > */ > static int tcp_v4_init_sock(struct sock *sk) > { > - struct inet_connection_sock *icsk = inet_csk(sk); > - > tcp_init_sock(sk); > > - icsk->icsk_af_ops = &ipv4_specific; > - > #ifdef CONFIG_TCP_MD5SIG > tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific; > #endif > diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c > index 9f5be16..f296f1f7 100644 > --- a/net/ipv4/tcp_output.c > +++ b/net/ipv4/tcp_output.c > @@ -771,8 +771,8 @@ static void tcp_tsq_handler(struct sock *sk) > tcp_xmit_retransmit_queue(sk); > } > > - tcp_write_xmit(sk, tcp_current_mss(sk), tp->nonagle, > - 0, GFP_ATOMIC); > + tcp_sk(sk)->op_ops->write_xmit(sk, tcp_current_mss(sk), > + tp->nonagle, 0, GFP_ATOMIC); > } > } > /* > @@ -2282,8 +2282,8 @@ bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, > > tcp_mstamp_refresh(tp); > if (!push_one) { > - /* Do MTU probing. */ > - result = tcp_mtu_probe(sk); > + /* Do MTU probing ? */ > + result = tp->op_ops->mtu_probe(sk); > if (!result) { > return false; > } else if (result > 0) { > @@ -2524,8 +2524,8 @@ void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, > if (unlikely(sk->sk_state == TCP_CLOSE)) > return; > > - if (tcp_write_xmit(sk, cur_mss, nonagle, 0, > - sk_gfp_mask(sk, GFP_ATOMIC))) > + if (tcp_sk(sk)->op_ops->write_xmit(sk, cur_mss, nonagle, 0, > + sk_gfp_mask(sk, GFP_ATOMIC))) > tcp_check_probe_timer(sk); > } > > @@ -2538,7 +2538,8 @@ void tcp_push_one(struct sock *sk, unsigned int mss_now) > > BUG_ON(!skb || skb->len < mss_now); > > - tcp_write_xmit(sk, mss_now, TCP_NAGLE_PUSH, 1, sk->sk_allocation); > + tcp_sk(sk)->op_ops->write_xmit(sk, mss_now, TCP_NAGLE_PUSH, 1, > + sk->sk_allocation); > } > > /* This function returns the amount that we can raise the > @@ -2822,7 +2823,8 @@ int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs) > if (before(TCP_SKB_CB(skb)->seq, tp->snd_una)) { > if (before(TCP_SKB_CB(skb)->end_seq, tp->snd_una)) > BUG(); > - if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq)) > + if (tp->op_ops->trim_head(sk, skb, > + tp->snd_una - TCP_SKB_CB(skb)->seq)) > return -ENOMEM; > } > > @@ -2855,7 +2857,7 @@ int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs) > if (diff) > tcp_adjust_pcount(sk, skb, diff); > if (skb->len < cur_mss) > - tcp_retrans_try_collapse(sk, skb, cur_mss); > + tp->op_ops->retrans_try_collapse(sk, skb, cur_mss); > } > > /* RFC3168, section 6.1.1.1. ECN fallback */ > @@ -3464,7 +3466,7 @@ int tcp_connect(struct sock *sk) > if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk)) > return -EHOSTUNREACH; /* Routing failure or similar. */ > > - tcp_connect_init(sk); > + tp->op_ops->connect_init(sk); > > if (unlikely(tp->repair)) { > tcp_finish_connect(sk, NULL); > @@ -3704,7 +3706,7 @@ void tcp_send_probe0(struct sock *sk) > unsigned long probe_max; > int err; > > - err = tcp_write_wakeup(sk, LINUX_MIB_TCPWINPROBE); > + err = tp->op_ops->write_wakeup(sk, LINUX_MIB_TCPWINPROBE); > > if (tp->packets_out || tcp_write_queue_empty(sk)) { > /* Cancel probe timer, if it is not required. */ > diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c > index 71fc60f..beaba7a 100644 > --- a/net/ipv4/tcp_timer.c > +++ b/net/ipv4/tcp_timer.c > @@ -569,7 +569,7 @@ void tcp_write_timer_handler(struct sock *sk) > break; > case ICSK_TIME_RETRANS: > icsk->icsk_pending = 0; > - tcp_retransmit_timer(sk); > + tcp_sk(sk)->op_ops->retransmit_timer(sk); > break; > case ICSK_TIME_PROBE0: > icsk->icsk_pending = 0; > diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c > index 883df0a..293bdc8 100644 > --- a/net/ipv6/tcp_ipv6.c > +++ b/net/ipv6/tcp_ipv6.c > @@ -77,8 +77,6 @@ static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > > static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); > > -static const struct inet_connection_sock_af_ops ipv6_mapped; > -static const struct inet_connection_sock_af_ops ipv6_specific; > #ifdef CONFIG_TCP_MD5SIG > static const struct tcp_sock_af_ops tcp_sock_ipv6_specific; > static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; > @@ -1656,7 +1654,7 @@ static struct timewait_sock_ops tcp6_timewait_sock_ops = { > .twsk_destructor = tcp_twsk_destructor, > }; > > -static const struct inet_connection_sock_af_ops ipv6_specific = { > +const struct inet_connection_sock_af_ops ipv6_specific = { > .queue_xmit = inet6_csk_xmit, > .send_check = tcp_v6_send_check, > .rebuild_header = inet6_sk_rebuild_header, > @@ -1687,7 +1685,7 @@ static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = { > /* > * TCP over IPv4 via INET6 API > */ > -static const struct inet_connection_sock_af_ops ipv6_mapped = { > +const struct inet_connection_sock_af_ops ipv6_mapped = { > .queue_xmit = ip_queue_xmit, > .send_check = tcp_v4_send_check, > .rebuild_header = inet_sk_rebuild_header, > @@ -1719,12 +1717,8 @@ static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = { > */ > static int tcp_v6_init_sock(struct sock *sk) > { > - struct inet_connection_sock *icsk = inet_csk(sk); > - > tcp_init_sock(sk); > > - icsk->icsk_af_ops = &ipv6_specific; > - > #ifdef CONFIG_TCP_MD5SIG > tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific; > #endif

From: Rao Shoaib <rao.shoaib(a)oracle.com&gt; Signed-off-by: Rao Shoaib <rao.shoaib(a)oracle.com&gt; --- include/net/tcp.h | 12 ++++++++++ net/ipv4/tcp.c | 3 +++ net/ipv4/tcp_output.c | 66 +++++++++++++++++++++++++++++++++------------------ 3 files changed, 58 insertions(+), 23 deletions(-) diff --git a/include/net/tcp.h b/include/net/tcp.h index bd6b082..f5d748a 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -571,6 +571,18 @@ int select_size(const struct sock *sk, bool sg, bool first_skb, bool zc); bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, int push_one, gfp_t gfp); void tcp_cwnd_validate(struct sock *sk, bool is_cwnd_limited); +unsigned int tcp_synack_options_size(const struct sock *sk, + struct request_sock *req, + unsigned int mss, struct sk_buff *skb, + struct tcp_out_options *opts, + const struct tcp_md5sig_key *md5, + struct tcp_fastopen_cookie *foc); +int tcp_options_size(struct sock *sk, struct sk_buff *skb, + struct tcp_out_options *opts, + struct tcp_md5sig_key **md5); +void tcp_options_write(__be32 **ptr, struct tcp_sock *tp, + struct tcp_out_options *opts, + struct sk_buff *skb); void tcp_connect_init(struct sock *sk); int tcp_send_mss(struct sock *sk, int *size_goal, int flags); int tcp_mtu_probe(struct sock *sk); diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index ab82e7c..136be43 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -435,6 +435,9 @@ static const struct tcp_operational_ops __tcp_default_op_ops = { .trim_head = tcp_trim_head, .urg = tcp_urg, .can_send = tcp_can_send, + .synack_options_size = tcp_synack_options_size, + .options_size = tcp_options_size, + .options_write = tcp_options_write, .connect_init = tcp_connect_init, .send_mss = tcp_send_mss, .mtu_probe = tcp_mtu_probe, diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c index f296f1f7..2fa5c05 100644 --- a/net/ipv4/tcp_output.c +++ b/net/ipv4/tcp_output.c @@ -430,10 +430,12 @@ static void smc_options_write(__be32 *ptr, u16 *options) * At least SACK_PERM as the first option is known to lead to a disaster * (but it may well be that other scenarios fail similarly). */ -static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp, - struct tcp_out_options *opts) +void tcp_options_write(__be32 **ptr_ptr, struct tcp_sock *tp, + struct tcp_out_options *opts, + struct sk_buff *skb) { u16 options = opts->options; /* mungable copy */ + __be32 *ptr = *ptr_ptr; if (unlikely(OPTION_MD5 & options)) { *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | @@ -525,6 +527,8 @@ static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp, } smc_options_write(ptr, &options); + + *ptr_ptr = ptr; } static void smc_set_option(const struct tcp_sock *tp, @@ -563,9 +567,9 @@ static void smc_set_option_cond(const struct tcp_sock *tp, /* Compute TCP options for SYN packets. This is not the final * network wire format yet. */ -static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb, - struct tcp_out_options *opts, - struct tcp_md5sig_key **md5) +unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb, + struct tcp_out_options *opts, + struct tcp_md5sig_key **md5) { struct tcp_sock *tp = tcp_sk(sk); unsigned int remaining = MAX_TCP_OPTION_SPACE; @@ -631,12 +635,12 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb, } /* Set up TCP options for SYN-ACKs. */ -static unsigned int tcp_synack_options(const struct sock *sk, - struct request_sock *req, - unsigned int mss, struct sk_buff *skb, - struct tcp_out_options *opts, - const struct tcp_md5sig_key *md5, - struct tcp_fastopen_cookie *foc) +unsigned int tcp_synack_options_size(const struct sock *sk, + struct request_sock *req, + unsigned int mss, struct sk_buff *skb, + struct tcp_out_options *opts, + const struct tcp_md5sig_key *md5, + struct tcp_fastopen_cookie *foc) { struct inet_request_sock *ireq = inet_rsk(req); unsigned int remaining = MAX_TCP_OPTION_SPACE; @@ -737,6 +741,16 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb return size; } +int tcp_options_size(struct sock *sk, struct sk_buff *skb, + struct tcp_out_options *opts, + struct tcp_md5sig_key **md5) +{ + if (unlikely(skb && (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN))) + return (tcp_syn_options(sk, skb, opts, md5)); + else + return (tcp_established_options(sk, skb, opts, md5)); +} + /* TCP SMALL QUEUES (TSQ) * @@ -1030,6 +1044,8 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, struct tcp_md5sig_key *md5; struct tcphdr *th; int err; + __be32 *ptr; + __be32 *orig_ptr; BUG_ON(!skb || !tcp_skb_pcount(skb)); tp = tcp_sk(sk); @@ -1055,12 +1071,9 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, tcb = TCP_SKB_CB(skb); memset(&opts, 0, sizeof(opts)); - if (unlikely(tcb->tcp_flags & TCPHDR_SYN)) - tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5); - else - tcp_options_size = tcp_established_options(sk, skb, &opts, - &md5); + tcp_options_size = tp->op_ops->options_size(sk, skb, &opts, &md5); tcp_header_size = tcp_options_size + sizeof(struct tcphdr); + WARN_ON(tcp_options_size > MAX_TCP_OPTION_SPACE); /* if no packet is in qdisc/device queue, then allow XPS to select * another queue. We can be called from tcp_tsq_handler() @@ -1112,7 +1125,10 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, } } - tcp_options_write((__be32 *)(th + 1), tp, &opts); + ptr = (__be32 *)(th + 1); + orig_ptr = ptr; + tp->op_ops->options_write(&ptr, tp, &opts, skb); + WARN_ON((ptr - orig_ptr) * 4 != tcp_options_size); skb_shinfo(skb)->gso_type = sk->sk_gso_type; if (likely(!(tcb->tcp_flags & TCPHDR_SYN))) { th->window = htons(tcp_select_window(sk)); @@ -1582,8 +1598,9 @@ unsigned int tcp_current_mss(struct sock *sk) mss_now = tcp_sync_mss(sk, mtu); } - header_len = tcp_established_options(sk, NULL, &opts, &md5) + - sizeof(struct tcphdr); + header_len = tp->op_ops->options_size(sk, NULL, &opts, &md5) + + sizeof(struct tcphdr); + /* The mss_cache is sized based on tp->tcp_header_len, which assumes * some common options. If this is an odd packet (because we have SACK * blocks etc) then our calculated header_len will be different, and @@ -3164,13 +3181,14 @@ struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst, enum tcp_synack_type synack_type) { struct inet_request_sock *ireq = inet_rsk(req); - const struct tcp_sock *tp = tcp_sk(sk); + struct tcp_sock *tp = tcp_sk(sk); struct tcp_md5sig_key *md5 = NULL; struct tcp_out_options opts; struct sk_buff *skb; int tcp_header_size; struct tcphdr *th; int mss; + __be32 *ptr; skb = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC); if (unlikely(!skb)) { @@ -3214,8 +3232,9 @@ struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst, md5 = tcp_rsk(req)->af_specific->req_md5_lookup(sk, req_to_sk(req)); #endif skb_set_hash(skb, tcp_rsk(req)->txhash, PKT_HASH_TYPE_L4); - tcp_header_size = tcp_synack_options(sk, req, mss, skb, &opts, md5, - foc) + sizeof(*th); + tcp_header_size = tp->op_ops->synack_options_size(sk, req, mss, skb, + &opts, md5, foc); + tcp_header_size += sizeof(*th); skb_push(skb, tcp_header_size); skb_reset_transport_header(skb); @@ -3235,7 +3254,8 @@ struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst, /* RFC1323: The window in SYN & SYN/ACK segments is never scaled. */ th->window = htons(min(req->rsk_rcv_wnd, 65535U)); - tcp_options_write((__be32 *)(th + 1), NULL, &opts); + ptr = (__be32 *)(th + 1); + tp->op_ops->options_write(&ptr, tp, &opts, skb); th->doff = (tcp_header_size >> 2); __TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS); -- 2.7.4

inline .... On Thu, 2018-02-22 at 15:49 -0800, rao.shoaib(a)oracle.com wrote: The first parameter should be &tcp6_request_sock_ops. Note missing '6'. See original usage near bottom of this spatch. All the above is a combination of alloc and init of the request_sock for both v4 and v6 into a single routine (which will then be replaced with a single mptcp version as appropriate). A different approach would be to add another field to struct request_sock_ops that is initialized to v4 and v6-specific routines. This change would be a standalone TCP change, unrelated to MPTCP. Then these fields could be replaced with MPTCP-specific v4 and v6 versions for MPTCP. This would 1) eliminate one more function pointer member of operational_ops, 2) reduce size of MPTCP change to TCP, 3) Better maintain existing v4/v6 separation. Here is the use of tcp6_request_sock_ops. Peter. if (!req) > goto out; > > ireq = inet_rsk(req); > - treq = tcp_rsk(req); > - treq->tfo_listener = false; > > if (security_inet_conn_request(sk, skb, req)) > goto out_free; > > - req->mss = mss; > - ireq->ir_rmt_port = th->source; > - ireq->ir_num = ntohs(th->dest); > - ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr; > - ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr; > - if (ipv6_opt_accepted(sk, skb, &TCP_SKB_CB(skb)->header.h6) || > - np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo || > - np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) { > - refcount_inc(&skb->users); > - ireq->pktopts = skb; > - } > - > - ireq->ir_iif = inet_request_bound_dev_if(sk, skb); > - /* So that link locals have meaning */ > - if (!sk->sk_bound_dev_if && > - ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL) > - ireq->ir_iif = tcp_v6_iif(skb); > - > - ireq->ir_mark = inet_request_mark(sk, skb); > - > - req->num_retrans = 0; > - ireq->snd_wscale = tcp_opt.snd_wscale; > - ireq->sack_ok = tcp_opt.sack_ok; > - ireq->wscale_ok = tcp_opt.wscale_ok; > - ireq->tstamp_ok = tcp_opt.saw_tstamp; > - req->ts_recent = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsval : 0; > - treq->snt_synack = 0; > - treq->rcv_isn = ntohl(th->seq) - 1; > - treq->snt_isn = cookie; > - treq->ts_off = 0; > - treq->txhash = net_tx_rndhash(); > - > /* > * We need to lookup the dst_entry to get the correct window size. > * This is taken from tcp_v6_syn_recv_sock. Somebody please enlighten > @@ -252,7 +218,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb) > ireq->rcv_wscale = rcv_wscale; > ireq->ecn_ok = cookie_ecn_ok(&tcp_opt, sock_net(sk), dst); > > - ret = tcp_get_cookie_sock(sk, skb, req, dst, tsoff); > + ret = tp->op_ops->get_cookie_sock(sk, skb, req, dst, tsoff); > out: > return ret; > out_free:

On Fri, 2018-03-30 at 11:30 -0700, Rao Shoaib wrote: No question here, just marking the original usage of tcp6_request_sock_ops that I refer to in my first comment in this patch. > > Shoaib > > > > Peter. > > > > > + > > > + req = tp->op_ops->cookie_req_alloc(sk, skb, &tcp_opt, cookie, mss); > > > > if (!req) > > > goto out; > > > > > > ireq = inet_rsk(req); > > > - treq = tcp_rsk(req); > > > - treq->tfo_listener = false; > > > > > > if (security_inet_conn_request(sk, skb, req)) > > > goto out_free; > > > > > > - req->mss = mss; > > > - ireq->ir_rmt_port = th->source; > > > - ireq->ir_num = ntohs(th->dest); > > > - ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr; > > > - ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr; > > > - if (ipv6_opt_accepted(sk, skb, &TCP_SKB_CB(skb)->header.h6) || > > > - np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo || > > > - np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) { > > > - refcount_inc(&skb->users); > > > - ireq->pktopts = skb; > > > - } > > > - > > > - ireq->ir_iif = inet_request_bound_dev_if(sk, skb); > > > - /* So that link locals have meaning */ > > > - if (!sk->sk_bound_dev_if && > > > - ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL) > > > - ireq->ir_iif = tcp_v6_iif(skb); > > > - > > > - ireq->ir_mark = inet_request_mark(sk, skb); > > > - > > > - req->num_retrans = 0; > > > - ireq->snd_wscale = tcp_opt.snd_wscale; > > > - ireq->sack_ok = tcp_opt.sack_ok; > > > - ireq->wscale_ok = tcp_opt.wscale_ok; > > > - ireq->tstamp_ok = tcp_opt.saw_tstamp; > > > - req->ts_recent = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsval : 0; > > > - treq->snt_synack = 0; > > > - treq->rcv_isn = ntohl(th->seq) - 1; > > > - treq->snt_isn = cookie; > > > - treq->ts_off = 0; > > > - treq->txhash = net_tx_rndhash(); > > > - > > > /* > > > * We need to lookup the dst_entry to get the correct window size. > > > * This is taken from tcp_v6_syn_recv_sock. Somebody please enlighten > > > @@ -252,7 +218,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb) > > > ireq->rcv_wscale = rcv_wscale; > > > ireq->ecn_ok = cookie_ecn_ok(&tcp_opt, sock_net(sk), dst); > > > > > > - ret = tcp_get_cookie_sock(sk, skb, req, dst, tsoff); > > > + ret = tp->op_ops->get_cookie_sock(sk, skb, req, dst, tsoff); > > > out: > > > return ret; > > > out_free: > > > > _______________________________________________ > > mptcp mailing list > > mptcp(a)lists.01.org > > https://lists.01.org/mailman/listinfo/mptcp > > _______________________________________________ > mptcp mailing list > mptcp(a)lists.01.org > https://lists.01.org/mailman/listinfo/mptcp

From: Rao Shoaib <rao.shoaib(a)oracle.com&gt; Signed-off-by: Rao Shoaib <rao.shoaib(a)oracle.com&gt; --- include/net/inet_common.h | 2 + include/net/tcp.h | 106 ++++++++++++++++++++++++++++++++++++++++++++++ net/ipv4/af_inet.c | 3 +- net/ipv4/tcp.c | 59 ++++++++++++++------------ net/ipv4/tcp_input.c | 89 +++++++++++++++++++++++--------------- net/ipv4/tcp_ipv4.c | 42 ++++++++++++------ net/ipv4/tcp_output.c | 55 +++++++++++++----------- net/ipv4/tcp_timer.c | 9 ++-- net/ipv6/af_inet6.c | 4 +- net/ipv6/tcp_ipv6.c | 63 ++++++++++++++------------- 10 files changed, 293 insertions(+), 139 deletions(-) diff --git a/include/net/inet_common.h b/include/net/inet_common.h index 500f813..7b919c7 100644 --- a/include/net/inet_common.h +++ b/include/net/inet_common.h @@ -14,6 +14,8 @@ struct sock; struct sockaddr; struct socket; +int inet_create(struct net *net, struct socket *sock, int protocol, int kern); +int inet6_create(struct net *net, struct socket *sock, int protocol, int kern); int inet_release(struct socket *sock); int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags); diff --git a/include/net/tcp.h b/include/net/tcp.h index f5d748a..3344b1d 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -314,6 +314,12 @@ static inline bool tcp_too_many_orphans(struct sock *sk, int shift) return false; } +static inline void tcp_drop(struct sock *sk, struct sk_buff *skb) +{ + sk_drops_add(sk, skb); + __kfree_skb(skb); +} + bool tcp_check_oom(struct sock *sk, int shift); extern struct proto tcp_prot; @@ -2273,6 +2279,106 @@ static inline bool tcp_bpf_ca_needs_ecn(struct sock *sk) return (tcp_call_bpf(sk, BPF_SOCK_OPS_NEEDS_ECN, 0, NULL) == 1); } +/* MPTCP */ +unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now, + int large_allowed); +ssize_t tcp_sendpages_xmit(struct sock *sk, struct page *page, int offset, + size_t size, int flags); +ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, + size_t size, int flags); +int tcp_close_state(struct sock *sk); +void tcp_enter_quickack_mode(struct sock *sk); +void tcp_sndbuf_expand_impl(struct sock *sk, u32 nr_segs); +bool tcp_check_rtt(struct sock *sk); +u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb); +void tcp_ack_probe(struct sock *sk); +bool tcp_may_update_window(const struct tcp_sock *tp, const u32 ack, + const u32 ack_seq, const u32 nwin); +bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, + struct tcp_fastopen_cookie *cookie); +bool tcp_rcv_fastopen_synack_impl(struct sock *sk, struct sk_buff *synack, + struct tcp_fastopen_cookie *cookie, + bool rexmit); +void tcp_enter_quickack_mode(struct sock *sk); +void tcp_check_space(struct sock *sk); +int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen, + bool *fragstolen); +void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb); +void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags); +bool tcp_urg_mode(const struct tcp_sock *tp); +int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, + gfp_t gfp_mask); +void tcp_queue_skb(struct sock *sk, struct sk_buff *skb); +void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now); +void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr); +int pskb_trim_head(struct sk_buff *skb, int len); +void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now, + const struct sk_buff *skb); +unsigned int tcp_mss_split_point(const struct sock *sk, + const struct sk_buff *skb, + unsigned int mss_now, + unsigned int max_segs, + int nonagle); +unsigned int tcp_cwnd_test(const struct tcp_sock *tp, + const struct sk_buff *skb); +int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now); +bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb, + unsigned int cur_mss, int nonagle); +bool tcp_snd_wnd_test(const struct tcp_sock *tp, const struct sk_buff *skb, + unsigned int cur_mss); +int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib); +void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb); +void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, + struct request_sock *req); +void tcp_v4_reqsk_destructor(struct request_sock *req); +struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb); +void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, + const struct tcphdr *th); +void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, + const struct tcphdr *th); +void tcp_write_err(struct sock *sk); +bool retransmits_timed_out(struct sock *sk, unsigned int boundary, + unsigned int timeout); +int tcp_write_timeout(struct sock *sk); +struct request_sock *tcp_cookie_req_alloc(struct sock *sk, + struct sk_buff *skb, + struct tcp_options_received *tcp_opts, + __u32 cookie, int mss); +void inet_twsk_free(struct inet_timewait_sock *tw); +#if IS_ENABLED(CONFIG_IPV6) +void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb); +void tcp_v6_mtu_reduced(struct sock *sk); +void tcp_v6_reqsk_destructor(struct request_sock *req); +void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb); +void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, + struct request_sock *req); +struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb); +int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb); +struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, + struct request_sock *req, + struct dst_entry *dst, + struct request_sock *req_unhash, + bool *own_req); +int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); +#endif + +static inline void tcp_data_snd_check(struct sock *sk) +{ + tcp_push_pending_frames(sk); + tcp_check_space(sk); +} + +/* These states need RST on ABORT according to RFC793 */ + +static inline bool tcp_need_reset(int state) +{ + return (1 << state) & + (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 | + TCPF_FIN_WAIT2 | TCPF_SYN_RECV); +} + +/* END MPTCP */ + #if IS_ENABLED(CONFIG_SMC) extern struct static_key_false tcp_have_smc; #endif diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index e8c7fad..5d8ea09 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -243,8 +243,7 @@ EXPORT_SYMBOL(inet_listen); * Create an inet socket. */ -static int inet_create(struct net *net, struct socket *sock, int protocol, - int kern) +int inet_create(struct net *net, struct socket *sock, int protocol, int kern) { struct sock *sk; struct inet_protosw *answer; diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index ea89a41..20a69eb 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -429,6 +429,7 @@ static const struct tcp_operational_ops __tcp_default_op_ops = { .sndbuf_expand = tcp_sndbuf_expand, .shift_skb_data = tcp_shift_skb_data, .grow_window = tcp_grow_window, + .check_rtt = tcp_check_rtt, .try_coalesce = tcp_try_coalesce, .try_rmem_schedule = tcp_try_rmem_schedule, .collapse_one = tcp_collapse_one, @@ -963,8 +964,7 @@ struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp, return NULL; } -static unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now, - int large_allowed) +unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now, int large_allowed) { struct tcp_sock *tp = tcp_sk(sk); u32 new_size_goal, size_goal; @@ -998,8 +998,8 @@ int tcp_send_mss(struct sock *sk, int *size_goal, int flags) return mss_now; } -ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, - size_t size, int flags) +ssize_t tcp_sendpages_xmit(struct sock *sk, struct page *page, int offset, + size_t size, int flags) { struct tcp_sock *tp = tcp_sk(sk); int mss_now, size_goal; @@ -1007,25 +1007,12 @@ ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, ssize_t copied; long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT); - /* Wait for a connection to finish. One exception is TCP Fast Open - * (passive side) where data is allowed to be sent before a connection - * is fully established. - */ - if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && - !tcp_passive_fastopen(sk)) { - err = sk_stream_wait_connect(sk, &timeo); - if (err != 0) - goto out_err; - } - sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk); mss_now = tp->op_ops->send_mss(sk, &size_goal, flags); copied = 0; err = -EPIPE; - if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) - goto out_err; while (size > 0) { struct sk_buff *skb = tcp_write_queue_tail(sk); @@ -1120,6 +1107,33 @@ ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, do_error: if (copied) goto out; + return err; +} +EXPORT_SYMBOL_GPL(tcp_sendpages_xmit); + +ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, + size_t size, int flags) +{ + int err; + long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT); + + /* Wait for a connection to finish. One exception is TCP Fast Open + * (passive side) where data is allowed to be sent before a connection + * is fully established. + */ + if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) && + !tcp_passive_fastopen(sk)) { + err = sk_stream_wait_connect(sk, &timeo); + if (err != 0) + goto out_err; + } + + if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN)) + goto out_err; + + err = tcp_sendpages_xmit(sk, page, offset, size, flags); + if (err >= 0) + return(err); out_err: /* make sure we wake any epoll edge trigger waiter */ if (unlikely(skb_queue_len(&sk->sk_write_queue) == 0 && @@ -2193,7 +2207,7 @@ static const unsigned char new_state[16] = { [TCP_NEW_SYN_RECV] = TCP_CLOSE, /* should not happen ! */ }; -static int tcp_close_state(struct sock *sk) +int tcp_close_state(struct sock *sk) { int next = (int)new_state[sk->sk_state]; int ns = next & TCP_STATE_MASK; @@ -2419,15 +2433,6 @@ void tcp_close(struct sock *sk, long timeout) } EXPORT_SYMBOL(tcp_close); -/* These states need RST on ABORT according to RFC793 */ - -static inline bool tcp_need_reset(int state) -{ - return (1 << state) & - (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 | - TCPF_FIN_WAIT2 | TCPF_SYN_RECV); -} - static void tcp_rtx_queue_purge(struct sock *sk) { struct rb_node *p = rb_first(&sk->tcp_rtx_queue); diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c index 8cc48bb..398505e 100644 --- a/net/ipv4/tcp_input.c +++ b/net/ipv4/tcp_input.c @@ -195,7 +195,7 @@ static void tcp_incr_quickack(struct sock *sk) icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS); } -static void tcp_enter_quickack_mode(struct sock *sk) +void tcp_enter_quickack_mode(struct sock *sk) { struct inet_connection_sock *icsk = inet_csk(sk); tcp_incr_quickack(sk); @@ -293,12 +293,11 @@ static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr * 1. Tuning sk->sk_sndbuf, when connection enters established state. */ -void tcp_sndbuf_expand(struct sock *sk) +void tcp_sndbuf_expand_impl(struct sock *sk, u32 nr_segs) { const struct tcp_sock *tp = tcp_sk(sk); const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops; int sndmem, per_mss; - u32 nr_segs; /* Worst case is non GSO/TSO : each frame consumes one skb * and skb->head is kmalloced using power of two area of memory @@ -310,8 +309,10 @@ void tcp_sndbuf_expand(struct sock *sk) per_mss = roundup_pow_of_two(per_mss) + SKB_DATA_ALIGN(sizeof(struct sk_buff)); - nr_segs = max_t(u32, TCP_INIT_CWND, tp->snd_cwnd); - nr_segs = max_t(u32, nr_segs, tp->reordering + 1); + if (nr_segs <= 0) { + nr_segs = max_t(u32, TCP_INIT_CWND, tp->snd_cwnd); + nr_segs = max_t(u32, nr_segs, tp->reordering + 1); + } /* Fast Recovery (RFC 5681 3.2) : * Cubic needs 1.7 factor, rounded to 2 to include @@ -324,6 +325,11 @@ void tcp_sndbuf_expand(struct sock *sk) sk->sk_sndbuf = min(sndmem, sock_net(sk)->ipv4.sysctl_tcp_wmem[2]); } +void tcp_sndbuf_expand(struct sock *sk) +{ + tcp_sndbuf_expand_impl(sk, 0); +} + /* 2. Tuning advertised window (window_clamp, rcv_ssthresh) * * All tcp_full_space() is split to two parts: "network" buffer, allocated @@ -572,6 +578,17 @@ static inline void tcp_rcv_rtt_measure_ts(struct sock *sk, } } +bool tcp_check_rtt(struct sock *sk) +{ + struct tcp_sock *tp = tcp_sk(sk); + int time; + + time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time); + + if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0) + return (true); + return false; +} /* * This function should be called every time data is copied to user space. * It calculates the appropriate TCP receive buffer space. @@ -580,11 +597,9 @@ void tcp_rcv_space_adjust(struct sock *sk) { struct tcp_sock *tp = tcp_sk(sk); u32 copied; - int time; tcp_mstamp_refresh(tp); - time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time); - if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0) + if (tp->op_ops->check_rtt(sk)) return; /* Number of bytes copied to user in last RTT */ @@ -2966,7 +2981,7 @@ static void tcp_set_xmit_timer(struct sock *sk) } /* If we get here, the whole TSO packet has not been acked. */ -static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb) +u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb) { struct tcp_sock *tp = tcp_sk(sk); u32 packets_acked; @@ -3201,7 +3216,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, u32 prior_fack, return flag; } -static void tcp_ack_probe(struct sock *sk) +void tcp_ack_probe(struct sock *sk) { struct inet_connection_sock *icsk = inet_csk(sk); struct sk_buff *head = tcp_send_head(sk); @@ -3273,7 +3288,7 @@ static void tcp_cong_control(struct sock *sk, u32 ack, u32 acked_sacked, /* Check that window update is acceptable. * The function assumes that snd_una<=ack<=snd_next. */ -static inline bool tcp_may_update_window(const struct tcp_sock *tp, +inline bool tcp_may_update_window(const struct tcp_sock *tp, const u32 ack, const u32 ack_seq, const u32 nwin) { @@ -4290,12 +4305,6 @@ bool tcp_try_coalesce(struct sock *sk, return true; } -static void tcp_drop(struct sock *sk, struct sk_buff *skb) -{ - sk_drops_add(sk, skb); - __kfree_skb(skb); -} - /* This one checks to see if we can put data from the * out_of_order queue into the receive_queue. */ @@ -4505,8 +4514,8 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb) } } -static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen, - bool *fragstolen) +int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen, + bool *fragstolen) { int eaten; struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue); @@ -4580,7 +4589,11 @@ static void tcp_data_queue(struct sock *sk, struct sk_buff *skb) int eaten; if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) { - __kfree_skb(skb); + /* options that a layer above might be interested in */ + if (unlikely(tp->op_ops->ack_only)) + tp->op_ops->ack_only(sk, skb); + else + __kfree_skb(skb); return; } skb_dst_drop(skb); @@ -4995,7 +5008,7 @@ static void tcp_new_space(struct sock *sk) sk->sk_write_space(sk); } -static void tcp_check_space(struct sock *sk) +void tcp_check_space(struct sock *sk) { if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) { sock_reset_flag(sk, SOCK_QUEUE_SHRUNK); @@ -5010,12 +5023,6 @@ static void tcp_check_space(struct sock *sk) } } -static inline void tcp_data_snd_check(struct sock *sk) -{ - tcp_push_pending_frames(sk); - tcp_check_space(sk); -} - /* * Check if sending an ack is needed. */ @@ -5504,8 +5511,9 @@ void tcp_finish_connect(struct sock *sk, struct sk_buff *skb) tp->pred_flags = 0; } -bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, - struct tcp_fastopen_cookie *cookie) +bool tcp_rcv_fastopen_synack_impl(struct sock *sk, struct sk_buff *synack, + struct tcp_fastopen_cookie *cookie, + bool rexmit) { struct tcp_sock *tp = tcp_sk(sk); struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL; @@ -5542,7 +5550,7 @@ bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp); - if (data) { /* Retransmit unacked data in SYN */ + if (data && rexmit) { /* Retransmit unacked data in SYN */ skb_rbtree_walk_from(data) { if (__tcp_retransmit_skb(sk, data, 1)) break; @@ -5562,6 +5570,12 @@ bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, return false; } +bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, + struct tcp_fastopen_cookie *cookie) +{ + return tcp_rcv_fastopen_synack_impl(sk, synack, cookie, true); +} + static void smc_check_reset_syn(struct tcp_sock *tp) { #if IS_ENABLED(CONFIG_SMC) @@ -5581,6 +5595,9 @@ int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, int saved_clamp = tp->rx_opt.mss_clamp; bool fastopen_fail; + tp->rx_opt.saw_tstamp = 0; + tcp_mstamp_refresh(tp); + tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc); if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) tp->rx_opt.rcv_tsecr -= tp->tsoffset; @@ -5682,7 +5699,7 @@ int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, tcp_finish_connect(sk, skb); fastopen_fail = (tp->syn_fastopen || tp->syn_data) && - tcp_rcv_fastopen_synack(sk, skb, &foc); + tp->op_ops->fastopen_synack(sk, skb, &foc); if (!sock_flag(sk, SOCK_DEAD)) { sk->sk_state_change(sk); @@ -5842,9 +5859,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb) goto discard; case TCP_SYN_SENT: - tp->rx_opt.saw_tstamp = 0; - tcp_mstamp_refresh(tp); - queued = tcp_rcv_synsent_state_process(sk, skb, th); + queued = tp->state_ops->synsent(sk, skb, th); if (queued >= 0) return queued; @@ -6052,8 +6067,12 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb) } if (!queued) { + /* options that a layer above might be interested in */ + if (unlikely(tp->op_ops && tp->op_ops->ack_only)) + tp->op_ops->ack_only(sk, skb); + else discard: - tcp_drop(sk, skb); + tcp_drop(sk, skb); } return 0; } diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c index 482ca15..95d4c1f 100644 --- a/net/ipv4/tcp_ipv4.c +++ b/net/ipv4/tcp_ipv4.c @@ -595,7 +595,7 @@ EXPORT_SYMBOL(tcp_v4_send_check); * Exception: precedence violation. We do not implement it in any case. */ -static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb) +void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb) { const struct tcphdr *th = tcp_hdr(skb); struct { @@ -829,8 +829,8 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb) inet_twsk_put(tw); } -static void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, - struct request_sock *req) +void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, + struct request_sock *req) { /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV * sk->sk_state == TCP_SYN_RECV -> for Fast Open. @@ -892,7 +892,7 @@ static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst, /* * IPv4 request_sock destructor. */ -static void tcp_v4_reqsk_destructor(struct request_sock *req) +void tcp_v4_reqsk_destructor(struct request_sock *req) { kfree(rcu_dereference_protected(inet_rsk(req)->ireq_opt, 1)); } @@ -1431,7 +1431,7 @@ struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, } EXPORT_SYMBOL(tcp_v4_syn_recv_sock); -static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb) +struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb) { #ifdef CONFIG_SYN_COOKIES const struct tcphdr *th = tcp_hdr(skb); @@ -1598,8 +1598,8 @@ static void tcp_v4_restore_cb(struct sk_buff *skb) sizeof(struct inet_skb_parm)); } -static void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, - const struct tcphdr *th) +void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, + const struct tcphdr *th) { /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB() * barrier() makes sure compiler wont play fool^Waliasing games. @@ -1620,6 +1620,9 @@ static void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, skb->tstamp || skb_hwtstamps(skb)->hwtstamp; } +process_unclaimed tcp_process_unclaimed; +EXPORT_SYMBOL(tcp_process_unclaimed); + /* * From tcp_input.c */ @@ -1750,13 +1753,16 @@ int tcp_v4_rcv(struct sk_buff *skb) sk_incoming_cpu_update(sk); - bh_lock_sock_nested(sk); - tcp_segs_in(tcp_sk(sk), skb); - ret = 0; - if (!sock_owned_by_user(sk)) { - ret = tcp_v4_do_rcv(sk, skb); - } else if (tcp_add_backlog(sk, skb)) { - goto discard_and_relse; + if (likely(!tcp_sk(sk)->op_ops->rx)) { + bh_lock_sock_nested(sk); + tcp_segs_in(tcp_sk(sk), skb); + ret = 0; + if (!sock_owned_by_user(sk)) + ret = tcp_v4_do_rcv(sk, skb); + else if (tcp_add_backlog(sk, skb)) + goto discard_and_relse; + } else { + return(tcp_sk(sk)->op_ops->rx(sk, skb, refcounted)); } bh_unlock_sock(sk); @@ -1778,6 +1784,10 @@ int tcp_v4_rcv(struct sk_buff *skb) bad_packet: __TCP_INC_STATS(net, TCP_MIB_INERRS); } else { + if (unlikely(tcp_process_unclaimed)) { + if (tcp_process_unclaimed(sk, skb)) + return (0); + } tcp_v4_send_reset(NULL, skb); } @@ -1820,6 +1830,10 @@ int tcp_v4_rcv(struct sk_buff *skb) refcounted = false; goto process; } + if (unlikely(tcp_process_unclaimed)) { + if (tcp_process_unclaimed(sk, skb)) + return 0; + } } /* to ACK */ /* fall through */ diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c index 2fa5c05..72b494a 100644 --- a/net/ipv4/tcp_output.c +++ b/net/ipv4/tcp_output.c @@ -46,7 +46,7 @@ #include <trace/events/tcp.h> /* Account for new data that has been sent to the network. */ -static void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb) +void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb) { struct inet_connection_sock *icsk = inet_csk(sk); struct tcp_sock *tp = tcp_sk(sk); @@ -375,7 +375,7 @@ static void tcp_ecn_send(struct sock *sk, struct sk_buff *skb, /* Constructs common control bits of non-data skb. If SYN/FIN is present, * auto increment end seqno. */ -static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) +void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) { skb->ip_summed = CHECKSUM_PARTIAL; @@ -390,7 +390,7 @@ static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) TCP_SKB_CB(skb)->end_seq = seq; } -static inline bool tcp_urg_mode(const struct tcp_sock *tp) +inline bool tcp_urg_mode(const struct tcp_sock *tp) { return tp->snd_una != tp->snd_up; } @@ -1031,8 +1031,8 @@ static void tcp_update_skb_after_send(struct tcp_sock *tp, struct sk_buff *skb) * We are working here with either a clone of the original * SKB, or a fresh unique copy made by the retransmit engine. */ -static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, - gfp_t gfp_mask) +int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, + gfp_t gfp_mask) { const struct inet_connection_sock *icsk = inet_csk(sk); struct inet_sock *inet; @@ -1193,7 +1193,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, * NOTE: probe0 timer is not checked, do not forget tcp_push_pending_frames, * otherwise socket can stall. */ -static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb) +void tcp_queue_skb(struct sock *sk, struct sk_buff *skb) { struct tcp_sock *tp = tcp_sk(sk); @@ -1206,7 +1206,7 @@ static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb) } /* Initialize TSO segments for a packet. */ -static void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now) +void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now) { if (skb->len <= mss_now || skb->ip_summed == CHECKSUM_NONE) { /* Avoid the costly divide in the normal @@ -1223,7 +1223,7 @@ static void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now) /* Pcount in the middle of the write queue got changed, we need to do various * tweaks to fix counters */ -static void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr) +void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr) { struct tcp_sock *tp = tcp_sk(sk); @@ -1426,6 +1426,11 @@ static int __pskb_trim_head(struct sk_buff *skb, int len) return len; } +int pskb_trim_head(struct sk_buff *skb, int len) +{ + return __pskb_trim_head(skb, len); +} + /* Remove acked data from a packet in the transmit queue. */ int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len) { @@ -1434,7 +1439,7 @@ int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len) if (skb_unclone(skb, GFP_ATOMIC)) return -ENOMEM; - delta_truesize = __pskb_trim_head(skb, len); + delta_truesize = pskb_trim_head(skb, len); TCP_SKB_CB(skb)->seq += len; skb->ip_summed = CHECKSUM_PARTIAL; @@ -1693,8 +1698,8 @@ static bool tcp_minshall_check(const struct tcp_sock *tp) * But we can avoid doing the divide again given we already have * skb_pcount = skb->len / mss_now */ -static void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now, - const struct sk_buff *skb) +void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now, + const struct sk_buff *skb) { if (skb->len < tcp_skb_pcount(skb) * mss_now) tp->snd_sml = TCP_SKB_CB(skb)->end_seq; @@ -1751,11 +1756,11 @@ static u32 tcp_tso_segs(struct sock *sk, unsigned int mss_now) } /* Returns the portion of skb which can be sent right away */ -static unsigned int tcp_mss_split_point(const struct sock *sk, - const struct sk_buff *skb, - unsigned int mss_now, - unsigned int max_segs, - int nonagle) +unsigned int tcp_mss_split_point(const struct sock *sk, + const struct sk_buff *skb, + unsigned int mss_now, + unsigned int max_segs, + int nonagle) { const struct tcp_sock *tp = tcp_sk(sk); u32 partial, needed, window, max_len; @@ -1785,7 +1790,7 @@ static unsigned int tcp_mss_split_point(const struct sock *sk, /* Can at least one segment of SKB be sent right now, according to the * congestion window rules? If so, return how many segments are allowed. */ -static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp, +inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp, const struct sk_buff *skb) { u32 in_flight, cwnd, halfcwnd; @@ -1811,7 +1816,7 @@ static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp, * This must be invoked the first time we consider transmitting * SKB onto the wire. */ -static int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now) +int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now) { int tso_segs = tcp_skb_pcount(skb); @@ -1826,8 +1831,8 @@ static int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now) /* Return true if the Nagle test allows this packet to be * sent now. */ -static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb, - unsigned int cur_mss, int nonagle) +inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb, + unsigned int cur_mss, int nonagle) { /* Nagle rule does not apply to frames, which sit in the middle of the * write_queue (they have no chances to get new data). @@ -1849,9 +1854,9 @@ static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buf } /* Does at least the first segment of SKB fit into the send window? */ -static bool tcp_snd_wnd_test(const struct tcp_sock *tp, - const struct sk_buff *skb, - unsigned int cur_mss) +bool tcp_snd_wnd_test(const struct tcp_sock *tp, + const struct sk_buff *skb, + unsigned int cur_mss) { u32 end_seq = TCP_SKB_CB(skb)->end_seq; @@ -2148,7 +2153,7 @@ int tcp_mtu_probe(struct sock *sk) skb->csum = csum_partial(skb->data, skb->len, 0); } else { - __pskb_trim_head(skb, copy); + pskb_trim_head(skb, copy); tcp_set_skb_tso_segs(skb, mss_now); } TCP_SKB_CB(skb)->seq += copy; @@ -3639,7 +3644,7 @@ EXPORT_SYMBOL_GPL(tcp_send_ack); * one is with SEG.SEQ=SND.UNA to deliver urgent pointer, another is * out-of-date with SND.UNA-1 to probe window. */ -static int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib) +int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib) { struct tcp_sock *tp = tcp_sk(sk); struct sk_buff *skb; diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c index beaba7a..dbf284d 100644 --- a/net/ipv4/tcp_timer.c +++ b/net/ipv4/tcp_timer.c @@ -29,7 +29,7 @@ * Returns: Nothing (void) */ -static void tcp_write_err(struct sock *sk) +void tcp_write_err(struct sock *sk) { sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT; sk->sk_error_report(sk); @@ -155,9 +155,8 @@ static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk) * after "boundary" unsuccessful, exponentially backed-off * retransmissions with an initial RTO of TCP_RTO_MIN. */ -static bool retransmits_timed_out(struct sock *sk, - unsigned int boundary, - unsigned int timeout) +bool retransmits_timed_out(struct sock *sk, unsigned int boundary, + unsigned int timeout) { const unsigned int rto_base = TCP_RTO_MIN; unsigned int linear_backoff_thresh, start_ts; @@ -187,7 +186,7 @@ static bool retransmits_timed_out(struct sock *sk, } /* A write timeout has occurred. Process the after effects. */ -static int tcp_write_timeout(struct sock *sk) +int tcp_write_timeout(struct sock *sk) { struct inet_connection_sock *icsk = inet_csk(sk); struct tcp_sock *tp = tcp_sk(sk); diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c index c1e292d..9a242a5 100644 --- a/net/ipv6/af_inet6.c +++ b/net/ipv6/af_inet6.c @@ -107,8 +107,8 @@ static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk) return (struct ipv6_pinfo *)(((u8 *)sk) + offset); } -static int inet6_create(struct net *net, struct socket *sock, int protocol, - int kern) +int inet6_create(struct net *net, struct socket *sock, int protocol, + int kern) { struct inet_sock *inet; struct ipv6_pinfo *np; diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c index 293bdc8..c226cf6 100644 --- a/net/ipv6/tcp_ipv6.c +++ b/net/ipv6/tcp_ipv6.c @@ -71,12 +71,6 @@ #include <trace/events/tcp.h> -static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb); -static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, - struct request_sock *req); - -static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); - #ifdef CONFIG_TCP_MD5SIG static const struct tcp_sock_af_ops tcp_sock_ipv6_specific; static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; @@ -88,7 +82,7 @@ static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk, } #endif -static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb) +void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb) { struct dst_entry *dst = skb_dst(skb); @@ -315,7 +309,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, return err; } -static void tcp_v6_mtu_reduced(struct sock *sk) +void tcp_v6_mtu_reduced(struct sock *sk) { struct dst_entry *dst; @@ -495,7 +489,7 @@ static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst, } -static void tcp_v6_reqsk_destructor(struct request_sock *req) +void tcp_v6_reqsk_destructor(struct request_sock *req) { kfree(inet_rsk(req)->ipv6_opt); kfree_skb(inet_rsk(req)->pktopts); @@ -877,7 +871,7 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 kfree_skb(buff); } -static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb) +void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb) { const struct tcphdr *th = tcp_hdr(skb); u32 seq = 0, ack_seq = 0; @@ -975,8 +969,8 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb) inet_twsk_put(tw); } -static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, - struct request_sock *req) +void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, + struct request_sock *req) { /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV * sk->sk_state == TCP_SYN_RECV -> for Fast Open. @@ -997,7 +991,7 @@ static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, } -static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) +struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) { #ifdef CONFIG_SYN_COOKIES const struct tcphdr *th = tcp_hdr(skb); @@ -1008,7 +1002,7 @@ static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) return sk; } -static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) +int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) { if (skb->protocol == htons(ETH_P_IP)) return tcp_v4_conn_request(sk, skb); @@ -1034,11 +1028,11 @@ static void tcp_v6_restore_cb(struct sk_buff *skb) sizeof(struct inet6_skb_parm)); } -static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, - struct request_sock *req, - struct dst_entry *dst, - struct request_sock *req_unhash, - bool *own_req) +struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, + struct request_sock *req, + struct dst_entry *dst, + struct request_sock *req_unhash, + bool *own_req) { struct inet_request_sock *ireq; struct ipv6_pinfo *newnp; @@ -1250,7 +1244,7 @@ static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff * * This is because we cannot sleep with the original spinlock * held. */ -static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) +int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) { struct ipv6_pinfo *np = inet6_sk(sk); struct tcp_sock *tp; @@ -1378,8 +1372,8 @@ static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) return 0; } -static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, - const struct tcphdr *th) +void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, + const struct tcphdr *th) { /* This is tricky: we move IP6CB at its correct location into * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because @@ -1522,13 +1516,16 @@ static int tcp_v6_rcv(struct sk_buff *skb) sk_incoming_cpu_update(sk); - bh_lock_sock_nested(sk); - tcp_segs_in(tcp_sk(sk), skb); - ret = 0; - if (!sock_owned_by_user(sk)) { - ret = tcp_v6_do_rcv(sk, skb); - } else if (tcp_add_backlog(sk, skb)) { - goto discard_and_relse; + if (likely(!tcp_sk(sk)->op_ops->rx)) { + bh_lock_sock_nested(sk); + tcp_segs_in(tcp_sk(sk), skb); + ret = 0; + if (!sock_owned_by_user(sk)) + ret = tcp_v6_do_rcv(sk, skb); + else if (tcp_add_backlog(sk, skb)) + goto discard_and_relse; + } else { + return(tcp_sk(sk)->op_ops->rx(sk, skb, refcounted)); } bh_unlock_sock(sk); @@ -1549,6 +1546,10 @@ static int tcp_v6_rcv(struct sk_buff *skb) bad_packet: __TCP_INC_STATS(net, TCP_MIB_INERRS); } else { + if (unlikely(tcp_process_unclaimed)) { + if (tcp_process_unclaimed(sk, skb)) + return(0); + } tcp_v6_send_reset(NULL, skb); } @@ -1594,6 +1595,10 @@ static int tcp_v6_rcv(struct sk_buff *skb) refcounted = false; goto process; } + if (unlikely(tcp_process_unclaimed)) { + if (tcp_process_unclaimed(sk, skb)) + return 0; + } } /* to ACK */ /* fall through */ -- 2.7.4

On 03/27/2018 03:15 AM, Christoph Paasch wrote: These changes are part of restructuring as the title says. MPTCP is very intrusive to TCP code. Where possible I have re-factored TCP functions into common code and separated out the code where MPTCP and TCP differ. The calling function calls the socket type specific function that uses the common function. These are very low level changes that are specific to MPTCP and was not the goal of this effort. However any such possibility will be explored later. Yes it is necessary because we are trying to clean up TCP code and clean it up from all the #ifdef MPTCP statements. It also provides us the opportunity to do more MPTCP specific stuff in the future. My understanding after talking to upstream folks is that they do not want MPTCP all over TCP code. I discussed the alternatives and was told to first present an implementation and we will talk. I have very recently communicated with Dave and Eric on the list where they have agreed to some refactoring. So please stop using we know what upstream wants, unless  a thread on the mailing list can be pointed to confirm. This is the case when where no socket matching socket is found. If MPTCP wants to process such packets, it initializes this function pointer to receive the packet. I did not want to make __pskb_trim_head a global. I can rename  the original function. Shoaib

On Thu, 2018-02-22 at 15:50 -0800, rao.shoaib(a)oracle.com wrote: If it is a possibility that ack_only() does not call __kfree_skb(skb) what is the consequence? I don't have enough context here. Peter. > return; > } > skb_dst_drop(skb); > @@ -4995,7 +5008,7 @@ static void tcp_new_space(struct sock *sk) > sk->sk_write_space(sk); > } > > -static void tcp_check_space(struct sock *sk) > +void tcp_check_space(struct sock *sk) > { > if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) { > sock_reset_flag(sk, SOCK_QUEUE_SHRUNK); > @@ -5010,12 +5023,6 @@ static void tcp_check_space(struct sock *sk) > } > } > > -static inline void tcp_data_snd_check(struct sock *sk) > -{ > - tcp_push_pending_frames(sk); > - tcp_check_space(sk); > -} > - > /* > * Check if sending an ack is needed. > */ > @@ -5504,8 +5511,9 @@ void tcp_finish_connect(struct sock *sk, struct sk_buff *skb) > tp->pred_flags = 0; > } > > -bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, > - struct tcp_fastopen_cookie *cookie) > +bool tcp_rcv_fastopen_synack_impl(struct sock *sk, struct sk_buff *synack, > + struct tcp_fastopen_cookie *cookie, > + bool rexmit) > { > struct tcp_sock *tp = tcp_sk(sk); > struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL; > @@ -5542,7 +5550,7 @@ bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, > > tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp); > > - if (data) { /* Retransmit unacked data in SYN */ > + if (data && rexmit) { /* Retransmit unacked data in SYN */ > skb_rbtree_walk_from(data) { > if (__tcp_retransmit_skb(sk, data, 1)) > break; > @@ -5562,6 +5570,12 @@ bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, > return false; > } > > +bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack, > + struct tcp_fastopen_cookie *cookie) > +{ > + return tcp_rcv_fastopen_synack_impl(sk, synack, cookie, true); > +} > + > static void smc_check_reset_syn(struct tcp_sock *tp) > { > #if IS_ENABLED(CONFIG_SMC) > @@ -5581,6 +5595,9 @@ int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, > int saved_clamp = tp->rx_opt.mss_clamp; > bool fastopen_fail; > > + tp->rx_opt.saw_tstamp = 0; > + tcp_mstamp_refresh(tp); > + > tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc); > if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) > tp->rx_opt.rcv_tsecr -= tp->tsoffset; > @@ -5682,7 +5699,7 @@ int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, > tcp_finish_connect(sk, skb); > > fastopen_fail = (tp->syn_fastopen || tp->syn_data) && > - tcp_rcv_fastopen_synack(sk, skb, &foc); > + tp->op_ops->fastopen_synack(sk, skb, &foc); > > if (!sock_flag(sk, SOCK_DEAD)) { > sk->sk_state_change(sk); > @@ -5842,9 +5859,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb) > goto discard; > > case TCP_SYN_SENT: > - tp->rx_opt.saw_tstamp = 0; > - tcp_mstamp_refresh(tp); > - queued = tcp_rcv_synsent_state_process(sk, skb, th); > + queued = tp->state_ops->synsent(sk, skb, th); > if (queued >= 0) > return queued; > > @@ -6052,8 +6067,12 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb) > } > > if (!queued) { > + /* options that a layer above might be interested in */ > + if (unlikely(tp->op_ops && tp->op_ops->ack_only)) > + tp->op_ops->ack_only(sk, skb); > + else > discard: > - tcp_drop(sk, skb); > + tcp_drop(sk, skb); > } > return 0; > } > diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c > index 482ca15..95d4c1f 100644 > --- a/net/ipv4/tcp_ipv4.c > +++ b/net/ipv4/tcp_ipv4.c > @@ -595,7 +595,7 @@ EXPORT_SYMBOL(tcp_v4_send_check); > * Exception: precedence violation. We do not implement it in any case. > */ > > -static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb) > +void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb) > { > const struct tcphdr *th = tcp_hdr(skb); > struct { > @@ -829,8 +829,8 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb) > inet_twsk_put(tw); > } > > -static void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > - struct request_sock *req) > +void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > + struct request_sock *req) > { > /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV > * sk->sk_state == TCP_SYN_RECV -> for Fast Open. > @@ -892,7 +892,7 @@ static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst, > /* > * IPv4 request_sock destructor. > */ > -static void tcp_v4_reqsk_destructor(struct request_sock *req) > +void tcp_v4_reqsk_destructor(struct request_sock *req) > { > kfree(rcu_dereference_protected(inet_rsk(req)->ireq_opt, 1)); > } > @@ -1431,7 +1431,7 @@ struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, > } > EXPORT_SYMBOL(tcp_v4_syn_recv_sock); > > -static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb) > +struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb) > { > #ifdef CONFIG_SYN_COOKIES > const struct tcphdr *th = tcp_hdr(skb); > @@ -1598,8 +1598,8 @@ static void tcp_v4_restore_cb(struct sk_buff *skb) > sizeof(struct inet_skb_parm)); > } > > -static void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, > - const struct tcphdr *th) > +void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, > + const struct tcphdr *th) > { > /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB() > * barrier() makes sure compiler wont play fool^Waliasing games. > @@ -1620,6 +1620,9 @@ static void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, > skb->tstamp || skb_hwtstamps(skb)->hwtstamp; > } > > +process_unclaimed tcp_process_unclaimed; > +EXPORT_SYMBOL(tcp_process_unclaimed); > + > /* > * From tcp_input.c > */ > @@ -1750,13 +1753,16 @@ int tcp_v4_rcv(struct sk_buff *skb) > > sk_incoming_cpu_update(sk); > > - bh_lock_sock_nested(sk); > - tcp_segs_in(tcp_sk(sk), skb); > - ret = 0; > - if (!sock_owned_by_user(sk)) { > - ret = tcp_v4_do_rcv(sk, skb); > - } else if (tcp_add_backlog(sk, skb)) { > - goto discard_and_relse; > + if (likely(!tcp_sk(sk)->op_ops->rx)) { > + bh_lock_sock_nested(sk); > + tcp_segs_in(tcp_sk(sk), skb); > + ret = 0; > + if (!sock_owned_by_user(sk)) > + ret = tcp_v4_do_rcv(sk, skb); > + else if (tcp_add_backlog(sk, skb)) > + goto discard_and_relse; > + } else { > + return(tcp_sk(sk)->op_ops->rx(sk, skb, refcounted)); > } > bh_unlock_sock(sk); > > @@ -1778,6 +1784,10 @@ int tcp_v4_rcv(struct sk_buff *skb) > bad_packet: > __TCP_INC_STATS(net, TCP_MIB_INERRS); > } else { > + if (unlikely(tcp_process_unclaimed)) { > + if (tcp_process_unclaimed(sk, skb)) > + return (0); > + } > tcp_v4_send_reset(NULL, skb); > } > > @@ -1820,6 +1830,10 @@ int tcp_v4_rcv(struct sk_buff *skb) > refcounted = false; > goto process; > } > + if (unlikely(tcp_process_unclaimed)) { > + if (tcp_process_unclaimed(sk, skb)) > + return 0; > + } > } > /* to ACK */ > /* fall through */ > diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c > index 2fa5c05..72b494a 100644 > --- a/net/ipv4/tcp_output.c > +++ b/net/ipv4/tcp_output.c > @@ -46,7 +46,7 @@ > #include <trace/events/tcp.h> > > /* Account for new data that has been sent to the network. */ > -static void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb) > +void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb) > { > struct inet_connection_sock *icsk = inet_csk(sk); > struct tcp_sock *tp = tcp_sk(sk); > @@ -375,7 +375,7 @@ static void tcp_ecn_send(struct sock *sk, struct sk_buff *skb, > /* Constructs common control bits of non-data skb. If SYN/FIN is present, > * auto increment end seqno. > */ > -static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) > +void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) > { > skb->ip_summed = CHECKSUM_PARTIAL; > > @@ -390,7 +390,7 @@ static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) > TCP_SKB_CB(skb)->end_seq = seq; > } > > -static inline bool tcp_urg_mode(const struct tcp_sock *tp) > +inline bool tcp_urg_mode(const struct tcp_sock *tp) > { > return tp->snd_una != tp->snd_up; > } > @@ -1031,8 +1031,8 @@ static void tcp_update_skb_after_send(struct tcp_sock *tp, struct sk_buff *skb) > * We are working here with either a clone of the original > * SKB, or a fresh unique copy made by the retransmit engine. > */ > -static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, > - gfp_t gfp_mask) > +int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, > + gfp_t gfp_mask) > { > const struct inet_connection_sock *icsk = inet_csk(sk); > struct inet_sock *inet; > @@ -1193,7 +1193,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, > * NOTE: probe0 timer is not checked, do not forget tcp_push_pending_frames, > * otherwise socket can stall. > */ > -static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb) > +void tcp_queue_skb(struct sock *sk, struct sk_buff *skb) > { > struct tcp_sock *tp = tcp_sk(sk); > > @@ -1206,7 +1206,7 @@ static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb) > } > > /* Initialize TSO segments for a packet. */ > -static void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now) > +void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now) > { > if (skb->len <= mss_now || skb->ip_summed == CHECKSUM_NONE) { > /* Avoid the costly divide in the normal > @@ -1223,7 +1223,7 @@ static void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now) > /* Pcount in the middle of the write queue got changed, we need to do various > * tweaks to fix counters > */ > -static void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr) > +void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr) > { > struct tcp_sock *tp = tcp_sk(sk); > > @@ -1426,6 +1426,11 @@ static int __pskb_trim_head(struct sk_buff *skb, int len) > return len; > } > > +int pskb_trim_head(struct sk_buff *skb, int len) > +{ > + return __pskb_trim_head(skb, len); > +} > + > /* Remove acked data from a packet in the transmit queue. */ > int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len) > { > @@ -1434,7 +1439,7 @@ int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len) > if (skb_unclone(skb, GFP_ATOMIC)) > return -ENOMEM; > > - delta_truesize = __pskb_trim_head(skb, len); > + delta_truesize = pskb_trim_head(skb, len); > > TCP_SKB_CB(skb)->seq += len; > skb->ip_summed = CHECKSUM_PARTIAL; > @@ -1693,8 +1698,8 @@ static bool tcp_minshall_check(const struct tcp_sock *tp) > * But we can avoid doing the divide again given we already have > * skb_pcount = skb->len / mss_now > */ > -static void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now, > - const struct sk_buff *skb) > +void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now, > + const struct sk_buff *skb) > { > if (skb->len < tcp_skb_pcount(skb) * mss_now) > tp->snd_sml = TCP_SKB_CB(skb)->end_seq; > @@ -1751,11 +1756,11 @@ static u32 tcp_tso_segs(struct sock *sk, unsigned int mss_now) > } > > /* Returns the portion of skb which can be sent right away */ > -static unsigned int tcp_mss_split_point(const struct sock *sk, > - const struct sk_buff *skb, > - unsigned int mss_now, > - unsigned int max_segs, > - int nonagle) > +unsigned int tcp_mss_split_point(const struct sock *sk, > + const struct sk_buff *skb, > + unsigned int mss_now, > + unsigned int max_segs, > + int nonagle) > { > const struct tcp_sock *tp = tcp_sk(sk); > u32 partial, needed, window, max_len; > @@ -1785,7 +1790,7 @@ static unsigned int tcp_mss_split_point(const struct sock *sk, > /* Can at least one segment of SKB be sent right now, according to the > * congestion window rules? If so, return how many segments are allowed. > */ > -static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp, > +inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp, > const struct sk_buff *skb) > { > u32 in_flight, cwnd, halfcwnd; > @@ -1811,7 +1816,7 @@ static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp, > * This must be invoked the first time we consider transmitting > * SKB onto the wire. > */ > -static int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now) > +int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now) > { > int tso_segs = tcp_skb_pcount(skb); > > @@ -1826,8 +1831,8 @@ static int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now) > /* Return true if the Nagle test allows this packet to be > * sent now. > */ > -static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb, > - unsigned int cur_mss, int nonagle) > +inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb, > + unsigned int cur_mss, int nonagle) > { > /* Nagle rule does not apply to frames, which sit in the middle of the > * write_queue (they have no chances to get new data). > @@ -1849,9 +1854,9 @@ static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buf > } > > /* Does at least the first segment of SKB fit into the send window? */ > -static bool tcp_snd_wnd_test(const struct tcp_sock *tp, > - const struct sk_buff *skb, > - unsigned int cur_mss) > +bool tcp_snd_wnd_test(const struct tcp_sock *tp, > + const struct sk_buff *skb, > + unsigned int cur_mss) > { > u32 end_seq = TCP_SKB_CB(skb)->end_seq; > > @@ -2148,7 +2153,7 @@ int tcp_mtu_probe(struct sock *sk) > skb->csum = csum_partial(skb->data, > skb->len, 0); > } else { > - __pskb_trim_head(skb, copy); > + pskb_trim_head(skb, copy); > tcp_set_skb_tso_segs(skb, mss_now); > } > TCP_SKB_CB(skb)->seq += copy; > @@ -3639,7 +3644,7 @@ EXPORT_SYMBOL_GPL(tcp_send_ack); > * one is with SEG.SEQ=SND.UNA to deliver urgent pointer, another is > * out-of-date with SND.UNA-1 to probe window. > */ > -static int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib) > +int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib) > { > struct tcp_sock *tp = tcp_sk(sk); > struct sk_buff *skb; > diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c > index beaba7a..dbf284d 100644 > --- a/net/ipv4/tcp_timer.c > +++ b/net/ipv4/tcp_timer.c > @@ -29,7 +29,7 @@ > * Returns: Nothing (void) > */ > > -static void tcp_write_err(struct sock *sk) > +void tcp_write_err(struct sock *sk) > { > sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT; > sk->sk_error_report(sk); > @@ -155,9 +155,8 @@ static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk) > * after "boundary" unsuccessful, exponentially backed-off > * retransmissions with an initial RTO of TCP_RTO_MIN. > */ > -static bool retransmits_timed_out(struct sock *sk, > - unsigned int boundary, > - unsigned int timeout) > +bool retransmits_timed_out(struct sock *sk, unsigned int boundary, > + unsigned int timeout) > { > const unsigned int rto_base = TCP_RTO_MIN; > unsigned int linear_backoff_thresh, start_ts; > @@ -187,7 +186,7 @@ static bool retransmits_timed_out(struct sock *sk, > } > > /* A write timeout has occurred. Process the after effects. */ > -static int tcp_write_timeout(struct sock *sk) > +int tcp_write_timeout(struct sock *sk) > { > struct inet_connection_sock *icsk = inet_csk(sk); > struct tcp_sock *tp = tcp_sk(sk); > diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c > index c1e292d..9a242a5 100644 > --- a/net/ipv6/af_inet6.c > +++ b/net/ipv6/af_inet6.c > @@ -107,8 +107,8 @@ static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk) > return (struct ipv6_pinfo *)(((u8 *)sk) + offset); > } > > -static int inet6_create(struct net *net, struct socket *sock, int protocol, > - int kern) > +int inet6_create(struct net *net, struct socket *sock, int protocol, > + int kern) > { > struct inet_sock *inet; > struct ipv6_pinfo *np; > diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c > index 293bdc8..c226cf6 100644 > --- a/net/ipv6/tcp_ipv6.c > +++ b/net/ipv6/tcp_ipv6.c > @@ -71,12 +71,6 @@ > > #include <trace/events/tcp.h> > > -static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb); > -static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > - struct request_sock *req); > - > -static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); > - > #ifdef CONFIG_TCP_MD5SIG > static const struct tcp_sock_af_ops tcp_sock_ipv6_specific; > static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; > @@ -88,7 +82,7 @@ static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk, > } > #endif > > -static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb) > +void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb) > { > struct dst_entry *dst = skb_dst(skb); > > @@ -315,7 +309,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, > return err; > } > > -static void tcp_v6_mtu_reduced(struct sock *sk) > +void tcp_v6_mtu_reduced(struct sock *sk) > { > struct dst_entry *dst; > > @@ -495,7 +489,7 @@ static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst, > } > > > -static void tcp_v6_reqsk_destructor(struct request_sock *req) > +void tcp_v6_reqsk_destructor(struct request_sock *req) > { > kfree(inet_rsk(req)->ipv6_opt); > kfree_skb(inet_rsk(req)->pktopts); > @@ -877,7 +871,7 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 > kfree_skb(buff); > } > > -static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb) > +void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb) > { > const struct tcphdr *th = tcp_hdr(skb); > u32 seq = 0, ack_seq = 0; > @@ -975,8 +969,8 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb) > inet_twsk_put(tw); > } > > -static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > - struct request_sock *req) > +void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > + struct request_sock *req) > { > /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV > * sk->sk_state == TCP_SYN_RECV -> for Fast Open. > @@ -997,7 +991,7 @@ static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, > } > > > -static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) > +struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) > { > #ifdef CONFIG_SYN_COOKIES > const struct tcphdr *th = tcp_hdr(skb); > @@ -1008,7 +1002,7 @@ static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb) > return sk; > } > > -static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) > +int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) > { > if (skb->protocol == htons(ETH_P_IP)) > return tcp_v4_conn_request(sk, skb); > @@ -1034,11 +1028,11 @@ static void tcp_v6_restore_cb(struct sk_buff *skb) > sizeof(struct inet6_skb_parm)); > } > > -static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, > - struct request_sock *req, > - struct dst_entry *dst, > - struct request_sock *req_unhash, > - bool *own_req) > +struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, > + struct request_sock *req, > + struct dst_entry *dst, > + struct request_sock *req_unhash, > + bool *own_req) > { > struct inet_request_sock *ireq; > struct ipv6_pinfo *newnp; > @@ -1250,7 +1244,7 @@ static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff * > * This is because we cannot sleep with the original spinlock > * held. > */ > -static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) > +int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) > { > struct ipv6_pinfo *np = inet6_sk(sk); > struct tcp_sock *tp; > @@ -1378,8 +1372,8 @@ static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) > return 0; > } > > -static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, > - const struct tcphdr *th) > +void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, > + const struct tcphdr *th) > { > /* This is tricky: we move IP6CB at its correct location into > * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because > @@ -1522,13 +1516,16 @@ static int tcp_v6_rcv(struct sk_buff *skb) > > sk_incoming_cpu_update(sk); > > - bh_lock_sock_nested(sk); > - tcp_segs_in(tcp_sk(sk), skb); > - ret = 0; > - if (!sock_owned_by_user(sk)) { > - ret = tcp_v6_do_rcv(sk, skb); > - } else if (tcp_add_backlog(sk, skb)) { > - goto discard_and_relse; > + if (likely(!tcp_sk(sk)->op_ops->rx)) { > + bh_lock_sock_nested(sk); > + tcp_segs_in(tcp_sk(sk), skb); > + ret = 0; > + if (!sock_owned_by_user(sk)) > + ret = tcp_v6_do_rcv(sk, skb); > + else if (tcp_add_backlog(sk, skb)) > + goto discard_and_relse; > + } else { > + return(tcp_sk(sk)->op_ops->rx(sk, skb, refcounted)); > } > bh_unlock_sock(sk); > > @@ -1549,6 +1546,10 @@ static int tcp_v6_rcv(struct sk_buff *skb) > bad_packet: > __TCP_INC_STATS(net, TCP_MIB_INERRS); > } else { > + if (unlikely(tcp_process_unclaimed)) { > + if (tcp_process_unclaimed(sk, skb)) > + return(0); > + } > tcp_v6_send_reset(NULL, skb); > } > > @@ -1594,6 +1595,10 @@ static int tcp_v6_rcv(struct sk_buff *skb) > refcounted = false; > goto process; > } > + if (unlikely(tcp_process_unclaimed)) { > + if (tcp_process_unclaimed(sk, skb)) > + return 0; > + } > } > /* to ACK */ > /* fall through */

From: Rao Shoaib <rao.shoaib(a)oracle.com&gt; Signed-off-by: Rao Shoaib <rao.shoaib(a)oracle.com&gt; --- include/net/net_namespace.h | 6 +++ include/net/tcp.h | 20 +++++++-- net/core/secure_seq.c | 70 +++++++++++++++++++++++++++++++ net/ipv4/af_inet.c | 13 ++++++ net/ipv4/inet_connection_sock.c | 17 +++++++- net/ipv4/ip_sockglue.c | 20 +++++++++ net/ipv4/syncookies.c | 3 ++ net/ipv4/tcp.c | 58 ++++++++++++++++++++++++++ net/ipv4/tcp_input.c | 25 +++++++++++ net/ipv4/tcp_ipv4.c | 66 ++++++++++++++++++++++++----- net/ipv4/tcp_minisocks.c | 56 ++++++++++++++++++++++++- net/ipv4/tcp_output.c | 31 +++++++++++--- net/ipv4/tcp_timer.c | 44 ++++++++++++++++---- net/ipv6/ipv6_sockglue.c | 14 +++++++ net/ipv6/tcp_ipv6.c | 92 ++++++++++++++++++++++++++++++++++------- 15 files changed, 489 insertions(+), 46 deletions(-) diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h index 9158ec1..eb845cb 100644 --- a/include/net/net_namespace.h +++ b/include/net/net_namespace.h @@ -18,6 +18,9 @@ #include <net/netns/packet.h> #include <net/netns/ipv4.h> #include <net/netns/ipv6.h> +#ifdef CONFIG_MPTCP +#include <net/netns/mptcp.h> +#endif #include <net/netns/ieee802154_6lowpan.h> #include <net/netns/sctp.h> #include <net/netns/dccp.h> @@ -100,6 +103,9 @@ struct net { #if IS_ENABLED(CONFIG_IPV6) struct netns_ipv6 ipv6; #endif +#ifdef CONFIG_MPTCP + struct netns_mptcp mptcp; +#endif #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN) struct netns_ieee802154_lowpan ieee802154_lowpan; #endif diff --git a/include/net/tcp.h b/include/net/tcp.h index 3344b1d..a785a85 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -2062,8 +2062,14 @@ extern void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs); static inline s64 tcp_rto_delta_us(const struct sock *sk) { const struct sk_buff *skb = tcp_rtx_queue_head(sk); - u32 rto = inet_csk(sk)->icsk_rto; - u64 rto_time_stamp_us = skb->skb_mstamp + jiffies_to_usecs(rto); + u32 rto; + u64 rto_time_stamp_us; + + if (!skb) + return -1; + + rto = inet_csk(sk)->icsk_rto; + rto_time_stamp_us = skb->skb_mstamp + jiffies_to_usecs(rto); return rto_time_stamp_us - tcp_sk(sk)->tcp_mstamp; } @@ -2334,8 +2340,6 @@ void tcp_v4_reqsk_destructor(struct request_sock *req); struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb); void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph, const struct tcphdr *th); -void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, - const struct tcphdr *th); void tcp_write_err(struct sock *sk); bool retransmits_timed_out(struct sock *sk, unsigned int boundary, unsigned int timeout); @@ -2345,7 +2349,15 @@ struct request_sock *tcp_cookie_req_alloc(struct sock *sk, struct tcp_options_received *tcp_opts, __u32 cookie, int mss); void inet_twsk_free(struct inet_timewait_sock *tw); +void tcp_cookie_req_init(struct sock *sk, struct sk_buff *skb, + struct request_sock *req, + struct tcp_options_received *tcp_opts, __u32 cookie, + int mss); +extern const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops; #if IS_ENABLED(CONFIG_IPV6) +extern const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops; +void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr, + const struct tcphdr *th); void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb); void tcp_v6_mtu_reduced(struct sock *sk); void tcp_v6_reqsk_destructor(struct request_sock *req); diff --git a/net/core/secure_seq.c b/net/core/secure_seq.c index 7232274..44226f1 100644 --- a/net/core/secure_seq.c +++ b/net/core/secure_seq.c @@ -191,3 +191,73 @@ u64 secure_dccpv6_sequence_number(__be32 *saddr, __be32 *daddr, EXPORT_SYMBOL(secure_dccpv6_sequence_number); #endif #endif + +#ifdef CONFIG_MPTCP +u32 mptcp_v4_get_nonce(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport) +{ + u32 hash; + + net_secret_init(); + hash = siphash_3u32((__force u32)saddr, (__force u32)daddr, + (__force u32)sport << 16 | (__force u32)dport, + &net_secret); + return seq_scale(hash); +} +EXPORT_SYMBOL_GPL(mptcp_v4_get_nonce); + +u64 mptcp_v4_get_key(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport) +{ + u64 hash; + + net_secret_init(); + hash = siphash_3u32((__force u32)saddr, (__force u32)daddr, + (__force u32)sport << 16 | (__force u32)dport, + &net_secret); + return hash; +} +EXPORT_SYMBOL_GPL(mptcp_v4_get_key); + +#if IS_ENABLED(CONFIG_IPV6) + +u32 mptcp_v6_get_nonce(const __be32 *saddr, const __be32 *daddr, + __be16 sport, __be16 dport) +{ + const struct { + struct in6_addr saddr; + struct in6_addr daddr; + __be16 sport; + __be16 dport; + } __aligned(SIPHASH_ALIGNMENT) combined = { + .saddr = *(struct in6_addr *)saddr, + .daddr = *(struct in6_addr *)daddr, + .sport = sport, + .dport = dport + }; + u64 hash; + + net_secret_init(); + hash = siphash(&combined, offsetofend(typeof(combined), dport), + &net_secret); + return seq_scale(hash); +} +EXPORT_SYMBOL_GPL(mptcp_v6_get_nonce); + +u64 mptcp_v6_get_key(const __be32 *saddr, const __be32 *daddr, + __be16 sport, __be16 dport) +{ + const struct { + struct in6_addr saddr; + struct in6_addr daddr; + __be16 dport; + } __aligned(SIPHASH_ALIGNMENT) combined = { + .saddr = *(struct in6_addr *)saddr, + .daddr = *(struct in6_addr *)daddr, + .dport = dport + }; + net_secret_init(); + return siphash(&combined, offsetofend(typeof(combined), dport), + &net_secret); +} +EXPORT_SYMBOL_GPL(mptcp_v6_get_key); +#endif +#endif diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index 5d8ea09..3334e68 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -123,6 +123,10 @@ #include <trace/events/sock.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif + /* The inetsw table contains everything that inet_create needs to * build a new socket. */ @@ -150,6 +154,10 @@ void inet_sock_destruct(struct sock *sk) return; } +#ifdef CONFIG_MPTCP + if (sock_flag(sk, SOCK_MPTCP)) + mptcp_disable_static_key(); +#endif WARN_ON(atomic_read(&sk->sk_rmem_alloc)); WARN_ON(refcount_read(&sk->sk_wmem_alloc)); WARN_ON(sk->sk_wmem_queued); @@ -1915,6 +1923,11 @@ static int __init inet_init(void) ip_init(); +#ifdef CONFIG_MPTCP + /* We must initialize MPTCP before TCP. */ + mptcp_init(); +#endif + /* Setup TCP slab cache for open requests. */ tcp_init(); diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c index 881ac6d..398eeae 100644 --- a/net/ipv4/inet_connection_sock.c +++ b/net/ipv4/inet_connection_sock.c @@ -26,6 +26,9 @@ #include <net/tcp.h> #include <net/sock_reuseport.h> #include <net/addrconf.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif #ifdef INET_CSK_DEBUG const char inet_csk_timer_bug_msg[] = "inet_csk BUG: unknown timer value\n"; @@ -944,11 +947,23 @@ EXPORT_SYMBOL(inet_csk_reqsk_queue_add); struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child, struct request_sock *req, bool own_req) { +#ifdef CONFIG_MPTCP + if (child->sk_protocol == IPPROTO_TCP && mptcp(tcp_sk(child))) { + if (is_meta_sk(sk)) + return(child); + child = mptcp_meta_sk(child); + } +#endif if (own_req) { inet_csk_reqsk_queue_drop(sk, req); reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req); - if (inet_csk_reqsk_queue_add(sk, req, child)) + if (inet_csk_reqsk_queue_add(sk, req, child)) { +#ifdef CONFIG_MPTCP + if (mptcp(tcp_sk(child))) + child = tcp_sk(child)->mpcb->master_sk; +#endif return child; + } } /* Too bad, another child took ownership of the request, undo. */ bh_unlock_sock(child); diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c index 008be04..01543fb 100644 --- a/net/ipv4/ip_sockglue.c +++ b/net/ipv4/ip_sockglue.c @@ -46,6 +46,9 @@ #include <linux/errqueue.h> #include <linux/uaccess.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif /* * SOL_IP control messages. @@ -752,6 +755,23 @@ static int do_ip_setsockopt(struct sock *sk, int level, inet->tos = val; sk->sk_priority = rt_tos2priority(val); sk_dst_reset(sk); +#ifdef CONFIG_MPTCP + /* Update TOS on mptcp subflow */ + if (is_meta_sk(sk)) { + struct sock *sk_it; + + mptcp_for_each_sk(tcp_sk(sk)->mpcb, sk_it) { + if (inet_sk(sk_it)->tos != + inet_sk(sk)->tos) { + inet_sk(sk_it)->tos = + inet_sk(sk)->tos; + sk_it->sk_priority = + sk->sk_priority; + sk_dst_reset(sk_it); + } + } + } +#endif } break; case IP_TTL: diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c index e0f511e..04e03c1 100644 --- a/net/ipv4/syncookies.c +++ b/net/ipv4/syncookies.c @@ -19,6 +19,9 @@ #include <net/secure_seq.h> #include <net/tcp.h> #include <net/route.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif static siphash_key_t syncookie_secret[2] __read_mostly; diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index 20a69eb..e7b7a77 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -282,6 +282,9 @@ #include <linux/uaccess.h> #include <asm/ioctls.h> #include <net/busy_poll.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif struct percpu_counter tcp_orphan_count; EXPORT_SYMBOL_GPL(tcp_orphan_count); @@ -850,6 +853,15 @@ ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos, int ret; sock_rps_record_flow(sk); + +#ifdef CONFIG_MPTCP + if (mptcp(tcp_sk(sk))) { + struct sock *sk_it; + + mptcp_for_each_sk(tcp_sk(sk)->mpcb, sk_it) + sock_rps_record_flow(sk_it); + } +#endif /* * We can't seek on a socket input */ @@ -1892,6 +1904,14 @@ int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, lock_sock(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tp)) { + struct sock *sk_it; + + mptcp_for_each_sk(tp->mpcb, sk_it) + sock_rps_record_flow(sk_it); + } +#endif err = -ENOTCONN; if (sk->sk_state == TCP_LISTEN) goto out; @@ -2262,6 +2282,12 @@ void tcp_close(struct sock *sk, long timeout) int data_was_unread = 0; int state; +#ifdef CONFIG_MPTCP + if (is_meta_sk(sk)) { + mptcp_close(sk, timeout); + return; + } +#endif lock_sock(sk); sk->sk_shutdown = SHUTDOWN_MASK; @@ -2502,6 +2528,12 @@ int tcp_disconnect(struct sock *sk, int flags) if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) inet_reset_saddr(sk); +#ifdef CONFIG_MPTCP + if (is_meta_sk(sk)) + mptcp_disconnect(sk); + else if (tp->inside_tk_table) + mptcp_hash_remove_bh(tp); +#endif sk->sk_shutdown = 0; sock_reset_flag(sk, SOCK_DONE); tp->srtt_us = 0; @@ -2870,6 +2902,14 @@ static int do_tcp_setsockopt(struct sock *sk, int level, break; case TCP_DEFER_ACCEPT: +#ifdef CONFIG_MPTCP + /* An established MPTCP-connection should not use DEFER on new + * subflows. mptcp(tp) only returns true if the socket is + * established. + */ + if (mptcp(tp)) + break; +#endif /* Translate value in seconds to number of retransmits */ icsk->icsk_accept_queue.rskq_defer_accept = secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ, @@ -2964,6 +3004,19 @@ static int do_tcp_setsockopt(struct sock *sk, int level, tp->notsent_lowat = val; sk->sk_write_space(sk); break; +#ifdef CONFIG_MPTCP + case MPTCP_ENABLED: + if (mptcp_init_failed || !sysctl_mptcp_enabled || + sk->sk_state != TCP_CLOSE) { + err = -EPERM; + break; + } + if (val) + mptcp_enable_sock(sk); + else + mptcp_disable_sock(sk); + break; +#endif default: err = -ENOPROTOOPT; break; @@ -3383,6 +3436,11 @@ static int do_tcp_getsockopt(struct sock *sk, int level, case TCP_SAVE_SYN: val = tp->save_syn; break; +#ifdef CONFIG_MPTCP + case MPTCP_ENABLED: + val = sock_flag(sk, SOCK_MPTCP) ? 1 : 0; + break; +#endif case TCP_SAVED_SYN: { if (get_user(len, optlen)) return -EFAULT; diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c index 398505e..84ce46a 100644 --- a/net/ipv4/tcp_input.c +++ b/net/ipv4/tcp_input.c @@ -78,6 +78,9 @@ #include <linux/errqueue.h> #include <trace/events/tcp.h> #include <linux/static_key.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif int sysctl_tcp_max_orphans __read_mostly = NR_FILE; @@ -4038,6 +4041,10 @@ void tcp_fin(struct sock *sk) /* Move to CLOSE_WAIT */ tcp_set_state(sk, TCP_CLOSE_WAIT); inet_csk(sk)->icsk_ack.pingpong = 1; +#ifdef CONFIG_MPTCP + if (mptcp(tp)) + mptcp_sub_close_passive(sk); +#endif break; case TCP_CLOSE_WAIT: @@ -4059,6 +4066,15 @@ void tcp_fin(struct sock *sk) tcp_set_state(sk, TCP_CLOSING); break; case TCP_FIN_WAIT2: +#ifdef CONFIG_MPTCP + if (mptcp(tp)) { + /* The socket will get closed by mptcp_data_ready. + * We first have to process all data-sequences. + */ + tp->close_it = 1; + break; + } +#endif /* Received a FIN -- send ACK and enter TIME_WAIT. */ tcp_send_ack(sk); tcp_time_wait(sk, TCP_TIME_WAIT, 0); @@ -4083,6 +4099,11 @@ void tcp_fin(struct sock *sk) if (!sock_flag(sk, SOCK_DEAD)) { sk->sk_state_change(sk); +#ifdef CONFIG_MPTCP + /* Don't wake up MPTCP-subflows */ + if (mptcp(tp)) + return; +#endif /* Do not send POLL_HUP for half duplex close. */ if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == TCP_CLOSE) @@ -6154,6 +6175,10 @@ static void tcp_openreq_init(struct request_sock *req, #if IS_ENABLED(CONFIG_SMC) ireq->smc_ok = rx_opt->smc_ok; #endif +#ifdef CONFIG_MPTCP + ireq->saw_mpc = 0; + ireq->mptcp_rqsk = 0; +#endif } struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops, diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c index 95d4c1f..b7f67d1 100644 --- a/net/ipv4/tcp_ipv4.c +++ b/net/ipv4/tcp_ipv4.c @@ -87,6 +87,10 @@ #include <trace/events/tcp.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif + #ifdef CONFIG_TCP_MD5SIG static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key, __be32 daddr, __be32 saddr, const struct tcphdr *th); @@ -375,6 +379,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) const int type = icmp_hdr(icmp_skb)->type; const int code = icmp_hdr(icmp_skb)->code; struct sock *sk; + struct sock *meta_sk; struct sk_buff *skb; struct request_sock *fastopen; u32 seq, snd_una; @@ -403,13 +408,20 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) (code == ICMP_NET_UNREACH || code == ICMP_HOST_UNREACH))); - bh_lock_sock(sk); + tp = tcp_sk(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tp)) + meta_sk = mptcp_meta_sk(sk); + else +#endif + meta_sk = sk; + bh_lock_sock(meta_sk); /* If too many ICMPs get dropped on busy * servers this needs to be solved differently. * We do take care of PMTU discovery (RFC1191) special case : * we can receive locally generated ICMP messages while socket is held. */ - if (sock_owned_by_user(sk)) { + if (sock_owned_by_user(meta_sk)) { if (!(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)) __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS); } @@ -456,11 +468,15 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) goto out; tp->mtu_info = info; - if (!sock_owned_by_user(sk)) { + if (!sock_owned_by_user(meta_sk)) { tcp_v4_mtu_reduced(sk); } else { if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &sk->sk_tsq_flags)) sock_hold(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tp)) + mptcp_tsq_flags(sk); +#endif } goto out; } @@ -474,7 +490,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) !icsk->icsk_backoff || fastopen) break; - if (sock_owned_by_user(sk)) + if (sock_owned_by_user(meta_sk)) break; icsk->icsk_backoff--; @@ -516,7 +532,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) if (fastopen && !fastopen->sk) break; - if (!sock_owned_by_user(sk)) { + if (!sock_owned_by_user(meta_sk)) { sk->sk_err = err; sk->sk_error_report(sk); @@ -545,7 +561,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) */ inet = inet_sk(sk); - if (!sock_owned_by_user(sk) && inet->recverr) { + if (!sock_owned_by_user(meta_sk) && inet->recverr) { sk->sk_err = err; sk->sk_error_report(sk); } else { /* Only an error on timeout */ @@ -553,7 +569,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) } out: - bh_unlock_sock(sk); + bh_unlock_sock(meta_sk); sock_put(sk); } @@ -747,10 +763,17 @@ static void tcp_v4_send_ack(const struct sock *sk, #ifdef CONFIG_TCP_MD5SIG + (TCPOLEN_MD5SIG_ALIGNED >> 2) #endif +#ifdef CONFIG_MPTCP + + ((MPTCP_SUB_LEN_DSS >> 2) + + (MPTCP_SUB_LEN_ACK >> 2)) +#endif ]; } rep; struct net *net = sock_net(sk); struct ip_reply_arg arg; +#if defined(CONFIG_MPTCP) || defined(CONFIG_TCP_MD5SIG) + int offset = (tsecr) ? 3 : 0; +#endif memset(&rep.th, 0, sizeof(struct tcphdr)); memset(&arg, 0, sizeof(arg)); @@ -777,8 +800,6 @@ static void tcp_v4_send_ack(const struct sock *sk, #ifdef CONFIG_TCP_MD5SIG if (key) { - int offset = (tsecr) ? 3 : 0; - rep.opt[offset++] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | (TCPOPT_MD5SIG << 8) | @@ -791,6 +812,12 @@ static void tcp_v4_send_ack(const struct sock *sk, ip_hdr(skb)->daddr, &rep.th); } #endif +#ifdef CONFIG_MPTCP + mptcp_v4_add_ack_opts(sk, skb, &offset, &arg, rep.opt); + rep.th.doff = (arg.iov[0].iov_len >> 2); +#endif + WARN_ON(rep.th.doff > (MAX_TCP_OPTION_SPACE >> 2) || + rep.th.doff > (sizeof(rep.opt) >> 2)); arg.flags = reply_flags; arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr, ip_hdr(skb)->saddr, /* XXX */ @@ -1294,7 +1321,7 @@ struct request_sock_ops tcp_request_sock_ops __read_mostly = { .syn_ack_timeout = tcp_syn_ack_timeout, }; -static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = { +const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = { .mss_clamp = TCP_MSS_DEFAULT, #ifdef CONFIG_TCP_MD5SIG .req_md5_lookup = tcp_v4_md5_lookup, @@ -1684,7 +1711,20 @@ int tcp_v4_rcv(struct sk_buff *skb) reqsk_put(req); goto discard_it; } + + /* In case of MPTCP join, the meta socket acts as the listener. + * So the state of the listener can be other than TCP_LISTEN + */ if (unlikely(sk->sk_state != TCP_LISTEN)) { +#ifdef CONFIG_MPTCP + if (inet_rsk(req)->saw_mpc) { + /* In case of MPTCP join, the meta socket acts + * as the listener. So the state of the listener + * can be other than TCP_LISTEN + */ + return mptcp_join_ack(req, skb); + } +#endif inet_csk_reqsk_queue_drop_and_put(sk, req); goto lookup; } @@ -1918,6 +1958,12 @@ void tcp_v4_destroy_sock(struct sock *sk) tcp_cleanup_congestion_control(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tp)) + mptcp_destroy_sock(sk); + if (tp->inside_tk_table) + mptcp_hash_remove(tp); +#endif tcp_cleanup_ulp(sk); /* Cleanup up the write buffer. */ diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c index e7e3643..c8712a9 100644 --- a/net/ipv4/tcp_minisocks.c +++ b/net/ipv4/tcp_minisocks.c @@ -28,6 +28,9 @@ #include <net/inet_common.h> #include <net/xfrm.h> #include <net/busy_poll.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif static bool tcp_in_window(u32 seq, u32 end_seq, u32 s_win, u32 e_win) { @@ -94,9 +97,17 @@ tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb, struct tcp_options_received tmp_opt; struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw); bool paws_reject = false; +#ifdef CONFIG_MPTCP + struct mptcp_options_received mopt; +#endif tmp_opt.saw_tstamp = 0; - if (th->doff > (sizeof(*th) >> 2) && tcptw->tw_ts_recent_stamp) { + if (th->doff > (sizeof(*th) >> 2) && +#ifdef CONFIG_MPTCP + (tcptw->tw_ts_recent_stamp || tcptw->mptcp_tw)) { +#else + tcptw->tw_ts_recent_stamp) { +#endif tcp_parse_options(twsk_net(tw), skb, &tmp_opt, 0, NULL); if (tmp_opt.saw_tstamp) { @@ -106,6 +117,16 @@ tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb, tmp_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp; paws_reject = tcp_paws_reject(&tmp_opt, th->rst); } + +#ifdef CONFIG_MPTCP + if (unlikely(tcptw->mptcp_tw)) { + mptcp_init_mp_opt(&mopt); + tcp_parse_mptcp_options(skb, &mopt); + if (mopt.mp_fclose && + mopt.mptcp_sender_key == tcptw->mptcp_tw->loc_key) + return TCP_TW_RST; + } +#endif } if (tw->tw_substate == TCP_FIN_WAIT2) { @@ -129,6 +150,13 @@ tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb, if (!th->ack || !after(TCP_SKB_CB(skb)->end_seq, tcptw->tw_rcv_nxt) || TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq) { +#ifdef CONFIG_MPTCP + if (tcptw->mptcp_tw && tcptw->mptcp_tw->meta_tw && + mptcp_is_data_fin(skb) && + TCP_SKB_CB(skb)->seq == tcptw->tw_rcv_nxt && + mopt.data_seq + 1 == (u32)tcptw->mptcp_tw->rcv_nxt) + return TCP_TW_ACK; +#endif inet_twsk_put(tw); return TCP_TW_SUCCESS; } @@ -272,6 +300,17 @@ void tcp_time_wait(struct sock *sk, int state, int timeo) tcptw->tw_ts_offset = tp->tsoffset; tcptw->tw_last_oow_ack_time = 0; +#ifdef CONFIG_MPTCP + if (mptcp(tp)) { + if (mptcp_init_tw_sock(sk, tcptw)) { + inet_twsk_free(tw); + goto exit; + } + } else { + tcptw->mptcp_tw = NULL; + } +#endif + #if IS_ENABLED(CONFIG_IPV6) if (tw->tw_family == PF_INET6) { struct ipv6_pinfo *np = inet6_sk(sk); @@ -329,15 +368,23 @@ void tcp_time_wait(struct sock *sk, int state, int timeo) NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPTIMEWAITOVERFLOW); } +#ifdef CONFIG_MPTCP +exit: +#endif tcp_update_metrics(sk); tcp_done(sk); } void tcp_twsk_destructor(struct sock *sk) { -#ifdef CONFIG_TCP_MD5SIG struct tcp_timewait_sock *twsk = tcp_twsk(sk); +#ifdef CONFIG_MPTCP + if (twsk->mptcp_tw) + mptcp_twsk_destructor(twsk); +#endif +#ifdef CONFIG_TCP_MD5SIG + if (twsk->tw_md5_key) kfree_rcu(twsk->tw_md5_key, rcu); #endif @@ -851,6 +898,11 @@ int tcp_child_process(struct sock *parent, struct sock *child, bh_unlock_sock(child); sock_put(child); + +#ifdef CONFIG_MPTCP + if (mptcp(tcp_sk(child))) + bh_unlock_sock(mptcp_meta_sk(child)); +#endif return ret; } EXPORT_SYMBOL(tcp_child_process); diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c index 72b494a..dc638f8 100644 --- a/net/ipv4/tcp_output.c +++ b/net/ipv4/tcp_output.c @@ -44,6 +44,9 @@ #include <linux/static_key.h> #include <trace/events/tcp.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif /* Account for new data that has been sent to the network. */ void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb) @@ -381,6 +384,7 @@ void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags) TCP_SKB_CB(skb)->tcp_flags = flags; TCP_SKB_CB(skb)->sacked = 0; + TCP_SKB_CB(skb)->mptcp_flags = 0; tcp_skb_pcount_set(skb, 1); @@ -802,7 +806,7 @@ static void tcp_tasklet_func(unsigned long data) unsigned long flags; struct list_head *q, *n; struct tcp_sock *tp; - struct sock *sk; + struct sock *sk, *meta_sk; local_irq_save(flags); list_splice_init(&tsq->head, &list); @@ -813,17 +817,22 @@ static void tcp_tasklet_func(unsigned long data) list_del(&tp->tsq_node); sk = (struct sock *)tp; +#ifndef CONFIG_MPTCP + meta_sk = sk; +#else + meta_sk = mptcp(tcp_sk(sk)) ? mptcp_meta_sk(sk) : sk; +#endif smp_mb__before_atomic(); clear_bit(TSQ_QUEUED, &sk->sk_tsq_flags); - if (!sk->sk_lock.owned && + if (!meta_sk->sk_lock.owned && test_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags)) { - bh_lock_sock(sk); - if (!sock_owned_by_user(sk)) { + bh_lock_sock(meta_sk); + if (!sock_owned_by_user(meta_sk)) { clear_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags); tcp_tsq_handler(sk); } - bh_unlock_sock(sk); + bh_unlock_sock(meta_sk); } sk_free(sk); @@ -879,6 +888,10 @@ void tcp_release_cb(struct sock *sk) inet_csk(sk)->icsk_af_ops->mtu_reduced(sk); __sock_put(sk); } +#ifdef CONFIG_MPTCP + if (flags & (1UL << MPTCP_SUB_DEFERRED)) + mptcp_tsq_sub_deferred(sk); +#endif } EXPORT_SYMBOL(tcp_release_cb); @@ -1846,6 +1859,10 @@ inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb, /* Don't use the nagle rule for urgent data (or for the final FIN). */ if (tcp_urg_mode(tp) || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)) return true; +#ifdef CONFIG_MPTCP + if (mptcp_is_data_fin(skb)) + return true; +#endif if (!tcp_nagle_check(skb->len < cur_mss, tp, nonagle)) return true; @@ -1941,6 +1958,10 @@ static bool tcp_tso_should_defer(struct sock *sk, struct sk_buff *skb, if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) goto send_now; +#ifdef CONFIG_MPTCP + if (mptcp_is_data_fin(skb)) + goto send_now; +#endif if (icsk->icsk_ca_state >= TCP_CA_Recovery) goto send_now; diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c index dbf284d..e315ad1 100644 --- a/net/ipv4/tcp_timer.c +++ b/net/ipv4/tcp_timer.c @@ -22,6 +22,10 @@ #include <linux/gfp.h> #include <net/tcp.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#endif + /** * tcp_write_err() - close socket and save error info * @sk: The socket the error has appeared on. @@ -295,8 +299,13 @@ static void tcp_delack_timer(struct timer_list *t) struct inet_connection_sock *icsk = from_timer(icsk, t, icsk_delack_timer); struct sock *sk = &icsk->icsk_inet.sk; +#ifndef CONFIG_MPTCP + struct sock *meta_sk = sk; +#else + struct sock *meta_sk = mptcp(tcp_sk(sk)) ? mptcp_meta_sk(sk) : sk; +#endif - bh_lock_sock(sk); + bh_lock_sock(meta_sk); if (!sock_owned_by_user(sk)) { tcp_delack_timer_handler(sk); } else { @@ -305,8 +314,12 @@ static void tcp_delack_timer(struct timer_list *t) /* deleguate our work to tcp_release_cb() */ if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, &sk->sk_tsq_flags)) sock_hold(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tcp_sk(sk))) + mptcp_tsq_flags(sk); +#endif } - bh_unlock_sock(sk); + bh_unlock_sock(meta_sk); sock_put(sk); } @@ -586,15 +599,25 @@ static void tcp_write_timer(struct timer_list *t) from_timer(icsk, t, icsk_retransmit_timer); struct sock *sk = &icsk->icsk_inet.sk; - bh_lock_sock(sk); - if (!sock_owned_by_user(sk)) { +#ifndef CONFIG_MPTCP + struct sock *meta_sk = sk; +#else + struct sock *meta_sk = mptcp(tcp_sk(sk)) ? mptcp_meta_sk(sk) : sk; +#endif + + bh_lock_sock(meta_sk); + if (!sock_owned_by_user(meta_sk)) { tcp_write_timer_handler(sk); } else { /* delegate our work to tcp_release_cb() */ if (!test_and_set_bit(TCP_WRITE_TIMER_DEFERRED, &sk->sk_tsq_flags)) sock_hold(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tcp_sk(sk))) + mptcp_tsq_flags(sk); +#endif } - bh_unlock_sock(sk); + bh_unlock_sock(meta_sk); sock_put(sk); } @@ -625,10 +648,15 @@ static void tcp_keepalive_timer (struct timer_list *t) struct inet_connection_sock *icsk = inet_csk(sk); struct tcp_sock *tp = tcp_sk(sk); u32 elapsed; +#ifndef CONFIG_MPTCP + struct sock *meta_sk = sk; +#else + struct sock *meta_sk = mptcp(tcp_sk(sk)) ? mptcp_meta_sk(sk) : sk; +#endif /* Only process if socket is not in use. */ - bh_lock_sock(sk); - if (sock_owned_by_user(sk)) { + bh_lock_sock(meta_sk); + if (sock_owned_by_user(meta_sk)) { /* Try again later. */ inet_csk_reset_keepalive_timer (sk, HZ/20); goto out; @@ -702,7 +730,7 @@ static void tcp_keepalive_timer (struct timer_list *t) tcp_done(sk); out: - bh_unlock_sock(sk); + bh_unlock_sock(meta_sk); sock_put(sk); } diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c index d78d41f..c5956c2 100644 --- a/net/ipv6/ipv6_sockglue.c +++ b/net/ipv6/ipv6_sockglue.c @@ -53,6 +53,10 @@ #include <net/xfrm.h> #include <net/compat.h> #include <net/seg6.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#include <net/mptcp_v4.h> +#endif #include <linux/uaccess.h> @@ -216,6 +220,12 @@ static int do_ipv6_setsockopt(struct sock *sk, int level, int optname, sock_prot_inuse_add(net, &tcp_prot, 1); local_bh_enable(); sk->sk_prot = &tcp_prot; +#ifdef CONFIG_MPTCP + if (sock_flag(sk, SOCK_MPTCP)) + icsk->icsk_af_ops = &mptcp_v4_specific; + else +#endif + icsk->icsk_af_ops = &ipv4_specific; icsk->icsk_af_ops = &ipv4_specific; sk->sk_socket->ops = &inet_stream_ops; sk->sk_family = PF_INET; @@ -242,6 +252,10 @@ static int do_ipv6_setsockopt(struct sock *sk, int level, int optname, pktopt = xchg(&np->pktoptions, NULL); kfree_skb(pktopt); +#ifdef CONFIG_MPTCP + if (is_meta_sk(sk)) + sk->sk_destruct = mptcp_sock_destruct; +#endif /* * ... and add it to the refcnt debug socks count * in the new family. -acme diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c index c226cf6..48c86b8 100644 --- a/net/ipv6/tcp_ipv6.c +++ b/net/ipv6/tcp_ipv6.c @@ -71,6 +71,11 @@ #include <trace/events/tcp.h> +#ifdef CONFIG_MPTCP +#include <net/mptcp.h> +#include <net/mptcp_v6.h> +#endif + #ifdef CONFIG_TCP_MD5SIG static const struct tcp_sock_af_ops tcp_sock_ipv6_specific; static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; @@ -206,7 +211,12 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, sin.sin_port = usin->sin6_port; sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3]; - icsk->icsk_af_ops = &ipv6_mapped; +#ifdef CONFIG_MPTCP + if (sock_flag(sk, SOCK_MPTCP)) + icsk->icsk_af_ops = &mptcp_v6_mapped; + else +#endif + icsk->icsk_af_ops = &ipv6_mapped; sk->sk_backlog_rcv = tcp_v4_do_rcv; #ifdef CONFIG_TCP_MD5SIG tp->af_specific = &tcp_sock_ipv6_mapped_specific; @@ -216,7 +226,12 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, if (err) { icsk->icsk_ext_hdr_len = exthdrlen; - icsk->icsk_af_ops = &ipv6_specific; +#ifdef CONFIG_MPTCP + if (sock_flag(sk, SOCK_MPTCP)) + icsk->icsk_af_ops = &mptcp_v6_specific; + else +#endif + icsk->icsk_af_ops = &ipv6_specific; sk->sk_backlog_rcv = tcp_v6_do_rcv; #ifdef CONFIG_TCP_MD5SIG tp->af_specific = &tcp_sock_ipv6_specific; @@ -337,6 +352,7 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, struct tcp_sock *tp; __u32 seq, snd_una; struct sock *sk; + struct sock *meta_sk; bool fatal; int err; @@ -359,9 +375,15 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, fatal = icmpv6_err_convert(type, code, &err); if (sk->sk_state == TCP_NEW_SYN_RECV) return tcp_req_err(sk, seq, fatal); - - bh_lock_sock(sk); - if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG) +#ifdef CONFIG_MPTCP + tp = tcp_sk(sk); + if (mptcp(tp)) + meta_sk = mptcp_meta_sk(sk); + else +#endif + meta_sk = sk; + bh_lock_sock(meta_sk); + if (sock_owned_by_user(meta_sk) && type != ICMPV6_PKT_TOOBIG) __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS); if (sk->sk_state == TCP_CLOSE) @@ -385,7 +407,7 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, np = inet6_sk(sk); if (type == NDISC_REDIRECT) { - if (!sock_owned_by_user(sk)) { + if (!sock_owned_by_user(meta_sk)) { struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie); if (dst) @@ -406,11 +428,17 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, goto out; tp->mtu_info = ntohl(info); - if (!sock_owned_by_user(sk)) + if (!sock_owned_by_user(meta_sk)) { tcp_v6_mtu_reduced(sk); - else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, - &sk->sk_tsq_flags)) - sock_hold(sk); + } else { + if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, + &sk->sk_tsq_flags)) + sock_hold(sk); +#ifdef CONFIG_MPTCP + if (mptcp(tp)) + mptcp_tsq_flags(sk); +#endif + } goto out; } @@ -425,7 +453,7 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, if (fastopen && !fastopen->sk) break; - if (!sock_owned_by_user(sk)) { + if (!sock_owned_by_user(meta_sk)) { sk->sk_err = err; sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */ @@ -435,14 +463,15 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, goto out; } - if (!sock_owned_by_user(sk) && np->recverr) { + if (!sock_owned_by_user(meta_sk) && np->recverr) { sk->sk_err = err; sk->sk_error_report(sk); - } else + } else { sk->sk_err_soft = err; + } out: - bh_unlock_sock(sk); + bh_unlock_sock(meta_sk); sock_put(sk); } @@ -749,7 +778,7 @@ struct request_sock_ops tcp6_request_sock_ops __read_mostly = { .syn_ack_timeout = tcp_syn_ack_timeout, }; -static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = { +const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = { .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr), #ifdef CONFIG_TCP_MD5SIG @@ -787,6 +816,10 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 if (key) tot_len += TCPOLEN_MD5SIG_ALIGNED; #endif +#ifdef CONFIG_MPTCP + /* We always allocate space when MPTCP is enabled */ + tot_len += MPTCP_SUB_LEN_DSS + MPTCP_SUB_LEN_ACK; +#endif buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len, GFP_ATOMIC); @@ -827,6 +860,9 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 &ipv6_hdr(skb)->daddr, t1); } #endif +#ifdef CONFIG_MPTCP + mptcp_v6_add_ack_opts(sk, skb, t1, &topt); +#endif memset(&fl6, 0, sizeof(fl6)); fl6.daddr = ipv6_hdr(skb)->saddr; @@ -1069,7 +1105,15 @@ struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, newnp->saddr = newsk->sk_v6_rcv_saddr; - inet_csk(newsk)->icsk_af_ops = &ipv6_mapped; +#ifdef CONFIG_MPTCP + /* We must check on the request-socket because the listener + * socket's flag may have been changed halfway through. + */ + if (!inet_rsk(req)->saw_mpc) + inet_csk(newsk)->icsk_af_ops = &mptcp_v6_mapped; + else +#endif + inet_csk(newsk)->icsk_af_ops = &ipv6_mapped; newsk->sk_backlog_rcv = tcp_v4_do_rcv; #ifdef CONFIG_TCP_MD5SIG newtp->af_specific = &tcp_sock_ipv6_mapped_specific; @@ -1116,6 +1160,13 @@ struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, if (!newsk) goto out_nonewsk; +#ifdef CONFIG_MPTCP + /* If the meta_sk is v6-mapped we can end up here with the wrong af_ops. + * Just make sure that this subflow is v6. + */ + if (is_meta_sk(sk)) + inet_csk(newsk)->icsk_af_ops = &mptcp_v6_specific; +#endif /* * No need to charge this sock to the relevant IPv6 refcnt debug socks * count here, tcp_create_openreq_child now does this for us, see the @@ -1453,6 +1504,15 @@ static int tcp_v6_rcv(struct sk_buff *skb) goto discard_it; } if (unlikely(sk->sk_state != TCP_LISTEN)) { +#ifdef CONFIG_MPTCP + if (inet_rsk(req)->saw_mpc) { + /* In case of MPTCP join, the meta socket acts + * as the listener. So the state of the listener + * can be other than TCP_LISTEN + */ + return mptcp_join_ack(req, skb); + } +#endif inet_csk_reqsk_queue_drop_and_put(sk, req); goto lookup; } -- 2.7.4

On 03/27/2018 03:27 AM, Christoph Paasch wrote: If you have an idea please submit a patch. The patch is not the final patch by any means. As I have said this is a base to start working from. Any change is welcome. That is not worth exposing MPTCP as a separate socket type. I prefer sharing as much existing code as possible. I have not looked at this level yet. I do not want any significant architectural changes just to disable RCU warning. Let me look at this at a later time. I am working with Paul McKinney on an RCU issue, I ask him as well. Shoaib