[PATCH 1/2] iproute2: import latest cake
Kevin Darbyshire-Bryant
ldir at darbyshire-bryant.me.uk
Sun May 6 11:12:02 PDT 2018
Bearing fruits of the latest upstreaming efforts on cake.
Changes: diffserv-llt dropped. The paper describing this DSCP
allocation has gone stale and doesn't appear used.
The userspace to kernel netlink messages for cake have been reworked in
a backwards incompatible way, so tc & cake must be bumped together this
once.
Signed-off-by: Kevin Darbyshire-Bryant <ldir at darbyshire-bryant.me.uk>
---
package/network/utils/iproute2/Makefile | 2 +-
.../iproute2/patches/950-add-cake-to-tc.patch | 869 ++++++++++-----------
2 files changed, 425 insertions(+), 446 deletions(-)
diff --git a/package/network/utils/iproute2/Makefile b/package/network/utils/iproute2/Makefile
index f5a9db321d..88a4851748 100644
--- a/package/network/utils/iproute2/Makefile
+++ b/package/network/utils/iproute2/Makefile
@@ -9,7 +9,7 @@ include $(TOPDIR)/rules.mk
PKG_NAME:=iproute2
PKG_VERSION:=4.16.0
-PKG_RELEASE:=2
+PKG_RELEASE:=3
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.xz
PKG_SOURCE_URL:=@KERNEL/linux/utils/net/iproute2
diff --git a/package/network/utils/iproute2/patches/950-add-cake-to-tc.patch b/package/network/utils/iproute2/patches/950-add-cake-to-tc.patch
index c8f70da132..3c2cdaaac3 100644
--- a/package/network/utils/iproute2/patches/950-add-cake-to-tc.patch
+++ b/package/network/utils/iproute2/patches/950-add-cake-to-tc.patch
@@ -1,6 +1,6 @@
--- a/include/uapi/linux/pkt_sched.h
+++ b/include/uapi/linux/pkt_sched.h
-@@ -934,4 +934,75 @@ enum {
+@@ -934,4 +934,110 @@ enum {
#define TCA_CBS_MAX (__TCA_CBS_MAX - 1)
@@ -22,66 +22,101 @@
+ TCA_CAKE_MPU,
+ TCA_CAKE_INGRESS,
+ TCA_CAKE_ACK_FILTER,
++ TCA_CAKE_SPLIT_GSO,
+ __TCA_CAKE_MAX
+};
+#define TCA_CAKE_MAX (__TCA_CAKE_MAX - 1)
+
-+struct tc_cake_traffic_stats {
-+ __u32 packets;
-+ __u32 link_ms;
-+ __u64 bytes;
++enum {
++ __TCA_CAKE_STATS_INVALID,
++ TCA_CAKE_STATS_CAPACITY_ESTIMATE,
++ TCA_CAKE_STATS_MEMORY_LIMIT,
++ TCA_CAKE_STATS_MEMORY_USED,
++ TCA_CAKE_STATS_AVG_NETOFF,
++ TCA_CAKE_STATS_MIN_NETLEN,
++ TCA_CAKE_STATS_MAX_NETLEN,
++ TCA_CAKE_STATS_MIN_ADJLEN,
++ TCA_CAKE_STATS_MAX_ADJLEN,
++ TCA_CAKE_STATS_TIN_STATS,
++ __TCA_CAKE_STATS_MAX
+};
++#define TCA_CAKE_STATS_MAX (__TCA_CAKE_STATS_MAX - 1)
+
++enum {
++ __TCA_CAKE_TIN_STATS_INVALID,
++ TCA_CAKE_TIN_STATS_PAD,
++ TCA_CAKE_TIN_STATS_SENT_PACKETS,
++ TCA_CAKE_TIN_STATS_SENT_BYTES64,
++ TCA_CAKE_TIN_STATS_DROPPED_PACKETS,
++ TCA_CAKE_TIN_STATS_DROPPED_BYTES64,
++ TCA_CAKE_TIN_STATS_ACKS_DROPPED_PACKETS,
++ TCA_CAKE_TIN_STATS_ACKS_DROPPED_BYTES64,
++ TCA_CAKE_TIN_STATS_ECN_MARKED_PACKETS,
++ TCA_CAKE_TIN_STATS_ECN_MARKED_BYTES64,
++ TCA_CAKE_TIN_STATS_BACKLOG_PACKETS,
++ TCA_CAKE_TIN_STATS_BACKLOG_BYTES64,
++ TCA_CAKE_TIN_STATS_THRESHOLD_RATE,
++ TCA_CAKE_TIN_STATS_TARGET_US,
++ TCA_CAKE_TIN_STATS_INTERVAL_US,
++ TCA_CAKE_TIN_STATS_WAY_INDIRECT_HITS,
++ TCA_CAKE_TIN_STATS_WAY_MISSES,
++ TCA_CAKE_TIN_STATS_WAY_COLLISIONS,
++ TCA_CAKE_TIN_STATS_PEAK_DELAY_US,
++ TCA_CAKE_TIN_STATS_AVG_DELAY_US,
++ TCA_CAKE_TIN_STATS_BASE_DELAY_US,
++ TCA_CAKE_TIN_STATS_SPARSE_FLOWS,
++ TCA_CAKE_TIN_STATS_BULK_FLOWS,
++ TCA_CAKE_TIN_STATS_UNRESPONSIVE_FLOWS,
++ TCA_CAKE_TIN_STATS_MAX_SKBLEN,
++ TCA_CAKE_TIN_STATS_FLOW_QUANTUM,
++ __TCA_CAKE_TIN_STATS_MAX
++};
++#define TCA_CAKE_TIN_STATS_MAX (__TCA_CAKE_TIN_STATS_MAX - 1)
+#define TC_CAKE_MAX_TINS (8)
-+struct tc_cake_tin_stats {
-+
-+ __u32 threshold_rate;
-+ __u32 target_us;
-+ struct tc_cake_traffic_stats sent;
-+ struct tc_cake_traffic_stats dropped;
-+ struct tc_cake_traffic_stats ecn_marked;
-+ struct tc_cake_traffic_stats backlog;
-+ __u32 interval_us;
-+ __u32 way_indirect_hits;
-+ __u32 way_misses;
-+ __u32 way_collisions;
-+ __u32 peak_delay_us; /* ~= bulk flow delay */
-+ __u32 avge_delay_us;
-+ __u32 base_delay_us; /* ~= sparse flows delay */
-+ __u16 sparse_flows;
-+ __u16 bulk_flows;
-+ __u16 unresponse_flows;
-+ __u16 spare;
-+ __u32 max_skblen;
-+ struct tc_cake_traffic_stats ack_drops;
++
++enum {
++ CAKE_FLOW_NONE = 0,
++ CAKE_FLOW_SRC_IP,
++ CAKE_FLOW_DST_IP,
++ CAKE_FLOW_HOSTS, /* = CAKE_FLOW_SRC_IP | CAKE_FLOW_DST_IP */
++ CAKE_FLOW_FLOWS,
++ CAKE_FLOW_DUAL_SRC, /* = CAKE_FLOW_SRC_IP | CAKE_FLOW_FLOWS */
++ CAKE_FLOW_DUAL_DST, /* = CAKE_FLOW_DST_IP | CAKE_FLOW_FLOWS */
++ CAKE_FLOW_TRIPLE, /* = CAKE_FLOW_HOSTS | CAKE_FLOW_FLOWS */
++ CAKE_FLOW_MAX,
+};
+
-+struct tc_cake_xstats {
-+ __u16 version;
-+ __u16 tin_stats_size; /* == sizeof(struct tc_cake_tin_stats) */
-+ __u32 capacity_estimate;
-+ __u32 memory_limit;
-+ __u32 memory_used;
-+ __u8 tin_cnt;
-+ __u8 avg_trnoff;
-+ __u16 max_trnlen;
-+ __u16 max_adjlen;
-+ __u16 min_trnlen;
-+ __u16 min_adjlen;
-+
-+ __u16 spare1;
-+ __u32 spare2;
-+
-+ struct tc_cake_tin_stats tin_stats[0]; /* keep last */
++enum {
++ CAKE_DIFFSERV_DIFFSERV3 = 0,
++ CAKE_DIFFSERV_DIFFSERV4,
++ CAKE_DIFFSERV_DIFFSERV8,
++ CAKE_DIFFSERV_BESTEFFORT,
++ CAKE_DIFFSERV_PRECEDENCE,
++ CAKE_DIFFSERV_MAX
++};
++
++enum {
++ CAKE_ACK_NONE = 0,
++ CAKE_ACK_FILTER,
++ CAKE_ACK_AGGRESSIVE,
++ CAKE_ACK_MAX
+};
++
++enum {
++ CAKE_ATM_NONE = 0,
++ CAKE_ATM_ATM,
++ CAKE_ATM_PTM,
++ CAKE_ATM_MAX
++};
++
+
#endif
--- /dev/null
+++ b/man/man8/tc-cake.8
-@@ -0,0 +1,678 @@
+@@ -0,0 +1,632 @@
+.TH CAKE 8 "23 November 2017" "iproute2" "Linux"
+.SH NAME
-+CAKE \- COMMON Applications Kept Enhanced (CAKE)
++CAKE \- Common Applications Kept Enhanced (CAKE)
+.SH SYNOPSIS
+.B tc qdisc ... cake
+.br
@@ -120,8 +155,6 @@
+|
+.BR diffserv4
+|
-+.BR diffserv-llt
-+|
+.BR diffserv3*
+]
+.br
@@ -578,20 +611,6 @@
+ Enables legacy interpretation of TOS "Precedence" field. Use of this
+preset on the modern Internet is firmly discouraged.
+.PP
-+.B diffserv-llt
-+.br
-+ Provides a "Latency-Loss Tradeoff" implementation with five tins:
-+.br
-+ Low Loss (TOS1, TOS2), 100% threshold, increased Codel target.
-+.br
-+ Best Effort (general), 100% threshold, normal Codel target & interval.
-+.br
-+ Low Latency (TOS4, TOS5, VA, EF), 100% threshold, reduced Codel interval.
-+.br
-+ Bulk (CS1), 6.25% threshold, normal Codel target & interval.
-+.br
-+ Net Control (CS6, CS7), 6.25% threshold, increased Codel target & interval.
-+.PP
+.B diffserv4
+.br
+ Provides a general-purpose Diffserv implementation with four tins:
@@ -646,103 +665,73 @@
+.SH EXAMPLES
+# tc qdisc delete root dev eth0
+.br
-+# tc qdisc add root dev eth0 cake bandwidth 9500Kbit pppoe-ptm ether-vlan
++# tc qdisc add root dev eth0 cake bandwidth 100Mbit ethernet
+.br
+# tc -s qdisc show dev eth0
+.br
-+qdisc cake 8007: root refcnt 6 bandwidth 9500Kbit diffserv3 triple-isolate rtt 100.0ms ptm overhead 34 via-ethernet total_overhead 34 hard_header_len 14
-+ Sent 0 bytes 0 pkt (dropped 0, overlimits 0 requeues 0)
++qdisc cake 1: dev eth0 root refcnt 2 bandwidth 100Mbit diffserv3 triple-isolate rtt 100.0ms noatm overhead 38 mpu 84
++ Sent 0 bytes 0 pkt (dropped 0, overlimits 0 requeues 0)
+ backlog 0b 0p requeues 0
-+ memory used: 0b of 4Mb
-+ capacity estimate: 9500Kbit
-+.br
-+ Bulk Best Effort Voice
-+.br
-+ thresh 593744bit 9500Kbit 2375Kbit
-+.br
-+ target 30.6ms 5.0ms 7.6ms
-+.br
-+ interval 125.6ms 100.0ms 102.6ms
-+.br
-+ pk_delay 0us 0us 0us
-+.br
-+ av_delay 0us 0us 0us
-+.br
-+ sp_delay 0us 0us 0us
-+.br
-+ pkts 0 0 0
-+.br
-+ bytes 0 0 0
-+.br
-+ way_inds 0 0 0
-+.br
-+ way_miss 0 0 0
-+.br
-+ way_cols 0 0 0
-+.br
-+ drops 0 0 0
-+.br
-+ marks 0 0 0
-+.br
-+ ack_drop 0 0 0
-+.br
-+ sp_flows 0 0 0
-+.br
-+ bk_flows 0 0 0
-+.br
-+ un_flows 0 0 0
-+.br
-+ max_len 0 0 0
-+.br
++ memory used: 0b of 5000000b
++ capacity estimate: 100Mbit
++ min/max network layer size: 65535 / 0
++ min/max overhead-adjusted size: 65535 / 0
++ average network hdr offset: 0
++
++ Bulk Best Effort Voice
++ thresh 6250Kbit 100Mbit 25Mbit
++ target 5.0ms 5.0ms 5.0ms
++ interval 100.0ms 100.0ms 100.0ms
++ pk_delay 0us 0us 0us
++ av_delay 0us 0us 0us
++ sp_delay 0us 0us 0us
++ pkts 0 0 0
++ bytes 0 0 0
++ way_inds 0 0 0
++ way_miss 0 0 0
++ way_cols 0 0 0
++ drops 0 0 0
++ marks 0 0 0
++ ack_drop 0 0 0
++ sp_flows 0 0 0
++ bk_flows 0 0 0
++ un_flows 0 0 0
++ max_len 0 0 0
++ quantum 300 1514 762
+
+After some use:
+.br
+# tc -s qdisc show dev eth0
+
-+qdisc cake 8007: root refcnt 6 bandwidth 9500Kbit diffserv3 triple-isolate rtt 100.0ms ptm overhead 34 via-ethernet total_overhead 34 hard_header_len 14
-+ Sent 110769306 bytes 313857 pkt (dropped 18, overlimits 741791 requeues 0)
-+ backlog 0b 0p requeues 0
-+ memory used: 110488b of 4Mb
-+ capacity estimate: 9500Kbit
-+.br
-+ Bulk Best Effort Voice
-+.br
-+ thresh 593744bit 9500Kbit 2375Kbit
-+.br
-+ target 30.6ms 5.0ms 7.6ms
-+.br
-+ interval 125.6ms 100.0ms 102.6ms
-+.br
-+ pk_delay 16.0ms 545us 15us
-+.br
-+ av_delay 2.4ms 161us 3us
-+.br
-+ sp_delay 59us 1us 1us
-+.br
-+ pkts 32866 195815 85194
-+.br
-+ bytes 8132614 69517496 33122156
-+.br
-+ way_inds 0 29208 0
-+.br
-+ way_miss 7 173 17
-+.br
-+ way_cols 0 0 0
-+.br
-+ drops 10 7 1
-+.br
-+ marks 217 692 300
-+.br
-+ ack_drop 0 0 0
-+.br
-+ sp_flows 0 0 0
-+.br
-+ bk_flows 0 0 1
-+.br
-+ un_flows 0 0 0
-+.br
-+ max_len 3028 3012 3028
-+.br
++qdisc cake 1: root refcnt 2 bandwidth 100Mbit diffserv3 triple-isolate rtt 100.0ms noatm overhead 38 mpu 84
++ Sent 44709231 bytes 31931 pkt (dropped 45, overlimits 93782 requeues 0)
++ backlog 33308b 22p requeues 0
++ memory used: 292352b of 5000000b
++ capacity estimate: 100Mbit
++ min/max network layer size: 28 / 1500
++ min/max overhead-adjusted size: 84 / 1538
++ average network hdr offset: 14
++
++ Bulk Best Effort Voice
++ thresh 6250Kbit 100Mbit 25Mbit
++ target 5.0ms 5.0ms 5.0ms
++ interval 100.0ms 100.0ms 100.0ms
++ pk_delay 8.7ms 6.9ms 5.0ms
++ av_delay 4.9ms 5.3ms 3.8ms
++ sp_delay 727us 1.4ms 511us
++ pkts 2590 21271 8137
++ bytes 3081804 30302659 11426206
++ way_inds 0 46 0
++ way_miss 3 17 4
++ way_cols 0 0 0
++ drops 20 15 10
++ marks 0 0 0
++ ack_drop 0 0 0
++ sp_flows 2 4 1
++ bk_flows 1 2 1
++ un_flows 0 0 0
++ max_len 1514 1514 1514
++ quantum 300 1514 762
+
+.SH SEE ALSO
+.BR tc (8),
@@ -769,44 +758,13 @@
TCMODULES += q_hhf.o
--- /dev/null
+++ b/tc/q_cake.c
-@@ -0,0 +1,770 @@
+@@ -0,0 +1,749 @@
+/* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */
+/*
+ * Common Applications Kept Enhanced -- CAKE
+ *
+ * Copyright (C) 2014-2018 Jonathan Morton <chromatix99 at gmail.com>
+ * Copyright (C) 2017-2018 Toke Høiland-Jørgensen <toke at toke.dk>
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions
-+ * are met:
-+ * 1. Redistributions of source code must retain the above copyright
-+ * notice, this list of conditions, and the following disclaimer,
-+ * without modification.
-+ * 2. Redistributions in binary form must reproduce the above copyright
-+ * notice, this list of conditions and the following disclaimer in the
-+ * documentation and/or other materials provided with the distribution.
-+ * 3. The names of the authors may not be used to endorse or promote products
-+ * derived from this software without specific prior written permission.
-+ *
-+ * Alternatively, provided that this notice is retained in full, this
-+ * software may be distributed under the terms of the GNU General
-+ * Public License ("GPL") version 2, in which case the provisions of the
-+ * GPL apply INSTEAD OF those given above.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-+ * DAMAGE.
-+ *
+ */
+
+#include <stddef.h>
@@ -823,14 +781,41 @@
+#include "utils.h"
+#include "tc_util.h"
+
++struct cake_preset {
++ char *name;
++ unsigned int target;
++ unsigned int interval;
++};
++
++static struct cake_preset presets[] = {
++ {"datacentre", 5, 100},
++ {"lan", 50, 1000},
++ {"metro", 500, 10000},
++ {"regional", 1500, 30000},
++ {"internet", 5000, 100000},
++ {"oceanic", 15000, 300000},
++ {"satellite", 50000, 1000000},
++ {"interplanetary", 50000000, 1000000000},
++};
++
++
++static struct cake_preset *find_preset(char *argv)
++{
++ int i;
++
++ for (i = 0; i < ARRAY_SIZE(presets); i++)
++ if (!strcmp(argv, presets[i].name))
++ return &presets[i];
++ return NULL;
++}
++
+static void explain(void)
+{
+ fprintf(stderr,
+"Usage: ... cake [ bandwidth RATE | unlimited* | autorate_ingress ]\n"
+" [ rtt TIME | datacentre | lan | metro | regional |\n"
+" internet* | oceanic | satellite | interplanetary ]\n"
-+" [ besteffort | diffserv8 | diffserv4 | diffserv-llt |\n"
-+" diffserv3* ]\n"
++" [ besteffort | diffserv8 | diffserv4 | diffserv3* ]\n"
+" [ flowblind | srchost | dsthost | hosts | flows |\n"
+" dual-srchost | dual-dsthost | triple-isolate* ]\n"
+" [ nat | nonat* ]\n"
@@ -863,6 +848,7 @@
+ int ingress = -1;
+ int ack_filter = -1;
+ struct rtattr *tail;
++ struct cake_preset *preset, *preset_set = NULL;
+
+ while (argc > 0) {
+ if (strcmp(*argv, "bandwidth") == 0) {
@@ -889,45 +875,25 @@
+ target = interval / 20;
+ if(!target)
+ target = 1;
-+ } else if (strcmp(*argv, "datacentre") == 0) {
-+ interval = 100;
-+ target = 5;
-+ } else if (strcmp(*argv, "lan") == 0) {
-+ interval = 1000;
-+ target = 50;
-+ } else if (strcmp(*argv, "metro") == 0) {
-+ interval = 10000;
-+ target = 500;
-+ } else if (strcmp(*argv, "regional") == 0) {
-+ interval = 30000;
-+ target = 1500;
-+ } else if (strcmp(*argv, "internet") == 0) {
-+ interval = 100000;
-+ target = 5000;
-+ } else if (strcmp(*argv, "oceanic") == 0) {
-+ interval = 300000;
-+ target = 15000;
-+ } else if (strcmp(*argv, "satellite") == 0) {
-+ interval = 1000000;
-+ target = 50000;
-+ } else if (strcmp(*argv, "interplanetary") == 0) {
-+ interval = 1000000000;
-+ target = 50000000;
++ } else if ((preset = find_preset(*argv))) {
++ if (preset_set)
++ duparg(*argv, preset_set->name);
++ preset_set = preset;
++ target = preset->target;
++ interval = preset->interval;
+
+ } else if (strcmp(*argv, "besteffort") == 0) {
-+ diffserv = 1;
++ diffserv = CAKE_DIFFSERV_BESTEFFORT;
+ } else if (strcmp(*argv, "precedence") == 0) {
-+ diffserv = 2;
++ diffserv = CAKE_DIFFSERV_PRECEDENCE;
+ } else if (strcmp(*argv, "diffserv8") == 0) {
-+ diffserv = 3;
++ diffserv = CAKE_DIFFSERV_DIFFSERV8;
+ } else if (strcmp(*argv, "diffserv4") == 0) {
-+ diffserv = 4;
++ diffserv = CAKE_DIFFSERV_DIFFSERV4;
+ } else if (strcmp(*argv, "diffserv") == 0) {
-+ diffserv = 4;
-+ } else if (strcmp(*argv, "diffserv-llt") == 0) {
-+ diffserv = 5;
++ diffserv = CAKE_DIFFSERV_DIFFSERV4;
+ } else if (strcmp(*argv, "diffserv3") == 0) {
-+ diffserv = 6;
++ diffserv = CAKE_DIFFSERV_DIFFSERV3;
+
+ } else if (strcmp(*argv, "nowash") == 0) {
+ wash = 0;
@@ -935,21 +901,21 @@
+ wash = 1;
+
+ } else if (strcmp(*argv, "flowblind") == 0) {
-+ flowmode = 0;
++ flowmode = CAKE_FLOW_NONE;
+ } else if (strcmp(*argv, "srchost") == 0) {
-+ flowmode = 1;
++ flowmode = CAKE_FLOW_SRC_IP;
+ } else if (strcmp(*argv, "dsthost") == 0) {
-+ flowmode = 2;
++ flowmode = CAKE_FLOW_DST_IP;
+ } else if (strcmp(*argv, "hosts") == 0) {
-+ flowmode = 3;
++ flowmode = CAKE_FLOW_HOSTS;
+ } else if (strcmp(*argv, "flows") == 0) {
-+ flowmode = 4;
++ flowmode = CAKE_FLOW_FLOWS;
+ } else if (strcmp(*argv, "dual-srchost") == 0) {
-+ flowmode = 5;
++ flowmode = CAKE_FLOW_DUAL_SRC;
+ } else if (strcmp(*argv, "dual-dsthost") == 0) {
-+ flowmode = 6;
++ flowmode = CAKE_FLOW_DUAL_DST;
+ } else if (strcmp(*argv, "triple-isolate") == 0) {
-+ flowmode = 7;
++ flowmode = CAKE_FLOW_TRIPLE;
+
+ } else if (strcmp(*argv, "nat") == 0) {
+ nat = 1;
@@ -957,14 +923,14 @@
+ nat = 0;
+
+ } else if (strcmp(*argv, "ptm") == 0) {
-+ atm = 2;
++ atm = CAKE_ATM_PTM;
+ } else if (strcmp(*argv, "atm") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ } else if (strcmp(*argv, "noatm") == 0) {
-+ atm = 0;
++ atm = CAKE_ATM_NONE;
+
+ } else if (strcmp(*argv, "raw") == 0) {
-+ atm = 0;
++ atm = CAKE_ATM_NONE;
+ overhead = 0;
+ overhead_set = true;
+ overhead_override = true;
@@ -974,41 +940,41 @@
+ * one whole ATM cell plus ATM framing.
+ * A safe choice if the actual overhead is unknown.
+ */
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead = 48;
+ overhead_set = true;
+
+ /* Various ADSL framing schemes, all over ATM cells */
+ } else if (strcmp(*argv, "ipoa-vcmux") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 8;
+ overhead_set = true;
+ } else if (strcmp(*argv, "ipoa-llcsnap") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 16;
+ overhead_set = true;
+ } else if (strcmp(*argv, "bridged-vcmux") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 24;
+ overhead_set = true;
+ } else if (strcmp(*argv, "bridged-llcsnap") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 32;
+ overhead_set = true;
+ } else if (strcmp(*argv, "pppoa-vcmux") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 10;
+ overhead_set = true;
+ } else if (strcmp(*argv, "pppoa-llc") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 14;
+ overhead_set = true;
+ } else if (strcmp(*argv, "pppoe-vcmux") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 32;
+ overhead_set = true;
+ } else if (strcmp(*argv, "pppoe-llcsnap") == 0) {
-+ atm = 1;
++ atm = CAKE_ATM_ATM;
+ overhead += 40;
+ overhead_set = true;
+
@@ -1020,7 +986,7 @@
+ * + 1B Start of Frame (S) + 1B End of Frame (Ck)
+ * + 2B TC-CRC (PTM-FCS) = 30B
+ */
-+ atm = 2;
++ atm = CAKE_ATM_PTM;
+ overhead += 30;
+ overhead_set = true;
+ } else if (strcmp(*argv, "bridged-ptm") == 0) {
@@ -1029,7 +995,7 @@
+ * + 1B Start of Frame (S) + 1B End of Frame (Ck)
+ * + 2B TC-CRC (PTM-FCS) = 22B
+ */
-+ atm = 2;
++ atm = CAKE_ATM_PTM;
+ overhead += 22;
+ overhead_set = true;
+
@@ -1065,7 +1031,7 @@
+ * but not interframe gap or preamble.
+ */
+ } else if (strcmp(*argv, "docsis") == 0) {
-+ atm = 0;
++ atm = CAKE_ATM_NONE;
+ overhead += 18;
+ overhead_set = true;
+ mpu = 64;
@@ -1095,11 +1061,11 @@
+ ingress = 0;
+
+ } else if (strcmp(*argv, "no-ack-filter") == 0) {
-+ ack_filter = 0;
++ ack_filter = CAKE_ACK_NONE;
+ } else if (strcmp(*argv, "ack-filter") == 0) {
-+ ack_filter = 0x0200;
++ ack_filter = CAKE_ACK_FILTER;
+ } else if (strcmp(*argv, "ack-filter-aggressive") == 0) {
-+ ack_filter = 0x0600;
++ ack_filter = CAKE_ACK_AGGRESSIVE;
+
+ } else if (strcmp(*argv, "memlimit") == 0) {
+ NEXT_ARG();
@@ -1176,6 +1142,7 @@
+ int wash = 0;
+ int ingress = 0;
+ int ack_filter = 0;
++ int split_gso = 0;
+ SPRINT_BUF(b1);
+ SPRINT_BUF(b2);
+
@@ -1205,23 +1172,20 @@
+ RTA_PAYLOAD(tb[TCA_CAKE_DIFFSERV_MODE]) >= sizeof(__u32)) {
+ diffserv = rta_getattr_u32(tb[TCA_CAKE_DIFFSERV_MODE]);
+ switch(diffserv) {
-+ case 1:
-+ print_string(PRINT_ANY, "diffserv", "%s ", "besteffort");
++ case CAKE_DIFFSERV_DIFFSERV3:
++ print_string(PRINT_ANY, "diffserv", "%s ", "diffserv3");
+ break;
-+ case 2:
-+ print_string(PRINT_ANY, "diffserv", "%s ", "precedence");
++ case CAKE_DIFFSERV_DIFFSERV4:
++ print_string(PRINT_ANY, "diffserv", "%s ", "diffserv4");
+ break;
-+ case 3:
++ case CAKE_DIFFSERV_DIFFSERV8:
+ print_string(PRINT_ANY, "diffserv", "%s ", "diffserv8");
+ break;
-+ case 4:
-+ print_string(PRINT_ANY, "diffserv", "%s ", "diffserv4");
-+ break;
-+ case 5:
-+ print_string(PRINT_ANY, "diffserv", "%s ", "diffserv-llt");
++ case CAKE_DIFFSERV_BESTEFFORT:
++ print_string(PRINT_ANY, "diffserv", "%s ", "besteffort");
+ break;
-+ case 6:
-+ print_string(PRINT_ANY, "diffserv", "%s ", "diffserv3");
++ case CAKE_DIFFSERV_PRECEDENCE:
++ print_string(PRINT_ANY, "diffserv", "%s ", "precedence");
+ break;
+ default:
+ print_string(PRINT_ANY, "diffserv", "(?diffserv?) ", "unknown");
@@ -1231,31 +1195,29 @@
+ if (tb[TCA_CAKE_FLOW_MODE] &&
+ RTA_PAYLOAD(tb[TCA_CAKE_FLOW_MODE]) >= sizeof(__u32)) {
+ flowmode = rta_getattr_u32(tb[TCA_CAKE_FLOW_MODE]);
-+ nat = !!(flowmode & 64);
-+ flowmode &= ~64;
+ switch(flowmode) {
-+ case 0:
++ case CAKE_FLOW_NONE:
+ print_string(PRINT_ANY, "flowmode", "%s ", "flowblind");
+ break;
-+ case 1:
++ case CAKE_FLOW_SRC_IP:
+ print_string(PRINT_ANY, "flowmode", "%s ", "srchost");
+ break;
-+ case 2:
++ case CAKE_FLOW_DST_IP:
+ print_string(PRINT_ANY, "flowmode", "%s ", "dsthost");
+ break;
-+ case 3:
++ case CAKE_FLOW_HOSTS:
+ print_string(PRINT_ANY, "flowmode", "%s ", "hosts");
+ break;
-+ case 4:
++ case CAKE_FLOW_FLOWS:
+ print_string(PRINT_ANY, "flowmode", "%s ", "flows");
+ break;
-+ case 5:
++ case CAKE_FLOW_DUAL_SRC:
+ print_string(PRINT_ANY, "flowmode", "%s ", "dual-srchost");
+ break;
-+ case 6:
++ case CAKE_FLOW_DUAL_DST:
+ print_string(PRINT_ANY, "flowmode", "%s ", "dual-dsthost");
+ break;
-+ case 7:
++ case CAKE_FLOW_TRIPLE:
+ print_string(PRINT_ANY, "flowmode", "%s ", "triple-isolate");
+ break;
+ default:
@@ -1263,10 +1225,17 @@
+ break;
+ };
+
-+ if(nat)
-+ print_string(PRINT_FP, NULL, "nat ", NULL);
-+ print_bool(PRINT_JSON, "nat", NULL, nat);
+ }
++
++ if (tb[TCA_CAKE_NAT] &&
++ RTA_PAYLOAD(tb[TCA_CAKE_NAT]) >= sizeof(__u32)) {
++ nat = rta_getattr_u32(tb[TCA_CAKE_NAT]);
++ }
++
++ if(nat)
++ print_string(PRINT_FP, NULL, "nat ", NULL);
++ print_bool(PRINT_JSON, "nat", NULL, nat);
++
+ if (tb[TCA_CAKE_WASH] &&
+ RTA_PAYLOAD(tb[TCA_CAKE_WASH]) >= sizeof(__u32)) {
+ wash = rta_getattr_u32(tb[TCA_CAKE_WASH]);
@@ -1276,8 +1245,8 @@
+ atm = rta_getattr_u32(tb[TCA_CAKE_ATM]);
+ }
+ if (tb[TCA_CAKE_OVERHEAD] &&
-+ RTA_PAYLOAD(tb[TCA_CAKE_OVERHEAD]) >= sizeof(__u32)) {
-+ overhead = rta_getattr_u32(tb[TCA_CAKE_OVERHEAD]);
++ RTA_PAYLOAD(tb[TCA_CAKE_OVERHEAD]) >= sizeof(__s32)) {
++ overhead = *(__s32 *) RTA_DATA(tb[TCA_CAKE_OVERHEAD]);
+ }
+ if (tb[TCA_CAKE_MPU] &&
+ RTA_PAYLOAD(tb[TCA_CAKE_MPU]) >= sizeof(__u32)) {
@@ -1291,6 +1260,10 @@
+ RTA_PAYLOAD(tb[TCA_CAKE_ACK_FILTER]) >= sizeof(__u32)) {
+ ack_filter = rta_getattr_u32(tb[TCA_CAKE_ACK_FILTER]);
+ }
++ if (tb[TCA_CAKE_SPLIT_GSO] &&
++ RTA_PAYLOAD(tb[TCA_CAKE_SPLIT_GSO]) >= sizeof(__u32)) {
++ split_gso = rta_getattr_u32(tb[TCA_CAKE_SPLIT_GSO]);
++ }
+ if (tb[TCA_CAKE_RAW]) {
+ raw = 1;
+ }
@@ -1307,13 +1280,17 @@
+ print_string(PRINT_FP, NULL, "ingress ", NULL);
+ print_bool(PRINT_JSON, "ingress", NULL, ingress);
+
-+ if (ack_filter == 0x0600)
++ if (ack_filter == CAKE_ACK_AGGRESSIVE)
+ print_string(PRINT_ANY, "ack-filter", "ack-filter-%s ", "aggressive");
-+ else if (ack_filter)
++ else if (ack_filter == CAKE_ACK_FILTER)
+ print_string(PRINT_ANY, "ack-filter", "ack-filter ", "enabled");
+ else
+ print_string(PRINT_JSON, "ack-filter", NULL, "disabled");
+
++ if (split_gso)
++ print_string(PRINT_FP, NULL, "split-gso ", NULL);
++ print_bool(PRINT_JSON, "split_gso", NULL, split_gso);
++
+ if (interval)
+ print_string(PRINT_FP, NULL, "rtt %s ", sprint_time(interval, b2));
+ print_uint(PRINT_JSON, "rtt", NULL, interval);
@@ -1322,9 +1299,9 @@
+ print_string(PRINT_FP, NULL, "raw ", NULL);
+ print_bool(PRINT_JSON, "raw", NULL, raw);
+
-+ if (atm == 1)
++ if (atm == CAKE_ATM_ATM)
+ print_string(PRINT_ANY, "atm", "%s ", "atm");
-+ else if (atm == 2)
++ else if (atm == CAKE_ATM_PTM)
+ print_string(PRINT_ANY, "atm", "%s ", "ptm");
+ else if (!raw)
+ print_string(PRINT_ANY, "atm", "%s ", "noatm");
@@ -1332,7 +1309,7 @@
+ print_uint(PRINT_ANY, "overhead", "overhead %d ", overhead);
+
+ if (mpu)
-+ print_uint(PRINT_ANY, "mpu", "mpu %d ", mpu);
++ print_uint(PRINT_ANY, "mpu", "mpu %u ", mpu);
+
+ if (memlimit) {
+ print_uint(PRINT_JSON, "memlimit", NULL, memlimit);
@@ -1342,195 +1319,186 @@
+ return 0;
+}
+
-+#define FOR_EACH_TIN(xstats, tst, i) \
-+ for(tst = xstats->tin_stats, i = 0; \
-+ i < xstats->tin_cnt; \
-+ i++, tst = ((void *) xstats->tin_stats) + xstats->tin_stats_size * i)
-+
-+static void cake_print_json_tin(struct tc_cake_tin_stats *tst)
++static void cake_print_json_tin(struct rtattr **tstat)
+{
++#define PRINT_TSTAT_JSON(type, name, attr) if (tstat[TCA_CAKE_TIN_STATS_ ## attr]) \
++ print_uint(PRINT_JSON, name, NULL, \
++ rta_getattr_ ## type((struct rtattr *)tstat[TCA_CAKE_TIN_STATS_ ## attr]))
++
+ open_json_object(NULL);
-+ print_uint(PRINT_JSON, "threshold_rate", NULL, tst->threshold_rate);
-+ print_uint(PRINT_JSON, "target", NULL, tst->target_us);
-+ print_uint(PRINT_JSON, "interval", NULL, tst->interval_us);
-+ print_uint(PRINT_JSON, "peak_delay", NULL, tst->peak_delay_us);
-+ print_uint(PRINT_JSON, "average_delay", NULL, tst->avge_delay_us);
-+ print_uint(PRINT_JSON, "base_delay", NULL, tst->base_delay_us);
-+ print_uint(PRINT_JSON, "sent_packets", NULL, tst->sent.packets);
-+ print_uint(PRINT_JSON, "sent_bytes", NULL, tst->sent.bytes);
-+ print_uint(PRINT_JSON, "way_indirect_hits", NULL, tst->way_indirect_hits);
-+ print_uint(PRINT_JSON, "way_misses", NULL, tst->way_misses);
-+ print_uint(PRINT_JSON, "way_collisions", NULL, tst->way_collisions);
-+ print_uint(PRINT_JSON, "drops", NULL, tst->dropped.packets);
-+ print_uint(PRINT_JSON, "ecn_mark", NULL, tst->ecn_marked.packets);
-+ print_uint(PRINT_JSON, "ack_drops", NULL, tst->ack_drops.packets);
-+ print_uint(PRINT_JSON, "sparse_flows", NULL, tst->sparse_flows);
-+ print_uint(PRINT_JSON, "bulk_flows", NULL, tst->bulk_flows);
-+ print_uint(PRINT_JSON, "unresponsive_flows", NULL, tst->unresponse_flows);
-+ print_uint(PRINT_JSON, "max_pkt_len", NULL, tst->max_skblen);
++ PRINT_TSTAT_JSON(u32, "threshold_rate", THRESHOLD_RATE);
++ PRINT_TSTAT_JSON(u32, "target_us", TARGET_US);
++ PRINT_TSTAT_JSON(u32, "interval_us", INTERVAL_US);
++ PRINT_TSTAT_JSON(u32, "peak_delay_us", PEAK_DELAY_US);
++ PRINT_TSTAT_JSON(u32, "avg_delay_us", AVG_DELAY_US);
++ PRINT_TSTAT_JSON(u32, "base_delay_us", BASE_DELAY_US);
++ PRINT_TSTAT_JSON(u32, "sent_packets", SENT_PACKETS);
++ PRINT_TSTAT_JSON(u64, "sent_bytes", SENT_BYTES64);
++ PRINT_TSTAT_JSON(u32, "way_indirect_hits", WAY_INDIRECT_HITS);
++ PRINT_TSTAT_JSON(u32, "way_misses", WAY_MISSES);
++ PRINT_TSTAT_JSON(u32, "way_collisions", WAY_COLLISIONS);
++ PRINT_TSTAT_JSON(u32, "drops", DROPPED_PACKETS);
++ PRINT_TSTAT_JSON(u32, "ecn_mark", ECN_MARKED_PACKETS);
++ PRINT_TSTAT_JSON(u32, "ack_drops", ACKS_DROPPED_PACKETS);
++ PRINT_TSTAT_JSON(u32, "sparse_flows", SPARSE_FLOWS);
++ PRINT_TSTAT_JSON(u32, "bulk_flows", BULK_FLOWS);
++ PRINT_TSTAT_JSON(u32, "unresponsive_flows", UNRESPONSIVE_FLOWS);
++ PRINT_TSTAT_JSON(u32, "max_pkt_len", MAX_SKBLEN);
++ PRINT_TSTAT_JSON(u32, "flow_quantum", FLOW_QUANTUM);
+ close_json_object();
++
++#undef PRINT_TSTAT_JSON
+}
+
+static int cake_print_xstats(struct qdisc_util *qu, FILE *f,
+ struct rtattr *xstats)
+{
-+ struct tc_cake_xstats *stnc;
-+ struct tc_cake_tin_stats *tst;
+ SPRINT_BUF(b1);
++ struct rtattr *st[TCA_CAKE_STATS_MAX + 1];
+ int i;
+
+ if (xstats == NULL)
+ return 0;
+
-+ if (RTA_PAYLOAD(xstats) < sizeof(*stnc))
-+ return -1;
-+
-+ stnc = RTA_DATA(xstats);
-+
-+ if (stnc->version < 0x101 ||
-+ RTA_PAYLOAD(xstats) < (sizeof(struct tc_cake_xstats) +
-+ stnc->tin_stats_size * stnc->tin_cnt))
-+ return -1;
-+
-+ print_uint(PRINT_JSON, "memory_used", NULL, stnc->memory_used);
-+ print_uint(PRINT_JSON, "memory_limit", NULL, stnc->memory_limit);
-+ print_uint(PRINT_JSON, "capacity_estimate", NULL, stnc->capacity_estimate);
-+
-+ print_string(PRINT_FP, NULL, " memory used: %s",
-+ sprint_size(stnc->memory_used, b1));
-+ print_string(PRINT_FP, NULL, " of %s\n",
-+ sprint_size(stnc->memory_limit, b1));
-+ print_string(PRINT_FP, NULL, " capacity estimate: %s\n",
-+ sprint_rate(stnc->capacity_estimate, b1));
-+
-+ print_uint(PRINT_ANY, "min_transport_size", " min/max transport layer size: %10u",
-+ stnc->min_trnlen);
-+ print_uint(PRINT_ANY, "max_transport_size", " /%8u\n", stnc->max_trnlen);
-+ print_uint(PRINT_ANY, "min_adj_size", " min/max overhead-adjusted size: %8u",
-+ stnc->min_adjlen);
-+ print_uint(PRINT_ANY, "max_adj_size", " /%8u\n", stnc->max_adjlen);
-+ print_uint(PRINT_ANY, "avg_hdr_offset", " average transport hdr offset: %10u\n\n",
-+ stnc->avg_trnoff);
-+
-+ if (is_json_context()) {
-+ open_json_array(PRINT_JSON, "tins");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ cake_print_json_tin(tst);
-+ close_json_array(PRINT_JSON, NULL);
-+ return 0;
++#define GET_STAT_U32(attr) rta_getattr_u32(st[TCA_CAKE_STATS_ ## attr])
++
++ parse_rtattr_nested(st, TCA_CAKE_STATS_MAX, xstats);
++
++ if (st[TCA_CAKE_STATS_MEMORY_USED] &&
++ st[TCA_CAKE_STATS_MEMORY_LIMIT]) {
++ print_string(PRINT_FP, NULL, " memory used: %s",
++ sprint_size(GET_STAT_U32(MEMORY_USED), b1));
++
++ print_string(PRINT_FP, NULL, " of %s\n",
++ sprint_size(GET_STAT_U32(MEMORY_LIMIT), b1));
++
++ print_uint(PRINT_JSON, "memory_used", NULL,
++ GET_STAT_U32(MEMORY_USED));
++ print_uint(PRINT_JSON, "memory_limit", NULL,
++ GET_STAT_U32(MEMORY_LIMIT));
++ }
++
++ if (st[TCA_CAKE_STATS_CAPACITY_ESTIMATE]) {
++ print_string(PRINT_FP, NULL, " capacity estimate: %s\n",
++ sprint_rate(GET_STAT_U32(CAPACITY_ESTIMATE), b1));
++ print_uint(PRINT_JSON, "capacity_estimate", NULL,
++ GET_STAT_U32(CAPACITY_ESTIMATE));
+ }
+
++ if (st[TCA_CAKE_STATS_MIN_NETLEN] &&
++ st[TCA_CAKE_STATS_MAX_NETLEN]) {
++ print_uint(PRINT_ANY, "min_network_size",
++ " min/max network layer size: %8u",
++ GET_STAT_U32(MIN_NETLEN));
++ print_uint(PRINT_ANY, "max_network_size",
++ " /%8u\n", GET_STAT_U32(MAX_NETLEN));
++ }
++
++ if (st[TCA_CAKE_STATS_MIN_ADJLEN] &&
++ st[TCA_CAKE_STATS_MAX_ADJLEN]) {
++ print_uint(PRINT_ANY, "min_adj_size",
++ " min/max overhead-adjusted size: %8u",
++ GET_STAT_U32(MIN_ADJLEN));
++ print_uint(PRINT_ANY, "max_adj_size",
++ " /%8u\n", GET_STAT_U32(MAX_ADJLEN));
++ }
++
++ if (st[TCA_CAKE_STATS_AVG_NETOFF])
++ print_uint(PRINT_ANY, "avg_hdr_offset",
++ " average network hdr offset: %8u\n\n",
++ GET_STAT_U32(AVG_NETOFF));
++
++#undef GET_STAT_U32
++
++ if (st[TCA_CAKE_STATS_TIN_STATS]) {
++ struct rtattr *tins[TC_CAKE_MAX_TINS + 1];
++ struct rtattr *tstat[TC_CAKE_MAX_TINS][TCA_CAKE_TIN_STATS_MAX + 1];
++ int num_tins = 0;
++
++ parse_rtattr_nested(tins, TC_CAKE_MAX_TINS, st[TCA_CAKE_STATS_TIN_STATS]);
++
++ for (i = 1; i <= TC_CAKE_MAX_TINS && tins[i]; i++) {
++ parse_rtattr_nested(tstat[i-1], TCA_CAKE_TIN_STATS_MAX, tins[i]);
++ num_tins++;
++ }
++
++ if (!num_tins)
++ return 0;
++
++ if (is_json_context()) {
++ open_json_array(PRINT_JSON, "tins");
++ for (i = 0; i < num_tins; i++)
++ cake_print_json_tin(tstat[i]);
++ close_json_array(PRINT_JSON, NULL);
++
++ return 0;
++ }
++
++
++ switch(num_tins) {
++ case 3:
++ fprintf(f, " Bulk Best Effort Voice\n");
++ break;
++
++ case 4:
++ fprintf(f, " Bulk Best Effort Video Voice\n");
++ break;
+
-+ switch(stnc->tin_cnt) {
-+ case 3:
-+ fprintf(f, " Bulk Best Effort Voice\n");
-+ break;
-+
-+ case 4:
-+ fprintf(f, " Bulk Best Effort Video Voice\n");
-+ break;
-+
-+ case 5:
-+ fprintf(f, " Low Loss Best Effort Low Delay Bulk Net Control\n");
-+ break;
-+
-+ default:
-+ fprintf(f, " ");
-+ for(i=0; i < stnc->tin_cnt; i++)
-+ fprintf(f, " Tin %u", i);
-+ fprintf(f, "\n");
-+ };
-+
-+ fprintf(f, " thresh ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12s", sprint_rate(tst->threshold_rate, b1));
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " target ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12s", sprint_time(tst->target_us, b1));
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " interval");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12s", sprint_time(tst->interval_us, b1));
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " pk_delay");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12s", sprint_time(tst->peak_delay_us, b1));
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " av_delay");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12s", sprint_time(tst->avge_delay_us, b1));
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " sp_delay");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12s", sprint_time(tst->base_delay_us, b1));
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " pkts ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->sent.packets);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " bytes ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12llu", tst->sent.bytes);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " way_inds");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->way_indirect_hits);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " way_miss");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->way_misses);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " way_cols");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->way_collisions);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " drops ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->dropped.packets);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " marks ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->ecn_marked.packets);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " ack_drop");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->ack_drops.packets);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " sp_flows");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->sparse_flows);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " bk_flows");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->bulk_flows);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " un_flows");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->unresponse_flows);
-+ fprintf(f, "\n");
-+
-+ fprintf(f, " max_len ");
-+ FOR_EACH_TIN(stnc, tst, i)
-+ fprintf(f, " %12u", tst->max_skblen);
-+ fprintf(f, "\n");
++ default:
++ fprintf(f, " ");
++ for(i=0; i < num_tins; i++)
++ fprintf(f, " Tin %u", i);
++ fprintf(f, "\n");
++ };
+
++#define GET_TSTAT(i, attr) (tstat[i][TCA_CAKE_TIN_STATS_ ## attr])
++#define PRINT_TSTAT(name, attr, fmts, val) do { \
++ if (GET_TSTAT(0, attr)) { \
++ fprintf(f, name); \
++ for (i = 0; i < num_tins; i++) \
++ fprintf(f, " %12" fmts, val); \
++ fprintf(f, "\n"); \
++ } \
++ } while (0)
++
++#define SPRINT_TSTAT(pfunc, name, attr) PRINT_TSTAT( \
++ name, attr, "s", sprint_ ## pfunc( \
++ rta_getattr_u32(GET_TSTAT(i, attr)), b1))
++
++#define PRINT_TSTAT_U32(name, attr) PRINT_TSTAT( \
++ name, attr, "u", rta_getattr_u32(GET_TSTAT(i, attr)))
++
++#define PRINT_TSTAT_U64(name, attr) PRINT_TSTAT( \
++ name, attr, "llu", rta_getattr_u64(GET_TSTAT(i, attr)))
++
++ SPRINT_TSTAT(rate, " thresh ", THRESHOLD_RATE);
++ SPRINT_TSTAT(time, " target ", TARGET_US);
++ SPRINT_TSTAT(time, " interval", INTERVAL_US);
++ SPRINT_TSTAT(time, " pk_delay", PEAK_DELAY_US);
++ SPRINT_TSTAT(time, " av_delay", AVG_DELAY_US);
++ SPRINT_TSTAT(time, " sp_delay", BASE_DELAY_US);
++
++ PRINT_TSTAT_U32(" pkts ", SENT_PACKETS);
++ PRINT_TSTAT_U64(" bytes ", SENT_BYTES64);
++
++ PRINT_TSTAT_U32(" way_inds", WAY_INDIRECT_HITS);
++ PRINT_TSTAT_U32(" way_miss", WAY_MISSES);
++ PRINT_TSTAT_U32(" way_cols", WAY_COLLISIONS);
++ PRINT_TSTAT_U32(" drops ", DROPPED_PACKETS);
++ PRINT_TSTAT_U32(" marks ", ECN_MARKED_PACKETS);
++ PRINT_TSTAT_U32(" ack_drop", ACKS_DROPPED_PACKETS);
++ PRINT_TSTAT_U32(" sp_flows", SPARSE_FLOWS);
++ PRINT_TSTAT_U32(" bk_flows", BULK_FLOWS);
++ PRINT_TSTAT_U32(" un_flows", UNRESPONSIVE_FLOWS);
++ PRINT_TSTAT_U32(" max_len ", MAX_SKBLEN);
++ PRINT_TSTAT_U32(" quantum ", FLOW_QUANTUM);
++
++#undef GET_STAT
++#undef PRINT_TSTAT
++#undef SPRINT_TSTAT
++#undef PRINT_TSTAT_U32
++#undef PRINT_TSTAT_U64
++ }
+ return 0;
+}
+
@@ -1540,3 +1508,14 @@
+ .print_qopt = cake_print_opt,
+ .print_xstats = cake_print_xstats,
+};
+--- a/tc/q_ingress.c
++++ b/tc/q_ingress.c
+@@ -40,7 +40,7 @@ static int ingress_parse_opt(struct qdis
+ static int ingress_print_opt(struct qdisc_util *qu, FILE *f,
+ struct rtattr *opt)
+ {
+- fprintf(f, "---------------- ");
++ print_string(PRINT_FP, NULL, "---------------- ", NULL);
+ return 0;
+ }
+
--
2.15.1 (Apple Git-101)
More information about the Lede-dev
mailing list