Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /* Multipath TCP
3 : : *
4 : : * Copyright (c) 2019, Intel Corporation.
5 : : */
6 : : #define pr_fmt(fmt) "MPTCP: " fmt
7 : :
8 : : #include <linux/kernel.h>
9 : : #include <net/mptcp.h>
10 : : #include "protocol.h"
11 : :
12 : : #include "mib.h"
13 : :
14 : : /* path manager command handlers */
15 : :
16 : 754 : int mptcp_pm_announce_addr(struct mptcp_sock *msk,
17 : : const struct mptcp_addr_info *addr,
18 : : bool echo)
19 : : {
20 : 754 : u8 add_addr = READ_ONCE(msk->pm.addr_signal);
21 : :
22 [ - + ]: 754 : pr_debug("msk=%p, local_id=%d, echo=%d\n", msk, addr->id, echo);
23 : :
24 [ + - + - : 1131 : lockdep_assert_held(&msk->pm.lock);
- + ]
25 : :
26 [ - + ]: 754 : if (add_addr &
27 [ + + ]: 754 : (echo ? BIT(MPTCP_ADD_ADDR_ECHO) : BIT(MPTCP_ADD_ADDR_SIGNAL))) {
28 [ # # # # ]: 0 : MPTCP_INC_STATS(sock_net((struct sock *)msk),
29 : : echo ? MPTCP_MIB_ECHOADDTXDROP : MPTCP_MIB_ADDADDRTXDROP);
30 : 0 : return -EINVAL;
31 : : }
32 : :
33 [ + + ]: 754 : if (echo) {
34 : 350 : msk->pm.remote = *addr;
35 : 350 : add_addr |= BIT(MPTCP_ADD_ADDR_ECHO);
36 : : } else {
37 : 404 : msk->pm.local = *addr;
38 : 404 : add_addr |= BIT(MPTCP_ADD_ADDR_SIGNAL);
39 : : }
40 : 754 : WRITE_ONCE(msk->pm.addr_signal, add_addr);
41 : 754 : return 0;
42 : : }
43 : :
44 : 106 : int mptcp_pm_remove_addr(struct mptcp_sock *msk, const struct mptcp_rm_list *rm_list)
45 : : {
46 : 106 : u8 rm_addr = READ_ONCE(msk->pm.addr_signal);
47 : :
48 [ - + ]: 106 : pr_debug("msk=%p, rm_list_nr=%d\n", msk, rm_list->nr);
49 : :
50 [ - + ]: 106 : if (rm_addr) {
51 : 0 : MPTCP_ADD_STATS(sock_net((struct sock *)msk),
52 : 0 : MPTCP_MIB_RMADDRTXDROP, rm_list->nr);
53 : 0 : return -EINVAL;
54 : : }
55 : :
56 : 106 : msk->pm.rm_list_tx = *rm_list;
57 : 106 : rm_addr |= BIT(MPTCP_RM_ADDR_SIGNAL);
58 : 106 : WRITE_ONCE(msk->pm.addr_signal, rm_addr);
59 : 106 : mptcp_pm_nl_addr_send_ack(msk);
60 : 106 : return 0;
61 : : }
62 : :
63 : : /* path manager event handlers */
64 : :
65 : 2268 : void mptcp_pm_new_connection(struct mptcp_sock *msk, const struct sock *ssk, int server_side)
66 : : {
67 : 2268 : struct mptcp_pm_data *pm = &msk->pm;
68 : :
69 [ - + ]: 2268 : pr_debug("msk=%p, token=%u side=%d\n", msk, READ_ONCE(msk->token), server_side);
70 : :
71 : 2268 : WRITE_ONCE(pm->server_side, server_side);
72 : 2268 : mptcp_event(MPTCP_EVENT_CREATED, msk, ssk, GFP_ATOMIC);
73 : 2268 : }
74 : :
75 : 486 : bool mptcp_pm_allow_new_subflow(struct mptcp_sock *msk)
76 : : {
77 : 486 : struct mptcp_pm_data *pm = &msk->pm;
78 : 486 : unsigned int subflows_max;
79 : 486 : int ret = 0;
80 : :
81 [ + + ]: 486 : if (mptcp_pm_is_userspace(msk)) {
82 [ + - ]: 22 : if (mptcp_userspace_pm_active(msk)) {
83 : 22 : spin_lock_bh(&pm->lock);
84 : 22 : pm->subflows++;
85 : 22 : spin_unlock_bh(&pm->lock);
86 : 22 : return true;
87 : : }
88 : : return false;
89 : : }
90 : :
91 : 464 : subflows_max = mptcp_pm_get_subflows_max(msk);
92 : :
93 [ - + - - ]: 464 : pr_debug("msk=%p subflows=%d max=%d allow=%d\n", msk, pm->subflows,
94 : : subflows_max, READ_ONCE(pm->accept_subflow));
95 : :
96 : : /* try to avoid acquiring the lock below */
97 [ - + - + ]: 464 : if (!READ_ONCE(pm->accept_subflow))
98 : : return false;
99 : :
100 : 464 : spin_lock_bh(&pm->lock);
101 [ + + + - ]: 464 : if (READ_ONCE(pm->accept_subflow)) {
102 : 464 : ret = pm->subflows < subflows_max;
103 [ - + + + ]: 464 : if (ret && ++pm->subflows == subflows_max)
104 : 182 : WRITE_ONCE(pm->accept_subflow, false);
105 : : }
106 : 464 : spin_unlock_bh(&pm->lock);
107 : :
108 : 464 : return ret;
109 : : }
110 : :
111 : : /* return true if the new status bit is currently cleared, that is, this event
112 : : * can be server, eventually by an already scheduled work
113 : : */
114 : 1352 : static bool mptcp_pm_schedule_work(struct mptcp_sock *msk,
115 : : enum mptcp_pm_status new_status)
116 : : {
117 [ - + - - ]: 1352 : pr_debug("msk=%p status=%x new=%lx\n", msk, msk->pm.status,
118 : : BIT(new_status));
119 [ + + + + ]: 1352 : if (msk->pm.status & BIT(new_status))
120 : : return false;
121 : :
122 [ - + ]: 1216 : msk->pm.status |= BIT(new_status);
123 : 1216 : mptcp_schedule_work((struct sock *)msk);
124 : 1216 : return true;
125 : : }
126 : :
127 : 2208 : void mptcp_pm_fully_established(struct mptcp_sock *msk, const struct sock *ssk)
128 : : {
129 : 2208 : struct mptcp_pm_data *pm = &msk->pm;
130 : 2208 : bool announce = false;
131 : :
132 [ - + ]: 2208 : pr_debug("msk=%p\n", msk);
133 : :
134 : 2208 : spin_lock_bh(&pm->lock);
135 : :
136 : : /* mptcp_pm_fully_established() can be invoked by multiple
137 : : * racing paths - accept() and check_fully_established()
138 : : * be sure to serve this event only once.
139 : : */
140 [ + + + + ]: 2208 : if (READ_ONCE(pm->work_pending) &&
141 [ + - ]: 424 : !(msk->pm.status & BIT(MPTCP_PM_ALREADY_ESTABLISHED)))
142 : 424 : mptcp_pm_schedule_work(msk, MPTCP_PM_ESTABLISHED);
143 : :
144 [ + - ]: 2208 : if ((msk->pm.status & BIT(MPTCP_PM_ALREADY_ESTABLISHED)) == 0)
145 : 2208 : announce = true;
146 : :
147 : 2208 : msk->pm.status |= BIT(MPTCP_PM_ALREADY_ESTABLISHED);
148 : 2208 : spin_unlock_bh(&pm->lock);
149 : :
150 [ + - ]: 2208 : if (announce)
151 : 2208 : mptcp_event(MPTCP_EVENT_ESTABLISHED, msk, ssk, GFP_ATOMIC);
152 : 2208 : }
153 : :
154 : 3670 : void mptcp_pm_connection_closed(struct mptcp_sock *msk)
155 : : {
156 [ - + ]: 3670 : pr_debug("msk=%p\n", msk);
157 : :
158 [ + + ]: 3670 : if (msk->token)
159 : 2270 : mptcp_event(MPTCP_EVENT_CLOSED, msk, NULL, GFP_KERNEL);
160 : 3670 : }
161 : :
162 : 958 : void mptcp_pm_subflow_established(struct mptcp_sock *msk)
163 : : {
164 : 958 : struct mptcp_pm_data *pm = &msk->pm;
165 : :
166 [ - + ]: 958 : pr_debug("msk=%p\n", msk);
167 : :
168 [ + + + + ]: 958 : if (!READ_ONCE(pm->work_pending))
169 : : return;
170 : :
171 : 243 : spin_lock_bh(&pm->lock);
172 : :
173 [ + + + - ]: 243 : if (READ_ONCE(pm->work_pending))
174 : 243 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
175 : :
176 : 243 : spin_unlock_bh(&pm->lock);
177 : : }
178 : :
179 : 723 : void mptcp_pm_subflow_check_next(struct mptcp_sock *msk,
180 : : const struct mptcp_subflow_context *subflow)
181 : : {
182 : 723 : struct mptcp_pm_data *pm = &msk->pm;
183 : 723 : bool update_subflows;
184 : :
185 : 723 : update_subflows = subflow->request_join || subflow->mp_join;
186 [ + + ]: 723 : if (mptcp_pm_is_userspace(msk)) {
187 [ + + ]: 47 : if (update_subflows) {
188 : 38 : spin_lock_bh(&pm->lock);
189 : 38 : pm->subflows--;
190 : 38 : spin_unlock_bh(&pm->lock);
191 : : }
192 : 47 : return;
193 : : }
194 : :
195 [ + + + + : 676 : if (!READ_ONCE(pm->work_pending) && !update_subflows)
+ + ]
196 : : return;
197 : :
198 : 278 : spin_lock_bh(&pm->lock);
199 [ + - ]: 278 : if (update_subflows)
200 : 278 : __mptcp_pm_close_subflow(msk);
201 : :
202 : : /* Even if this subflow is not really established, tell the PM to try
203 : : * to pick the next ones, if possible.
204 : : */
205 [ + + ]: 278 : if (mptcp_pm_nl_check_work_pending(msk))
206 : 78 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
207 : :
208 : 278 : spin_unlock_bh(&pm->lock);
209 : : }
210 : :
211 : 360 : void mptcp_pm_add_addr_received(const struct sock *ssk,
212 : : const struct mptcp_addr_info *addr)
213 : : {
214 [ - + ]: 360 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
215 [ - + ]: 360 : struct mptcp_sock *msk = mptcp_sk(subflow->conn);
216 : 360 : struct mptcp_pm_data *pm = &msk->pm;
217 : :
218 [ - + - - ]: 360 : pr_debug("msk=%p remote_id=%d accept=%d\n", msk, addr->id,
219 : : READ_ONCE(pm->accept_addr));
220 : :
221 : 360 : mptcp_event_addr_announced(ssk, addr);
222 : :
223 : 360 : spin_lock_bh(&pm->lock);
224 : :
225 [ + + ]: 360 : if (mptcp_pm_is_userspace(msk)) {
226 [ + + ]: 30 : if (mptcp_userspace_pm_active(msk)) {
227 : 28 : mptcp_pm_announce_addr(msk, addr, true);
228 : 28 : mptcp_pm_add_addr_send_ack(msk);
229 : : } else {
230 [ + - ]: 2 : __MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_ADDADDRDROP);
231 : : }
232 : : /* id0 should not have a different address */
233 [ + + + - ]: 330 : } else if ((addr->id == 0 && !mptcp_pm_nl_is_init_remote_addr(msk, addr)) ||
234 [ + + + + : 330 : (addr->id > 0 && !READ_ONCE(pm->accept_addr))) {
+ + ]
235 : 34 : mptcp_pm_announce_addr(msk, addr, true);
236 : 34 : mptcp_pm_add_addr_send_ack(msk);
237 [ + + ]: 296 : } else if (mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_RECEIVED)) {
238 : 288 : pm->remote = *addr;
239 : : } else {
240 [ + - ]: 8 : __MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_ADDADDRDROP);
241 : : }
242 : :
243 : 360 : spin_unlock_bh(&pm->lock);
244 : 360 : }
245 : :
246 : 330 : void mptcp_pm_add_addr_echoed(struct mptcp_sock *msk,
247 : : const struct mptcp_addr_info *addr)
248 : : {
249 : 330 : struct mptcp_pm_data *pm = &msk->pm;
250 : :
251 [ - + ]: 330 : pr_debug("msk=%p\n", msk);
252 : :
253 : 330 : spin_lock_bh(&pm->lock);
254 : :
255 [ + + + + : 330 : if (mptcp_lookup_anno_list_by_saddr(msk, addr) && READ_ONCE(pm->work_pending))
+ + ]
256 : 83 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
257 : :
258 : 330 : spin_unlock_bh(&pm->lock);
259 : 330 : }
260 : :
261 : 122 : void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk)
262 : : {
263 [ + - ]: 122 : if (!mptcp_pm_should_add_signal(msk))
264 : : return;
265 : :
266 : 122 : mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_SEND_ACK);
267 : : }
268 : :
269 : 106 : void mptcp_pm_rm_addr_received(struct mptcp_sock *msk,
270 : : const struct mptcp_rm_list *rm_list)
271 : : {
272 : 106 : struct mptcp_pm_data *pm = &msk->pm;
273 : 106 : u8 i;
274 : :
275 [ - + ]: 106 : pr_debug("msk=%p remote_ids_nr=%d\n", msk, rm_list->nr);
276 : :
277 [ + + ]: 220 : for (i = 0; i < rm_list->nr; i++)
278 : 114 : mptcp_event_addr_removed(msk, rm_list->ids[i]);
279 : :
280 : 106 : spin_lock_bh(&pm->lock);
281 [ + - ]: 106 : if (mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED))
282 : 106 : pm->rm_list_rx = *rm_list;
283 : : else
284 [ # # ]: 0 : __MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_RMADDRDROP);
285 : 106 : spin_unlock_bh(&pm->lock);
286 : 106 : }
287 : :
288 : 40 : void mptcp_pm_mp_prio_received(struct sock *ssk, u8 bkup)
289 : : {
290 [ - + ]: 40 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
291 : 40 : struct sock *sk = subflow->conn;
292 : 40 : struct mptcp_sock *msk;
293 : :
294 [ - + ]: 40 : pr_debug("subflow->backup=%d, bkup=%d\n", subflow->backup, bkup);
295 [ - + ]: 40 : msk = mptcp_sk(sk);
296 [ + - ]: 40 : if (subflow->backup != bkup)
297 : 40 : subflow->backup = bkup;
298 : :
299 : 40 : mptcp_event(MPTCP_EVENT_SUB_PRIORITY, msk, ssk, GFP_ATOMIC);
300 : 40 : }
301 : :
302 : 6 : void mptcp_pm_mp_fail_received(struct sock *sk, u64 fail_seq)
303 : : {
304 [ - + ]: 6 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
305 [ - + ]: 6 : struct mptcp_sock *msk = mptcp_sk(subflow->conn);
306 : :
307 [ - + ]: 6 : pr_debug("fail_seq=%llu\n", fail_seq);
308 : :
309 [ + + + + ]: 6 : if (!READ_ONCE(msk->allow_infinite_fallback))
310 : : return;
311 : :
312 [ + + ]: 4 : if (!subflow->fail_tout) {
313 [ - + ]: 2 : pr_debug("send MP_FAIL response and infinite map\n");
314 : :
315 : 2 : subflow->send_mp_fail = 1;
316 : 2 : subflow->send_infinite_map = 1;
317 : 2 : tcp_send_ack(sk);
318 : : } else {
319 [ - + ]: 2 : pr_debug("MP_FAIL response received\n");
320 : 2 : WRITE_ONCE(subflow->fail_tout, 0);
321 : : }
322 : : }
323 : :
324 : : /* path manager helpers */
325 : :
326 : 754 : bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, const struct sk_buff *skb,
327 : : unsigned int opt_size, unsigned int remaining,
328 : : struct mptcp_addr_info *addr, bool *echo,
329 : : bool *drop_other_suboptions)
330 : : {
331 : 754 : int ret = false;
332 : 754 : u8 add_addr;
333 : 754 : u8 family;
334 : 754 : bool port;
335 : :
336 : 754 : spin_lock_bh(&msk->pm.lock);
337 : :
338 : : /* double check after the lock is acquired */
339 [ - + ]: 754 : if (!mptcp_pm_should_add_signal(msk))
340 : 0 : goto out_unlock;
341 : :
342 : : /* always drop every other options for pure ack ADD_ADDR; this is a
343 : : * plain dup-ack from TCP perspective. The other MPTCP-relevant info,
344 : : * if any, will be carried by the 'original' TCP ack
345 : : */
346 [ + - + - ]: 754 : if (skb && skb_is_tcp_pure_ack(skb)) {
347 : 754 : remaining += opt_size;
348 : 754 : *drop_other_suboptions = true;
349 : : }
350 : :
351 [ + + ]: 754 : *echo = mptcp_pm_should_add_signal_echo(msk);
352 [ + + + + ]: 754 : port = !!(*echo ? msk->pm.remote.port : msk->pm.local.port);
353 : :
354 [ + + + + ]: 754 : family = *echo ? msk->pm.remote.family : msk->pm.local.family;
355 [ + + + + : 1508 : if (remaining < mptcp_add_addr_len(family, *echo, port))
- + ]
356 : 0 : goto out_unlock;
357 : :
358 [ + + + + ]: 754 : if (*echo) {
359 : 350 : *addr = msk->pm.remote;
360 : 350 : add_addr = msk->pm.addr_signal & ~BIT(MPTCP_ADD_ADDR_ECHO);
361 : : } else {
362 : 404 : *addr = msk->pm.local;
363 : 404 : add_addr = msk->pm.addr_signal & ~BIT(MPTCP_ADD_ADDR_SIGNAL);
364 : : }
365 : 754 : WRITE_ONCE(msk->pm.addr_signal, add_addr);
366 : 754 : ret = true;
367 : :
368 : 754 : out_unlock:
369 : 754 : spin_unlock_bh(&msk->pm.lock);
370 : 754 : return ret;
371 : : }
372 : :
373 : 106 : bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
374 : : struct mptcp_rm_list *rm_list)
375 : : {
376 : 106 : int ret = false, len;
377 : 106 : u8 rm_addr;
378 : :
379 : 106 : spin_lock_bh(&msk->pm.lock);
380 : :
381 : : /* double check after the lock is acquired */
382 [ - + ]: 106 : if (!mptcp_pm_should_rm_signal(msk))
383 : 0 : goto out_unlock;
384 : :
385 : 106 : rm_addr = msk->pm.addr_signal & ~BIT(MPTCP_RM_ADDR_SIGNAL);
386 [ - + ]: 106 : len = mptcp_rm_addr_len(&msk->pm.rm_list_tx);
387 : 0 : if (len < 0) {
388 : 0 : WRITE_ONCE(msk->pm.addr_signal, rm_addr);
389 : 0 : goto out_unlock;
390 : : }
391 [ - + ]: 106 : if (remaining < len)
392 : 0 : goto out_unlock;
393 : :
394 : 106 : *rm_list = msk->pm.rm_list_tx;
395 : 106 : WRITE_ONCE(msk->pm.addr_signal, rm_addr);
396 : 106 : ret = true;
397 : :
398 : 106 : out_unlock:
399 : 106 : spin_unlock_bh(&msk->pm.lock);
400 : 106 : return ret;
401 : : }
402 : :
403 : 746 : int mptcp_pm_get_local_id(struct mptcp_sock *msk, struct sock_common *skc)
404 : : {
405 : 746 : struct mptcp_addr_info skc_local;
406 : 746 : struct mptcp_addr_info msk_local;
407 : :
408 [ - + ]: 746 : if (WARN_ON_ONCE(!msk))
409 : 0 : return -1;
410 : :
411 : : /* The 0 ID mapping is defined by the first subflow, copied into the msk
412 : : * addr
413 : : */
414 : 746 : mptcp_local_address((struct sock_common *)msk, &msk_local);
415 : 746 : mptcp_local_address((struct sock_common *)skc, &skc_local);
416 [ + + ]: 746 : if (mptcp_addresses_equal(&msk_local, &skc_local, false))
417 : : return 0;
418 : :
419 [ + + ]: 382 : if (mptcp_pm_is_userspace(msk))
420 : 22 : return mptcp_userspace_pm_get_local_id(msk, &skc_local);
421 : 360 : return mptcp_pm_nl_get_local_id(msk, &skc_local);
422 : : }
423 : :
424 : 746 : bool mptcp_pm_is_backup(struct mptcp_sock *msk, struct sock_common *skc)
425 : : {
426 : 746 : struct mptcp_addr_info skc_local;
427 : :
428 : 746 : mptcp_local_address((struct sock_common *)skc, &skc_local);
429 : :
430 [ + + ]: 746 : if (mptcp_pm_is_userspace(msk))
431 : 26 : return mptcp_userspace_pm_is_backup(msk, &skc_local);
432 : :
433 : 720 : return mptcp_pm_nl_is_backup(msk, &skc_local);
434 : : }
435 : :
436 : 28 : int mptcp_pm_get_addr(struct sk_buff *skb, struct genl_info *info)
437 : : {
438 [ + + ]: 28 : if (info->attrs[MPTCP_PM_ATTR_TOKEN])
439 : 6 : return mptcp_userspace_pm_get_addr(skb, info);
440 : 22 : return mptcp_pm_nl_get_addr(skb, info);
441 : : }
442 : :
443 : 236 : int mptcp_pm_dump_addr(struct sk_buff *msg, struct netlink_callback *cb)
444 : : {
445 [ + + ]: 236 : const struct genl_info *info = genl_info_dump(cb);
446 : :
447 [ + + ]: 236 : if (info->attrs[MPTCP_PM_ATTR_TOKEN])
448 : 20 : return mptcp_userspace_pm_dump_addr(msg, cb);
449 : 216 : return mptcp_pm_nl_dump_addr(msg, cb);
450 : : }
451 : :
452 : 48 : int mptcp_pm_set_flags(struct sk_buff *skb, struct genl_info *info)
453 : : {
454 [ + + ]: 48 : if (info->attrs[MPTCP_PM_ATTR_TOKEN])
455 : 2 : return mptcp_userspace_pm_set_flags(skb, info);
456 : 46 : return mptcp_pm_nl_set_flags(skb, info);
457 : : }
458 : :
459 : 731 : void mptcp_pm_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk)
460 : : {
461 [ - + ]: 731 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
462 [ - + ]: 731 : u32 rcv_tstamp = READ_ONCE(tcp_sk(ssk)->rcv_tstamp);
463 : :
464 : : /* keep track of rtx periods with no progress */
465 [ + + ]: 731 : if (!subflow->stale_count) {
466 : 266 : subflow->stale_rcv_tstamp = rcv_tstamp;
467 : 266 : subflow->stale_count++;
468 [ + + ]: 465 : } else if (subflow->stale_rcv_tstamp == rcv_tstamp) {
469 [ + - ]: 311 : if (subflow->stale_count < U8_MAX)
470 : 311 : subflow->stale_count++;
471 : 311 : mptcp_pm_nl_subflow_chk_stale(msk, ssk);
472 : : } else {
473 : 154 : subflow->stale_count = 0;
474 : 154 : mptcp_subflow_set_active(subflow);
475 : : }
476 : 731 : }
477 : :
478 : : /* if sk is ipv4 or ipv6_only allows only same-family local and remote addresses,
479 : : * otherwise allow any matching local/remote pair
480 : : */
481 : 626 : bool mptcp_pm_addr_families_match(const struct sock *sk,
482 : : const struct mptcp_addr_info *loc,
483 : : const struct mptcp_addr_info *rem)
484 : : {
485 : 626 : bool mptcp_is_v4 = sk->sk_family == AF_INET;
486 : :
487 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
488 [ + + + + ]: 626 : bool loc_is_v4 = loc->family == AF_INET || ipv6_addr_v4mapped(&loc->addr6);
489 [ + + + + ]: 626 : bool rem_is_v4 = rem->family == AF_INET || ipv6_addr_v4mapped(&rem->addr6);
490 : :
491 [ + + ]: 626 : if (mptcp_is_v4)
492 : 502 : return loc_is_v4 && rem_is_v4;
493 : :
494 [ - + ]: 124 : if (ipv6_only_sock(sk))
495 : 0 : return !loc_is_v4 && !rem_is_v4;
496 : :
497 : 124 : return loc_is_v4 == rem_is_v4;
498 : : #else
499 : : return mptcp_is_v4 && loc->family == AF_INET && rem->family == AF_INET;
500 : : #endif
501 : : }
502 : :
503 : 3726 : void mptcp_pm_data_reset(struct mptcp_sock *msk)
504 : : {
505 : 3726 : u8 pm_type = mptcp_get_pm_type(sock_net((struct sock *)msk));
506 : 3726 : struct mptcp_pm_data *pm = &msk->pm;
507 : :
508 : 3726 : pm->add_addr_signaled = 0;
509 : 3726 : pm->add_addr_accepted = 0;
510 : 3726 : pm->local_addr_used = 0;
511 : 3726 : pm->subflows = 0;
512 : 3726 : pm->rm_list_tx.nr = 0;
513 : 3726 : pm->rm_list_rx.nr = 0;
514 : 3726 : WRITE_ONCE(pm->pm_type, pm_type);
515 : :
516 [ + + ]: 3726 : if (pm_type == MPTCP_PM_TYPE_KERNEL) {
517 : 3662 : bool subflows_allowed = !!mptcp_pm_get_subflows_max(msk);
518 : :
519 : : /* pm->work_pending must be only be set to 'true' when
520 : : * pm->pm_type is set to MPTCP_PM_TYPE_KERNEL
521 : : */
522 [ + + + + : 3662 : WRITE_ONCE(pm->work_pending,
+ + ]
523 : : (!!mptcp_pm_get_local_addr_max(msk) &&
524 : : subflows_allowed) ||
525 : : !!mptcp_pm_get_add_addr_signal_max(msk));
526 [ + + - + ]: 3662 : WRITE_ONCE(pm->accept_addr,
527 : : !!mptcp_pm_get_add_addr_accept_max(msk) &&
528 : : subflows_allowed);
529 : 3662 : WRITE_ONCE(pm->accept_subflow, subflows_allowed);
530 : : } else {
531 : 64 : WRITE_ONCE(pm->work_pending, 0);
532 : 64 : WRITE_ONCE(pm->accept_addr, 0);
533 : 64 : WRITE_ONCE(pm->accept_subflow, 0);
534 : : }
535 : :
536 : 3726 : WRITE_ONCE(pm->addr_signal, 0);
537 : 3726 : WRITE_ONCE(pm->remote_deny_join_id0, false);
538 : 3726 : pm->status = 0;
539 : 3726 : bitmap_fill(msk->pm.id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
540 : 3726 : }
541 : :
542 : 3666 : void mptcp_pm_data_init(struct mptcp_sock *msk)
543 : : {
544 : 3666 : spin_lock_init(&msk->pm.lock);
545 : 3666 : INIT_LIST_HEAD(&msk->pm.anno_list);
546 : 3666 : INIT_LIST_HEAD(&msk->pm.userspace_pm_local_addr_list);
547 : 3666 : mptcp_pm_data_reset(msk);
548 : 3666 : }
549 : :
550 : 4 : void __init mptcp_pm_init(void)
551 : : {
552 : 4 : mptcp_pm_nl_init();
553 : 4 : }
|
