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