From patchwork Sat Jul 14 00:06:11 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vinicius Costa Gomes X-Patchwork-Id: 943850 X-Patchwork-Delegate: dsahern@gmail.com Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=intel.com Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 41S9274WmVz9s1R for ; Sat, 14 Jul 2018 10:06:23 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731975AbeGNAXP (ORCPT ); Fri, 13 Jul 2018 20:23:15 -0400 Received: from mga12.intel.com ([192.55.52.136]:16148 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731897AbeGNAXO (ORCPT ); Fri, 13 Jul 2018 20:23:14 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 13 Jul 2018 17:06:21 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.51,349,1526367600"; d="scan'208";a="245140629" Received: from ellie.jf.intel.com (HELO localhost.localdomain) ([10.54.70.63]) by fmsmga005.fm.intel.com with ESMTP; 13 Jul 2018 17:06:21 -0700 From: Vinicius Costa Gomes To: netdev@vger.kernel.org Cc: Vinicius Costa Gomes , jhs@mojatatu.com, xiyou.wangcong@gmail.com, jiri@resnulli.us, jesus.sanchez-palencia@intel.com Subject: [RFC iproute2-next v1 5/5] tc: Add support for configuring the taprio scheduler Date: Fri, 13 Jul 2018 17:06:11 -0700 Message-Id: <20180714000611.1179-6-vinicius.gomes@intel.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20180714000611.1179-1-vinicius.gomes@intel.com> References: <20180714000611.1179-1-vinicius.gomes@intel.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This traffic scheduler allows traffic classes states (transmission allowed/not allowed, in the simplest case) to be scheduled, according to a pre-generated time sequence. This is the basis of the IEEE 802.1Qbv specification. If the controller supports it, traffic can be also marked as preemptable/not preemptable, and the states for each entry in the time sequence gains a couple more commands. This maps to the functionality defined by the IEEE 802.1Qbu specification. The syntax is: tc qdisc add dev DEV parent NODE taprio num_tc NUMBER map P0 P1 ... queues TC0 TC1 TC2 ... [ [sched-file file] | [sched-row INDEX CMD GATE-MASK INTERVAL] [ base-time TIME ] [ extension-time TIME ] [ cycle-time TIME ] [ preemption TC0 TC1 TC2 ... ] clockid CLOCKID The parameters should be similar to what the IEEE 802.1Q family of specification define. Signed-off-by: Vinicius Costa Gomes Signed-off-by: Jesus Sanchez-Palencia --- tc/Makefile | 1 + tc/q_taprio.c | 450 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 451 insertions(+) create mode 100644 tc/q_taprio.c diff --git a/tc/Makefile b/tc/Makefile index dfd00267..6534d69b 100644 --- a/tc/Makefile +++ b/tc/Makefile @@ -71,6 +71,7 @@ TCMODULES += q_clsact.o TCMODULES += e_bpf.o TCMODULES += f_matchall.o TCMODULES += q_cbs.o +TCMODULES += q_taprio.o TCSO := ifeq ($(TC_CONFIG_ATM),y) diff --git a/tc/q_taprio.c b/tc/q_taprio.c new file mode 100644 index 00000000..ef8baa4b --- /dev/null +++ b/tc/q_taprio.c @@ -0,0 +1,450 @@ +/* + * q_taprio.c Time Aware Priority Scheduler + * + * 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, or (at your option) any later version. + * + * Authors: Vinicius Costa Gomes + * Jesus Sanchez-Palencia + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "utils.h" +#include "tc_util.h" + +#define CLOCKID_INVALID (-1) +static const struct static_clockid { + const char *name; + clockid_t clockid; +} clockids_sysv[] = { + { "REALTIME", CLOCK_REALTIME }, + { "TAI", CLOCK_TAI }, + { "BOOTTIME", CLOCK_BOOTTIME }, + { "MONOTONIC", CLOCK_MONOTONIC }, + { NULL } +}; + +static void explain(void) +{ + fprintf(stderr, "Usage: ... taprio clockid CLOCKID\n"); + fprintf(stderr, " [num_tc NUMBER] [map P0 P1 ...] "); + fprintf(stderr, " [queues TC0 TC1 TC2 ...] "); + fprintf(stderr, " [ [sched-file file] | [sched-row index cmd gate-mask interval] ] "); + fprintf(stderr, " [base-time time] [extension-time time] [cycle-time time] "); + fprintf(stderr, " [preemption TC0 TC1 TC2 ... ] "); + fprintf(stderr, "\nCLOCKID must be a valid SYS-V id (i.e. CLOCK_TAI)"); + fprintf(stderr, "\n"); +} + +static void explain_clockid(const char *val) +{ + fprintf(stderr, "taprio: illegal value for \"clockid\": \"%s\".\n", val); + fprintf(stderr, "It must be a valid SYS-V id (i.e. CLOCK_TAI)\n"); +} + +static int get_clockid(__s32 *val, const char *arg) +{ + const struct static_clockid *c; + + /* Drop the CLOCK_ prefix if that is being used. */ + if (strcasestr(arg, "CLOCK_") != NULL) + arg += sizeof("CLOCK_") - 1; + + for (c = clockids_sysv; c->name; c++) { + if (strcasecmp(c->name, arg) == 0) { + *val = c->clockid; + + return 0; + } + } + + return -1; +} + +static const char* get_clock_name(clockid_t clockid) +{ + const struct static_clockid *c; + + for (c = clockids_sysv; c->name; c++) { + if (clockid == c->clockid) + return c->name; + } + + return "invalid"; +} + +static int str_to_entry_cmd(const char *str) +{ + if (strcmp(str, "S") == 0) + return TC_TAPRIO_CMD_SET_GATES; + + if (strcmp(str, "H") == 0) + return TC_TAPRIO_CMD_SET_AND_HOLD; + + if (strcmp(str, "R") == 0) + return TC_TAPRIO_CMD_SET_AND_RELEASE; + + return -1; +} + +static int add_sched_list(FILE *f, struct nlmsghdr *n) +{ + __u32 interval, gatemask, index = 0; + char *cmd_str; + __u8 cmd; + int err; + + while (fscanf(f, "%ms %x %" PRIu32 "\n", &cmd_str, &gatemask, &interval) != EOF) { + struct rtattr *entry; + + err = str_to_entry_cmd(cmd_str); + free(cmd_str); + + if (err < 0) + return err; + + cmd = err; + + entry = addattr_nest(n, 1024, TCA_TAPRIO_SCHED_ENTRY); + + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_INDEX, &index, sizeof(index)); + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_CMD, &cmd, sizeof(cmd)); + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_GATE_MASK, &gatemask, sizeof(gatemask)); + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_INTERVAL, &interval, sizeof(interval)); + + addattr_nest_end(n, entry); + } + + return 0; +} + +static void explain_sched_row(void) +{ + fprintf(stderr, "Usage: ... taprio ... sched-row \n"); +} + +static int taprio_parse_opt(struct qdisc_util *qu, int argc, + char **argv, struct nlmsghdr *n, const char *dev) +{ + __u32 entry_interval = 0, entry_gatemask = 0, entry_index = 0; + __s64 base_time = 0, extension_time = 0, cycle_time = 0; + __s32 clockid = CLOCKID_INVALID; + struct tc_mqprio_qopt opt = { }; + unsigned int preemption = 0; + FILE *sched_file = NULL; + struct rtattr *tail; + __u8 entry_cmd = 0; + int err, idx; + + while (argc > 0) { + idx = 0; + if (strcmp(*argv, "num_tc") == 0) { + NEXT_ARG(); + if (get_u8(&opt.num_tc, *argv, 10)) { + fprintf(stderr, "Illegal \"num_tc\"\n"); + return -1; + } + } else if (strcmp(*argv, "map") == 0) { + while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) { + NEXT_ARG(); + if (get_u8(&opt.prio_tc_map[idx], *argv, 10)) { + PREV_ARG(); + break; + } + idx++; + } + for ( ; idx < TC_QOPT_MAX_QUEUE; idx++) + opt.prio_tc_map[idx] = 0; + } else if (strcmp(*argv, "queues") == 0) { + char *tmp, *tok; + + while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) { + NEXT_ARG(); + + tmp = strdup(*argv); + if (!tmp) + break; + + tok = strtok(tmp, "@"); + if (get_u16(&opt.count[idx], tok, 10)) { + free(tmp); + PREV_ARG(); + break; + } + tok = strtok(NULL, "@"); + if (get_u16(&opt.offset[idx], tok, 10)) { + free(tmp); + PREV_ARG(); + break; + } + free(tmp); + idx++; + } + } else if (strcmp(*argv, "sched-file") == 0) { + if (entry_index || entry_cmd || entry_gatemask || entry_interval) { + fprintf(stderr, + "taprio: specifying both \"sched-file\" and \"sched-row\" is not allowed\n"); + return -1; + } + NEXT_ARG(); + + sched_file = fopen(*argv, "r"); + if (!sched_file) { + break; + } + } else if (strcmp(*argv, "sched-row") == 0) { + if (sched_file) { + fprintf(stderr, "taprio: specifying both \"sched-file\" and \"sched-row\" is not allowed\n"); + return -1; + } + + NEXT_ARG(); + + if (get_u32(&entry_index, *argv, 10)) { + explain_sched_row(); + return -1; + } + + NEXT_ARG(); + err = str_to_entry_cmd(*argv); + if (err < 0) { + explain_sched_row(); + return -1; + } + entry_cmd = err; + + NEXT_ARG(); + if (get_u32(&entry_gatemask, *argv, 0)) { + explain_sched_row(); + return -1; + } + + NEXT_ARG(); + if (get_u32(&entry_interval, *argv, 0)) { + explain_sched_row(); + return -1; + } + } else if (strcmp(*argv, "base-time") == 0) { + NEXT_ARG(); + if (get_s64(&base_time, *argv, 10)) { + PREV_ARG(); + break; + } + } else if (strcmp(*argv, "cycle-time") == 0) { + NEXT_ARG(); + if (get_s64(&cycle_time, *argv, 10)) { + PREV_ARG(); + break; + } + } else if (strcmp(*argv, "extension-time") == 0) { + NEXT_ARG(); + if (get_s64(&extension_time, *argv, 10)) { + PREV_ARG(); + break; + } + } else if (strcmp(*argv, "preemption") == 0) { + __u8 enable; + int i; + + for (i = 0; i < opt.num_tc; i++) { + NEXT_ARG(); + + if (get_u8(&enable, *argv, 0)) { + PREV_ARG(); + break; + } + + preemption |= enable ? BIT(i) : 0; + } + } else if (strcmp(*argv, "clockid") == 0) { + NEXT_ARG(); + if (clockid != CLOCKID_INVALID) { + fprintf(stderr, "taprio: duplicate \"clockid\" specification\n"); + return -1; + } + if (get_clockid(&clockid, *argv)) { + explain_clockid(*argv); + return -1; + } + } else if (strcmp(*argv, "help") == 0) { + explain(); + return -1; + } else { + fprintf(stderr, "Unknown argument\n"); + return -1; + } + argc--; argv++; + } + + tail = NLMSG_TAIL(n); + addattr_l(n, 1024, TCA_OPTIONS, NULL, 0); + + if (opt.num_tc > 0) + addattr_l(n, 1024, TCA_TAPRIO_ATTR_PRIOMAP, &opt, sizeof(opt)); + + if (preemption) + addattr_l(n, 1024, TCA_TAPRIO_ATTR_PREEMPT_MASK, &preemption, sizeof(preemption)); + + if (base_time) + addattr_l(n, 1024, TCA_TAPRIO_ATTR_SCHED_BASE_TIME, &base_time, sizeof(base_time)); + + if (cycle_time) + addattr_l(n, 1024, TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME, &cycle_time, sizeof(cycle_time)); + + if (extension_time) + addattr_l(n, 1024, TCA_TAPRIO_ATTR_SCHED_EXTENSION_TIME, &extension_time, sizeof(extension_time)); + + addattr_l(n, 1024, TCA_TAPRIO_ATTR_SCHED_CLOCKID, &clockid, sizeof(clockid)); + + if (sched_file) { + struct rtattr *entry_list; + entry_list = addattr_nest(n, 1024, TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST | NLA_F_NESTED); + + err = add_sched_list(sched_file, n); + if (err < 0) { + fprintf(stderr, "Could not read sched list from file\n"); + return -1; + } + + addattr_nest_end(n, entry_list); + } + + if (entry_index || entry_cmd || entry_gatemask || entry_interval) { + struct rtattr *entry, *entry_list; + + entry_list = addattr_nest(n, 1024, TCA_TAPRIO_ATTR_SCHED_SINGLE_ENTRY | NLA_F_NESTED); + entry = addattr_nest(n, 1024, TCA_TAPRIO_SCHED_ENTRY); + + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_INDEX, &entry_index, sizeof(entry_index)); + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_CMD, &entry_cmd, sizeof(entry_cmd)); + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_GATE_MASK, &entry_gatemask, sizeof(entry_gatemask)); + addattr_l(n, 1024, TCA_TAPRIO_SCHED_ENTRY_INTERVAL, &entry_interval, sizeof(entry_interval)); + + addattr_nest_end(n, entry); + addattr_nest_end(n, entry_list); + } + + tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; + + return 0; +} + +static const char *command_to_str(__u8 cmd) +{ + switch (cmd) { + case TC_TAPRIO_CMD_SET_GATES: + return "S"; + case TC_TAPRIO_CMD_SET_AND_HOLD: + return "H"; + case TC_TAPRIO_CMD_SET_AND_RELEASE: + return "R"; + default: + return "Invalid"; + } +} + +static int print_sched_list(FILE *f, struct rtattr *list) +{ + struct rtattr *item; + int rem; + + if (list == NULL) + return 0; + + rem = RTA_PAYLOAD(list); + + for (item = RTA_DATA(list); RTA_OK(item, rem); item = RTA_NEXT(item, rem)) { + struct rtattr *tb[TCA_TAPRIO_SCHED_ENTRY_MAX + 1]; + __u32 index = 0, gatemask = 0, interval = 0; + __u8 command = 0; + + parse_rtattr_nested(tb, TCA_TAPRIO_SCHED_ENTRY_MAX, item); + + if (tb[TCA_TAPRIO_SCHED_ENTRY_INDEX]) + index = rta_getattr_u32(tb[TCA_TAPRIO_SCHED_ENTRY_INDEX]); + + if (tb[TCA_TAPRIO_SCHED_ENTRY_CMD]) + command = rta_getattr_u8(tb[TCA_TAPRIO_SCHED_ENTRY_CMD]); + + if (tb[TCA_TAPRIO_SCHED_ENTRY_GATE_MASK]) + gatemask = rta_getattr_u32(tb[TCA_TAPRIO_SCHED_ENTRY_GATE_MASK]); + + if (tb[TCA_TAPRIO_SCHED_ENTRY_INTERVAL]) + interval = rta_getattr_u32(tb[TCA_TAPRIO_SCHED_ENTRY_INTERVAL]); + + fprintf(f, "\n index %u cmd %s gate-mask 0x%x interval %u", index, + command_to_str(command), gatemask, interval); + } + + return 0; +} + +static int taprio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) +{ + struct rtattr *tb[TCA_TAPRIO_ATTR_MAX + 1]; + struct tc_mqprio_qopt *qopt = 0; + __s64 cycle_time = 0, extension_time = 0, base_time = 0; + __s32 clockid = CLOCKID_INVALID; + __u32 preempt_mask = 0; + int i; + + if (opt == NULL) + return 0; + + parse_rtattr_nested(tb, TCA_TAPRIO_ATTR_MAX, opt); + + if (tb[TCA_TAPRIO_ATTR_PRIOMAP] == NULL) + return -1; + + qopt = RTA_DATA(tb[TCA_TAPRIO_ATTR_PRIOMAP]); + + fprintf(f, "tc %u map ", qopt->num_tc); + for (i = 0; i <= TC_PRIO_MAX; i++) + fprintf(f, "%u ", qopt->prio_tc_map[i]); + fprintf(f, "\n queues:"); + for (i = 0; i < qopt->num_tc; i++) + fprintf(f, "(%u:%u) ", qopt->offset[i], + qopt->offset[i] + qopt->count[i] - 1); + + if (tb[TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME]) + cycle_time = rta_getattr_s64(tb[TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME]); + + if (tb[TCA_TAPRIO_ATTR_SCHED_EXTENSION_TIME]) + extension_time = rta_getattr_s64(tb[TCA_TAPRIO_ATTR_SCHED_EXTENSION_TIME]); + + if (tb[TCA_TAPRIO_ATTR_SCHED_BASE_TIME]) + base_time = rta_getattr_s64(tb[TCA_TAPRIO_ATTR_SCHED_BASE_TIME]); + + if (tb[TCA_TAPRIO_ATTR_PREEMPT_MASK]) + preempt_mask = rta_getattr_s64(tb[TCA_TAPRIO_ATTR_PREEMPT_MASK]); + + if (tb[TCA_TAPRIO_ATTR_SCHED_CLOCKID]) + clockid = rta_getattr_s32(tb[TCA_TAPRIO_ATTR_SCHED_CLOCKID]); + + fprintf(f, "\n clockid %s ", get_clock_name(clockid)); + + fprintf(f, "\n base-time %lld cycle-time %lld extension-time %lld ", + base_time, cycle_time, extension_time); + + fprintf(f, "\n preempt-mask 0x%x ", preempt_mask); + + return print_sched_list(f, tb[TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST]); +} + +struct qdisc_util taprio_qdisc_util = { + .id = "taprio", + .parse_qopt = taprio_parse_opt, + .print_qopt = taprio_print_opt, +};