| From cded87ae1e15aa95dba07f9be20868b5fef1368e Mon Sep 17 00:00:00 2001 |
| From: Kan Yan <kyan@google.com> |
| Date: Thu, 23 Jan 2020 16:55:53 -0800 |
| Subject: [PATCH] tc: add support for new qdisc "ARL" |
| |
| Ingress mode is also supported in this patch. |
| |
| BUG=b:124309202 |
| TEST="tc qdisc add dev ifbwan0 root handle 1: arl minrate 4800kbit" |
| " buffer 5000 limit 500 latency 100ms latency_hysteresis 30ms" |
| " codel_target 10ms ingress" |
| |
| Kill this once the 3.18 and 4.4 kernels are deprecated |
| |
| Signed-off-by: Kan Yan <kyan@google.com> |
| --- |
| include/uapi/linux/pkt_sched.h | 27 ++++ |
| tc/Makefile | 1 + |
| tc/q_arl.c | 232 +++++++++++++++++++++++++++++++++ |
| 3 files changed, 260 insertions(+) |
| create mode 100644 tc/q_arl.c |
| |
| diff --git a/include/uapi/linux/pkt_sched.h b/include/uapi/linux/pkt_sched.h |
| index d35dd7a2..12b51898 100644 |
| --- a/include/uapi/linux/pkt_sched.h |
| +++ b/include/uapi/linux/pkt_sched.h |
| @@ -742,6 +742,33 @@ enum { |
| |
| #define TCA_CBQ_MAX (__TCA_CBQ_MAX - 1) |
| |
| +/* ARL section */ |
| + |
| +struct tc_arl_xstats { |
| + __u32 max_bw; /* The maximum bw measured */ |
| + __u32 min_rate; /* The lowest base rate */ |
| + __u32 current_rate; /* The current rate */ |
| + __u32 latency; /* The current latency */ |
| + __u32 base_rate; /* The base rate */ |
| + __u32 current_bw; /* The current bw measured */ |
| + __u32 state; /* The current state */ |
| +}; |
| + |
| +enum { |
| + TCA_ARL_UNSPEC, |
| + TCA_ARL_BUFFER, |
| + TCA_ARL_MIN_RATE, |
| + TCA_ARL_MAX_BW, |
| + TCA_ARL_LIMIT, |
| + TCA_ARL_MAX_LATENCY, |
| + TCA_ARL_LATENCY_HYSTERESIS, |
| + TCA_ARL_PAD, |
| + TCA_ARL_MODE, |
| + TCA_ARL_CODEL_TARGET, |
| + __TCA_ARL_MAX, |
| +}; |
| +#define TCA_ARL_MAX (__TCA_ARL_MAX - 1) |
| + |
| /* dsmark section */ |
| |
| enum { |
| diff --git a/tc/Makefile b/tc/Makefile |
| index 457a3ea1..d6e67940 100644 |
| --- a/tc/Makefile |
| +++ b/tc/Makefile |
| @@ -80,6 +80,7 @@ TCMODULES += q_cbs.o |
| TCMODULES += q_etf.o |
| TCMODULES += q_taprio.o |
| TCMODULES += q_plug.o |
| +TCMODULES += q_arl.o |
| |
| TCSO := |
| ifeq ($(TC_CONFIG_ATM),y) |
| diff --git a/tc/q_arl.c b/tc/q_arl.c |
| new file mode 100644 |
| index 00000000..4ba63a99 |
| --- /dev/null |
| +++ b/tc/q_arl.c |
| @@ -0,0 +1,232 @@ |
| +/* |
| + * This program is free software; you can redistribute it and/or |
| + * modify it under the terms of the GNU General Public License |
| + * as published by the Free Software Foundation; either version 2 |
| + * of the License. |
| + * |
| + * This program is distributed in the hope that it will be useful, |
| + * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| + * GNU General Public License for more details. |
| + * |
| + * Copyright 2018 Google LLC. |
| + * Author: Kan Yan <kyan@google.com> |
| + * |
| + */ |
| + |
| +#include <stdio.h> |
| + |
| +#include "utils.h" |
| +#include "tc_util.h" |
| + |
| +static const char * const arl_state_names[] = { |
| + "STABLE", |
| + "DRAIN", |
| + "BW_PROBE", |
| + "LATENCY_PROBE", |
| + "UNTHROTTLED", |
| + "UNDEFINED", |
| +}; |
| + |
| +static void explain(void) |
| +{ |
| + fprintf(stderr, "Usage: ... arl [ limit PACKETS] [ buffer TIME ]"); |
| + fprintf(stderr, " [ minrate KBPS ] [ maxbw KBPS ]\n"); |
| + fprintf(stderr, " [ latency TIME ] "); |
| + fprintf(stderr, "[ latency_hysteresis TIME ]\n"); |
| + fprintf(stderr, "[ codel_target TIME ]\n"); |
| + fprintf(stderr, "[ ingress ]\n"); |
| +} |
| + |
| +static int arl_parse_opt(struct qdisc_util *qu, int argc, char **argv, |
| + struct nlmsghdr *n) |
| +{ |
| + unsigned int buffer = 0, limit = 0, latency = 0, latency_hysteresis = 0, |
| + mode = 0, codel_target = 0; |
| + __u64 min_rate = 0, max_bw = 0; |
| + struct rtattr *tail; |
| + |
| + while (argc > 0) { |
| + if (strcmp(*argv, "buffer") == 0) { |
| + NEXT_ARG(); |
| + if (get_time(&buffer, *argv)) { |
| + fprintf(stderr, "Illegal \"buffer\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "minrate") == 0) { |
| + NEXT_ARG(); |
| + if (get_rate64(&min_rate, *argv)) { |
| + fprintf(stderr, "Illegal \"minrate\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "maxbw") == 0) { |
| + NEXT_ARG(); |
| + if (get_rate64(&max_bw, *argv)) { |
| + fprintf(stderr, "Illegal \"max_bw\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "limit") == 0) { |
| + NEXT_ARG(); |
| + if (get_unsigned(&limit, *argv, 0)) { |
| + fprintf(stderr, "Illegal \"limit\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "latency") == 0) { |
| + NEXT_ARG(); |
| + if (get_time(&latency, *argv)) { |
| + fprintf(stderr, "Illegal \"latency\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "latency_hysteresis") == 0) { |
| + NEXT_ARG(); |
| + if (get_time(&latency_hysteresis, *argv)) { |
| + fprintf(stderr, |
| + "Illegal \"latency hysteresis\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "codel_target") == 0) { |
| + NEXT_ARG(); |
| + if (get_time(&codel_target, *argv)) { |
| + fprintf(stderr, "Illegal \"codel_target\"\n"); |
| + return -1; |
| + } |
| + } else if (strcmp(*argv, "ingress") == 0) { |
| + mode = 1; |
| + } else if (strcmp(*argv, "help") == 0) { |
| + explain(); |
| + return -1; |
| + } else { |
| + fprintf(stderr, "arl: unknown parameter \"%s\"\n", |
| + *argv); |
| + explain(); |
| + return -1; |
| + } |
| + argc--; argv++; |
| + } |
| + |
| + tail = NLMSG_TAIL(n); |
| + addattr_l(n, 1024, TCA_OPTIONS, NULL, 0); |
| + if (buffer) |
| + addattr_l(n, 1024, TCA_ARL_BUFFER, &buffer, sizeof(__u32)); |
| + if (min_rate) |
| + addattr_l(n, 1024, TCA_ARL_MIN_RATE, &min_rate, sizeof(__u64)); |
| + if (max_bw) |
| + addattr_l(n, 1024, TCA_ARL_MAX_BW, &max_bw, sizeof(__u64)); |
| + if (limit) |
| + addattr_l(n, 1024, TCA_ARL_LIMIT, &limit, sizeof(__u32)); |
| + if (latency) |
| + addattr_l(n, 1024, TCA_ARL_MAX_LATENCY, &latency, |
| + sizeof(__u32)); |
| + if (latency_hysteresis) |
| + addattr_l(n, 1024, TCA_ARL_LATENCY_HYSTERESIS, |
| + &latency_hysteresis, sizeof(__u32)); |
| + if (codel_target) |
| + addattr_l(n, 1024, TCA_ARL_CODEL_TARGET, &codel_target, |
| + sizeof(__u32)); |
| + if (mode) |
| + addattr_l(n, 1024, TCA_ARL_MODE, &mode, sizeof(__u32)); |
| + |
| + tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; |
| + return 0; |
| +} |
| + |
| +static int arl_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) |
| +{ |
| + unsigned int buffer, limit, latency, latency_hysteresis, mode, |
| + codel_target; |
| + __u64 min_rate = 0, max_bw; |
| + struct rtattr *tb[TCA_ARL_MAX + 1]; |
| + |
| + SPRINT_BUF(b1); |
| + |
| + if (opt == NULL) |
| + return 0; |
| + |
| + parse_rtattr_nested(tb, TCA_ARL_MAX, opt); |
| + if (tb[TCA_ARL_MIN_RATE] && |
| + RTA_PAYLOAD(tb[TCA_ARL_MIN_RATE]) >= sizeof(__u64)) { |
| + min_rate = rta_getattr_u64(tb[TCA_ARL_MIN_RATE]); |
| + fprintf(f, "minrate %s ", sprint_rate(min_rate, b1)); |
| + } |
| + |
| + if (tb[TCA_ARL_BUFFER] && |
| + RTA_PAYLOAD(tb[TCA_ARL_BUFFER]) >= sizeof(__u32)) { |
| + buffer = rta_getattr_u32(tb[TCA_ARL_BUFFER]); |
| + fprintf(f, "buffer %s ", sprint_time(buffer, b1)); |
| + } |
| + |
| + if (tb[TCA_ARL_MAX_BW] && |
| + RTA_PAYLOAD(tb[TCA_ARL_MAX_BW]) >= sizeof(__u64)) { |
| + max_bw = rta_getattr_u64(tb[TCA_ARL_MAX_BW]); |
| + fprintf(f, "max_bw %s ", sprint_rate(max_bw, b1)); |
| + } |
| + |
| + if (tb[TCA_ARL_LIMIT] && |
| + RTA_PAYLOAD(tb[TCA_ARL_LIMIT]) >= sizeof(__u32)) { |
| + limit = rta_getattr_u32(tb[TCA_ARL_LIMIT]); |
| + fprintf(f, "limit %u ", limit); |
| + } |
| + |
| + if (tb[TCA_ARL_MAX_LATENCY] && |
| + RTA_PAYLOAD(tb[TCA_ARL_MAX_LATENCY]) >= sizeof(__u32)) { |
| + latency = rta_getattr_u32(tb[TCA_ARL_MAX_LATENCY]); |
| + fprintf(f, "latency %s ", sprint_time(latency, b1)); |
| + } |
| + |
| + if (tb[TCA_ARL_LATENCY_HYSTERESIS] && |
| + RTA_PAYLOAD(tb[TCA_ARL_LATENCY_HYSTERESIS]) >= sizeof(__u32)) { |
| + latency_hysteresis = |
| + rta_getattr_u32(tb[TCA_ARL_LATENCY_HYSTERESIS]); |
| + fprintf(f, "latency_hysteresis %s ", |
| + sprint_time(latency_hysteresis, b1)); |
| + } |
| + |
| + if (tb[TCA_ARL_CODEL_TARGET] && |
| + RTA_PAYLOAD(tb[TCA_ARL_CODEL_TARGET]) >= sizeof(__u32)) { |
| + codel_target = rta_getattr_u32(tb[TCA_ARL_CODEL_TARGET]); |
| + fprintf(f, "codel_target %s ", sprint_time(codel_target, b1)); |
| + } |
| + |
| + if (tb[TCA_ARL_MODE] && |
| + RTA_PAYLOAD(tb[TCA_ARL_MODE]) >= sizeof(__u32)) { |
| + mode = rta_getattr_u32(tb[TCA_ARL_MODE]); |
| + if (mode) |
| + fprintf(f, "mode ingress"); |
| + else |
| + fprintf(f, "mode egress"); |
| + } |
| + |
| + return 0; |
| +} |
| + |
| +static int arl_print_xstats(struct qdisc_util *qu, FILE *f, |
| + struct rtattr *xstats) |
| +{ |
| + struct tc_arl_xstats *st; |
| + |
| + if (xstats == NULL) |
| + return 0; |
| + |
| + if (RTA_PAYLOAD(xstats) < sizeof(*st)) |
| + return -1; |
| + |
| + st = RTA_DATA(xstats); |
| + |
| + fprintf(f, "state %s base_rate %uKbit current_rate %uKbit latency %uus bw %uKbit", |
| + arl_state_names[st->state], st->base_rate, st->current_rate, |
| + st->latency, st->current_bw); |
| + if (st->max_bw) |
| + fprintf(f, " max_bw %uKbit", st->max_bw); |
| + |
| + if (st->min_rate) |
| + fprintf(f, " min_base_rate %uKbit", st->min_rate); |
| + |
| + return 0; |
| +} |
| + |
| +struct qdisc_util arl_qdisc_util = { |
| + .id = "arl", |
| + .parse_qopt = arl_parse_opt, |
| + .print_qopt = arl_print_opt, |
| + .print_xstats = arl_print_xstats, |
| +}; |
| -- |
| 2.21.0 |
| |