Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /* Multipath TCP
3 : : *
4 : : * Copyright (c) 2020, Red Hat, Inc.
5 : : */
6 : :
7 : : #define pr_fmt(fmt) "MPTCP: " fmt
8 : :
9 : : #include <linux/inet.h>
10 : : #include <linux/kernel.h>
11 : : #include <net/inet_common.h>
12 : : #include <net/netns/generic.h>
13 : : #include <net/mptcp.h>
14 : :
15 : : #include "protocol.h"
16 : : #include "mib.h"
17 : : #include "mptcp_pm_gen.h"
18 : :
19 : : static int pm_nl_pernet_id;
20 : :
21 : : struct mptcp_pm_add_entry {
22 : : struct list_head list;
23 : : struct mptcp_addr_info addr;
24 : : u8 retrans_times;
25 : : struct timer_list add_timer;
26 : : struct mptcp_sock *sock;
27 : : };
28 : :
29 : : struct pm_nl_pernet {
30 : : /* protects pernet updates */
31 : : spinlock_t lock;
32 : : struct list_head local_addr_list;
33 : : unsigned int addrs;
34 : : unsigned int stale_loss_cnt;
35 : : unsigned int add_addr_signal_max;
36 : : unsigned int add_addr_accept_max;
37 : : unsigned int local_addr_max;
38 : : unsigned int subflows_max;
39 : : unsigned int next_id;
40 : : DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
41 : : };
42 : :
43 : : #define MPTCP_PM_ADDR_MAX 8
44 : : #define ADD_ADDR_RETRANS_MAX 3
45 : :
46 : 15751 : static struct pm_nl_pernet *pm_nl_get_pernet(const struct net *net)
47 : : {
48 : 29577 : return net_generic(net, pm_nl_pernet_id);
49 : : }
50 : :
51 : : static struct pm_nl_pernet *
52 : 13055 : pm_nl_get_pernet_from_msk(const struct mptcp_sock *msk)
53 : : {
54 : 25283 : return pm_nl_get_pernet(sock_net((struct sock *)msk));
55 : : }
56 : :
57 : 8731 : bool mptcp_addresses_equal(const struct mptcp_addr_info *a,
58 : : const struct mptcp_addr_info *b, bool use_port)
59 : : {
60 : 8731 : bool addr_equals = false;
61 : :
62 [ + + ]: 8731 : if (a->family == b->family) {
63 [ + + ]: 7365 : if (a->family == AF_INET)
64 : 6366 : addr_equals = a->addr.s_addr == b->addr.s_addr;
65 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
66 : : else
67 : 999 : addr_equals = !ipv6_addr_cmp(&a->addr6, &b->addr6);
68 [ + + ]: 1366 : } else if (a->family == AF_INET) {
69 [ + + ]: 968 : if (ipv6_addr_v4mapped(&b->addr6))
70 : 672 : addr_equals = a->addr.s_addr == b->addr6.s6_addr32[3];
71 [ + - ]: 398 : } else if (b->family == AF_INET) {
72 [ + + ]: 398 : if (ipv6_addr_v4mapped(&a->addr6))
73 : 181 : addr_equals = a->addr6.s6_addr32[3] == b->addr.s_addr;
74 : : #endif
75 : : }
76 : :
77 [ + + ]: 8218 : if (!addr_equals)
78 : : return false;
79 [ + + ]: 1980 : if (!use_port)
80 : : return true;
81 : :
82 : 834 : return a->port == b->port;
83 : : }
84 : :
85 : 3332 : void mptcp_local_address(const struct sock_common *skc, struct mptcp_addr_info *addr)
86 : : {
87 : 3332 : addr->family = skc->skc_family;
88 : 3332 : addr->port = htons(skc->skc_num);
89 [ + + ]: 3332 : if (addr->family == AF_INET)
90 : 1590 : addr->addr.s_addr = skc->skc_rcv_saddr;
91 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
92 [ + - ]: 1742 : else if (addr->family == AF_INET6)
93 : 1742 : addr->addr6 = skc->skc_v6_rcv_saddr;
94 : : #endif
95 : 3332 : }
96 : :
97 : 0 : static void remote_address(const struct sock_common *skc,
98 : : struct mptcp_addr_info *addr)
99 : : {
100 : 776 : addr->family = skc->skc_family;
101 : 776 : addr->port = skc->skc_dport;
102 : 776 : if (addr->family == AF_INET)
103 : 591 : addr->addr.s_addr = skc->skc_daddr;
104 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
105 [ - - - - : 185 : else if (addr->family == AF_INET6)
+ - + - +
- ]
106 : 0 : addr->addr6 = skc->skc_v6_daddr;
107 : : #endif
108 : : }
109 : :
110 : 102 : static bool lookup_subflow_by_saddr(const struct list_head *list,
111 : : const struct mptcp_addr_info *saddr)
112 : : {
113 : 102 : struct mptcp_subflow_context *subflow;
114 : 102 : struct mptcp_addr_info cur;
115 : 102 : struct sock_common *skc;
116 : :
117 [ + + ]: 222 : list_for_each_entry(subflow, list, node) {
118 : 198 : skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow);
119 : :
120 : 198 : mptcp_local_address(skc, &cur);
121 [ + + ]: 198 : if (mptcp_addresses_equal(&cur, saddr, saddr->port))
122 : : return true;
123 : : }
124 : :
125 : : return false;
126 : : }
127 : :
128 : 288 : static bool lookup_subflow_by_daddr(const struct list_head *list,
129 : : const struct mptcp_addr_info *daddr)
130 : : {
131 : 288 : struct mptcp_subflow_context *subflow;
132 : 288 : struct mptcp_addr_info cur;
133 : :
134 [ + + ]: 756 : list_for_each_entry(subflow, list, node) {
135 : 486 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
136 : :
137 [ + + + + ]: 486 : if (!((1 << inet_sk_state_load(ssk)) &
138 : : (TCPF_ESTABLISHED | TCPF_SYN_SENT | TCPF_SYN_RECV)))
139 : 4 : continue;
140 : :
141 [ + + ]: 482 : remote_address((struct sock_common *)ssk, &cur);
142 [ + + ]: 482 : if (mptcp_addresses_equal(&cur, daddr, daddr->port))
143 : : return true;
144 : : }
145 : :
146 : : return false;
147 : : }
148 : :
149 : : static bool
150 : 334 : select_local_address(const struct pm_nl_pernet *pernet,
151 : : const struct mptcp_sock *msk,
152 : : struct mptcp_pm_local *new_local)
153 : : {
154 : 334 : struct mptcp_pm_addr_entry *entry;
155 : 334 : bool found = false;
156 : :
157 : 334 : msk_owned_by_me(msk);
158 : :
159 : 334 : rcu_read_lock();
160 [ + + ]: 470 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
161 [ + + ]: 442 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW))
162 : 16 : continue;
163 : :
164 [ - + - - : 852 : if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
- - - - +
+ + + ]
165 : 120 : continue;
166 : :
167 : 306 : new_local->addr = entry->addr;
168 : 306 : new_local->flags = entry->flags;
169 : 306 : new_local->ifindex = entry->ifindex;
170 : 306 : found = true;
171 : 306 : break;
172 : : }
173 : 334 : rcu_read_unlock();
174 : :
175 : 334 : return found;
176 : : }
177 : :
178 : : static bool
179 : 310 : select_signal_address(struct pm_nl_pernet *pernet, const struct mptcp_sock *msk,
180 : : struct mptcp_pm_local *new_local)
181 : : {
182 : 310 : struct mptcp_pm_addr_entry *entry;
183 : 310 : bool found = false;
184 : :
185 : 310 : rcu_read_lock();
186 : : /* do not keep any additional per socket state, just signal
187 : : * the address list in order.
188 : : * Note: removal from the local address list during the msk life-cycle
189 : : * can lead to additional addresses not being announced.
190 : : */
191 [ + - ]: 620 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
192 [ - + - - : 1240 : if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap))
- - - - +
+ + + ]
193 : 310 : continue;
194 : :
195 [ - + ]: 310 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL))
196 : 0 : continue;
197 : :
198 : 310 : new_local->addr = entry->addr;
199 : 310 : new_local->flags = entry->flags;
200 : 310 : new_local->ifindex = entry->ifindex;
201 : 310 : found = true;
202 : 310 : break;
203 : : }
204 : 310 : rcu_read_unlock();
205 : :
206 : 310 : return found;
207 : : }
208 : :
209 : 4480 : unsigned int mptcp_pm_get_add_addr_signal_max(const struct mptcp_sock *msk)
210 : : {
211 : 4348 : const struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
212 : :
213 : 5122 : return READ_ONCE(pernet->add_addr_signal_max);
214 : : }
215 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_signal_max);
216 : :
217 : 4444 : unsigned int mptcp_pm_get_add_addr_accept_max(const struct mptcp_sock *msk)
218 : : {
219 : 4444 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
220 : :
221 : 4776 : return READ_ONCE(pernet->add_addr_accept_max);
222 : : }
223 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_accept_max);
224 : :
225 : 5170 : unsigned int mptcp_pm_get_subflows_max(const struct mptcp_sock *msk)
226 : : {
227 : 5170 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
228 : :
229 : 7514 : return READ_ONCE(pernet->subflows_max);
230 : : }
231 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_subflows_max);
232 : :
233 : 4764 : unsigned int mptcp_pm_get_local_addr_max(const struct mptcp_sock *msk)
234 : : {
235 : 4632 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
236 : :
237 : 5406 : return READ_ONCE(pernet->local_addr_max);
238 : : }
239 : : EXPORT_SYMBOL_GPL(mptcp_pm_get_local_addr_max);
240 : :
241 : 1052 : bool mptcp_pm_nl_check_work_pending(struct mptcp_sock *msk)
242 : : {
243 : 1052 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
244 : :
245 [ + + + + ]: 1778 : if (msk->pm.subflows == mptcp_pm_get_subflows_max(msk) ||
246 [ + - ]: 864 : (find_next_and_bit(pernet->id_bitmap, msk->pm.id_avail_bitmap,
247 : : MPTCP_PM_MAX_ADDR_ID + 1, 0) == MPTCP_PM_MAX_ADDR_ID + 1)) {
248 : 811 : WRITE_ONCE(msk->pm.work_pending, false);
249 : 811 : return false;
250 : : }
251 : : return true;
252 : : }
253 : :
254 : : struct mptcp_pm_add_entry *
255 : 1134 : mptcp_lookup_anno_list_by_saddr(const struct mptcp_sock *msk,
256 : : const struct mptcp_addr_info *addr)
257 : : {
258 : 1134 : struct mptcp_pm_add_entry *entry;
259 : :
260 [ + - + - : 1701 : lockdep_assert_held(&msk->pm.lock);
- + ]
261 : :
262 [ + + ]: 1434 : list_for_each_entry(entry, &msk->pm.anno_list, list) {
263 [ + + ]: 1026 : if (mptcp_addresses_equal(&entry->addr, addr, true))
264 : 726 : return entry;
265 : : }
266 : :
267 : : return NULL;
268 : : }
269 : :
270 : 48 : bool mptcp_pm_sport_in_anno_list(struct mptcp_sock *msk, const struct sock *sk)
271 : : {
272 : 48 : struct mptcp_pm_add_entry *entry;
273 : 48 : struct mptcp_addr_info saddr;
274 : 48 : bool ret = false;
275 : :
276 : 48 : mptcp_local_address((struct sock_common *)sk, &saddr);
277 : :
278 : 48 : spin_lock_bh(&msk->pm.lock);
279 [ + - ]: 48 : list_for_each_entry(entry, &msk->pm.anno_list, list) {
280 [ + - ]: 48 : if (mptcp_addresses_equal(&entry->addr, &saddr, true)) {
281 : 48 : ret = true;
282 : 48 : goto out;
283 : : }
284 : : }
285 : :
286 : 0 : out:
287 : 48 : spin_unlock_bh(&msk->pm.lock);
288 : 48 : return ret;
289 : : }
290 : :
291 : 62 : static void mptcp_pm_add_timer(struct timer_list *timer)
292 : : {
293 : 62 : struct mptcp_pm_add_entry *entry = from_timer(entry, timer, add_timer);
294 : 62 : struct mptcp_sock *msk = entry->sock;
295 : 62 : struct sock *sk = (struct sock *)msk;
296 : :
297 [ - + ]: 62 : pr_debug("msk=%p\n", msk);
298 : :
299 [ + - ]: 62 : if (!msk)
300 : : return;
301 : :
302 [ + - ]: 62 : if (inet_sk_state_load(sk) == TCP_CLOSE)
303 : : return;
304 : :
305 [ + - ]: 62 : if (!entry->addr.id)
306 : : return;
307 : :
308 [ + + ]: 62 : if (mptcp_pm_should_add_signal_addr(msk)) {
309 : 2 : sk_reset_timer(sk, timer, jiffies + TCP_RTO_MAX / 8);
310 : 2 : goto out;
311 : : }
312 : :
313 : 60 : spin_lock_bh(&msk->pm.lock);
314 : :
315 [ + - ]: 60 : if (!mptcp_pm_should_add_signal_addr(msk)) {
316 [ - + ]: 60 : pr_debug("retransmit ADD_ADDR id=%d\n", entry->addr.id);
317 : 60 : mptcp_pm_announce_addr(msk, &entry->addr, false);
318 : 60 : mptcp_pm_add_addr_send_ack(msk);
319 : 60 : entry->retrans_times++;
320 : : }
321 : :
322 [ + + ]: 60 : if (entry->retrans_times < ADD_ADDR_RETRANS_MAX)
323 : 48 : sk_reset_timer(sk, timer,
324 : 48 : jiffies + mptcp_get_add_addr_timeout(sock_net(sk)));
325 : :
326 : 60 : spin_unlock_bh(&msk->pm.lock);
327 : :
328 [ + + ]: 60 : if (entry->retrans_times == ADD_ADDR_RETRANS_MAX)
329 : 12 : mptcp_pm_subflow_established(msk);
330 : :
331 : 48 : out:
332 : 62 : __sock_put(sk);
333 : : }
334 : :
335 : : struct mptcp_pm_add_entry *
336 : 460 : mptcp_pm_del_add_timer(struct mptcp_sock *msk,
337 : : const struct mptcp_addr_info *addr, bool check_id)
338 : : {
339 : 460 : struct mptcp_pm_add_entry *entry;
340 : 460 : struct sock *sk = (struct sock *)msk;
341 : 460 : struct timer_list *add_timer = NULL;
342 : :
343 : 460 : spin_lock_bh(&msk->pm.lock);
344 : 460 : entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
345 [ + + + + : 460 : if (entry && (!check_id || entry->addr.id == addr->id)) {
+ + ]
346 : 392 : entry->retrans_times = ADD_ADDR_RETRANS_MAX;
347 : 392 : add_timer = &entry->add_timer;
348 : : }
349 [ + + ]: 460 : if (!check_id && entry)
350 : 78 : list_del(&entry->list);
351 : 460 : spin_unlock_bh(&msk->pm.lock);
352 : :
353 : : /* no lock, because sk_stop_timer_sync() is calling del_timer_sync() */
354 [ + + ]: 460 : if (add_timer)
355 : 392 : sk_stop_timer_sync(sk, add_timer);
356 : :
357 : 460 : return entry;
358 : : }
359 : :
360 : 344 : bool mptcp_pm_alloc_anno_list(struct mptcp_sock *msk,
361 : : const struct mptcp_addr_info *addr)
362 : : {
363 : 344 : struct mptcp_pm_add_entry *add_entry = NULL;
364 : 344 : struct sock *sk = (struct sock *)msk;
365 : 344 : struct net *net = sock_net(sk);
366 : :
367 [ + - + - : 516 : lockdep_assert_held(&msk->pm.lock);
- + ]
368 : :
369 : 344 : add_entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
370 : :
371 [ - + ]: 344 : if (add_entry) {
372 [ # # ]: 0 : if (WARN_ON_ONCE(mptcp_pm_is_kernel(msk)))
373 : 0 : return false;
374 : :
375 : 0 : sk_reset_timer(sk, &add_entry->add_timer,
376 : 0 : jiffies + mptcp_get_add_addr_timeout(net));
377 : 0 : return true;
378 : : }
379 : :
380 : 344 : add_entry = kmalloc(sizeof(*add_entry), GFP_ATOMIC);
381 [ - + ]: 344 : if (!add_entry)
382 : : return false;
383 : :
384 : 344 : list_add(&add_entry->list, &msk->pm.anno_list);
385 : :
386 : 344 : add_entry->addr = *addr;
387 : 344 : add_entry->sock = msk;
388 : 344 : add_entry->retrans_times = 0;
389 : :
390 : 344 : timer_setup(&add_entry->add_timer, mptcp_pm_add_timer, 0);
391 : 688 : sk_reset_timer(sk, &add_entry->add_timer,
392 : 344 : jiffies + mptcp_get_add_addr_timeout(net));
393 : :
394 : 344 : return true;
395 : : }
396 : :
397 : 3633 : void mptcp_pm_free_anno_list(struct mptcp_sock *msk)
398 : : {
399 : 3633 : struct mptcp_pm_add_entry *entry, *tmp;
400 : 3633 : struct sock *sk = (struct sock *)msk;
401 : 3633 : LIST_HEAD(free_list);
402 : :
403 [ - + ]: 3633 : pr_debug("msk=%p\n", msk);
404 : :
405 : 3633 : spin_lock_bh(&msk->pm.lock);
406 [ + + ]: 3633 : list_splice_init(&msk->pm.anno_list, &free_list);
407 : 3633 : spin_unlock_bh(&msk->pm.lock);
408 : :
409 [ + + ]: 3899 : list_for_each_entry_safe(entry, tmp, &free_list, list) {
410 : 266 : sk_stop_timer_sync(sk, &entry->add_timer);
411 : 266 : kfree(entry);
412 : : }
413 : 3633 : }
414 : :
415 : : /* Fill all the remote addresses into the array addrs[],
416 : : * and return the array size.
417 : : */
418 : 314 : static unsigned int fill_remote_addresses_vec(struct mptcp_sock *msk,
419 : : struct mptcp_addr_info *local,
420 : : bool fullmesh,
421 : : struct mptcp_addr_info *addrs)
422 : : {
423 [ - + ]: 314 : bool deny_id0 = READ_ONCE(msk->pm.remote_deny_join_id0);
424 : 314 : struct sock *sk = (struct sock *)msk, *ssk;
425 : 314 : struct mptcp_subflow_context *subflow;
426 : 314 : struct mptcp_addr_info remote = { 0 };
427 : 314 : unsigned int subflows_max;
428 : 314 : int i = 0;
429 : :
430 : 314 : subflows_max = mptcp_pm_get_subflows_max(msk);
431 [ + + ]: 314 : remote_address((struct sock_common *)sk, &remote);
432 : :
433 : : /* Non-fullmesh endpoint, fill in the single entry
434 : : * corresponding to the primary MPC subflow remote address
435 : : */
436 [ + + ]: 314 : if (!fullmesh) {
437 [ + + ]: 284 : if (deny_id0)
438 : : return 0;
439 : :
440 [ + + ]: 280 : if (!mptcp_pm_addr_families_match(sk, local, &remote))
441 : : return 0;
442 : :
443 : 274 : msk->pm.subflows++;
444 : 274 : addrs[i++] = remote;
445 : : } else {
446 : 30 : DECLARE_BITMAP(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1);
447 : :
448 : : /* Forbid creation of new subflows matching existing
449 : : * ones, possibly already created by incoming ADD_ADDR
450 : : */
451 : 30 : bitmap_zero(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1);
452 [ + + ]: 88 : mptcp_for_each_subflow(msk, subflow)
453 [ - + ]: 58 : if (READ_ONCE(subflow->local_id) == local->id)
454 [ # # # # ]: 0 : __set_bit(subflow->remote_id, unavail_id);
455 : :
456 [ + + ]: 88 : mptcp_for_each_subflow(msk, subflow) {
457 [ + + ]: 58 : ssk = mptcp_subflow_tcp_sock(subflow);
458 [ + + ]: 58 : remote_address((struct sock_common *)ssk, &addrs[i]);
459 : 58 : addrs[i].id = READ_ONCE(subflow->remote_id);
460 [ - + - - ]: 58 : if (deny_id0 && !addrs[i].id)
461 : 0 : continue;
462 : :
463 [ - + - - : 116 : if (test_bit(addrs[i].id, unavail_id))
+ + + + ]
464 : 8 : continue;
465 : :
466 [ + + ]: 50 : if (!mptcp_pm_addr_families_match(sk, local, &addrs[i]))
467 : 2 : continue;
468 : :
469 [ + + ]: 48 : if (msk->pm.subflows < subflows_max) {
470 : : /* forbid creating multiple address towards
471 : : * this id
472 : : */
473 [ - + - - ]: 44 : __set_bit(addrs[i].id, unavail_id);
474 : 44 : msk->pm.subflows++;
475 : 44 : i++;
476 : : }
477 : : }
478 : : }
479 : :
480 : 304 : return i;
481 : : }
482 : :
483 : 888 : static void __mptcp_pm_send_ack(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
484 : : bool prio, bool backup)
485 : : {
486 [ - + ]: 888 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
487 : 888 : bool slow;
488 : :
489 [ - + - - : 888 : pr_debug("send ack for %s\n",
- - ]
490 : : prio ? "mp_prio" : (mptcp_pm_should_add_signal(msk) ? "add_addr" : "rm_addr"));
491 : :
492 : 888 : slow = lock_sock_fast(ssk);
493 [ + + ]: 888 : if (prio) {
494 : 28 : subflow->send_mp_prio = 1;
495 : 28 : subflow->request_bkup = backup;
496 : : }
497 : :
498 : 888 : __mptcp_subflow_send_ack(ssk);
499 : 888 : unlock_sock_fast(ssk, slow);
500 : 888 : }
501 : :
502 : 866 : static void mptcp_pm_send_ack(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
503 : : bool prio, bool backup)
504 : : {
505 : 866 : spin_unlock_bh(&msk->pm.lock);
506 : 866 : __mptcp_pm_send_ack(msk, subflow, prio, backup);
507 : 866 : spin_lock_bh(&msk->pm.lock);
508 : 866 : }
509 : :
510 : : static struct mptcp_pm_addr_entry *
511 : 0 : __lookup_addr_by_id(struct pm_nl_pernet *pernet, unsigned int id)
512 : : {
513 : 900 : struct mptcp_pm_addr_entry *entry;
514 : :
515 [ + - + - : 4672 : list_for_each_entry(entry, &pernet->local_addr_list, list) {
+ + + - ]
516 [ - + + + : 4666 : if (entry->addr.id == id)
+ + + + ]
517 : : return entry;
518 : : }
519 : : return NULL;
520 : : }
521 : :
522 : : static struct mptcp_pm_addr_entry *
523 : 472 : __lookup_addr(struct pm_nl_pernet *pernet, const struct mptcp_addr_info *info)
524 : : {
525 : 472 : struct mptcp_pm_addr_entry *entry;
526 : :
527 [ + + ]: 1035 : list_for_each_entry(entry, &pernet->local_addr_list, list) {
528 [ + + ]: 601 : if (mptcp_addresses_equal(&entry->addr, info, entry->addr.port))
529 : 38 : return entry;
530 : : }
531 : : return NULL;
532 : : }
533 : :
534 : 774 : static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
535 : : {
536 : 774 : struct sock *sk = (struct sock *)msk;
537 : 774 : unsigned int add_addr_signal_max;
538 : 774 : bool signal_and_subflow = false;
539 : 774 : unsigned int local_addr_max;
540 : 774 : struct pm_nl_pernet *pernet;
541 : 774 : struct mptcp_pm_local local;
542 : 774 : unsigned int subflows_max;
543 : :
544 : 774 : pernet = pm_nl_get_pernet(sock_net(sk));
545 : :
546 : 774 : add_addr_signal_max = mptcp_pm_get_add_addr_signal_max(msk);
547 : 774 : local_addr_max = mptcp_pm_get_local_addr_max(msk);
548 : 774 : subflows_max = mptcp_pm_get_subflows_max(msk);
549 : :
550 : : /* do lazy endpoint usage accounting for the MPC subflows */
551 [ + + + - ]: 774 : if (unlikely(!(msk->pm.status & BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED))) && msk->first) {
552 : 468 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(msk->first);
553 : 468 : struct mptcp_pm_addr_entry *entry;
554 : 468 : struct mptcp_addr_info mpc_addr;
555 : 468 : bool backup = false;
556 : :
557 : 468 : mptcp_local_address((struct sock_common *)msk->first, &mpc_addr);
558 : 468 : rcu_read_lock();
559 : 468 : entry = __lookup_addr(pernet, &mpc_addr);
560 [ + + ]: 468 : if (entry) {
561 [ - + - - : 34 : __clear_bit(entry->addr.id, msk->pm.id_avail_bitmap);
- - - - ]
562 : 34 : msk->mpc_endpoint_id = entry->addr.id;
563 : 34 : backup = !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
564 : : }
565 : 206 : rcu_read_unlock();
566 : :
567 [ + + ]: 468 : if (backup)
568 : 6 : mptcp_pm_send_ack(msk, subflow, true, backup);
569 : :
570 : 468 : msk->pm.status |= BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED);
571 : : }
572 : :
573 [ - + ]: 774 : pr_debug("local %d:%d signal %d:%d subflows %d:%d\n",
574 : : msk->pm.local_addr_used, local_addr_max,
575 : : msk->pm.add_addr_signaled, add_addr_signal_max,
576 : : msk->pm.subflows, subflows_max);
577 : :
578 : : /* check first for announce */
579 [ + + ]: 774 : if (msk->pm.add_addr_signaled < add_addr_signal_max) {
580 : : /* due to racing events on both ends we can reach here while
581 : : * previous add address is still running: if we invoke now
582 : : * mptcp_pm_announce_addr(), that will fail and the
583 : : * corresponding id will be marked as used.
584 : : * Instead let the PM machinery reschedule us when the
585 : : * current address announce will be completed.
586 : : */
587 [ + - ]: 310 : if (msk->pm.addr_signal & BIT(MPTCP_ADD_ADDR_SIGNAL))
588 : 0 : return;
589 : :
590 [ - + ]: 310 : if (!select_signal_address(pernet, msk, &local))
591 : 0 : goto subflow;
592 : :
593 : : /* If the alloc fails, we are on memory pressure, not worth
594 : : * continuing, and trying to create subflows.
595 : : */
596 [ + - ]: 310 : if (!mptcp_pm_alloc_anno_list(msk, &local.addr))
597 : : return;
598 : :
599 [ - + - - : 310 : __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
- - - - ]
600 : 310 : msk->pm.add_addr_signaled++;
601 : :
602 : : /* Special case for ID0: set the correct ID */
603 [ + + ]: 310 : if (local.addr.id == msk->mpc_endpoint_id)
604 : 4 : local.addr.id = 0;
605 : :
606 : 310 : mptcp_pm_announce_addr(msk, &local.addr, false);
607 : 310 : mptcp_pm_nl_addr_send_ack(msk);
608 : :
609 [ + + ]: 310 : if (local.flags & MPTCP_PM_ADDR_FLAG_SUBFLOW)
610 : 132 : signal_and_subflow = true;
611 : : }
612 : :
613 : 766 : subflow:
614 : : /* check if should create a new subflow */
615 [ + + ]: 1088 : while (msk->pm.local_addr_used < local_addr_max &&
616 [ + + ]: 354 : msk->pm.subflows < subflows_max) {
617 : 342 : struct mptcp_addr_info addrs[MPTCP_PM_ADDR_MAX];
618 : 342 : bool fullmesh;
619 : 342 : int i, nr;
620 : :
621 [ + + ]: 342 : if (signal_and_subflow)
622 : : signal_and_subflow = false;
623 [ + + ]: 334 : else if (!select_local_address(pernet, msk, &local))
624 : : break;
625 : :
626 : 314 : fullmesh = !!(local.flags & MPTCP_PM_ADDR_FLAG_FULLMESH);
627 : :
628 [ - + - - : 314 : __clear_bit(local.addr.id, msk->pm.id_avail_bitmap);
- - - - ]
629 : :
630 : : /* Special case for ID0: set the correct ID */
631 [ + + ]: 314 : if (local.addr.id == msk->mpc_endpoint_id)
632 : 6 : local.addr.id = 0;
633 : : else /* local_addr_used is not decr for ID 0 */
634 : 308 : msk->pm.local_addr_used++;
635 : :
636 : 314 : nr = fill_remote_addresses_vec(msk, &local.addr, fullmesh, addrs);
637 [ + + ]: 314 : if (nr == 0)
638 : 10 : continue;
639 : :
640 : 304 : spin_unlock_bh(&msk->pm.lock);
641 [ + + ]: 926 : for (i = 0; i < nr; i++)
642 : 318 : __mptcp_subflow_connect(sk, &local, &addrs[i]);
643 : 304 : spin_lock_bh(&msk->pm.lock);
644 : : }
645 : 774 : mptcp_pm_nl_check_work_pending(msk);
646 : : }
647 : :
648 : 90 : static void mptcp_pm_nl_fully_established(struct mptcp_sock *msk)
649 : : {
650 : 424 : mptcp_pm_create_subflow_or_signal_addr(msk);
651 : 424 : }
652 : :
653 : 42 : static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk)
654 : : {
655 : 272 : mptcp_pm_create_subflow_or_signal_addr(msk);
656 : 272 : }
657 : :
658 : : /* Fill all the local addresses into the array addrs[],
659 : : * and return the array size.
660 : : */
661 : 270 : static unsigned int fill_local_addresses_vec(struct mptcp_sock *msk,
662 : : struct mptcp_addr_info *remote,
663 : : struct mptcp_pm_local *locals)
664 : : {
665 : 270 : struct sock *sk = (struct sock *)msk;
666 : 270 : struct mptcp_pm_addr_entry *entry;
667 : 270 : struct mptcp_addr_info mpc_addr;
668 : 270 : struct pm_nl_pernet *pernet;
669 : 270 : unsigned int subflows_max;
670 : 270 : int i = 0;
671 : :
672 : 270 : pernet = pm_nl_get_pernet_from_msk(msk);
673 : 270 : subflows_max = mptcp_pm_get_subflows_max(msk);
674 : :
675 : 270 : mptcp_local_address((struct sock_common *)msk, &mpc_addr);
676 : :
677 : 270 : rcu_read_lock();
678 [ + + ]: 768 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
679 [ + + ]: 498 : if (!(entry->flags & MPTCP_PM_ADDR_FLAG_FULLMESH))
680 : 490 : continue;
681 : :
682 [ + + ]: 8 : if (!mptcp_pm_addr_families_match(sk, &entry->addr, remote))
683 : 2 : continue;
684 : :
685 [ - + ]: 6 : if (msk->pm.subflows < subflows_max) {
686 : 6 : locals[i].addr = entry->addr;
687 : 6 : locals[i].flags = entry->flags;
688 : 6 : locals[i].ifindex = entry->ifindex;
689 : :
690 : : /* Special case for ID0: set the correct ID */
691 [ + + ]: 6 : if (mptcp_addresses_equal(&locals[i].addr, &mpc_addr, locals[i].addr.port))
692 : 2 : locals[i].addr.id = 0;
693 : :
694 : 6 : msk->pm.subflows++;
695 : 6 : i++;
696 : : }
697 : : }
698 : 270 : rcu_read_unlock();
699 : :
700 : : /* If the array is empty, fill in the single
701 : : * 'IPADDRANY' local address
702 : : */
703 [ + + ]: 270 : if (!i) {
704 : 266 : memset(&locals[i], 0, sizeof(locals[i]));
705 : 532 : locals[i].addr.family =
706 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
707 [ + + + + ]: 266 : remote->family == AF_INET6 &&
708 [ # # ]: 0 : ipv6_addr_v4mapped(&remote->addr6) ? AF_INET :
709 : : #endif
710 : : remote->family;
711 : :
712 [ + + ]: 266 : if (!mptcp_pm_addr_families_match(sk, &locals[i].addr, remote))
713 : : return 0;
714 : :
715 : 244 : msk->pm.subflows++;
716 : 244 : i++;
717 : : }
718 : :
719 : 248 : return i;
720 : : }
721 : :
722 : 288 : static void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk)
723 : : {
724 : 288 : struct mptcp_pm_local locals[MPTCP_PM_ADDR_MAX];
725 : 288 : struct sock *sk = (struct sock *)msk;
726 : 288 : unsigned int add_addr_accept_max;
727 : 288 : struct mptcp_addr_info remote;
728 : 288 : unsigned int subflows_max;
729 : 288 : bool sf_created = false;
730 : 288 : int i, nr;
731 : :
732 : 288 : add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk);
733 : 288 : subflows_max = mptcp_pm_get_subflows_max(msk);
734 : :
735 [ - + ]: 288 : pr_debug("accepted %d:%d remote family %d\n",
736 : : msk->pm.add_addr_accepted, add_addr_accept_max,
737 : : msk->pm.remote.family);
738 : :
739 : 288 : remote = msk->pm.remote;
740 : 288 : mptcp_pm_announce_addr(msk, &remote, true);
741 : 288 : mptcp_pm_nl_addr_send_ack(msk);
742 : :
743 [ + + ]: 288 : if (lookup_subflow_by_daddr(&msk->conn_list, &remote))
744 : 40 : return;
745 : :
746 : : /* pick id 0 port, if none is provided the remote address */
747 [ + + ]: 270 : if (!remote.port)
748 : 238 : remote.port = sk->sk_dport;
749 : :
750 : : /* connect to the specified remote address, using whatever
751 : : * local address the routing configuration will pick.
752 : : */
753 : 270 : nr = fill_local_addresses_vec(msk, &remote, locals);
754 [ + + ]: 270 : if (nr == 0)
755 : : return;
756 : :
757 : 248 : spin_unlock_bh(&msk->pm.lock);
758 [ + + ]: 746 : for (i = 0; i < nr; i++)
759 [ + + ]: 250 : if (__mptcp_subflow_connect(sk, &locals[i], &remote) == 0)
760 : 224 : sf_created = true;
761 : 248 : spin_lock_bh(&msk->pm.lock);
762 : :
763 [ + + ]: 248 : if (sf_created) {
764 : : /* add_addr_accepted is not decr for ID 0 */
765 [ + + ]: 222 : if (remote.id)
766 : 218 : msk->pm.add_addr_accepted++;
767 [ + + ]: 222 : if (msk->pm.add_addr_accepted >= add_addr_accept_max ||
768 [ + + ]: 108 : msk->pm.subflows >= subflows_max)
769 : 248 : WRITE_ONCE(msk->pm.accept_addr, false);
770 : : }
771 : : }
772 : :
773 : 4 : bool mptcp_pm_nl_is_init_remote_addr(struct mptcp_sock *msk,
774 : : const struct mptcp_addr_info *remote)
775 : : {
776 : 4 : struct mptcp_addr_info mpc_remote;
777 : :
778 [ + - ]: 4 : remote_address((struct sock_common *)msk, &mpc_remote);
779 : 4 : return mptcp_addresses_equal(&mpc_remote, remote, remote->port);
780 : : }
781 : :
782 : 860 : void mptcp_pm_nl_addr_send_ack(struct mptcp_sock *msk)
783 : : {
784 : 860 : struct mptcp_subflow_context *subflow, *alt = NULL;
785 : :
786 : 860 : msk_owned_by_me(msk);
787 [ + - + - : 1290 : lockdep_assert_held(&msk->pm.lock);
- + ]
788 : :
789 [ + + + - ]: 860 : if (!mptcp_pm_should_add_signal(msk) &&
790 [ # # ]: 0 : !mptcp_pm_should_rm_signal(msk))
791 : : return;
792 : :
793 [ + - ]: 874 : mptcp_for_each_subflow(msk, subflow) {
794 [ + + ]: 874 : if (__mptcp_subflow_active(subflow)) {
795 [ + - ]: 860 : if (!subflow->stale) {
796 : 860 : mptcp_pm_send_ack(msk, subflow, false, false);
797 : 860 : return;
798 : : }
799 : :
800 [ # # ]: 0 : if (!alt)
801 : 0 : alt = subflow;
802 : : }
803 : : }
804 : :
805 [ # # ]: 0 : if (alt)
806 : 0 : mptcp_pm_send_ack(msk, alt, false, false);
807 : : }
808 : :
809 : 26 : int mptcp_pm_nl_mp_prio_send_ack(struct mptcp_sock *msk,
810 : : struct mptcp_addr_info *addr,
811 : : struct mptcp_addr_info *rem,
812 : : u8 bkup)
813 : : {
814 : 26 : struct mptcp_subflow_context *subflow;
815 : :
816 [ - + ]: 26 : pr_debug("bkup=%d\n", bkup);
817 : :
818 [ + + ]: 46 : mptcp_for_each_subflow(msk, subflow) {
819 : 42 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
820 : 42 : struct mptcp_addr_info local, remote;
821 : :
822 : 42 : mptcp_local_address((struct sock_common *)ssk, &local);
823 [ + + ]: 42 : if (!mptcp_addresses_equal(&local, addr, addr->port))
824 : 20 : continue;
825 : :
826 [ + + + - ]: 22 : if (rem && rem->family != AF_UNSPEC) {
827 [ + - ]: 2 : remote_address((struct sock_common *)ssk, &remote);
828 [ - + ]: 2 : if (!mptcp_addresses_equal(&remote, rem, rem->port))
829 : 0 : continue;
830 : : }
831 : :
832 : 22 : __mptcp_pm_send_ack(msk, subflow, true, bkup);
833 : 22 : return 0;
834 : : }
835 : :
836 : : return -EINVAL;
837 : : }
838 : :
839 : 192 : static void mptcp_pm_nl_rm_addr_or_subflow(struct mptcp_sock *msk,
840 : : const struct mptcp_rm_list *rm_list,
841 : : enum linux_mptcp_mib_field rm_type)
842 : : {
843 : 192 : struct mptcp_subflow_context *subflow, *tmp;
844 : 192 : struct sock *sk = (struct sock *)msk;
845 : 192 : u8 i;
846 : :
847 [ - + - - ]: 192 : pr_debug("%s rm_list_nr %d\n",
848 : : rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow", rm_list->nr);
849 : :
850 : 192 : msk_owned_by_me(msk);
851 : :
852 [ + - ]: 192 : if (sk->sk_state == TCP_LISTEN)
853 : : return;
854 : :
855 [ + - ]: 192 : if (!rm_list->nr)
856 : : return;
857 : :
858 [ + - ]: 192 : if (list_empty(&msk->conn_list))
859 : : return;
860 : :
861 [ + + ]: 402 : for (i = 0; i < rm_list->nr; i++) {
862 : 210 : u8 rm_id = rm_list->ids[i];
863 : 210 : bool removed = false;
864 : :
865 [ + + ]: 720 : mptcp_for_each_subflow_safe(msk, subflow, tmp) {
866 : 510 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
867 : 510 : u8 remote_id = READ_ONCE(subflow->remote_id);
868 : 510 : int how = RCV_SHUTDOWN | SEND_SHUTDOWN;
869 : 510 : u8 id = subflow_get_local_id(subflow);
870 : :
871 [ + + + + ]: 510 : if ((1 << inet_sk_state_load(ssk)) &
872 : : (TCPF_FIN_WAIT1 | TCPF_FIN_WAIT2 | TCPF_CLOSING | TCPF_CLOSE))
873 : 12 : continue;
874 [ + + ]: 498 : if (rm_type == MPTCP_MIB_RMADDR && remote_id != rm_id)
875 : 170 : continue;
876 [ + + ]: 328 : if (rm_type == MPTCP_MIB_RMSUBFLOW && id != rm_id)
877 : 156 : continue;
878 : :
879 [ - + - - ]: 172 : pr_debug(" -> %s rm_list_ids[%d]=%u local_id=%u remote_id=%u mpc_id=%u\n",
880 : : rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow",
881 : : i, rm_id, id, remote_id, msk->mpc_endpoint_id);
882 : 172 : spin_unlock_bh(&msk->pm.lock);
883 : 172 : mptcp_subflow_shutdown(sk, ssk, how);
884 : 172 : removed |= subflow->request_join;
885 : :
886 : : /* the following takes care of updating the subflows counter */
887 : 172 : mptcp_close_ssk(sk, ssk, subflow);
888 : 172 : spin_lock_bh(&msk->pm.lock);
889 : :
890 [ + + ]: 172 : if (rm_type == MPTCP_MIB_RMSUBFLOW)
891 [ - + ]: 90 : __MPTCP_INC_STATS(sock_net(sk), rm_type);
892 : : }
893 : :
894 [ + + ]: 210 : if (rm_type == MPTCP_MIB_RMADDR)
895 [ + - ]: 114 : __MPTCP_INC_STATS(sock_net(sk), rm_type);
896 : :
897 [ + + ]: 210 : if (!removed)
898 : 120 : continue;
899 : :
900 [ - + ]: 90 : if (!mptcp_pm_is_kernel(msk))
901 : 0 : continue;
902 : :
903 [ + + ]: 90 : if (rm_type == MPTCP_MIB_RMADDR && rm_id &&
904 [ - + ]: 44 : !WARN_ON_ONCE(msk->pm.add_addr_accepted == 0)) {
905 : : /* Note: if the subflow has been closed before, this
906 : : * add_addr_accepted counter will not be decremented.
907 : : */
908 [ + - ]: 44 : if (--msk->pm.add_addr_accepted < mptcp_pm_get_add_addr_accept_max(msk))
909 : 210 : WRITE_ONCE(msk->pm.accept_addr, true);
910 : : }
911 : : }
912 : : }
913 : :
914 : 0 : static void mptcp_pm_nl_rm_addr_received(struct mptcp_sock *msk)
915 : : {
916 : 106 : mptcp_pm_nl_rm_addr_or_subflow(msk, &msk->pm.rm_list_rx, MPTCP_MIB_RMADDR);
917 : 106 : }
918 : :
919 : 0 : static void mptcp_pm_nl_rm_subflow_received(struct mptcp_sock *msk,
920 : : const struct mptcp_rm_list *rm_list)
921 : : {
922 : 86 : mptcp_pm_nl_rm_addr_or_subflow(msk, rm_list, MPTCP_MIB_RMSUBFLOW);
923 : 12 : }
924 : :
925 : 10726 : void mptcp_pm_nl_work(struct mptcp_sock *msk)
926 : : {
927 : 10726 : struct mptcp_pm_data *pm = &msk->pm;
928 : :
929 : 10726 : msk_owned_by_me(msk);
930 : :
931 [ + + ]: 10726 : if (!(pm->status & MPTCP_PM_WORK_MASK))
932 : : return;
933 : :
934 : 946 : spin_lock_bh(&msk->pm.lock);
935 : :
936 [ - + ]: 946 : pr_debug("msk=%p status=%x\n", msk, pm->status);
937 [ + + ]: 946 : if (pm->status & BIT(MPTCP_PM_ADD_ADDR_RECEIVED)) {
938 : 288 : pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_RECEIVED);
939 : 288 : mptcp_pm_nl_add_addr_received(msk);
940 : : }
941 [ + + ]: 946 : if (pm->status & BIT(MPTCP_PM_ADD_ADDR_SEND_ACK)) {
942 : 122 : pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_SEND_ACK);
943 : 122 : mptcp_pm_nl_addr_send_ack(msk);
944 : : }
945 [ + + ]: 946 : if (pm->status & BIT(MPTCP_PM_RM_ADDR_RECEIVED)) {
946 : 106 : pm->status &= ~BIT(MPTCP_PM_RM_ADDR_RECEIVED);
947 : 106 : mptcp_pm_nl_rm_addr_received(msk);
948 : : }
949 [ + + ]: 946 : if (pm->status & BIT(MPTCP_PM_ESTABLISHED)) {
950 : 424 : pm->status &= ~BIT(MPTCP_PM_ESTABLISHED);
951 : 424 : mptcp_pm_nl_fully_established(msk);
952 : : }
953 [ + + ]: 946 : if (pm->status & BIT(MPTCP_PM_SUBFLOW_ESTABLISHED)) {
954 : 272 : pm->status &= ~BIT(MPTCP_PM_SUBFLOW_ESTABLISHED);
955 : 272 : mptcp_pm_nl_subflow_established(msk);
956 : : }
957 : :
958 : 946 : spin_unlock_bh(&msk->pm.lock);
959 : : }
960 : :
961 : 0 : static bool address_use_port(struct mptcp_pm_addr_entry *entry)
962 : : {
963 : 1222 : return (entry->flags &
964 : : (MPTCP_PM_ADDR_FLAG_SIGNAL | MPTCP_PM_ADDR_FLAG_SUBFLOW)) ==
965 : : MPTCP_PM_ADDR_FLAG_SIGNAL;
966 : : }
967 : :
968 : : /* caller must ensure the RCU grace period is already elapsed */
969 : 1232 : static void __mptcp_pm_release_addr_entry(struct mptcp_pm_addr_entry *entry)
970 : : {
971 [ + + ]: 1232 : if (entry->lsk)
972 : 6 : sock_release(entry->lsk);
973 : 1232 : kfree(entry);
974 : 1232 : }
975 : :
976 : 1248 : static int mptcp_pm_nl_append_new_local_addr(struct pm_nl_pernet *pernet,
977 : : struct mptcp_pm_addr_entry *entry,
978 : : bool needs_id)
979 : : {
980 : 1248 : struct mptcp_pm_addr_entry *cur, *del_entry = NULL;
981 : 1248 : unsigned int addr_max;
982 : 1248 : int ret = -EINVAL;
983 : :
984 : 1248 : spin_lock_bh(&pernet->lock);
985 : : /* to keep the code simple, don't do IDR-like allocation for address ID,
986 : : * just bail when we exceed limits
987 : : */
988 [ + + ]: 1248 : if (pernet->next_id == MPTCP_PM_MAX_ADDR_ID)
989 : 4 : pernet->next_id = 1;
990 [ - + ]: 1248 : if (pernet->addrs >= MPTCP_PM_ADDR_MAX) {
991 : 0 : ret = -ERANGE;
992 : 0 : goto out;
993 : : }
994 [ - + - - : 2496 : if (test_bit(entry->addr.id, pernet->id_bitmap)) {
- - - - -
+ - + ]
995 : 0 : ret = -EBUSY;
996 : 0 : goto out;
997 : : }
998 : :
999 : : /* do not insert duplicate address, differentiate on port only
1000 : : * singled addresses
1001 : : */
1002 [ + + ]: 1248 : if (!address_use_port(entry))
1003 : 938 : entry->addr.port = 0;
1004 [ + + ]: 5244 : list_for_each_entry(cur, &pernet->local_addr_list, list) {
1005 [ + + ]: 4002 : if (mptcp_addresses_equal(&cur->addr, &entry->addr,
1006 [ + + - + ]: 4002 : cur->addr.port || entry->addr.port)) {
1007 : : /* allow replacing the exiting endpoint only if such
1008 : : * endpoint is an implicit one and the user-space
1009 : : * did not provide an endpoint id
1010 : : */
1011 [ + + ]: 6 : if (!(cur->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT)) {
1012 : 2 : ret = -EEXIST;
1013 : 2 : goto out;
1014 : : }
1015 [ + + ]: 4 : if (entry->addr.id)
1016 : 2 : goto out;
1017 : :
1018 : 2 : pernet->addrs--;
1019 : 2 : entry->addr.id = cur->addr.id;
1020 : 2 : list_del_rcu(&cur->list);
1021 : 2 : del_entry = cur;
1022 : 2 : break;
1023 : : }
1024 : : }
1025 : :
1026 [ + + + - ]: 1244 : if (!entry->addr.id && needs_id) {
1027 : 674 : find_next:
1028 : 1352 : entry->addr.id = find_next_zero_bit(pernet->id_bitmap,
1029 : : MPTCP_PM_MAX_ADDR_ID + 1,
1030 : 676 : pernet->next_id);
1031 [ + + + - ]: 676 : if (!entry->addr.id && pernet->next_id != 1) {
1032 : 2 : pernet->next_id = 1;
1033 : 2 : goto find_next;
1034 : : }
1035 : : }
1036 : :
1037 [ - + - - ]: 1244 : if (!entry->addr.id && needs_id)
1038 : 0 : goto out;
1039 : :
1040 [ - + - - : 1244 : __set_bit(entry->addr.id, pernet->id_bitmap);
- - - - ]
1041 [ + + ]: 1244 : if (entry->addr.id > pernet->next_id)
1042 : 764 : pernet->next_id = entry->addr.id;
1043 : :
1044 [ + + ]: 1244 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1045 : 318 : addr_max = pernet->add_addr_signal_max;
1046 : 318 : WRITE_ONCE(pernet->add_addr_signal_max, addr_max + 1);
1047 : : }
1048 [ + + ]: 1244 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1049 : 268 : addr_max = pernet->local_addr_max;
1050 : 268 : WRITE_ONCE(pernet->local_addr_max, addr_max + 1);
1051 : : }
1052 : :
1053 : 1244 : pernet->addrs++;
1054 [ + + ]: 1244 : if (!entry->addr.port)
1055 : 1222 : list_add_tail_rcu(&entry->list, &pernet->local_addr_list);
1056 : : else
1057 : 22 : list_add_rcu(&entry->list, &pernet->local_addr_list);
1058 : 1244 : ret = entry->addr.id;
1059 : :
1060 : 1248 : out:
1061 : 1248 : spin_unlock_bh(&pernet->lock);
1062 : :
1063 : : /* just replaced an existing entry, free it */
1064 [ + + ]: 1248 : if (del_entry) {
1065 : 2 : synchronize_rcu();
1066 : 2 : __mptcp_pm_release_addr_entry(del_entry);
1067 : : }
1068 : 1248 : return ret;
1069 : : }
1070 : :
1071 : : static struct lock_class_key mptcp_slock_keys[2];
1072 : : static struct lock_class_key mptcp_keys[2];
1073 : :
1074 : 22 : static int mptcp_pm_nl_create_listen_socket(struct sock *sk,
1075 : : struct mptcp_pm_addr_entry *entry)
1076 : : {
1077 : 22 : bool is_ipv6 = sk->sk_family == AF_INET6;
1078 : 22 : int addrlen = sizeof(struct sockaddr_in);
1079 : 22 : struct sockaddr_storage addr;
1080 : 22 : struct sock *newsk, *ssk;
1081 : 22 : int backlog = 1024;
1082 : 22 : int err;
1083 : :
1084 : 22 : err = sock_create_kern(sock_net(sk), entry->addr.family,
1085 : : SOCK_STREAM, IPPROTO_MPTCP, &entry->lsk);
1086 [ + - ]: 22 : if (err)
1087 : : return err;
1088 : :
1089 : 22 : newsk = entry->lsk->sk;
1090 [ + - ]: 22 : if (!newsk)
1091 : : return -EINVAL;
1092 : :
1093 : : /* The subflow socket lock is acquired in a nested to the msk one
1094 : : * in several places, even by the TCP stack, and this msk is a kernel
1095 : : * socket: lockdep complains. Instead of propagating the _nested
1096 : : * modifiers in several places, re-init the lock class for the msk
1097 : : * socket to an mptcp specific one.
1098 : : */
1099 [ + - + - ]: 44 : sock_lock_init_class_and_name(newsk,
1100 : : is_ipv6 ? "mlock-AF_INET6" : "mlock-AF_INET",
1101 : : &mptcp_slock_keys[is_ipv6],
1102 : : is_ipv6 ? "msk_lock-AF_INET6" : "msk_lock-AF_INET",
1103 : : &mptcp_keys[is_ipv6]);
1104 : :
1105 : 22 : lock_sock(newsk);
1106 [ - + ]: 22 : ssk = __mptcp_nmpc_sk(mptcp_sk(newsk));
1107 : 22 : release_sock(newsk);
1108 [ - + ]: 22 : if (IS_ERR(ssk))
1109 : 0 : return PTR_ERR(ssk);
1110 : :
1111 : 22 : mptcp_info2sockaddr(&entry->addr, &addr, entry->addr.family);
1112 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1113 [ - + ]: 22 : if (entry->addr.family == AF_INET6)
1114 : 0 : addrlen = sizeof(struct sockaddr_in6);
1115 : : #endif
1116 [ + - ]: 22 : if (ssk->sk_family == AF_INET)
1117 : 22 : err = inet_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
1118 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1119 [ # # ]: 0 : else if (ssk->sk_family == AF_INET6)
1120 : 0 : err = inet6_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
1121 : : #endif
1122 [ + - ]: 22 : if (err)
1123 : : return err;
1124 : :
1125 : : /* We don't use mptcp_set_state() here because it needs to be called
1126 : : * under the msk socket lock. For the moment, that will not bring
1127 : : * anything more than only calling inet_sk_state_store(), because the
1128 : : * old status is known (TCP_CLOSE).
1129 : : */
1130 : 22 : inet_sk_state_store(newsk, TCP_LISTEN);
1131 : 22 : lock_sock(ssk);
1132 : 22 : WRITE_ONCE(mptcp_subflow_ctx(ssk)->pm_listener, true);
1133 : 22 : err = __inet_listen_sk(ssk, backlog);
1134 [ + - ]: 22 : if (!err)
1135 : 22 : mptcp_event_pm_listener(ssk, MPTCP_EVENT_LISTENER_CREATED);
1136 : 22 : release_sock(ssk);
1137 : 22 : return err;
1138 : : }
1139 : :
1140 : 360 : int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk, struct mptcp_addr_info *skc)
1141 : : {
1142 : 360 : struct mptcp_pm_addr_entry *entry;
1143 : 360 : struct pm_nl_pernet *pernet;
1144 : 360 : int ret = -1;
1145 : :
1146 : 360 : pernet = pm_nl_get_pernet_from_msk(msk);
1147 : :
1148 : 360 : rcu_read_lock();
1149 [ + + ]: 706 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
1150 [ + + ]: 566 : if (mptcp_addresses_equal(&entry->addr, skc, entry->addr.port)) {
1151 : 220 : ret = entry->addr.id;
1152 : 220 : break;
1153 : : }
1154 : : }
1155 : 250 : rcu_read_unlock();
1156 : 360 : if (ret >= 0)
1157 : 220 : return ret;
1158 : :
1159 : : /* address not found, add to local list */
1160 : 140 : entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
1161 [ + - ]: 140 : if (!entry)
1162 : : return -ENOMEM;
1163 : :
1164 : 140 : entry->addr = *skc;
1165 : 140 : entry->addr.id = 0;
1166 : 140 : entry->addr.port = 0;
1167 : 140 : entry->ifindex = 0;
1168 : 140 : entry->flags = MPTCP_PM_ADDR_FLAG_IMPLICIT;
1169 : 140 : entry->lsk = NULL;
1170 : 140 : ret = mptcp_pm_nl_append_new_local_addr(pernet, entry, true);
1171 [ - + ]: 140 : if (ret < 0)
1172 : 0 : kfree(entry);
1173 : :
1174 : : return ret;
1175 : : }
1176 : :
1177 : 720 : bool mptcp_pm_nl_is_backup(struct mptcp_sock *msk, struct mptcp_addr_info *skc)
1178 : : {
1179 : 720 : struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk);
1180 : 720 : struct mptcp_pm_addr_entry *entry;
1181 : 720 : bool backup = false;
1182 : :
1183 : 720 : rcu_read_lock();
1184 [ + + ]: 1218 : list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) {
1185 [ + + ]: 866 : if (mptcp_addresses_equal(&entry->addr, skc, entry->addr.port)) {
1186 : 368 : backup = !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
1187 : 368 : break;
1188 : : }
1189 : : }
1190 : 720 : rcu_read_unlock();
1191 : :
1192 : 720 : return backup;
1193 : : }
1194 : :
1195 : : #define MPTCP_PM_CMD_GRP_OFFSET 0
1196 : : #define MPTCP_PM_EV_GRP_OFFSET 1
1197 : :
1198 : : static const struct genl_multicast_group mptcp_pm_mcgrps[] = {
1199 : : [MPTCP_PM_CMD_GRP_OFFSET] = { .name = MPTCP_PM_CMD_GRP_NAME, },
1200 : : [MPTCP_PM_EV_GRP_OFFSET] = { .name = MPTCP_PM_EV_GRP_NAME,
1201 : : .flags = GENL_MCAST_CAP_NET_ADMIN,
1202 : : },
1203 : : };
1204 : :
1205 : 311 : void mptcp_pm_nl_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk)
1206 : : {
1207 : 311 : struct mptcp_subflow_context *iter, *subflow = mptcp_subflow_ctx(ssk);
1208 : 311 : struct sock *sk = (struct sock *)msk;
1209 : 311 : unsigned int active_max_loss_cnt;
1210 : 311 : struct net *net = sock_net(sk);
1211 : 311 : unsigned int stale_loss_cnt;
1212 : 311 : bool slow;
1213 : :
1214 : 311 : stale_loss_cnt = mptcp_stale_loss_cnt(net);
1215 [ + + + - : 311 : if (subflow->stale || !stale_loss_cnt || subflow->stale_count <= stale_loss_cnt)
+ + ]
1216 : : return;
1217 : :
1218 : : /* look for another available subflow not in loss state */
1219 : 204 : active_max_loss_cnt = max_t(int, stale_loss_cnt - 1, 1);
1220 [ + + ]: 413 : mptcp_for_each_subflow(msk, iter) {
1221 [ + + + + ]: 226 : if (iter != subflow && mptcp_subflow_active(iter) &&
1222 [ + + ]: 22 : iter->stale_count < active_max_loss_cnt) {
1223 : : /* we have some alternatives, try to mark this subflow as idle ...*/
1224 : 17 : slow = lock_sock_fast(ssk);
1225 [ + + + - ]: 34 : if (!tcp_rtx_and_write_queues_empty(ssk)) {
1226 : 17 : subflow->stale = 1;
1227 : 17 : __mptcp_retransmit_pending_data(sk);
1228 [ + - ]: 17 : MPTCP_INC_STATS(net, MPTCP_MIB_SUBFLOWSTALE);
1229 : : }
1230 : 17 : unlock_sock_fast(ssk, slow);
1231 : :
1232 : : /* always try to push the pending data regardless of re-injections:
1233 : : * we can possibly use backup subflows now, and subflow selection
1234 : : * is cheap under the msk socket lock
1235 : : */
1236 : 17 : __mptcp_push_pending(sk, 0);
1237 : 17 : return;
1238 : : }
1239 : : }
1240 : : }
1241 : :
1242 : 48 : static int mptcp_pm_family_to_addr(int family)
1243 : : {
1244 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1245 : 1238 : if (family == AF_INET6)
1246 : 106 : return MPTCP_PM_ADDR_ATTR_ADDR6;
1247 : : #endif
1248 : : return MPTCP_PM_ADDR_ATTR_ADDR4;
1249 : : }
1250 : :
1251 : 1870 : static int mptcp_pm_parse_pm_addr_attr(struct nlattr *tb[],
1252 : : const struct nlattr *attr,
1253 : : struct genl_info *info,
1254 : : struct mptcp_addr_info *addr,
1255 : : bool require_family)
1256 : : {
1257 : 1870 : int err, addr_addr;
1258 : :
1259 [ - + ]: 1870 : if (!attr) {
1260 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "missing address info");
1261 : 0 : return -EINVAL;
1262 : : }
1263 : :
1264 : : /* no validation needed - was already done via nested policy */
1265 : 1870 : err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
1266 : : mptcp_pm_address_nl_policy, info->extack);
1267 [ + - ]: 1870 : if (err)
1268 : : return err;
1269 : :
1270 [ + + ]: 1870 : if (tb[MPTCP_PM_ADDR_ATTR_ID])
1271 : 1262 : addr->id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]);
1272 : :
1273 [ + + ]: 1870 : if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) {
1274 [ + - ]: 632 : if (!require_family)
1275 : : return 0;
1276 : :
1277 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
1278 : : "missing family");
1279 : 0 : return -EINVAL;
1280 : : }
1281 : :
1282 [ - + ]: 1238 : addr->family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]);
1283 : 1238 : if (addr->family != AF_INET
1284 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1285 [ - + ]: 1238 : && addr->family != AF_INET6
1286 : : #endif
1287 : : ) {
1288 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
1289 : : "unknown address family");
1290 : 0 : return -EINVAL;
1291 : : }
1292 [ + + ]: 1238 : addr_addr = mptcp_pm_family_to_addr(addr->family);
1293 [ - + ]: 1238 : if (!tb[addr_addr]) {
1294 [ # # ]: 0 : NL_SET_ERR_MSG_ATTR(info->extack, attr,
1295 : : "missing address data");
1296 : 0 : return -EINVAL;
1297 : : }
1298 : :
1299 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1300 [ + + ]: 1238 : if (addr->family == AF_INET6)
1301 : 106 : addr->addr6 = nla_get_in6_addr(tb[addr_addr]);
1302 : : else
1303 : : #endif
1304 : 1132 : addr->addr.s_addr = nla_get_in_addr(tb[addr_addr]);
1305 : :
1306 [ + + ]: 1238 : if (tb[MPTCP_PM_ADDR_ATTR_PORT])
1307 : 96 : addr->port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
1308 : :
1309 : : return 0;
1310 : : }
1311 : :
1312 : 62 : int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info,
1313 : : struct mptcp_addr_info *addr)
1314 : : {
1315 : 62 : struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
1316 : :
1317 : 62 : memset(addr, 0, sizeof(*addr));
1318 : :
1319 : 62 : return mptcp_pm_parse_pm_addr_attr(tb, attr, info, addr, true);
1320 : : }
1321 : :
1322 : 1808 : int mptcp_pm_parse_entry(struct nlattr *attr, struct genl_info *info,
1323 : : bool require_family,
1324 : : struct mptcp_pm_addr_entry *entry)
1325 : : {
1326 : 1808 : struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
1327 : 1808 : int err;
1328 : :
1329 : 1808 : memset(entry, 0, sizeof(*entry));
1330 : :
1331 : 1808 : err = mptcp_pm_parse_pm_addr_attr(tb, attr, info, &entry->addr, require_family);
1332 [ + - ]: 1808 : if (err)
1333 : : return err;
1334 : :
1335 [ + + ]: 1808 : if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) {
1336 : 62 : u32 val = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]);
1337 : :
1338 : 62 : entry->ifindex = val;
1339 : : }
1340 : :
1341 [ + + ]: 1808 : if (tb[MPTCP_PM_ADDR_ATTR_FLAGS])
1342 : 682 : entry->flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]);
1343 : :
1344 [ + + ]: 1808 : if (tb[MPTCP_PM_ADDR_ATTR_PORT])
1345 : 34 : entry->addr.port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
1346 : :
1347 : : return 0;
1348 : : }
1349 : :
1350 : 1233 : static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info)
1351 : : {
1352 : 2439 : return pm_nl_get_pernet(genl_info_net(info));
1353 : : }
1354 : :
1355 : 1104 : static int mptcp_nl_add_subflow_or_signal_addr(struct net *net,
1356 : : struct mptcp_addr_info *addr)
1357 : : {
1358 : 1104 : struct mptcp_sock *msk;
1359 : 1104 : long s_slot = 0, s_num = 0;
1360 : :
1361 [ + + ]: 1168 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1362 : 64 : struct sock *sk = (struct sock *)msk;
1363 : 64 : struct mptcp_addr_info mpc_addr;
1364 : :
1365 [ + + + + : 64 : if (!READ_ONCE(msk->fully_established) ||
- + ]
1366 [ # # ]: 0 : mptcp_pm_is_userspace(msk))
1367 : 0 : goto next;
1368 : :
1369 : : /* if the endp linked to the init sf is re-added with a != ID */
1370 : 64 : mptcp_local_address((struct sock_common *)msk, &mpc_addr);
1371 : :
1372 : 64 : lock_sock(sk);
1373 : 64 : spin_lock_bh(&msk->pm.lock);
1374 [ + + ]: 64 : if (mptcp_addresses_equal(addr, &mpc_addr, addr->port))
1375 : 10 : msk->mpc_endpoint_id = addr->id;
1376 : 64 : mptcp_pm_create_subflow_or_signal_addr(msk);
1377 : 64 : spin_unlock_bh(&msk->pm.lock);
1378 : 64 : release_sock(sk);
1379 : :
1380 : 64 : next:
1381 : 64 : sock_put(sk);
1382 : 64 : cond_resched();
1383 : : }
1384 : :
1385 : 1104 : return 0;
1386 : : }
1387 : :
1388 : 1108 : static bool mptcp_pm_has_addr_attr_id(const struct nlattr *attr,
1389 : : struct genl_info *info)
1390 : : {
1391 : 1108 : struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
1392 : :
1393 [ + - ]: 1108 : if (!nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
1394 : 1108 : mptcp_pm_address_nl_policy, info->extack) &&
1395 [ + + ]: 1108 : tb[MPTCP_PM_ADDR_ATTR_ID])
1396 : 570 : return true;
1397 : : return false;
1398 : : }
1399 : :
1400 : 1108 : int mptcp_pm_nl_add_addr_doit(struct sk_buff *skb, struct genl_info *info)
1401 : : {
1402 : 1108 : struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
1403 : 1108 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1404 : 1108 : struct mptcp_pm_addr_entry addr, *entry;
1405 : 1108 : int ret;
1406 : :
1407 : 1108 : ret = mptcp_pm_parse_entry(attr, info, true, &addr);
1408 [ + - ]: 1108 : if (ret < 0)
1409 : : return ret;
1410 : :
1411 [ + + - + ]: 1108 : if (addr.addr.port && !address_use_port(&addr)) {
1412 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "flags must have signal and not subflow when using port");
1413 : 0 : return -EINVAL;
1414 : : }
1415 : :
1416 [ - + ]: 1108 : if (addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL &&
1417 : : addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) {
1418 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "flags mustn't have both signal and fullmesh");
1419 : 0 : return -EINVAL;
1420 : : }
1421 : :
1422 [ - + ]: 1108 : if (addr.flags & MPTCP_PM_ADDR_FLAG_IMPLICIT) {
1423 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "can't create IMPLICIT endpoint");
1424 : 0 : return -EINVAL;
1425 : : }
1426 : :
1427 : 1108 : entry = kzalloc(sizeof(*entry), GFP_KERNEL_ACCOUNT);
1428 [ - + ]: 1108 : if (!entry) {
1429 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "can't allocate addr");
1430 : 0 : return -ENOMEM;
1431 : : }
1432 : :
1433 : 1108 : *entry = addr;
1434 [ + + ]: 1108 : if (entry->addr.port) {
1435 : 22 : ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry);
1436 [ - + ]: 22 : if (ret) {
1437 [ # # # # : 0 : GENL_SET_ERR_MSG_FMT(info, "create listen socket error: %d", ret);
# # ]
1438 : 0 : goto out_free;
1439 : : }
1440 : : }
1441 : 2264 : ret = mptcp_pm_nl_append_new_local_addr(pernet, entry,
1442 : 1108 : !mptcp_pm_has_addr_attr_id(attr, info));
1443 [ + + ]: 1108 : if (ret < 0) {
1444 [ + - - + : 4 : GENL_SET_ERR_MSG_FMT(info, "too many addresses or duplicate one: %d", ret);
- - ]
1445 : 4 : goto out_free;
1446 : : }
1447 : :
1448 : 1104 : mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk), &entry->addr);
1449 : 1104 : return 0;
1450 : :
1451 : 4 : out_free:
1452 : 4 : __mptcp_pm_release_addr_entry(entry);
1453 : 4 : return ret;
1454 : : }
1455 : :
1456 : 130 : static bool remove_anno_list_by_saddr(struct mptcp_sock *msk,
1457 : : const struct mptcp_addr_info *addr)
1458 : : {
1459 : 130 : struct mptcp_pm_add_entry *entry;
1460 : :
1461 : 130 : entry = mptcp_pm_del_add_timer(msk, addr, false);
1462 [ + + ]: 130 : if (entry) {
1463 : 78 : kfree(entry);
1464 : 78 : return true;
1465 : : }
1466 : :
1467 : : return false;
1468 : : }
1469 : :
1470 : 0 : static u8 mptcp_endp_get_local_id(struct mptcp_sock *msk,
1471 : : const struct mptcp_addr_info *addr)
1472 : : {
1473 [ + - + - ]: 111 : return msk->mpc_endpoint_id == addr->id ? 0 : addr->id;
1474 : : }
1475 : :
1476 : 64 : static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk,
1477 : : const struct mptcp_addr_info *addr,
1478 : : bool force)
1479 : : {
1480 : 64 : struct mptcp_rm_list list = { .nr = 0 };
1481 : 64 : bool ret;
1482 : :
1483 [ + + ]: 64 : list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
1484 : :
1485 : 64 : ret = remove_anno_list_by_saddr(msk, addr);
1486 [ + + ]: 64 : if (ret || force) {
1487 : 62 : spin_lock_bh(&msk->pm.lock);
1488 [ + + ]: 62 : if (ret) {
1489 [ - + - - : 32 : __set_bit(addr->id, msk->pm.id_avail_bitmap);
- - - - ]
1490 : 32 : msk->pm.add_addr_signaled--;
1491 : : }
1492 : 62 : mptcp_pm_remove_addr(msk, &list);
1493 : 62 : spin_unlock_bh(&msk->pm.lock);
1494 : : }
1495 : 64 : return ret;
1496 : : }
1497 : :
1498 : 48 : static void __mark_subflow_endp_available(struct mptcp_sock *msk, u8 id)
1499 : : {
1500 : : /* If it was marked as used, and not ID 0, decrement local_addr_used */
1501 [ + + + + : 72 : if (!__test_and_set_bit(id ? : msk->mpc_endpoint_id, msk->pm.id_avail_bitmap) &&
+ + ]
1502 [ - + ]: 38 : id && !WARN_ON_ONCE(msk->pm.local_addr_used == 0))
1503 : 38 : msk->pm.local_addr_used--;
1504 : 48 : }
1505 : :
1506 : 562 : static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net,
1507 : : const struct mptcp_pm_addr_entry *entry)
1508 : : {
1509 : 562 : const struct mptcp_addr_info *addr = &entry->addr;
1510 : 562 : struct mptcp_rm_list list = { .nr = 1 };
1511 : 562 : long s_slot = 0, s_num = 0;
1512 : 562 : struct mptcp_sock *msk;
1513 : :
1514 [ - + ]: 562 : pr_debug("remove_id=%d\n", addr->id);
1515 : :
1516 [ + + ]: 628 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1517 : 66 : struct sock *sk = (struct sock *)msk;
1518 : 66 : bool remove_subflow;
1519 : :
1520 [ + + ]: 66 : if (mptcp_pm_is_userspace(msk))
1521 : 2 : goto next;
1522 : :
1523 [ - + ]: 64 : if (list_empty(&msk->conn_list)) {
1524 : 0 : mptcp_pm_remove_anno_addr(msk, addr, false);
1525 : 0 : goto next;
1526 : : }
1527 : :
1528 : 64 : lock_sock(sk);
1529 : 64 : remove_subflow = lookup_subflow_by_saddr(&msk->conn_list, addr);
1530 [ + + ]: 128 : mptcp_pm_remove_anno_addr(msk, addr, remove_subflow &&
1531 [ - + ]: 56 : !(entry->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT));
1532 : :
1533 [ + + ]: 64 : list.ids[0] = mptcp_endp_get_local_id(msk, addr);
1534 [ + + ]: 64 : if (remove_subflow) {
1535 : 56 : spin_lock_bh(&msk->pm.lock);
1536 : 56 : mptcp_pm_nl_rm_subflow_received(msk, &list);
1537 : 56 : spin_unlock_bh(&msk->pm.lock);
1538 : : }
1539 : :
1540 [ + + ]: 64 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1541 : 30 : spin_lock_bh(&msk->pm.lock);
1542 : 30 : __mark_subflow_endp_available(msk, list.ids[0]);
1543 : 30 : spin_unlock_bh(&msk->pm.lock);
1544 : : }
1545 : :
1546 [ + + ]: 64 : if (msk->mpc_endpoint_id == entry->addr.id)
1547 : 10 : msk->mpc_endpoint_id = 0;
1548 : 64 : release_sock(sk);
1549 : :
1550 : 66 : next:
1551 : 66 : sock_put(sk);
1552 : 66 : cond_resched();
1553 : : }
1554 : :
1555 : 562 : return 0;
1556 : : }
1557 : :
1558 : 4 : static int mptcp_nl_remove_id_zero_address(struct net *net,
1559 : : struct mptcp_addr_info *addr)
1560 : : {
1561 : 4 : struct mptcp_rm_list list = { .nr = 0 };
1562 : 4 : long s_slot = 0, s_num = 0;
1563 : 4 : struct mptcp_sock *msk;
1564 : :
1565 : 4 : list.ids[list.nr++] = 0;
1566 : :
1567 [ + + ]: 8 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1568 : 4 : struct sock *sk = (struct sock *)msk;
1569 : 4 : struct mptcp_addr_info msk_local;
1570 : :
1571 [ + - - + ]: 4 : if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
1572 : 0 : goto next;
1573 : :
1574 : 4 : mptcp_local_address((struct sock_common *)msk, &msk_local);
1575 [ - + ]: 4 : if (!mptcp_addresses_equal(&msk_local, addr, addr->port))
1576 : 0 : goto next;
1577 : :
1578 : 4 : lock_sock(sk);
1579 : 4 : spin_lock_bh(&msk->pm.lock);
1580 : 4 : mptcp_pm_remove_addr(msk, &list);
1581 : 4 : mptcp_pm_nl_rm_subflow_received(msk, &list);
1582 : 4 : __mark_subflow_endp_available(msk, 0);
1583 : 4 : spin_unlock_bh(&msk->pm.lock);
1584 : 4 : release_sock(sk);
1585 : :
1586 : 4 : next:
1587 : 4 : sock_put(sk);
1588 : 4 : cond_resched();
1589 : : }
1590 : :
1591 : 4 : return 0;
1592 : : }
1593 : :
1594 : 566 : int mptcp_pm_nl_del_addr_doit(struct sk_buff *skb, struct genl_info *info)
1595 : : {
1596 : 566 : struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
1597 : 566 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1598 : 566 : struct mptcp_pm_addr_entry addr, *entry;
1599 : 566 : unsigned int addr_max;
1600 : 566 : int ret;
1601 : :
1602 : 566 : ret = mptcp_pm_parse_entry(attr, info, false, &addr);
1603 [ - + ]: 566 : if (ret < 0)
1604 : : return ret;
1605 : :
1606 : : /* the zero id address is special: the first address used by the msk
1607 : : * always gets such an id, so different subflows can have different zero
1608 : : * id addresses. Additionally zero id is not accounted for in id_bitmap.
1609 : : * Let's use an 'mptcp_rm_list' instead of the common remove code.
1610 : : */
1611 [ + + ]: 566 : if (addr.addr.id == 0)
1612 : 4 : return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr);
1613 : :
1614 : 562 : spin_lock_bh(&pernet->lock);
1615 : 562 : entry = __lookup_addr_by_id(pernet, addr.addr.id);
1616 [ - + ]: 562 : if (!entry) {
1617 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "address not found");
1618 : 0 : spin_unlock_bh(&pernet->lock);
1619 : 0 : return -EINVAL;
1620 : : }
1621 [ + + ]: 562 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
1622 : 36 : addr_max = pernet->add_addr_signal_max;
1623 : 36 : WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1);
1624 : : }
1625 [ + + ]: 562 : if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) {
1626 : 34 : addr_max = pernet->local_addr_max;
1627 : 34 : WRITE_ONCE(pernet->local_addr_max, addr_max - 1);
1628 : : }
1629 : :
1630 : 562 : pernet->addrs--;
1631 [ - + ]: 562 : list_del_rcu(&entry->list);
1632 [ - + - - : 562 : __clear_bit(entry->addr.id, pernet->id_bitmap);
- - - - ]
1633 : 562 : spin_unlock_bh(&pernet->lock);
1634 : :
1635 : 562 : mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), entry);
1636 : 562 : synchronize_rcu();
1637 : 562 : __mptcp_pm_release_addr_entry(entry);
1638 : :
1639 : 562 : return ret;
1640 : : }
1641 : :
1642 : : /* Called from the userspace PM only */
1643 : 28 : void mptcp_pm_remove_addrs(struct mptcp_sock *msk, struct list_head *rm_list)
1644 : : {
1645 : 28 : struct mptcp_rm_list alist = { .nr = 0 };
1646 : 28 : struct mptcp_pm_addr_entry *entry;
1647 : 28 : int anno_nr = 0;
1648 : :
1649 [ + + ]: 56 : list_for_each_entry(entry, rm_list, list) {
1650 [ + - ]: 28 : if (alist.nr >= MPTCP_RM_IDS_MAX)
1651 : : break;
1652 : :
1653 : : /* only delete if either announced or matching a subflow */
1654 [ + - ]: 28 : if (remove_anno_list_by_saddr(msk, &entry->addr))
1655 : 28 : anno_nr++;
1656 [ # # ]: 0 : else if (!lookup_subflow_by_saddr(&msk->conn_list,
1657 : : &entry->addr))
1658 : 0 : continue;
1659 : :
1660 : 28 : alist.ids[alist.nr++] = entry->addr.id;
1661 : : }
1662 : :
1663 [ + - ]: 28 : if (alist.nr) {
1664 : 28 : spin_lock_bh(&msk->pm.lock);
1665 : 28 : msk->pm.add_addr_signaled -= anno_nr;
1666 : 28 : mptcp_pm_remove_addr(msk, &alist);
1667 : 28 : spin_unlock_bh(&msk->pm.lock);
1668 : : }
1669 : 28 : }
1670 : :
1671 : : /* Called from the in-kernel PM only */
1672 : 18 : static void mptcp_pm_flush_addrs_and_subflows(struct mptcp_sock *msk,
1673 : : struct list_head *rm_list)
1674 : : {
1675 : 18 : struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 };
1676 : 18 : struct mptcp_pm_addr_entry *entry;
1677 : :
1678 [ + + ]: 56 : list_for_each_entry(entry, rm_list, list) {
1679 [ + - + + ]: 76 : if (slist.nr < MPTCP_RM_IDS_MAX &&
1680 : 38 : lookup_subflow_by_saddr(&msk->conn_list, &entry->addr))
1681 [ + - ]: 44 : slist.ids[slist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1682 : :
1683 [ + - + + ]: 76 : if (alist.nr < MPTCP_RM_IDS_MAX &&
1684 : 38 : remove_anno_list_by_saddr(msk, &entry->addr))
1685 [ + - ]: 36 : alist.ids[alist.nr++] = mptcp_endp_get_local_id(msk, &entry->addr);
1686 : : }
1687 : :
1688 : 18 : spin_lock_bh(&msk->pm.lock);
1689 [ + + ]: 18 : if (alist.nr) {
1690 : 10 : msk->pm.add_addr_signaled -= alist.nr;
1691 : 10 : mptcp_pm_remove_addr(msk, &alist);
1692 : : }
1693 [ + + ]: 18 : if (slist.nr)
1694 : 12 : mptcp_pm_nl_rm_subflow_received(msk, &slist);
1695 : : /* Reset counters: maybe some subflows have been removed before */
1696 : 18 : bitmap_fill(msk->pm.id_avail_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1697 : 18 : msk->pm.local_addr_used = 0;
1698 : 18 : spin_unlock_bh(&msk->pm.lock);
1699 : 18 : }
1700 : :
1701 : 178 : static void mptcp_nl_flush_addrs_list(struct net *net,
1702 : : struct list_head *rm_list)
1703 : : {
1704 : 178 : long s_slot = 0, s_num = 0;
1705 : 178 : struct mptcp_sock *msk;
1706 : :
1707 [ + + ]: 178 : if (list_empty(rm_list))
1708 : 154 : return;
1709 : :
1710 [ + + ]: 42 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
1711 : 18 : struct sock *sk = (struct sock *)msk;
1712 : :
1713 [ + - ]: 18 : if (!mptcp_pm_is_userspace(msk)) {
1714 : 18 : lock_sock(sk);
1715 : 18 : mptcp_pm_flush_addrs_and_subflows(msk, rm_list);
1716 : 18 : release_sock(sk);
1717 : : }
1718 : :
1719 : 18 : sock_put(sk);
1720 : 18 : cond_resched();
1721 : : }
1722 : : }
1723 : :
1724 : : /* caller must ensure the RCU grace period is already elapsed */
1725 : 1167 : static void __flush_addrs(struct list_head *list)
1726 : : {
1727 [ + + ]: 1831 : while (!list_empty(list)) {
1728 : 664 : struct mptcp_pm_addr_entry *cur;
1729 : :
1730 : 664 : cur = list_entry(list->next,
1731 : : struct mptcp_pm_addr_entry, list);
1732 : 664 : list_del_rcu(&cur->list);
1733 : 664 : __mptcp_pm_release_addr_entry(cur);
1734 : : }
1735 : 1167 : }
1736 : :
1737 : 6 : static void __reset_counters(struct pm_nl_pernet *pernet)
1738 : : {
1739 : 178 : WRITE_ONCE(pernet->add_addr_signal_max, 0);
1740 : 178 : WRITE_ONCE(pernet->add_addr_accept_max, 0);
1741 : 178 : WRITE_ONCE(pernet->local_addr_max, 0);
1742 : 178 : pernet->addrs = 0;
1743 : : }
1744 : :
1745 : 178 : int mptcp_pm_nl_flush_addrs_doit(struct sk_buff *skb, struct genl_info *info)
1746 : : {
1747 : 178 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1748 : 178 : LIST_HEAD(free_list);
1749 : :
1750 : 178 : spin_lock_bh(&pernet->lock);
1751 [ + + ]: 178 : list_splice_init(&pernet->local_addr_list, &free_list);
1752 : 178 : __reset_counters(pernet);
1753 : 178 : pernet->next_id = 1;
1754 : 178 : bitmap_zero(pernet->id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
1755 : 178 : spin_unlock_bh(&pernet->lock);
1756 : 178 : mptcp_nl_flush_addrs_list(sock_net(skb->sk), &free_list);
1757 : 178 : synchronize_rcu();
1758 : 178 : __flush_addrs(&free_list);
1759 : 178 : return 0;
1760 : : }
1761 : :
1762 : 204 : int mptcp_nl_fill_addr(struct sk_buff *skb,
1763 : : struct mptcp_pm_addr_entry *entry)
1764 : : {
1765 : 204 : struct mptcp_addr_info *addr = &entry->addr;
1766 : 204 : struct nlattr *attr;
1767 : :
1768 : 204 : attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR);
1769 [ - + ]: 204 : if (!attr)
1770 : : return -EMSGSIZE;
1771 : :
1772 [ - + ]: 204 : if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family))
1773 : 0 : goto nla_put_failure;
1774 [ - + ]: 204 : if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_PORT, ntohs(addr->port)))
1775 : 0 : goto nla_put_failure;
1776 [ - + ]: 204 : if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id))
1777 : 0 : goto nla_put_failure;
1778 [ - + ]: 204 : if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->flags))
1779 : 0 : goto nla_put_failure;
1780 [ + + - + ]: 210 : if (entry->ifindex &&
1781 [ # # ]: 0 : nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->ifindex))
1782 : 0 : goto nla_put_failure;
1783 : :
1784 [ + + - + ]: 390 : if (addr->family == AF_INET &&
1785 [ # # ]: 186 : nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4,
1786 : : addr->addr.s_addr))
1787 : 0 : goto nla_put_failure;
1788 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
1789 [ + + - + ]: 222 : else if (addr->family == AF_INET6 &&
1790 [ # # ]: 18 : nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6))
1791 : 0 : goto nla_put_failure;
1792 : : #endif
1793 : 204 : nla_nest_end(skb, attr);
1794 : 204 : return 0;
1795 : :
1796 : 0 : nla_put_failure:
1797 : 0 : nla_nest_cancel(skb, attr);
1798 : 0 : return -EMSGSIZE;
1799 : : }
1800 : :
1801 : 22 : int mptcp_pm_nl_get_addr(struct sk_buff *skb, struct genl_info *info)
1802 : : {
1803 : 22 : struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
1804 : 22 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1805 : 22 : struct mptcp_pm_addr_entry addr, *entry;
1806 : 22 : struct sk_buff *msg;
1807 : 22 : void *reply;
1808 : 22 : int ret;
1809 : :
1810 : 22 : ret = mptcp_pm_parse_entry(attr, info, false, &addr);
1811 [ + - ]: 22 : if (ret < 0)
1812 : : return ret;
1813 : :
1814 : 22 : msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1815 [ + - ]: 22 : if (!msg)
1816 : : return -ENOMEM;
1817 : :
1818 : 22 : reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1819 : 22 : info->genlhdr->cmd);
1820 [ - + ]: 22 : if (!reply) {
1821 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1822 : 0 : ret = -EMSGSIZE;
1823 : 0 : goto fail;
1824 : : }
1825 : :
1826 : 22 : spin_lock_bh(&pernet->lock);
1827 : 22 : entry = __lookup_addr_by_id(pernet, addr.addr.id);
1828 [ + + ]: 22 : if (!entry) {
1829 [ + - ]: 6 : GENL_SET_ERR_MSG(info, "address not found");
1830 : 6 : ret = -EINVAL;
1831 : 6 : goto unlock_fail;
1832 : : }
1833 : :
1834 : 16 : ret = mptcp_nl_fill_addr(msg, entry);
1835 [ - + ]: 16 : if (ret)
1836 : 0 : goto unlock_fail;
1837 : :
1838 : 16 : genlmsg_end(msg, reply);
1839 : 16 : ret = genlmsg_reply(msg, info);
1840 : 16 : spin_unlock_bh(&pernet->lock);
1841 : 16 : return ret;
1842 : :
1843 : 6 : unlock_fail:
1844 : 6 : spin_unlock_bh(&pernet->lock);
1845 : :
1846 : 6 : fail:
1847 : 6 : nlmsg_free(msg);
1848 : 6 : return ret;
1849 : : }
1850 : :
1851 : 28 : int mptcp_pm_nl_get_addr_doit(struct sk_buff *skb, struct genl_info *info)
1852 : : {
1853 : 28 : return mptcp_pm_get_addr(skb, info);
1854 : : }
1855 : :
1856 : 216 : int mptcp_pm_nl_dump_addr(struct sk_buff *msg,
1857 : : struct netlink_callback *cb)
1858 : : {
1859 : 216 : struct net *net = sock_net(msg->sk);
1860 : 216 : struct mptcp_pm_addr_entry *entry;
1861 : 216 : struct pm_nl_pernet *pernet;
1862 : 216 : int id = cb->args[0];
1863 : 216 : void *hdr;
1864 : 216 : int i;
1865 : :
1866 : 216 : pernet = pm_nl_get_pernet(net);
1867 : :
1868 : 216 : spin_lock_bh(&pernet->lock);
1869 [ + + ]: 54066 : for (i = id; i < MPTCP_PM_MAX_ADDR_ID + 1; i++) {
1870 [ - + - - : 107268 : if (test_bit(i, pernet->id_bitmap)) {
- - - - +
+ + + ]
1871 : 274 : entry = __lookup_addr_by_id(pernet, i);
1872 [ - + ]: 274 : if (!entry)
1873 : : break;
1874 : :
1875 [ + + ]: 274 : if (entry->addr.id <= id)
1876 : 102 : continue;
1877 : :
1878 : 172 : hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
1879 : 172 : cb->nlh->nlmsg_seq, &mptcp_genl_family,
1880 : : NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
1881 [ - + ]: 172 : if (!hdr)
1882 : : break;
1883 : :
1884 [ - + ]: 172 : if (mptcp_nl_fill_addr(msg, entry) < 0) {
1885 : 0 : genlmsg_cancel(msg, hdr);
1886 : 0 : break;
1887 : : }
1888 : :
1889 : 172 : id = entry->addr.id;
1890 : 172 : genlmsg_end(msg, hdr);
1891 : : }
1892 : : }
1893 : 216 : spin_unlock_bh(&pernet->lock);
1894 : :
1895 : 216 : cb->args[0] = id;
1896 : 216 : return msg->len;
1897 : : }
1898 : :
1899 : 236 : int mptcp_pm_nl_get_addr_dumpit(struct sk_buff *msg,
1900 : : struct netlink_callback *cb)
1901 : : {
1902 : 236 : return mptcp_pm_dump_addr(msg, cb);
1903 : : }
1904 : :
1905 : 1162 : static int parse_limit(struct genl_info *info, int id, unsigned int *limit)
1906 : : {
1907 : 1162 : struct nlattr *attr = info->attrs[id];
1908 : :
1909 [ - + ]: 1162 : if (!attr)
1910 : : return 0;
1911 : :
1912 [ + + ]: 1162 : *limit = nla_get_u32(attr);
1913 [ + + ]: 1162 : if (*limit > MPTCP_PM_ADDR_MAX) {
1914 [ + - ]: 4 : GENL_SET_ERR_MSG(info, "limit greater than maximum");
1915 : 4 : return -EINVAL;
1916 : : }
1917 : : return 0;
1918 : : }
1919 : :
1920 : 582 : int mptcp_pm_nl_set_limits_doit(struct sk_buff *skb, struct genl_info *info)
1921 : : {
1922 : 582 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1923 : 582 : unsigned int rcv_addrs, subflows;
1924 : 582 : int ret;
1925 : :
1926 : 582 : spin_lock_bh(&pernet->lock);
1927 : 582 : rcv_addrs = pernet->add_addr_accept_max;
1928 : 582 : ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs);
1929 [ + + ]: 582 : if (ret)
1930 : 2 : goto unlock;
1931 : :
1932 : 580 : subflows = pernet->subflows_max;
1933 : 580 : ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows);
1934 [ + + ]: 580 : if (ret)
1935 : 2 : goto unlock;
1936 : :
1937 : 578 : WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs);
1938 : 578 : WRITE_ONCE(pernet->subflows_max, subflows);
1939 : :
1940 : 582 : unlock:
1941 : 582 : spin_unlock_bh(&pernet->lock);
1942 : 582 : return ret;
1943 : : }
1944 : :
1945 : 10 : int mptcp_pm_nl_get_limits_doit(struct sk_buff *skb, struct genl_info *info)
1946 : : {
1947 : 10 : struct pm_nl_pernet *pernet = genl_info_pm_nl(info);
1948 : 10 : struct sk_buff *msg;
1949 : 10 : void *reply;
1950 : :
1951 : 10 : msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1952 [ + - ]: 10 : if (!msg)
1953 : : return -ENOMEM;
1954 : :
1955 : 10 : reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
1956 : : MPTCP_PM_CMD_GET_LIMITS);
1957 [ - + ]: 10 : if (!reply)
1958 : 0 : goto fail;
1959 : :
1960 [ - + ]: 10 : if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS,
1961 : 10 : READ_ONCE(pernet->add_addr_accept_max)))
1962 : 0 : goto fail;
1963 : :
1964 [ - + ]: 10 : if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS,
1965 : 10 : READ_ONCE(pernet->subflows_max)))
1966 : 0 : goto fail;
1967 : :
1968 : 10 : genlmsg_end(msg, reply);
1969 : 10 : return genlmsg_reply(msg, info);
1970 : :
1971 : 0 : fail:
1972 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
1973 : 0 : nlmsg_free(msg);
1974 : 0 : return -EMSGSIZE;
1975 : : }
1976 : :
1977 : 14 : static void mptcp_pm_nl_fullmesh(struct mptcp_sock *msk,
1978 : : struct mptcp_addr_info *addr)
1979 : : {
1980 : 14 : struct mptcp_rm_list list = { .nr = 0 };
1981 : :
1982 [ + - ]: 14 : list.ids[list.nr++] = mptcp_endp_get_local_id(msk, addr);
1983 : :
1984 : 14 : spin_lock_bh(&msk->pm.lock);
1985 : 14 : mptcp_pm_nl_rm_subflow_received(msk, &list);
1986 : 14 : __mark_subflow_endp_available(msk, list.ids[0]);
1987 : 14 : mptcp_pm_create_subflow_or_signal_addr(msk);
1988 : 14 : spin_unlock_bh(&msk->pm.lock);
1989 : 14 : }
1990 : :
1991 : 46 : static int mptcp_nl_set_flags(struct net *net,
1992 : : struct mptcp_addr_info *addr,
1993 : : u8 bkup, u8 changed)
1994 : : {
1995 : 46 : long s_slot = 0, s_num = 0;
1996 : 46 : struct mptcp_sock *msk;
1997 : 46 : int ret = -EINVAL;
1998 : :
1999 [ + + ]: 82 : while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) {
2000 : 36 : struct sock *sk = (struct sock *)msk;
2001 : :
2002 [ + - - + ]: 36 : if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk))
2003 : 0 : goto next;
2004 : :
2005 : 36 : lock_sock(sk);
2006 [ + + ]: 36 : if (changed & MPTCP_PM_ADDR_FLAG_BACKUP)
2007 : 24 : ret = mptcp_pm_nl_mp_prio_send_ack(msk, addr, NULL, bkup);
2008 [ + + ]: 36 : if (changed & MPTCP_PM_ADDR_FLAG_FULLMESH)
2009 : 14 : mptcp_pm_nl_fullmesh(msk, addr);
2010 : 36 : release_sock(sk);
2011 : :
2012 : 36 : next:
2013 : 36 : sock_put(sk);
2014 : 36 : cond_resched();
2015 : : }
2016 : :
2017 : 46 : return ret;
2018 : : }
2019 : :
2020 : 46 : int mptcp_pm_nl_set_flags(struct sk_buff *skb, struct genl_info *info)
2021 : : {
2022 : 46 : struct mptcp_pm_addr_entry addr = { .addr = { .family = AF_UNSPEC }, };
2023 : 46 : struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
2024 : 46 : u8 changed, mask = MPTCP_PM_ADDR_FLAG_BACKUP |
2025 : : MPTCP_PM_ADDR_FLAG_FULLMESH;
2026 : 46 : struct net *net = sock_net(skb->sk);
2027 : 46 : struct mptcp_pm_addr_entry *entry;
2028 : 46 : struct pm_nl_pernet *pernet;
2029 : 46 : u8 lookup_by_id = 0;
2030 : 46 : u8 bkup = 0;
2031 : 46 : int ret;
2032 : :
2033 : 46 : pernet = pm_nl_get_pernet(net);
2034 : :
2035 : 46 : ret = mptcp_pm_parse_entry(attr, info, false, &addr);
2036 [ + - ]: 46 : if (ret < 0)
2037 : : return ret;
2038 : :
2039 [ + + ]: 46 : if (addr.addr.family == AF_UNSPEC) {
2040 : 42 : lookup_by_id = 1;
2041 [ - + ]: 42 : if (!addr.addr.id) {
2042 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "missing required inputs");
2043 : 0 : return -EOPNOTSUPP;
2044 : : }
2045 : : }
2046 : :
2047 [ + + ]: 46 : if (addr.flags & MPTCP_PM_ADDR_FLAG_BACKUP)
2048 : 20 : bkup = 1;
2049 : :
2050 : 46 : spin_lock_bh(&pernet->lock);
2051 [ + + ]: 46 : entry = lookup_by_id ? __lookup_addr_by_id(pernet, addr.addr.id) :
2052 : 4 : __lookup_addr(pernet, &addr.addr);
2053 [ - + ]: 46 : if (!entry) {
2054 : 0 : spin_unlock_bh(&pernet->lock);
2055 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "address not found");
2056 : 0 : return -EINVAL;
2057 : : }
2058 [ + + ]: 46 : if ((addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) &&
2059 [ - + ]: 12 : (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) {
2060 : 0 : spin_unlock_bh(&pernet->lock);
2061 [ # # ]: 0 : GENL_SET_ERR_MSG(info, "invalid addr flags");
2062 : 0 : return -EINVAL;
2063 : : }
2064 : :
2065 : 46 : changed = (addr.flags ^ entry->flags) & mask;
2066 : 46 : entry->flags = (entry->flags & ~mask) | (addr.flags & mask);
2067 : 46 : addr = *entry;
2068 : 46 : spin_unlock_bh(&pernet->lock);
2069 : :
2070 : 46 : mptcp_nl_set_flags(net, &addr.addr, bkup, changed);
2071 : 46 : return 0;
2072 : : }
2073 : :
2074 : 48 : int mptcp_pm_nl_set_flags_doit(struct sk_buff *skb, struct genl_info *info)
2075 : : {
2076 : 48 : return mptcp_pm_set_flags(skb, info);
2077 : : }
2078 : :
2079 : 430 : static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb, gfp_t gfp)
2080 : : {
2081 : 430 : genlmsg_multicast_netns(&mptcp_genl_family, net,
2082 : : nlskb, 0, MPTCP_PM_EV_GRP_OFFSET, gfp);
2083 : 430 : }
2084 : :
2085 : 78 : bool mptcp_userspace_pm_active(const struct mptcp_sock *msk)
2086 : : {
2087 : 78 : return genl_has_listeners(&mptcp_genl_family,
2088 : : sock_net((const struct sock *)msk),
2089 : : MPTCP_PM_EV_GRP_OFFSET);
2090 : : }
2091 : :
2092 : 268 : static int mptcp_event_add_subflow(struct sk_buff *skb, const struct sock *ssk)
2093 : : {
2094 : 268 : const struct inet_sock *issk = inet_sk(ssk);
2095 : 268 : const struct mptcp_subflow_context *sf;
2096 : :
2097 [ - + ]: 268 : if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
2098 : : return -EMSGSIZE;
2099 : :
2100 [ + + - ]: 268 : switch (ssk->sk_family) {
2101 : 152 : case AF_INET:
2102 [ - + ]: 152 : if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
2103 : : return -EMSGSIZE;
2104 [ - + ]: 152 : if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, issk->inet_daddr))
2105 : : return -EMSGSIZE;
2106 : : break;
2107 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
2108 : : case AF_INET6: {
2109 [ + - ]: 116 : const struct ipv6_pinfo *np = inet6_sk(ssk);
2110 : :
2111 [ - + ]: 116 : if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr))
2112 : : return -EMSGSIZE;
2113 [ - + ]: 116 : if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &ssk->sk_v6_daddr))
2114 : : return -EMSGSIZE;
2115 : : break;
2116 : : }
2117 : : #endif
2118 : : default:
2119 : 0 : WARN_ON_ONCE(1);
2120 : 0 : return -EMSGSIZE;
2121 : : }
2122 : :
2123 [ - + ]: 268 : if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
2124 : : return -EMSGSIZE;
2125 [ - + ]: 268 : if (nla_put_be16(skb, MPTCP_ATTR_DPORT, issk->inet_dport))
2126 : : return -EMSGSIZE;
2127 : :
2128 [ - + ]: 268 : sf = mptcp_subflow_ctx(ssk);
2129 [ - + ]: 268 : if (WARN_ON_ONCE(!sf))
2130 : 0 : return -EINVAL;
2131 : :
2132 [ - + ]: 268 : if (nla_put_u8(skb, MPTCP_ATTR_LOC_ID, subflow_get_local_id(sf)))
2133 : : return -EMSGSIZE;
2134 : :
2135 [ - + ]: 268 : if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, sf->remote_id))
2136 : : return -EMSGSIZE;
2137 : :
2138 : : return 0;
2139 : : }
2140 : :
2141 : 188 : static int mptcp_event_put_token_and_ssk(struct sk_buff *skb,
2142 : : const struct mptcp_sock *msk,
2143 : : const struct sock *ssk)
2144 : : {
2145 : 188 : const struct sock *sk = (const struct sock *)msk;
2146 : 188 : const struct mptcp_subflow_context *sf;
2147 : 188 : u8 sk_err;
2148 : :
2149 [ - + ]: 188 : if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
2150 : : return -EMSGSIZE;
2151 : :
2152 [ - + ]: 188 : if (mptcp_event_add_subflow(skb, ssk))
2153 : : return -EMSGSIZE;
2154 : :
2155 [ - + ]: 188 : sf = mptcp_subflow_ctx(ssk);
2156 [ - + ]: 188 : if (WARN_ON_ONCE(!sf))
2157 : 0 : return -EINVAL;
2158 : :
2159 [ - + ]: 188 : if (nla_put_u8(skb, MPTCP_ATTR_BACKUP, sf->backup))
2160 : : return -EMSGSIZE;
2161 : :
2162 [ + + - + ]: 204 : if (ssk->sk_bound_dev_if &&
2163 [ # # ]: 0 : nla_put_s32(skb, MPTCP_ATTR_IF_IDX, ssk->sk_bound_dev_if))
2164 : : return -EMSGSIZE;
2165 : :
2166 : 188 : sk_err = READ_ONCE(ssk->sk_err);
2167 [ - + - - : 188 : if (sk_err && sk->sk_state == TCP_ESTABLISHED &&
- - ]
2168 [ # # ]: 0 : nla_put_u8(skb, MPTCP_ATTR_ERROR, sk_err))
2169 : : return -EMSGSIZE;
2170 : :
2171 : : return 0;
2172 : : }
2173 : :
2174 : 0 : static int mptcp_event_sub_established(struct sk_buff *skb,
2175 : : const struct mptcp_sock *msk,
2176 : : const struct sock *ssk)
2177 : : {
2178 : 106 : return mptcp_event_put_token_and_ssk(skb, msk, ssk);
2179 : : }
2180 : :
2181 : 82 : static int mptcp_event_sub_closed(struct sk_buff *skb,
2182 : : const struct mptcp_sock *msk,
2183 : : const struct sock *ssk)
2184 : : {
2185 : 82 : const struct mptcp_subflow_context *sf;
2186 : :
2187 [ - + ]: 82 : if (mptcp_event_put_token_and_ssk(skb, msk, ssk))
2188 : : return -EMSGSIZE;
2189 : :
2190 [ + - ]: 82 : sf = mptcp_subflow_ctx(ssk);
2191 [ + - ]: 82 : if (!sf->reset_seen)
2192 : : return 0;
2193 : :
2194 [ # # ]: 0 : if (nla_put_u32(skb, MPTCP_ATTR_RESET_REASON, sf->reset_reason))
2195 : : return -EMSGSIZE;
2196 : :
2197 [ # # ]: 0 : if (nla_put_u32(skb, MPTCP_ATTR_RESET_FLAGS, sf->reset_transient))
2198 : : return -EMSGSIZE;
2199 : :
2200 : : return 0;
2201 : : }
2202 : :
2203 : 80 : static int mptcp_event_created(struct sk_buff *skb,
2204 : : const struct mptcp_sock *msk,
2205 : : const struct sock *ssk)
2206 : : {
2207 : 80 : int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token));
2208 : :
2209 [ + - ]: 80 : if (err)
2210 : : return err;
2211 : :
2212 [ + + + - ]: 120 : if (nla_put_u8(skb, MPTCP_ATTR_SERVER_SIDE, READ_ONCE(msk->pm.server_side)))
2213 : : return -EMSGSIZE;
2214 : :
2215 : 80 : return mptcp_event_add_subflow(skb, ssk);
2216 : : }
2217 : :
2218 : 114 : void mptcp_event_addr_removed(const struct mptcp_sock *msk, uint8_t id)
2219 : : {
2220 : 114 : struct net *net = sock_net((const struct sock *)msk);
2221 : 114 : struct nlmsghdr *nlh;
2222 : 114 : struct sk_buff *skb;
2223 : :
2224 [ + + ]: 114 : if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2225 : : return;
2226 : :
2227 : 48 : skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
2228 [ + - ]: 48 : if (!skb)
2229 : : return;
2230 : :
2231 : 48 : nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, MPTCP_EVENT_REMOVED);
2232 [ - + ]: 48 : if (!nlh)
2233 : 0 : goto nla_put_failure;
2234 : :
2235 [ - + ]: 48 : if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
2236 : 0 : goto nla_put_failure;
2237 : :
2238 [ - + ]: 48 : if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, id))
2239 : 0 : goto nla_put_failure;
2240 : :
2241 : 48 : genlmsg_end(skb, nlh);
2242 : 48 : mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
2243 : 48 : return;
2244 : :
2245 : 0 : nla_put_failure:
2246 : 0 : nlmsg_free(skb);
2247 : : }
2248 : :
2249 : 360 : void mptcp_event_addr_announced(const struct sock *ssk,
2250 : : const struct mptcp_addr_info *info)
2251 : : {
2252 [ - + ]: 360 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
2253 [ - + ]: 360 : struct mptcp_sock *msk = mptcp_sk(subflow->conn);
2254 : 360 : struct net *net = sock_net(ssk);
2255 : 360 : struct nlmsghdr *nlh;
2256 : 360 : struct sk_buff *skb;
2257 : :
2258 [ + + ]: 360 : if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2259 : : return;
2260 : :
2261 : 48 : skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
2262 [ + - ]: 48 : if (!skb)
2263 : : return;
2264 : :
2265 : 48 : nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0,
2266 : : MPTCP_EVENT_ANNOUNCED);
2267 [ - + ]: 48 : if (!nlh)
2268 : 0 : goto nla_put_failure;
2269 : :
2270 [ - + ]: 48 : if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
2271 : 0 : goto nla_put_failure;
2272 : :
2273 [ - + ]: 48 : if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, info->id))
2274 : 0 : goto nla_put_failure;
2275 : :
2276 [ - + ]: 58 : if (nla_put_be16(skb, MPTCP_ATTR_DPORT,
2277 [ + + ]: 48 : info->port == 0 ?
2278 : 38 : inet_sk(ssk)->inet_dport :
2279 : : info->port))
2280 : 0 : goto nla_put_failure;
2281 : :
2282 [ + + - ]: 48 : switch (info->family) {
2283 : 40 : case AF_INET:
2284 [ - + ]: 40 : if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, info->addr.s_addr))
2285 : 0 : goto nla_put_failure;
2286 : : break;
2287 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
2288 : 8 : case AF_INET6:
2289 [ - + ]: 8 : if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &info->addr6))
2290 : 0 : goto nla_put_failure;
2291 : : break;
2292 : : #endif
2293 : : default:
2294 : 0 : WARN_ON_ONCE(1);
2295 : 0 : goto nla_put_failure;
2296 : : }
2297 : :
2298 : 48 : genlmsg_end(skb, nlh);
2299 : 48 : mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
2300 : 48 : return;
2301 : :
2302 : 0 : nla_put_failure:
2303 : 0 : nlmsg_free(skb);
2304 : : }
2305 : :
2306 : 2500 : void mptcp_event_pm_listener(const struct sock *ssk,
2307 : : enum mptcp_event_type event)
2308 : : {
2309 : 2500 : const struct inet_sock *issk = inet_sk(ssk);
2310 : 2500 : struct net *net = sock_net(ssk);
2311 : 2500 : struct nlmsghdr *nlh;
2312 : 2500 : struct sk_buff *skb;
2313 : :
2314 [ + + ]: 2500 : if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2315 : : return;
2316 : :
2317 : 54 : skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2318 [ + - ]: 54 : if (!skb)
2319 : : return;
2320 : :
2321 : 54 : nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, event);
2322 [ - + ]: 54 : if (!nlh)
2323 : 0 : goto nla_put_failure;
2324 : :
2325 [ - + ]: 54 : if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
2326 : 0 : goto nla_put_failure;
2327 : :
2328 [ - + ]: 54 : if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
2329 : 0 : goto nla_put_failure;
2330 : :
2331 [ + + - ]: 54 : switch (ssk->sk_family) {
2332 : 26 : case AF_INET:
2333 [ - + ]: 26 : if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
2334 : 0 : goto nla_put_failure;
2335 : : break;
2336 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
2337 : : case AF_INET6: {
2338 [ + - ]: 28 : const struct ipv6_pinfo *np = inet6_sk(ssk);
2339 : :
2340 [ - + ]: 28 : if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr))
2341 : 0 : goto nla_put_failure;
2342 : : break;
2343 : : }
2344 : : #endif
2345 : : default:
2346 : 0 : WARN_ON_ONCE(1);
2347 : 0 : goto nla_put_failure;
2348 : : }
2349 : :
2350 : 54 : genlmsg_end(skb, nlh);
2351 : 54 : mptcp_nl_mcast_send(net, skb, GFP_KERNEL);
2352 : 54 : return;
2353 : :
2354 : 0 : nla_put_failure:
2355 : 0 : nlmsg_free(skb);
2356 : : }
2357 : :
2358 : 8062 : void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk,
2359 : : const struct sock *ssk, gfp_t gfp)
2360 : : {
2361 : 8062 : struct net *net = sock_net((const struct sock *)msk);
2362 : 8062 : struct nlmsghdr *nlh;
2363 : 8062 : struct sk_buff *skb;
2364 : :
2365 [ + + ]: 8062 : if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
2366 : : return;
2367 : :
2368 : 280 : skb = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
2369 [ + - ]: 280 : if (!skb)
2370 : : return;
2371 : :
2372 : 280 : nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, type);
2373 [ - + ]: 280 : if (!nlh)
2374 : 0 : goto nla_put_failure;
2375 : :
2376 [ - + + - : 280 : switch (type) {
+ + - ]
2377 : : case MPTCP_EVENT_UNSPEC:
2378 : 0 : WARN_ON_ONCE(1);
2379 : 0 : break;
2380 : 80 : case MPTCP_EVENT_CREATED:
2381 : : case MPTCP_EVENT_ESTABLISHED:
2382 [ - + ]: 80 : if (mptcp_event_created(skb, msk, ssk) < 0)
2383 : 0 : goto nla_put_failure;
2384 : : break;
2385 : : case MPTCP_EVENT_CLOSED:
2386 [ - + ]: 12 : if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)) < 0)
2387 : 0 : goto nla_put_failure;
2388 : : break;
2389 : : case MPTCP_EVENT_ANNOUNCED:
2390 : : case MPTCP_EVENT_REMOVED:
2391 : : /* call mptcp_event_addr_announced()/removed instead */
2392 : 0 : WARN_ON_ONCE(1);
2393 : 0 : break;
2394 : : case MPTCP_EVENT_SUB_ESTABLISHED:
2395 : : case MPTCP_EVENT_SUB_PRIORITY:
2396 [ - + ]: 106 : if (mptcp_event_sub_established(skb, msk, ssk) < 0)
2397 : 0 : goto nla_put_failure;
2398 : : break;
2399 : 82 : case MPTCP_EVENT_SUB_CLOSED:
2400 [ - + ]: 82 : if (mptcp_event_sub_closed(skb, msk, ssk) < 0)
2401 : 0 : goto nla_put_failure;
2402 : : break;
2403 : : case MPTCP_EVENT_LISTENER_CREATED:
2404 : : case MPTCP_EVENT_LISTENER_CLOSED:
2405 : : break;
2406 : : }
2407 : :
2408 : 280 : genlmsg_end(skb, nlh);
2409 : 280 : mptcp_nl_mcast_send(net, skb, gfp);
2410 : 280 : return;
2411 : :
2412 : 0 : nla_put_failure:
2413 : 0 : nlmsg_free(skb);
2414 : : }
2415 : :
2416 : : struct genl_family mptcp_genl_family __ro_after_init = {
2417 : : .name = MPTCP_PM_NAME,
2418 : : .version = MPTCP_PM_VER,
2419 : : .netnsok = true,
2420 : : .module = THIS_MODULE,
2421 : : .ops = mptcp_pm_nl_ops,
2422 : : .n_ops = ARRAY_SIZE(mptcp_pm_nl_ops),
2423 : : .resv_start_op = MPTCP_PM_CMD_SUBFLOW_DESTROY + 1,
2424 : : .mcgrps = mptcp_pm_mcgrps,
2425 : : .n_mcgrps = ARRAY_SIZE(mptcp_pm_mcgrps),
2426 : : };
2427 : :
2428 : 1082 : static int __net_init pm_nl_init_net(struct net *net)
2429 : : {
2430 : 1082 : struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
2431 : :
2432 : 1082 : INIT_LIST_HEAD_RCU(&pernet->local_addr_list);
2433 : :
2434 : : /* Cit. 2 subflows ought to be enough for anybody. */
2435 : 1082 : pernet->subflows_max = 2;
2436 : 1082 : pernet->next_id = 1;
2437 : 1082 : pernet->stale_loss_cnt = 4;
2438 : 1082 : spin_lock_init(&pernet->lock);
2439 : :
2440 : : /* No need to initialize other pernet fields, the struct is zeroed at
2441 : : * allocation time.
2442 : : */
2443 : :
2444 : 1082 : return 0;
2445 : : }
2446 : :
2447 : 917 : static void __net_exit pm_nl_exit_net(struct list_head *net_list)
2448 : : {
2449 : 917 : struct net *net;
2450 : :
2451 [ + + ]: 1906 : list_for_each_entry(net, net_list, exit_list) {
2452 : 989 : struct pm_nl_pernet *pernet = pm_nl_get_pernet(net);
2453 : :
2454 : : /* net is removed from namespace list, can't race with
2455 : : * other modifiers, also netns core already waited for a
2456 : : * RCU grace period.
2457 : : */
2458 : 989 : __flush_addrs(&pernet->local_addr_list);
2459 : : }
2460 : 917 : }
2461 : :
2462 : : static struct pernet_operations mptcp_pm_pernet_ops = {
2463 : : .init = pm_nl_init_net,
2464 : : .exit_batch = pm_nl_exit_net,
2465 : : .id = &pm_nl_pernet_id,
2466 : : .size = sizeof(struct pm_nl_pernet),
2467 : : };
2468 : :
2469 : 4 : void __init mptcp_pm_nl_init(void)
2470 : : {
2471 [ - + ]: 4 : if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0)
2472 : 0 : panic("Failed to register MPTCP PM pernet subsystem.\n");
2473 : :
2474 [ - + ]: 4 : if (genl_register_family(&mptcp_genl_family))
2475 : 0 : panic("Failed to register MPTCP PM netlink family\n");
2476 : 4 : }
|
