// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
/* Copyright 2020 NXP */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <linux/if_ether.h>
#include "utils.h"
#include "rt_names.h"
#include "tc_util.h"
#include "list.h"
#include <linux/tc_act/tc_gate.h>
struct gate_entry {
struct list_head list;
uint8_t gate_state;
uint32_t interval;
int32_t ipv;
int32_t maxoctets;
};
#define CLOCKID_INVALID (-1)
static const struct clockid_table {
const char *name;
clockid_t clockid;
} clockt_map[] = {
{ "REALTIME", CLOCK_REALTIME },
{ "TAI", CLOCK_TAI },
{ "BOOTTIME", CLOCK_BOOTTIME },
{ "MONOTONIC", CLOCK_MONOTONIC },
{ NULL }
};
static void explain(void)
{
fprintf(stderr,
"Usage: gate [ priority PRIO-SPEC ] [ base-time BASE-TIME ]\n"
" [ cycle-time CYCLE-TIME ]\n"
" [ cycle-time-ext CYCLE-TIME-EXT ]\n"
" [ clockid CLOCKID ] [flags FLAGS]\n"
" [ sched-entry GATE0 INTERVAL [ INTERNAL-PRIO-VALUE MAX-OCTETS ] ]\n"
" [ sched-entry GATE1 INTERVAL [ INTERNAL-PRIO-VALUE MAX-OCTETS ] ]\n"
" ......\n"
" [ sched-entry GATEn INTERVAL [ INTERNAL-PRIO-VALUE MAX-OCTETS ] ]\n"
" [ CONTROL ]\n"
" GATEn := open | close\n"
" INTERVAL : nanoseconds period of gate slot\n"
" INTERNAL-PRIO-VALUE : internal priority decide which\n"
" rx queue number direct to.\n"
" default to be -1 which means wildcard.\n"
" MAX-OCTETS : maximum number of MSDU octets that are\n"
" permitted to pas the gate during the\n"
" specified TimeInterval.\n"
" default to be -1 which means wildcard.\n"
" CONTROL := pipe | drop | continue | pass |\n"
" goto chain <CHAIN_INDEX>\n");
}
static void usage(void)
{
explain();
exit(-1);
}
static void explain_entry_format(void)
{
fprintf(stderr, "Usage: sched-entry <open | close> <interval> [ <interval ipv> <octets max bytes> ]\n");
}
static int parse_gate(struct action_util *a, int *argc_p, char ***argv_p,
int tca_id, struct nlmsghdr *n);
static int print_gate(struct action_util *au, FILE *f, struct rtattr *arg);
struct action_util gate_action_util = {
.id = "gate",
.parse_aopt = parse_gate,
.print_aopt = print_gate,
};
static int get_clockid(__s32 *val, const char *arg)
{
const struct clockid_table *c;
if (strcasestr(arg, "CLOCK_") != NULL)
arg += sizeof("CLOCK_") - 1;
for (c = clockt_map; 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 clockid_table *c;
for (c = clockt_map; c->name; c++) {
if (clockid == c->clockid)
return c->name;
}
return "invalid";
}
static int get_gate_state(__u8 *val, const char *arg)
{
if (!strcasecmp("OPEN", arg)) {
*val = 1;
return 0;
}
if (!strcasecmp("CLOSE", arg)) {
*val = 0;
return 0;
}
return -1;
}
static struct gate_entry *create_gate_entry(uint8_t gate_state,
uint32_t interval,
int32_t ipv,
int32_t maxoctets)
{
struct gate_entry *e;
e = calloc(1, sizeof(*e));
if (!e)
return NULL;
e->gate_state = gate_state;
e->interval = interval;
e->ipv = ipv;
e->maxoctets = maxoctets;
return e;
}
static int add_gate_list(struct list_head *gate_entries, struct nlmsghdr *n)
{
struct gate_entry *e;
list_for_each_entry(e, gate_entries, list) {
struct rtattr *a;
a = addattr_nest(n, 1024, TCA_GATE_ONE_ENTRY | NLA_F_NESTED);
if (e->gate_state)
addattr(n, MAX_MSG, TCA_GATE_ENTRY_GATE);
addattr_l(n, MAX_MSG, TCA_GATE_ENTRY_INTERVAL,
&e->interval, sizeof(e->interval));
addattr_l(n, MAX_MSG, TCA_GATE_ENTRY_IPV,
&e->ipv, sizeof(e->ipv));
addattr_l(n, MAX_MSG, TCA_GATE_ENTRY_MAX_OCTETS,
&e->maxoctets, sizeof(e->maxoctets));
addattr_nest_end(n, a);
}
return 0;
}
static void free_entries(struct list_head *gate_entries)
{
struct gate_entry *e, *n;
list_for_each_entry_safe(e, n, gate_entries, list) {
list_del(&e->list);
free(e);
}
}
static int parse_gate(struct action_util *a, int *argc_p, char ***argv_p,
int tca_id, struct nlmsghdr *n)
{
struct tc_gate parm = {.action = TC_ACT_PIPE};
struct list_head gate_entries;
__s32 clockid = CLOCKID_INVALID;
struct rtattr *tail, *nle;
char **argv = *argv_p;
int argc = *argc_p;
__s64 base_time = 0;
__s64 cycle_time = 0;
__s64 cycle_time_ext = 0;
int entry_num = 0;
char *invalidarg;
__u32 flags = 0;
int prio = -1;
int err;
if (matches(*argv, "gate") != 0)
return -1;
NEXT_ARG();
if (argc <= 0)
return -1;
INIT_LIST_HEAD(&gate_entries);
while (argc > 0) {
if (matches(*argv, "index") == 0) {
NEXT_ARG();
if (get_u32(&parm.index, *argv, 10)) {
invalidarg = "index";
goto err_arg;
}
} else if (matches(*argv, "priority") == 0) {
NEXT_ARG();
if (get_s32(&prio, *argv, 0)) {
invalidarg = "priority";
goto err_arg;
}
} else if (matches(*argv, "base-time") == 0) {
NEXT_ARG();
if (get_s64(&base_time, *argv, 10) &&
get_time64(&base_time, *argv)) {
invalidarg = "base-time";
goto err_arg;
}
} else if (matches(*argv, "cycle-time") == 0) {
NEXT_ARG();
if (get_s64(&cycle_time, *argv, 10) &&
get_time64(&cycle_time, *argv)) {
invalidarg = "cycle-time";
goto err_arg;
}
} else if (matches(*argv, "cycle-time-ext") == 0) {
NEXT_ARG();
if (get_s64(&cycle_time_ext, *argv, 10) &&
get_time64(&cycle_time_ext, *argv)) {
invalidarg = "cycle-time-ext";
goto err_arg;
}
} else if (matches(*argv, "clockid") == 0) {
NEXT_ARG();
if (get_clockid(&clockid, *argv)) {
invalidarg = "clockid";
goto err_arg;
}
} else if (matches(*argv, "flags") == 0) {
NEXT_ARG();
if (get_u32(&flags, *argv, 0)) {
invalidarg = "flags";
goto err_arg;
}
} else if (matches(*argv, "sched-entry") == 0) {
unsigned int maxoctets_uint = 0;
int32_t maxoctets = -1;
struct gate_entry *e;
uint8_t gate_state = 0;
__s64 interval_s64 = 0;
uint32_t interval = 0;
int32_t ipv = -1;
if (!NEXT_ARG_OK()) {
explain_entry_format();
fprintf(stderr, "\"sched-entry\" is incomplete\n");
free_entries(&gate_entries);
return -1;
}
NEXT_ARG();
if (get_gate_state(&gate_state, *argv)) {
explain_entry_format();
fprintf(stderr, "\"sched-entry\" is incomplete\n");
free_entries(&gate_entries);
return -1;
}
if (!NEXT_ARG_OK()) {
explain_entry_format();
fprintf(stderr, "\"sched-entry\" is incomplete\n");
free_entries(&gate_entries);
return -1;
}
NEXT_ARG();
if (get_u32(&interval, *argv, 0) &&
get_time64(&interval_s64, *argv)) {
explain_entry_format();
fprintf(stderr, "\"sched-entry\" is incomplete\n");
free_entries(&gate_entries);
return -1;
}
if (interval_s64 > UINT_MAX) {
fprintf(stderr, "\"interval\" is too large\n");
free_entries(&gate_entries);
return -1;
} else if (interval_s64) {
interval = interval_s64;
}
if (!NEXT_ARG_OK())
goto create_entry;
NEXT_ARG();
if (get_s32(&ipv, *argv, 0)) {
PREV_ARG();
goto create_entry;
}
if (!gate_state)
ipv = -1;
if (!NEXT_ARG_OK())
goto create_entry;
NEXT_ARG();
if (get_s32(&maxoctets, *argv, 0) &&
get_size(&maxoctets_uint, *argv))
PREV_ARG();
if (maxoctets_uint > INT_MAX) {
fprintf(stderr, "\"maxoctets\" is too large\n");
free_entries(&gate_entries);
return -1;
} else if (maxoctets_uint ) {
maxoctets = maxoctets_uint;
}
if (!gate_state)
maxoctets = -1;
create_entry:
e = create_gate_entry(gate_state, interval,
ipv, maxoctets);
if (!e) {
fprintf(stderr, "gate: not enough memory\n");
free_entries(&gate_entries);
return -1;
}
list_add_tail(&e->list, &gate_entries);
entry_num++;
} else if (matches(*argv, "help") == 0) {
usage();
} else {
break;
}
argc--;
argv++;
}
parse_action_control_dflt(&argc, &argv, &parm.action,
false, TC_ACT_PIPE);
if (!entry_num && !parm.index) {
fprintf(stderr, "gate: must add at least one entry\n");
return -1;
}
tail = addattr_nest(n, MAX_MSG, tca_id | NLA_F_NESTED);
addattr_l(n, MAX_MSG, TCA_GATE_PARMS, &parm, sizeof(parm));
if (prio != -1)
addattr_l(n, MAX_MSG, TCA_GATE_PRIORITY, &prio, sizeof(prio));
if (flags)
addattr_l(n, MAX_MSG, TCA_GATE_FLAGS, &flags, sizeof(flags));
if (base_time)
addattr_l(n, MAX_MSG, TCA_GATE_BASE_TIME,
&base_time, sizeof(base_time));
if (cycle_time)
addattr_l(n, MAX_MSG, TCA_GATE_CYCLE_TIME,
&cycle_time, sizeof(cycle_time));
if (cycle_time_ext)
addattr_l(n, MAX_MSG, TCA_GATE_CYCLE_TIME_EXT,
&cycle_time_ext, sizeof(cycle_time_ext));
if (clockid != CLOCKID_INVALID)
addattr_l(n, MAX_MSG, TCA_GATE_CLOCKID,
&clockid, sizeof(clockid));
nle = addattr_nest(n, MAX_MSG, TCA_GATE_ENTRY_LIST | NLA_F_NESTED);
err = add_gate_list(&gate_entries, n);
if (err < 0) {
fprintf(stderr, "Could not add entries to netlink message\n");
free_entries(&gate_entries);
return -1;
}
addattr_nest_end(n, nle);
addattr_nest_end(n, tail);
free_entries(&gate_entries);
*argc_p = argc;
*argv_p = argv;
return 0;
err_arg:
invarg(invalidarg, *argv);
free_entries(&gate_entries);
return -1;
}
static int print_gate_list(struct rtattr *list)
{
struct rtattr *item;
int rem;
rem = RTA_PAYLOAD(list);
print_string(PRINT_FP, NULL, "%s", _SL_);
print_string(PRINT_FP, NULL, "\tschedule:%s", _SL_);
open_json_array(PRINT_JSON, "schedule");
for (item = RTA_DATA(list);
RTA_OK(item, rem);
item = RTA_NEXT(item, rem)) {
struct rtattr *tb[TCA_GATE_ENTRY_MAX + 1];
__u32 index = 0, interval = 0;
__u8 gate_state = 0;
__s32 ipv = -1, maxoctets = -1;
SPRINT_BUF(buf);
parse_rtattr_nested(tb, TCA_GATE_ENTRY_MAX, item);
if (tb[TCA_GATE_ENTRY_INDEX])
index = rta_getattr_u32(tb[TCA_GATE_ENTRY_INDEX]);
if (tb[TCA_GATE_ENTRY_GATE])
gate_state = 1;
if (tb[TCA_GATE_ENTRY_INTERVAL])
interval = rta_getattr_u32(tb[TCA_GATE_ENTRY_INTERVAL]);
if (tb[TCA_GATE_ENTRY_IPV])
ipv = rta_getattr_s32(tb[TCA_GATE_ENTRY_IPV]);
if (tb[TCA_GATE_ENTRY_MAX_OCTETS])
maxoctets = rta_getattr_s32(tb[TCA_GATE_ENTRY_MAX_OCTETS]);
open_json_object(NULL);
print_uint(PRINT_ANY, "number", "\t number %4u", index);
print_string(PRINT_ANY, "gate_state", "\tgate-state %s ",
gate_state ? "open" : "close");
print_uint(PRINT_JSON, "interval", NULL, interval);
memset(buf, 0, sizeof(buf));
print_string(PRINT_FP, NULL, "\tinterval %s",
sprint_time64(interval, buf));
if (ipv != -1) {
print_uint(PRINT_ANY, "ipv", "\t ipv %-10u", ipv);
} else {
print_int(PRINT_JSON, "ipv", NULL, ipv);
print_string(PRINT_FP, NULL, "\t ipv %s", "wildcard");
}
if (maxoctets != -1) {
print_size(PRINT_ANY, "max_octets", "\t max-octets %s",
maxoctets);
} else {
print_string(PRINT_FP, NULL,
"\t max-octets %s", "wildcard");
print_int(PRINT_JSON, "max_octets", NULL, maxoctets);
}
close_json_object();
print_string(PRINT_FP, NULL, "%s", _SL_);
}
close_json_array(PRINT_ANY, "");
return 0;
}
static int print_gate(struct action_util *au, FILE *f, struct rtattr *arg)
{
struct tc_gate *parm;
struct rtattr *tb[TCA_GATE_MAX + 1];
__s32 clockid = CLOCKID_INVALID;
__s64 base_time = 0;
__s64 cycle_time = 0;
__s64 cycle_time_ext = 0;
SPRINT_BUF(buf);
int prio = -1;
if (arg == NULL)
return -1;
parse_rtattr_nested(tb, TCA_GATE_MAX, arg);
if (!tb[TCA_GATE_PARMS]) {
fprintf(stderr, "Missing gate parameters\n");
return -1;
}
print_string(PRINT_FP, NULL, "%s", "\n");
parm = RTA_DATA(tb[TCA_GATE_PARMS]);
if (tb[TCA_GATE_PRIORITY])
prio = rta_getattr_s32(tb[TCA_GATE_PRIORITY]);
if (prio != -1) {
print_int(PRINT_ANY, "priority", "\tpriority %-8d", prio);
} else {
print_string(PRINT_FP, NULL, "\tpriority %s", "wildcard");
print_int(PRINT_JSON, "priority", NULL, prio);
}
if (tb[TCA_GATE_CLOCKID])
clockid = rta_getattr_s32(tb[TCA_GATE_CLOCKID]);
print_string(PRINT_ANY, "clockid", "\tclockid %s",
get_clock_name(clockid));
if (tb[TCA_GATE_FLAGS]) {
__u32 flags;
flags = rta_getattr_u32(tb[TCA_GATE_FLAGS]);
print_0xhex(PRINT_ANY, "flags", "\tflags %#x", flags);
}
print_string(PRINT_FP, NULL, "%s", "\n");
if (tb[TCA_GATE_BASE_TIME])
base_time = rta_getattr_s64(tb[TCA_GATE_BASE_TIME]);
memset(buf, 0, sizeof(buf));
print_string(PRINT_FP, NULL, "\tbase-time %s",
sprint_time64(base_time, buf));
print_lluint(PRINT_JSON, "base_time", NULL, base_time);
if (tb[TCA_GATE_CYCLE_TIME])
cycle_time = rta_getattr_s64(tb[TCA_GATE_CYCLE_TIME]);
memset(buf, 0, sizeof(buf));
print_string(PRINT_FP, NULL,
"\tcycle-time %s", sprint_time64(cycle_time, buf));
print_lluint(PRINT_JSON, "cycle_time", NULL, cycle_time);
if (tb[TCA_GATE_CYCLE_TIME_EXT])
cycle_time_ext = rta_getattr_s64(tb[TCA_GATE_CYCLE_TIME_EXT]);
memset(buf, 0, sizeof(buf));
print_string(PRINT_FP, NULL, "\tcycle-time-ext %s",
sprint_time64(cycle_time_ext, buf));
print_lluint(PRINT_JSON, "cycle_time_ext", NULL, cycle_time_ext);
if (tb[TCA_GATE_ENTRY_LIST])
print_gate_list(tb[TCA_GATE_ENTRY_LIST]);
print_action_control(f, "\t", parm->action, "");
print_uint(PRINT_ANY, "index", "\n\t index %u", parm->index);
print_int(PRINT_ANY, "ref", " ref %d", parm->refcnt);
print_int(PRINT_ANY, "bind", " bind %d", parm->bindcnt);
if (show_stats) {
if (tb[TCA_GATE_TM]) {
struct tcf_t *tm = RTA_DATA(tb[TCA_GATE_TM]);
print_tm(f, tm);
}
}
print_string(PRINT_FP, NULL, "%s", "\n");
return 0;
}