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 : 2286 : void mptcp_pm_new_connection(struct mptcp_sock *msk, const struct sock *ssk, int server_side)
67 : : {
68 : 2286 : struct mptcp_pm_data *pm = &msk->pm;
69 : :
70 [ - + ]: 2286 : pr_debug("msk=%p, token=%u side=%d\n", msk, READ_ONCE(msk->token), server_side);
71 : :
72 : 2286 : WRITE_ONCE(pm->server_side, server_side);
73 : 2286 : mptcp_event(MPTCP_EVENT_CREATED, msk, ssk, GFP_ATOMIC);
74 : 2286 : }
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 : 1384 : static bool mptcp_pm_schedule_work(struct mptcp_sock *msk,
116 : : enum mptcp_pm_status new_status)
117 : : {
118 [ - + - - ]: 1384 : pr_debug("msk=%p status=%x new=%lx\n", msk, msk->pm.status,
119 : : BIT(new_status));
120 [ + + + + ]: 1384 : if (msk->pm.status & BIT(new_status))
121 : : return false;
122 : :
123 [ - + ]: 1235 : msk->pm.status |= BIT(new_status);
124 : 1235 : mptcp_schedule_work((struct sock *)msk);
125 : 1235 : 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 : 3692 : void mptcp_pm_connection_closed(struct mptcp_sock *msk)
156 : : {
157 [ - + ]: 3692 : pr_debug("msk=%p\n", msk);
158 : :
159 [ + + ]: 3692 : if (msk->token)
160 : 2289 : mptcp_event(MPTCP_EVENT_CLOSED, msk, NULL, GFP_KERNEL);
161 : 3692 : }
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 : 753 : void mptcp_pm_subflow_check_next(struct mptcp_sock *msk,
181 : : const struct mptcp_subflow_context *subflow)
182 : : {
183 : 753 : struct mptcp_pm_data *pm = &msk->pm;
184 : 753 : bool update_subflows;
185 : :
186 : 753 : update_subflows = subflow->request_join || subflow->mp_join;
187 [ + + ]: 753 : if (mptcp_pm_is_userspace(msk)) {
188 [ + + ]: 51 : if (update_subflows) {
189 : 40 : spin_lock_bh(&pm->lock);
190 : 40 : pm->subflows--;
191 : 40 : spin_unlock_bh(&pm->lock);
192 : : }
193 : 51 : return;
194 : : }
195 : :
196 [ + + + + : 702 : if (!READ_ONCE(pm->work_pending) && !update_subflows)
+ + ]
197 : : return;
198 : :
199 : 298 : spin_lock_bh(&pm->lock);
200 [ + - ]: 298 : if (update_subflows)
201 : 298 : __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 [ + + ]: 298 : if (mptcp_pm_nl_check_work_pending(msk))
207 : 78 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
208 : :
209 : 298 : 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 : 85 : 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 : 768 : int mptcp_pm_get_local_id(struct mptcp_sock *msk, struct sock_common *skc)
405 : : {
406 : 768 : struct mptcp_addr_info skc_local;
407 : 768 : struct mptcp_addr_info msk_local;
408 : :
409 [ - + ]: 768 : 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 : 768 : mptcp_local_address((struct sock_common *)msk, &msk_local);
416 : 768 : mptcp_local_address((struct sock_common *)skc, &skc_local);
417 [ + + ]: 768 : if (mptcp_addresses_equal(&msk_local, &skc_local, false))
418 : : return 0;
419 : :
420 [ + + ]: 386 : if (mptcp_pm_is_userspace(msk))
421 : 22 : return mptcp_userspace_pm_get_local_id(msk, &skc_local);
422 : 364 : return mptcp_pm_nl_get_local_id(msk, &skc_local);
423 : : }
424 : :
425 : 768 : bool mptcp_pm_is_backup(struct mptcp_sock *msk, struct sock_common *skc)
426 : : {
427 : 768 : struct mptcp_addr_info skc_local;
428 : :
429 : 768 : mptcp_local_address((struct sock_common *)skc, &skc_local);
430 : :
431 [ + + ]: 768 : if (mptcp_pm_is_userspace(msk))
432 : 26 : return mptcp_userspace_pm_is_backup(msk, &skc_local);
433 : :
434 : 742 : 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 : 182 : int mptcp_pm_genl_fill_addr(struct sk_buff *msg,
493 : : struct netlink_callback *cb,
494 : : struct mptcp_pm_addr_entry *entry)
495 : : {
496 : 182 : void *hdr;
497 : :
498 : 182 : hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
499 : 182 : cb->nlh->nlmsg_seq, &mptcp_genl_family,
500 : : NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
501 [ - + ]: 182 : if (!hdr)
502 : : return -EINVAL;
503 : :
504 [ - + ]: 182 : if (mptcp_nl_fill_addr(msg, entry) < 0) {
505 : 0 : genlmsg_cancel(msg, hdr);
506 : 0 : return -EINVAL;
507 : : }
508 : :
509 : 182 : genlmsg_end(msg, hdr);
510 : 182 : return 0;
511 : : }
512 : :
513 : 236 : static int mptcp_pm_dump_addr(struct sk_buff *msg, struct netlink_callback *cb)
514 : : {
515 [ + + ]: 236 : const struct genl_info *info = genl_info_dump(cb);
516 : :
517 [ + + ]: 236 : if (info->attrs[MPTCP_PM_ATTR_TOKEN])
518 : 20 : return mptcp_userspace_pm_dump_addr(msg, cb);
519 : 216 : return mptcp_pm_nl_dump_addr(msg, cb);
520 : : }
521 : :
522 : 236 : int mptcp_pm_nl_get_addr_dumpit(struct sk_buff *msg,
523 : : struct netlink_callback *cb)
524 : : {
525 : 236 : return mptcp_pm_dump_addr(msg, cb);
526 : : }
527 : :
528 : 48 : static int mptcp_pm_set_flags(struct genl_info *info)
529 : : {
530 : 48 : struct mptcp_pm_addr_entry loc = { .addr = { .family = AF_UNSPEC }, };
531 : 48 : struct nlattr *attr_loc;
532 : 48 : int ret = -EINVAL;
533 : :
534 [ + - - - ]: 48 : if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR))
535 : 0 : return ret;
536 : :
537 : 48 : attr_loc = info->attrs[MPTCP_PM_ATTR_ADDR];
538 : 48 : ret = mptcp_pm_parse_entry(attr_loc, info, false, &loc);
539 [ + - ]: 48 : if (ret < 0)
540 : : return ret;
541 : :
542 [ + + ]: 48 : if (info->attrs[MPTCP_PM_ATTR_TOKEN])
543 : 2 : return mptcp_userspace_pm_set_flags(&loc, info);
544 : 46 : return mptcp_pm_nl_set_flags(&loc, info);
545 : : }
546 : :
547 : 48 : int mptcp_pm_nl_set_flags_doit(struct sk_buff *skb, struct genl_info *info)
548 : : {
549 : 48 : return mptcp_pm_set_flags(info);
550 : : }
551 : :
552 : 559 : void mptcp_pm_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk)
553 : : {
554 [ - + ]: 559 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
555 [ - + ]: 559 : u32 rcv_tstamp = READ_ONCE(tcp_sk(ssk)->rcv_tstamp);
556 : :
557 : : /* keep track of rtx periods with no progress */
558 [ + + ]: 559 : if (!subflow->stale_count) {
559 : 270 : subflow->stale_rcv_tstamp = rcv_tstamp;
560 : 270 : subflow->stale_count++;
561 [ + + ]: 289 : } else if (subflow->stale_rcv_tstamp == rcv_tstamp) {
562 [ + - ]: 189 : if (subflow->stale_count < U8_MAX)
563 : 189 : subflow->stale_count++;
564 : 189 : mptcp_pm_nl_subflow_chk_stale(msk, ssk);
565 : : } else {
566 : 100 : subflow->stale_count = 0;
567 : 100 : mptcp_subflow_set_active(subflow);
568 : : }
569 : 559 : }
570 : :
571 : : /* if sk is ipv4 or ipv6_only allows only same-family local and remote addresses,
572 : : * otherwise allow any matching local/remote pair
573 : : */
574 : 664 : bool mptcp_pm_addr_families_match(const struct sock *sk,
575 : : const struct mptcp_addr_info *loc,
576 : : const struct mptcp_addr_info *rem)
577 : : {
578 : 664 : bool mptcp_is_v4 = sk->sk_family == AF_INET;
579 : :
580 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
581 [ + + + + ]: 664 : bool loc_is_v4 = loc->family == AF_INET || ipv6_addr_v4mapped(&loc->addr6);
582 [ + + + + ]: 664 : bool rem_is_v4 = rem->family == AF_INET || ipv6_addr_v4mapped(&rem->addr6);
583 : :
584 [ + + ]: 664 : if (mptcp_is_v4)
585 : 538 : return loc_is_v4 && rem_is_v4;
586 : :
587 [ - + ]: 126 : if (ipv6_only_sock(sk))
588 : 0 : return !loc_is_v4 && !rem_is_v4;
589 : :
590 : 126 : return loc_is_v4 == rem_is_v4;
591 : : #else
592 : : return mptcp_is_v4 && loc->family == AF_INET && rem->family == AF_INET;
593 : : #endif
594 : : }
595 : :
596 : 3754 : void mptcp_pm_data_reset(struct mptcp_sock *msk)
597 : : {
598 : 3754 : u8 pm_type = mptcp_get_pm_type(sock_net((struct sock *)msk));
599 : 3754 : struct mptcp_pm_data *pm = &msk->pm;
600 : :
601 : 3754 : pm->add_addr_signaled = 0;
602 : 3754 : pm->add_addr_accepted = 0;
603 : 3754 : pm->local_addr_used = 0;
604 : 3754 : pm->subflows = 0;
605 : 3754 : pm->rm_list_tx.nr = 0;
606 : 3754 : pm->rm_list_rx.nr = 0;
607 : 3754 : WRITE_ONCE(pm->pm_type, pm_type);
608 : :
609 [ + + ]: 3754 : if (pm_type == MPTCP_PM_TYPE_KERNEL) {
610 : 3690 : bool subflows_allowed = !!mptcp_pm_get_subflows_max(msk);
611 : :
612 : : /* pm->work_pending must be only be set to 'true' when
613 : : * pm->pm_type is set to MPTCP_PM_TYPE_KERNEL
614 : : */
615 [ + + + + : 3690 : WRITE_ONCE(pm->work_pending,
+ + ]
616 : : (!!mptcp_pm_get_local_addr_max(msk) &&
617 : : subflows_allowed) ||
618 : : !!mptcp_pm_get_add_addr_signal_max(msk));
619 [ + + - + ]: 3690 : WRITE_ONCE(pm->accept_addr,
620 : : !!mptcp_pm_get_add_addr_accept_max(msk) &&
621 : : subflows_allowed);
622 : 3690 : WRITE_ONCE(pm->accept_subflow, subflows_allowed);
623 : : } else {
624 : 64 : WRITE_ONCE(pm->work_pending, 0);
625 : 64 : WRITE_ONCE(pm->accept_addr, 0);
626 : 64 : WRITE_ONCE(pm->accept_subflow, 0);
627 : : }
628 : :
629 : 3754 : WRITE_ONCE(pm->addr_signal, 0);
630 : 3754 : WRITE_ONCE(pm->remote_deny_join_id0, false);
631 : 3754 : pm->status = 0;
632 : 3754 : bitmap_fill(msk->pm.id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
633 : 3754 : }
634 : :
635 : 3696 : void mptcp_pm_data_init(struct mptcp_sock *msk)
636 : : {
637 : 3696 : spin_lock_init(&msk->pm.lock);
638 : 3696 : INIT_LIST_HEAD(&msk->pm.anno_list);
639 : 3696 : INIT_LIST_HEAD(&msk->pm.userspace_pm_local_addr_list);
640 : 3696 : mptcp_pm_data_reset(msk);
641 : 3696 : }
642 : :
643 : 4 : void __init mptcp_pm_init(void)
644 : : {
645 : 4 : mptcp_pm_nl_init();
646 : 4 : }
|
