mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-24 21:24:00 +08:00
Merge branch 'basic-mpls-support'
Eric W. Biederman says: ==================== Basic MPLS support take 2 On top of my two pending neighbour table prep patches here is the mpls support refactored to use them, and edited to not drop routes when an interface goes down. Additionally the addition of RTA_LLGATEWAY has been replaced with the addtion of RTA_VIA. RTA_VIA being an attribute that includes the address family as well as the address of the next hop. MPLS is at it's heart simple and I have endeavoured to maintain that simplicity in my implemenation. This is an implementation of a RFC3032 forwarding engine, and basic MPLS egress logic. Which should make linux sufficient to be a mpls forwarding node or to be a LSA (Label Switched Router) as it says in all of the MPLS documents. The ingress support will follow but it deserves it's own discussion so I am pushing it separately. ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
commit
27db730c4f
20
Documentation/networking/mpls-sysctl.txt
Normal file
20
Documentation/networking/mpls-sysctl.txt
Normal file
@ -0,0 +1,20 @@
|
||||
/proc/sys/net/mpls/* Variables:
|
||||
|
||||
platform_labels - INTEGER
|
||||
Number of entries in the platform label table. It is not
|
||||
possible to configure forwarding for label values equal to or
|
||||
greater than the number of platform labels.
|
||||
|
||||
A dense utliziation of the entries in the platform label table
|
||||
is possible and expected aas the platform labels are locally
|
||||
allocated.
|
||||
|
||||
If the number of platform label table entries is set to 0 no
|
||||
label will be recognized by the kernel and mpls forwarding
|
||||
will be disabled.
|
||||
|
||||
Reducing this value will remove all label routing entries that
|
||||
no longer fit in the table.
|
||||
|
||||
Possible values: 0 - 1048575
|
||||
Default: 0
|
@ -181,6 +181,7 @@ struct ucred {
|
||||
#define AF_WANPIPE 25 /* Wanpipe API Sockets */
|
||||
#define AF_LLC 26 /* Linux LLC */
|
||||
#define AF_IB 27 /* Native InfiniBand address */
|
||||
#define AF_MPLS 28 /* MPLS */
|
||||
#define AF_CAN 29 /* Controller Area Network */
|
||||
#define AF_TIPC 30 /* TIPC sockets */
|
||||
#define AF_BLUETOOTH 31 /* Bluetooth sockets */
|
||||
@ -226,6 +227,7 @@ struct ucred {
|
||||
#define PF_WANPIPE AF_WANPIPE
|
||||
#define PF_LLC AF_LLC
|
||||
#define PF_IB AF_IB
|
||||
#define PF_MPLS AF_MPLS
|
||||
#define PF_CAN AF_CAN
|
||||
#define PF_TIPC AF_TIPC
|
||||
#define PF_BLUETOOTH AF_BLUETOOTH
|
||||
|
@ -26,6 +26,7 @@
|
||||
#endif
|
||||
#include <net/netns/nftables.h>
|
||||
#include <net/netns/xfrm.h>
|
||||
#include <net/netns/mpls.h>
|
||||
#include <linux/ns_common.h>
|
||||
|
||||
struct user_namespace;
|
||||
@ -129,6 +130,9 @@ struct net {
|
||||
#endif
|
||||
#if IS_ENABLED(CONFIG_IP_VS)
|
||||
struct netns_ipvs *ipvs;
|
||||
#endif
|
||||
#if IS_ENABLED(CONFIG_MPLS)
|
||||
struct netns_mpls mpls;
|
||||
#endif
|
||||
struct sock *diag_nlsk;
|
||||
atomic_t fnhe_genid;
|
||||
|
17
include/net/netns/mpls.h
Normal file
17
include/net/netns/mpls.h
Normal file
@ -0,0 +1,17 @@
|
||||
/*
|
||||
* mpls in net namespaces
|
||||
*/
|
||||
|
||||
#ifndef __NETNS_MPLS_H__
|
||||
#define __NETNS_MPLS_H__
|
||||
|
||||
struct mpls_route;
|
||||
struct ctl_table_header;
|
||||
|
||||
struct netns_mpls {
|
||||
size_t platform_labels;
|
||||
struct mpls_route __rcu * __rcu *platform_label;
|
||||
struct ctl_table_header *ctl;
|
||||
};
|
||||
|
||||
#endif /* __NETNS_MPLS_H__ */
|
@ -303,6 +303,8 @@ enum rtattr_type_t {
|
||||
RTA_TABLE,
|
||||
RTA_MARK,
|
||||
RTA_MFC_STATS,
|
||||
RTA_VIA,
|
||||
RTA_NEWDST,
|
||||
__RTA_MAX
|
||||
};
|
||||
|
||||
@ -344,6 +346,12 @@ struct rtnexthop {
|
||||
#define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
|
||||
#define RTNH_DATA(rtnh) ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
|
||||
|
||||
/* RTA_VIA */
|
||||
struct rtvia {
|
||||
__kernel_sa_family_t rtvia_family;
|
||||
__u8 rtvia_addr[0];
|
||||
};
|
||||
|
||||
/* RTM_CACHEINFO */
|
||||
|
||||
struct rta_cacheinfo {
|
||||
@ -623,6 +631,8 @@ enum rtnetlink_groups {
|
||||
#define RTNLGRP_IPV6_NETCONF RTNLGRP_IPV6_NETCONF
|
||||
RTNLGRP_MDB,
|
||||
#define RTNLGRP_MDB RTNLGRP_MDB
|
||||
RTNLGRP_MPLS_ROUTE,
|
||||
#define RTNLGRP_MPLS_ROUTE RTNLGRP_MPLS_ROUTE
|
||||
__RTNLGRP_MAX
|
||||
};
|
||||
#define RTNLGRP_MAX (__RTNLGRP_MAX - 1)
|
||||
|
@ -69,7 +69,7 @@ obj-$(CONFIG_BATMAN_ADV) += batman-adv/
|
||||
obj-$(CONFIG_NFC) += nfc/
|
||||
obj-$(CONFIG_OPENVSWITCH) += openvswitch/
|
||||
obj-$(CONFIG_VSOCKETS) += vmw_vsock/
|
||||
obj-$(CONFIG_NET_MPLS_GSO) += mpls/
|
||||
obj-$(CONFIG_MPLS) += mpls/
|
||||
obj-$(CONFIG_HSR) += hsr/
|
||||
ifneq ($(CONFIG_NET_SWITCHDEV),)
|
||||
obj-y += switchdev/
|
||||
|
@ -1,9 +1,30 @@
|
||||
#
|
||||
# MPLS configuration
|
||||
#
|
||||
|
||||
menuconfig MPLS
|
||||
tristate "MultiProtocol Label Switching"
|
||||
default n
|
||||
---help---
|
||||
MultiProtocol Label Switching routes packets through logical
|
||||
circuits. Originally conceved as a way of routing packets at
|
||||
hardware speeds (before hardware was capable of routing ipv4 packets),
|
||||
MPLS remains as simple way of making tunnels.
|
||||
|
||||
If you have not heard of MPLS you probably want to say N here.
|
||||
|
||||
if MPLS
|
||||
|
||||
config NET_MPLS_GSO
|
||||
tristate "MPLS: GSO support"
|
||||
bool "MPLS: GSO support"
|
||||
help
|
||||
This is helper module to allow segmentation of non-MPLS GSO packets
|
||||
that have had MPLS stack entries pushed onto them and thus
|
||||
become MPLS GSO packets.
|
||||
|
||||
config MPLS_ROUTING
|
||||
bool "MPLS: routing support"
|
||||
help
|
||||
Add support for forwarding of mpls packets.
|
||||
|
||||
endif # MPLS
|
||||
|
@ -2,3 +2,4 @@
|
||||
# Makefile for MPLS.
|
||||
#
|
||||
obj-$(CONFIG_NET_MPLS_GSO) += mpls_gso.o
|
||||
obj-$(CONFIG_MPLS_ROUTING) += af_mpls.o
|
||||
|
974
net/mpls/af_mpls.c
Normal file
974
net/mpls/af_mpls.c
Normal file
@ -0,0 +1,974 @@
|
||||
#include <linux/types.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/socket.h>
|
||||
#include <linux/sysctl.h>
|
||||
#include <linux/net.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/if_arp.h>
|
||||
#include <linux/ipv6.h>
|
||||
#include <linux/mpls.h>
|
||||
#include <net/ip.h>
|
||||
#include <net/dst.h>
|
||||
#include <net/sock.h>
|
||||
#include <net/arp.h>
|
||||
#include <net/ip_fib.h>
|
||||
#include <net/netevent.h>
|
||||
#include <net/netns/generic.h>
|
||||
#include "internal.h"
|
||||
|
||||
#define LABEL_NOT_SPECIFIED (1<<20)
|
||||
#define MAX_NEW_LABELS 2
|
||||
|
||||
/* This maximum ha length copied from the definition of struct neighbour */
|
||||
#define MAX_VIA_ALEN (ALIGN(MAX_ADDR_LEN, sizeof(unsigned long)))
|
||||
|
||||
struct mpls_route { /* next hop label forwarding entry */
|
||||
struct net_device *rt_dev;
|
||||
struct rcu_head rt_rcu;
|
||||
u32 rt_label[MAX_NEW_LABELS];
|
||||
u8 rt_protocol; /* routing protocol that set this entry */
|
||||
u8 rt_labels:2,
|
||||
rt_via_alen:6;
|
||||
unsigned short rt_via_family;
|
||||
u8 rt_via[0];
|
||||
};
|
||||
|
||||
static int zero = 0;
|
||||
static int label_limit = (1 << 20) - 1;
|
||||
|
||||
static void rtmsg_lfib(int event, u32 label, struct mpls_route *rt,
|
||||
struct nlmsghdr *nlh, struct net *net, u32 portid,
|
||||
unsigned int nlm_flags);
|
||||
|
||||
static struct mpls_route *mpls_route_input_rcu(struct net *net, unsigned index)
|
||||
{
|
||||
struct mpls_route *rt = NULL;
|
||||
|
||||
if (index < net->mpls.platform_labels) {
|
||||
struct mpls_route __rcu **platform_label =
|
||||
rcu_dereference(net->mpls.platform_label);
|
||||
rt = rcu_dereference(platform_label[index]);
|
||||
}
|
||||
return rt;
|
||||
}
|
||||
|
||||
static bool mpls_output_possible(const struct net_device *dev)
|
||||
{
|
||||
return dev && (dev->flags & IFF_UP) && netif_carrier_ok(dev);
|
||||
}
|
||||
|
||||
static unsigned int mpls_rt_header_size(const struct mpls_route *rt)
|
||||
{
|
||||
/* The size of the layer 2.5 labels to be added for this route */
|
||||
return rt->rt_labels * sizeof(struct mpls_shim_hdr);
|
||||
}
|
||||
|
||||
static unsigned int mpls_dev_mtu(const struct net_device *dev)
|
||||
{
|
||||
/* The amount of data the layer 2 frame can hold */
|
||||
return dev->mtu;
|
||||
}
|
||||
|
||||
static bool mpls_pkt_too_big(const struct sk_buff *skb, unsigned int mtu)
|
||||
{
|
||||
if (skb->len <= mtu)
|
||||
return false;
|
||||
|
||||
if (skb_is_gso(skb) && skb_gso_network_seglen(skb) <= mtu)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool mpls_egress(struct mpls_route *rt, struct sk_buff *skb,
|
||||
struct mpls_entry_decoded dec)
|
||||
{
|
||||
/* RFC4385 and RFC5586 encode other packets in mpls such that
|
||||
* they don't conflict with the ip version number, making
|
||||
* decoding by examining the ip version correct in everything
|
||||
* except for the strangest cases.
|
||||
*
|
||||
* The strange cases if we choose to support them will require
|
||||
* manual configuration.
|
||||
*/
|
||||
struct iphdr *hdr4 = ip_hdr(skb);
|
||||
bool success = true;
|
||||
|
||||
if (hdr4->version == 4) {
|
||||
skb->protocol = htons(ETH_P_IP);
|
||||
csum_replace2(&hdr4->check,
|
||||
htons(hdr4->ttl << 8),
|
||||
htons(dec.ttl << 8));
|
||||
hdr4->ttl = dec.ttl;
|
||||
}
|
||||
else if (hdr4->version == 6) {
|
||||
struct ipv6hdr *hdr6 = ipv6_hdr(skb);
|
||||
skb->protocol = htons(ETH_P_IPV6);
|
||||
hdr6->hop_limit = dec.ttl;
|
||||
}
|
||||
else
|
||||
/* version 0 and version 1 are used by pseudo wires */
|
||||
success = false;
|
||||
return success;
|
||||
}
|
||||
|
||||
static int mpls_forward(struct sk_buff *skb, struct net_device *dev,
|
||||
struct packet_type *pt, struct net_device *orig_dev)
|
||||
{
|
||||
struct net *net = dev_net(dev);
|
||||
struct mpls_shim_hdr *hdr;
|
||||
struct mpls_route *rt;
|
||||
struct mpls_entry_decoded dec;
|
||||
struct net_device *out_dev;
|
||||
unsigned int hh_len;
|
||||
unsigned int new_header_size;
|
||||
unsigned int mtu;
|
||||
int err;
|
||||
|
||||
/* Careful this entire function runs inside of an rcu critical section */
|
||||
|
||||
if (skb->pkt_type != PACKET_HOST)
|
||||
goto drop;
|
||||
|
||||
if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
|
||||
goto drop;
|
||||
|
||||
if (!pskb_may_pull(skb, sizeof(*hdr)))
|
||||
goto drop;
|
||||
|
||||
/* Read and decode the label */
|
||||
hdr = mpls_hdr(skb);
|
||||
dec = mpls_entry_decode(hdr);
|
||||
|
||||
/* Pop the label */
|
||||
skb_pull(skb, sizeof(*hdr));
|
||||
skb_reset_network_header(skb);
|
||||
|
||||
skb_orphan(skb);
|
||||
|
||||
rt = mpls_route_input_rcu(net, dec.label);
|
||||
if (!rt)
|
||||
goto drop;
|
||||
|
||||
/* Find the output device */
|
||||
out_dev = rt->rt_dev;
|
||||
if (!mpls_output_possible(out_dev))
|
||||
goto drop;
|
||||
|
||||
if (skb_warn_if_lro(skb))
|
||||
goto drop;
|
||||
|
||||
skb_forward_csum(skb);
|
||||
|
||||
/* Verify ttl is valid */
|
||||
if (dec.ttl <= 2)
|
||||
goto drop;
|
||||
dec.ttl -= 1;
|
||||
|
||||
/* Verify the destination can hold the packet */
|
||||
new_header_size = mpls_rt_header_size(rt);
|
||||
mtu = mpls_dev_mtu(out_dev);
|
||||
if (mpls_pkt_too_big(skb, mtu - new_header_size))
|
||||
goto drop;
|
||||
|
||||
hh_len = LL_RESERVED_SPACE(out_dev);
|
||||
if (!out_dev->header_ops)
|
||||
hh_len = 0;
|
||||
|
||||
/* Ensure there is enough space for the headers in the skb */
|
||||
if (skb_cow(skb, hh_len + new_header_size))
|
||||
goto drop;
|
||||
|
||||
skb->dev = out_dev;
|
||||
skb->protocol = htons(ETH_P_MPLS_UC);
|
||||
|
||||
if (unlikely(!new_header_size && dec.bos)) {
|
||||
/* Penultimate hop popping */
|
||||
if (!mpls_egress(rt, skb, dec))
|
||||
goto drop;
|
||||
} else {
|
||||
bool bos;
|
||||
int i;
|
||||
skb_push(skb, new_header_size);
|
||||
skb_reset_network_header(skb);
|
||||
/* Push the new labels */
|
||||
hdr = mpls_hdr(skb);
|
||||
bos = dec.bos;
|
||||
for (i = rt->rt_labels - 1; i >= 0; i--) {
|
||||
hdr[i] = mpls_entry_encode(rt->rt_label[i], dec.ttl, 0, bos);
|
||||
bos = false;
|
||||
}
|
||||
}
|
||||
|
||||
err = neigh_xmit(rt->rt_via_family, out_dev, rt->rt_via, skb);
|
||||
if (err)
|
||||
net_dbg_ratelimited("%s: packet transmission failed: %d\n",
|
||||
__func__, err);
|
||||
return 0;
|
||||
|
||||
drop:
|
||||
kfree_skb(skb);
|
||||
return NET_RX_DROP;
|
||||
}
|
||||
|
||||
static struct packet_type mpls_packet_type __read_mostly = {
|
||||
.type = cpu_to_be16(ETH_P_MPLS_UC),
|
||||
.func = mpls_forward,
|
||||
};
|
||||
|
||||
const struct nla_policy rtm_mpls_policy[RTA_MAX+1] = {
|
||||
[RTA_DST] = { .type = NLA_U32 },
|
||||
[RTA_OIF] = { .type = NLA_U32 },
|
||||
};
|
||||
|
||||
struct mpls_route_config {
|
||||
u32 rc_protocol;
|
||||
u32 rc_ifindex;
|
||||
u16 rc_via_family;
|
||||
u16 rc_via_alen;
|
||||
u8 rc_via[MAX_VIA_ALEN];
|
||||
u32 rc_label;
|
||||
u32 rc_output_labels;
|
||||
u32 rc_output_label[MAX_NEW_LABELS];
|
||||
u32 rc_nlflags;
|
||||
struct nl_info rc_nlinfo;
|
||||
};
|
||||
|
||||
static struct mpls_route *mpls_rt_alloc(size_t alen)
|
||||
{
|
||||
struct mpls_route *rt;
|
||||
|
||||
rt = kzalloc(GFP_KERNEL, sizeof(*rt) + alen);
|
||||
if (rt)
|
||||
rt->rt_via_alen = alen;
|
||||
return rt;
|
||||
}
|
||||
|
||||
static void mpls_rt_free(struct mpls_route *rt)
|
||||
{
|
||||
if (rt)
|
||||
kfree_rcu(rt, rt_rcu);
|
||||
}
|
||||
|
||||
static void mpls_notify_route(struct net *net, unsigned index,
|
||||
struct mpls_route *old, struct mpls_route *new,
|
||||
const struct nl_info *info)
|
||||
{
|
||||
struct nlmsghdr *nlh = info ? info->nlh : NULL;
|
||||
unsigned portid = info ? info->portid : 0;
|
||||
int event = new ? RTM_NEWROUTE : RTM_DELROUTE;
|
||||
struct mpls_route *rt = new ? new : old;
|
||||
unsigned nlm_flags = (old && new) ? NLM_F_REPLACE : 0;
|
||||
/* Ignore reserved labels for now */
|
||||
if (rt && (index >= 16))
|
||||
rtmsg_lfib(event, index, rt, nlh, net, portid, nlm_flags);
|
||||
}
|
||||
|
||||
static void mpls_route_update(struct net *net, unsigned index,
|
||||
struct net_device *dev, struct mpls_route *new,
|
||||
const struct nl_info *info)
|
||||
{
|
||||
struct mpls_route *rt, *old = NULL;
|
||||
|
||||
ASSERT_RTNL();
|
||||
|
||||
rt = net->mpls.platform_label[index];
|
||||
if (!dev || (rt && (rt->rt_dev == dev))) {
|
||||
rcu_assign_pointer(net->mpls.platform_label[index], new);
|
||||
old = rt;
|
||||
}
|
||||
|
||||
mpls_notify_route(net, index, old, new, info);
|
||||
|
||||
/* If we removed a route free it now */
|
||||
mpls_rt_free(old);
|
||||
}
|
||||
|
||||
static unsigned find_free_label(struct net *net)
|
||||
{
|
||||
unsigned index;
|
||||
for (index = 16; index < net->mpls.platform_labels; index++) {
|
||||
if (!net->mpls.platform_label[index])
|
||||
return index;
|
||||
}
|
||||
return LABEL_NOT_SPECIFIED;
|
||||
}
|
||||
|
||||
static int mpls_route_add(struct mpls_route_config *cfg)
|
||||
{
|
||||
struct net *net = cfg->rc_nlinfo.nl_net;
|
||||
struct net_device *dev = NULL;
|
||||
struct mpls_route *rt, *old;
|
||||
unsigned index;
|
||||
int i;
|
||||
int err = -EINVAL;
|
||||
|
||||
index = cfg->rc_label;
|
||||
|
||||
/* If a label was not specified during insert pick one */
|
||||
if ((index == LABEL_NOT_SPECIFIED) &&
|
||||
(cfg->rc_nlflags & NLM_F_CREATE)) {
|
||||
index = find_free_label(net);
|
||||
}
|
||||
|
||||
/* The first 16 labels are reserved, and may not be set */
|
||||
if (index < 16)
|
||||
goto errout;
|
||||
|
||||
/* The full 20 bit range may not be supported. */
|
||||
if (index >= net->mpls.platform_labels)
|
||||
goto errout;
|
||||
|
||||
/* Ensure only a supported number of labels are present */
|
||||
if (cfg->rc_output_labels > MAX_NEW_LABELS)
|
||||
goto errout;
|
||||
|
||||
err = -ENODEV;
|
||||
dev = dev_get_by_index(net, cfg->rc_ifindex);
|
||||
if (!dev)
|
||||
goto errout;
|
||||
|
||||
/* For now just support ethernet devices */
|
||||
err = -EINVAL;
|
||||
if ((dev->type != ARPHRD_ETHER) && (dev->type != ARPHRD_LOOPBACK))
|
||||
goto errout;
|
||||
|
||||
err = -EINVAL;
|
||||
if ((cfg->rc_via_family == AF_PACKET) &&
|
||||
(dev->addr_len != cfg->rc_via_alen))
|
||||
goto errout;
|
||||
|
||||
/* Append makes no sense with mpls */
|
||||
err = -EINVAL;
|
||||
if (cfg->rc_nlflags & NLM_F_APPEND)
|
||||
goto errout;
|
||||
|
||||
err = -EEXIST;
|
||||
old = net->mpls.platform_label[index];
|
||||
if ((cfg->rc_nlflags & NLM_F_EXCL) && old)
|
||||
goto errout;
|
||||
|
||||
err = -EEXIST;
|
||||
if (!(cfg->rc_nlflags & NLM_F_REPLACE) && old)
|
||||
goto errout;
|
||||
|
||||
err = -ENOENT;
|
||||
if (!(cfg->rc_nlflags & NLM_F_CREATE) && !old)
|
||||
goto errout;
|
||||
|
||||
err = -ENOMEM;
|
||||
rt = mpls_rt_alloc(cfg->rc_via_alen);
|
||||
if (!rt)
|
||||
goto errout;
|
||||
|
||||
rt->rt_labels = cfg->rc_output_labels;
|
||||
for (i = 0; i < rt->rt_labels; i++)
|
||||
rt->rt_label[i] = cfg->rc_output_label[i];
|
||||
rt->rt_protocol = cfg->rc_protocol;
|
||||
rt->rt_dev = dev;
|
||||
rt->rt_via_family = cfg->rc_via_family;
|
||||
memcpy(rt->rt_via, cfg->rc_via, cfg->rc_via_alen);
|
||||
|
||||
mpls_route_update(net, index, NULL, rt, &cfg->rc_nlinfo);
|
||||
|
||||
dev_put(dev);
|
||||
return 0;
|
||||
|
||||
errout:
|
||||
if (dev)
|
||||
dev_put(dev);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int mpls_route_del(struct mpls_route_config *cfg)
|
||||
{
|
||||
struct net *net = cfg->rc_nlinfo.nl_net;
|
||||
unsigned index;
|
||||
int err = -EINVAL;
|
||||
|
||||
index = cfg->rc_label;
|
||||
|
||||
/* The first 16 labels are reserved, and may not be removed */
|
||||
if (index < 16)
|
||||
goto errout;
|
||||
|
||||
/* The full 20 bit range may not be supported */
|
||||
if (index >= net->mpls.platform_labels)
|
||||
goto errout;
|
||||
|
||||
mpls_route_update(net, index, NULL, NULL, &cfg->rc_nlinfo);
|
||||
|
||||
err = 0;
|
||||
errout:
|
||||
return err;
|
||||
}
|
||||
|
||||
static void mpls_ifdown(struct net_device *dev)
|
||||
{
|
||||
struct net *net = dev_net(dev);
|
||||
unsigned index;
|
||||
|
||||
for (index = 0; index < net->mpls.platform_labels; index++) {
|
||||
struct mpls_route *rt = net->mpls.platform_label[index];
|
||||
if (!rt)
|
||||
continue;
|
||||
if (rt->rt_dev != dev)
|
||||
continue;
|
||||
rt->rt_dev = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int mpls_dev_notify(struct notifier_block *this, unsigned long event,
|
||||
void *ptr)
|
||||
{
|
||||
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
||||
|
||||
switch(event) {
|
||||
case NETDEV_UNREGISTER:
|
||||
mpls_ifdown(dev);
|
||||
break;
|
||||
}
|
||||
return NOTIFY_OK;
|
||||
}
|
||||
|
||||
static struct notifier_block mpls_dev_notifier = {
|
||||
.notifier_call = mpls_dev_notify,
|
||||
};
|
||||
|
||||
static int nla_put_via(struct sk_buff *skb,
|
||||
u16 family, const void *addr, int alen)
|
||||
{
|
||||
struct nlattr *nla;
|
||||
struct rtvia *via;
|
||||
|
||||
nla = nla_reserve(skb, RTA_VIA, alen + 2);
|
||||
if (!nla)
|
||||
return -EMSGSIZE;
|
||||
|
||||
via = nla_data(nla);
|
||||
via->rtvia_family = family;
|
||||
memcpy(via->rtvia_addr, addr, alen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int nla_put_labels(struct sk_buff *skb, int attrtype,
|
||||
u8 labels, const u32 label[])
|
||||
{
|
||||
struct nlattr *nla;
|
||||
struct mpls_shim_hdr *nla_label;
|
||||
bool bos;
|
||||
int i;
|
||||
nla = nla_reserve(skb, attrtype, labels*4);
|
||||
if (!nla)
|
||||
return -EMSGSIZE;
|
||||
|
||||
nla_label = nla_data(nla);
|
||||
bos = true;
|
||||
for (i = labels - 1; i >= 0; i--) {
|
||||
nla_label[i] = mpls_entry_encode(label[i], 0, 0, bos);
|
||||
bos = false;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int nla_get_labels(const struct nlattr *nla,
|
||||
u32 max_labels, u32 *labels, u32 label[])
|
||||
{
|
||||
unsigned len = nla_len(nla);
|
||||
unsigned nla_labels;
|
||||
struct mpls_shim_hdr *nla_label;
|
||||
bool bos;
|
||||
int i;
|
||||
|
||||
/* len needs to be an even multiple of 4 (the label size) */
|
||||
if (len & 3)
|
||||
return -EINVAL;
|
||||
|
||||
/* Limit the number of new labels allowed */
|
||||
nla_labels = len/4;
|
||||
if (nla_labels > max_labels)
|
||||
return -EINVAL;
|
||||
|
||||
nla_label = nla_data(nla);
|
||||
bos = true;
|
||||
for (i = nla_labels - 1; i >= 0; i--, bos = false) {
|
||||
struct mpls_entry_decoded dec;
|
||||
dec = mpls_entry_decode(nla_label + i);
|
||||
|
||||
/* Ensure the bottom of stack flag is properly set
|
||||
* and ttl and tc are both clear.
|
||||
*/
|
||||
if ((dec.bos != bos) || dec.ttl || dec.tc)
|
||||
return -EINVAL;
|
||||
|
||||
label[i] = dec.label;
|
||||
}
|
||||
*labels = nla_labels;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int rtm_to_route_config(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
struct mpls_route_config *cfg)
|
||||
{
|
||||
struct rtmsg *rtm;
|
||||
struct nlattr *tb[RTA_MAX+1];
|
||||
int index;
|
||||
int err;
|
||||
|
||||
err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_mpls_policy);
|
||||
if (err < 0)
|
||||
goto errout;
|
||||
|
||||
err = -EINVAL;
|
||||
rtm = nlmsg_data(nlh);
|
||||
memset(cfg, 0, sizeof(*cfg));
|
||||
|
||||
if (rtm->rtm_family != AF_MPLS)
|
||||
goto errout;
|
||||
if (rtm->rtm_dst_len != 20)
|
||||
goto errout;
|
||||
if (rtm->rtm_src_len != 0)
|
||||
goto errout;
|
||||
if (rtm->rtm_tos != 0)
|
||||
goto errout;
|
||||
if (rtm->rtm_table != RT_TABLE_MAIN)
|
||||
goto errout;
|
||||
/* Any value is acceptable for rtm_protocol */
|
||||
|
||||
/* As mpls uses destination specific addresses
|
||||
* (or source specific address in the case of multicast)
|
||||
* all addresses have universal scope.
|
||||
*/
|
||||
if (rtm->rtm_scope != RT_SCOPE_UNIVERSE)
|
||||
goto errout;
|
||||
if (rtm->rtm_type != RTN_UNICAST)
|
||||
goto errout;
|
||||
if (rtm->rtm_flags != 0)
|
||||
goto errout;
|
||||
|
||||
cfg->rc_label = LABEL_NOT_SPECIFIED;
|
||||
cfg->rc_protocol = rtm->rtm_protocol;
|
||||
cfg->rc_nlflags = nlh->nlmsg_flags;
|
||||
cfg->rc_nlinfo.portid = NETLINK_CB(skb).portid;
|
||||
cfg->rc_nlinfo.nlh = nlh;
|
||||
cfg->rc_nlinfo.nl_net = sock_net(skb->sk);
|
||||
|
||||
for (index = 0; index <= RTA_MAX; index++) {
|
||||
struct nlattr *nla = tb[index];
|
||||
if (!nla)
|
||||
continue;
|
||||
|
||||
switch(index) {
|
||||
case RTA_OIF:
|
||||
cfg->rc_ifindex = nla_get_u32(nla);
|
||||
break;
|
||||
case RTA_NEWDST:
|
||||
if (nla_get_labels(nla, MAX_NEW_LABELS,
|
||||
&cfg->rc_output_labels,
|
||||
cfg->rc_output_label))
|
||||
goto errout;
|
||||
break;
|
||||
case RTA_DST:
|
||||
{
|
||||
u32 label_count;
|
||||
if (nla_get_labels(nla, 1, &label_count,
|
||||
&cfg->rc_label))
|
||||
goto errout;
|
||||
|
||||
/* The first 16 labels are reserved, and may not be set */
|
||||
if (cfg->rc_label < 16)
|
||||
goto errout;
|
||||
|
||||
break;
|
||||
}
|
||||
case RTA_VIA:
|
||||
{
|
||||
struct rtvia *via = nla_data(nla);
|
||||
cfg->rc_via_family = via->rtvia_family;
|
||||
cfg->rc_via_alen = nla_len(nla) - 2;
|
||||
if (cfg->rc_via_alen > MAX_VIA_ALEN)
|
||||
goto errout;
|
||||
|
||||
/* Validate the address family */
|
||||
switch(cfg->rc_via_family) {
|
||||
case AF_PACKET:
|
||||
break;
|
||||
case AF_INET:
|
||||
if (cfg->rc_via_alen != 4)
|
||||
goto errout;
|
||||
break;
|
||||
case AF_INET6:
|
||||
if (cfg->rc_via_alen != 16)
|
||||
goto errout;
|
||||
break;
|
||||
default:
|
||||
/* Unsupported address family */
|
||||
goto errout;
|
||||
}
|
||||
|
||||
memcpy(cfg->rc_via, via->rtvia_addr, cfg->rc_via_alen);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
/* Unsupported attribute */
|
||||
goto errout;
|
||||
}
|
||||
}
|
||||
|
||||
err = 0;
|
||||
errout:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int mpls_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
|
||||
{
|
||||
struct mpls_route_config cfg;
|
||||
int err;
|
||||
|
||||
err = rtm_to_route_config(skb, nlh, &cfg);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
return mpls_route_del(&cfg);
|
||||
}
|
||||
|
||||
|
||||
static int mpls_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
|
||||
{
|
||||
struct mpls_route_config cfg;
|
||||
int err;
|
||||
|
||||
err = rtm_to_route_config(skb, nlh, &cfg);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
return mpls_route_add(&cfg);
|
||||
}
|
||||
|
||||
static int mpls_dump_route(struct sk_buff *skb, u32 portid, u32 seq, int event,
|
||||
u32 label, struct mpls_route *rt, int flags)
|
||||
{
|
||||
struct nlmsghdr *nlh;
|
||||
struct rtmsg *rtm;
|
||||
|
||||
nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags);
|
||||
if (nlh == NULL)
|
||||
return -EMSGSIZE;
|
||||
|
||||
rtm = nlmsg_data(nlh);
|
||||
rtm->rtm_family = AF_MPLS;
|
||||
rtm->rtm_dst_len = 20;
|
||||
rtm->rtm_src_len = 0;
|
||||
rtm->rtm_tos = 0;
|
||||
rtm->rtm_table = RT_TABLE_MAIN;
|
||||
rtm->rtm_protocol = rt->rt_protocol;
|
||||
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
|
||||
rtm->rtm_type = RTN_UNICAST;
|
||||
rtm->rtm_flags = 0;
|
||||
|
||||
if (rt->rt_labels &&
|
||||
nla_put_labels(skb, RTA_NEWDST, rt->rt_labels, rt->rt_label))
|
||||
goto nla_put_failure;
|
||||
if (nla_put_via(skb, rt->rt_via_family, rt->rt_via, rt->rt_via_alen))
|
||||
goto nla_put_failure;
|
||||
if (rt->rt_dev && nla_put_u32(skb, RTA_OIF, rt->rt_dev->ifindex))
|
||||
goto nla_put_failure;
|
||||
if (nla_put_labels(skb, RTA_DST, 1, &label))
|
||||
goto nla_put_failure;
|
||||
|
||||
nlmsg_end(skb, nlh);
|
||||
return 0;
|
||||
|
||||
nla_put_failure:
|
||||
nlmsg_cancel(skb, nlh);
|
||||
return -EMSGSIZE;
|
||||
}
|
||||
|
||||
static int mpls_dump_routes(struct sk_buff *skb, struct netlink_callback *cb)
|
||||
{
|
||||
struct net *net = sock_net(skb->sk);
|
||||
unsigned int index;
|
||||
|
||||
ASSERT_RTNL();
|
||||
|
||||
index = cb->args[0];
|
||||
if (index < 16)
|
||||
index = 16;
|
||||
|
||||
for (; index < net->mpls.platform_labels; index++) {
|
||||
struct mpls_route *rt;
|
||||
rt = net->mpls.platform_label[index];
|
||||
if (!rt)
|
||||
continue;
|
||||
|
||||
if (mpls_dump_route(skb, NETLINK_CB(cb->skb).portid,
|
||||
cb->nlh->nlmsg_seq, RTM_NEWROUTE,
|
||||
index, rt, NLM_F_MULTI) < 0)
|
||||
break;
|
||||
}
|
||||
cb->args[0] = index;
|
||||
|
||||
return skb->len;
|
||||
}
|
||||
|
||||
static inline size_t lfib_nlmsg_size(struct mpls_route *rt)
|
||||
{
|
||||
size_t payload =
|
||||
NLMSG_ALIGN(sizeof(struct rtmsg))
|
||||
+ nla_total_size(2 + rt->rt_via_alen) /* RTA_VIA */
|
||||
+ nla_total_size(4); /* RTA_DST */
|
||||
if (rt->rt_labels) /* RTA_NEWDST */
|
||||
payload += nla_total_size(rt->rt_labels * 4);
|
||||
if (rt->rt_dev) /* RTA_OIF */
|
||||
payload += nla_total_size(4);
|
||||
return payload;
|
||||
}
|
||||
|
||||
static void rtmsg_lfib(int event, u32 label, struct mpls_route *rt,
|
||||
struct nlmsghdr *nlh, struct net *net, u32 portid,
|
||||
unsigned int nlm_flags)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
u32 seq = nlh ? nlh->nlmsg_seq : 0;
|
||||
int err = -ENOBUFS;
|
||||
|
||||
skb = nlmsg_new(lfib_nlmsg_size(rt), GFP_KERNEL);
|
||||
if (skb == NULL)
|
||||
goto errout;
|
||||
|
||||
err = mpls_dump_route(skb, portid, seq, event, label, rt, nlm_flags);
|
||||
if (err < 0) {
|
||||
/* -EMSGSIZE implies BUG in lfib_nlmsg_size */
|
||||
WARN_ON(err == -EMSGSIZE);
|
||||
kfree_skb(skb);
|
||||
goto errout;
|
||||
}
|
||||
rtnl_notify(skb, net, portid, RTNLGRP_MPLS_ROUTE, nlh, GFP_KERNEL);
|
||||
|
||||
return;
|
||||
errout:
|
||||
if (err < 0)
|
||||
rtnl_set_sk_err(net, RTNLGRP_MPLS_ROUTE, err);
|
||||
}
|
||||
|
||||
static int resize_platform_label_table(struct net *net, size_t limit)
|
||||
{
|
||||
size_t size = sizeof(struct mpls_route *) * limit;
|
||||
size_t old_limit;
|
||||
size_t cp_size;
|
||||
struct mpls_route __rcu **labels = NULL, **old;
|
||||
struct mpls_route *rt0 = NULL, *rt2 = NULL;
|
||||
unsigned index;
|
||||
|
||||
if (size) {
|
||||
labels = kzalloc(size, GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY);
|
||||
if (!labels)
|
||||
labels = vzalloc(size);
|
||||
|
||||
if (!labels)
|
||||
goto nolabels;
|
||||
}
|
||||
|
||||
/* In case the predefined labels need to be populated */
|
||||
if (limit > LABEL_IPV4_EXPLICIT_NULL) {
|
||||
struct net_device *lo = net->loopback_dev;
|
||||
rt0 = mpls_rt_alloc(lo->addr_len);
|
||||
if (!rt0)
|
||||
goto nort0;
|
||||
rt0->rt_dev = lo;
|
||||
rt0->rt_protocol = RTPROT_KERNEL;
|
||||
rt0->rt_via_family = AF_PACKET;
|
||||
memcpy(rt0->rt_via, lo->dev_addr, lo->addr_len);
|
||||
}
|
||||
if (limit > LABEL_IPV6_EXPLICIT_NULL) {
|
||||
struct net_device *lo = net->loopback_dev;
|
||||
rt2 = mpls_rt_alloc(lo->addr_len);
|
||||
if (!rt2)
|
||||
goto nort2;
|
||||
rt2->rt_dev = lo;
|
||||
rt2->rt_protocol = RTPROT_KERNEL;
|
||||
rt2->rt_via_family = AF_PACKET;
|
||||
memcpy(rt2->rt_via, lo->dev_addr, lo->addr_len);
|
||||
}
|
||||
|
||||
rtnl_lock();
|
||||
/* Remember the original table */
|
||||
old = net->mpls.platform_label;
|
||||
old_limit = net->mpls.platform_labels;
|
||||
|
||||
/* Free any labels beyond the new table */
|
||||
for (index = limit; index < old_limit; index++)
|
||||
mpls_route_update(net, index, NULL, NULL, NULL);
|
||||
|
||||
/* Copy over the old labels */
|
||||
cp_size = size;
|
||||
if (old_limit < limit)
|
||||
cp_size = old_limit * sizeof(struct mpls_route *);
|
||||
|
||||
memcpy(labels, old, cp_size);
|
||||
|
||||
/* If needed set the predefined labels */
|
||||
if ((old_limit <= LABEL_IPV6_EXPLICIT_NULL) &&
|
||||
(limit > LABEL_IPV6_EXPLICIT_NULL)) {
|
||||
labels[LABEL_IPV6_EXPLICIT_NULL] = rt2;
|
||||
rt2 = NULL;
|
||||
}
|
||||
|
||||
if ((old_limit <= LABEL_IPV4_EXPLICIT_NULL) &&
|
||||
(limit > LABEL_IPV4_EXPLICIT_NULL)) {
|
||||
labels[LABEL_IPV4_EXPLICIT_NULL] = rt0;
|
||||
rt0 = NULL;
|
||||
}
|
||||
|
||||
/* Update the global pointers */
|
||||
net->mpls.platform_labels = limit;
|
||||
net->mpls.platform_label = labels;
|
||||
|
||||
rtnl_unlock();
|
||||
|
||||
mpls_rt_free(rt2);
|
||||
mpls_rt_free(rt0);
|
||||
|
||||
if (old) {
|
||||
synchronize_rcu();
|
||||
kvfree(old);
|
||||
}
|
||||
return 0;
|
||||
|
||||
nort2:
|
||||
mpls_rt_free(rt0);
|
||||
nort0:
|
||||
kvfree(labels);
|
||||
nolabels:
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
static int mpls_platform_labels(struct ctl_table *table, int write,
|
||||
void __user *buffer, size_t *lenp, loff_t *ppos)
|
||||
{
|
||||
struct net *net = table->data;
|
||||
int platform_labels = net->mpls.platform_labels;
|
||||
int ret;
|
||||
struct ctl_table tmp = {
|
||||
.procname = table->procname,
|
||||
.data = &platform_labels,
|
||||
.maxlen = sizeof(int),
|
||||
.mode = table->mode,
|
||||
.extra1 = &zero,
|
||||
.extra2 = &label_limit,
|
||||
};
|
||||
|
||||
ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
|
||||
|
||||
if (write && ret == 0)
|
||||
ret = resize_platform_label_table(net, platform_labels);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct ctl_table mpls_table[] = {
|
||||
{
|
||||
.procname = "platform_labels",
|
||||
.data = NULL,
|
||||
.maxlen = sizeof(int),
|
||||
.mode = 0644,
|
||||
.proc_handler = mpls_platform_labels,
|
||||
},
|
||||
{ }
|
||||
};
|
||||
|
||||
static int mpls_net_init(struct net *net)
|
||||
{
|
||||
struct ctl_table *table;
|
||||
|
||||
net->mpls.platform_labels = 0;
|
||||
net->mpls.platform_label = NULL;
|
||||
|
||||
table = kmemdup(mpls_table, sizeof(mpls_table), GFP_KERNEL);
|
||||
if (table == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
table[0].data = net;
|
||||
net->mpls.ctl = register_net_sysctl(net, "net/mpls", table);
|
||||
if (net->mpls.ctl == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mpls_net_exit(struct net *net)
|
||||
{
|
||||
struct ctl_table *table;
|
||||
unsigned int index;
|
||||
|
||||
table = net->mpls.ctl->ctl_table_arg;
|
||||
unregister_net_sysctl_table(net->mpls.ctl);
|
||||
kfree(table);
|
||||
|
||||
/* An rcu grace period haselapsed since there was a device in
|
||||
* the network namespace (and thus the last in fqlight packet)
|
||||
* left this network namespace. This is because
|
||||
* unregister_netdevice_many and netdev_run_todo has completed
|
||||
* for each network device that was in this network namespace.
|
||||
*
|
||||
* As such no additional rcu synchronization is necessary when
|
||||
* freeing the platform_label table.
|
||||
*/
|
||||
rtnl_lock();
|
||||
for (index = 0; index < net->mpls.platform_labels; index++) {
|
||||
struct mpls_route *rt = net->mpls.platform_label[index];
|
||||
rcu_assign_pointer(net->mpls.platform_label[index], NULL);
|
||||
mpls_rt_free(rt);
|
||||
}
|
||||
rtnl_unlock();
|
||||
|
||||
kvfree(net->mpls.platform_label);
|
||||
}
|
||||
|
||||
static struct pernet_operations mpls_net_ops = {
|
||||
.init = mpls_net_init,
|
||||
.exit = mpls_net_exit,
|
||||
};
|
||||
|
||||
static int __init mpls_init(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
BUILD_BUG_ON(sizeof(struct mpls_shim_hdr) != 4);
|
||||
|
||||
err = register_pernet_subsys(&mpls_net_ops);
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
err = register_netdevice_notifier(&mpls_dev_notifier);
|
||||
if (err)
|
||||
goto out_unregister_pernet;
|
||||
|
||||
dev_add_pack(&mpls_packet_type);
|
||||
|
||||
rtnl_register(PF_MPLS, RTM_NEWROUTE, mpls_rtm_newroute, NULL, NULL);
|
||||
rtnl_register(PF_MPLS, RTM_DELROUTE, mpls_rtm_delroute, NULL, NULL);
|
||||
rtnl_register(PF_MPLS, RTM_GETROUTE, NULL, mpls_dump_routes, NULL);
|
||||
err = 0;
|
||||
out:
|
||||
return err;
|
||||
|
||||
out_unregister_pernet:
|
||||
unregister_pernet_subsys(&mpls_net_ops);
|
||||
goto out;
|
||||
}
|
||||
module_init(mpls_init);
|
||||
|
||||
static void __exit mpls_exit(void)
|
||||
{
|
||||
rtnl_unregister_all(PF_MPLS);
|
||||
dev_remove_pack(&mpls_packet_type);
|
||||
unregister_netdevice_notifier(&mpls_dev_notifier);
|
||||
unregister_pernet_subsys(&mpls_net_ops);
|
||||
}
|
||||
module_exit(mpls_exit);
|
||||
|
||||
MODULE_DESCRIPTION("MultiProtocol Label Switching");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS_NETPROTO(PF_MPLS);
|
59
net/mpls/internal.h
Normal file
59
net/mpls/internal.h
Normal file
@ -0,0 +1,59 @@
|
||||
#ifndef MPLS_INTERNAL_H
|
||||
#define MPLS_INTERNAL_H
|
||||
|
||||
#define LABEL_IPV4_EXPLICIT_NULL 0 /* RFC3032 */
|
||||
#define LABEL_ROUTER_ALERT_LABEL 1 /* RFC3032 */
|
||||
#define LABEL_IPV6_EXPLICIT_NULL 2 /* RFC3032 */
|
||||
#define LABEL_IMPLICIT_NULL 3 /* RFC3032 */
|
||||
#define LABEL_ENTROPY_INDICATOR 7 /* RFC6790 */
|
||||
#define LABEL_GAL 13 /* RFC5586 */
|
||||
#define LABEL_OAM_ALERT 14 /* RFC3429 */
|
||||
#define LABEL_EXTENSION 15 /* RFC7274 */
|
||||
|
||||
|
||||
struct mpls_shim_hdr {
|
||||
__be32 label_stack_entry;
|
||||
};
|
||||
|
||||
struct mpls_entry_decoded {
|
||||
u32 label;
|
||||
u8 ttl;
|
||||
u8 tc;
|
||||
u8 bos;
|
||||
};
|
||||
|
||||
struct sk_buff;
|
||||
|
||||
static inline struct mpls_shim_hdr *mpls_hdr(const struct sk_buff *skb)
|
||||
{
|
||||
return (struct mpls_shim_hdr *)skb_network_header(skb);
|
||||
}
|
||||
|
||||
static inline struct mpls_shim_hdr mpls_entry_encode(u32 label, unsigned ttl, unsigned tc, bool bos)
|
||||
{
|
||||
struct mpls_shim_hdr result;
|
||||
result.label_stack_entry =
|
||||
cpu_to_be32((label << MPLS_LS_LABEL_SHIFT) |
|
||||
(tc << MPLS_LS_TC_SHIFT) |
|
||||
(bos ? (1 << MPLS_LS_S_SHIFT) : 0) |
|
||||
(ttl << MPLS_LS_TTL_SHIFT));
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline struct mpls_entry_decoded mpls_entry_decode(struct mpls_shim_hdr *hdr)
|
||||
{
|
||||
struct mpls_entry_decoded result;
|
||||
unsigned entry = be32_to_cpu(hdr->label_stack_entry);
|
||||
|
||||
result.label = (entry & MPLS_LS_LABEL_MASK) >> MPLS_LS_LABEL_SHIFT;
|
||||
result.ttl = (entry & MPLS_LS_TTL_MASK) >> MPLS_LS_TTL_SHIFT;
|
||||
result.tc = (entry & MPLS_LS_TC_MASK) >> MPLS_LS_TC_SHIFT;
|
||||
result.bos = (entry & MPLS_LS_S_MASK) >> MPLS_LS_S_SHIFT;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int nla_put_labels(struct sk_buff *skb, int attrtype, u8 labels, const u32 label[]);
|
||||
int nla_get_labels(const struct nlattr *nla, u32 max_labels, u32 *labels, u32 label[]);
|
||||
|
||||
#endif /* MPLS_INTERNAL_H */
|
Loading…
Reference in New Issue
Block a user