src/network/tc/qdisc.c

   1 /* SPDX-License-Identifier: LGPL-2.1+
   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_CODEL] = &codel_vtable,
  20         [QDISC_KIND_FQ] = &fq_vtable,
  21         [QDISC_KIND_FQ_CODEL] = &fq_codel_vtable,
  22         [QDISC_KIND_HTB] = &htb_vtable,
  23         [QDISC_KIND_NETEM] = &netem_vtable,
  24         [QDISC_KIND_SFQ] = &sfq_vtable,
  25         [QDISC_KIND_TBF] = &tbf_vtable,
  26         [QDISC_KIND_TEQL] = &teql_vtable,
  27 };
  28
  29 static int qdisc_new(QDiscKind kind, QDisc **ret) {
  30         QDisc *qdisc;
  31         int r;
  32
  33         if (kind == _QDISC_KIND_INVALID) {
  34                 qdisc = new(QDisc, 1);
  35                 if (!qdisc)
  36                         return -ENOMEM;
  37
  38                 *qdisc = (QDisc) {
  39                         .family = AF_UNSPEC,
  40                         .parent = TC_H_ROOT,
  41                         .kind = kind,
  42                 };
  43         } else {
  44                 qdisc = malloc0(qdisc_vtable[kind]->object_size);
  45                 if (!qdisc)
  46                         return -ENOMEM;
  47
  48                 qdisc->family = AF_UNSPEC;
  49                 qdisc->parent = TC_H_ROOT;
  50                 qdisc->kind = kind;
  51
  52                 if (QDISC_VTABLE(qdisc)->init) {
  53                         r = QDISC_VTABLE(qdisc)->init(qdisc);
  54                         if (r < 0)
  55                                 return r;
  56                 }
  57         }
  58
  59         *ret = TAKE_PTR(qdisc);
  60
  61         return 0;
  62 }
  63
  64 int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret) {
  65         _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
  66         _cleanup_(qdisc_freep) QDisc *qdisc = NULL;
  67         QDisc *existing;
  68         int r;
  69
  70         assert(network);
  71         assert(ret);
  72         assert(filename);
  73         assert(section_line > 0);
  74
  75         r = network_config_section_new(filename, section_line, &n);
  76         if (r < 0)
  77                 return r;
  78
  79         existing = ordered_hashmap_get(network->qdiscs_by_section, n);
  80         if (existing) {
  81                 if (existing->kind != _QDISC_KIND_INVALID &&
  82                     kind != _QDISC_KIND_INVALID &&
  83                     existing->kind != kind)
  84                         return -EINVAL;
  85
  86                 if (existing->kind == kind || kind == _QDISC_KIND_INVALID) {
  87                         *ret = existing;
  88                         return 0;
  89                 }
  90         }
  91
  92         r = qdisc_new(kind, &qdisc);
  93         if (r < 0)
  94                 return r;
  95
  96         if (existing) {
  97                 qdisc->family = existing->family;
  98                 qdisc->handle = existing->handle;
  99                 qdisc->parent = existing->parent;
 100                 qdisc->tca_kind = TAKE_PTR(existing->tca_kind);
 101
 102                 qdisc_free(ordered_hashmap_remove(network->qdiscs_by_section, n));
 103         }
 104
 105         qdisc->network = network;
 106         qdisc->section = TAKE_PTR(n);
 107
 108         r = ordered_hashmap_ensure_allocated(&network->qdiscs_by_section, &network_config_hash_ops);
 109         if (r < 0)
 110                 return r;
 111
 112         r = ordered_hashmap_put(network->qdiscs_by_section, qdisc->section, qdisc);
 113         if (r < 0)
 114                 return r;
 115
 116         *ret = TAKE_PTR(qdisc);
 117         return 0;
 118 }
 119
 120 void qdisc_free(QDisc *qdisc) {
 121         if (!qdisc)
 122                 return;
 123
 124         if (qdisc->network && qdisc->section)
 125                 ordered_hashmap_remove(qdisc->network->qdiscs_by_section, qdisc->section);
 126
 127         network_config_section_free(qdisc->section);
 128
 129         free(qdisc->tca_kind);
 130         free(qdisc);
 131 }
 132
 133 static int qdisc_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 134         int r;
 135
 136         assert(link);
 137         assert(link->qdisc_messages > 0);
 138         link->qdisc_messages--;
 139
 140         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 141                 return 1;
 142
 143         r = sd_netlink_message_get_errno(m);
 144         if (r < 0 && r != -EEXIST) {
 145                 log_link_message_error_errno(link, m, r, "Could not set QDisc");
 146                 link_enter_failed(link);
 147                 return 1;
 148         }
 149
 150         if (link->qdisc_messages == 0) {
 151                 log_link_debug(link, "QDisc configured");
 152                 link->qdiscs_configured = true;
 153                 link_check_ready(link);
 154         }
 155
 156         return 1;
 157 }
 158
 159 int qdisc_configure(Link *link, QDisc *qdisc) {
 160         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 161         int r;
 162
 163         assert(link);
 164         assert(link->manager);
 165         assert(link->manager->rtnl);
 166         assert(link->ifindex > 0);
 167
 168         r = sd_rtnl_message_new_qdisc(link->manager->rtnl, &req, RTM_NEWQDISC, qdisc->family, link->ifindex);
 169         if (r < 0)
 170                 return log_link_error_errno(link, r, "Could not create RTM_NEWQDISC message: %m");
 171
 172         r = sd_rtnl_message_set_qdisc_parent(req, qdisc->parent);
 173         if (r < 0)
 174                 return log_link_error_errno(link, r, "Could not create tcm_parent message: %m");
 175
 176         if (qdisc->handle != TC_H_UNSPEC) {
 177                 r = sd_rtnl_message_set_qdisc_handle(req, qdisc->handle);
 178                 if (r < 0)
 179                         return log_link_error_errno(link, r, "Could not set tcm_handle message: %m");
 180         }
 181
 182         if (QDISC_VTABLE(qdisc)) {
 183                 if (QDISC_VTABLE(qdisc)->fill_tca_kind) {
 184                         r = QDISC_VTABLE(qdisc)->fill_tca_kind(link, qdisc, req);
 185                         if (r < 0)
 186                                 return r;
 187                 } else {
 188                         r = sd_netlink_message_append_string(req, TCA_KIND, QDISC_VTABLE(qdisc)->tca_kind);
 189                         if (r < 0)
 190                                 return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
 191                 }
 192
 193                 if (QDISC_VTABLE(qdisc)->fill_message) {
 194                         r = QDISC_VTABLE(qdisc)->fill_message(link, qdisc, req);
 195                         if (r < 0)
 196                                 return r;
 197                 }
 198         } else {
 199                 r = sd_netlink_message_append_string(req, TCA_KIND, qdisc->tca_kind);
 200                 if (r < 0)
 201                         return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
 202         }
 203
 204         r = netlink_call_async(link->manager->rtnl, NULL, req, qdisc_handler, link_netlink_destroy_callback, link);
 205         if (r < 0)
 206                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
 207
 208         link_ref(link);
 209         link->qdisc_messages++;
 210
 211         return 0;
 212 }
 213
 214 int qdisc_section_verify(QDisc *qdisc, bool *has_root, bool *has_clsact) {
 215         int r;
 216
 217         assert(qdisc);
 218         assert(has_root);
 219         assert(has_clsact);
 220
 221         if (section_is_invalid(qdisc->section))
 222                 return -EINVAL;
 223
 224         if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->verify) {
 225                 r = QDISC_VTABLE(qdisc)->verify(qdisc);
 226                 if (r < 0)
 227                         return r;
 228         }
 229
 230         if (qdisc->parent == TC_H_ROOT) {
 231                 if (*has_root)
 232                         return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 233                                                  "%s: More than one root qdisc section is defined. "
 234                                                  "Ignoring the qdisc section from line %u.",
 235                                                  qdisc->section->filename, qdisc->section->line);
 236                 *has_root = true;
 237         } else if (qdisc->parent == TC_H_CLSACT) { /* TC_H_CLSACT == TC_H_INGRESS */
 238                 if (*has_clsact)
 239                         return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 240                                                  "%s: More than one clsact or ingress qdisc section is defined. "
 241                                                  "Ignoring the qdisc section from line %u.",
 242                                                  qdisc->section->filename, qdisc->section->line);
 243                 *has_clsact = true;
 244         }
 245
 246         return 0;
 247 }
 248
 249 int config_parse_qdisc_parent(
 250                 const char *unit,
 251                 const char *filename,
 252                 unsigned line,
 253                 const char *section,
 254                 unsigned section_line,
 255                 const char *lvalue,
 256                 int ltype,
 257                 const char *rvalue,
 258                 void *data,
 259                 void *userdata) {
 260
 261         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 262         Network *network = data;
 263         int r;
 264
 265         assert(filename);
 266         assert(lvalue);
 267         assert(rvalue);
 268         assert(data);
 269
 270         r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
 271         if (r < 0)
 272                 return r;
 273
 274         if (streq(rvalue, "root")) {
 275                 qdisc->parent = TC_H_ROOT;
 276                 if (qdisc->handle == 0)
 277                         qdisc->handle = TC_H_UNSPEC;
 278         } else if (streq(rvalue, "clsact")) {
 279                 qdisc->parent = TC_H_CLSACT;
 280                 qdisc->handle = TC_H_MAKE(TC_H_CLSACT, 0);
 281         } else if (streq(rvalue, "ingress")) {
 282                 qdisc->parent = TC_H_INGRESS;
 283                 qdisc->handle = TC_H_MAKE(TC_H_INGRESS, 0);
 284         } else {
 285                 r = parse_handle(rvalue, &qdisc->parent);
 286                 if (r < 0) {
 287                         log_syntax(unit, LOG_ERR, filename, line, r,
 288                                    "Failed to parse 'Parent=', ignoring assignment: %s",
 289                                    rvalue);
 290                         return 0;
 291                 }
 292         }
 293
 294         if (STR_IN_SET(rvalue, "clsact", "ingress")) {
 295                 r = free_and_strdup(&qdisc->tca_kind, rvalue);
 296                 if (r < 0)
 297                         return log_oom();
 298         } else
 299                 qdisc->tca_kind = mfree(qdisc->tca_kind);
 300
 301         qdisc = NULL;
 302
 303         return 0;
 304 }
 305
 306 int config_parse_qdisc_handle(
 307                 const char *unit,
 308                 const char *filename,
 309                 unsigned line,
 310                 const char *section,
 311                 unsigned section_line,
 312                 const char *lvalue,
 313                 int ltype,
 314                 const char *rvalue,
 315                 void *data,
 316                 void *userdata) {
 317
 318         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 319         Network *network = data;
 320         uint16_t n;
 321         int r;
 322
 323         assert(filename);
 324         assert(lvalue);
 325         assert(rvalue);
 326         assert(data);
 327
 328         r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
 329         if (r < 0)
 330                 return r;
 331
 332         if (isempty(rvalue)) {
 333                 qdisc->handle = TC_H_UNSPEC;
 334                 qdisc = NULL;
 335                 return 0;
 336         }
 337
 338         r = safe_atou16_full(rvalue, 16, &n);
 339         if (r < 0) {
 340                 log_syntax(unit, LOG_ERR, filename, line, r,
 341                            "Failed to parse 'Handle=', ignoring assignment: %s",
 342                            rvalue);
 343                 return 0;
 344         }
 345
 346         qdisc->handle = (uint32_t) n << 16;
 347         qdisc = NULL;
 348
 349         return 0;
 350 }