src/network/networkd-sriov.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later
   2  * Copyright © 2020 VMware, Inc. */
   3
   4 #include "alloc-util.h"
   5 #include "netlink-util.h"
   6 #include "networkd-manager.h"
   7 #include "networkd-sriov.h"
   8 #include "parse-util.h"
   9 #include "set.h"
  10 #include "string-util.h"
  11
  12 static int sr_iov_new(SRIOV **ret) {
  13         SRIOV *sr_iov;
  14
  15         sr_iov = new(SRIOV, 1);
  16         if (!sr_iov)
  17                 return -ENOMEM;
  18
  19         *sr_iov = (SRIOV) {
  20                   .vf = (uint32_t) -1,
  21                   .vlan_proto = ETH_P_8021Q,
  22                   .vf_spoof_check_setting = -1,
  23                   .trust = -1,
  24                   .query_rss = -1,
  25                   .link_state = _SR_IOV_LINK_STATE_INVALID,
  26         };
  27
  28         *ret = TAKE_PTR(sr_iov);
  29
  30         return 0;
  31 }
  32
  33 static int sr_iov_new_static(Network *network, const char *filename, unsigned section_line, SRIOV **ret) {
  34         _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
  35         _cleanup_(sr_iov_freep) SRIOV *sr_iov = NULL;
  36         SRIOV *existing = NULL;
  37         int r;
  38
  39         assert(network);
  40         assert(ret);
  41         assert(filename);
  42         assert(section_line > 0);
  43
  44         r = network_config_section_new(filename, section_line, &n);
  45         if (r < 0)
  46                 return r;
  47
  48         existing = ordered_hashmap_get(network->sr_iov_by_section, n);
  49         if (existing) {
  50                 *ret = existing;
  51                 return 0;
  52         }
  53
  54         r = sr_iov_new(&sr_iov);
  55         if (r < 0)
  56                 return r;
  57
  58         sr_iov->network = network;
  59         sr_iov->section = TAKE_PTR(n);
  60
  61         r = ordered_hashmap_ensure_allocated(&network->sr_iov_by_section, &network_config_hash_ops);
  62         if (r < 0)
  63                 return r;
  64
  65         r = ordered_hashmap_put(network->sr_iov_by_section, sr_iov->section, sr_iov);
  66         if (r < 0)
  67                 return r;
  68
  69         *ret = TAKE_PTR(sr_iov);
  70         return 0;
  71 }
  72
  73 SRIOV *sr_iov_free(SRIOV *sr_iov) {
  74         if (!sr_iov)
  75                 return NULL;
  76
  77         if (sr_iov->network && sr_iov->section)
  78                 ordered_hashmap_remove(sr_iov->network->sr_iov_by_section, sr_iov->section);
  79
  80         network_config_section_free(sr_iov->section);
  81
  82         return mfree(sr_iov);
  83 }
  84
  85 static int sr_iov_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
  86         int r;
  87
  88         assert(link);
  89         assert(link->sr_iov_messages > 0);
  90         link->sr_iov_messages--;
  91
  92         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
  93                 return 1;
  94
  95         r = sd_netlink_message_get_errno(m);
  96         if (r < 0 && r != -EEXIST) {
  97                 log_link_message_error_errno(link, m, r, "Could not set up SR-IOV");
  98                 link_enter_failed(link);
  99                 return 1;
 100         }
 101
 102         if (link->sr_iov_messages == 0) {
 103                 log_link_debug(link, "SR-IOV configured");
 104                 link->sr_iov_configured = true;
 105                 link_check_ready(link);
 106         }
 107
 108         return 1;
 109 }
 110
 111 static int sr_iov_configure(Link *link, SRIOV *sr_iov) {
 112         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 113         int r;
 114
 115         assert(link);
 116         assert(link->manager);
 117         assert(link->manager->rtnl);
 118         assert(link->ifindex > 0);
 119
 120         log_link_debug(link, "Setting SR-IOV virtual function %"PRIu32, sr_iov->vf);
 121
 122         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
 123         if (r < 0)
 124                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 125
 126         r = sd_netlink_message_open_container(req, IFLA_VFINFO_LIST);
 127         if (r < 0)
 128                 return log_link_error_errno(link, r, "Could not open IFLA_VFINFO_LIST container: %m");
 129
 130         r = sd_netlink_message_open_container(req, IFLA_VF_INFO);
 131         if (r < 0)
 132                 return log_link_error_errno(link, r, "Could not open IFLA_VF_INFO container: %m");
 133
 134         if (!ether_addr_is_null(&sr_iov->mac)) {
 135                 struct ifla_vf_mac ivm = {
 136                         .vf = sr_iov->vf,
 137                 };
 138
 139                 memcpy(ivm.mac, &sr_iov->mac, ETH_ALEN);
 140                 r = sd_netlink_message_append_data(req, IFLA_VF_MAC, &ivm, sizeof(struct ifla_vf_mac));
 141                 if (r < 0)
 142                         return log_link_error_errno(link, r, "Could not append IFLA_VF_MAC: %m");
 143         }
 144
 145         if (sr_iov->vf_spoof_check_setting >= 0) {
 146                 struct ifla_vf_spoofchk ivs = {
 147                         .vf = sr_iov->vf,
 148                         .setting = sr_iov->vf_spoof_check_setting,
 149                 };
 150
 151                 r = sd_netlink_message_append_data(req, IFLA_VF_SPOOFCHK, &ivs, sizeof(struct ifla_vf_spoofchk));
 152                 if (r < 0)
 153                         return log_link_error_errno(link, r, "Could not append IFLA_VF_SPOOFCHK: %m");
 154         }
 155
 156         if (sr_iov->query_rss >= 0) {
 157                 struct ifla_vf_rss_query_en ivs = {
 158                         .vf = sr_iov->vf,
 159                         .setting = sr_iov->query_rss,
 160                 };
 161
 162                 r = sd_netlink_message_append_data(req, IFLA_VF_RSS_QUERY_EN, &ivs, sizeof(struct ifla_vf_rss_query_en));
 163                 if (r < 0)
 164                         return log_link_error_errno(link, r, "Could not append IFLA_VF_RSS_QUERY_EN: %m");
 165         }
 166
 167         if (sr_iov->trust >= 0) {
 168                 struct ifla_vf_trust ivt = {
 169                         .vf = sr_iov->vf,
 170                         .setting = sr_iov->trust,
 171                 };
 172
 173                 r = sd_netlink_message_append_data(req, IFLA_VF_TRUST, &ivt, sizeof(struct ifla_vf_trust));
 174                 if (r < 0)
 175                         return log_link_error_errno(link, r, "Could not append IFLA_VF_TRUST: %m");
 176         }
 177
 178         if (sr_iov->link_state >= 0) {
 179                 struct ifla_vf_link_state ivl = {
 180                         .vf = sr_iov->vf,
 181                         .link_state = sr_iov->link_state,
 182                 };
 183
 184                 r = sd_netlink_message_append_data(req, IFLA_VF_LINK_STATE, &ivl, sizeof(struct ifla_vf_link_state));
 185                 if (r < 0)
 186                         return log_link_error_errno(link, r, "Could not append IFLA_VF_LINK_STATE: %m");
 187         }
 188
 189         if (sr_iov->vlan > 0) {
 190                 /* Because of padding, first the buffer must be initialized with 0. */
 191                 struct ifla_vf_vlan_info ivvi = {};
 192                 ivvi.vf = sr_iov->vf;
 193                 ivvi.vlan = sr_iov->vlan;
 194                 ivvi.qos = sr_iov->qos;
 195                 ivvi.vlan_proto = htobe16(sr_iov->vlan_proto);
 196
 197                 r = sd_netlink_message_open_container(req, IFLA_VF_VLAN_LIST);
 198                 if (r < 0)
 199                         return log_link_error_errno(link, r, "Could not open IFLA_VF_VLAN_LIST container: %m");
 200
 201                 r = sd_netlink_message_append_data(req, IFLA_VF_VLAN_INFO, &ivvi, sizeof(struct ifla_vf_vlan_info));
 202                 if (r < 0)
 203                         return log_link_error_errno(link, r, "Could not append IFLA_VF_VLAN_INFO: %m");
 204
 205                 r = sd_netlink_message_close_container(req);
 206                 if (r < 0)
 207                         return log_link_error_errno(link, r, "Could not close IFLA_VF_VLAN_LIST container: %m");
 208         }
 209
 210         r = sd_netlink_message_close_container(req);
 211         if (r < 0)
 212                 return log_link_error_errno(link, r, "Could not close IFLA_VF_INFO container: %m");
 213
 214         r = sd_netlink_message_close_container(req);
 215         if (r < 0)
 216                 return log_link_error_errno(link, r, "Could not close IFLA_VFINFO_LIST container: %m");
 217
 218         r = netlink_call_async(link->manager->rtnl, NULL, req, sr_iov_handler,
 219                                link_netlink_destroy_callback, link);
 220         if (r < 0)
 221                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
 222
 223         link_ref(link);
 224         link->sr_iov_messages++;
 225
 226         return 0;
 227 }
 228
 229 int link_configure_sr_iov(Link *link) {
 230         SRIOV *sr_iov;
 231         int r;
 232
 233         link->sr_iov_configured = false;
 234         link->sr_iov_messages = 0;
 235
 236         ORDERED_HASHMAP_FOREACH(sr_iov, link->network->sr_iov_by_section) {
 237                 r = sr_iov_configure(link, sr_iov);
 238                 if (r < 0)
 239                         return r;
 240         }
 241
 242         if (link->sr_iov_messages == 0)
 243                 link->sr_iov_configured = true;
 244         else
 245                 log_link_debug(link, "Configuring SR-IOV");
 246
 247         return 0;
 248 }
 249
 250 static int sr_iov_section_verify(SRIOV *sr_iov) {
 251         assert(sr_iov);
 252
 253         if (section_is_invalid(sr_iov->section))
 254                 return -EINVAL;
 255
 256         if (sr_iov->vf == (uint32_t) -1)
 257                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 258                                          "%s: [SRIOV] section without VirtualFunction= field configured. "
 259                                          "Ignoring [SRIOV] section from line %u.",
 260                                          sr_iov->section->filename, sr_iov->section->line);
 261
 262         return 0;
 263 }
 264
 265 void network_drop_invalid_sr_iov(Network *network) {
 266         SRIOV *sr_iov;
 267
 268         assert(network);
 269
 270         ORDERED_HASHMAP_FOREACH(sr_iov, network->sr_iov_by_section)
 271                 if (sr_iov_section_verify(sr_iov) < 0)
 272                         sr_iov_free(sr_iov);
 273 }
 274
 275 int config_parse_sr_iov_uint32(
 276                 const char *unit,
 277                 const char *filename,
 278                 unsigned line,
 279                 const char *section,
 280                 unsigned section_line,
 281                 const char *lvalue,
 282                 int ltype,
 283                 const char *rvalue,
 284                 void *data,
 285                 void *userdata) {
 286
 287         _cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
 288         Network *network = data;
 289         uint32_t k;
 290         int r;
 291
 292         assert(filename);
 293         assert(lvalue);
 294         assert(rvalue);
 295         assert(data);
 296
 297         r = sr_iov_new_static(network, filename, section_line, &sr_iov);
 298         if (r < 0)
 299                 return r;
 300
 301         if (isempty(rvalue)) {
 302                 if (streq(lvalue, "VirtualFunction"))
 303                         sr_iov->vf = (uint32_t) -1;
 304                 else if (streq(lvalue, "VLANId"))
 305                         sr_iov->vlan = 0;
 306                 else if (streq(lvalue, "QualityOfService"))
 307                         sr_iov->qos = 0;
 308                 else
 309                         assert_not_reached("Invalid lvalue");
 310
 311                 TAKE_PTR(sr_iov);
 312                 return 0;
 313         }
 314
 315         r = safe_atou32(rvalue, &k);
 316         if (r < 0) {
 317                 log_syntax(unit, LOG_WARNING, filename, line, r,
 318                            "Failed to parse SR-IOV '%s=', ignoring assignment: %s", lvalue, rvalue);
 319                 return 0;
 320         }
 321
 322         if (streq(lvalue, "VLANId")) {
 323                 if (k == 0 || k > 4095) {
 324                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid SR-IOV VLANId: %d", k);
 325                         return 0;
 326                 }
 327                 sr_iov->vlan = k;
 328         } else if (streq(lvalue, "VirtualFunction")) {
 329                 if (k >= INT_MAX) {
 330                         log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid SR-IOV virtual function: %d", k);
 331                         return 0;
 332                 }
 333                 sr_iov->vf = k;
 334         } else if (streq(lvalue, "QualityOfService"))
 335                 sr_iov->qos = k;
 336         else
 337                 assert_not_reached("Invalid lvalue");
 338
 339         TAKE_PTR(sr_iov);
 340         return 0;
 341 }
 342
 343 int config_parse_sr_iov_vlan_proto(
 344                 const char *unit,
 345                 const char *filename,
 346                 unsigned line,
 347                 const char *section,
 348                 unsigned section_line,
 349                 const char *lvalue,
 350                 int ltype,
 351                 const char *rvalue,
 352                 void *data,
 353                 void *userdata) {
 354
 355         _cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
 356         Network *network = data;
 357         int r;
 358
 359         assert(filename);
 360         assert(lvalue);
 361         assert(rvalue);
 362         assert(data);
 363
 364         r = sr_iov_new_static(network, filename, section_line, &sr_iov);
 365         if (r < 0)
 366                 return r;
 367
 368         if (isempty(rvalue) || streq(rvalue, "802.1Q"))
 369                 sr_iov->vlan_proto = ETH_P_8021Q;
 370         else if (streq(rvalue, "802.1ad"))
 371                 sr_iov->vlan_proto = ETH_P_8021AD;
 372         else {
 373                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 374                            "Invalid SR-IOV '%s=', ignoring assignment: %s", lvalue, rvalue);
 375                 return 0;
 376         }
 377
 378         TAKE_PTR(sr_iov);
 379         return 0;
 380 }
 381
 382 int config_parse_sr_iov_link_state(
 383                 const char *unit,
 384                 const char *filename,
 385                 unsigned line,
 386                 const char *section,
 387                 unsigned section_line,
 388                 const char *lvalue,
 389                 int ltype,
 390                 const char *rvalue,
 391                 void *data,
 392                 void *userdata) {
 393
 394         _cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
 395         Network *network = data;
 396         int r;
 397
 398         assert(filename);
 399         assert(lvalue);
 400         assert(rvalue);
 401         assert(data);
 402
 403         r = sr_iov_new_static(network, filename, section_line, &sr_iov);
 404         if (r < 0)
 405                 return r;
 406
 407         /* Unfortunately, SR_IOV_LINK_STATE_DISABLE is 2, not 0. So, we cannot use
 408          * DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN() macro. */
 409
 410         if (isempty(rvalue)) {
 411                 sr_iov->link_state = _SR_IOV_LINK_STATE_INVALID;
 412                 TAKE_PTR(sr_iov);
 413                 return 0;
 414         }
 415
 416         if (streq(rvalue, "auto")) {
 417                 sr_iov->link_state = SR_IOV_LINK_STATE_AUTO;
 418                 TAKE_PTR(sr_iov);
 419                 return 0;
 420         }
 421
 422         r = parse_boolean(rvalue);
 423         if (r < 0) {
 424                 log_syntax(unit, LOG_WARNING, filename, line, r,
 425                            "Failed to parse SR-IOV '%s=', ignoring assignment: %s", lvalue, rvalue);
 426                 return 0;
 427         }
 428
 429         sr_iov->link_state = r ? SR_IOV_LINK_STATE_ENABLE : SR_IOV_LINK_STATE_DISABLE;
 430         TAKE_PTR(sr_iov);
 431         return 0;
 432 }
 433
 434 int config_parse_sr_iov_boolean(
 435                 const char *unit,
 436                 const char *filename,
 437                 unsigned line,
 438                 const char *section,
 439                 unsigned section_line,
 440                 const char *lvalue,
 441                 int ltype,
 442                 const char *rvalue,
 443                 void *data,
 444                 void *userdata) {
 445
 446         _cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
 447         Network *network = data;
 448         int r;
 449
 450         assert(filename);
 451         assert(lvalue);
 452         assert(rvalue);
 453         assert(data);
 454
 455         r = sr_iov_new_static(network, filename, section_line, &sr_iov);
 456         if (r < 0)
 457                 return r;
 458
 459         if (isempty(rvalue)) {
 460                 if (streq(lvalue, "MACSpoofCheck"))
 461                         sr_iov->vf_spoof_check_setting = -1;
 462                 else if (streq(lvalue, "QueryReceiveSideScaling"))
 463                         sr_iov->query_rss = -1;
 464                 else if (streq(lvalue, "Trust"))
 465                         sr_iov->trust = -1;
 466                 else
 467                         assert_not_reached("Invalid lvalue");
 468
 469                 TAKE_PTR(sr_iov);
 470                 return 0;
 471         }
 472
 473         r = parse_boolean(rvalue);
 474         if (r < 0) {
 475                 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse '%s=', ignoring: %s", lvalue, rvalue);
 476                 return 0;
 477         }
 478
 479         if (streq(lvalue, "MACSpoofCheck"))
 480                 sr_iov->vf_spoof_check_setting = r;
 481         else if (streq(lvalue, "QueryReceiveSideScaling"))
 482                 sr_iov->query_rss = r;
 483         else if (streq(lvalue, "Trust"))
 484                 sr_iov->trust = r;
 485         else
 486                 assert_not_reached("Invalid lvalue");
 487
 488         TAKE_PTR(sr_iov);
 489         return 0;
 490 }
 491
 492 int config_parse_sr_iov_mac(
 493                 const char *unit,
 494                 const char *filename,
 495                 unsigned line,
 496                 const char *section,
 497                 unsigned section_line,
 498                 const char *lvalue,
 499                 int ltype,
 500                 const char *rvalue,
 501                 void *data,
 502                 void *userdata) {
 503
 504         _cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
 505         Network *network = data;
 506         int r;
 507
 508         assert(filename);
 509         assert(lvalue);
 510         assert(rvalue);
 511         assert(data);
 512
 513         r = sr_iov_new_static(network, filename, section_line, &sr_iov);
 514         if (r < 0)
 515                 return r;
 516
 517         if (isempty(rvalue)) {
 518                 sr_iov->mac = ETHER_ADDR_NULL;
 519                 TAKE_PTR(sr_iov);
 520                 return 0;
 521         }
 522
 523         r = ether_addr_from_string(rvalue, &sr_iov->mac);
 524         if (r < 0) {
 525                 log_syntax(unit, LOG_WARNING, filename, line, r,
 526                            "Failed to parse SR-IOV '%s=', ignoring assignment: %s", lvalue, rvalue);
 527                 return 0;
 528         }
 529
 530         TAKE_PTR(sr_iov);
 531         return 0;
 532 }