net/mpls/mpls_iptunnel.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * mpls tunnels An implementation mpls tunnels using the light weight tunnel
0004  *      infrastructure
0005  *
0006  * Authors: Roopa Prabhu, <roopa@cumulusnetworks.com>
0007  */
0008 #include <linux/types.h>
0009 #include <linux/skbuff.h>
0010 #include <linux/net.h>
0011 #include <linux/module.h>
0012 #include <linux/mpls.h>
0013 #include <linux/vmalloc.h>
0014 #include <net/ip.h>
0015 #include <net/dst.h>
0016 #include <net/lwtunnel.h>
0017 #include <net/netevent.h>
0018 #include <net/netns/generic.h>
0019 #include <net/ip6_fib.h>
0020 #include <net/route.h>
0021 #include <net/mpls_iptunnel.h>
0022 #include <linux/mpls_iptunnel.h>
0023 #include "internal.h"
0024
0025 static const struct nla_policy mpls_iptunnel_policy[MPLS_IPTUNNEL_MAX + 1] = {
0026     [MPLS_IPTUNNEL_DST] = { .len = sizeof(u32) },
0027     [MPLS_IPTUNNEL_TTL] = { .type = NLA_U8 },
0028 };
0029
0030 static unsigned int mpls_encap_size(struct mpls_iptunnel_encap *en)
0031 {
0032     /* The size of the layer 2.5 labels to be added for this route */
0033     return en->labels * sizeof(struct mpls_shim_hdr);
0034 }
0035
0036 static int mpls_xmit(struct sk_buff *skb)
0037 {
0038     struct mpls_iptunnel_encap *tun_encap_info;
0039     struct mpls_shim_hdr *hdr;
0040     struct net_device *out_dev;
0041     unsigned int hh_len;
0042     unsigned int new_header_size;
0043     unsigned int mtu;
0044     struct dst_entry *dst = skb_dst(skb);
0045     struct rtable *rt = NULL;
0046     struct rt6_info *rt6 = NULL;
0047     struct mpls_dev *out_mdev;
0048     struct net *net;
0049     int err = 0;
0050     bool bos;
0051     int i;
0052     unsigned int ttl;
0053
0054     /* Find the output device */
0055     out_dev = dst->dev;
0056     net = dev_net(out_dev);
0057
0058     skb_orphan(skb);
0059
0060     if (!mpls_output_possible(out_dev) ||
0061         !dst->lwtstate || skb_warn_if_lro(skb))
0062         goto drop;
0063
0064     skb_forward_csum(skb);
0065
0066     tun_encap_info = mpls_lwtunnel_encap(dst->lwtstate);
0067
0068     /* Obtain the ttl using the following set of rules.
0069      *
0070      * LWT ttl propagation setting:
0071      *  - disabled => use default TTL value from LWT
0072      *  - enabled  => use TTL value from IPv4/IPv6 header
0073      *  - default  =>
0074      *   Global ttl propagation setting:
0075      *    - disabled => use default TTL value from global setting
0076      *    - enabled => use TTL value from IPv4/IPv6 header
0077      */
0078     if (dst->ops->family == AF_INET) {
0079         if (tun_encap_info->ttl_propagate == MPLS_TTL_PROP_DISABLED)
0080             ttl = tun_encap_info->default_ttl;
0081         else if (tun_encap_info->ttl_propagate == MPLS_TTL_PROP_DEFAULT &&
0082              !net->mpls.ip_ttl_propagate)
0083             ttl = net->mpls.default_ttl;
0084         else
0085             ttl = ip_hdr(skb)->ttl;
0086         rt = (struct rtable *)dst;
0087     } else if (dst->ops->family == AF_INET6) {
0088         if (tun_encap_info->ttl_propagate == MPLS_TTL_PROP_DISABLED)
0089             ttl = tun_encap_info->default_ttl;
0090         else if (tun_encap_info->ttl_propagate == MPLS_TTL_PROP_DEFAULT &&
0091              !net->mpls.ip_ttl_propagate)
0092             ttl = net->mpls.default_ttl;
0093         else
0094             ttl = ipv6_hdr(skb)->hop_limit;
0095         rt6 = (struct rt6_info *)dst;
0096     } else {
0097         goto drop;
0098     }
0099
0100     /* Verify the destination can hold the packet */
0101     new_header_size = mpls_encap_size(tun_encap_info);
0102     mtu = mpls_dev_mtu(out_dev);
0103     if (mpls_pkt_too_big(skb, mtu - new_header_size))
0104         goto drop;
0105
0106     hh_len = LL_RESERVED_SPACE(out_dev);
0107     if (!out_dev->header_ops)
0108         hh_len = 0;
0109
0110     /* Ensure there is enough space for the headers in the skb */
0111     if (skb_cow(skb, hh_len + new_header_size))
0112         goto drop;
0113
0114     skb_set_inner_protocol(skb, skb->protocol);
0115     skb_reset_inner_network_header(skb);
0116
0117     skb_push(skb, new_header_size);
0118
0119     skb_reset_network_header(skb);
0120
0121     skb->dev = out_dev;
0122     skb->protocol = htons(ETH_P_MPLS_UC);
0123
0124     /* Push the new labels */
0125     hdr = mpls_hdr(skb);
0126     bos = true;
0127     for (i = tun_encap_info->labels - 1; i >= 0; i--) {
0128         hdr[i] = mpls_entry_encode(tun_encap_info->label[i],
0129                        ttl, 0, bos);
0130         bos = false;
0131     }
0132
0133     mpls_stats_inc_outucastpkts(out_dev, skb);
0134
0135     if (rt) {
0136         if (rt->rt_gw_family == AF_INET6)
0137             err = neigh_xmit(NEIGH_ND_TABLE, out_dev, &rt->rt_gw6,
0138                      skb);
0139         else
0140             err = neigh_xmit(NEIGH_ARP_TABLE, out_dev, &rt->rt_gw4,
0141                      skb);
0142     } else if (rt6) {
0143         if (ipv6_addr_v4mapped(&rt6->rt6i_gateway)) {
0144             /* 6PE (RFC 4798) */
0145             err = neigh_xmit(NEIGH_ARP_TABLE, out_dev, &rt6->rt6i_gateway.s6_addr32[3],
0146                      skb);
0147         } else
0148             err = neigh_xmit(NEIGH_ND_TABLE, out_dev, &rt6->rt6i_gateway,
0149                      skb);
0150     }
0151     if (err)
0152         net_dbg_ratelimited("%s: packet transmission failed: %d\n",
0153                     __func__, err);
0154
0155     return LWTUNNEL_XMIT_DONE;
0156
0157 drop:
0158     out_mdev = out_dev ? mpls_dev_get(out_dev) : NULL;
0159     if (out_mdev)
0160         MPLS_INC_STATS(out_mdev, tx_errors);
0161     kfree_skb(skb);
0162     return -EINVAL;
0163 }
0164
0165 static int mpls_build_state(struct net *net, struct nlattr *nla,
0166                 unsigned int family, const void *cfg,
0167                 struct lwtunnel_state **ts,
0168                 struct netlink_ext_ack *extack)
0169 {
0170     struct mpls_iptunnel_encap *tun_encap_info;
0171     struct nlattr *tb[MPLS_IPTUNNEL_MAX + 1];
0172     struct lwtunnel_state *newts;
0173     u8 n_labels;
0174     int ret;
0175
0176     ret = nla_parse_nested_deprecated(tb, MPLS_IPTUNNEL_MAX, nla,
0177                       mpls_iptunnel_policy, extack);
0178     if (ret < 0)
0179         return ret;
0180
0181     if (!tb[MPLS_IPTUNNEL_DST]) {
0182         NL_SET_ERR_MSG(extack, "MPLS_IPTUNNEL_DST attribute is missing");
0183         return -EINVAL;
0184     }
0185
0186     /* determine number of labels */
0187     if (nla_get_labels(tb[MPLS_IPTUNNEL_DST], MAX_NEW_LABELS,
0188                &n_labels, NULL, extack))
0189         return -EINVAL;
0190
0191     newts = lwtunnel_state_alloc(struct_size(tun_encap_info, label,
0192                          n_labels));
0193     if (!newts)
0194         return -ENOMEM;
0195
0196     tun_encap_info = mpls_lwtunnel_encap(newts);
0197     ret = nla_get_labels(tb[MPLS_IPTUNNEL_DST], n_labels,
0198                  &tun_encap_info->labels, tun_encap_info->label,
0199                  extack);
0200     if (ret)
0201         goto errout;
0202
0203     tun_encap_info->ttl_propagate = MPLS_TTL_PROP_DEFAULT;
0204
0205     if (tb[MPLS_IPTUNNEL_TTL]) {
0206         tun_encap_info->default_ttl = nla_get_u8(tb[MPLS_IPTUNNEL_TTL]);
0207         /* TTL 0 implies propagate from IP header */
0208         tun_encap_info->ttl_propagate = tun_encap_info->default_ttl ?
0209             MPLS_TTL_PROP_DISABLED :
0210             MPLS_TTL_PROP_ENABLED;
0211     }
0212
0213     newts->type = LWTUNNEL_ENCAP_MPLS;
0214     newts->flags |= LWTUNNEL_STATE_XMIT_REDIRECT;
0215     newts->headroom = mpls_encap_size(tun_encap_info);
0216
0217     *ts = newts;
0218
0219     return 0;
0220
0221 errout:
0222     kfree(newts);
0223     *ts = NULL;
0224
0225     return ret;
0226 }
0227
0228 static int mpls_fill_encap_info(struct sk_buff *skb,
0229                 struct lwtunnel_state *lwtstate)
0230 {
0231     struct mpls_iptunnel_encap *tun_encap_info;
0232
0233     tun_encap_info = mpls_lwtunnel_encap(lwtstate);
0234
0235     if (nla_put_labels(skb, MPLS_IPTUNNEL_DST, tun_encap_info->labels,
0236                tun_encap_info->label))
0237         goto nla_put_failure;
0238
0239     if (tun_encap_info->ttl_propagate != MPLS_TTL_PROP_DEFAULT &&
0240         nla_put_u8(skb, MPLS_IPTUNNEL_TTL, tun_encap_info->default_ttl))
0241         goto nla_put_failure;
0242
0243     return 0;
0244
0245 nla_put_failure:
0246     return -EMSGSIZE;
0247 }
0248
0249 static int mpls_encap_nlsize(struct lwtunnel_state *lwtstate)
0250 {
0251     struct mpls_iptunnel_encap *tun_encap_info;
0252     int nlsize;
0253
0254     tun_encap_info = mpls_lwtunnel_encap(lwtstate);
0255
0256     nlsize = nla_total_size(tun_encap_info->labels * 4);
0257
0258     if (tun_encap_info->ttl_propagate != MPLS_TTL_PROP_DEFAULT)
0259         nlsize += nla_total_size(1);
0260
0261     return nlsize;
0262 }
0263
0264 static int mpls_encap_cmp(struct lwtunnel_state *a, struct lwtunnel_state *b)
0265 {
0266     struct mpls_iptunnel_encap *a_hdr = mpls_lwtunnel_encap(a);
0267     struct mpls_iptunnel_encap *b_hdr = mpls_lwtunnel_encap(b);
0268     int l;
0269
0270     if (a_hdr->labels != b_hdr->labels ||
0271         a_hdr->ttl_propagate != b_hdr->ttl_propagate ||
0272         a_hdr->default_ttl != b_hdr->default_ttl)
0273         return 1;
0274
0275     for (l = 0; l < a_hdr->labels; l++)
0276         if (a_hdr->label[l] != b_hdr->label[l])
0277             return 1;
0278     return 0;
0279 }
0280
0281 static const struct lwtunnel_encap_ops mpls_iptun_ops = {
0282     .build_state = mpls_build_state,
0283     .xmit = mpls_xmit,
0284     .fill_encap = mpls_fill_encap_info,
0285     .get_encap_size = mpls_encap_nlsize,
0286     .cmp_encap = mpls_encap_cmp,
0287     .owner = THIS_MODULE,
0288 };
0289
0290 static int __init mpls_iptunnel_init(void)
0291 {
0292     return lwtunnel_encap_add_ops(&mpls_iptun_ops, LWTUNNEL_ENCAP_MPLS);
0293 }
0294 module_init(mpls_iptunnel_init);
0295
0296 static void __exit mpls_iptunnel_exit(void)
0297 {
0298     lwtunnel_encap_del_ops(&mpls_iptun_ops, LWTUNNEL_ENCAP_MPLS);
0299 }
0300 module_exit(mpls_iptunnel_exit);
0301
0302 MODULE_ALIAS_RTNL_LWT(MPLS);
0303 MODULE_SOFTDEP("post: mpls_gso");
0304 MODULE_DESCRIPTION("MultiProtocol Label Switching IP Tunnels");
0305 MODULE_LICENSE("GPL v2");