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