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