src/network/networkd-sriov.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later
   2  * Copyright © 2020 VMware, Inc. */
   3
   4 #include "device-enumerator-private.h"
   5 #include "device-util.h"
   6 #include "fd-util.h"
   7 #include "networkd-link.h"
   8 #include "networkd-manager.h"
   9 #include "networkd-queue.h"
  10 #include "networkd-sriov.h"
  11
  12 static int sr_iov_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, SRIOV *sr_iov) {
  13         int r;
  14
  15         assert(m);
  16         assert(link);
  17
  18         r = sd_netlink_message_get_errno(m);
  19         if (r < 0 && r != -EEXIST) {
  20                 log_link_message_error_errno(link, m, r, "Could not set up SR-IOV");
  21                 link_enter_failed(link);
  22                 return 1;
  23         }
  24
  25         if (link->sr_iov_messages == 0) {
  26                 log_link_debug(link, "SR-IOV configured");
  27                 link->sr_iov_configured = true;
  28                 link_check_ready(link);
  29         }
  30
  31         return 1;
  32 }
  33
  34 static int sr_iov_configure(SRIOV *sr_iov, Link *link, Request *req) {
  35         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
  36         int r;
  37
  38         assert(sr_iov);
  39         assert(link);
  40         assert(link->manager);
  41         assert(link->manager->rtnl);
  42         assert(link->ifindex > 0);
  43         assert(req);
  44
  45         log_link_debug(link, "Setting SR-IOV virtual function %"PRIu32".", sr_iov->vf);
  46
  47         r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_SETLINK, link->ifindex);
  48         if (r < 0)
  49                 return r;
  50
  51         r = sr_iov_set_netlink_message(sr_iov, m);
  52         if (r < 0)
  53                 return r;
  54
  55         return request_call_netlink_async(link->manager->rtnl, m, req);
  56 }
  57
  58 static int sr_iov_process_request(Request *req, Link *link, SRIOV *sr_iov) {
  59         int r;
  60
  61         assert(req);
  62         assert(link);
  63         assert(sr_iov);
  64
  65         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
  66                 return 0;
  67
  68         r = sr_iov_configure(sr_iov, link, req);
  69         if (r < 0)
  70                 return log_link_warning_errno(link, r,
  71                                               "Failed to configure SR-IOV virtual function %"PRIu32": %m",
  72                                               sr_iov->vf);
  73
  74         return 1;
  75 }
  76
  77 int link_request_sr_iov_vfs(Link *link) {
  78         SRIOV *sr_iov;
  79         int r;
  80
  81         assert(link);
  82         assert(link->network);
  83
  84         link->sr_iov_configured = false;
  85
  86         ORDERED_HASHMAP_FOREACH(sr_iov, link->network->sr_iov_by_section) {
  87                 r = link_queue_request_safe(link, REQUEST_TYPE_SRIOV,
  88                                             sr_iov, NULL,
  89                                             sr_iov_hash_func,
  90                                             sr_iov_compare_func,
  91                                             sr_iov_process_request,
  92                                             &link->sr_iov_messages,
  93                                             sr_iov_handler,
  94                                             NULL);
  95                 if (r < 0)
  96                         return log_link_warning_errno(link, r,
  97                                                       "Failed to request SR-IOV virtual function %"PRIu32": %m",
  98                                                       sr_iov->vf);
  99         }
 100
 101         if (link->sr_iov_messages == 0) {
 102                 link->sr_iov_configured = true;
 103                 link_check_ready(link);
 104         } else
 105                 log_link_debug(link, "Configuring SR-IOV");
 106
 107         return 0;
 108 }
 109
 110 static int find_ifindex_from_pci_dev_port(sd_device *pci_dev, const char *dev_port) {
 111         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 112         sd_device *dev;
 113         int ifindex, r;
 114
 115         assert(pci_dev);
 116         assert(dev_port);
 117
 118         r = sd_device_enumerator_new(&e);
 119         if (r < 0)
 120                 return r;
 121
 122         r = sd_device_enumerator_allow_uninitialized(e);
 123         if (r < 0)
 124                 return r;
 125
 126         r = sd_device_enumerator_add_match_parent(e, pci_dev);
 127         if (r < 0)
 128                 return r;
 129
 130         r = sd_device_enumerator_add_match_subsystem(e, "net", true);
 131         if (r < 0)
 132                 return r;
 133
 134         r = sd_device_enumerator_add_match_sysattr(e, "dev_port", dev_port, true);
 135         if (r < 0)
 136                 return r;
 137
 138         dev = sd_device_enumerator_get_device_first(e);
 139         if (!dev)
 140                 return -ENODEV; /* no device found */
 141
 142         if (sd_device_enumerator_get_device_next(e))
 143                 return -ENXIO; /* multiple devices found */
 144
 145         r = sd_device_get_ifindex(dev, &ifindex);
 146         if (r < 0)
 147                 return r;
 148
 149         assert(ifindex > 0);
 150         return ifindex;
 151 }
 152
 153 static int manager_update_sr_iov_ifindices(Manager *manager, int phys_port_ifindex, int virt_port_ifindex) {
 154         Link *phys_link = NULL, *virt_link = NULL;
 155         int r;
 156
 157         assert(manager);
 158         assert(phys_port_ifindex > 0);
 159         assert(virt_port_ifindex > 0);
 160
 161         /* This sets ifindices only when both interfaces are already managed by us. */
 162
 163         r = link_get_by_index(manager, phys_port_ifindex, &phys_link);
 164         if (r < 0)
 165                 return r;
 166
 167         r = link_get_by_index(manager, virt_port_ifindex, &virt_link);
 168         if (r < 0)
 169                 return r;
 170
 171         /* update VF ifindex in PF */
 172         r = set_ensure_put(&phys_link->sr_iov_virt_port_ifindices, NULL, INT_TO_PTR(virt_port_ifindex));
 173         if (r < 0)
 174                 return r;
 175
 176         log_link_debug(phys_link,
 177                        "Found SR-IOV VF port %s(%i).",
 178                        virt_link ? virt_link->ifname : "n/a", virt_port_ifindex);
 179
 180         /* update PF ifindex in VF */
 181         if (virt_link->sr_iov_phys_port_ifindex > 0 && virt_link->sr_iov_phys_port_ifindex != phys_port_ifindex) {
 182                 Link *old_phys_link;
 183
 184                 if (link_get_by_index(manager, virt_link->sr_iov_phys_port_ifindex, &old_phys_link) >= 0)
 185                         set_remove(old_phys_link->sr_iov_virt_port_ifindices, INT_TO_PTR(virt_port_ifindex));
 186         }
 187
 188         virt_link->sr_iov_phys_port_ifindex = phys_port_ifindex;
 189
 190         log_link_debug(virt_link,
 191                        "Found SR-IOV PF port %s(%i).",
 192                        phys_link ? phys_link->ifname : "n/a", phys_port_ifindex);
 193
 194         return 0;
 195 }
 196
 197 static int link_set_sr_iov_phys_port(Link *link) {
 198         _cleanup_(sd_device_unrefp) sd_device *pci_physfn_dev = NULL;
 199         const char *dev_port;
 200         sd_device *pci_dev;
 201         int r;
 202
 203         assert(link);
 204         assert(link->manager);
 205
 206         if (link->sr_iov_phys_port_ifindex > 0)
 207                 return 0;
 208
 209         if (!link->dev)
 210                 return -ENODEV;
 211
 212         r = sd_device_get_sysattr_value(link->dev, "dev_port", &dev_port);
 213         if (r < 0)
 214                 return r;
 215
 216         r = sd_device_get_parent_with_subsystem_devtype(link->dev, "pci", NULL, &pci_dev);
 217         if (r < 0)
 218                 return r;
 219
 220         r = sd_device_new_child(&pci_physfn_dev, pci_dev, "physfn");
 221         if (r < 0)
 222                 return r;
 223
 224         r = find_ifindex_from_pci_dev_port(pci_physfn_dev, dev_port);
 225         if (r < 0)
 226                 return r;
 227
 228         return manager_update_sr_iov_ifindices(link->manager, r, link->ifindex);
 229 }
 230
 231 static int link_set_sr_iov_virt_ports(Link *link) {
 232         const char *dev_port, *name;
 233         sd_device *pci_dev;
 234         int r;
 235
 236         assert(link);
 237         assert(link->manager);
 238
 239         set_clear(link->sr_iov_virt_port_ifindices);
 240
 241         if (!link->dev)
 242                 return -ENODEV;
 243
 244         r = sd_device_get_sysattr_value(link->dev, "dev_port", &dev_port);
 245         if (r < 0)
 246                 return r;
 247
 248         r = sd_device_get_parent_with_subsystem_devtype(link->dev, "pci", NULL, &pci_dev);
 249         if (r < 0)
 250                 return r;
 251
 252         FOREACH_DEVICE_CHILD_WITH_SUFFIX(pci_dev, child, name) {
 253                 const char *n;
 254
 255                 /* Accept name prefixed with "virtfn", but refuse "virtfn" itself. */
 256                 n = startswith(name, "virtfn");
 257                 if (isempty(n) || !in_charset(n, DIGITS))
 258                         continue;
 259
 260                 r = find_ifindex_from_pci_dev_port(child, dev_port);
 261                 if (r < 0)
 262                         continue;
 263
 264                 if (manager_update_sr_iov_ifindices(link->manager, link->ifindex, r) < 0)
 265                         continue;
 266         }
 267
 268         return 0;
 269 }
 270
 271 int link_set_sr_iov_ifindices(Link *link) {
 272         int r;
 273
 274         assert(link);
 275
 276         r = link_set_sr_iov_phys_port(link);
 277         if (r < 0 && !ERRNO_IS_DEVICE_ABSENT(r))
 278                 return r;
 279
 280         r = link_set_sr_iov_virt_ports(link);
 281         if (r < 0 && !ERRNO_IS_DEVICE_ABSENT(r))
 282                 return r;
 283
 284         return 0;
 285 }
 286
 287 void link_clear_sr_iov_ifindices(Link *link) {
 288         void *v;
 289
 290         assert(link);
 291         assert(link->manager);
 292
 293         if (link->sr_iov_phys_port_ifindex > 0) {
 294                 Link *phys_link;
 295
 296                 if (link_get_by_index(link->manager, link->sr_iov_phys_port_ifindex, &phys_link) >= 0)
 297                         set_remove(phys_link->sr_iov_virt_port_ifindices, INT_TO_PTR(link->ifindex));
 298
 299                 link->sr_iov_phys_port_ifindex = 0;
 300         }
 301
 302         while ((v = set_steal_first(link->sr_iov_virt_port_ifindices))) {
 303                 Link *virt_link;
 304
 305                 if (link_get_by_index(link->manager, PTR_TO_INT(v), &virt_link) >= 0)
 306                         virt_link->sr_iov_phys_port_ifindex = 0;
 307         }
 308 }
 309
 310 bool check_ready_for_all_sr_iov_ports(
 311                 Link *link,
 312                 bool allow_unmanaged, /* for the main target */
 313                 bool (check_one)(Link *link, bool allow_unmanaged)) {
 314
 315         Link *phys_link;
 316         void *v;
 317
 318         assert(link);
 319         assert(link->manager);
 320         assert(check_one);
 321
 322         /* Some drivers make VF ports become down when their PF port becomes down, and may fail to configure
 323          * VF ports. Also, when a VF port becomes up/down, its PF port and other VF ports may become down.
 324          * See issue #23315. */
 325
 326         /* First, check the main target. */
 327         if (!check_one(link, allow_unmanaged))
 328                 return false;
 329
 330         /* If this is a VF port, then also check the PF port. */
 331         if (link->sr_iov_phys_port_ifindex > 0) {
 332                 if (link_get_by_index(link->manager, link->sr_iov_phys_port_ifindex, &phys_link) < 0 ||
 333                     !check_one(phys_link, /* allow_unmanaged = */ true))
 334                         return false;
 335         } else
 336                 phys_link = link;
 337
 338         /* Also check all VF ports. */
 339         SET_FOREACH(v, phys_link->sr_iov_virt_port_ifindices) {
 340                 int ifindex = PTR_TO_INT(v);
 341                 Link *virt_link;
 342
 343                 if (ifindex == link->ifindex)
 344                         continue; /* The main target link is a VF port, and its state is already checked. */
 345
 346                 if (link_get_by_index(link->manager, ifindex, &virt_link) < 0)
 347                         return false;
 348
 349                 if (!check_one(virt_link, /* allow_unmanaged = */ true))
 350                         return false;
 351         }
 352
 353         return true;
 354 }