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@gmail.com>
 + *  Copyright (C) 2017-2018 Toke Høiland-Jørgensen <toke@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;
+ }
+ 
