blob: 4913ac7b6d199b10aecd1f6fe0c49b7b6dc83b7d [file] [log] [blame]
Mat Martineauf870fa02020-01-21 16:56:15 -08001/* SPDX-License-Identifier: GPL-2.0 */
2/* Multipath TCP
3 *
4 * Copyright (c) 2017 - 2019, Intel Corporation.
5 */
6
7#ifndef __MPTCP_PROTOCOL_H
8#define __MPTCP_PROTOCOL_H
9
Peter Krystad79c09492020-01-21 16:56:20 -080010#include <linux/random.h>
11#include <net/tcp.h>
12#include <net/inet_connection_sock.h>
Florian Westphalb911c972021-02-12 16:00:01 -080013#include <uapi/linux/mptcp.h>
Peter Krystad79c09492020-01-21 16:56:20 -080014
Christoph Paaschcc7972e2020-01-21 16:56:31 -080015#define MPTCP_SUPPORTED_VERSION 1
Peter Krystadeda7acd2020-01-21 16:56:16 -080016
17/* MPTCP option bits */
18#define OPTION_MPTCP_MPC_SYN BIT(0)
19#define OPTION_MPTCP_MPC_SYNACK BIT(1)
20#define OPTION_MPTCP_MPC_ACK BIT(2)
Peter Krystadf2962342020-03-27 14:48:39 -070021#define OPTION_MPTCP_MPJ_SYN BIT(3)
22#define OPTION_MPTCP_MPJ_SYNACK BIT(4)
23#define OPTION_MPTCP_MPJ_ACK BIT(5)
Peter Krystad3df523a2020-03-27 14:48:37 -070024#define OPTION_MPTCP_ADD_ADDR BIT(6)
Geliang Tangfef6b7e2021-04-06 17:15:59 -070025#define OPTION_MPTCP_RM_ADDR BIT(7)
26#define OPTION_MPTCP_FASTCLOSE BIT(8)
27#define OPTION_MPTCP_PRIO BIT(9)
28#define OPTION_MPTCP_RST BIT(10)
Peter Krystadeda7acd2020-01-21 16:56:16 -080029
30/* MPTCP option subtypes */
31#define MPTCPOPT_MP_CAPABLE 0
32#define MPTCPOPT_MP_JOIN 1
33#define MPTCPOPT_DSS 2
34#define MPTCPOPT_ADD_ADDR 3
35#define MPTCPOPT_RM_ADDR 4
36#define MPTCPOPT_MP_PRIO 5
37#define MPTCPOPT_MP_FAIL 6
38#define MPTCPOPT_MP_FASTCLOSE 7
Florian Westphaldc87efd2021-04-01 16:19:44 -070039#define MPTCPOPT_RST 8
Peter Krystadeda7acd2020-01-21 16:56:16 -080040
41/* MPTCP suboption lengths */
Christoph Paaschcc7972e2020-01-21 16:56:31 -080042#define TCPOLEN_MPTCP_MPC_SYN 4
Peter Krystadeda7acd2020-01-21 16:56:16 -080043#define TCPOLEN_MPTCP_MPC_SYNACK 12
44#define TCPOLEN_MPTCP_MPC_ACK 20
Christoph Paaschcc7972e2020-01-21 16:56:31 -080045#define TCPOLEN_MPTCP_MPC_ACK_DATA 22
Peter Krystadf2962342020-03-27 14:48:39 -070046#define TCPOLEN_MPTCP_MPJ_SYN 12
47#define TCPOLEN_MPTCP_MPJ_SYNACK 16
48#define TCPOLEN_MPTCP_MPJ_ACK 24
Mat Martineau6d0060f2020-01-21 16:56:23 -080049#define TCPOLEN_MPTCP_DSS_BASE 4
Mat Martineau648ef4b2020-01-21 16:56:24 -080050#define TCPOLEN_MPTCP_DSS_ACK32 4
Mat Martineau6d0060f2020-01-21 16:56:23 -080051#define TCPOLEN_MPTCP_DSS_ACK64 8
Mat Martineau648ef4b2020-01-21 16:56:24 -080052#define TCPOLEN_MPTCP_DSS_MAP32 10
Mat Martineau6d0060f2020-01-21 16:56:23 -080053#define TCPOLEN_MPTCP_DSS_MAP64 14
54#define TCPOLEN_MPTCP_DSS_CHECKSUM 2
Peter Krystad3df523a2020-03-27 14:48:37 -070055#define TCPOLEN_MPTCP_ADD_ADDR 16
Davide Caratti27ab92d2021-03-08 10:00:04 +010056#define TCPOLEN_MPTCP_ADD_ADDR_PORT 18
Peter Krystad3df523a2020-03-27 14:48:37 -070057#define TCPOLEN_MPTCP_ADD_ADDR_BASE 8
Davide Caratti27ab92d2021-03-08 10:00:04 +010058#define TCPOLEN_MPTCP_ADD_ADDR_BASE_PORT 10
Peter Krystad3df523a2020-03-27 14:48:37 -070059#define TCPOLEN_MPTCP_ADD_ADDR6 28
Davide Caratti27ab92d2021-03-08 10:00:04 +010060#define TCPOLEN_MPTCP_ADD_ADDR6_PORT 30
Peter Krystad3df523a2020-03-27 14:48:37 -070061#define TCPOLEN_MPTCP_ADD_ADDR6_BASE 20
Davide Caratti27ab92d2021-03-08 10:00:04 +010062#define TCPOLEN_MPTCP_ADD_ADDR6_BASE_PORT 22
63#define TCPOLEN_MPTCP_PORT_LEN 2
64#define TCPOLEN_MPTCP_PORT_ALIGN 2
Geliang Tang6445e172021-03-12 17:16:11 -080065#define TCPOLEN_MPTCP_RM_ADDR_BASE 3
Davide Carattiec99a472021-02-01 14:05:26 +010066#define TCPOLEN_MPTCP_PRIO 3
67#define TCPOLEN_MPTCP_PRIO_ALIGN 4
Florian Westphal50c504a2020-12-10 14:25:04 -080068#define TCPOLEN_MPTCP_FASTCLOSE 12
Florian Westphaldc87efd2021-04-01 16:19:44 -070069#define TCPOLEN_MPTCP_RST 4
Peter Krystadeda7acd2020-01-21 16:56:16 -080070
Peter Krystadec3edaa2020-03-27 14:48:40 -070071/* MPTCP MP_JOIN flags */
Peter Krystadf2962342020-03-27 14:48:39 -070072#define MPTCPOPT_BACKUP BIT(0)
73#define MPTCPOPT_HMAC_LEN 20
Peter Krystadec3edaa2020-03-27 14:48:40 -070074#define MPTCPOPT_THMAC_LEN 8
Peter Krystadf2962342020-03-27 14:48:39 -070075
Peter Krystadeda7acd2020-01-21 16:56:16 -080076/* MPTCP MP_CAPABLE flags */
77#define MPTCP_VERSION_MASK (0x0F)
78#define MPTCP_CAP_CHECKSUM_REQD BIT(7)
79#define MPTCP_CAP_EXTENSIBILITY BIT(6)
Paolo Abeni65492c52020-01-21 16:56:30 -080080#define MPTCP_CAP_HMAC_SHA256 BIT(0)
Peter Krystadeda7acd2020-01-21 16:56:16 -080081#define MPTCP_CAP_FLAG_MASK (0x3F)
82
Mat Martineau6d0060f2020-01-21 16:56:23 -080083/* MPTCP DSS flags */
84#define MPTCP_DSS_DATA_FIN BIT(4)
85#define MPTCP_DSS_DSN64 BIT(3)
86#define MPTCP_DSS_HAS_MAP BIT(2)
87#define MPTCP_DSS_ACK64 BIT(1)
88#define MPTCP_DSS_HAS_ACK BIT(0)
Mat Martineau648ef4b2020-01-21 16:56:24 -080089#define MPTCP_DSS_FLAG_MASK (0x1F)
90
Peter Krystad3df523a2020-03-27 14:48:37 -070091/* MPTCP ADD_ADDR flags */
92#define MPTCP_ADDR_ECHO BIT(0)
Peter Krystad3df523a2020-03-27 14:48:37 -070093
Geliang Tang40453a52021-01-08 16:47:58 -080094/* MPTCP MP_PRIO flags */
95#define MPTCP_PRIO_BKUP BIT(0)
96
Florian Westphaldc87efd2021-04-01 16:19:44 -070097/* MPTCP TCPRST flags */
98#define MPTCP_RST_TRANSIENT BIT(0)
99
Mat Martineau648ef4b2020-01-21 16:56:24 -0800100/* MPTCP socket flags */
Florian Westphald99bfed2020-02-17 16:54:38 +0100101#define MPTCP_DATA_READY 0
Florian Westphal8edf0862020-11-16 10:48:12 +0100102#define MPTCP_NOSPACE 1
Paolo Abeni3b1d6212020-03-27 14:48:48 -0700103#define MPTCP_WORK_RTX 2
Florian Westphal59832e22020-04-02 13:44:52 +0200104#define MPTCP_WORK_EOF 3
Davide Carattie1ff9e82020-06-29 22:26:20 +0200105#define MPTCP_FALLBACK_DONE 4
Paolo Abeni0e4f35d2020-10-09 19:00:01 +0200106#define MPTCP_WORK_CLOSE_SUBFLOW 5
Paolo Abeni6e628cd2020-11-27 11:10:27 +0100107#define MPTCP_PUSH_PENDING 6
108#define MPTCP_CLEAN_UNA 7
Paolo Abeni15cc1042021-02-11 15:30:37 -0800109#define MPTCP_ERROR_REPORT 8
Paolo Abeni2d6f5a22021-03-26 11:26:30 -0700110#define MPTCP_RETRANSMIT 9
Florian Westphal78962482021-04-15 16:44:53 -0700111#define MPTCP_WORK_SYNC_SETSOCKOPT 10
Mat Martineau6d0060f2020-01-21 16:56:23 -0800112
Paolo Abenieaa2ffa2020-11-16 10:48:08 +0100113static inline bool before64(__u64 seq1, __u64 seq2)
114{
115 return (__s64)(seq1 - seq2) < 0;
116}
117
118#define after64(seq2, seq1) before64(seq1, seq2)
119
Paolo Abenicfde1412020-04-30 15:01:52 +0200120struct mptcp_options_received {
121 u64 sndr_key;
122 u64 rcvr_key;
123 u64 data_ack;
124 u64 data_seq;
125 u32 subflow_seq;
126 u16 data_len;
127 u16 mp_capable : 1,
128 mp_join : 1,
Florian Westphal50c504a2020-12-10 14:25:04 -0800129 fastclose : 1,
Florian Westphaldc87efd2021-04-01 16:19:44 -0700130 reset : 1,
Paolo Abenicfde1412020-04-30 15:01:52 +0200131 dss : 1,
132 add_addr : 1,
133 rm_addr : 1,
Geliang Tang40453a52021-01-08 16:47:58 -0800134 mp_prio : 1,
Paolo Abenicfde1412020-04-30 15:01:52 +0200135 echo : 1,
136 backup : 1;
137 u32 token;
138 u32 nonce;
139 u64 thmac;
Geliang Tangba34c3d2020-12-10 14:25:01 -0800140 u8 hmac[MPTCPOPT_HMAC_LEN];
Paolo Abenicfde1412020-04-30 15:01:52 +0200141 u8 join_id;
142 u8 use_map:1,
143 dsn64:1,
144 data_fin:1,
145 use_ack:1,
146 ack64:1,
147 mpc_map:1,
148 __unused:2;
Geliang Tangf7dafee2021-04-06 17:16:00 -0700149 struct mptcp_addr_info addr;
Geliang Tang5c4a8242021-03-12 17:16:13 -0800150 struct mptcp_rm_list rm_list;
Paolo Abenicfde1412020-04-30 15:01:52 +0200151 u64 ahmac;
Florian Westphaldc87efd2021-04-01 16:19:44 -0700152 u8 reset_reason:4;
153 u8 reset_transient:1;
Paolo Abenicfde1412020-04-30 15:01:52 +0200154};
155
Peter Krystad3df523a2020-03-27 14:48:37 -0700156static inline __be32 mptcp_option(u8 subopt, u8 len, u8 nib, u8 field)
157{
158 return htonl((TCPOPT_MPTCP << 24) | (len << 16) | (subopt << 12) |
159 ((nib & 0xF) << 8) | field);
160}
161
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700162enum mptcp_pm_status {
163 MPTCP_PM_ADD_ADDR_RECEIVED,
Geliang Tang84dfe362020-11-19 11:46:00 -0800164 MPTCP_PM_ADD_ADDR_SEND_ACK,
Geliang Tangd0876b22020-09-24 08:29:49 +0800165 MPTCP_PM_RM_ADDR_RECEIVED,
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700166 MPTCP_PM_ESTABLISHED,
Paolo Abeni5b950ff2020-12-09 12:03:29 +0100167 MPTCP_PM_ALREADY_ESTABLISHED, /* persistent status, set after ESTABLISHED event */
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700168 MPTCP_PM_SUBFLOW_ESTABLISHED,
169};
170
Geliang Tang13ad9f02020-12-09 15:51:27 -0800171enum mptcp_addr_signal_status {
Geliang Tangd91d3222020-11-19 11:45:59 -0800172 MPTCP_ADD_ADDR_SIGNAL,
173 MPTCP_ADD_ADDR_ECHO,
Geliang Tang84dfe362020-11-19 11:46:00 -0800174 MPTCP_ADD_ADDR_IPV6,
Geliang Tang4a2777a82020-12-09 15:51:22 -0800175 MPTCP_ADD_ADDR_PORT,
Geliang Tang42842a42020-12-09 15:51:26 -0800176 MPTCP_RM_ADDR_SIGNAL,
Geliang Tangd91d3222020-11-19 11:45:59 -0800177};
178
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700179struct mptcp_pm_data {
180 struct mptcp_addr_info local;
181 struct mptcp_addr_info remote;
Geliang Tangb6c08382020-09-24 08:29:54 +0800182 struct list_head anno_list;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700183
184 spinlock_t lock; /*protects the whole PM data */
185
Geliang Tang13ad9f02020-12-09 15:51:27 -0800186 u8 addr_signal;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700187 bool server_side;
188 bool work_pending;
189 bool accept_addr;
190 bool accept_subflow;
191 u8 add_addr_signaled;
192 u8 add_addr_accepted;
193 u8 local_addr_used;
194 u8 subflows;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700195 u8 status;
Geliang Tangcbde2782021-03-12 17:16:12 -0800196 struct mptcp_rm_list rm_list_tx;
Geliang Tangb5c55f32021-03-12 17:16:14 -0800197 struct mptcp_rm_list rm_list_rx;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700198};
199
Paolo Abeni18b683b2020-03-27 14:48:43 -0700200struct mptcp_data_frag {
201 struct list_head list;
202 u64 data_seq;
Paolo Abenif0e6a4c2020-11-16 10:48:07 +0100203 u16 data_len;
204 u16 offset;
205 u16 overhead;
206 u16 already_sent;
Paolo Abeni18b683b2020-03-27 14:48:43 -0700207 struct page *page;
208};
209
Mat Martineauf870fa02020-01-21 16:56:15 -0800210/* MPTCP connection sock */
211struct mptcp_sock {
212 /* inet_connection_sock must be the first member */
213 struct inet_connection_sock sk;
Peter Krystadcec37a62020-01-21 16:56:18 -0800214 u64 local_key;
215 u64 remote_key;
Mat Martineau6d0060f2020-01-21 16:56:23 -0800216 u64 write_seq;
Paolo Abenieaa2ffa2020-11-16 10:48:08 +0100217 u64 snd_nxt;
Mat Martineau6d0060f2020-01-21 16:56:23 -0800218 u64 ack_seq;
Florian Westphalfa3fe2b2020-11-19 11:46:02 -0800219 u64 rcv_wnd_sent;
Mat Martineau3721b9b2020-07-28 15:12:03 -0700220 u64 rcv_data_fin_seq;
Paolo Abenie93da922020-11-27 11:10:23 +0100221 int wmem_reserved;
Paolo Abenid5f49192020-09-14 10:01:17 +0200222 struct sock *last_snd;
223 int snd_burst;
Paolo Abeniea4ca582020-11-19 11:46:03 -0800224 int old_wspace;
Paolo Abeni7439d682020-11-27 11:10:26 +0100225 u64 snd_una;
226 u64 wnd_end;
Paolo Abenib51f9b82020-03-27 14:48:44 -0700227 unsigned long timer_ival;
Peter Krystad79c09492020-01-21 16:56:20 -0800228 u32 token;
Paolo Abeni87952602020-11-27 11:10:24 +0100229 int rmem_released;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800230 unsigned long flags;
Christoph Paaschd22f4982020-01-21 16:56:32 -0800231 bool can_ack;
Paolo Abenib93df082020-07-23 13:02:32 +0200232 bool fully_established;
Mat Martineau3721b9b2020-07-28 15:12:03 -0700233 bool rcv_data_fin;
Mat Martineau7279da62020-07-28 15:12:02 -0700234 bool snd_data_fin_enable;
Florian Westphal50c504a2020-12-10 14:25:04 -0800235 bool rcv_fastclose;
Davide Caratti37198e92020-10-06 18:26:17 +0200236 bool use_64bit_ack; /* Set when we received a 64-bit DSN */
Geliang Tang752e9062021-06-17 16:46:07 -0700237 bool csum_enabled;
Peter Krystadec3edaa2020-03-27 14:48:40 -0700238 spinlock_t join_list_lock;
Paolo Abeniea4ca582020-11-19 11:46:03 -0800239 struct sock *ack_hint;
Paolo Abeni80992012020-02-26 10:14:47 +0100240 struct work_struct work;
Paolo Abeniab174ad2020-09-14 10:01:12 +0200241 struct sk_buff *ooo_last_skb;
242 struct rb_root out_of_order_queue;
Paolo Abeni87952602020-11-27 11:10:24 +0100243 struct sk_buff_head receive_queue;
Paolo Abeni724cfd22020-11-27 11:10:25 +0100244 struct sk_buff_head skb_tx_cache; /* this is wmem accounted */
245 int tx_pending_data;
246 int size_goal_cache;
Peter Krystadcec37a62020-01-21 16:56:18 -0800247 struct list_head conn_list;
Paolo Abeni18b683b2020-03-27 14:48:43 -0700248 struct list_head rtx_queue;
Paolo Abenif0e6a4c2020-11-16 10:48:07 +0100249 struct mptcp_data_frag *first_pending;
Peter Krystadec3edaa2020-03-27 14:48:40 -0700250 struct list_head join_list;
Mat Martineauf870fa02020-01-21 16:56:15 -0800251 struct socket *subflow; /* outgoing connect/listener/!mp_capable */
Paolo Abeni8ab183d2020-01-21 16:56:33 -0800252 struct sock *first;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700253 struct mptcp_pm_data pm;
Florian Westphala6b118f2020-06-30 21:24:45 +0200254 struct {
255 u32 space; /* bytes copied in last measurement window */
256 u32 copied; /* bytes copied in this measurement window */
257 u64 time; /* start time of measurement window */
258 u64 rtt_us; /* last maximum rtt of subflows */
259 } rcvq_space;
Florian Westphaldf00b082021-04-15 16:44:54 -0700260
261 u32 setsockopt_seq;
Paolo Abeni20b57592021-05-25 14:23:10 -0700262 char ca_name[TCP_CA_NAME_MAX];
Mat Martineauf870fa02020-01-21 16:56:15 -0800263};
264
Paolo Abeniad80b0f2020-11-27 11:10:22 +0100265#define mptcp_lock_sock(___sk, cb) do { \
266 struct sock *__sk = (___sk); /* silence macro reuse warning */ \
267 might_sleep(); \
268 spin_lock_bh(&__sk->sk_lock.slock); \
269 if (__sk->sk_lock.owned) \
270 __lock_sock(__sk); \
271 cb; \
272 __sk->sk_lock.owned = 1; \
273 spin_unlock(&__sk->sk_lock.slock); \
274 mutex_acquire(&__sk->sk_lock.dep_map, 0, 0, _RET_IP_); \
275 local_bh_enable(); \
276} while (0)
277
Paolo Abeni87952602020-11-27 11:10:24 +0100278#define mptcp_data_lock(sk) spin_lock_bh(&(sk)->sk_lock.slock)
279#define mptcp_data_unlock(sk) spin_unlock_bh(&(sk)->sk_lock.slock)
280
Peter Krystadcec37a62020-01-21 16:56:18 -0800281#define mptcp_for_each_subflow(__msk, __subflow) \
282 list_for_each_entry(__subflow, &((__msk)->conn_list), node)
283
Florian Westphal3abc05d2021-02-04 15:23:30 -0800284static inline void msk_owned_by_me(const struct mptcp_sock *msk)
285{
286 sock_owned_by_me((const struct sock *)msk);
287}
288
Mat Martineauf870fa02020-01-21 16:56:15 -0800289static inline struct mptcp_sock *mptcp_sk(const struct sock *sk)
290{
291 return (struct mptcp_sock *)sk;
292}
293
Paolo Abeniea4ca582020-11-19 11:46:03 -0800294static inline int __mptcp_space(const struct sock *sk)
295{
Paolo Abenie3859602021-02-11 15:30:41 -0800296 return tcp_space(sk) + READ_ONCE(mptcp_sk(sk)->rmem_released);
Paolo Abeniea4ca582020-11-19 11:46:03 -0800297}
298
Paolo Abenif0e6a4c2020-11-16 10:48:07 +0100299static inline struct mptcp_data_frag *mptcp_send_head(const struct sock *sk)
300{
301 const struct mptcp_sock *msk = mptcp_sk(sk);
302
303 return READ_ONCE(msk->first_pending);
304}
305
306static inline struct mptcp_data_frag *mptcp_send_next(struct sock *sk)
307{
308 struct mptcp_sock *msk = mptcp_sk(sk);
309 struct mptcp_data_frag *cur;
310
311 cur = msk->first_pending;
312 return list_is_last(&cur->list, &msk->rtx_queue) ? NULL :
313 list_next_entry(cur, list);
314}
315
316static inline struct mptcp_data_frag *mptcp_pending_tail(const struct sock *sk)
317{
318 struct mptcp_sock *msk = mptcp_sk(sk);
319
320 if (!msk->first_pending)
321 return NULL;
322
323 if (WARN_ON_ONCE(list_empty(&msk->rtx_queue)))
324 return NULL;
325
326 return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list);
327}
328
Florian Westphal7948f6c2020-03-27 14:48:46 -0700329static inline struct mptcp_data_frag *mptcp_rtx_head(const struct sock *sk)
330{
331 struct mptcp_sock *msk = mptcp_sk(sk);
332
Paolo Abeni64b9cea2021-02-11 15:30:39 -0800333 if (msk->snd_una == READ_ONCE(msk->snd_nxt))
334 return NULL;
335
Geliang Tanga386bc52020-06-15 16:34:28 +0800336 return list_first_entry_or_null(&msk->rtx_queue, struct mptcp_data_frag, list);
Florian Westphal7948f6c2020-03-27 14:48:46 -0700337}
338
Geliang Tangd0cc2982021-06-17 16:46:08 -0700339struct csum_pseudo_header {
340 __be64 data_seq;
341 __be32 subflow_seq;
342 __be16 data_len;
343 __sum16 csum;
344};
345
Peter Krystadcec37a62020-01-21 16:56:18 -0800346struct mptcp_subflow_request_sock {
347 struct tcp_request_sock sk;
Christoph Paaschd22f4982020-01-21 16:56:32 -0800348 u16 mp_capable : 1,
Peter Krystadcec37a62020-01-21 16:56:18 -0800349 mp_join : 1,
Paolo Abenifca5c822020-04-20 16:25:06 +0200350 backup : 1;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700351 u8 local_id;
Peter Krystadf2962342020-03-27 14:48:39 -0700352 u8 remote_id;
Peter Krystadcec37a62020-01-21 16:56:18 -0800353 u64 local_key;
Peter Krystad79c09492020-01-21 16:56:20 -0800354 u64 idsn;
355 u32 token;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800356 u32 ssn_offset;
Peter Krystadf2962342020-03-27 14:48:39 -0700357 u64 thmac;
358 u32 local_nonce;
359 u32 remote_nonce;
Paolo Abeni8fd4de12020-06-17 12:08:56 +0200360 struct mptcp_sock *msk;
Paolo Abeni2c5ebd02020-06-26 19:30:00 +0200361 struct hlist_nulls_node token_node;
Peter Krystadcec37a62020-01-21 16:56:18 -0800362};
363
364static inline struct mptcp_subflow_request_sock *
365mptcp_subflow_rsk(const struct request_sock *rsk)
366{
367 return (struct mptcp_subflow_request_sock *)rsk;
368}
369
Paolo Abeni67193312020-09-14 10:01:09 +0200370enum mptcp_data_avail {
371 MPTCP_SUBFLOW_NODATA,
372 MPTCP_SUBFLOW_DATA_AVAIL,
373 MPTCP_SUBFLOW_OOO_DATA
374};
375
Paolo Abenib19bc292021-01-20 15:39:14 +0100376struct mptcp_delegated_action {
377 struct napi_struct napi;
378 struct list_head head;
379};
380
381DECLARE_PER_CPU(struct mptcp_delegated_action, mptcp_delegated_actions);
382
383#define MPTCP_DELEGATE_SEND 0
384
Peter Krystad2303f992020-01-21 16:56:17 -0800385/* MPTCP subflow context */
386struct mptcp_subflow_context {
Peter Krystadcec37a62020-01-21 16:56:18 -0800387 struct list_head node;/* conn_list of subflows */
388 u64 local_key;
389 u64 remote_key;
Peter Krystad79c09492020-01-21 16:56:20 -0800390 u64 idsn;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800391 u64 map_seq;
Christoph Paaschcc7972e2020-01-21 16:56:31 -0800392 u32 snd_isn;
Peter Krystad79c09492020-01-21 16:56:20 -0800393 u32 token;
Mat Martineau6d0060f2020-01-21 16:56:23 -0800394 u32 rel_write_seq;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800395 u32 map_subflow_seq;
396 u32 ssn_offset;
397 u32 map_data_len;
Peter Krystadcec37a62020-01-21 16:56:18 -0800398 u32 request_mptcp : 1, /* send MP_CAPABLE */
Peter Krystadec3edaa2020-03-27 14:48:40 -0700399 request_join : 1, /* send MP_JOIN */
400 request_bkup : 1,
Peter Krystadcec37a62020-01-21 16:56:18 -0800401 mp_capable : 1, /* remote is MPTCP capable */
Peter Krystadf2962342020-03-27 14:48:39 -0700402 mp_join : 1, /* remote is JOINing */
Paolo Abeni0be534f2020-03-19 11:06:30 +0100403 fully_established : 1, /* path validated */
Peter Krystadf2962342020-03-27 14:48:39 -0700404 pm_notified : 1, /* PM hook called for established status */
Mat Martineau648ef4b2020-01-21 16:56:24 -0800405 conn_finished : 1,
406 map_valid : 1,
Christoph Paaschd22f4982020-01-21 16:56:32 -0800407 mpc_map : 1,
Peter Krystadf2962342020-03-27 14:48:39 -0700408 backup : 1,
Geliang Tang06706542021-01-08 16:47:57 -0800409 send_mp_prio : 1,
Christoph Paaschd22f4982020-01-21 16:56:32 -0800410 rx_eof : 1,
Paolo Abenie16163b2020-11-16 10:48:09 +0100411 can_ack : 1, /* only after processing the remote a key */
412 disposable : 1; /* ctx can be free at ulp release time */
Paolo Abeni67193312020-09-14 10:01:09 +0200413 enum mptcp_data_avail data_avail;
Peter Krystadf2962342020-03-27 14:48:39 -0700414 u32 remote_nonce;
415 u64 thmac;
416 u32 local_nonce;
Peter Krystadec3edaa2020-03-27 14:48:40 -0700417 u32 remote_token;
418 u8 hmac[MPTCPOPT_HMAC_LEN];
Peter Krystadf2962342020-03-27 14:48:39 -0700419 u8 local_id;
420 u8 remote_id;
Florian Westphaldc87efd2021-04-01 16:19:44 -0700421 u8 reset_seen:1;
422 u8 reset_transient:1;
423 u8 reset_reason:4;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800424
Paolo Abenib19bc292021-01-20 15:39:14 +0100425 long delegated_status;
426 struct list_head delegated_node; /* link into delegated_action, protected by local BH */
427
Florian Westphaldf00b082021-04-15 16:44:54 -0700428 u32 setsockopt_seq;
429
Peter Krystad2303f992020-01-21 16:56:17 -0800430 struct sock *tcp_sock; /* tcp sk backpointer */
431 struct sock *conn; /* parent mptcp_sock */
Peter Krystadcec37a62020-01-21 16:56:18 -0800432 const struct inet_connection_sock_af_ops *icsk_af_ops;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800433 void (*tcp_data_ready)(struct sock *sk);
434 void (*tcp_state_change)(struct sock *sk);
435 void (*tcp_write_space)(struct sock *sk);
Paolo Abeni15cc1042021-02-11 15:30:37 -0800436 void (*tcp_error_report)(struct sock *sk);
Mat Martineau648ef4b2020-01-21 16:56:24 -0800437
Peter Krystad2303f992020-01-21 16:56:17 -0800438 struct rcu_head rcu;
439};
440
441static inline struct mptcp_subflow_context *
442mptcp_subflow_ctx(const struct sock *sk)
443{
444 struct inet_connection_sock *icsk = inet_csk(sk);
445
446 /* Use RCU on icsk_ulp_data only for sock diag code */
447 return (__force struct mptcp_subflow_context *)icsk->icsk_ulp_data;
448}
449
450static inline struct sock *
451mptcp_subflow_tcp_sock(const struct mptcp_subflow_context *subflow)
452{
453 return subflow->tcp_sock;
454}
455
Mat Martineau648ef4b2020-01-21 16:56:24 -0800456static inline u64
457mptcp_subflow_get_map_offset(const struct mptcp_subflow_context *subflow)
458{
459 return tcp_sk(mptcp_subflow_tcp_sock(subflow))->copied_seq -
460 subflow->ssn_offset -
461 subflow->map_subflow_seq;
462}
463
464static inline u64
465mptcp_subflow_get_mapped_dsn(const struct mptcp_subflow_context *subflow)
466{
467 return subflow->map_seq + mptcp_subflow_get_map_offset(subflow);
468}
469
Paolo Abeni0397c6d2020-11-19 11:45:58 -0800470static inline void mptcp_add_pending_subflow(struct mptcp_sock *msk,
471 struct mptcp_subflow_context *subflow)
472{
473 sock_hold(mptcp_subflow_tcp_sock(subflow));
474 spin_lock_bh(&msk->join_list_lock);
475 list_add_tail(&subflow->node, &msk->join_list);
476 spin_unlock_bh(&msk->join_list_lock);
477}
478
Paolo Abenib19bc292021-01-20 15:39:14 +0100479void mptcp_subflow_process_delegated(struct sock *ssk);
480
481static inline void mptcp_subflow_delegate(struct mptcp_subflow_context *subflow)
482{
483 struct mptcp_delegated_action *delegated;
484 bool schedule;
485
486 /* The implied barrier pairs with mptcp_subflow_delegated_done(), and
487 * ensures the below list check sees list updates done prior to status
488 * bit changes
489 */
490 if (!test_and_set_bit(MPTCP_DELEGATE_SEND, &subflow->delegated_status)) {
491 /* still on delegated list from previous scheduling */
492 if (!list_empty(&subflow->delegated_node))
493 return;
494
495 /* the caller held the subflow bh socket lock */
496 lockdep_assert_in_softirq();
497
498 delegated = this_cpu_ptr(&mptcp_delegated_actions);
499 schedule = list_empty(&delegated->head);
500 list_add_tail(&subflow->delegated_node, &delegated->head);
501 sock_hold(mptcp_subflow_tcp_sock(subflow));
502 if (schedule)
503 napi_schedule(&delegated->napi);
504 }
505}
506
507static inline struct mptcp_subflow_context *
508mptcp_subflow_delegated_next(struct mptcp_delegated_action *delegated)
509{
510 struct mptcp_subflow_context *ret;
511
512 if (list_empty(&delegated->head))
513 return NULL;
514
515 ret = list_first_entry(&delegated->head, struct mptcp_subflow_context, delegated_node);
516 list_del_init(&ret->delegated_node);
517 return ret;
518}
519
520static inline bool mptcp_subflow_has_delegated_action(const struct mptcp_subflow_context *subflow)
521{
522 return test_bit(MPTCP_DELEGATE_SEND, &subflow->delegated_status);
523}
524
525static inline void mptcp_subflow_delegated_done(struct mptcp_subflow_context *subflow)
526{
527 /* pairs with mptcp_subflow_delegate, ensures delegate_node is updated before
528 * touching the status bit
529 */
530 smp_wmb();
531 clear_bit(MPTCP_DELEGATE_SEND, &subflow->delegated_status);
532}
533
Mat Martineau648ef4b2020-01-21 16:56:24 -0800534int mptcp_is_enabled(struct net *net);
Geliang Tang93f323b2020-11-03 11:05:07 -0800535unsigned int mptcp_get_add_addr_timeout(struct net *net);
Geliang Tang752e9062021-06-17 16:46:07 -0700536static inline int mptcp_is_checksum_enabled(struct net *net) { return false; }
Paolo Abenib93df082020-07-23 13:02:32 +0200537void mptcp_subflow_fully_established(struct mptcp_subflow_context *subflow,
538 struct mptcp_options_received *mp_opt);
Mat Martineau648ef4b2020-01-21 16:56:24 -0800539bool mptcp_subflow_data_available(struct sock *sk);
Paolo Abenid39dcec2020-06-26 19:29:59 +0200540void __init mptcp_subflow_init(void);
Geliang Tangd0876b22020-09-24 08:29:49 +0800541void mptcp_subflow_shutdown(struct sock *sk, struct sock *ssk, int how);
Florian Westphala141e022021-02-12 15:59:55 -0800542void mptcp_close_ssk(struct sock *sk, struct sock *ssk,
543 struct mptcp_subflow_context *subflow);
Paolo Abenid5824842020-10-09 19:00:00 +0200544void mptcp_subflow_reset(struct sock *ssk);
Paolo Abeni866f26f2021-01-20 15:39:10 +0100545void mptcp_sock_graft(struct sock *sk, struct socket *parent);
Geliang Tang1729cf12021-02-01 15:09:12 -0800546struct socket *__mptcp_nmpc_socket(const struct mptcp_sock *msk);
Peter Krystadec3edaa2020-03-27 14:48:40 -0700547
548/* called with sk socket lock held */
Paolo Abenief0da3b2020-09-14 10:01:15 +0200549int __mptcp_subflow_connect(struct sock *sk, const struct mptcp_addr_info *loc,
Geliang Tangdaa83ab2021-04-06 17:15:57 -0700550 const struct mptcp_addr_info *remote,
551 u8 flags, int ifindex);
Peter Krystad2303f992020-01-21 16:56:17 -0800552int mptcp_subflow_create_socket(struct sock *sk, struct socket **new_sock);
Geliang Tang1729cf12021-02-01 15:09:12 -0800553void mptcp_info2sockaddr(const struct mptcp_addr_info *info,
554 struct sockaddr_storage *addr,
555 unsigned short family);
Peter Krystad2303f992020-01-21 16:56:17 -0800556
Geliang Tang43f11402021-04-16 15:38:03 -0700557static inline bool mptcp_subflow_active(struct mptcp_subflow_context *subflow)
558{
559 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
560
561 /* can't send if JOIN hasn't completed yet (i.e. is usable for mptcp) */
562 if (subflow->request_join && !subflow->fully_established)
563 return false;
564
565 /* only send if our side has not closed yet */
566 return ((1 << ssk->sk_state) & (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT));
567}
568
Mat Martineau648ef4b2020-01-21 16:56:24 -0800569static inline void mptcp_subflow_tcp_fallback(struct sock *sk,
570 struct mptcp_subflow_context *ctx)
571{
572 sk->sk_data_ready = ctx->tcp_data_ready;
573 sk->sk_state_change = ctx->tcp_state_change;
574 sk->sk_write_space = ctx->tcp_write_space;
Paolo Abeni15cc1042021-02-11 15:30:37 -0800575 sk->sk_error_report = ctx->tcp_error_report;
Mat Martineau648ef4b2020-01-21 16:56:24 -0800576
577 inet_csk(sk)->icsk_af_ops = ctx->icsk_af_ops;
578}
579
Paolo Abenid39dcec2020-06-26 19:29:59 +0200580void __init mptcp_proto_init(void);
Matthieu Baerts784325e2020-01-21 16:56:28 -0800581#if IS_ENABLED(CONFIG_MPTCP_IPV6)
Paolo Abenid39dcec2020-06-26 19:29:59 +0200582int __init mptcp_proto_v6_init(void);
Matthieu Baerts784325e2020-01-21 16:56:28 -0800583#endif
Mat Martineau648ef4b2020-01-21 16:56:24 -0800584
Paolo Abenifca5c822020-04-20 16:25:06 +0200585struct sock *mptcp_sk_clone(const struct sock *sk,
Paolo Abenicfde1412020-04-30 15:01:52 +0200586 const struct mptcp_options_received *mp_opt,
Paolo Abenifca5c822020-04-20 16:25:06 +0200587 struct request_sock *req);
Peter Krystadcec37a62020-01-21 16:56:18 -0800588void mptcp_get_options(const struct sk_buff *skb,
Paolo Abenicfde1412020-04-30 15:01:52 +0200589 struct mptcp_options_received *mp_opt);
Peter Krystadcec37a62020-01-21 16:56:18 -0800590
591void mptcp_finish_connect(struct sock *sk);
Paolo Abenib93df082020-07-23 13:02:32 +0200592static inline bool mptcp_is_fully_established(struct sock *sk)
593{
594 return inet_sk_state_load(sk) == TCP_ESTABLISHED &&
595 READ_ONCE(mptcp_sk(sk)->fully_established);
596}
Florian Westphala6b118f2020-06-30 21:24:45 +0200597void mptcp_rcv_space_init(struct mptcp_sock *msk, const struct sock *ssk);
Florian Westphal2e522132020-02-26 10:14:51 +0100598void mptcp_data_ready(struct sock *sk, struct sock *ssk);
Peter Krystadf2962342020-03-27 14:48:39 -0700599bool mptcp_finish_join(struct sock *sk);
Paolo Abeniba8f48f2020-11-16 10:48:05 +0100600bool mptcp_schedule_work(struct sock *sk);
Paolo Abeni0abdde82021-04-15 16:44:51 -0700601int mptcp_setsockopt(struct sock *sk, int level, int optname,
602 sockptr_t optval, unsigned int optlen);
603int mptcp_getsockopt(struct sock *sk, int level, int optname,
604 char __user *optval, int __user *option);
605
Paolo Abeni219d0492020-12-16 12:48:34 +0100606void __mptcp_check_push(struct sock *sk, struct sock *ssk);
Paolo Abeni7439d682020-11-27 11:10:26 +0100607void __mptcp_data_acked(struct sock *sk);
Paolo Abeni15cc1042021-02-11 15:30:37 -0800608void __mptcp_error_report(struct sock *sk);
Florian Westphal59832e22020-04-02 13:44:52 +0200609void mptcp_subflow_eof(struct sock *sk);
Mat Martineau1a49b2c2020-09-29 15:08:20 -0700610bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq, bool use_64bit);
Geliang Tang84dfe362020-11-19 11:46:00 -0800611void __mptcp_flush_join_list(struct mptcp_sock *msk);
Paolo Abenie16163b2020-11-16 10:48:09 +0100612static inline bool mptcp_data_fin_enabled(const struct mptcp_sock *msk)
613{
614 return READ_ONCE(msk->snd_data_fin_enable) &&
615 READ_ONCE(msk->write_seq) == READ_ONCE(msk->snd_nxt);
616}
617
Paolo Abeni5cf92bb2021-01-20 15:39:11 +0100618static inline bool mptcp_propagate_sndbuf(struct sock *sk, struct sock *ssk)
619{
620 if ((sk->sk_userlocks & SOCK_SNDBUF_LOCK) || ssk->sk_sndbuf <= READ_ONCE(sk->sk_sndbuf))
621 return false;
622
623 WRITE_ONCE(sk->sk_sndbuf, ssk->sk_sndbuf);
624 return true;
625}
626
627static inline void mptcp_write_space(struct sock *sk)
628{
629 if (sk_stream_is_writeable(sk)) {
630 /* pairs with memory barrier in mptcp_poll */
631 smp_mb();
632 if (test_and_clear_bit(MPTCP_NOSPACE, &mptcp_sk(sk)->flags))
633 sk_stream_write_space(sk);
634 }
635}
636
Geliang Tang5c8c1642020-09-24 08:29:57 +0800637void mptcp_destroy_common(struct mptcp_sock *msk);
Peter Krystadcec37a62020-01-21 16:56:18 -0800638
Jianguo Wuc68a0cd2021-05-27 16:54:25 -0700639#define MPTCP_TOKEN_MAX_RETRIES 4
640
Paolo Abeni2c5ebd02020-06-26 19:30:00 +0200641void __init mptcp_token_init(void);
642static inline void mptcp_token_init_request(struct request_sock *req)
643{
644 mptcp_subflow_rsk(req)->token_node.pprev = NULL;
645}
646
Peter Krystad79c09492020-01-21 16:56:20 -0800647int mptcp_token_new_request(struct request_sock *req);
Paolo Abeni2c5ebd02020-06-26 19:30:00 +0200648void mptcp_token_destroy_request(struct request_sock *req);
Peter Krystad79c09492020-01-21 16:56:20 -0800649int mptcp_token_new_connect(struct sock *sk);
Paolo Abeni2c5ebd02020-06-26 19:30:00 +0200650void mptcp_token_accept(struct mptcp_subflow_request_sock *r,
651 struct mptcp_sock *msk);
Florian Westphalc83a47e2020-07-30 21:25:54 +0200652bool mptcp_token_exists(u32 token);
Peter Krystadf2962342020-03-27 14:48:39 -0700653struct mptcp_sock *mptcp_token_get_sock(u32 token);
Paolo Abeni96d890d2020-07-09 15:12:40 +0200654struct mptcp_sock *mptcp_token_iter_next(const struct net *net, long *s_slot,
655 long *s_num);
Paolo Abeni2c5ebd02020-06-26 19:30:00 +0200656void mptcp_token_destroy(struct mptcp_sock *msk);
Peter Krystad79c09492020-01-21 16:56:20 -0800657
658void mptcp_crypto_key_sha(u64 key, u32 *token, u64 *idsn);
Peter Krystad79c09492020-01-21 16:56:20 -0800659
Peter Krystad3df523a2020-03-27 14:48:37 -0700660void mptcp_crypto_hmac_sha(u64 key1, u64 key2, u8 *msg, int len, void *hmac);
Peter Krystad79c09492020-01-21 16:56:20 -0800661
Paolo Abenid39dcec2020-06-26 19:29:59 +0200662void __init mptcp_pm_init(void);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700663void mptcp_pm_data_init(struct mptcp_sock *msk);
Florian Westphal6c714f12021-02-12 15:59:58 -0800664void mptcp_pm_new_connection(struct mptcp_sock *msk, const struct sock *ssk, int server_side);
665void mptcp_pm_fully_established(struct mptcp_sock *msk, const struct sock *ssk, gfp_t gfp);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700666bool mptcp_pm_allow_new_subflow(struct mptcp_sock *msk);
667void mptcp_pm_connection_closed(struct mptcp_sock *msk);
Geliang Tang625352002021-03-26 11:26:33 -0700668void mptcp_pm_subflow_established(struct mptcp_sock *msk);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700669void mptcp_pm_subflow_closed(struct mptcp_sock *msk, u8 id);
670void mptcp_pm_add_addr_received(struct mptcp_sock *msk,
671 const struct mptcp_addr_info *addr);
Geliang Tang557963c2021-03-26 11:26:38 -0700672void mptcp_pm_add_addr_echoed(struct mptcp_sock *msk,
673 struct mptcp_addr_info *addr);
Geliang Tang84dfe362020-11-19 11:46:00 -0800674void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk);
Geliang Tangb46a0232021-03-26 11:26:41 -0700675void mptcp_pm_nl_addr_send_ack(struct mptcp_sock *msk);
Geliang Tang5c4a8242021-03-12 17:16:13 -0800676void mptcp_pm_rm_addr_received(struct mptcp_sock *msk,
677 const struct mptcp_rm_list *rm_list);
Geliang Tang40453a52021-01-08 16:47:58 -0800678void mptcp_pm_mp_prio_received(struct sock *sk, u8 bkup);
Geliang Tang06706542021-01-08 16:47:57 -0800679int mptcp_pm_nl_mp_prio_send_ack(struct mptcp_sock *msk,
680 struct mptcp_addr_info *addr,
681 u8 bkup);
Geliang Tangb6c08382020-09-24 08:29:54 +0800682void mptcp_pm_free_anno_list(struct mptcp_sock *msk);
Geliang Tang5bc56382021-02-01 15:09:15 -0800683bool mptcp_pm_sport_in_anno_list(struct mptcp_sock *msk, const struct sock *sk);
Geliang Tang00cfd772020-09-24 08:30:02 +0800684struct mptcp_pm_add_entry *
685mptcp_pm_del_add_timer(struct mptcp_sock *msk,
Davide Carattid58300c2021-05-25 14:23:13 -0700686 struct mptcp_addr_info *addr, bool check_id);
Geliang Tangd88c4762021-03-26 11:26:37 -0700687struct mptcp_pm_add_entry *
688mptcp_lookup_anno_list_by_saddr(struct mptcp_sock *msk,
689 struct mptcp_addr_info *addr);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700690
691int mptcp_pm_announce_addr(struct mptcp_sock *msk,
Geliang Tang6a6c05a2020-09-24 08:29:50 +0800692 const struct mptcp_addr_info *addr,
Geliang Tangf7efc772021-03-26 11:26:31 -0700693 bool echo);
Geliang Tangcbde2782021-03-12 17:16:12 -0800694int mptcp_pm_remove_addr(struct mptcp_sock *msk, const struct mptcp_rm_list *rm_list);
Geliang Tangddd14bb2021-03-12 17:16:16 -0800695int mptcp_pm_remove_subflow(struct mptcp_sock *msk, const struct mptcp_rm_list *rm_list);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700696
Florian Westphalb911c972021-02-12 16:00:01 -0800697void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk,
698 const struct sock *ssk, gfp_t gfp);
699void mptcp_event_addr_announced(const struct mptcp_sock *msk, const struct mptcp_addr_info *info);
700void mptcp_event_addr_removed(const struct mptcp_sock *msk, u8 id);
701
Geliang Tangf643b802020-09-24 08:29:47 +0800702static inline bool mptcp_pm_should_add_signal(struct mptcp_sock *msk)
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700703{
Geliang Tang13ad9f02020-12-09 15:51:27 -0800704 return READ_ONCE(msk->pm.addr_signal) & BIT(MPTCP_ADD_ADDR_SIGNAL);
Geliang Tangd91d3222020-11-19 11:45:59 -0800705}
706
707static inline bool mptcp_pm_should_add_signal_echo(struct mptcp_sock *msk)
708{
Geliang Tang13ad9f02020-12-09 15:51:27 -0800709 return READ_ONCE(msk->pm.addr_signal) & BIT(MPTCP_ADD_ADDR_ECHO);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700710}
711
Geliang Tang84dfe362020-11-19 11:46:00 -0800712static inline bool mptcp_pm_should_add_signal_ipv6(struct mptcp_sock *msk)
713{
Geliang Tang13ad9f02020-12-09 15:51:27 -0800714 return READ_ONCE(msk->pm.addr_signal) & BIT(MPTCP_ADD_ADDR_IPV6);
Geliang Tang84dfe362020-11-19 11:46:00 -0800715}
716
Geliang Tang4a2777a82020-12-09 15:51:22 -0800717static inline bool mptcp_pm_should_add_signal_port(struct mptcp_sock *msk)
718{
Geliang Tang13ad9f02020-12-09 15:51:27 -0800719 return READ_ONCE(msk->pm.addr_signal) & BIT(MPTCP_ADD_ADDR_PORT);
Geliang Tang4a2777a82020-12-09 15:51:22 -0800720}
721
Geliang Tang5cb104a2020-09-24 08:29:48 +0800722static inline bool mptcp_pm_should_rm_signal(struct mptcp_sock *msk)
723{
Geliang Tang13ad9f02020-12-09 15:51:27 -0800724 return READ_ONCE(msk->pm.addr_signal) & BIT(MPTCP_RM_ADDR_SIGNAL);
Geliang Tang5cb104a2020-09-24 08:29:48 +0800725}
726
Geliang Tang4a2777a82020-12-09 15:51:22 -0800727static inline unsigned int mptcp_add_addr_len(int family, bool echo, bool port)
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700728{
Geliang Tang2ec72fa2020-12-09 15:51:21 -0800729 u8 len = TCPOLEN_MPTCP_ADD_ADDR_BASE;
730
731 if (family == AF_INET6)
732 len = TCPOLEN_MPTCP_ADD_ADDR6_BASE;
733 if (!echo)
734 len += MPTCPOPT_THMAC_LEN;
Davide Caratti27ab92d2021-03-08 10:00:04 +0100735 /* account for 2 trailing 'nop' options */
Geliang Tang4a2777a82020-12-09 15:51:22 -0800736 if (port)
Davide Caratti27ab92d2021-03-08 10:00:04 +0100737 len += TCPOLEN_MPTCP_PORT_LEN + TCPOLEN_MPTCP_PORT_ALIGN;
Geliang Tang2ec72fa2020-12-09 15:51:21 -0800738
739 return len;
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700740}
741
Geliang Tang6445e172021-03-12 17:16:11 -0800742static inline int mptcp_rm_addr_len(const struct mptcp_rm_list *rm_list)
743{
744 if (rm_list->nr == 0 || rm_list->nr > MPTCP_RM_IDS_MAX)
745 return -EINVAL;
746
747 return TCPOLEN_MPTCP_RM_ADDR_BASE + roundup(rm_list->nr - 1, 4) + 1;
748}
749
Geliang Tangf643b802020-09-24 08:29:47 +0800750bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
Geliang Tang4a2777a82020-12-09 15:51:22 -0800751 struct mptcp_addr_info *saddr, bool *echo, bool *port);
Geliang Tang5cb104a2020-09-24 08:29:48 +0800752bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
Geliang Tang6445e172021-03-12 17:16:11 -0800753 struct mptcp_rm_list *rm_list);
Peter Krystad1b1c7a02020-03-27 14:48:38 -0700754int mptcp_pm_get_local_id(struct mptcp_sock *msk, struct sock_common *skc);
755
Paolo Abenid39dcec2020-06-26 19:29:59 +0200756void __init mptcp_pm_nl_init(void);
Paolo Abeni01cacb02020-03-27 14:48:51 -0700757void mptcp_pm_nl_data_init(struct mptcp_sock *msk);
Florian Westphale9801432021-02-12 15:59:54 -0800758void mptcp_pm_nl_work(struct mptcp_sock *msk);
Geliang Tangddd14bb2021-03-12 17:16:16 -0800759void mptcp_pm_nl_rm_subflow_received(struct mptcp_sock *msk,
760 const struct mptcp_rm_list *rm_list);
Paolo Abeni01cacb02020-03-27 14:48:51 -0700761int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk, struct sock_common *skc);
Geliang Tanga914e582021-02-01 15:09:07 -0800762unsigned int mptcp_pm_get_add_addr_signal_max(struct mptcp_sock *msk);
763unsigned int mptcp_pm_get_add_addr_accept_max(struct mptcp_sock *msk);
764unsigned int mptcp_pm_get_subflows_max(struct mptcp_sock *msk);
Geliang Tang0caf3ad2021-02-12 16:52:02 -0800765unsigned int mptcp_pm_get_local_addr_max(struct mptcp_sock *msk);
Paolo Abeni01cacb02020-03-27 14:48:51 -0700766
Florian Westphal78962482021-04-15 16:44:53 -0700767int mptcp_setsockopt(struct sock *sk, int level, int optname,
768 sockptr_t optval, unsigned int optlen);
769
770void mptcp_sockopt_sync(struct mptcp_sock *msk, struct sock *ssk);
771void mptcp_sockopt_sync_all(struct mptcp_sock *msk);
772
Florian Westphaldc87efd2021-04-01 16:19:44 -0700773static inline struct mptcp_ext *mptcp_get_ext(const struct sk_buff *skb)
Mat Martineau6d0060f2020-01-21 16:56:23 -0800774{
775 return (struct mptcp_ext *)skb_ext_find(skb, SKB_EXT_MPTCP);
776}
777
Davide Caratti5147dfb2020-03-27 14:48:49 -0700778void mptcp_diag_subflow_init(struct tcp_ulp_ops *ops);
779
Paolo Abenid5f49192020-09-14 10:01:17 +0200780static inline bool __mptcp_check_fallback(const struct mptcp_sock *msk)
Davide Carattie1ff9e82020-06-29 22:26:20 +0200781{
782 return test_bit(MPTCP_FALLBACK_DONE, &msk->flags);
783}
784
Paolo Abenid5f49192020-09-14 10:01:17 +0200785static inline bool mptcp_check_fallback(const struct sock *sk)
Davide Carattie1ff9e82020-06-29 22:26:20 +0200786{
787 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
788 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
789
790 return __mptcp_check_fallback(msk);
791}
792
793static inline void __mptcp_do_fallback(struct mptcp_sock *msk)
794{
795 if (test_bit(MPTCP_FALLBACK_DONE, &msk->flags)) {
796 pr_debug("TCP fallback already done (msk=%p)", msk);
797 return;
798 }
799 set_bit(MPTCP_FALLBACK_DONE, &msk->flags);
800}
801
802static inline void mptcp_do_fallback(struct sock *sk)
803{
804 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
805 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
806
807 __mptcp_do_fallback(msk);
808}
809
810#define pr_fallback(a) pr_debug("%s:fallback to TCP (msk=%p)", __func__, a)
811
Davide Caratti8fd73802020-06-29 22:26:21 +0200812static inline bool subflow_simultaneous_connect(struct sock *sk)
813{
814 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
815 struct sock *parent = subflow->conn;
816
817 return sk->sk_state == TCP_ESTABLISHED &&
818 !mptcp_sk(parent)->pm.server_side &&
819 !subflow->conn_finished;
820}
821
Florian Westphal9466a1c2020-07-30 21:25:56 +0200822#ifdef CONFIG_SYN_COOKIES
823void subflow_init_req_cookie_join_save(const struct mptcp_subflow_request_sock *subflow_req,
824 struct sk_buff *skb);
825bool mptcp_token_join_cookie_init_state(struct mptcp_subflow_request_sock *subflow_req,
826 struct sk_buff *skb);
827void __init mptcp_join_cookie_init(void);
828#else
829static inline void
830subflow_init_req_cookie_join_save(const struct mptcp_subflow_request_sock *subflow_req,
831 struct sk_buff *skb) {}
832static inline bool
833mptcp_token_join_cookie_init_state(struct mptcp_subflow_request_sock *subflow_req,
834 struct sk_buff *skb)
835{
836 return false;
837}
838
839static inline void mptcp_join_cookie_init(void) {}
840#endif
841
Mat Martineauf870fa02020-01-21 16:56:15 -0800842#endif /* __MPTCP_PROTOCOL_H */