From 1827694858b9ff5e326f75fd50783a8dfafdbc55 Mon Sep 17 00:00:00 2001 From: David Ahern Date: Wed, 10 Jul 2019 14:05:19 -0700 Subject: [PATCH 1/4] Import tc_mpls.h uapi header Import tc_mpls.h uapi header from kernel headers at commit: 1ff2f0fa450e ("net/mlx5e: Return in default case statement in tx_post_resync_params") Signed-off-by: David Ahern --- include/uapi/linux/tc_act/tc_mpls.h | 33 +++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 include/uapi/linux/tc_act/tc_mpls.h diff --git a/include/uapi/linux/tc_act/tc_mpls.h b/include/uapi/linux/tc_act/tc_mpls.h new file mode 100644 index 00000000..9360e952 --- /dev/null +++ b/include/uapi/linux/tc_act/tc_mpls.h @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* Copyright (C) 2019 Netronome Systems, Inc. */ + +#ifndef __LINUX_TC_MPLS_H +#define __LINUX_TC_MPLS_H + +#include + +#define TCA_MPLS_ACT_POP 1 +#define TCA_MPLS_ACT_PUSH 2 +#define TCA_MPLS_ACT_MODIFY 3 +#define TCA_MPLS_ACT_DEC_TTL 4 + +struct tc_mpls { + tc_gen; /* generic TC action fields. */ + int m_action; /* action of type TCA_MPLS_ACT_*. */ +}; + +enum { + TCA_MPLS_UNSPEC, + TCA_MPLS_TM, /* struct tcf_t; time values associated with action. */ + TCA_MPLS_PARMS, /* struct tc_mpls; action type and general TC fields. */ + TCA_MPLS_PAD, + TCA_MPLS_PROTO, /* be16; eth_type of pushed or next (for pop) header. */ + TCA_MPLS_LABEL, /* u32; MPLS label. Lower 20 bits are used. */ + TCA_MPLS_TC, /* u8; MPLS TC field. Lower 3 bits are used. */ + TCA_MPLS_TTL, /* u8; MPLS TTL field. Must not be 0. */ + TCA_MPLS_BOS, /* u8; MPLS BOS field. Either 1 or 0. */ + __TCA_MPLS_MAX, +}; +#define TCA_MPLS_MAX (__TCA_MPLS_MAX - 1) + +#endif From 11d7087a4ededf203c578912a64ada2324ee8e87 Mon Sep 17 00:00:00 2001 From: John Hurley Date: Wed, 10 Jul 2019 13:40:38 +0100 Subject: [PATCH 2/4] lib: add mpls_uc and mpls_mc as link layer protocol names Update the llproto_names array to allow users to reference the mpls protocol ids with the names 'mpls_uc' for unicast MPLS and 'mpls_mc' for multicast. Signed-off-by: John Hurley Reviewed-by: Jakub Kicinski Signed-off-by: David Ahern --- lib/ll_proto.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/ll_proto.c b/lib/ll_proto.c index 78c39616..2a0c1cb3 100644 --- a/lib/ll_proto.c +++ b/lib/ll_proto.c @@ -78,6 +78,8 @@ __PF(TIPC,tipc) __PF(AOE,aoe) __PF(8021Q,802.1Q) __PF(8021AD,802.1ad) +__PF(MPLS_UC,mpls_uc) +__PF(MPLS_MC,mpls_mc) { 0x8100, "802.1Q" }, { 0x88cc, "LLDP" }, From fb57b0920f06645df86986df05c5e4bbb6f5ee34 Mon Sep 17 00:00:00 2001 From: John Hurley Date: Wed, 10 Jul 2019 13:40:39 +0100 Subject: [PATCH 3/4] tc: add mpls actions Create a new action type for TC that allows the pushing, popping, and modifying of MPLS headers. Signed-off-by: John Hurley Reviewed-by: Jakub Kicinski Signed-off-by: David Ahern --- tc/Makefile | 1 + tc/m_mpls.c | 276 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 277 insertions(+) create mode 100644 tc/m_mpls.c diff --git a/tc/Makefile b/tc/Makefile index 60abddee..09ff3692 100644 --- a/tc/Makefile +++ b/tc/Makefile @@ -39,6 +39,7 @@ TCMODULES += q_drr.o TCMODULES += q_qfq.o TCMODULES += m_gact.o TCMODULES += m_mirred.o +TCMODULES += m_mpls.o TCMODULES += m_nat.o TCMODULES += m_pedit.o TCMODULES += m_ife.o diff --git a/tc/m_mpls.c b/tc/m_mpls.c new file mode 100644 index 00000000..4b1ec70e --- /dev/null +++ b/tc/m_mpls.c @@ -0,0 +1,276 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* Copyright (C) 2019 Netronome Systems, Inc. */ + +#include +#include +#include +#include +#include +#include + +#include "utils.h" +#include "rt_names.h" +#include "tc_util.h" + +static const char * const action_names[] = { + [TCA_MPLS_ACT_POP] = "pop", + [TCA_MPLS_ACT_PUSH] = "push", + [TCA_MPLS_ACT_MODIFY] = "modify", + [TCA_MPLS_ACT_DEC_TTL] = "dec_ttl", +}; + +static void explain(void) +{ + fprintf(stderr, + "Usage: mpls pop [ protocol MPLS_PROTO ]\n" + " mpls push [ protocol MPLS_PROTO ] [ label MPLS_LABEL ] [ tc MPLS_TC ]\n" + " [ ttl MPLS_TTL ] [ bos MPLS_BOS ] [CONTROL]\n" + " mpls modify [ label MPLS_LABEL ] [ tc MPLS_TC ] [ ttl MPLS_TTL ] [CONTROL]\n" + " for pop MPLS_PROTO is next header of packet - e.g. ip or mpls_uc\n" + " for push MPLS_PROTO is one of mpls_uc or mpls_mc\n" + " with default: mpls_uc\n" + " CONTROL := reclassify | pipe | drop | continue | pass |\n" + " goto chain \n"); +} + +static void usage(void) +{ + explain(); + exit(-1); +} + +static bool can_modify_mpls_fields(unsigned int action) +{ + return action == TCA_MPLS_ACT_PUSH || action == TCA_MPLS_ACT_MODIFY; +} + +static bool can_modify_ethtype(unsigned int action) +{ + return action == TCA_MPLS_ACT_PUSH || action == TCA_MPLS_ACT_POP; +} + +static bool is_valid_label(__u32 label) +{ + return label <= 0xfffff; +} + +static bool check_double_action(unsigned int action, const char *arg) +{ + if (!action) + return false; + + fprintf(stderr, + "Error: got \"%s\" but action already set to \"%s\"\n", + arg, action_names[action]); + explain(); + return true; +} + +static int parse_mpls(struct action_util *a, int *argc_p, char ***argv_p, + int tca_id, struct nlmsghdr *n) +{ + struct tc_mpls parm = {}; + __u32 label = 0xffffffff; + unsigned int action = 0; + char **argv = *argv_p; + struct rtattr *tail; + int argc = *argc_p; + __u16 proto = 0; + __u8 bos = 0xff; + __u8 tc = 0xff; + __u8 ttl = 0; + + if (matches(*argv, "mpls") != 0) + return -1; + + NEXT_ARG(); + + while (argc > 0) { + if (matches(*argv, "pop") == 0) { + if (check_double_action(action, *argv)) + return -1; + action = TCA_MPLS_ACT_POP; + } else if (matches(*argv, "push") == 0) { + if (check_double_action(action, *argv)) + return -1; + action = TCA_MPLS_ACT_PUSH; + } else if (matches(*argv, "modify") == 0) { + if (check_double_action(action, *argv)) + return -1; + action = TCA_MPLS_ACT_MODIFY; + } else if (matches(*argv, "dec_ttl") == 0) { + if (check_double_action(action, *argv)) + return -1; + action = TCA_MPLS_ACT_DEC_TTL; + } else if (matches(*argv, "label") == 0) { + if (!can_modify_mpls_fields(action)) + invarg("only valid for push/modify", *argv); + NEXT_ARG(); + if (get_u32(&label, *argv, 0) || !is_valid_label(label)) + invarg("label must be <=0xFFFFF", *argv); + } else if (matches(*argv, "tc") == 0) { + if (!can_modify_mpls_fields(action)) + invarg("only valid for push/modify", *argv); + NEXT_ARG(); + if (get_u8(&tc, *argv, 0) || (tc & ~0x7)) + invarg("tc field is 3 bits max", *argv); + } else if (matches(*argv, "ttl") == 0) { + if (!can_modify_mpls_fields(action)) + invarg("only valid for push/modify", *argv); + NEXT_ARG(); + if (get_u8(&ttl, *argv, 0) || !ttl) + invarg("ttl must be >0 and <=255", *argv); + } else if (matches(*argv, "bos") == 0) { + if (!can_modify_mpls_fields(action)) + invarg("only valid for push/modify", *argv); + NEXT_ARG(); + if (get_u8(&bos, *argv, 0) || (bos & ~0x1)) + invarg("bos must be 0 or 1", *argv); + } else if (matches(*argv, "protocol") == 0) { + if (!can_modify_ethtype(action)) + invarg("only valid for push/pop", *argv); + NEXT_ARG(); + if (ll_proto_a2n(&proto, *argv)) + invarg("protocol is invalid", *argv); + } else if (matches(*argv, "help") == 0) { + usage(); + } else { + break; + } + + NEXT_ARG_FWD(); + } + + if (!action) + incomplete_command(); + + parse_action_control_dflt(&argc, &argv, &parm.action, + false, TC_ACT_PIPE); + + if (argc) { + if (matches(*argv, "index") == 0) { + NEXT_ARG(); + if (get_u32(&parm.index, *argv, 10)) + invarg("illegal index", *argv); + NEXT_ARG_FWD(); + } + } + + if (action == TCA_MPLS_ACT_PUSH && !label) + missarg("label"); + + if (action == TCA_MPLS_ACT_PUSH && proto && + proto != htons(ETH_P_MPLS_UC) && proto != htons(ETH_P_MPLS_MC)) { + fprintf(stderr, + "invalid push protocol \"0x%04x\" - use mpls_(uc|mc)\n", + ntohs(proto)); + return -1; + } + + if (action == TCA_MPLS_ACT_POP && !proto) + missarg("protocol"); + + parm.m_action = action; + tail = addattr_nest(n, MAX_MSG, tca_id | NLA_F_NESTED); + addattr_l(n, MAX_MSG, TCA_MPLS_PARMS, &parm, sizeof(parm)); + if (label != 0xffffffff) + addattr_l(n, MAX_MSG, TCA_MPLS_LABEL, &label, sizeof(label)); + if (proto) + addattr_l(n, MAX_MSG, TCA_MPLS_PROTO, &proto, sizeof(proto)); + if (tc != 0xff) + addattr8(n, MAX_MSG, TCA_MPLS_TC, tc); + if (ttl) + addattr8(n, MAX_MSG, TCA_MPLS_TTL, ttl); + if (bos != 0xff) + addattr8(n, MAX_MSG, TCA_MPLS_BOS, bos); + addattr_nest_end(n, tail); + + *argc_p = argc; + *argv_p = argv; + return 0; +} + +static int print_mpls(struct action_util *au, FILE *f, struct rtattr *arg) +{ + struct rtattr *tb[TCA_MPLS_MAX + 1]; + struct tc_mpls *parm; + SPRINT_BUF(b1); + __u32 val; + + if (!arg) + return -1; + + parse_rtattr_nested(tb, TCA_MPLS_MAX, arg); + + if (!tb[TCA_MPLS_PARMS]) { + fprintf(stderr, "[NULL mpls parameters]\n"); + return -1; + } + parm = RTA_DATA(tb[TCA_MPLS_PARMS]); + + print_string(PRINT_ANY, "kind", "%s ", "mpls"); + print_string(PRINT_ANY, "mpls_action", " %s", + action_names[parm->m_action]); + + switch (parm->m_action) { + case TCA_MPLS_ACT_POP: + if (tb[TCA_MPLS_PROTO]) { + __u16 proto; + + proto = rta_getattr_u16(tb[TCA_MPLS_PROTO]); + print_string(PRINT_ANY, "protocol", " protocol %s", + ll_proto_n2a(proto, b1, sizeof(b1))); + } + break; + case TCA_MPLS_ACT_PUSH: + if (tb[TCA_MPLS_PROTO]) { + __u16 proto; + + proto = rta_getattr_u16(tb[TCA_MPLS_PROTO]); + print_string(PRINT_ANY, "protocol", " protocol %s", + ll_proto_n2a(proto, b1, sizeof(b1))); + } + /* Fallthrough */ + case TCA_MPLS_ACT_MODIFY: + if (tb[TCA_MPLS_LABEL]) { + val = rta_getattr_u32(tb[TCA_MPLS_LABEL]); + print_uint(PRINT_ANY, "label", " label %u", val); + } + if (tb[TCA_MPLS_TC]) { + val = rta_getattr_u8(tb[TCA_MPLS_TC]); + print_uint(PRINT_ANY, "tc", " tc %u", val); + } + if (tb[TCA_MPLS_BOS]) { + val = rta_getattr_u8(tb[TCA_MPLS_BOS]); + print_uint(PRINT_ANY, "bos", " bos %u", val); + } + if (tb[TCA_MPLS_TTL]) { + val = rta_getattr_u8(tb[TCA_MPLS_TTL]); + print_uint(PRINT_ANY, "ttl", " ttl %u", val); + } + break; + } + print_action_control(f, " ", 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_MPLS_TM]) { + struct tcf_t *tm = RTA_DATA(tb[TCA_MPLS_TM]); + + print_tm(f, tm); + } + } + + print_string(PRINT_FP, NULL, "%s", _SL_); + + return 0; +} + +struct action_util mpls_action_util = { + .id = "mpls", + .parse_aopt = parse_mpls, + .print_aopt = print_mpls, +}; From 3b810b3b9ac4261c23019a8bd2caf8a6de76af17 Mon Sep 17 00:00:00 2001 From: John Hurley Date: Wed, 10 Jul 2019 13:40:40 +0100 Subject: [PATCH 4/4] man: update man pages for TC MPLS actions Add a man page describing the newly added TC mpls manipulation actions. Signed-off-by: John Hurley Reviewed-by: Jakub Kicinski Signed-off-by: David Ahern --- man/man8/tc-mpls.8 | 156 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 156 insertions(+) create mode 100644 man/man8/tc-mpls.8 diff --git a/man/man8/tc-mpls.8 b/man/man8/tc-mpls.8 new file mode 100644 index 00000000..84ef2ef1 --- /dev/null +++ b/man/man8/tc-mpls.8 @@ -0,0 +1,156 @@ +.TH "MPLS manipulation action in tc" 8 "22 May 2019" "iproute2" "Linux" + +.SH NAME +mpls - mpls manipulation module +.SH SYNOPSIS +.in +8 +.ti -8 +.BR tc " ... " "action mpls" " { " +.IR POP " | " PUSH " | " MODIFY " | " +.BR dec_ttl " } [ " +.IR CONTROL " ]" + +.ti -8 +.IR POP " := " +.BR pop " " protocol +.IR MPLS_PROTO + +.ti -8 +.IR PUSH " := " +.BR push " [ " protocol +.IR MPLS_PROTO " ]" +.RB " [ " tc +.IR MPLS_TC " ] " +.RB " [ " ttl +.IR MPLS_TTL " ] " +.RB " [ " bos +.IR MPLS_BOS " ] " +.BI label " MPLS_LABEL" + +.ti -8 +.IR MODIFY " := " +.BR modify " [ " label +.IR MPLS_LABEL " ]" +.RB " [ " tc +.IR MPLS_TC " ] " +.RB " [ " ttl +.IR MPLS_TTL " ] " + +.ti -8 +.IR CONTROL " := { " +.BR reclassify " | " pipe " | " drop " | " continue " | " pass " | " goto " " chain " " CHAIN_INDEX " }" +.SH DESCRIPTION +The +.B mpls +action performs mpls encapsulation or decapsulation on a packet, reflected by the +operation modes +.IR POP ", " PUSH ", " MODIFY " and " DEC_TTL . +The +.I POP +mode requires the ethertype of the header that follows the MPLS header (e.g. +IPv4 or another MPLS). It will remove the outer MPLS header and replace the +ethertype in the MAC header with that passed. The +.IR PUSH " and " MODIFY +modes update the current MPLS header information or add a new header. +.IR PUSH +requires at least an +.IR MPLS_LABEL ". " +.I DEC_TTL +requires no arguments and simply subtracts 1 from the MPLS header TTL field. + +.SH OPTIONS +.TP +.B pop +Decapsulation mode. Requires the protocol of the next header. +.TP +.B push +Encapsulation mode. Requires at least the +.B label +option. +.TP +.B modify +Replace mode. Existing MPLS tag is replaced. +.BR label ", " +.BR tc ", " +and +.B ttl +are all optional. +.TP +.B dec_ttl +Decrement the TTL field on the outer most MPLS header. +.TP +.BI label " MPLS_LABEL" +Specify the MPLS LABEL for the outer MPLS header. +.I MPLS_LABEL +is an unsigned 20bit integer, the format is detected automatically (e.g. prefix +with +.RB ' 0x ' +for hexadecimal interpretation, etc.). +.TP +.BI protocol " MPLS_PROTO" +Choose the protocol to use. For push actions this must be +.BR mpls_uc " or " mpls_mc " (" mpls_uc +is the default). For pop actions it should be the protocol of the next header. +This option cannot be used with modify. +.TP +.BI tc " MPLS_TC" +Choose the TC value for the outer MPLS header. Decimal number in range of 0-7. +Defaults to 0. +.TP +.BI ttl " MPLS_TTL" +Choose the TTL value for the outer MPLS header. Number in range of 0-255. A +non-zero default value will be selected if this is not explicitly set. +.TP +.BI bos " MPLS_BOS" +Manually configure the bottom of stack bit for an MPLS header push. The default +is for TC to automatically set (or unset) the bit based on the next header of +the packet. +.TP +.I CONTROL +How to continue after executing this action. +.RS +.TP +.B reclassify +Restarts classification by jumping back to the first filter attached to this +action's parent. +.TP +.B pipe +Continue with the next action, this is the default. +.TP +.B drop +Packet will be dropped without running further actions. +.TP +.B continue +Continue classification with next filter in line. +.TP +.B pass +Return to calling qdisc for packet processing. This ends the classification +process. +.RE +.SH EXAMPLES +The following example encapsulates incoming IP packets on eth0 into MPLS with +a label 123 and sends them out eth1: + +.RS +.EX +#tc qdisc add dev eth0 handle ffff: ingress +#tc filter add dev eth0 protocol ip parent ffff: flower \\ + action mpls push protocol mpls_uc label 123 \\ + action mirred egress redirect dev eth1 +.EE +.RE + +In this example, incoming MPLS unicast packets on eth0 are decapsulated and to +ip packets and output to eth1: + +.RS +.EX +#tc qdisc add dev eth0 handle ffff: ingress +#tc filter add dev eth0 protocol mpls_uc parent ffff: flower \\ + action mpls pop protocol ipv4 \\ + action mirred egress redirect dev eth0 +.EE +.RE + +.SH SEE ALSO +.BR tc (8)