Debian Codegraph @

src/network/tc/qdisc.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later
2 * Copyright © 2019 VMware, Inc. */
3
4 #include <linux/pkt_sched.h>
5 #include "sd-netlink.h"
6
7 #include "alloc-util.h"
8 #include "cake.h"
9 #include "codel.h"
10 #include "conf-parser.h"
11 #include "drr.h"
12 #include "ets.h"
13 #include "fifo.h"
14 #include "fq.h"
15 #include "fq-codel.h"
16 #include "fq-pie.h"
17 #include "gred.h"
18 #include "hhf.h"
19 #include "htb.h"
20 #include "mq.h"
21 #include "multiq.h"
22 #include "netem.h"
23 #include "networkd-link.h"
24 #include "networkd-manager.h"
25 #include "networkd-network.h"
26 #include "networkd-queue.h"
27 #include "ordered-set.h"
28 #include "parse-util.h"
29 #include "pie.h"
30 #include "qdisc.h"
31 #include "qfq.h"
32 #include "set.h"
33 #include "sfb.h"
34 #include "sfq.h"
35 #include "siphash24.h"
36 #include "string-util.h"
37 #include "strv.h"
38 #include "tbf.h"
39 #include "tc-util.h"
40 #include "teql.h"
41
42 const QDiscVTable * const qdisc_vtable[_QDISC_KIND_MAX] = {
43 [QDISC_KIND_BFIFO] = &bfifo_vtable,
44 [QDISC_KIND_CAKE] = &cake_vtable,
45 [QDISC_KIND_CODEL] = &codel_vtable,
46 [QDISC_KIND_DRR] = &drr_vtable,
47 [QDISC_KIND_ETS] = &ets_vtable,
48 [QDISC_KIND_FQ] = &fq_vtable,
49 [QDISC_KIND_FQ_CODEL] = &fq_codel_vtable,
50 [QDISC_KIND_FQ_PIE] = &fq_pie_vtable,
51 [QDISC_KIND_GRED] = &gred_vtable,
52 [QDISC_KIND_HHF] = &hhf_vtable,
53 [QDISC_KIND_HTB] = &htb_vtable,
54 [QDISC_KIND_MQ] = &mq_vtable,
55 [QDISC_KIND_MULTIQ] = &multiq_vtable,
56 [QDISC_KIND_NETEM] = &netem_vtable,
57 [QDISC_KIND_PIE] = &pie_vtable,
58 [QDISC_KIND_QFQ] = &qfq_vtable,
59 [QDISC_KIND_PFIFO] = &pfifo_vtable,
60 [QDISC_KIND_PFIFO_FAST] = &pfifo_fast_vtable,
61 [QDISC_KIND_PFIFO_HEAD_DROP] = &pfifo_head_drop_vtable,
62 [QDISC_KIND_SFB] = &sfb_vtable,
63 [QDISC_KIND_SFQ] = &sfq_vtable,
64 [QDISC_KIND_TBF] = &tbf_vtable,
65 [QDISC_KIND_TEQL] = &teql_vtable,
66 };
67
68 static QDisc* qdisc_detach_impl(QDisc *qdisc) {
69 assert(qdisc);
70 assert(!qdisc->link || !qdisc->network);
71
72 if (qdisc->network) {
73 assert(qdisc->section);
74 hashmap_remove(qdisc->network->qdiscs_by_section, qdisc->section);
75
76 qdisc->network = NULL;
77 return qdisc;
78 }
79
80 if (qdisc->link) {
81 set_remove(qdisc->link->qdiscs, qdisc);
82
83 qdisc->link = NULL;
84 return qdisc;
85 }
86
87 return NULL;
88 }
89
90 static void qdisc_detach(QDisc *qdisc) {
91 assert(qdisc);
92
93 qdisc_unref(qdisc_detach_impl(qdisc));
94 }
95
96 static void qdisc_hash_func(const QDisc *qdisc, struct siphash *state);
97 static int qdisc_compare_func(const QDisc *a, const QDisc *b);
98
99 DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
100 qdisc_hash_ops,
101 QDisc,
102 qdisc_hash_func,
103 qdisc_compare_func,
104 qdisc_detach);
105
106 DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
107 qdisc_section_hash_ops,
108 ConfigSection,
109 config_section_hash_func,
110 config_section_compare_func,
111 QDisc,
112 qdisc_detach);
113
114 static int qdisc_new(QDiscKind kind, QDisc **ret) {
115 _cleanup_(qdisc_unrefp) QDisc *qdisc = NULL;
116 int r;
117
118 assert(ret);
119
120 if (kind == _QDISC_KIND_INVALID) {
121 qdisc = new(QDisc, 1);
122 if (!qdisc)
123 return -ENOMEM;
124
125 *qdisc = (QDisc) {
126 .n_ref = 1,
127 .parent = TC_H_ROOT,
128 .kind = kind,
129 };
130 } else {
131 assert(kind >= 0 && kind < _QDISC_KIND_MAX);
132 qdisc = malloc0(qdisc_vtable[kind]->object_size);
133 if (!qdisc)
134 return -ENOMEM;
135
136 qdisc->n_ref = 1;
137 qdisc->parent = TC_H_ROOT;
138 qdisc->kind = kind;
139
140 if (QDISC_VTABLE(qdisc)->init) {
141 r = QDISC_VTABLE(qdisc)->init(qdisc);
142 if (r < 0)
143 return r;
144 }
145 }
146
147 *ret = TAKE_PTR(qdisc);
148
149 return 0;
150 }
151
152 int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret) {
153 _cleanup_(config_section_freep) ConfigSection *n = NULL;
154 _cleanup_(qdisc_unrefp) QDisc *qdisc = NULL;
155 QDisc *existing;
156 int r;
157
158 assert(network);
159 assert(ret);
160 assert(filename);
161 assert(section_line > 0);
162
163 r = config_section_new(filename, section_line, &n);
164 if (r < 0)
165 return r;
166
167 existing = hashmap_get(network->qdiscs_by_section, n);
168 if (existing) {
169 if (existing->kind != _QDISC_KIND_INVALID &&
170 kind != _QDISC_KIND_INVALID &&
171 existing->kind != kind)
172 return -EINVAL;
173
174 if (existing->kind == kind || kind == _QDISC_KIND_INVALID) {
175 *ret = existing;
176 return 0;
177 }
178 }
179
180 r = qdisc_new(kind, &qdisc);
181 if (r < 0)
182 return r;
183
184 if (existing) {
185 qdisc->handle = existing->handle;
186 qdisc->parent = existing->parent;
187 qdisc->tca_kind = TAKE_PTR(existing->tca_kind);
188
189 qdisc_detach(existing);
190 }
191
192 qdisc->network = network;
193 qdisc->section = TAKE_PTR(n);
194 qdisc->source = NETWORK_CONFIG_SOURCE_STATIC;
195
196 r = hashmap_ensure_put(&network->qdiscs_by_section, &qdisc_section_hash_ops, qdisc->section, qdisc);
197 if (r < 0)
198 return r;
199
200 *ret = TAKE_PTR(qdisc);
201 return 0;
202 }
203
204 static QDisc* qdisc_free(QDisc *qdisc) {
205 if (!qdisc)
206 return NULL;
207
208 qdisc_detach_impl(qdisc);
209
210 config_section_free(qdisc->section);
211
212 free(qdisc->tca_kind);
213 return mfree(qdisc);
214 }
215
216 DEFINE_TRIVIAL_REF_UNREF_FUNC(QDisc, qdisc, qdisc_free);
217
218 static const char *qdisc_get_tca_kind(const QDisc *qdisc) {
219 assert(qdisc);
220
221 return (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->tca_kind) ?
222 QDISC_VTABLE(qdisc)->tca_kind : qdisc->tca_kind;
223 }
224
225 static void qdisc_hash_func(const QDisc *qdisc, struct siphash *state) {
226 assert(qdisc);
227 assert(state);
228
229 siphash24_compress_typesafe(qdisc->handle, state);
230 siphash24_compress_typesafe(qdisc->parent, state);
231 siphash24_compress_string(qdisc_get_tca_kind(qdisc), state);
232 }
233
234 static int qdisc_compare_func(const QDisc *a, const QDisc *b) {
235 int r;
236
237 assert(a);
238 assert(b);
239
240 r = CMP(a->handle, b->handle);
241 if (r != 0)
242 return r;
243
244 r = CMP(a->parent, b->parent);
245 if (r != 0)
246 return r;
247
248 return strcmp_ptr(qdisc_get_tca_kind(a), qdisc_get_tca_kind(b));
249 }
250
251 static int qdisc_get(Link *link, const QDisc *in, QDisc **ret) {
252 QDisc *existing;
253
254 assert(link);
255 assert(in);
256
257 existing = set_get(link->qdiscs, in);
258 if (!existing)
259 return -ENOENT;
260
261 if (ret)
262 *ret = existing;
263 return 0;
264 }
265
266 static int qdisc_get_request(Link *link, const QDisc *qdisc, Request **ret) {
267 Request *req;
268
269 assert(link);
270 assert(link->manager);
271 assert(qdisc);
272
273 req = ordered_set_get(
274 link->manager->request_queue,
275 &(Request) {
276 .link = link,
277 .type = REQUEST_TYPE_TC_QDISC,
278 .userdata = (void*) qdisc,
279 .hash_func = (hash_func_t) qdisc_hash_func,
280 .compare_func = (compare_func_t) qdisc_compare_func,
281 });
282 if (!req)
283 return -ENOENT;
284
285 if (ret)
286 *ret = req;
287 return 0;
288 }
289
290 static int qdisc_attach(Link *link, QDisc *qdisc) {
291 int r;
292
293 assert(link);
294 assert(qdisc);
295 assert(!qdisc->link);
296 assert(!qdisc->network);
297
298 r = set_ensure_put(&link->qdiscs, &qdisc_hash_ops, qdisc);
299 if (r < 0)
300 return r;
301 if (r == 0)
302 return -EEXIST;
303
304 qdisc->link = link;
305 qdisc_ref(qdisc);
306 return 0;
307 }
308
309 static int qdisc_dup(const QDisc *src, QDisc **ret) {
310 _cleanup_(qdisc_unrefp) QDisc *dst = NULL;
311
312 assert(src);
313 assert(ret);
314
315 if (QDISC_VTABLE(src))
316 dst = memdup(src, QDISC_VTABLE(src)->object_size);
317 else
318 dst = newdup(QDisc, src, 1);
319 if (!dst)
320 return -ENOMEM;
321
322 /* clear the reference counter and all pointers */
323 dst->n_ref = 1;
324 dst->network = NULL;
325 dst->section = NULL;
326 dst->link = NULL;
327 dst->tca_kind = NULL;
328
329 if (src->tca_kind) {
330 dst->tca_kind = strdup(src->tca_kind);
331 if (!dst->tca_kind)
332 return -ENOMEM;
333 }
334
335 *ret = TAKE_PTR(dst);
336 return 0;
337 }
338
339 static void log_qdisc_debug(QDisc *qdisc, Link *link, const char *str) {
340 _cleanup_free_ char *state = NULL;
341
342 assert(qdisc);
343 assert(str);
344
345 if (!DEBUG_LOGGING)
346 return;
347
348 (void) network_config_state_to_string_alloc(qdisc->state, &state);
349
350 log_link_debug(link, "%s %s QDisc (%s): handle=%"PRIx32":%"PRIx32", parent=%"PRIx32":%"PRIx32", kind=%s",
351 str, strna(network_config_source_to_string(qdisc->source)), strna(state),
352 TC_H_MAJ(qdisc->handle) >> 16, TC_H_MIN(qdisc->handle),
353 TC_H_MAJ(qdisc->parent) >> 16, TC_H_MIN(qdisc->parent),
354 strna(qdisc_get_tca_kind(qdisc)));
355 }
356
357 int link_find_qdisc(Link *link, uint32_t handle, const char *kind, QDisc **ret) {
358 QDisc *qdisc;
359
360 assert(link);
361
362 SET_FOREACH(qdisc, link->qdiscs) {
363 if (qdisc->handle != handle)
364 continue;
365
366 if (!qdisc_exists(qdisc))
367 continue;
368
369 if (kind && !streq_ptr(kind, qdisc_get_tca_kind(qdisc)))
370 continue;
371
372 if (ret)
373 *ret = qdisc;
374 return 0;
375 }
376
377 return -ENOENT;
378 }
379
380 void qdisc_mark_recursive(QDisc *qdisc) {
381 TClass *tclass;
382
383 assert(qdisc);
384 assert(qdisc->link);
385
386 if (qdisc_is_marked(qdisc))
387 return;
388
389 qdisc_mark(qdisc);
390
391 /* also mark all child classes assigned to the qdisc. */
392 SET_FOREACH(tclass, qdisc->link->tclasses) {
393 if (TC_H_MAJ(tclass->classid) != qdisc->handle)
394 continue;
395
396 tclass_mark_recursive(tclass);
397 }
398 }
399
400 void link_qdisc_drop_marked(Link *link) {
401 QDisc *qdisc;
402
403 assert(link);
404
405 SET_FOREACH(qdisc, link->qdiscs) {
406 Request *req;
407
408 if (!qdisc_is_marked(qdisc))
409 continue;
410
411 qdisc_unmark(qdisc);
412 qdisc_enter_removed(qdisc);
413 if (qdisc_get_request(link, qdisc, &req) >= 0)
414 qdisc_enter_removed(req->userdata);
415
416 if (qdisc->state == 0) {
417 log_qdisc_debug(qdisc, link, "Forgetting");
418 qdisc_detach(qdisc);
419 } else
420 log_qdisc_debug(qdisc, link, "Removed");
421 }
422 }
423
424 static void qdisc_drop(QDisc *qdisc) {
425 assert(qdisc);
426 assert(qdisc->link);
427
428 qdisc_mark_recursive(qdisc);
429
430 /* link_qdisc_drop_marked() may invalidate qdisc, so run link_tclass_drop_marked() first. */
431 link_tclass_drop_marked(qdisc->link);
432 link_qdisc_drop_marked(qdisc->link);
433 }
434
435 static int qdisc_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, QDisc *qdisc) {
436 int r;
437
438 assert(m);
439 assert(link);
440
441 r = sd_netlink_message_get_errno(m);
442 if (r < 0 && r != -EEXIST) {
443 log_link_message_error_errno(link, m, r, "Could not set QDisc");
444 link_enter_failed(link);
445 return 1;
446 }
447
448 if (link->tc_messages == 0) {
449 log_link_debug(link, "Traffic control configured");
450 link->tc_configured = true;
451 link_check_ready(link);
452 }
453
454 return 1;
455 }
456
457 static int qdisc_configure(QDisc *qdisc, Link *link, Request *req) {
458 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
459 int r;
460
461 assert(qdisc);
462 assert(link);
463 assert(link->manager);
464 assert(link->manager->rtnl);
465 assert(link->ifindex > 0);
466 assert(req);
467
468 log_qdisc_debug(qdisc, link, "Configuring");
469
470 r = sd_rtnl_message_new_traffic_control(link->manager->rtnl, &m, RTM_NEWQDISC,
471 link->ifindex, qdisc->handle, qdisc->parent);
472 if (r < 0)
473 return r;
474
475 r = sd_netlink_message_append_string(m, TCA_KIND, qdisc_get_tca_kind(qdisc));
476 if (r < 0)
477 return r;
478
479 if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->fill_message) {
480 r = QDISC_VTABLE(qdisc)->fill_message(link, qdisc, m);
481 if (r < 0)
482 return r;
483 }
484
485 return request_call_netlink_async(link->manager->rtnl, m, req);
486 }
487
488 static bool qdisc_is_ready_to_configure(QDisc *qdisc, Link *link) {
489 assert(qdisc);
490 assert(link);
491
492 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
493 return false;
494
495 /* TC_H_CLSACT == TC_H_INGRESS */
496 if (!IN_SET(qdisc->parent, TC_H_ROOT, TC_H_CLSACT)) {
497 if (TC_H_MIN(qdisc->parent) == 0) {
498 if (link_find_qdisc(link, qdisc->parent, NULL, NULL) < 0)
499 return false;
500 } else {
501 if (link_find_tclass(link, qdisc->parent, NULL) < 0)
502 return false;
503 }
504 }
505
506 if (QDISC_VTABLE(qdisc) &&
507 QDISC_VTABLE(qdisc)->is_ready &&
508 QDISC_VTABLE(qdisc)->is_ready(qdisc, link) <= 0)
509 return false;
510
511 return true;
512 }
513
514 static int qdisc_process_request(Request *req, Link *link, QDisc *qdisc) {
515 QDisc *existing;
516 int r;
517
518 assert(req);
519 assert(link);
520 assert(qdisc);
521
522 if (!qdisc_is_ready_to_configure(qdisc, link))
523 return 0;
524
525 r = qdisc_configure(qdisc, link, req);
526 if (r < 0)
527 return log_link_warning_errno(link, r, "Failed to configure QDisc: %m");
528
529 qdisc_enter_configuring(qdisc);
530 if (qdisc_get(link, qdisc, &existing) >= 0)
531 qdisc_enter_configuring(existing);
532
533 return 1;
534 }
535
536 int link_request_qdisc(Link *link, const QDisc *qdisc) {
537 _cleanup_(qdisc_unrefp) QDisc *tmp = NULL;
538 QDisc *existing = NULL;
539 int r;
540
541 assert(link);
542 assert(qdisc);
543 assert(qdisc->source != NETWORK_CONFIG_SOURCE_FOREIGN);
544
545 if (qdisc_get_request(link, qdisc, NULL) >= 0)
546 return 0; /* already requested, skipping. */
547
548 r = qdisc_dup(qdisc, &tmp);
549 if (r < 0)
550 return r;
551
552 if (qdisc_get(link, qdisc, &existing) >= 0)
553 /* Copy state for logging below. */
554 tmp->state = existing->state;
555
556 log_qdisc_debug(tmp, link, "Requesting");
557 r = link_queue_request_safe(link, REQUEST_TYPE_TC_QDISC,
558 tmp,
559 qdisc_unref,
560 qdisc_hash_func,
561 qdisc_compare_func,
562 qdisc_process_request,
563 &link->tc_messages,
564 qdisc_handler,
565 NULL);
566 if (r <= 0)
567 return r;
568
569 qdisc_enter_requesting(tmp);
570 if (existing)
571 qdisc_enter_requesting(existing);
572
573 TAKE_PTR(tmp);
574 return 1;
575 }
576
577 int manager_rtnl_process_qdisc(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
578 _cleanup_(qdisc_unrefp) QDisc *tmp = NULL;
579 Request *req = NULL;
580 QDisc *qdisc = NULL;
581 Link *link;
582 uint16_t type;
583 int ifindex, r;
584
585 assert(rtnl);
586 assert(message);
587 assert(m);
588
589 if (sd_netlink_message_is_error(message)) {
590 r = sd_netlink_message_get_errno(message);
591 if (r < 0)
592 log_message_warning_errno(message, r, "rtnl: failed to receive QDisc message, ignoring");
593
594 return 0;
595 }
596
597 r = sd_netlink_message_get_type(message, &type);
598 if (r < 0) {
599 log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
600 return 0;
601 } else if (!IN_SET(type, RTM_NEWQDISC, RTM_DELQDISC)) {
602 log_warning("rtnl: received unexpected message type %u when processing QDisc, ignoring.", type);
603 return 0;
604 }
605
606 r = sd_rtnl_message_traffic_control_get_ifindex(message, &ifindex);
607 if (r < 0) {
608 log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
609 return 0;
610 } else if (ifindex <= 0) {
611 log_warning("rtnl: received QDisc message with invalid ifindex %d, ignoring.", ifindex);
612 return 0;
613 }
614
615 if (link_get_by_index(m, ifindex, &link) < 0) {
616 if (!m->enumerating)
617 log_warning("rtnl: received QDisc for link '%d' we don't know about, ignoring.", ifindex);
618 return 0;
619 }
620
621 r = qdisc_new(_QDISC_KIND_INVALID, &tmp);
622 if (r < 0)
623 return log_oom();
624
625 r = sd_rtnl_message_traffic_control_get_handle(message, &tmp->handle);
626 if (r < 0) {
627 log_link_warning_errno(link, r, "rtnl: received QDisc message without handle, ignoring: %m");
628 return 0;
629 }
630
631 r = sd_rtnl_message_traffic_control_get_parent(message, &tmp->parent);
632 if (r < 0) {
633 log_link_warning_errno(link, r, "rtnl: received QDisc message without parent, ignoring: %m");
634 return 0;
635 }
636
637 r = sd_netlink_message_read_string_strdup(message, TCA_KIND, &tmp->tca_kind);
638 if (r < 0) {
639 log_link_warning_errno(link, r, "rtnl: received QDisc message without kind, ignoring: %m");
640 return 0;
641 }
642
643 (void) qdisc_get(link, tmp, &qdisc);
644 (void) qdisc_get_request(link, tmp, &req);
645
646 if (type == RTM_DELQDISC) {
647 if (qdisc)
648 qdisc_drop(qdisc);
649 else
650 log_qdisc_debug(tmp, link, "Kernel removed unknown");
651
652 return 0;
653 }
654
655 bool is_new = false;
656 if (!qdisc) {
657 /* If we did not know the qdisc, then save it. */
658 r = qdisc_attach(link, tmp);
659 if (r < 0) {
660 log_link_warning_errno(link, r, "Failed to remember QDisc, ignoring: %m");
661 return 0;
662 }
663
664 qdisc = tmp;
665 is_new = true;
666 }
667
668 /* Also update information that cannot be obtained through netlink notification. */
669 if (req && req->waiting_reply) {
670 QDisc *q = ASSERT_PTR(req->userdata);
671
672 qdisc->source = q->source;
673 }
674
675 qdisc_enter_configured(qdisc);
676 if (req)
677 qdisc_enter_configured(req->userdata);
678
679 log_qdisc_debug(qdisc, link, is_new ? "Remembering" : "Received remembered");
680
681 if (!m->enumerating) {
682 /* Some kind of QDisc (e.g. tbf) also create an implicit class under the qdisc, but
683 * the kernel may not notify about the class. Hence, we need to enumerate classes. */
684 r = link_enumerate_tclass(link, qdisc->handle);
685 if (r < 0)
686 log_link_warning_errno(link, r, "Failed to enumerate TClass, ignoring: %m");
687 }
688
689 return 1;
690 }
691
692 static int qdisc_section_verify(QDisc *qdisc, bool *has_root, bool *has_clsact) {
693 int r;
694
695 assert(qdisc);
696 assert(has_root);
697 assert(has_clsact);
698
699 if (section_is_invalid(qdisc->section))
700 return -EINVAL;
701
702 if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->verify) {
703 r = QDISC_VTABLE(qdisc)->verify(qdisc);
704 if (r < 0)
705 return r;
706 }
707
708 if (qdisc->parent == TC_H_ROOT) {
709 if (*has_root)
710 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
711 "%s: More than one root qdisc section is defined. "
712 "Ignoring the qdisc section from line %u.",
713 qdisc->section->filename, qdisc->section->line);
714 *has_root = true;
715 } else if (qdisc->parent == TC_H_CLSACT) { /* TC_H_CLSACT == TC_H_INGRESS */
716 if (*has_clsact)
717 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
718 "%s: More than one clsact or ingress qdisc section is defined. "
719 "Ignoring the qdisc section from line %u.",
720 qdisc->section->filename, qdisc->section->line);
721 *has_clsact = true;
722 }
723
724 return 0;
725 }
726
727 void network_drop_invalid_qdisc(Network *network) {
728 bool has_root = false, has_clsact = false;
729 QDisc *qdisc;
730
731 assert(network);
732
733 HASHMAP_FOREACH(qdisc, network->qdiscs_by_section)
734 if (qdisc_section_verify(qdisc, &has_root, &has_clsact) < 0)
735 qdisc_detach(qdisc);
736 }
737
738 int config_parse_qdisc_parent(
739 const char *unit,
740 const char *filename,
741 unsigned line,
742 const char *section,
743 unsigned section_line,
744 const char *lvalue,
745 int ltype,
746 const char *rvalue,
747 void *data,
748 void *userdata) {
749
750 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
751 Network *network = ASSERT_PTR(data);
752 int r;
753
754 assert(filename);
755 assert(lvalue);
756 assert(rvalue);
757
758 r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
759 if (r == -ENOMEM)
760 return log_oom();
761 if (r < 0) {
762 log_syntax(unit, LOG_WARNING, filename, line, r,
763 "More than one kind of queueing discipline, ignoring assignment: %m");
764 return 0;
765 }
766
767 if (streq(rvalue, "root"))
768 qdisc->parent = TC_H_ROOT;
769 else if (streq(rvalue, "clsact")) {
770 qdisc->parent = TC_H_CLSACT;
771 qdisc->handle = TC_H_MAKE(TC_H_CLSACT, 0);
772 } else if (streq(rvalue, "ingress")) {
773 qdisc->parent = TC_H_INGRESS;
774 qdisc->handle = TC_H_MAKE(TC_H_INGRESS, 0);
775 } else {
776 r = parse_handle(rvalue, &qdisc->parent);
777 if (r < 0) {
778 log_syntax(unit, LOG_WARNING, filename, line, r,
779 "Failed to parse 'Parent=', ignoring assignment: %s",
780 rvalue);
781 return 0;
782 }
783 }
784
785 if (STR_IN_SET(rvalue, "clsact", "ingress")) {
786 r = free_and_strdup(&qdisc->tca_kind, rvalue);
787 if (r < 0)
788 return log_oom();
789 } else
790 qdisc->tca_kind = mfree(qdisc->tca_kind);
791
792 TAKE_PTR(qdisc);
793
794 return 0;
795 }
796
797 int config_parse_qdisc_handle(
798 const char *unit,
799 const char *filename,
800 unsigned line,
801 const char *section,
802 unsigned section_line,
803 const char *lvalue,
804 int ltype,
805 const char *rvalue,
806 void *data,
807 void *userdata) {
808
809 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
810 Network *network = ASSERT_PTR(data);
811 uint16_t n;
812 int r;
813
814 assert(filename);
815 assert(lvalue);
816 assert(rvalue);
817
818 r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
819 if (r == -ENOMEM)
820 return log_oom();
821 if (r < 0) {
822 log_syntax(unit, LOG_WARNING, filename, line, r,
823 "More than one kind of queueing discipline, ignoring assignment: %m");
824 return 0;
825 }
826
827 if (isempty(rvalue)) {
828 qdisc->handle = TC_H_UNSPEC;
829 TAKE_PTR(qdisc);
830 return 0;
831 }
832
833 r = safe_atou16_full(rvalue, 16, &n);
834 if (r < 0) {
835 log_syntax(unit, LOG_WARNING, filename, line, r,
836 "Failed to parse 'Handle=', ignoring assignment: %s",
837 rvalue);
838 return 0;
839 }
840
841 qdisc->handle = (uint32_t) n << 16;
842 TAKE_PTR(qdisc);
843
844 return 0;
845 }