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-link.h"
  11 #include "networkd-manager.h"
  12 #include "networkd-network.h"
  13 #include "networkd-queue.h"
  14 #include "parse-util.h"
  15 #include "qdisc.h"
  16 #include "set.h"
  17 #include "string-util.h"
  18 #include "strv.h"
  19 #include "tc-util.h"
  20
  21 const QDiscVTable * const qdisc_vtable[_QDISC_KIND_MAX] = {
  22         [QDISC_KIND_BFIFO] = &bfifo_vtable,
  23         [QDISC_KIND_CAKE] = &cake_vtable,
  24         [QDISC_KIND_CODEL] = &codel_vtable,
  25         [QDISC_KIND_DRR] = &drr_vtable,
  26         [QDISC_KIND_ETS] = &ets_vtable,
  27         [QDISC_KIND_FQ] = &fq_vtable,
  28         [QDISC_KIND_FQ_CODEL] = &fq_codel_vtable,
  29         [QDISC_KIND_FQ_PIE] = &fq_pie_vtable,
  30         [QDISC_KIND_GRED] = &gred_vtable,
  31         [QDISC_KIND_HHF] = &hhf_vtable,
  32         [QDISC_KIND_HTB] = &htb_vtable,
  33         [QDISC_KIND_NETEM] = &netem_vtable,
  34         [QDISC_KIND_PIE] = &pie_vtable,
  35         [QDISC_KIND_QFQ] = &qfq_vtable,
  36         [QDISC_KIND_PFIFO] = &pfifo_vtable,
  37         [QDISC_KIND_PFIFO_FAST] = &pfifo_fast_vtable,
  38         [QDISC_KIND_PFIFO_HEAD_DROP] = &pfifo_head_drop_vtable,
  39         [QDISC_KIND_SFB] = &sfb_vtable,
  40         [QDISC_KIND_SFQ] = &sfq_vtable,
  41         [QDISC_KIND_TBF] = &tbf_vtable,
  42         [QDISC_KIND_TEQL] = &teql_vtable,
  43 };
  44
  45 static int qdisc_new(QDiscKind kind, QDisc **ret) {
  46         _cleanup_(qdisc_freep) QDisc *qdisc = NULL;
  47         int r;
  48
  49         if (kind == _QDISC_KIND_INVALID) {
  50                 qdisc = new(QDisc, 1);
  51                 if (!qdisc)
  52                         return -ENOMEM;
  53
  54                 *qdisc = (QDisc) {
  55                         .parent = TC_H_ROOT,
  56                         .kind = kind,
  57                 };
  58         } else {
  59                 assert(kind >= 0 && kind < _QDISC_KIND_MAX);
  60                 qdisc = malloc0(qdisc_vtable[kind]->object_size);
  61                 if (!qdisc)
  62                         return -ENOMEM;
  63
  64                 qdisc->parent = TC_H_ROOT;
  65                 qdisc->kind = kind;
  66
  67                 if (QDISC_VTABLE(qdisc)->init) {
  68                         r = QDISC_VTABLE(qdisc)->init(qdisc);
  69                         if (r < 0)
  70                                 return r;
  71                 }
  72         }
  73
  74         *ret = TAKE_PTR(qdisc);
  75
  76         return 0;
  77 }
  78
  79 int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret) {
  80         _cleanup_(config_section_freep) ConfigSection *n = NULL;
  81         _cleanup_(qdisc_freep) QDisc *qdisc = NULL;
  82         QDisc *existing;
  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 = hashmap_get(network->qdiscs_by_section, n);
  95         if (existing) {
  96                 if (existing->kind != _QDISC_KIND_INVALID &&
  97                     kind != _QDISC_KIND_INVALID &&
  98                     existing->kind != kind)
  99                         return -EINVAL;
 100
 101                 if (existing->kind == kind || kind == _QDISC_KIND_INVALID) {
 102                         *ret = existing;
 103                         return 0;
 104                 }
 105         }
 106
 107         r = qdisc_new(kind, &qdisc);
 108         if (r < 0)
 109                 return r;
 110
 111         if (existing) {
 112                 qdisc->handle = existing->handle;
 113                 qdisc->parent = existing->parent;
 114                 qdisc->tca_kind = TAKE_PTR(existing->tca_kind);
 115
 116                 qdisc_free(existing);
 117         }
 118
 119         qdisc->network = network;
 120         qdisc->section = TAKE_PTR(n);
 121         qdisc->source = NETWORK_CONFIG_SOURCE_STATIC;
 122
 123         r = hashmap_ensure_put(&network->qdiscs_by_section, &config_section_hash_ops, qdisc->section, qdisc);
 124         if (r < 0)
 125                 return r;
 126
 127         *ret = TAKE_PTR(qdisc);
 128         return 0;
 129 }
 130
 131 QDisc* qdisc_free(QDisc *qdisc) {
 132         if (!qdisc)
 133                 return NULL;
 134
 135         if (qdisc->network && qdisc->section)
 136                 hashmap_remove(qdisc->network->qdiscs_by_section, qdisc->section);
 137
 138         config_section_free(qdisc->section);
 139
 140         if (qdisc->link)
 141                 set_remove(qdisc->link->qdiscs, qdisc);
 142
 143         free(qdisc->tca_kind);
 144         return mfree(qdisc);
 145 }
 146
 147 static const char *qdisc_get_tca_kind(const QDisc *qdisc) {
 148         assert(qdisc);
 149
 150         return (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->tca_kind) ?
 151                 QDISC_VTABLE(qdisc)->tca_kind : qdisc->tca_kind;
 152 }
 153
 154 void qdisc_hash_func(const QDisc *qdisc, struct siphash *state) {
 155         assert(qdisc);
 156         assert(state);
 157
 158         siphash24_compress(&qdisc->handle, sizeof(qdisc->handle), state);
 159         siphash24_compress(&qdisc->parent, sizeof(qdisc->parent), state);
 160         siphash24_compress_string(qdisc_get_tca_kind(qdisc), state);
 161 }
 162
 163 int qdisc_compare_func(const QDisc *a, const QDisc *b) {
 164         int r;
 165
 166         assert(a);
 167         assert(b);
 168
 169         r = CMP(a->handle, b->handle);
 170         if (r != 0)
 171                 return r;
 172
 173         r = CMP(a->parent, b->parent);
 174         if (r != 0)
 175                 return r;
 176
 177         return strcmp_ptr(qdisc_get_tca_kind(a), qdisc_get_tca_kind(b));
 178 }
 179
 180 DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
 181         qdisc_hash_ops,
 182         QDisc,
 183         qdisc_hash_func,
 184         qdisc_compare_func,
 185         qdisc_free);
 186
 187 static int qdisc_get(Link *link, const QDisc *in, QDisc **ret) {
 188         QDisc *existing;
 189
 190         assert(link);
 191         assert(in);
 192
 193         existing = set_get(link->qdiscs, in);
 194         if (!existing)
 195                 return -ENOENT;
 196
 197         if (ret)
 198                 *ret = existing;
 199         return 0;
 200 }
 201
 202 static int qdisc_add(Link *link, QDisc *qdisc) {
 203         int r;
 204
 205         assert(link);
 206         assert(qdisc);
 207
 208         r = set_ensure_put(&link->qdiscs, &qdisc_hash_ops, qdisc);
 209         if (r < 0)
 210                 return r;
 211         if (r == 0)
 212                 return -EEXIST;
 213
 214         qdisc->link = link;
 215         return 0;
 216 }
 217
 218 static int qdisc_dup(const QDisc *src, QDisc **ret) {
 219         _cleanup_(qdisc_freep) QDisc *dst = NULL;
 220
 221         assert(src);
 222         assert(ret);
 223
 224         if (QDISC_VTABLE(src))
 225                 dst = memdup(src, QDISC_VTABLE(src)->object_size);
 226         else
 227                 dst = newdup(QDisc, src, 1);
 228         if (!dst)
 229                 return -ENOMEM;
 230
 231         /* clear all pointers */
 232         dst->network = NULL;
 233         dst->section = NULL;
 234         dst->link = NULL;
 235         dst->tca_kind = NULL;
 236
 237         if (src->tca_kind) {
 238                 dst->tca_kind = strdup(src->tca_kind);
 239                 if (!dst->tca_kind)
 240                         return -ENOMEM;
 241         }
 242
 243         *ret = TAKE_PTR(dst);
 244         return 0;
 245 }
 246
 247 static void log_qdisc_debug(QDisc *qdisc, Link *link, const char *str) {
 248         _cleanup_free_ char *state = NULL;
 249
 250         assert(qdisc);
 251         assert(str);
 252
 253         if (!DEBUG_LOGGING)
 254                 return;
 255
 256         (void) network_config_state_to_string_alloc(qdisc->state, &state);
 257
 258         log_link_debug(link, "%s %s QDisc (%s): handle=%"PRIx32":%"PRIx32", parent=%"PRIx32":%"PRIx32", kind=%s",
 259                        str, strna(network_config_source_to_string(qdisc->source)), strna(state),
 260                        TC_H_MAJ(qdisc->handle) >> 16, TC_H_MIN(qdisc->handle),
 261                        TC_H_MAJ(qdisc->parent) >> 16, TC_H_MIN(qdisc->parent),
 262                        strna(qdisc_get_tca_kind(qdisc)));
 263 }
 264
 265 int link_find_qdisc(Link *link, uint32_t handle, uint32_t parent, const char *kind, QDisc **ret) {
 266         QDisc *qdisc;
 267
 268         assert(link);
 269
 270         handle = TC_H_MAJ(handle);
 271
 272         SET_FOREACH(qdisc, link->qdiscs) {
 273                 if (qdisc->handle != handle)
 274                         continue;
 275
 276                 if (qdisc->parent != parent)
 277                         continue;
 278
 279                 if (qdisc->source == NETWORK_CONFIG_SOURCE_FOREIGN)
 280                         continue;
 281
 282                 if (!qdisc_exists(qdisc))
 283                         continue;
 284
 285                 if (kind && !streq_ptr(kind, qdisc_get_tca_kind(qdisc)))
 286                         continue;
 287
 288                 if (ret)
 289                         *ret = qdisc;
 290                 return 0;
 291         }
 292
 293         return -ENOENT;
 294 }
 295
 296 static int qdisc_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 297         int r;
 298
 299         assert(link);
 300         assert(link->tc_messages > 0);
 301         link->tc_messages--;
 302
 303         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 304                 return 1;
 305
 306         r = sd_netlink_message_get_errno(m);
 307         if (r < 0 && r != -EEXIST) {
 308                 log_link_message_error_errno(link, m, r, "Could not set QDisc");
 309                 link_enter_failed(link);
 310                 return 1;
 311         }
 312
 313         if (link->tc_messages == 0) {
 314                 log_link_debug(link, "Traffic control configured");
 315                 link->tc_configured = true;
 316                 link_check_ready(link);
 317         }
 318
 319         return 1;
 320 }
 321
 322 static int qdisc_configure(QDisc *qdisc, Link *link) {
 323         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 324         int r;
 325
 326         assert(qdisc);
 327         assert(link);
 328         assert(link->manager);
 329         assert(link->manager->rtnl);
 330         assert(link->ifindex > 0);
 331
 332         log_qdisc_debug(qdisc, link, "Configuring");
 333
 334         r = sd_rtnl_message_new_traffic_control(link->manager->rtnl, &req, RTM_NEWQDISC,
 335                                                 link->ifindex, qdisc->handle, qdisc->parent);
 336         if (r < 0)
 337                 return log_link_debug_errno(link, r, "Could not create RTM_NEWQDISC message: %m");
 338
 339         r = sd_netlink_message_append_string(req, TCA_KIND, qdisc_get_tca_kind(qdisc));
 340         if (r < 0)
 341                 return r;
 342
 343         if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->fill_message) {
 344                 r = QDISC_VTABLE(qdisc)->fill_message(link, qdisc, req);
 345                 if (r < 0)
 346                         return r;
 347         }
 348
 349         r = netlink_call_async(link->manager->rtnl, NULL, req, qdisc_handler, link_netlink_destroy_callback, link);
 350         if (r < 0)
 351                 return log_link_debug_errno(link, r, "Could not send netlink message: %m");
 352
 353         link_ref(link);
 354         return 0;
 355 }
 356
 357 static bool qdisc_is_ready_to_configure(QDisc *qdisc, Link *link) {
 358         assert(qdisc);
 359         assert(link);
 360
 361         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
 362                 return false;
 363
 364         if (IN_SET(qdisc->parent, TC_H_ROOT, TC_H_CLSACT)) /* TC_H_CLSACT == TC_H_INGRESS */
 365                 return true;
 366
 367         return link_find_tclass(link, qdisc->parent, NULL) >= 0;
 368 }
 369
 370 int request_process_qdisc(Request *req) {
 371         QDisc *qdisc;
 372         Link *link;
 373         int r;
 374
 375         assert(req);
 376         assert_se(link = req->link);
 377         assert_se(qdisc = req->qdisc);
 378
 379         if (!qdisc_is_ready_to_configure(qdisc, link))
 380                 return 0;
 381
 382         r = qdisc_configure(qdisc, link);
 383         if (r < 0)
 384                 return log_link_warning_errno(link, r, "Failed to configure QDisc: %m");
 385
 386         qdisc_enter_configuring(qdisc);
 387         return 1;
 388 }
 389
 390 int link_request_qdisc(Link *link, QDisc *qdisc) {
 391         QDisc *existing;
 392         int r;
 393
 394         assert(link);
 395         assert(qdisc);
 396
 397         if (qdisc_get(link, qdisc, &existing) < 0) {
 398                 _cleanup_(qdisc_freep) QDisc *tmp = NULL;
 399
 400                 r = qdisc_dup(qdisc, &tmp);
 401                 if (r < 0)
 402                         return log_oom();
 403
 404                 r = qdisc_add(link, tmp);
 405                 if (r < 0)
 406                         return log_link_warning_errno(link, r, "Failed to store QDisc: %m");
 407
 408                 existing = TAKE_PTR(tmp);
 409         } else
 410                 existing->source = qdisc->source;
 411
 412         log_qdisc_debug(existing, link, "Requesting");
 413         r = link_queue_request(link, REQUEST_TYPE_TC_QDISC, existing, false,
 414                                &link->tc_messages, NULL, NULL);
 415         if (r < 0)
 416                 return log_link_warning_errno(link, r, "Failed to request QDisc: %m");
 417         if (r == 0)
 418                 return 0;
 419
 420         qdisc_enter_requesting(existing);
 421         return 1;
 422 }
 423
 424 int manager_rtnl_process_qdisc(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
 425         _cleanup_(qdisc_freep) QDisc *tmp = NULL;
 426         QDisc *qdisc = NULL;
 427         Link *link;
 428         uint16_t type;
 429         int ifindex, r;
 430
 431         assert(rtnl);
 432         assert(message);
 433         assert(m);
 434
 435         if (sd_netlink_message_is_error(message)) {
 436                 r = sd_netlink_message_get_errno(message);
 437                 if (r < 0)
 438                         log_message_warning_errno(message, r, "rtnl: failed to receive QDisc message, ignoring");
 439
 440                 return 0;
 441         }
 442
 443         r = sd_netlink_message_get_type(message, &type);
 444         if (r < 0) {
 445                 log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
 446                 return 0;
 447         } else if (!IN_SET(type, RTM_NEWQDISC, RTM_DELQDISC)) {
 448                 log_warning("rtnl: received unexpected message type %u when processing QDisc, ignoring.", type);
 449                 return 0;
 450         }
 451
 452         r = sd_rtnl_message_traffic_control_get_ifindex(message, &ifindex);
 453         if (r < 0) {
 454                 log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
 455                 return 0;
 456         } else if (ifindex <= 0) {
 457                 log_warning("rtnl: received QDisc message with invalid ifindex %d, ignoring.", ifindex);
 458                 return 0;
 459         }
 460
 461         if (link_get_by_index(m, ifindex, &link) < 0) {
 462                 if (!m->enumerating)
 463                         log_warning("rtnl: received QDisc for link '%d' we don't know about, ignoring.", ifindex);
 464                 return 0;
 465         }
 466
 467         r = qdisc_new(_QDISC_KIND_INVALID, &tmp);
 468         if (r < 0)
 469                 return log_oom();
 470
 471         r = sd_rtnl_message_traffic_control_get_handle(message, &tmp->handle);
 472         if (r < 0) {
 473                 log_link_warning_errno(link, r, "rtnl: received QDisc message without handle, ignoring: %m");
 474                 return 0;
 475         }
 476
 477         r = sd_rtnl_message_traffic_control_get_parent(message, &tmp->parent);
 478         if (r < 0) {
 479                 log_link_warning_errno(link, r, "rtnl: received QDisc message without parent, ignoring: %m");
 480                 return 0;
 481         }
 482
 483         r = sd_netlink_message_read_string_strdup(message, TCA_KIND, &tmp->tca_kind);
 484         if (r < 0) {
 485                 log_link_warning_errno(link, r, "rtnl: received QDisc message without kind, ignoring: %m");
 486                 return 0;
 487         }
 488
 489         (void) qdisc_get(link, tmp, &qdisc);
 490
 491         switch (type) {
 492         case RTM_NEWQDISC:
 493                 if (qdisc) {
 494                         qdisc_enter_configured(qdisc);
 495                         log_qdisc_debug(qdisc, link, "Received remembered");
 496                 } else {
 497                         qdisc_enter_configured(tmp);
 498                         log_qdisc_debug(tmp, link, "Received new");
 499
 500                         r = qdisc_add(link, tmp);
 501                         if (r < 0) {
 502                                 log_link_warning_errno(link, r, "Failed to remember QDisc, ignoring: %m");
 503                                 return 0;
 504                         }
 505
 506                         qdisc = TAKE_PTR(tmp);
 507                 }
 508
 509                 break;
 510
 511         case RTM_DELQDISC:
 512                 if (qdisc) {
 513                         qdisc_enter_removed(qdisc);
 514                         if (qdisc->state == 0) {
 515                                 log_qdisc_debug(qdisc, link, "Forgetting");
 516                                 qdisc_free(qdisc);
 517                         } else
 518                                 log_qdisc_debug(qdisc, link, "Removed");
 519                 } else
 520                         log_qdisc_debug(tmp, link, "Kernel removed unknown");
 521
 522                 break;
 523
 524         default:
 525                 assert_not_reached();
 526         }
 527
 528         return 1;
 529 }
 530
 531 static int qdisc_section_verify(QDisc *qdisc, bool *has_root, bool *has_clsact) {
 532         int r;
 533
 534         assert(qdisc);
 535         assert(has_root);
 536         assert(has_clsact);
 537
 538         if (section_is_invalid(qdisc->section))
 539                 return -EINVAL;
 540
 541         if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->verify) {
 542                 r = QDISC_VTABLE(qdisc)->verify(qdisc);
 543                 if (r < 0)
 544                         return r;
 545         }
 546
 547         if (qdisc->parent == TC_H_ROOT) {
 548                 if (*has_root)
 549                         return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 550                                                  "%s: More than one root qdisc section is defined. "
 551                                                  "Ignoring the qdisc section from line %u.",
 552                                                  qdisc->section->filename, qdisc->section->line);
 553                 *has_root = true;
 554         } else if (qdisc->parent == TC_H_CLSACT) { /* TC_H_CLSACT == TC_H_INGRESS */
 555                 if (*has_clsact)
 556                         return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 557                                                  "%s: More than one clsact or ingress qdisc section is defined. "
 558                                                  "Ignoring the qdisc section from line %u.",
 559                                                  qdisc->section->filename, qdisc->section->line);
 560                 *has_clsact = true;
 561         }
 562
 563         return 0;
 564 }
 565
 566 void network_drop_invalid_qdisc(Network *network) {
 567         bool has_root = false, has_clsact = false;
 568         QDisc *qdisc;
 569
 570         assert(network);
 571
 572         HASHMAP_FOREACH(qdisc, network->qdiscs_by_section)
 573                 if (qdisc_section_verify(qdisc, &has_root, &has_clsact) < 0)
 574                         qdisc_free(qdisc);
 575 }
 576
 577 int config_parse_qdisc_parent(
 578                 const char *unit,
 579                 const char *filename,
 580                 unsigned line,
 581                 const char *section,
 582                 unsigned section_line,
 583                 const char *lvalue,
 584                 int ltype,
 585                 const char *rvalue,
 586                 void *data,
 587                 void *userdata) {
 588
 589         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 590         Network *network = data;
 591         int r;
 592
 593         assert(filename);
 594         assert(lvalue);
 595         assert(rvalue);
 596         assert(data);
 597
 598         r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
 599         if (r == -ENOMEM)
 600                 return log_oom();
 601         if (r < 0) {
 602                 log_syntax(unit, LOG_WARNING, filename, line, r,
 603                            "More than one kind of queueing discipline, ignoring assignment: %m");
 604                 return 0;
 605         }
 606
 607         if (streq(rvalue, "root"))
 608                 qdisc->parent = TC_H_ROOT;
 609         else if (streq(rvalue, "clsact")) {
 610                 qdisc->parent = TC_H_CLSACT;
 611                 qdisc->handle = TC_H_MAKE(TC_H_CLSACT, 0);
 612         } else if (streq(rvalue, "ingress")) {
 613                 qdisc->parent = TC_H_INGRESS;
 614                 qdisc->handle = TC_H_MAKE(TC_H_INGRESS, 0);
 615         } else {
 616                 r = parse_handle(rvalue, &qdisc->parent);
 617                 if (r < 0) {
 618                         log_syntax(unit, LOG_WARNING, filename, line, r,
 619                                    "Failed to parse 'Parent=', ignoring assignment: %s",
 620                                    rvalue);
 621                         return 0;
 622                 }
 623         }
 624
 625         if (STR_IN_SET(rvalue, "clsact", "ingress")) {
 626                 r = free_and_strdup(&qdisc->tca_kind, rvalue);
 627                 if (r < 0)
 628                         return log_oom();
 629         } else
 630                 qdisc->tca_kind = mfree(qdisc->tca_kind);
 631
 632         TAKE_PTR(qdisc);
 633
 634         return 0;
 635 }
 636
 637 int config_parse_qdisc_handle(
 638                 const char *unit,
 639                 const char *filename,
 640                 unsigned line,
 641                 const char *section,
 642                 unsigned section_line,
 643                 const char *lvalue,
 644                 int ltype,
 645                 const char *rvalue,
 646                 void *data,
 647                 void *userdata) {
 648
 649         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 650         Network *network = data;
 651         uint16_t n;
 652         int r;
 653
 654         assert(filename);
 655         assert(lvalue);
 656         assert(rvalue);
 657         assert(data);
 658
 659         r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
 660         if (r == -ENOMEM)
 661                 return log_oom();
 662         if (r < 0) {
 663                 log_syntax(unit, LOG_WARNING, filename, line, r,
 664                            "More than one kind of queueing discipline, ignoring assignment: %m");
 665                 return 0;
 666         }
 667
 668         if (isempty(rvalue)) {
 669                 qdisc->handle = TC_H_UNSPEC;
 670                 TAKE_PTR(qdisc);
 671                 return 0;
 672         }
 673
 674         r = safe_atou16_full(rvalue, 16, &n);
 675         if (r < 0) {
 676                 log_syntax(unit, LOG_WARNING, filename, line, r,
 677                            "Failed to parse 'Handle=', ignoring assignment: %s",
 678                            rvalue);
 679                 return 0;
 680         }
 681
 682         qdisc->handle = (uint32_t) n << 16;
 683         TAKE_PTR(qdisc);
 684
 685         return 0;
 686 }