src/network/networkd-setlink.c

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