Debian Codegraph @

src/network/tc/cake.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later
2 * Copyright © 2020 VMware, Inc. */
3
4 #include <linux/pkt_sched.h>
5
6 #include "sd-netlink.h"
7
8 #include "cake.h"
9 #include "log.h"
10 #include "parse-util.h"
11 #include "qdisc.h"
12 #include "string-table.h"
13 #include "string-util.h"
14
15 static int cake_init(QDisc *qdisc) {
16 CommonApplicationsKeptEnhanced *c;
17
18 assert(qdisc);
19
20 c = CAKE(qdisc);
21
22 c->autorate = -1;
23 c->compensation_mode = _CAKE_COMPENSATION_MODE_INVALID;
24 c->raw = -1;
25 c->flow_isolation_mode = _CAKE_FLOW_ISOLATION_MODE_INVALID;
26 c->nat = -1;
27 c->preset = _CAKE_PRESET_INVALID;
28 c->wash = -1;
29 c->split_gso = -1;
30 c->ack_filter = _CAKE_ACK_FILTER_INVALID;
31
32 return 0;
33 }
34
35 static int cake_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
36 CommonApplicationsKeptEnhanced *c;
37 int r;
38
39 assert(link);
40 assert(qdisc);
41 assert(req);
42
43 assert_se(c = CAKE(qdisc));
44
45 r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "cake");
46 if (r < 0)
47 return r;
48
49 if (c->bandwidth > 0) {
50 r = sd_netlink_message_append_u64(req, TCA_CAKE_BASE_RATE64, c->bandwidth);
51 if (r < 0)
52 return r;
53 }
54
55 if (c->autorate >= 0) {
56 r = sd_netlink_message_append_u32(req, TCA_CAKE_AUTORATE, c->autorate);
57 if (r < 0)
58 return r;
59 }
60
61 if (c->overhead_set) {
62 r = sd_netlink_message_append_s32(req, TCA_CAKE_OVERHEAD, c->overhead);
63 if (r < 0)
64 return r;
65 }
66
67 if (c->mpu > 0) {
68 r = sd_netlink_message_append_u32(req, TCA_CAKE_MPU, c->mpu);
69 if (r < 0)
70 return r;
71 }
72
73 if (c->compensation_mode >= 0) {
74 r = sd_netlink_message_append_u32(req, TCA_CAKE_ATM, c->compensation_mode);
75 if (r < 0)
76 return r;
77 }
78
79 if (c->raw > 0) {
80 /* TCA_CAKE_RAW attribute is mostly a flag, not boolean. */
81 r = sd_netlink_message_append_u32(req, TCA_CAKE_RAW, 0);
82 if (r < 0)
83 return r;
84 }
85
86 if (c->flow_isolation_mode >= 0) {
87 r = sd_netlink_message_append_u32(req, TCA_CAKE_FLOW_MODE, c->flow_isolation_mode);
88 if (r < 0)
89 return r;
90 }
91
92 if (c->nat >= 0) {
93 r = sd_netlink_message_append_u32(req, TCA_CAKE_NAT, c->nat);
94 if (r < 0)
95 return r;
96 }
97
98 if (c->preset >= 0) {
99 r = sd_netlink_message_append_u32(req, TCA_CAKE_DIFFSERV_MODE, c->preset);
100 if (r < 0)
101 return r;
102 }
103
104 if (c->fwmark > 0) {
105 r = sd_netlink_message_append_u32(req, TCA_CAKE_FWMARK, c->fwmark);
106 if (r < 0)
107 return r;
108 }
109
110 if (c->wash >= 0) {
111 r = sd_netlink_message_append_u32(req, TCA_CAKE_WASH, c->wash);
112 if (r < 0)
113 return r;
114 }
115
116 if (c->split_gso >= 0) {
117 r = sd_netlink_message_append_u32(req, TCA_CAKE_SPLIT_GSO, c->split_gso);
118 if (r < 0)
119 return r;
120 }
121
122 if (c->rtt > 0) {
123 r = sd_netlink_message_append_u32(req, TCA_CAKE_RTT, c->rtt);
124 if (r < 0)
125 return r;
126 }
127
128 if (c->ack_filter >= 0) {
129 r = sd_netlink_message_append_u32(req, TCA_CAKE_ACK_FILTER, c->ack_filter);
130 if (r < 0)
131 return r;
132 }
133
134 r = sd_netlink_message_close_container(req);
135 if (r < 0)
136 return r;
137
138 return 0;
139 }
140
141 int config_parse_cake_bandwidth(
142 const char *unit,
143 const char *filename,
144 unsigned line,
145 const char *section,
146 unsigned section_line,
147 const char *lvalue,
148 int ltype,
149 const char *rvalue,
150 void *data,
151 void *userdata) {
152
153 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
154 CommonApplicationsKeptEnhanced *c;
155 Network *network = ASSERT_PTR(data);
156 uint64_t k;
157 int r;
158
159 assert(filename);
160 assert(lvalue);
161 assert(rvalue);
162
163 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
164 if (r == -ENOMEM)
165 return log_oom();
166 if (r < 0) {
167 log_syntax(unit, LOG_WARNING, filename, line, r,
168 "More than one kind of queueing discipline, ignoring assignment: %m");
169 return 0;
170 }
171
172 c = CAKE(qdisc);
173
174 if (isempty(rvalue)) {
175 c->bandwidth = 0;
176
177 TAKE_PTR(qdisc);
178 return 0;
179 }
180
181 r = parse_size(rvalue, 1000, &k);
182 if (r < 0) {
183 log_syntax(unit, LOG_WARNING, filename, line, r,
184 "Failed to parse '%s=', ignoring assignment: %s",
185 lvalue, rvalue);
186 return 0;
187 }
188
189 c->bandwidth = k/8;
190 TAKE_PTR(qdisc);
191
192 return 0;
193 }
194
195 int config_parse_cake_overhead(
196 const char *unit,
197 const char *filename,
198 unsigned line,
199 const char *section,
200 unsigned section_line,
201 const char *lvalue,
202 int ltype,
203 const char *rvalue,
204 void *data,
205 void *userdata) {
206
207 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
208 CommonApplicationsKeptEnhanced *c;
209 Network *network = ASSERT_PTR(data);
210 int32_t v;
211 int r;
212
213 assert(filename);
214 assert(lvalue);
215 assert(rvalue);
216
217 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
218 if (r == -ENOMEM)
219 return log_oom();
220 if (r < 0) {
221 log_syntax(unit, LOG_WARNING, filename, line, r,
222 "More than one kind of queueing discipline, ignoring assignment: %m");
223 return 0;
224 }
225
226 c = CAKE(qdisc);
227
228 if (isempty(rvalue)) {
229 c->overhead_set = false;
230 TAKE_PTR(qdisc);
231 return 0;
232 }
233
234 r = safe_atoi32(rvalue, &v);
235 if (r < 0) {
236 log_syntax(unit, LOG_WARNING, filename, line, r,
237 "Failed to parse '%s=', ignoring assignment: %s",
238 lvalue, rvalue);
239 return 0;
240 }
241 if (v < -64 || v > 256) {
242 log_syntax(unit, LOG_WARNING, filename, line, 0,
243 "Invalid '%s=', ignoring assignment: %s",
244 lvalue, rvalue);
245 return 0;
246 }
247
248 c->overhead = v;
249 c->overhead_set = true;
250 TAKE_PTR(qdisc);
251 return 0;
252 }
253
254 int config_parse_cake_mpu(
255 const char *unit,
256 const char *filename,
257 unsigned line,
258 const char *section,
259 unsigned section_line,
260 const char *lvalue,
261 int ltype,
262 const char *rvalue,
263 void *data,
264 void *userdata) {
265
266 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
267 CommonApplicationsKeptEnhanced *c;
268 Network *network = ASSERT_PTR(data);
269 uint32_t v;
270 int r;
271
272 assert(filename);
273 assert(lvalue);
274 assert(rvalue);
275
276 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
277 if (r == -ENOMEM)
278 return log_oom();
279 if (r < 0) {
280 log_syntax(unit, LOG_WARNING, filename, line, r,
281 "More than one kind of queueing discipline, ignoring assignment: %m");
282 return 0;
283 }
284
285 c = CAKE(qdisc);
286
287 if (isempty(rvalue)) {
288 c->mpu = 0;
289 TAKE_PTR(qdisc);
290 return 0;
291 }
292
293 r = safe_atou32(rvalue, &v);
294 if (r < 0) {
295 log_syntax(unit, LOG_WARNING, filename, line, r,
296 "Failed to parse '%s=', ignoring assignment: %s",
297 lvalue, rvalue);
298 return 0;
299 }
300 if (v <= 0 || v > 256) {
301 log_syntax(unit, LOG_WARNING, filename, line, 0,
302 "Invalid '%s=', ignoring assignment: %s",
303 lvalue, rvalue);
304 return 0;
305 }
306
307 c->mpu = v;
308 TAKE_PTR(qdisc);
309 return 0;
310 }
311
312 int config_parse_cake_tristate(
313 const char *unit,
314 const char *filename,
315 unsigned line,
316 const char *section,
317 unsigned section_line,
318 const char *lvalue,
319 int ltype,
320 const char *rvalue,
321 void *data,
322 void *userdata) {
323
324 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
325 CommonApplicationsKeptEnhanced *c;
326 Network *network = ASSERT_PTR(data);
327 int *dest, r;
328
329 assert(filename);
330 assert(lvalue);
331 assert(rvalue);
332
333 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
334 if (r == -ENOMEM)
335 return log_oom();
336 if (r < 0) {
337 log_syntax(unit, LOG_WARNING, filename, line, r,
338 "More than one kind of queueing discipline, ignoring assignment: %m");
339 return 0;
340 }
341
342 c = CAKE(qdisc);
343
344 if (streq(lvalue, "AutoRateIngress"))
345 dest = &c->autorate;
346 else if (streq(lvalue, "UseRawPacketSize"))
347 dest = &c->raw;
348 else if (streq(lvalue, "NAT"))
349 dest = &c->nat;
350 else if (streq(lvalue, "Wash"))
351 dest = &c->wash;
352 else if (streq(lvalue, "SplitGSO"))
353 dest = &c->split_gso;
354 else
355 assert_not_reached();
356
357 r = parse_tristate(rvalue, dest);
358 if (r < 0) {
359 log_syntax(unit, LOG_WARNING, filename, line, r,
360 "Failed to parse '%s=', ignoring assignment: %s",
361 lvalue, rvalue);
362 return 0;
363 }
364
365 TAKE_PTR(qdisc);
366 return 0;
367 }
368
369 static const char * const cake_compensation_mode_table[_CAKE_COMPENSATION_MODE_MAX] = {
370 [CAKE_COMPENSATION_MODE_NONE] = "none",
371 [CAKE_COMPENSATION_MODE_ATM] = "atm",
372 [CAKE_COMPENSATION_MODE_PTM] = "ptm",
373 };
374
375 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(cake_compensation_mode, CakeCompensationMode);
376
377 int config_parse_cake_compensation_mode(
378 const char *unit,
379 const char *filename,
380 unsigned line,
381 const char *section,
382 unsigned section_line,
383 const char *lvalue,
384 int ltype,
385 const char *rvalue,
386 void *data,
387 void *userdata) {
388
389 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
390 CommonApplicationsKeptEnhanced *c;
391 Network *network = ASSERT_PTR(data);
392 CakeCompensationMode mode;
393 int r;
394
395 assert(filename);
396 assert(lvalue);
397 assert(rvalue);
398
399 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
400 if (r == -ENOMEM)
401 return log_oom();
402 if (r < 0) {
403 log_syntax(unit, LOG_WARNING, filename, line, r,
404 "More than one kind of queueing discipline, ignoring assignment: %m");
405 return 0;
406 }
407
408 c = CAKE(qdisc);
409
410 if (isempty(rvalue)) {
411 c->compensation_mode = _CAKE_COMPENSATION_MODE_INVALID;
412 TAKE_PTR(qdisc);
413 return 0;
414 }
415
416 mode = cake_compensation_mode_from_string(rvalue);
417 if (mode < 0) {
418 log_syntax(unit, LOG_WARNING, filename, line, mode,
419 "Failed to parse '%s=', ignoring assignment: %s",
420 lvalue, rvalue);
421 return 0;
422 }
423
424 c->compensation_mode = mode;
425 TAKE_PTR(qdisc);
426 return 0;
427 }
428
429 static const char * const cake_flow_isolation_mode_table[_CAKE_FLOW_ISOLATION_MODE_MAX] = {
430 [CAKE_FLOW_ISOLATION_MODE_NONE] = "none",
431 [CAKE_FLOW_ISOLATION_MODE_SRC_IP] = "src-host",
432 [CAKE_FLOW_ISOLATION_MODE_DST_IP] = "dst-host",
433 [CAKE_FLOW_ISOLATION_MODE_HOSTS] = "hosts",
434 [CAKE_FLOW_ISOLATION_MODE_FLOWS] = "flows",
435 [CAKE_FLOW_ISOLATION_MODE_DUAL_SRC] = "dual-src-host",
436 [CAKE_FLOW_ISOLATION_MODE_DUAL_DST] = "dual-dst-host",
437 [CAKE_FLOW_ISOLATION_MODE_TRIPLE] = "triple",
438 };
439
440 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(cake_flow_isolation_mode, CakeFlowIsolationMode);
441
442 int config_parse_cake_flow_isolation_mode(
443 const char *unit,
444 const char *filename,
445 unsigned line,
446 const char *section,
447 unsigned section_line,
448 const char *lvalue,
449 int ltype,
450 const char *rvalue,
451 void *data,
452 void *userdata) {
453
454 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
455 CommonApplicationsKeptEnhanced *c;
456 Network *network = ASSERT_PTR(data);
457 CakeFlowIsolationMode mode;
458 int r;
459
460 assert(filename);
461 assert(lvalue);
462 assert(rvalue);
463
464 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
465 if (r == -ENOMEM)
466 return log_oom();
467 if (r < 0) {
468 log_syntax(unit, LOG_WARNING, filename, line, r,
469 "More than one kind of queueing discipline, ignoring assignment: %m");
470 return 0;
471 }
472
473 c = CAKE(qdisc);
474
475 if (isempty(rvalue)) {
476 c->flow_isolation_mode = _CAKE_FLOW_ISOLATION_MODE_INVALID;
477 TAKE_PTR(qdisc);
478 return 0;
479 }
480
481 mode = cake_flow_isolation_mode_from_string(rvalue);
482 if (mode < 0) {
483 log_syntax(unit, LOG_WARNING, filename, line, mode,
484 "Failed to parse '%s=', ignoring assignment: %s",
485 lvalue, rvalue);
486 return 0;
487 }
488
489 c->flow_isolation_mode = mode;
490 TAKE_PTR(qdisc);
491 return 0;
492 }
493
494 static const char * const cake_priority_queueing_preset_table[_CAKE_PRESET_MAX] = {
495 [CAKE_PRESET_DIFFSERV3] = "diffserv3",
496 [CAKE_PRESET_DIFFSERV4] = "diffserv4",
497 [CAKE_PRESET_DIFFSERV8] = "diffserv8",
498 [CAKE_PRESET_BESTEFFORT] = "besteffort",
499 [CAKE_PRESET_PRECEDENCE] = "precedence",
500 };
501
502 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(cake_priority_queueing_preset, CakePriorityQueueingPreset);
503
504 int config_parse_cake_priority_queueing_preset(
505 const char *unit,
506 const char *filename,
507 unsigned line,
508 const char *section,
509 unsigned section_line,
510 const char *lvalue,
511 int ltype,
512 const char *rvalue,
513 void *data,
514 void *userdata) {
515
516 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
517 CommonApplicationsKeptEnhanced *c;
518 CakePriorityQueueingPreset preset;
519 Network *network = ASSERT_PTR(data);
520 int r;
521
522 assert(filename);
523 assert(lvalue);
524 assert(rvalue);
525
526 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
527 if (r == -ENOMEM)
528 return log_oom();
529 if (r < 0) {
530 log_syntax(unit, LOG_WARNING, filename, line, r,
531 "More than one kind of queueing discipline, ignoring assignment: %m");
532 return 0;
533 }
534
535 c = CAKE(qdisc);
536
537 if (isempty(rvalue)) {
538 c->preset = _CAKE_PRESET_INVALID;
539 TAKE_PTR(qdisc);
540 return 0;
541 }
542
543 preset = cake_priority_queueing_preset_from_string(rvalue);
544 if (preset < 0) {
545 log_syntax(unit, LOG_WARNING, filename, line, preset,
546 "Failed to parse '%s=', ignoring assignment: %s",
547 lvalue, rvalue);
548 return 0;
549 }
550
551 c->preset = preset;
552 TAKE_PTR(qdisc);
553 return 0;
554 }
555
556 int config_parse_cake_fwmark(
557 const char *unit,
558 const char *filename,
559 unsigned line,
560 const char *section,
561 unsigned section_line,
562 const char *lvalue,
563 int ltype,
564 const char *rvalue,
565 void *data,
566 void *userdata) {
567
568 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
569 CommonApplicationsKeptEnhanced *c;
570 Network *network = ASSERT_PTR(data);
571 uint32_t fwmark;
572 int r;
573
574 assert(filename);
575 assert(lvalue);
576 assert(rvalue);
577
578 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
579 if (r == -ENOMEM)
580 return log_oom();
581 if (r < 0) {
582 log_syntax(unit, LOG_WARNING, filename, line, r,
583 "More than one kind of queueing discipline, ignoring assignment: %m");
584 return 0;
585 }
586
587 c = CAKE(qdisc);
588
589 if (isempty(rvalue)) {
590 c->fwmark = 0;
591 TAKE_PTR(qdisc);
592 return 0;
593 }
594
595 r = safe_atou32(rvalue, &fwmark);
596 if (r < 0) {
597 log_syntax(unit, LOG_WARNING, filename, line, r,
598 "Failed to parse '%s=', ignoring assignment: %s",
599 lvalue, rvalue);
600 return 0;
601 }
602 if (fwmark <= 0) {
603 log_syntax(unit, LOG_WARNING, filename, line, 0,
604 "Invalid '%s=', ignoring assignment: %s",
605 lvalue, rvalue);
606 return 0;
607 }
608
609 c->fwmark = fwmark;
610 TAKE_PTR(qdisc);
611 return 0;
612 }
613
614 int config_parse_cake_rtt(
615 const char *unit,
616 const char *filename,
617 unsigned line,
618 const char *section,
619 unsigned section_line,
620 const char *lvalue,
621 int ltype,
622 const char *rvalue,
623 void *data,
624 void *userdata) {
625
626 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
627 CommonApplicationsKeptEnhanced *c;
628 Network *network = ASSERT_PTR(data);
629 usec_t t;
630 int r;
631
632 assert(filename);
633 assert(lvalue);
634 assert(rvalue);
635
636 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
637 if (r == -ENOMEM)
638 return log_oom();
639 if (r < 0) {
640 log_syntax(unit, LOG_WARNING, filename, line, r,
641 "More than one kind of queueing discipline, ignoring assignment: %m");
642 return 0;
643 }
644
645 c = CAKE(qdisc);
646
647 if (isempty(rvalue)) {
648 c->rtt = 0;
649 TAKE_PTR(qdisc);
650 return 0;
651 }
652
653 r = parse_sec(rvalue, &t);
654 if (r < 0) {
655 log_syntax(unit, LOG_WARNING, filename, line, r,
656 "Failed to parse '%s=', ignoring assignment: %s",
657 lvalue, rvalue);
658 return 0;
659 }
660 if (t <= 0 || t > UINT32_MAX) {
661 log_syntax(unit, LOG_WARNING, filename, line, 0,
662 "Invalid '%s=', ignoring assignment: %s",
663 lvalue, rvalue);
664 return 0;
665 }
666
667 c->rtt = t;
668 TAKE_PTR(qdisc);
669 return 0;
670 }
671
672 static const char * const cake_ack_filter_table[_CAKE_ACK_FILTER_MAX] = {
673 [CAKE_ACK_FILTER_NO] = "no",
674 [CAKE_ACK_FILTER_YES] = "yes",
675 [CAKE_ACK_FILTER_AGGRESSIVE] = "aggressive",
676 };
677
678 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING_WITH_BOOLEAN(cake_ack_filter, CakeAckFilter, CAKE_ACK_FILTER_YES);
679
680 int config_parse_cake_ack_filter(
681 const char *unit,
682 const char *filename,
683 unsigned line,
684 const char *section,
685 unsigned section_line,
686 const char *lvalue,
687 int ltype,
688 const char *rvalue,
689 void *data,
690 void *userdata) {
691
692 _cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
693 CommonApplicationsKeptEnhanced *c;
694 CakeAckFilter ack_filter;
695 Network *network = ASSERT_PTR(data);
696 int r;
697
698 assert(filename);
699 assert(lvalue);
700 assert(rvalue);
701
702 r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
703 if (r == -ENOMEM)
704 return log_oom();
705 if (r < 0) {
706 log_syntax(unit, LOG_WARNING, filename, line, r,
707 "More than one kind of queueing discipline, ignoring assignment: %m");
708 return 0;
709 }
710
711 c = CAKE(qdisc);
712
713 if (isempty(rvalue)) {
714 c->ack_filter = _CAKE_ACK_FILTER_INVALID;
715 TAKE_PTR(qdisc);
716 return 0;
717 }
718
719 ack_filter = cake_ack_filter_from_string(rvalue);
720 if (ack_filter < 0) {
721 log_syntax(unit, LOG_WARNING, filename, line, ack_filter,
722 "Failed to parse '%s=', ignoring assignment: %s",
723 lvalue, rvalue);
724 return 0;
725 }
726
727 c->ack_filter = ack_filter;
728 TAKE_PTR(qdisc);
729 return 0;
730 }
731
732 const QDiscVTable cake_vtable = {
733 .object_size = sizeof(CommonApplicationsKeptEnhanced),
734 .tca_kind = "cake",
735 .init = cake_init,
736 .fill_message = cake_fill_message,
737 };