src/network/tc/qdisc.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later
   2  * Copyright © 2019 VMware, Inc. */
   3
   4 #include <linux/pkt_sched.h>
   5
   6 #include "alloc-util.h"
   7 #include "conf-parser.h"
   8 #include "in-addr-util.h"
   9 #include "netlink-util.h"
  10 #include "networkd-manager.h"
  11 #include "parse-util.h"
  12 #include "qdisc.h"
  13 #include "set.h"
  14 #include "string-util.h"
  15 #include "strv.h"
  16 #include "tc-util.h"
  17
  18 const QDiscVTable * const qdisc_vtable[_QDISC_KIND_MAX] = {
  19         [QDISC_KIND_BFIFO] = &bfifo_vtable,
  20         [QDISC_KIND_CAKE] = &cake_vtable,
  21         [QDISC_KIND_CODEL] = &codel_vtable,
  22         [QDISC_KIND_DRR] = &drr_vtable,
  23         [QDISC_KIND_ETS] = &ets_vtable,
  24         [QDISC_KIND_FQ] = &fq_vtable,
  25         [QDISC_KIND_FQ_CODEL] = &fq_codel_vtable,
  26         [QDISC_KIND_FQ_PIE] = &fq_pie_vtable,
  27         [QDISC_KIND_GRED] = &gred_vtable,
  28         [QDISC_KIND_HHF] = &hhf_vtable,
  29         [QDISC_KIND_HTB] = &htb_vtable,
  30         [QDISC_KIND_NETEM] = &netem_vtable,
  31         [QDISC_KIND_PIE] = &pie_vtable,
  32         [QDISC_KIND_QFQ] = &qfq_vtable,
  33         [QDISC_KIND_PFIFO] = &pfifo_vtable,
  34         [QDISC_KIND_PFIFO_FAST] = &pfifo_fast_vtable,
  35         [QDISC_KIND_PFIFO_HEAD_DROP] = &pfifo_head_drop_vtable,
  36         [QDISC_KIND_SFB] = &sfb_vtable,
  37         [QDISC_KIND_SFQ] = &sfq_vtable,
  38         [QDISC_KIND_TBF] = &tbf_vtable,
  39         [QDISC_KIND_TEQL] = &teql_vtable,
  40 };
  41
  42 static int qdisc_new(QDiscKind kind, QDisc **ret) {
  43         _cleanup_(qdisc_freep) QDisc *qdisc = NULL;
  44         int r;
  45
  46         if (kind == _QDISC_KIND_INVALID) {
  47                 qdisc = new(QDisc, 1);
  48                 if (!qdisc)
  49                         return -ENOMEM;
  50
  51                 *qdisc = (QDisc) {
  52                         .meta.kind = TC_KIND_QDISC,
  53                         .parent = TC_H_ROOT,
  54                         .kind = kind,
  55                 };
  56         } else {
  57                 assert(kind >= 0 && kind < _QDISC_KIND_MAX);
  58                 qdisc = malloc0(qdisc_vtable[kind]->object_size);
  59                 if (!qdisc)
  60                         return -ENOMEM;
  61
  62                 qdisc->meta.kind = TC_KIND_QDISC,
  63                 qdisc->parent = TC_H_ROOT;
  64                 qdisc->kind = kind;
  65
  66                 if (QDISC_VTABLE(qdisc)->init) {
  67                         r = QDISC_VTABLE(qdisc)->init(qdisc);
  68                         if (r < 0)
  69                                 return r;
  70                 }
  71         }
  72
  73         *ret = TAKE_PTR(qdisc);
  74
  75         return 0;
  76 }
  77
  78 int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret) {
  79         _cleanup_(config_section_freep) ConfigSection *n = NULL;
  80         _cleanup_(qdisc_freep) QDisc *qdisc = NULL;
  81         TrafficControl *existing;
  82         QDisc *q = NULL;
  83         int r;
  84
  85         assert(network);
  86         assert(ret);
  87         assert(filename);
  88         assert(section_line > 0);
  89
  90         r = config_section_new(filename, section_line, &n);
  91         if (r < 0)
  92                 return r;
  93
  94         existing = ordered_hashmap_get(network->tc_by_section, n);
  95         if (existing) {
  96                 if (existing->kind != TC_KIND_QDISC)
  97                         return -EINVAL;
  98
  99                 q = TC_TO_QDISC(existing);
 100
 101                 if (q->kind != _QDISC_KIND_INVALID &&
 102                     kind != _QDISC_KIND_INVALID &&
 103                     q->kind != kind)
 104                         return -EINVAL;
 105
 106                 if (q->kind == kind || kind == _QDISC_KIND_INVALID) {
 107                         *ret = q;
 108                         return 0;
 109                 }
 110         }
 111
 112         r = qdisc_new(kind, &qdisc);
 113         if (r < 0)
 114                 return r;
 115
 116         if (q) {
 117                 qdisc->handle = q->handle;
 118                 qdisc->parent = q->parent;
 119                 qdisc->tca_kind = TAKE_PTR(q->tca_kind);
 120
 121                 qdisc_free(q);
 122         }
 123
 124         qdisc->network = network;
 125         qdisc->section = TAKE_PTR(n);
 126
 127         r = ordered_hashmap_ensure_put(&network->tc_by_section, &config_section_hash_ops, qdisc->section, TC(qdisc));
 128         if (r < 0)
 129                 return r;
 130
 131         *ret = TAKE_PTR(qdisc);
 132         return 0;
 133 }
 134
 135 QDisc* qdisc_free(QDisc *qdisc) {
 136         if (!qdisc)
 137                 return NULL;
 138
 139         if (qdisc->network && qdisc->section)
 140                 ordered_hashmap_remove(qdisc->network->tc_by_section, qdisc->section);
 141
 142         config_section_free(qdisc->section);
 143
 144         if (qdisc->link)
 145                 set_remove(qdisc->link->traffic_control, TC(qdisc));
 146
 147         free(qdisc->tca_kind);
 148         return mfree(qdisc);
 149 }
 150
 151 static const char *qdisc_get_tca_kind(const QDisc *qdisc) {
 152         assert(qdisc);
 153
 154         return (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->tca_kind) ?
 155                 QDISC_VTABLE(qdisc)->tca_kind : qdisc->tca_kind;
 156 }
 157
 158 void qdisc_hash_func(const QDisc *qdisc, struct siphash *state) {
 159         assert(qdisc);
 160         assert(state);
 161
 162         siphash24_compress(&qdisc->handle, sizeof(qdisc->handle), state);
 163         siphash24_compress(&qdisc->parent, sizeof(qdisc->parent), state);
 164         siphash24_compress_string(qdisc_get_tca_kind(qdisc), state);
 165 }
 166
 167 int qdisc_compare_func(const QDisc *a, const QDisc *b) {
 168         int r;
 169
 170         assert(a);
 171         assert(b);
 172
 173         r = CMP(a->handle, b->handle);
 174         if (r != 0)
 175                 return r;
 176
 177         r = CMP(a->parent, b->parent);
 178         if (r != 0)
 179                 return r;
 180
 181         return strcmp_ptr(qdisc_get_tca_kind(a), qdisc_get_tca_kind(b));
 182 }
 183
 184 static int qdisc_get(Link *link, const QDisc *in, QDisc **ret) {
 185         TrafficControl *existing;
 186         int r;
 187
 188         assert(link);
 189         assert(in);
 190
 191         r = traffic_control_get(link, TC(in), &existing);
 192         if (r < 0)
 193                 return r;
 194
 195         if (ret)
 196                 *ret = TC_TO_QDISC(existing);
 197         return 0;
 198 }
 199
 200 static int qdisc_add(Link *link, QDisc *qdisc) {
 201         int r;
 202
 203         assert(link);
 204         assert(qdisc);
 205
 206         r = traffic_control_add(link, TC(qdisc));
 207         if (r < 0)
 208                 return r;
 209
 210         qdisc->link = link;
 211         return 0;
 212 }
 213
 214 static void log_qdisc_debug(QDisc *qdisc, Link *link, const char *str) {
 215         _cleanup_free_ char *state = NULL;
 216
 217         assert(qdisc);
 218         assert(str);
 219
 220         if (!DEBUG_LOGGING)
 221                 return;
 222
 223         (void) network_config_state_to_string_alloc(qdisc->state, &state);
 224
 225         log_link_debug(link, "%s %s QDisc (%s): handle=%"PRIx32":%"PRIx32", parent=%"PRIx32":%"PRIx32", kind=%s",
 226                        str, strna(network_config_source_to_string(qdisc->source)), strna(state),
 227                        TC_H_MAJ(qdisc->handle) >> 16, TC_H_MIN(qdisc->handle),
 228                        TC_H_MAJ(qdisc->parent) >> 16, TC_H_MIN(qdisc->parent),
 229                        strna(qdisc_get_tca_kind(qdisc)));
 230 }
 231
 232 static int qdisc_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 233         int r;
 234
 235         assert(link);
 236         assert(link->tc_messages > 0);
 237         link->tc_messages--;
 238
 239         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 240                 return 1;
 241
 242         r = sd_netlink_message_get_errno(m);
 243         if (r < 0 && r != -EEXIST) {
 244                 log_link_message_error_errno(link, m, r, "Could not set QDisc");
 245                 link_enter_failed(link);
 246                 return 1;
 247         }
 248
 249         if (link->tc_messages == 0) {
 250                 log_link_debug(link, "Traffic control configured");
 251                 link->tc_configured = true;
 252                 link_check_ready(link);
 253         }
 254
 255         return 1;
 256 }
 257
 258 int qdisc_configure(Link *link, QDisc *qdisc) {
 259         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 260         int r;
 261
 262         assert(link);
 263         assert(link->manager);
 264         assert(link->manager->rtnl);
 265         assert(link->ifindex > 0);
 266
 267         r = sd_rtnl_message_new_traffic_control(link->manager->rtnl, &req, RTM_NEWQDISC,
 268                                                 link->ifindex, qdisc->handle, qdisc->parent);
 269         if (r < 0)
 270                 return log_link_debug_errno(link, r, "Could not create RTM_NEWQDISC message: %m");
 271
 272         if (QDISC_VTABLE(qdisc)) {
 273                 if (QDISC_VTABLE(qdisc)->fill_tca_kind) {
 274                         r = QDISC_VTABLE(qdisc)->fill_tca_kind(link, qdisc, req);
 275                         if (r < 0)
 276                                 return r;
 277                 } else {
 278                         r = sd_netlink_message_append_string(req, TCA_KIND, QDISC_VTABLE(qdisc)->tca_kind);
 279                         if (r < 0)
 280                                 return r;
 281                 }
 282
 283                 if (QDISC_VTABLE(qdisc)->fill_message) {
 284                         r = QDISC_VTABLE(qdisc)->fill_message(link, qdisc, req);
 285                         if (r < 0)
 286                                 return r;
 287                 }
 288         } else {
 289                 r = sd_netlink_message_append_string(req, TCA_KIND, qdisc->tca_kind);
 290                 if (r < 0)
 291                         return r;
 292         }
 293
 294         r = netlink_call_async(link->manager->rtnl, NULL, req, qdisc_handler, link_netlink_destroy_callback, link);
 295         if (r < 0)
 296                 return log_link_debug_errno(link, r, "Could not send netlink message: %m");
 297
 298         link_ref(link);
 299         link->tc_messages++;
 300
 301         return 0;
 302 }
 303
 304 int manager_rtnl_process_qdisc(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
 305         _cleanup_(qdisc_freep) QDisc *tmp = NULL;
 306         QDisc *qdisc = NULL;
 307         Link *link;
 308         uint16_t type;
 309         int ifindex, r;
 310
 311         assert(rtnl);
 312         assert(message);
 313         assert(m);
 314
 315         if (sd_netlink_message_is_error(message)) {
 316                 r = sd_netlink_message_get_errno(message);
 317                 if (r < 0)
 318                         log_message_warning_errno(message, r, "rtnl: failed to receive QDisc message, ignoring");
 319
 320                 return 0;
 321         }
 322
 323         r = sd_netlink_message_get_type(message, &type);
 324         if (r < 0) {
 325                 log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
 326                 return 0;
 327         } else if (!IN_SET(type, RTM_NEWQDISC, RTM_DELQDISC)) {
 328                 log_warning("rtnl: received unexpected message type %u when processing QDisc, ignoring.", type);
 329                 return 0;
 330         }
 331
 332         r = sd_rtnl_message_traffic_control_get_ifindex(message, &ifindex);
 333         if (r < 0) {
 334                 log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
 335                 return 0;
 336         } else if (ifindex <= 0) {
 337                 log_warning("rtnl: received QDisc message with invalid ifindex %d, ignoring.", ifindex);
 338                 return 0;
 339         }
 340
 341         if (link_get_by_index(m, ifindex, &link) < 0) {
 342                 if (!m->enumerating)
 343                         log_warning("rtnl: received QDisc for link '%d' we don't know about, ignoring.", ifindex);
 344                 return 0;
 345         }
 346
 347         r = qdisc_new(_QDISC_KIND_INVALID, &tmp);
 348         if (r < 0)
 349                 return log_oom();
 350
 351         r = sd_rtnl_message_traffic_control_get_handle(message, &tmp->handle);
 352         if (r < 0) {
 353                 log_link_warning_errno(link, r, "rtnl: received QDisc message without handle, ignoring: %m");
 354                 return 0;
 355         }
 356
 357         r = sd_rtnl_message_traffic_control_get_parent(message, &tmp->parent);
 358         if (r < 0) {
 359                 log_link_warning_errno(link, r, "rtnl: received QDisc message without parent, ignoring: %m");
 360                 return 0;
 361         }
 362
 363         r = sd_netlink_message_read_string_strdup(message, TCA_KIND, &tmp->tca_kind);
 364         if (r < 0) {
 365                 log_link_warning_errno(link, r, "rtnl: received QDisc message without kind, ignoring: %m");
 366                 return 0;
 367         }
 368
 369         (void) qdisc_get(link, tmp, &qdisc);
 370
 371         switch (type) {
 372         case RTM_NEWQDISC:
 373                 if (qdisc) {
 374                         qdisc_enter_configured(qdisc);
 375                         log_qdisc_debug(qdisc, link, "Received remembered");
 376                 } else {
 377                         qdisc_enter_configured(tmp);
 378                         log_qdisc_debug(tmp, link, "Received new");
 379
 380                         r = qdisc_add(link, tmp);
 381                         if (r < 0) {
 382                                 log_link_warning_errno(link, r, "Failed to remember QDisc, ignoring: %m");
 383                                 return 0;
 384                         }
 385
 386                         qdisc = TAKE_PTR(tmp);
 387                 }
 388
 389                 break;
 390
 391         case RTM_DELQDISC:
 392                 if (qdisc) {
 393                         qdisc_enter_removed(qdisc);
 394                         if (qdisc->state == 0) {
 395                                 log_qdisc_debug(qdisc, link, "Forgetting");
 396                                 qdisc_free(qdisc);
 397                         } else
 398                                 log_qdisc_debug(qdisc, link, "Removed");
 399                 } else
 400                         log_qdisc_debug(tmp, link, "Kernel removed unknown");
 401
 402                 break;
 403
 404         default:
 405                 assert_not_reached();
 406         }
 407
 408         return 1;
 409 }
 410
 411 int qdisc_section_verify(QDisc *qdisc, bool *has_root, bool *has_clsact) {
 412         int r;
 413
 414         assert(qdisc);
 415         assert(has_root);
 416         assert(has_clsact);
 417
 418         if (section_is_invalid(qdisc->section))
 419                 return -EINVAL;
 420
 421         if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->verify) {
 422                 r = QDISC_VTABLE(qdisc)->verify(qdisc);
 423                 if (r < 0)
 424                         return r;
 425         }
 426
 427         if (qdisc->parent == TC_H_ROOT) {
 428                 if (*has_root)
 429                         return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 430                                                  "%s: More than one root qdisc section is defined. "
 431                                                  "Ignoring the qdisc section from line %u.",
 432                                                  qdisc->section->filename, qdisc->section->line);
 433                 *has_root = true;
 434         } else if (qdisc->parent == TC_H_CLSACT) { /* TC_H_CLSACT == TC_H_INGRESS */
 435                 if (*has_clsact)
 436                         return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 437                                                  "%s: More than one clsact or ingress qdisc section is defined. "
 438                                                  "Ignoring the qdisc section from line %u.",
 439                                                  qdisc->section->filename, qdisc->section->line);
 440                 *has_clsact = true;
 441         }
 442
 443         return 0;
 444 }
 445
 446 int config_parse_qdisc_parent(
 447                 const char *unit,
 448                 const char *filename,
 449                 unsigned line,
 450                 const char *section,
 451                 unsigned section_line,
 452                 const char *lvalue,
 453                 int ltype,
 454                 const char *rvalue,
 455                 void *data,
 456                 void *userdata) {
 457
 458         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 459         Network *network = data;
 460         int r;
 461
 462         assert(filename);
 463         assert(lvalue);
 464         assert(rvalue);
 465         assert(data);
 466
 467         r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
 468         if (r == -ENOMEM)
 469                 return log_oom();
 470         if (r < 0) {
 471                 log_syntax(unit, LOG_WARNING, filename, line, r,
 472                            "More than one kind of queueing discipline, ignoring assignment: %m");
 473                 return 0;
 474         }
 475
 476         if (streq(rvalue, "root"))
 477                 qdisc->parent = TC_H_ROOT;
 478         else if (streq(rvalue, "clsact")) {
 479                 qdisc->parent = TC_H_CLSACT;
 480                 qdisc->handle = TC_H_MAKE(TC_H_CLSACT, 0);
 481         } else if (streq(rvalue, "ingress")) {
 482                 qdisc->parent = TC_H_INGRESS;
 483                 qdisc->handle = TC_H_MAKE(TC_H_INGRESS, 0);
 484         } else {
 485                 r = parse_handle(rvalue, &qdisc->parent);
 486                 if (r < 0) {
 487                         log_syntax(unit, LOG_WARNING, filename, line, r,
 488                                    "Failed to parse 'Parent=', ignoring assignment: %s",
 489                                    rvalue);
 490                         return 0;
 491                 }
 492         }
 493
 494         if (STR_IN_SET(rvalue, "clsact", "ingress")) {
 495                 r = free_and_strdup(&qdisc->tca_kind, rvalue);
 496                 if (r < 0)
 497                         return log_oom();
 498         } else
 499                 qdisc->tca_kind = mfree(qdisc->tca_kind);
 500
 501         TAKE_PTR(qdisc);
 502
 503         return 0;
 504 }
 505
 506 int config_parse_qdisc_handle(
 507                 const char *unit,
 508                 const char *filename,
 509                 unsigned line,
 510                 const char *section,
 511                 unsigned section_line,
 512                 const char *lvalue,
 513                 int ltype,
 514                 const char *rvalue,
 515                 void *data,
 516                 void *userdata) {
 517
 518         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 519         Network *network = data;
 520         uint16_t n;
 521         int r;
 522
 523         assert(filename);
 524         assert(lvalue);
 525         assert(rvalue);
 526         assert(data);
 527
 528         r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
 529         if (r == -ENOMEM)
 530                 return log_oom();
 531         if (r < 0) {
 532                 log_syntax(unit, LOG_WARNING, filename, line, r,
 533                            "More than one kind of queueing discipline, ignoring assignment: %m");
 534                 return 0;
 535         }
 536
 537         if (isempty(rvalue)) {
 538                 qdisc->handle = TC_H_UNSPEC;
 539                 TAKE_PTR(qdisc);
 540                 return 0;
 541         }
 542
 543         r = safe_atou16_full(rvalue, 16, &n);
 544         if (r < 0) {
 545                 log_syntax(unit, LOG_WARNING, filename, line, r,
 546                            "Failed to parse 'Handle=', ignoring assignment: %s",
 547                            rvalue);
 548                 return 0;
 549         }
 550
 551         qdisc->handle = (uint32_t) n << 16;
 552         TAKE_PTR(qdisc);
 553
 554         return 0;
 555 }