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