Debian Codegraph @

src/network/networkd-setlink.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/if_arp.h>
4 #include <linux/ipv6.h>
5 #include <netinet/in.h>
6
7 #include "sd-netlink.h"
8 #include "sd-varlink.h"
9
10 #include "alloc-util.h"
11 #include "device-private.h"
12 #include "missing-network.h"
13 #include "netif-util.h"
14 #include "netlink-util.h"
15 #include "networkd-address.h"
16 #include "networkd-can.h"
17 #include "networkd-ipv4acd.h"
18 #include "networkd-ipv4ll.h"
19 #include "networkd-link.h"
20 #include "networkd-manager.h"
21 #include "networkd-queue.h"
22 #include "networkd-setlink.h"
23 #include "networkd-sriov.h"
24 #include "networkd-wiphy.h"
25 #include "ordered-set.h"
26 #include "set.h"
27 #include "socket-util.h"
28 #include "string-util.h"
29
30 static int get_link_default_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
31 return link_getlink_handler_internal(rtnl, m, link, "Failed to sync link information");
32 }
33
34 static int get_link_master_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
35 if (get_link_default_handler(rtnl, m, link) > 0)
36 link->master_set = true;
37 return 0;
38 }
39
40 static int get_link_update_flag_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
41 assert(link);
42 assert(link->set_flags_messages > 0);
43
44 link->set_flags_messages--;
45
46 return get_link_default_handler(rtnl, m, link);
47 }
48
49 static int set_link_handler_internal(
50 sd_netlink *rtnl,
51 sd_netlink_message *m,
52 Request *req,
53 Link *link,
54 bool ignore,
55 link_netlink_message_handler_t get_link_handler) {
56
57 int r;
58
59 assert(m);
60 assert(req);
61 assert(link);
62
63 r = sd_netlink_message_get_errno(m);
64 if (r < 0) {
65 log_link_message_warning_errno(link, m, r, "Failed to set %s%s",
66 request_type_to_string(req->type),
67 ignore ? ", ignoring" : "");
68
69 if (!ignore)
70 link_enter_failed(link);
71 return 0;
72 }
73
74 log_link_debug(link, "%s set.", request_type_to_string(req->type));
75
76 if (get_link_handler) {
77 r = link_call_getlink(link, get_link_handler);
78 if (r < 0) {
79 link_enter_failed(link);
80 return 0;
81 }
82 }
83
84 if (link->set_link_messages == 0)
85 link_check_ready(link);
86
87 return 1;
88 }
89
90 static int link_set_addrgen_mode_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
91 int r;
92
93 r = set_link_handler_internal(rtnl, m, req, link, /* ignore= */ true, NULL);
94 if (r <= 0)
95 return r;
96
97 r = link_drop_ipv6ll_addresses(link);
98 if (r < 0) {
99 log_link_warning_errno(link, r, "Failed to drop IPv6LL addresses: %m");
100 link_enter_failed(link);
101 }
102
103 return 0;
104 }
105
106 static int link_set_bond_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
107 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, NULL);
108 }
109
110 static int link_set_bridge_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
111 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ true, NULL);
112 }
113
114 static int link_set_bridge_vlan_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
115 int r;
116
117 assert(link);
118
119 r = set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, NULL);
120 if (r <= 0)
121 return r;
122
123 link->bridge_vlan_set = true;
124 return 0;
125 }
126
127 static int link_del_bridge_vlan_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
128 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, NULL);
129 }
130
131 static int link_set_can_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
132 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, NULL);
133 }
134
135 static int link_set_flags_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
136 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, get_link_default_handler);
137 }
138
139 static int link_set_group_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
140 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, NULL);
141 }
142
143 static int link_set_ipoib_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
144 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ true, NULL);
145 }
146
147 static int link_set_mac_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
148 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ true, get_link_default_handler);
149 }
150
151 static int link_set_mac_allow_retry_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
152 int r;
153
154 assert(m);
155 assert(link);
156
157 r = sd_netlink_message_get_errno(m);
158 if (r == -EBUSY) {
159 /* Most real network devices refuse to set its hardware address with -EBUSY when its
160 * operstate is not down. See, eth_prepare_mac_addr_change() in net/ethernet/eth.c
161 * of kernel. */
162
163 log_link_message_debug_errno(link, m, r, "Failed to set MAC address, retrying again");
164
165 r = link_request_to_set_mac(link, /* allow_retry= */ false);
166 if (r < 0)
167 link_enter_failed(link);
168
169 return 0;
170 }
171
172 return link_set_mac_handler(rtnl, m, req, link, userdata);
173 }
174
175 static int link_set_master_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
176 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ false, get_link_master_handler);
177 }
178
179 static int link_unset_master_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
180 /* Some devices do not support setting master ifindex. Let's ignore error on unsetting master ifindex. */
181 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ true, get_link_master_handler);
182 }
183
184 static int link_set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
185 return set_link_handler_internal(rtnl, m, req, link, /* ignore= */ true, get_link_default_handler);
186 }
187
188 static int link_get_arp(Link *link) {
189 assert(link);
190
191 /* This returns tristate. */
192
193 if (!link->network)
194 return -1;
195
196 /* If ARP= is explicitly specified, use the setting. */
197 if (link->network->arp >= 0)
198 return link->network->arp;
199
200 /* Enable ARP when IPv4ACD is enabled. */
201 if (link_ipv4acd_enabled(link))
202 return true;
203
204 /* Similarly, enable ARP when IPv4LL is enabled. */
205 if (link_ipv4ll_enabled(link))
206 return true;
207
208 /* Otherwise, do not change the flag. */
209 return -1;
210 }
211
212 static int link_configure_fill_message(
213 Link *link,
214 sd_netlink_message *req,
215 RequestType type,
216 void *userdata) {
217 int r;
218
219 switch (type) {
220 case REQUEST_TYPE_SET_LINK_ADDRESS_GENERATION_MODE:
221 r = ipv6ll_addrgen_mode_fill_message(req, PTR_TO_UINT8(userdata));
222 if (r < 0)
223 return r;
224 break;
225 case REQUEST_TYPE_SET_LINK_BOND:
226 r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
227 if (r < 0)
228 return r;
229
230 r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, "bond");
231 if (r < 0)
232 return r;
233
234 if (link->network->active_slave) {
235 r = sd_netlink_message_append_u32(req, IFLA_BOND_ACTIVE_SLAVE, link->ifindex);
236 if (r < 0)
237 return r;
238 }
239
240 if (link->network->primary_slave) {
241 r = sd_netlink_message_append_u32(req, IFLA_BOND_PRIMARY, link->ifindex);
242 if (r < 0)
243 return r;
244 }
245
246 r = sd_netlink_message_close_container(req);
247 if (r < 0)
248 return r;
249
250 r = sd_netlink_message_close_container(req);
251 if (r < 0)
252 return r;
253
254 break;
255 case REQUEST_TYPE_SET_LINK_BRIDGE:
256 r = sd_rtnl_message_link_set_family(req, AF_BRIDGE);
257 if (r < 0)
258 return r;
259
260 r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
261 if (r < 0)
262 return r;
263
264 if (link->network->use_bpdu >= 0) {
265 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_GUARD, !link->network->use_bpdu);
266 if (r < 0)
267 return r;
268 }
269
270 if (link->network->hairpin >= 0) {
271 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MODE, link->network->hairpin);
272 if (r < 0)
273 return r;
274 }
275
276 if (link->network->isolated >= 0) {
277 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_ISOLATED, link->network->isolated);
278 if (r < 0)
279 return r;
280 }
281
282 if (link->network->fast_leave >= 0) {
283 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_FAST_LEAVE, link->network->fast_leave);
284 if (r < 0)
285 return r;
286 }
287
288 if (link->network->allow_port_to_be_root >= 0) {
289 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROTECT, !link->network->allow_port_to_be_root);
290 if (r < 0)
291 return r;
292 }
293
294 if (link->network->unicast_flood >= 0) {
295 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_UNICAST_FLOOD, link->network->unicast_flood);
296 if (r < 0)
297 return r;
298 }
299
300 if (link->network->multicast_flood >= 0) {
301 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MCAST_FLOOD, link->network->multicast_flood);
302 if (r < 0)
303 return r;
304 }
305
306 if (link->network->multicast_to_unicast >= 0) {
307 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MCAST_TO_UCAST, link->network->multicast_to_unicast);
308 if (r < 0)
309 return r;
310 }
311
312 if (link->network->neighbor_suppression >= 0) {
313 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_NEIGH_SUPPRESS, link->network->neighbor_suppression);
314 if (r < 0)
315 return r;
316 }
317
318 if (link->network->learning >= 0) {
319 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_LEARNING, link->network->learning);
320 if (r < 0)
321 return r;
322 }
323
324 if (link->network->bridge_proxy_arp >= 0) {
325 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROXYARP, link->network->bridge_proxy_arp);
326 if (r < 0)
327 return r;
328 }
329
330 if (link->network->bridge_proxy_arp_wifi >= 0) {
331 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROXYARP_WIFI, link->network->bridge_proxy_arp_wifi);
332 if (r < 0)
333 return r;
334 }
335
336 if (link->network->cost != 0) {
337 r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
338 if (r < 0)
339 return r;
340 }
341
342 if (link->network->priority != LINK_BRIDGE_PORT_PRIORITY_INVALID) {
343 r = sd_netlink_message_append_u16(req, IFLA_BRPORT_PRIORITY, link->network->priority);
344 if (r < 0)
345 return r;
346 }
347
348 if (link->network->multicast_router != _MULTICAST_ROUTER_INVALID) {
349 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MULTICAST_ROUTER, link->network->multicast_router);
350 if (r < 0)
351 return r;
352 }
353
354 if (link->network->bridge_locked >= 0) {
355 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_LOCKED, link->network->bridge_locked);
356 if (r < 0)
357 return r;
358 }
359
360 if (link->network->bridge_mac_authentication_bypass >= 0) {
361 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MAB, link->network->bridge_mac_authentication_bypass);
362 if (r < 0)
363 return r;
364 }
365
366 if (link->network->bridge_vlan_tunnel >= 0) {
367 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_VLAN_TUNNEL, link->network->bridge_vlan_tunnel);
368 if (r < 0)
369 return r;
370 }
371
372 r = sd_netlink_message_close_container(req);
373 if (r < 0)
374 return r;
375 break;
376 case REQUEST_TYPE_SET_LINK_BRIDGE_VLAN:
377 r = bridge_vlan_set_message(link, req, /* is_set= */ true);
378 if (r < 0)
379 return r;
380 break;
381 case REQUEST_TYPE_DEL_LINK_BRIDGE_VLAN:
382 r = bridge_vlan_set_message(link, req, /* is_set= */ false);
383 if (r < 0)
384 return r;
385 break;
386 case REQUEST_TYPE_SET_LINK_CAN:
387 r = can_set_netlink_message(link, req);
388 if (r < 0)
389 return r;
390 break;
391 case REQUEST_TYPE_SET_LINK_FLAGS: {
392 unsigned ifi_change = 0, ifi_flags = 0;
393
394 int arp = link_get_arp(link);
395
396 if (arp >= 0) {
397 ifi_change |= IFF_NOARP;
398 SET_FLAG(ifi_flags, IFF_NOARP, arp == 0);
399 }
400
401 if (link->network->multicast >= 0) {
402 ifi_change |= IFF_MULTICAST;
403 SET_FLAG(ifi_flags, IFF_MULTICAST, link->network->multicast);
404 }
405
406 if (link->network->allmulticast >= 0) {
407 ifi_change |= IFF_ALLMULTI;
408 SET_FLAG(ifi_flags, IFF_ALLMULTI, link->network->allmulticast);
409 }
410
411 if (link->network->promiscuous >= 0) {
412 ifi_change |= IFF_PROMISC;
413 SET_FLAG(ifi_flags, IFF_PROMISC, link->network->promiscuous);
414 }
415
416 r = sd_rtnl_message_link_set_flags(req, ifi_flags, ifi_change);
417 if (r < 0)
418 return r;
419
420 break;
421 }
422 case REQUEST_TYPE_SET_LINK_GROUP:
423 r = sd_netlink_message_append_u32(req, IFLA_GROUP, (uint32_t) link->network->group);
424 if (r < 0)
425 return r;
426 break;
427 case REQUEST_TYPE_SET_LINK_MAC:
428 r = netlink_message_append_hw_addr(req, IFLA_ADDRESS, &link->requested_hw_addr);
429 if (r < 0)
430 return r;
431 break;
432 case REQUEST_TYPE_SET_LINK_IPOIB:
433 r = ipoib_set_netlink_message(link, req);
434 if (r < 0)
435 return r;
436 break;
437 case REQUEST_TYPE_SET_LINK_MASTER:
438 r = sd_netlink_message_append_u32(req, IFLA_MASTER, PTR_TO_UINT32(userdata));
439 if (r < 0)
440 return r;
441 break;
442 case REQUEST_TYPE_SET_LINK_MTU:
443 r = sd_netlink_message_append_u32(req, IFLA_MTU, PTR_TO_UINT32(userdata));
444 if (r < 0)
445 return r;
446 break;
447 default:
448 assert_not_reached();
449 }
450
451 return 0;
452 }
453
454 static int link_configure(Link *link, Request *req) {
455 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
456 int r;
457
458 assert(link);
459 assert(link->manager);
460 assert(req);
461
462 log_link_debug(link, "Setting %s", request_type_to_string(req->type));
463
464 if (req->type == REQUEST_TYPE_SET_LINK_BOND)
465 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, link->master_ifindex);
466 else if (IN_SET(req->type, REQUEST_TYPE_SET_LINK_CAN, REQUEST_TYPE_SET_LINK_IPOIB))
467 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, link->ifindex);
468 else if (req->type == REQUEST_TYPE_DEL_LINK_BRIDGE_VLAN)
469 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_DELLINK, link->ifindex);
470 else
471 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_SETLINK, link->ifindex);
472 if (r < 0)
473 return r;
474
475 r = link_configure_fill_message(link, m, req->type, req->userdata);
476 if (r < 0)
477 return r;
478
479 return request_call_netlink_async(link->manager->rtnl, m, req);
480 }
481
482 static bool netdev_is_ready(NetDev *netdev) {
483 assert(netdev);
484
485 if (netdev->state != NETDEV_STATE_READY)
486 return false;
487 if (netdev->ifindex == 0)
488 return false;
489
490 return true;
491 }
492
493 static uint32_t link_adjust_mtu(Link *link, uint32_t mtu) {
494 const char *origin;
495 uint32_t min_mtu;
496
497 assert(link);
498 assert(link->network);
499
500 min_mtu = link->min_mtu;
501 origin = "the minimum MTU of the interface";
502 if (link_ipv6_enabled(link)) {
503 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes on the interface. Bump up
504 * MTU bytes to IPV6_MTU_MIN. */
505 if (min_mtu < IPV6_MIN_MTU) {
506 min_mtu = IPV6_MIN_MTU;
507 origin = "the minimum IPv6 MTU";
508 }
509 if (min_mtu < link->network->ipv6_mtu) {
510 min_mtu = link->network->ipv6_mtu;
511 origin = "the requested IPv6 MTU in IPv6MTUBytes=";
512 }
513 }
514
515 if (mtu < min_mtu) {
516 log_link_warning(link, "Bumping the requested MTU %"PRIu32" to %s (%"PRIu32")",
517 mtu, origin, min_mtu);
518 mtu = min_mtu;
519 }
520
521 if (mtu > link->max_mtu) {
522 log_link_warning(link, "Reducing the requested MTU %"PRIu32" to the interface's maximum MTU %"PRIu32".",
523 mtu, link->max_mtu);
524 mtu = link->max_mtu;
525 }
526
527 return mtu;
528 }
529
530 static int link_is_ready_to_set_link(Link *link, Request *req) {
531 int r;
532
533 assert(link);
534 assert(link->manager);
535 assert(link->network);
536 assert(req);
537
538 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
539 return false;
540
541 switch (req->type) {
542 case REQUEST_TYPE_SET_LINK_BOND:
543 case REQUEST_TYPE_SET_LINK_BRIDGE:
544 if (!link->master_set)
545 return false;
546
547 if (link->network->keep_master && link->master_ifindex <= 0)
548 return false;
549 break;
550
551 case REQUEST_TYPE_SET_LINK_BRIDGE_VLAN:
552 if (!link->master_set)
553 return false;
554
555 if (link->network->keep_master && link->master_ifindex <= 0 && !streq_ptr(link->kind, "bridge"))
556 return false;
557 break;
558
559 case REQUEST_TYPE_DEL_LINK_BRIDGE_VLAN:
560 return link->bridge_vlan_set;
561
562 case REQUEST_TYPE_SET_LINK_CAN:
563 /* Do not check link->set_flags_messages here, as it is ok even if link->flags
564 * is outdated, and checking the counter causes a deadlock. */
565 if (link_is_up(link)) {
566 /* The CAN interface must be down to configure bitrate, etc... */
567 r = link_down_now(link);
568 if (r < 0)
569 return r;
570 }
571 break;
572
573 case REQUEST_TYPE_SET_LINK_MAC:
574 if (req->netlink_handler == link_set_mac_handler) {
575 /* This is the second attempt to set hardware address. On the first attempt
576 * req->netlink_handler points to link_set_mac_allow_retry_handler().
577 * The first attempt failed as the interface was up. */
578 r = link_down_now(link);
579 if (r < 0)
580 return r;
581
582 /* If the kind of the link is "bond", we need
583 * set the slave link down as well. */
584 if (streq_ptr(link->kind, "bond")) {
585 r = link_down_slave_links(link);
586 if (r < 0)
587 return r;
588 }
589 }
590 break;
591
592 case REQUEST_TYPE_SET_LINK_MASTER: {
593 uint32_t m = 0;
594 Request req_mac = {
595 .link = link,
596 .type = REQUEST_TYPE_SET_LINK_MAC,
597 };
598
599 if (link->network->batadv) {
600 if (!netdev_is_ready(link->network->batadv))
601 return false;
602 m = link->network->batadv->ifindex;
603 } else if (link->network->bond) {
604 if (ordered_set_contains(link->manager->request_queue, &req_mac))
605 return false;
606 if (!netdev_is_ready(link->network->bond))
607 return false;
608 m = link->network->bond->ifindex;
609 } else if (link->network->bridge) {
610 if (ordered_set_contains(link->manager->request_queue, &req_mac))
611 return false;
612 if (!netdev_is_ready(link->network->bridge))
613 return false;
614 m = link->network->bridge->ifindex;
615 } else if (link->network->vrf) {
616 if (!netdev_is_ready(link->network->vrf))
617 return false;
618 m = link->network->vrf->ifindex;
619 }
620
621 if (m == (uint32_t) link->master_ifindex) {
622 /* The requested master is already set. */
623 link->master_set = true;
624 return -EALREADY; /* indicate to cancel the request. */
625 }
626
627 /* Do not check link->set_flags_messages here, as it is ok even if link->flags is outdated,
628 * and checking the counter causes a deadlock. */
629 if (link->network->bond && link_is_up(link)) {
630 /* link must be down when joining to bond master. */
631 r = link_down_now(link);
632 if (r < 0)
633 return r;
634 }
635
636 if (link->network->bridge && !link_is_up(link) && link->dev) {
637 /* Some devices require the port to be up before joining the bridge.
638 *
639 * E.g. Texas Instruments SoC Ethernet running in switch mode:
640 * https://docs.kernel.org/networking/device_drivers/ethernet/ti/am65_nuss_cpsw_switchdev.html#enabling-switch
641 * > Port’s netdev devices have to be in UP before joining to the bridge to avoid
642 * > overwriting of bridge configuration as CPSW switch driver completely reloads its
643 * > configuration when first port changes its state to UP. */
644
645 r = device_get_property_bool(link->dev, "ID_NET_BRING_UP_BEFORE_JOINING_BRIDGE");
646 if (r < 0 && r != -ENOENT)
647 log_link_warning_errno(link, r, "Failed to get or parse ID_NET_BRING_UP_BEFORE_JOINING_BRIDGE property, ignoring: %m");
648 else if (r > 0) {
649 r = link_up_now(link);
650 if (r < 0)
651 return r;
652 }
653 }
654
655 req->userdata = UINT32_TO_PTR(m);
656 break;
657 }
658 case REQUEST_TYPE_SET_LINK_MTU: {
659 if (ordered_set_contains(link->manager->request_queue,
660 &(const Request) {
661 .link = link,
662 .type = REQUEST_TYPE_SET_LINK_IPOIB,
663 }))
664 return false;
665
666 /* Changing FD mode may affect MTU.
667 * See https://docs.kernel.org/networking/can.html#can-fd-flexible-data-rate-driver-support
668 * MTU = 16 (CAN_MTU) => Classical CAN device
669 * MTU = 72 (CANFD_MTU) => CAN FD capable device */
670 if (ordered_set_contains(link->manager->request_queue,
671 &(const Request) {
672 .link = link,
673 .type = REQUEST_TYPE_SET_LINK_CAN,
674 }))
675 return false;
676
677 /* Now, it is ready to set MTU, but before setting, adjust requested MTU. */
678 uint32_t mtu = link_adjust_mtu(link, PTR_TO_UINT32(req->userdata));
679 if (mtu == link->mtu)
680 return -EALREADY; /* Not necessary to set the same value. */
681
682 req->userdata = UINT32_TO_PTR(mtu);
683 break;
684 }
685 default:
686 ;
687 }
688
689 return true;
690 }
691
692 static int link_process_set_link(Request *req, Link *link, void *userdata) {
693 int r;
694
695 assert(req);
696 assert(link);
697
698 r = link_is_ready_to_set_link(link, req);
699 if (r == -EALREADY)
700 return 1; /* Cancel the request. */
701 if (r <= 0)
702 return r;
703
704 r = link_configure(link, req);
705 if (r < 0)
706 return log_link_warning_errno(link, r, "Failed to set %s", request_type_to_string(req->type));
707
708 return 1;
709 }
710
711 static int link_request_set_link(
712 Link *link,
713 RequestType type,
714 request_netlink_handler_t netlink_handler,
715 Request **ret) {
716
717 Request *req;
718 int r;
719
720 assert(link);
721
722 r = link_queue_request_full(link, type, NULL, NULL, NULL, NULL,
723 link_process_set_link,
724 &link->set_link_messages,
725 netlink_handler,
726 &req);
727 if (r < 0)
728 return log_link_warning_errno(link, r, "Failed to request to set %s: %m",
729 request_type_to_string(type));
730
731 log_link_debug(link, "Requested to set %s", request_type_to_string(type));
732
733 if (ret)
734 *ret = req;
735 return 0;
736 }
737
738 int link_request_to_set_addrgen_mode(Link *link) {
739 IPv6LinkLocalAddressGenMode mode;
740 Request *req;
741 int r;
742
743 assert(link);
744 assert(link->network);
745
746 if (!socket_ipv6_is_supported())
747 return 0;
748
749 mode = link_get_ipv6ll_addrgen_mode(link);
750
751 if (mode == link->ipv6ll_address_gen_mode)
752 return 0;
753
754 /* If the link is already up, then changing the mode by netlink does not take effect until the
755 * link goes down. Hence, we need to reset the interface. However, setting the mode by sysctl
756 * does not need that. Let's use the sysctl interface when the link is already up.
757 * See also issue #22424. */
758 if (mode != IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_NONE && link_is_up(link)) {
759 r = link_set_ipv6ll_addrgen_mode(link, mode);
760 if (r < 0)
761 log_link_warning_errno(link, r, "Cannot set IPv6 address generation mode, ignoring: %m");
762
763 return 0;
764 }
765
766 r = link_request_set_link(link, REQUEST_TYPE_SET_LINK_ADDRESS_GENERATION_MODE,
767 link_set_addrgen_mode_handler,
768 &req);
769 if (r < 0)
770 return r;
771
772 req->userdata = UINT8_TO_PTR(mode);
773 return 0;
774 }
775
776 int link_request_to_set_bond(Link *link) {
777 assert(link);
778 assert(link->network);
779
780 if (!link->network->bond) {
781 Link *master;
782
783 if (!link->network->keep_master)
784 return 0;
785
786 if (link_get_master(link, &master) < 0)
787 return 0;
788
789 if (!streq_ptr(master->kind, "bond"))
790 return 0;
791 }
792
793 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_BOND,
794 link_set_bond_handler, NULL);
795 }
796
797 int link_request_to_set_bridge(Link *link) {
798 assert(link);
799 assert(link->network);
800
801 if (!link->network->bridge) {
802 Link *master;
803
804 if (!link->network->keep_master)
805 return 0;
806
807 if (link_get_master(link, &master) < 0)
808 return 0;
809
810 if (!streq_ptr(master->kind, "bridge"))
811 return 0;
812 }
813
814 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_BRIDGE,
815 link_set_bridge_handler,
816 NULL);
817 }
818
819 int link_request_to_set_bridge_vlan(Link *link) {
820 int r;
821
822 assert(link);
823 assert(link->network);
824
825 /* If nothing configured, use the default vlan ID. */
826 if (memeqzero(link->network->bridge_vlan_bitmap, BRIDGE_VLAN_BITMAP_LEN * sizeof(uint32_t)) &&
827 link->network->bridge_vlan_pvid == BRIDGE_VLAN_KEEP_PVID)
828 return 0;
829
830 if (!link->network->bridge && !streq_ptr(link->kind, "bridge")) {
831 Link *master;
832
833 if (!link->network->keep_master)
834 return 0;
835
836 if (link_get_master(link, &master) < 0)
837 return 0;
838
839 if (!streq_ptr(master->kind, "bridge"))
840 return 0;
841 }
842
843 link->bridge_vlan_set = false;
844
845 r = link_request_set_link(link, REQUEST_TYPE_SET_LINK_BRIDGE_VLAN,
846 link_set_bridge_vlan_handler,
847 NULL);
848 if (r < 0)
849 return r;
850
851 r = link_request_set_link(link, REQUEST_TYPE_DEL_LINK_BRIDGE_VLAN,
852 link_del_bridge_vlan_handler,
853 NULL);
854 if (r < 0)
855 return r;
856
857 return 0;
858 }
859
860 int link_request_to_set_can(Link *link) {
861 assert(link);
862 assert(link->network);
863
864 if (link->iftype != ARPHRD_CAN)
865 return 0;
866
867 if (!streq_ptr(link->kind, "can"))
868 return 0;
869
870 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_CAN,
871 link_set_can_handler,
872 NULL);
873 }
874
875 int link_request_to_set_flags(Link *link) {
876 assert(link);
877 assert(link->network);
878
879 if (link_get_arp(link) < 0 &&
880 link->network->multicast < 0 &&
881 link->network->allmulticast < 0 &&
882 link->network->promiscuous < 0)
883 return 0;
884
885 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_FLAGS,
886 link_set_flags_handler,
887 NULL);
888 }
889
890 int link_request_to_set_group(Link *link) {
891 assert(link);
892 assert(link->network);
893
894 if (link->network->group < 0)
895 return 0;
896
897 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_GROUP,
898 link_set_group_handler,
899 NULL);
900 }
901
902 int link_request_to_set_mac(Link *link, bool allow_retry) {
903 int r;
904
905 assert(link);
906 assert(link->network);
907
908 if (link->network->hw_addr.length == 0)
909 return 0;
910
911 link->requested_hw_addr = link->network->hw_addr;
912 r = net_verify_hardware_address(link->ifname, /* is_static= */ true,
913 link->iftype, &link->hw_addr, &link->requested_hw_addr);
914 if (r < 0)
915 return r;
916
917 if (hw_addr_equal(&link->hw_addr, &link->requested_hw_addr))
918 return 0;
919
920 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_MAC,
921 allow_retry ? link_set_mac_allow_retry_handler : link_set_mac_handler,
922 NULL);
923 }
924
925 int link_request_to_set_ipoib(Link *link) {
926 assert(link);
927 assert(link->network);
928
929 if (link->iftype != ARPHRD_INFINIBAND)
930 return 0;
931
932 if (link->network->ipoib_mode < 0 &&
933 link->network->ipoib_umcast < 0)
934 return 0;
935
936 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_IPOIB,
937 link_set_ipoib_handler,
938 NULL);
939 }
940
941 int link_request_to_set_master(Link *link) {
942 assert(link);
943 assert(link->network);
944
945 if (link->network->keep_master) {
946 /* When KeepMaster=yes, BatmanAdvanced=, Bond=, Bridge=, and VRF= are ignored. */
947 link->master_set = true;
948 return 0;
949
950 } else if (link->network->batadv || link->network->bond || link->network->bridge || link->network->vrf) {
951 link->master_set = false;
952 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_MASTER,
953 link_set_master_handler,
954 NULL);
955
956 } else if (link->master_ifindex != 0) {
957 /* Unset master only when it is set. */
958 link->master_set = false;
959 return link_request_set_link(link, REQUEST_TYPE_SET_LINK_MASTER,
960 link_unset_master_handler,
961 NULL);
962
963 } else {
964 /* Nothing we need to do. */
965 link->master_set = true;
966 return 0;
967 }
968 }
969
970 int link_request_to_set_mtu(Link *link, uint32_t mtu) {
971 Request *req;
972 int r;
973
974 assert(link);
975
976 if (mtu == 0)
977 return 0;
978
979 r = link_request_set_link(link, REQUEST_TYPE_SET_LINK_MTU,
980 link_set_mtu_handler,
981 &req);
982 if (r < 0)
983 return r;
984
985 req->userdata = UINT32_TO_PTR(mtu);
986 return 0;
987 }
988
989 static bool link_reduces_vlan_mtu(Link *link) {
990 /* See netif_reduces_vlan_mtu() in kernel. */
991 return streq_ptr(link->kind, "macsec");
992 }
993
994 static uint32_t link_get_requested_mtu_by_stacked_netdevs(Link *link) {
995 uint32_t mtu = 0;
996 NetDev *dev;
997
998 HASHMAP_FOREACH(dev, link->network->stacked_netdevs)
999 if (dev->kind == NETDEV_KIND_VLAN && dev->mtu > 0)
1000 /* See vlan_dev_change_mtu() in kernel. */
1001 mtu = MAX(mtu, link_reduces_vlan_mtu(link) ? dev->mtu + 4 : dev->mtu);
1002
1003 else if (dev->kind == NETDEV_KIND_MACVLAN && dev->mtu > mtu)
1004 /* See macvlan_change_mtu() in kernel. */
1005 mtu = dev->mtu;
1006
1007 return mtu;
1008 }
1009
1010 int link_configure_mtu(Link *link) {
1011 uint32_t mtu;
1012
1013 assert(link);
1014 assert(link->network);
1015
1016 if (link->network->mtu > 0)
1017 return link_request_to_set_mtu(link, link->network->mtu);
1018
1019 mtu = link_get_requested_mtu_by_stacked_netdevs(link);
1020 if (link->mtu >= mtu)
1021 return 0;
1022
1023 log_link_notice(link, "Bumping MTU bytes from %"PRIu32" to %"PRIu32" because of stacked device. "
1024 "If it is not desired, then please explicitly specify MTUBytes= setting.",
1025 link->mtu, mtu);
1026
1027 return link_request_to_set_mtu(link, mtu);
1028 }
1029
1030 static int link_up_dsa_slave(Link *link) {
1031 Link *master;
1032 int r;
1033
1034 assert(link);
1035
1036 /* For older kernels (specifically, older than 9d5ef190e5615a7b63af89f88c4106a5bc127974, kernel-5.12),
1037 * it is necessary to bring up a DSA slave that its master interface is already up. And bringing up
1038 * the slave fails with -ENETDOWN. So, let's bring up the master even if it is not managed by us,
1039 * and try to bring up the slave after the master becomes up. */
1040
1041 if (link->dsa_master_ifindex <= 0)
1042 return 0;
1043
1044 if (!streq_ptr(link->driver, "dsa"))
1045 return 0;
1046
1047 if (link_get_by_index(link->manager, link->dsa_master_ifindex, &master) < 0)
1048 return 0;
1049
1050 if (master->state == LINK_STATE_UNMANAGED) {
1051 /* If the DSA master interface is unmanaged, then it will never become up.
1052 * Let's request to bring up the master. */
1053 r = link_request_to_bring_up_or_down(master, /* up= */ true);
1054 if (r < 0)
1055 return r;
1056 }
1057
1058 r = link_request_to_bring_up_or_down(link, /* up= */ true);
1059 if (r < 0)
1060 return r;
1061
1062 return 1;
1063 }
1064
1065 static const char* up_or_down(bool up) {
1066 return up ? "up" : "down";
1067 }
1068
1069 static int link_up_or_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
1070 bool on_activate, up;
1071 int r;
1072
1073 assert(m);
1074 assert(req);
1075 assert(link);
1076
1077 on_activate = req->type == REQUEST_TYPE_ACTIVATE_LINK;
1078 up = PTR_TO_INT(req->userdata);
1079
1080 r = sd_netlink_message_get_errno(m);
1081 if (r == -ENETDOWN && up && link_up_dsa_slave(link) > 0)
1082 log_link_message_debug_errno(link, m, r, "Could not bring up dsa slave, retrying again after dsa master becomes up");
1083 else if (r < 0)
1084 log_link_message_warning_errno(link, m, r, "Could not bring %s interface, ignoring", up_or_down(up));
1085
1086 r = link_call_getlink(link, get_link_update_flag_handler);
1087 if (r < 0) {
1088 link_enter_failed(link);
1089 return 0;
1090 }
1091
1092 link->set_flags_messages++;
1093
1094 if (on_activate) {
1095 link->activated = true;
1096 link_check_ready(link);
1097 }
1098
1099 return 0;
1100 }
1101
1102 static int link_up_or_down(Link *link, bool up, Request *req) {
1103 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
1104 int r;
1105
1106 assert(link);
1107 assert(link->manager);
1108 assert(link->manager->rtnl);
1109 assert(req);
1110
1111 /* The log message is checked in the test. Please also update test_bond_active_slave() in
1112 * test/test-network/systemd-networkd-tests.py. when the log message below is modified. */
1113 log_link_debug(link, "Bringing link %s", up_or_down(up));
1114
1115 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_SETLINK, link->ifindex);
1116 if (r < 0)
1117 return r;
1118
1119 r = sd_rtnl_message_link_set_flags(m, up ? IFF_UP : 0, IFF_UP);
1120 if (r < 0)
1121 return r;
1122
1123 return request_call_netlink_async(link->manager->rtnl, m, req);
1124 }
1125
1126 static bool link_is_ready_to_activate_one(Link *link, bool allow_unmanaged) {
1127 assert(link);
1128
1129 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED, LINK_STATE_UNMANAGED))
1130 return false;
1131
1132 if (!link->network)
1133 return allow_unmanaged;
1134
1135 if (link->set_link_messages > 0)
1136 return false;
1137
1138 return true;
1139 }
1140
1141 static bool link_is_ready_to_activate(Link *link, bool up) {
1142 assert(link);
1143
1144 if (!check_ready_for_all_sr_iov_ports(link, /* allow_unmanaged= */ false,
1145 link_is_ready_to_activate_one))
1146 return false;
1147
1148 if (up && link_rfkilled(link) > 0)
1149 return false;
1150
1151 return true;
1152 }
1153
1154 static int link_process_activation(Request *req, Link *link, void *userdata) {
1155 bool up = PTR_TO_INT(userdata);
1156 int r;
1157
1158 assert(req);
1159 assert(link);
1160
1161 if (!link_is_ready_to_activate(link, up))
1162 return 0;
1163
1164 r = link_up_or_down(link, up, req);
1165 if (r < 0)
1166 return log_link_warning_errno(link, r, "Failed to activate link: %m");
1167
1168 return 1;
1169 }
1170
1171 int link_request_to_activate(Link *link) {
1172 bool up;
1173 int r;
1174
1175 assert(link);
1176 assert(link->network);
1177
1178 switch (link->network->activation_policy) {
1179 case ACTIVATION_POLICY_BOUND:
1180 r = link_handle_bound_to_list(link);
1181 if (r < 0)
1182 return r;
1183 _fallthrough_;
1184 case ACTIVATION_POLICY_MANUAL:
1185 link->activated = true;
1186 link_check_ready(link);
1187 return 0;
1188 case ACTIVATION_POLICY_UP:
1189 case ACTIVATION_POLICY_ALWAYS_UP:
1190 up = true;
1191 break;
1192 case ACTIVATION_POLICY_DOWN:
1193 case ACTIVATION_POLICY_ALWAYS_DOWN:
1194 up = false;
1195 break;
1196 default:
1197 assert_not_reached();
1198 }
1199
1200 link->activated = false;
1201
1202 r = link_queue_request_full(link, REQUEST_TYPE_ACTIVATE_LINK,
1203 INT_TO_PTR(up), NULL, NULL, NULL,
1204 link_process_activation,
1205 &link->set_flags_messages,
1206 link_up_or_down_handler, NULL);
1207 if (r < 0)
1208 return log_link_error_errno(link, r, "Failed to request to activate link: %m");
1209
1210 log_link_debug(link, "Requested to activate link");
1211 return 0;
1212 }
1213
1214 static bool link_is_ready_to_bring_up_or_down(Link *link, bool up) {
1215 assert(link);
1216
1217 if (up && link->dsa_master_ifindex > 0) {
1218 Link *master;
1219
1220 /* The master interface must be up. See comments in link_up_dsa_slave(). */
1221
1222 if (link_get_by_index(link->manager, link->dsa_master_ifindex, &master) < 0)
1223 return false;
1224
1225 if (!link_is_up(master))
1226 return false;
1227 }
1228
1229 if (link->state == LINK_STATE_UNMANAGED)
1230 return true;
1231
1232 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
1233 return false;
1234
1235 if (link->set_link_messages > 0)
1236 return false;
1237
1238 if (!link->activated)
1239 return false;
1240
1241 if (up && link_rfkilled(link) > 0)
1242 return false;
1243
1244 return true;
1245 }
1246
1247 static int link_process_up_or_down(Request *req, Link *link, void *userdata) {
1248 bool up = PTR_TO_INT(userdata);
1249 int r;
1250
1251 assert(req);
1252 assert(link);
1253
1254 if (!link_is_ready_to_bring_up_or_down(link, up))
1255 return 0;
1256
1257 r = link_up_or_down(link, up, req);
1258 if (r < 0)
1259 return log_link_warning_errno(link, r, "Failed to bring link %s: %m", up_or_down(up));
1260
1261 return 1;
1262 }
1263
1264 int link_request_to_bring_up_or_down(Link *link, bool up) {
1265 int r;
1266
1267 assert(link);
1268
1269 r = link_queue_request_full(link, REQUEST_TYPE_UP_DOWN,
1270 INT_TO_PTR(up), NULL, NULL, NULL,
1271 link_process_up_or_down,
1272 &link->set_flags_messages,
1273 link_up_or_down_handler, NULL);
1274 if (r < 0)
1275 return log_link_warning_errno(link, r, "Failed to request to bring link %s: %m",
1276 up_or_down(up));
1277
1278 log_link_debug(link, "Requested to bring link %s", up_or_down(up));
1279 return 0;
1280 }
1281
1282 static int link_up_or_down_now_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link, bool up) {
1283 int r;
1284
1285 assert(m);
1286 assert(link);
1287 assert(link->set_flags_messages > 0);
1288
1289 link->set_flags_messages--;
1290
1291 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1292 return 0;
1293
1294 r = sd_netlink_message_get_errno(m);
1295 if (r < 0)
1296 log_link_message_warning_errno(link, m, r, "Could not bring %s interface, ignoring", up_or_down(up));
1297
1298 r = link_call_getlink(link, get_link_update_flag_handler);
1299 if (r < 0) {
1300 link_enter_failed(link);
1301 return 0;
1302 }
1303
1304 link->set_flags_messages++;
1305 return 0;
1306 }
1307
1308 static int link_up_now_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1309 return link_up_or_down_now_handler(rtnl, m, link, /* up= */ true);
1310 }
1311
1312 static int link_down_now_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1313 return link_up_or_down_now_handler(rtnl, m, link, /* up= */ false);
1314 }
1315
1316 int link_up_or_down_now(Link *link, bool up) {
1317 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1318 int r;
1319
1320 assert(link);
1321 assert(link->manager);
1322 assert(link->manager->rtnl);
1323
1324 log_link_debug(link, "Bringing link %s", up_or_down(up));
1325
1326 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1327 if (r < 0)
1328 return log_link_warning_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1329
1330 r = sd_rtnl_message_link_set_flags(req, up ? IFF_UP : 0, IFF_UP);
1331 if (r < 0)
1332 return log_link_warning_errno(link, r, "Could not set link flags: %m");
1333
1334 r = netlink_call_async(link->manager->rtnl, NULL, req,
1335 up ? link_up_now_handler : link_down_now_handler,
1336 link_netlink_destroy_callback, link);
1337 if (r < 0)
1338 return log_link_warning_errno(link, r, "Could not send rtnetlink message: %m");
1339
1340 link->set_flags_messages++;
1341 link_ref(link);
1342 return 0;
1343 }
1344
1345 typedef struct SetLinkVarlinkContext {
1346 Link *link;
1347 sd_varlink *vlink;
1348 bool up;
1349 } SetLinkVarlinkContext;
1350
1351 static SetLinkVarlinkContext* set_link_varlink_context_free(SetLinkVarlinkContext *ctx) {
1352 if (!ctx)
1353 return NULL;
1354
1355 if (ctx->vlink)
1356 sd_varlink_unref(ctx->vlink);
1357 if (ctx->link)
1358 link_unref(ctx->link);
1359 return mfree(ctx);
1360 }
1361
1362 DEFINE_TRIVIAL_CLEANUP_FUNC(SetLinkVarlinkContext*, set_link_varlink_context_free);
1363
1364 static void set_link_varlink_context_destroy(SetLinkVarlinkContext *ctx) {
1365 set_link_varlink_context_free(ctx);
1366 }
1367
1368 static int link_up_or_down_now_varlink_handler(sd_netlink *rtnl, sd_netlink_message *m, SetLinkVarlinkContext *ctx) {
1369 int r;
1370
1371 assert(m);
1372 assert(ctx);
1373
1374 Link *link = ASSERT_PTR(ctx->link);
1375 sd_varlink *vlink = ASSERT_PTR(ctx->vlink);
1376 bool up = ctx->up;
1377
1378 assert(link->set_flags_messages > 0);
1379
1380 link->set_flags_messages--;
1381
1382 r = sd_netlink_message_get_errno(m);
1383 if (r < 0) {
1384 (void) sd_varlink_error_errno(vlink, r);
1385 log_link_message_warning_errno(link, m, r, "Could not bring %s interface", up_or_down(up));
1386 } else
1387 (void) sd_varlink_reply(vlink, NULL);
1388
1389 if (link->state == LINK_STATE_LINGER)
1390 return 0;
1391
1392 r = link_call_getlink(link, get_link_update_flag_handler);
1393 if (r < 0) {
1394 link_enter_failed(link);
1395 return 0;
1396 }
1397
1398 link->set_flags_messages++;
1399 return 0;
1400 }
1401
1402 int link_up_or_down_now_by_varlink(Link *link, bool up, sd_varlink *vlink) {
1403 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1404 int r;
1405
1406 assert(link);
1407 assert(link->manager);
1408 assert(link->manager->rtnl);
1409
1410 log_link_debug(link, "Bringing link %s (varlink)", up_or_down(up));
1411
1412 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1413 if (r < 0)
1414 return log_link_warning_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1415
1416 r = sd_rtnl_message_link_set_flags(req, up ? IFF_UP : 0, IFF_UP);
1417 if (r < 0)
1418 return log_link_warning_errno(link, r, "Could not set link flags: %m");
1419
1420 _cleanup_(set_link_varlink_context_freep) SetLinkVarlinkContext *ctx = new(SetLinkVarlinkContext, 1);
1421 if (!ctx)
1422 return log_oom();
1423
1424 *ctx = (SetLinkVarlinkContext) {
1425 .link = link_ref(link),
1426 .vlink = sd_varlink_ref(vlink),
1427 .up = up,
1428 };
1429
1430 r = netlink_call_async(link->manager->rtnl, NULL, req,
1431 link_up_or_down_now_varlink_handler,
1432 set_link_varlink_context_destroy,
1433 ctx);
1434 if (r < 0)
1435 return log_link_warning_errno(link, r, "Could not send rtnetlink message: %m");
1436
1437 TAKE_PTR(ctx);
1438 link->set_flags_messages++;
1439 return 0;
1440 }
1441
1442 int link_down_slave_links(Link *link) {
1443 Link *slave;
1444 int r;
1445
1446 assert(link);
1447
1448 SET_FOREACH(slave, link->slaves) {
1449 r = link_down_now(slave);
1450 if (r < 0)
1451 return r;
1452 }
1453
1454 return 0;
1455 }
1456
1457 static int link_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1458 int r;
1459
1460 assert(m);
1461 assert(link);
1462
1463 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1464 return 0;
1465
1466 r = sd_netlink_message_get_errno(m);
1467 if (r < 0)
1468 log_link_message_warning_errno(link, m, r, "Could not remove interface, ignoring");
1469
1470 return 0;
1471 }
1472
1473 int link_remove(Link *link) {
1474 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1475 int r;
1476
1477 assert(link);
1478 assert(link->manager);
1479 assert(link->manager->rtnl);
1480
1481 log_link_debug(link, "Removing link.");
1482
1483 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_DELLINK, link->ifindex);
1484 if (r < 0)
1485 return log_link_debug_errno(link, r, "Could not allocate RTM_DELLINK message: %m");
1486
1487 r = netlink_call_async(link->manager->rtnl, NULL, req, link_remove_handler,
1488 link_netlink_destroy_callback, link);
1489 if (r < 0)
1490 return log_link_debug_errno(link, r, "Could not send rtnetlink message: %m");
1491
1492 link_ref(link);
1493
1494 return 0;
1495 }