1 #include <linux/types.h>
2 #include <linux/skbuff.h>
3 #include <linux/socket.h>
4 #include <linux/sysctl.h>
6 #include <linux/module.h>
7 #include <linux/if_arp.h>
8 #include <linux/ipv6.h>
9 #include <linux/mpls.h>
10 #include <linux/netconf.h>
11 #include <linux/vmalloc.h>
12 #include <linux/percpu.h>
17 #include <net/ip_fib.h>
18 #include <net/netevent.h>
19 #include <net/ip_tunnels.h>
20 #include <net/netns/generic.h>
21 #if IS_ENABLED(CONFIG_IPV6)
24 #include <net/addrconf.h>
25 #include <net/nexthop.h>
28 /* max memory we will use for mpls_route */
29 #define MAX_MPLS_ROUTE_MEM 4096
31 /* Maximum number of labels to look ahead at when selecting a path of
34 #define MAX_MP_SELECT_LABELS 4
36 #define MPLS_NEIGH_TABLE_UNSPEC (NEIGH_LINK_TABLE + 1)
40 static int label_limit
= (1 << 20) - 1;
41 static int ttl_max
= 255;
43 #if IS_ENABLED(CONFIG_NET_IP_TUNNEL)
44 static size_t ipgre_mpls_encap_hlen(struct ip_tunnel_encap
*e
)
46 return sizeof(struct mpls_shim_hdr
);
49 static const struct ip_tunnel_encap_ops mpls_iptun_ops
= {
50 .encap_hlen
= ipgre_mpls_encap_hlen
,
53 static int ipgre_tunnel_encap_add_mpls_ops(void)
55 return ip_tunnel_encap_add_ops(&mpls_iptun_ops
, TUNNEL_ENCAP_MPLS
);
58 static void ipgre_tunnel_encap_del_mpls_ops(void)
60 ip_tunnel_encap_del_ops(&mpls_iptun_ops
, TUNNEL_ENCAP_MPLS
);
63 static int ipgre_tunnel_encap_add_mpls_ops(void)
68 static void ipgre_tunnel_encap_del_mpls_ops(void)
73 static void rtmsg_lfib(int event
, u32 label
, struct mpls_route
*rt
,
74 struct nlmsghdr
*nlh
, struct net
*net
, u32 portid
,
75 unsigned int nlm_flags
);
77 static struct mpls_route
*mpls_route_input_rcu(struct net
*net
, unsigned index
)
79 struct mpls_route
*rt
= NULL
;
81 if (index
< net
->mpls
.platform_labels
) {
82 struct mpls_route __rcu
**platform_label
=
83 rcu_dereference(net
->mpls
.platform_label
);
84 rt
= rcu_dereference(platform_label
[index
]);
89 bool mpls_output_possible(const struct net_device
*dev
)
91 return dev
&& (dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
);
93 EXPORT_SYMBOL_GPL(mpls_output_possible
);
95 static u8
*__mpls_nh_via(struct mpls_route
*rt
, struct mpls_nh
*nh
)
97 return (u8
*)nh
+ rt
->rt_via_offset
;
100 static const u8
*mpls_nh_via(const struct mpls_route
*rt
,
101 const struct mpls_nh
*nh
)
103 return __mpls_nh_via((struct mpls_route
*)rt
, (struct mpls_nh
*)nh
);
106 static unsigned int mpls_nh_header_size(const struct mpls_nh
*nh
)
108 /* The size of the layer 2.5 labels to be added for this route */
109 return nh
->nh_labels
* sizeof(struct mpls_shim_hdr
);
112 unsigned int mpls_dev_mtu(const struct net_device
*dev
)
114 /* The amount of data the layer 2 frame can hold */
117 EXPORT_SYMBOL_GPL(mpls_dev_mtu
);
119 bool mpls_pkt_too_big(const struct sk_buff
*skb
, unsigned int mtu
)
124 if (skb_is_gso(skb
) && skb_gso_validate_mtu(skb
, mtu
))
129 EXPORT_SYMBOL_GPL(mpls_pkt_too_big
);
131 void mpls_stats_inc_outucastpkts(struct net_device
*dev
,
132 const struct sk_buff
*skb
)
134 struct mpls_dev
*mdev
;
136 if (skb
->protocol
== htons(ETH_P_MPLS_UC
)) {
137 mdev
= mpls_dev_get(dev
);
139 MPLS_INC_STATS_LEN(mdev
, skb
->len
,
142 } else if (skb
->protocol
== htons(ETH_P_IP
)) {
143 IP_UPD_PO_STATS(dev_net(dev
), IPSTATS_MIB_OUT
, skb
->len
);
144 #if IS_ENABLED(CONFIG_IPV6)
145 } else if (skb
->protocol
== htons(ETH_P_IPV6
)) {
146 struct inet6_dev
*in6dev
= __in6_dev_get(dev
);
149 IP6_UPD_PO_STATS(dev_net(dev
), in6dev
,
150 IPSTATS_MIB_OUT
, skb
->len
);
154 EXPORT_SYMBOL_GPL(mpls_stats_inc_outucastpkts
);
156 static u32
mpls_multipath_hash(struct mpls_route
*rt
, struct sk_buff
*skb
)
158 struct mpls_entry_decoded dec
;
159 unsigned int mpls_hdr_len
= 0;
160 struct mpls_shim_hdr
*hdr
;
161 bool eli_seen
= false;
165 for (label_index
= 0; label_index
< MAX_MP_SELECT_LABELS
;
167 mpls_hdr_len
+= sizeof(*hdr
);
168 if (!pskb_may_pull(skb
, mpls_hdr_len
))
171 /* Read and decode the current label */
172 hdr
= mpls_hdr(skb
) + label_index
;
173 dec
= mpls_entry_decode(hdr
);
175 /* RFC6790 - reserved labels MUST NOT be used as keys
176 * for the load-balancing function
178 if (likely(dec
.label
>= MPLS_LABEL_FIRST_UNRESERVED
)) {
179 hash
= jhash_1word(dec
.label
, hash
);
181 /* The entropy label follows the entropy label
182 * indicator, so this means that the entropy
183 * label was just added to the hash - no need to
184 * go any deeper either in the label stack or in the
189 } else if (dec
.label
== MPLS_LABEL_ENTROPY
) {
196 /* found bottom label; does skb have room for a header? */
197 if (pskb_may_pull(skb
, mpls_hdr_len
+ sizeof(struct iphdr
))) {
198 const struct iphdr
*v4hdr
;
200 v4hdr
= (const struct iphdr
*)(hdr
+ 1);
201 if (v4hdr
->version
== 4) {
202 hash
= jhash_3words(ntohl(v4hdr
->saddr
),
204 v4hdr
->protocol
, hash
);
205 } else if (v4hdr
->version
== 6 &&
206 pskb_may_pull(skb
, mpls_hdr_len
+
207 sizeof(struct ipv6hdr
))) {
208 const struct ipv6hdr
*v6hdr
;
210 v6hdr
= (const struct ipv6hdr
*)(hdr
+ 1);
211 hash
= __ipv6_addr_jhash(&v6hdr
->saddr
, hash
);
212 hash
= __ipv6_addr_jhash(&v6hdr
->daddr
, hash
);
213 hash
= jhash_1word(v6hdr
->nexthdr
, hash
);
223 static struct mpls_nh
*mpls_get_nexthop(struct mpls_route
*rt
, u8 index
)
225 return (struct mpls_nh
*)((u8
*)rt
->rt_nh
+ index
* rt
->rt_nh_size
);
228 /* number of alive nexthops (rt->rt_nhn_alive) and the flags for
229 * a next hop (nh->nh_flags) are modified by netdev event handlers.
230 * Since those fields can change at any moment, use READ_ONCE to
233 static struct mpls_nh
*mpls_select_multipath(struct mpls_route
*rt
,
241 /* No need to look further into packet if there's only
247 alive
= READ_ONCE(rt
->rt_nhn_alive
);
251 hash
= mpls_multipath_hash(rt
, skb
);
252 nh_index
= hash
% alive
;
253 if (alive
== rt
->rt_nhn
)
256 unsigned int nh_flags
= READ_ONCE(nh
->nh_flags
);
258 if (nh_flags
& (RTNH_F_DEAD
| RTNH_F_LINKDOWN
))
263 } endfor_nexthops(rt
);
266 return mpls_get_nexthop(rt
, nh_index
);
269 static bool mpls_egress(struct net
*net
, struct mpls_route
*rt
,
270 struct sk_buff
*skb
, struct mpls_entry_decoded dec
)
272 enum mpls_payload_type payload_type
;
273 bool success
= false;
275 /* The IPv4 code below accesses through the IPv4 header
276 * checksum, which is 12 bytes into the packet.
277 * The IPv6 code below accesses through the IPv6 hop limit
278 * which is 8 bytes into the packet.
280 * For all supported cases there should always be at least 12
281 * bytes of packet data present. The IPv4 header is 20 bytes
282 * without options and the IPv6 header is always 40 bytes
285 if (!pskb_may_pull(skb
, 12))
288 payload_type
= rt
->rt_payload_type
;
289 if (payload_type
== MPT_UNSPEC
)
290 payload_type
= ip_hdr(skb
)->version
;
292 switch (payload_type
) {
294 struct iphdr
*hdr4
= ip_hdr(skb
);
296 skb
->protocol
= htons(ETH_P_IP
);
298 /* If propagating TTL, take the decremented TTL from
299 * the incoming MPLS header, otherwise decrement the
300 * TTL, but only if not 0 to avoid underflow.
302 if (rt
->rt_ttl_propagate
== MPLS_TTL_PROP_ENABLED
||
303 (rt
->rt_ttl_propagate
== MPLS_TTL_PROP_DEFAULT
&&
304 net
->mpls
.ip_ttl_propagate
))
307 new_ttl
= hdr4
->ttl
? hdr4
->ttl
- 1 : 0;
309 csum_replace2(&hdr4
->check
,
310 htons(hdr4
->ttl
<< 8),
311 htons(new_ttl
<< 8));
317 struct ipv6hdr
*hdr6
= ipv6_hdr(skb
);
318 skb
->protocol
= htons(ETH_P_IPV6
);
320 /* If propagating TTL, take the decremented TTL from
321 * the incoming MPLS header, otherwise decrement the
322 * hop limit, but only if not 0 to avoid underflow.
324 if (rt
->rt_ttl_propagate
== MPLS_TTL_PROP_ENABLED
||
325 (rt
->rt_ttl_propagate
== MPLS_TTL_PROP_DEFAULT
&&
326 net
->mpls
.ip_ttl_propagate
))
327 hdr6
->hop_limit
= dec
.ttl
;
328 else if (hdr6
->hop_limit
)
329 hdr6
->hop_limit
= hdr6
->hop_limit
- 1;
334 /* Should have decided which protocol it is by now */
341 static int mpls_forward(struct sk_buff
*skb
, struct net_device
*dev
,
342 struct packet_type
*pt
, struct net_device
*orig_dev
)
344 struct net
*net
= dev_net(dev
);
345 struct mpls_shim_hdr
*hdr
;
346 struct mpls_route
*rt
;
348 struct mpls_entry_decoded dec
;
349 struct net_device
*out_dev
;
350 struct mpls_dev
*out_mdev
;
351 struct mpls_dev
*mdev
;
353 unsigned int new_header_size
;
357 /* Careful this entire function runs inside of an rcu critical section */
359 mdev
= mpls_dev_get(dev
);
363 MPLS_INC_STATS_LEN(mdev
, skb
->len
, rx_packets
,
366 if (!mdev
->input_enabled
) {
367 MPLS_INC_STATS(mdev
, rx_dropped
);
371 if (skb
->pkt_type
!= PACKET_HOST
)
374 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
)
377 if (!pskb_may_pull(skb
, sizeof(*hdr
)))
380 /* Read and decode the label */
382 dec
= mpls_entry_decode(hdr
);
384 rt
= mpls_route_input_rcu(net
, dec
.label
);
386 MPLS_INC_STATS(mdev
, rx_noroute
);
390 nh
= mpls_select_multipath(rt
, skb
);
395 skb_pull(skb
, sizeof(*hdr
));
396 skb_reset_network_header(skb
);
400 if (skb_warn_if_lro(skb
))
403 skb_forward_csum(skb
);
405 /* Verify ttl is valid */
410 /* Find the output device */
411 out_dev
= rcu_dereference(nh
->nh_dev
);
412 if (!mpls_output_possible(out_dev
))
415 /* Verify the destination can hold the packet */
416 new_header_size
= mpls_nh_header_size(nh
);
417 mtu
= mpls_dev_mtu(out_dev
);
418 if (mpls_pkt_too_big(skb
, mtu
- new_header_size
))
421 hh_len
= LL_RESERVED_SPACE(out_dev
);
422 if (!out_dev
->header_ops
)
425 /* Ensure there is enough space for the headers in the skb */
426 if (skb_cow(skb
, hh_len
+ new_header_size
))
430 skb
->protocol
= htons(ETH_P_MPLS_UC
);
432 if (unlikely(!new_header_size
&& dec
.bos
)) {
433 /* Penultimate hop popping */
434 if (!mpls_egress(dev_net(out_dev
), rt
, skb
, dec
))
439 skb_push(skb
, new_header_size
);
440 skb_reset_network_header(skb
);
441 /* Push the new labels */
444 for (i
= nh
->nh_labels
- 1; i
>= 0; i
--) {
445 hdr
[i
] = mpls_entry_encode(nh
->nh_label
[i
],
451 mpls_stats_inc_outucastpkts(out_dev
, skb
);
453 /* If via wasn't specified then send out using device address */
454 if (nh
->nh_via_table
== MPLS_NEIGH_TABLE_UNSPEC
)
455 err
= neigh_xmit(NEIGH_LINK_TABLE
, out_dev
,
456 out_dev
->dev_addr
, skb
);
458 err
= neigh_xmit(nh
->nh_via_table
, out_dev
,
459 mpls_nh_via(rt
, nh
), skb
);
461 net_dbg_ratelimited("%s: packet transmission failed: %d\n",
466 out_mdev
= out_dev
? mpls_dev_get(out_dev
) : NULL
;
468 MPLS_INC_STATS(out_mdev
, tx_errors
);
471 MPLS_INC_STATS(mdev
, rx_errors
);
477 static struct packet_type mpls_packet_type __read_mostly
= {
478 .type
= cpu_to_be16(ETH_P_MPLS_UC
),
479 .func
= mpls_forward
,
482 static const struct nla_policy rtm_mpls_policy
[RTA_MAX
+1] = {
483 [RTA_DST
] = { .type
= NLA_U32
},
484 [RTA_OIF
] = { .type
= NLA_U32
},
485 [RTA_TTL_PROPAGATE
] = { .type
= NLA_U8
},
488 struct mpls_route_config
{
493 u8 rc_via
[MAX_VIA_ALEN
];
497 u32 rc_output_label
[MAX_NEW_LABELS
];
499 enum mpls_payload_type rc_payload_type
;
500 struct nl_info rc_nlinfo
;
501 struct rtnexthop
*rc_mp
;
505 /* all nexthops within a route have the same size based on max
506 * number of labels and max via length for a hop
508 static struct mpls_route
*mpls_rt_alloc(u8 num_nh
, u8 max_alen
, u8 max_labels
)
510 u8 nh_size
= MPLS_NH_SIZE(max_labels
, max_alen
);
511 struct mpls_route
*rt
;
514 size
= sizeof(*rt
) + num_nh
* nh_size
;
515 if (size
> MAX_MPLS_ROUTE_MEM
)
516 return ERR_PTR(-EINVAL
);
518 rt
= kzalloc(size
, GFP_KERNEL
);
520 return ERR_PTR(-ENOMEM
);
523 rt
->rt_nhn_alive
= num_nh
;
524 rt
->rt_nh_size
= nh_size
;
525 rt
->rt_via_offset
= MPLS_NH_VIA_OFF(max_labels
);
530 static void mpls_rt_free(struct mpls_route
*rt
)
533 kfree_rcu(rt
, rt_rcu
);
536 static void mpls_notify_route(struct net
*net
, unsigned index
,
537 struct mpls_route
*old
, struct mpls_route
*new,
538 const struct nl_info
*info
)
540 struct nlmsghdr
*nlh
= info
? info
->nlh
: NULL
;
541 unsigned portid
= info
? info
->portid
: 0;
542 int event
= new ? RTM_NEWROUTE
: RTM_DELROUTE
;
543 struct mpls_route
*rt
= new ? new : old
;
544 unsigned nlm_flags
= (old
&& new) ? NLM_F_REPLACE
: 0;
545 /* Ignore reserved labels for now */
546 if (rt
&& (index
>= MPLS_LABEL_FIRST_UNRESERVED
))
547 rtmsg_lfib(event
, index
, rt
, nlh
, net
, portid
, nlm_flags
);
550 static void mpls_route_update(struct net
*net
, unsigned index
,
551 struct mpls_route
*new,
552 const struct nl_info
*info
)
554 struct mpls_route __rcu
**platform_label
;
555 struct mpls_route
*rt
;
559 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
560 rt
= rtnl_dereference(platform_label
[index
]);
561 rcu_assign_pointer(platform_label
[index
], new);
563 mpls_notify_route(net
, index
, rt
, new, info
);
565 /* If we removed a route free it now */
569 static unsigned find_free_label(struct net
*net
)
571 struct mpls_route __rcu
**platform_label
;
572 size_t platform_labels
;
575 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
576 platform_labels
= net
->mpls
.platform_labels
;
577 for (index
= MPLS_LABEL_FIRST_UNRESERVED
; index
< platform_labels
;
579 if (!rtnl_dereference(platform_label
[index
]))
582 return LABEL_NOT_SPECIFIED
;
585 #if IS_ENABLED(CONFIG_INET)
586 static struct net_device
*inet_fib_lookup_dev(struct net
*net
,
589 struct net_device
*dev
;
591 struct in_addr daddr
;
593 memcpy(&daddr
, addr
, sizeof(struct in_addr
));
594 rt
= ip_route_output(net
, daddr
.s_addr
, 0, 0, 0);
606 static struct net_device
*inet_fib_lookup_dev(struct net
*net
,
609 return ERR_PTR(-EAFNOSUPPORT
);
613 #if IS_ENABLED(CONFIG_IPV6)
614 static struct net_device
*inet6_fib_lookup_dev(struct net
*net
,
617 struct net_device
*dev
;
618 struct dst_entry
*dst
;
623 return ERR_PTR(-EAFNOSUPPORT
);
625 memset(&fl6
, 0, sizeof(fl6
));
626 memcpy(&fl6
.daddr
, addr
, sizeof(struct in6_addr
));
627 err
= ipv6_stub
->ipv6_dst_lookup(net
, NULL
, &dst
, &fl6
);
638 static struct net_device
*inet6_fib_lookup_dev(struct net
*net
,
641 return ERR_PTR(-EAFNOSUPPORT
);
645 static struct net_device
*find_outdev(struct net
*net
,
646 struct mpls_route
*rt
,
647 struct mpls_nh
*nh
, int oif
)
649 struct net_device
*dev
= NULL
;
652 switch (nh
->nh_via_table
) {
653 case NEIGH_ARP_TABLE
:
654 dev
= inet_fib_lookup_dev(net
, mpls_nh_via(rt
, nh
));
657 dev
= inet6_fib_lookup_dev(net
, mpls_nh_via(rt
, nh
));
659 case NEIGH_LINK_TABLE
:
663 dev
= dev_get_by_index(net
, oif
);
667 return ERR_PTR(-ENODEV
);
672 /* The caller is holding rtnl anyways, so release the dev reference */
678 static int mpls_nh_assign_dev(struct net
*net
, struct mpls_route
*rt
,
679 struct mpls_nh
*nh
, int oif
)
681 struct net_device
*dev
= NULL
;
684 dev
= find_outdev(net
, rt
, nh
, oif
);
691 /* Ensure this is a supported device */
693 if (!mpls_dev_get(dev
))
696 if ((nh
->nh_via_table
== NEIGH_LINK_TABLE
) &&
697 (dev
->addr_len
!= nh
->nh_via_alen
))
700 RCU_INIT_POINTER(nh
->nh_dev
, dev
);
702 if (!(dev
->flags
& IFF_UP
)) {
703 nh
->nh_flags
|= RTNH_F_DEAD
;
707 flags
= dev_get_flags(dev
);
708 if (!(flags
& (IFF_RUNNING
| IFF_LOWER_UP
)))
709 nh
->nh_flags
|= RTNH_F_LINKDOWN
;
718 static int nla_get_via(const struct nlattr
*nla
, u8
*via_alen
, u8
*via_table
,
719 u8 via_addr
[], struct netlink_ext_ack
*extack
)
721 struct rtvia
*via
= nla_data(nla
);
725 if (nla_len(nla
) < offsetof(struct rtvia
, rtvia_addr
)) {
726 NL_SET_ERR_MSG_ATTR(extack
, nla
,
727 "Invalid attribute length for RTA_VIA");
730 alen
= nla_len(nla
) -
731 offsetof(struct rtvia
, rtvia_addr
);
732 if (alen
> MAX_VIA_ALEN
) {
733 NL_SET_ERR_MSG_ATTR(extack
, nla
,
734 "Invalid address length for RTA_VIA");
738 /* Validate the address family */
739 switch (via
->rtvia_family
) {
741 *via_table
= NEIGH_LINK_TABLE
;
744 *via_table
= NEIGH_ARP_TABLE
;
749 *via_table
= NEIGH_ND_TABLE
;
754 /* Unsupported address family */
758 memcpy(via_addr
, via
->rtvia_addr
, alen
);
766 static int mpls_nh_build_from_cfg(struct mpls_route_config
*cfg
,
767 struct mpls_route
*rt
)
769 struct net
*net
= cfg
->rc_nlinfo
.nl_net
;
770 struct mpls_nh
*nh
= rt
->rt_nh
;
777 nh
->nh_labels
= cfg
->rc_output_labels
;
778 for (i
= 0; i
< nh
->nh_labels
; i
++)
779 nh
->nh_label
[i
] = cfg
->rc_output_label
[i
];
781 nh
->nh_via_table
= cfg
->rc_via_table
;
782 memcpy(__mpls_nh_via(rt
, nh
), cfg
->rc_via
, cfg
->rc_via_alen
);
783 nh
->nh_via_alen
= cfg
->rc_via_alen
;
785 err
= mpls_nh_assign_dev(net
, rt
, nh
, cfg
->rc_ifindex
);
789 if (nh
->nh_flags
& (RTNH_F_DEAD
| RTNH_F_LINKDOWN
))
798 static int mpls_nh_build(struct net
*net
, struct mpls_route
*rt
,
799 struct mpls_nh
*nh
, int oif
, struct nlattr
*via
,
800 struct nlattr
*newdst
, u8 max_labels
,
801 struct netlink_ext_ack
*extack
)
809 err
= nla_get_labels(newdst
, max_labels
, &nh
->nh_labels
,
810 nh
->nh_label
, extack
);
816 err
= nla_get_via(via
, &nh
->nh_via_alen
, &nh
->nh_via_table
,
817 __mpls_nh_via(rt
, nh
), extack
);
821 nh
->nh_via_table
= MPLS_NEIGH_TABLE_UNSPEC
;
824 err
= mpls_nh_assign_dev(net
, rt
, nh
, oif
);
834 static u8
mpls_count_nexthops(struct rtnexthop
*rtnh
, int len
,
835 u8 cfg_via_alen
, u8
*max_via_alen
,
844 while (rtnh_ok(rtnh
, remaining
)) {
845 struct nlattr
*nla
, *attrs
= rtnh_attrs(rtnh
);
849 attrlen
= rtnh_attrlen(rtnh
);
850 nla
= nla_find(attrs
, attrlen
, RTA_VIA
);
851 if (nla
&& nla_len(nla
) >=
852 offsetof(struct rtvia
, rtvia_addr
)) {
853 int via_alen
= nla_len(nla
) -
854 offsetof(struct rtvia
, rtvia_addr
);
856 if (via_alen
<= MAX_VIA_ALEN
)
857 *max_via_alen
= max_t(u16
, *max_via_alen
,
861 nla
= nla_find(attrs
, attrlen
, RTA_NEWDST
);
863 nla_get_labels(nla
, MAX_NEW_LABELS
, &n_labels
,
867 *max_labels
= max_t(u8
, *max_labels
, n_labels
);
869 /* number of nexthops is tracked by a u8.
870 * Check for overflow.
876 rtnh
= rtnh_next(rtnh
, &remaining
);
879 /* leftover implies invalid nexthop configuration, discard it */
880 return remaining
> 0 ? 0 : nhs
;
883 static int mpls_nh_build_multi(struct mpls_route_config
*cfg
,
884 struct mpls_route
*rt
, u8 max_labels
,
885 struct netlink_ext_ack
*extack
)
887 struct rtnexthop
*rtnh
= cfg
->rc_mp
;
888 struct nlattr
*nla_via
, *nla_newdst
;
889 int remaining
= cfg
->rc_mp_len
;
893 change_nexthops(rt
) {
900 if (!rtnh_ok(rtnh
, remaining
))
903 /* neither weighted multipath nor any flags
906 if (rtnh
->rtnh_hops
|| rtnh
->rtnh_flags
)
909 attrlen
= rtnh_attrlen(rtnh
);
911 struct nlattr
*attrs
= rtnh_attrs(rtnh
);
913 nla_via
= nla_find(attrs
, attrlen
, RTA_VIA
);
914 nla_newdst
= nla_find(attrs
, attrlen
, RTA_NEWDST
);
917 err
= mpls_nh_build(cfg
->rc_nlinfo
.nl_net
, rt
, nh
,
918 rtnh
->rtnh_ifindex
, nla_via
, nla_newdst
,
923 if (nh
->nh_flags
& (RTNH_F_DEAD
| RTNH_F_LINKDOWN
))
926 rtnh
= rtnh_next(rtnh
, &remaining
);
928 } endfor_nexthops(rt
);
938 static bool mpls_label_ok(struct net
*net
, unsigned int index
,
939 struct netlink_ext_ack
*extack
)
941 /* Reserved labels may not be set */
942 if (index
< MPLS_LABEL_FIRST_UNRESERVED
) {
943 NL_SET_ERR_MSG(extack
,
944 "Invalid label - must be MPLS_LABEL_FIRST_UNRESERVED or higher");
948 /* The full 20 bit range may not be supported. */
949 if (index
>= net
->mpls
.platform_labels
) {
950 NL_SET_ERR_MSG(extack
,
951 "Label >= configured maximum in platform_labels");
958 static int mpls_route_add(struct mpls_route_config
*cfg
,
959 struct netlink_ext_ack
*extack
)
961 struct mpls_route __rcu
**platform_label
;
962 struct net
*net
= cfg
->rc_nlinfo
.nl_net
;
963 struct mpls_route
*rt
, *old
;
970 index
= cfg
->rc_label
;
972 /* If a label was not specified during insert pick one */
973 if ((index
== LABEL_NOT_SPECIFIED
) &&
974 (cfg
->rc_nlflags
& NLM_F_CREATE
)) {
975 index
= find_free_label(net
);
978 if (!mpls_label_ok(net
, index
, extack
))
981 /* Append makes no sense with mpls */
983 if (cfg
->rc_nlflags
& NLM_F_APPEND
) {
984 NL_SET_ERR_MSG(extack
, "MPLS does not support route append");
989 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
990 old
= rtnl_dereference(platform_label
[index
]);
991 if ((cfg
->rc_nlflags
& NLM_F_EXCL
) && old
)
995 if (!(cfg
->rc_nlflags
& NLM_F_REPLACE
) && old
)
999 if (!(cfg
->rc_nlflags
& NLM_F_CREATE
) && !old
)
1004 nhs
= mpls_count_nexthops(cfg
->rc_mp
, cfg
->rc_mp_len
,
1005 cfg
->rc_via_alen
, &max_via_alen
,
1008 max_via_alen
= cfg
->rc_via_alen
;
1009 max_labels
= cfg
->rc_output_labels
;
1014 NL_SET_ERR_MSG(extack
, "Route does not contain a nexthop");
1019 rt
= mpls_rt_alloc(nhs
, max_via_alen
, max_labels
);
1025 rt
->rt_protocol
= cfg
->rc_protocol
;
1026 rt
->rt_payload_type
= cfg
->rc_payload_type
;
1027 rt
->rt_ttl_propagate
= cfg
->rc_ttl_propagate
;
1030 err
= mpls_nh_build_multi(cfg
, rt
, max_labels
, extack
);
1032 err
= mpls_nh_build_from_cfg(cfg
, rt
);
1036 mpls_route_update(net
, index
, rt
, &cfg
->rc_nlinfo
);
1046 static int mpls_route_del(struct mpls_route_config
*cfg
,
1047 struct netlink_ext_ack
*extack
)
1049 struct net
*net
= cfg
->rc_nlinfo
.nl_net
;
1053 index
= cfg
->rc_label
;
1055 if (!mpls_label_ok(net
, index
, extack
))
1058 mpls_route_update(net
, index
, NULL
, &cfg
->rc_nlinfo
);
1065 static void mpls_get_stats(struct mpls_dev
*mdev
,
1066 struct mpls_link_stats
*stats
)
1068 struct mpls_pcpu_stats
*p
;
1071 memset(stats
, 0, sizeof(*stats
));
1073 for_each_possible_cpu(i
) {
1074 struct mpls_link_stats local
;
1077 p
= per_cpu_ptr(mdev
->stats
, i
);
1079 start
= u64_stats_fetch_begin(&p
->syncp
);
1081 } while (u64_stats_fetch_retry(&p
->syncp
, start
));
1083 stats
->rx_packets
+= local
.rx_packets
;
1084 stats
->rx_bytes
+= local
.rx_bytes
;
1085 stats
->tx_packets
+= local
.tx_packets
;
1086 stats
->tx_bytes
+= local
.tx_bytes
;
1087 stats
->rx_errors
+= local
.rx_errors
;
1088 stats
->tx_errors
+= local
.tx_errors
;
1089 stats
->rx_dropped
+= local
.rx_dropped
;
1090 stats
->tx_dropped
+= local
.tx_dropped
;
1091 stats
->rx_noroute
+= local
.rx_noroute
;
1095 static int mpls_fill_stats_af(struct sk_buff
*skb
,
1096 const struct net_device
*dev
)
1098 struct mpls_link_stats
*stats
;
1099 struct mpls_dev
*mdev
;
1102 mdev
= mpls_dev_get(dev
);
1106 nla
= nla_reserve_64bit(skb
, MPLS_STATS_LINK
,
1107 sizeof(struct mpls_link_stats
),
1112 stats
= nla_data(nla
);
1113 mpls_get_stats(mdev
, stats
);
1118 static size_t mpls_get_stats_af_size(const struct net_device
*dev
)
1120 struct mpls_dev
*mdev
;
1122 mdev
= mpls_dev_get(dev
);
1126 return nla_total_size_64bit(sizeof(struct mpls_link_stats
));
1129 static int mpls_netconf_fill_devconf(struct sk_buff
*skb
, struct mpls_dev
*mdev
,
1130 u32 portid
, u32 seq
, int event
,
1131 unsigned int flags
, int type
)
1133 struct nlmsghdr
*nlh
;
1134 struct netconfmsg
*ncm
;
1137 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(struct netconfmsg
),
1142 if (type
== NETCONFA_ALL
)
1145 ncm
= nlmsg_data(nlh
);
1146 ncm
->ncm_family
= AF_MPLS
;
1148 if (nla_put_s32(skb
, NETCONFA_IFINDEX
, mdev
->dev
->ifindex
) < 0)
1149 goto nla_put_failure
;
1151 if ((all
|| type
== NETCONFA_INPUT
) &&
1152 nla_put_s32(skb
, NETCONFA_INPUT
,
1153 mdev
->input_enabled
) < 0)
1154 goto nla_put_failure
;
1156 nlmsg_end(skb
, nlh
);
1160 nlmsg_cancel(skb
, nlh
);
1164 static int mpls_netconf_msgsize_devconf(int type
)
1166 int size
= NLMSG_ALIGN(sizeof(struct netconfmsg
))
1167 + nla_total_size(4); /* NETCONFA_IFINDEX */
1170 if (type
== NETCONFA_ALL
)
1173 if (all
|| type
== NETCONFA_INPUT
)
1174 size
+= nla_total_size(4);
1179 static void mpls_netconf_notify_devconf(struct net
*net
, int event
,
1180 int type
, struct mpls_dev
*mdev
)
1182 struct sk_buff
*skb
;
1185 skb
= nlmsg_new(mpls_netconf_msgsize_devconf(type
), GFP_KERNEL
);
1189 err
= mpls_netconf_fill_devconf(skb
, mdev
, 0, 0, event
, 0, type
);
1191 /* -EMSGSIZE implies BUG in mpls_netconf_msgsize_devconf() */
1192 WARN_ON(err
== -EMSGSIZE
);
1197 rtnl_notify(skb
, net
, 0, RTNLGRP_MPLS_NETCONF
, NULL
, GFP_KERNEL
);
1201 rtnl_set_sk_err(net
, RTNLGRP_MPLS_NETCONF
, err
);
1204 static const struct nla_policy devconf_mpls_policy
[NETCONFA_MAX
+ 1] = {
1205 [NETCONFA_IFINDEX
] = { .len
= sizeof(int) },
1208 static int mpls_netconf_get_devconf(struct sk_buff
*in_skb
,
1209 struct nlmsghdr
*nlh
,
1210 struct netlink_ext_ack
*extack
)
1212 struct net
*net
= sock_net(in_skb
->sk
);
1213 struct nlattr
*tb
[NETCONFA_MAX
+ 1];
1214 struct netconfmsg
*ncm
;
1215 struct net_device
*dev
;
1216 struct mpls_dev
*mdev
;
1217 struct sk_buff
*skb
;
1221 err
= nlmsg_parse(nlh
, sizeof(*ncm
), tb
, NETCONFA_MAX
,
1222 devconf_mpls_policy
, NULL
);
1227 if (!tb
[NETCONFA_IFINDEX
])
1230 ifindex
= nla_get_s32(tb
[NETCONFA_IFINDEX
]);
1231 dev
= __dev_get_by_index(net
, ifindex
);
1235 mdev
= mpls_dev_get(dev
);
1240 skb
= nlmsg_new(mpls_netconf_msgsize_devconf(NETCONFA_ALL
), GFP_KERNEL
);
1244 err
= mpls_netconf_fill_devconf(skb
, mdev
,
1245 NETLINK_CB(in_skb
).portid
,
1246 nlh
->nlmsg_seq
, RTM_NEWNETCONF
, 0,
1249 /* -EMSGSIZE implies BUG in mpls_netconf_msgsize_devconf() */
1250 WARN_ON(err
== -EMSGSIZE
);
1254 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
1259 static int mpls_netconf_dump_devconf(struct sk_buff
*skb
,
1260 struct netlink_callback
*cb
)
1262 struct net
*net
= sock_net(skb
->sk
);
1263 struct hlist_head
*head
;
1264 struct net_device
*dev
;
1265 struct mpls_dev
*mdev
;
1270 s_idx
= idx
= cb
->args
[1];
1272 for (h
= s_h
; h
< NETDEV_HASHENTRIES
; h
++, s_idx
= 0) {
1274 head
= &net
->dev_index_head
[h
];
1276 cb
->seq
= net
->dev_base_seq
;
1277 hlist_for_each_entry_rcu(dev
, head
, index_hlist
) {
1280 mdev
= mpls_dev_get(dev
);
1283 if (mpls_netconf_fill_devconf(skb
, mdev
,
1284 NETLINK_CB(cb
->skb
).portid
,
1288 NETCONFA_ALL
) < 0) {
1292 nl_dump_check_consistent(cb
, nlmsg_hdr(skb
));
1305 #define MPLS_PERDEV_SYSCTL_OFFSET(field) \
1306 (&((struct mpls_dev *)0)->field)
1308 static int mpls_conf_proc(struct ctl_table
*ctl
, int write
,
1309 void __user
*buffer
,
1310 size_t *lenp
, loff_t
*ppos
)
1312 int oval
= *(int *)ctl
->data
;
1313 int ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1316 struct mpls_dev
*mdev
= ctl
->extra1
;
1317 int i
= (int *)ctl
->data
- (int *)mdev
;
1318 struct net
*net
= ctl
->extra2
;
1319 int val
= *(int *)ctl
->data
;
1321 if (i
== offsetof(struct mpls_dev
, input_enabled
) &&
1323 mpls_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
1324 NETCONFA_INPUT
, mdev
);
1331 static const struct ctl_table mpls_dev_table
[] = {
1333 .procname
= "input",
1334 .maxlen
= sizeof(int),
1336 .proc_handler
= mpls_conf_proc
,
1337 .data
= MPLS_PERDEV_SYSCTL_OFFSET(input_enabled
),
1342 static int mpls_dev_sysctl_register(struct net_device
*dev
,
1343 struct mpls_dev
*mdev
)
1345 char path
[sizeof("net/mpls/conf/") + IFNAMSIZ
];
1346 struct net
*net
= dev_net(dev
);
1347 struct ctl_table
*table
;
1350 table
= kmemdup(&mpls_dev_table
, sizeof(mpls_dev_table
), GFP_KERNEL
);
1354 /* Table data contains only offsets relative to the base of
1355 * the mdev at this point, so make them absolute.
1357 for (i
= 0; i
< ARRAY_SIZE(mpls_dev_table
); i
++) {
1358 table
[i
].data
= (char *)mdev
+ (uintptr_t)table
[i
].data
;
1359 table
[i
].extra1
= mdev
;
1360 table
[i
].extra2
= net
;
1363 snprintf(path
, sizeof(path
), "net/mpls/conf/%s", dev
->name
);
1365 mdev
->sysctl
= register_net_sysctl(net
, path
, table
);
1369 mpls_netconf_notify_devconf(net
, RTM_NEWNETCONF
, NETCONFA_ALL
, mdev
);
1378 static void mpls_dev_sysctl_unregister(struct net_device
*dev
,
1379 struct mpls_dev
*mdev
)
1381 struct net
*net
= dev_net(dev
);
1382 struct ctl_table
*table
;
1384 table
= mdev
->sysctl
->ctl_table_arg
;
1385 unregister_net_sysctl_table(mdev
->sysctl
);
1388 mpls_netconf_notify_devconf(net
, RTM_DELNETCONF
, 0, mdev
);
1391 static struct mpls_dev
*mpls_add_dev(struct net_device
*dev
)
1393 struct mpls_dev
*mdev
;
1399 mdev
= kzalloc(sizeof(*mdev
), GFP_KERNEL
);
1401 return ERR_PTR(err
);
1403 mdev
->stats
= alloc_percpu(struct mpls_pcpu_stats
);
1407 for_each_possible_cpu(i
) {
1408 struct mpls_pcpu_stats
*mpls_stats
;
1410 mpls_stats
= per_cpu_ptr(mdev
->stats
, i
);
1411 u64_stats_init(&mpls_stats
->syncp
);
1416 err
= mpls_dev_sysctl_register(dev
, mdev
);
1420 rcu_assign_pointer(dev
->mpls_ptr
, mdev
);
1425 free_percpu(mdev
->stats
);
1427 return ERR_PTR(err
);
1430 static void mpls_dev_destroy_rcu(struct rcu_head
*head
)
1432 struct mpls_dev
*mdev
= container_of(head
, struct mpls_dev
, rcu
);
1434 free_percpu(mdev
->stats
);
1438 static void mpls_ifdown(struct net_device
*dev
, int event
)
1440 struct mpls_route __rcu
**platform_label
;
1441 struct net
*net
= dev_net(dev
);
1445 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
1446 for (index
= 0; index
< net
->mpls
.platform_labels
; index
++) {
1447 struct mpls_route
*rt
= rtnl_dereference(platform_label
[index
]);
1454 change_nexthops(rt
) {
1455 unsigned int nh_flags
= nh
->nh_flags
;
1457 if (rtnl_dereference(nh
->nh_dev
) != dev
)
1462 case NETDEV_UNREGISTER
:
1463 nh_flags
|= RTNH_F_DEAD
;
1466 nh_flags
|= RTNH_F_LINKDOWN
;
1469 if (event
== NETDEV_UNREGISTER
)
1470 RCU_INIT_POINTER(nh
->nh_dev
, NULL
);
1472 if (nh
->nh_flags
!= nh_flags
)
1473 WRITE_ONCE(nh
->nh_flags
, nh_flags
);
1475 if (!(nh_flags
& (RTNH_F_DEAD
| RTNH_F_LINKDOWN
)))
1477 if (!rtnl_dereference(nh
->nh_dev
))
1479 } endfor_nexthops(rt
);
1481 WRITE_ONCE(rt
->rt_nhn_alive
, alive
);
1483 /* if there are no more nexthops, delete the route */
1484 if (event
== NETDEV_UNREGISTER
&& deleted
== rt
->rt_nhn
)
1485 mpls_route_update(net
, index
, NULL
, NULL
);
1489 static void mpls_ifup(struct net_device
*dev
, unsigned int flags
)
1491 struct mpls_route __rcu
**platform_label
;
1492 struct net
*net
= dev_net(dev
);
1496 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
1497 for (index
= 0; index
< net
->mpls
.platform_labels
; index
++) {
1498 struct mpls_route
*rt
= rtnl_dereference(platform_label
[index
]);
1504 change_nexthops(rt
) {
1505 unsigned int nh_flags
= nh
->nh_flags
;
1506 struct net_device
*nh_dev
=
1507 rtnl_dereference(nh
->nh_dev
);
1509 if (!(nh_flags
& flags
)) {
1517 WRITE_ONCE(nh
->nh_flags
, nh_flags
);
1518 } endfor_nexthops(rt
);
1520 WRITE_ONCE(rt
->rt_nhn_alive
, alive
);
1524 static int mpls_dev_notify(struct notifier_block
*this, unsigned long event
,
1527 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1528 struct mpls_dev
*mdev
;
1531 if (event
== NETDEV_REGISTER
) {
1532 /* For now just support Ethernet, IPGRE, SIT and IPIP devices */
1533 if (dev
->type
== ARPHRD_ETHER
||
1534 dev
->type
== ARPHRD_LOOPBACK
||
1535 dev
->type
== ARPHRD_IPGRE
||
1536 dev
->type
== ARPHRD_SIT
||
1537 dev
->type
== ARPHRD_TUNNEL
) {
1538 mdev
= mpls_add_dev(dev
);
1540 return notifier_from_errno(PTR_ERR(mdev
));
1545 mdev
= mpls_dev_get(dev
);
1551 mpls_ifdown(dev
, event
);
1554 flags
= dev_get_flags(dev
);
1555 if (flags
& (IFF_RUNNING
| IFF_LOWER_UP
))
1556 mpls_ifup(dev
, RTNH_F_DEAD
| RTNH_F_LINKDOWN
);
1558 mpls_ifup(dev
, RTNH_F_DEAD
);
1561 flags
= dev_get_flags(dev
);
1562 if (flags
& (IFF_RUNNING
| IFF_LOWER_UP
))
1563 mpls_ifup(dev
, RTNH_F_DEAD
| RTNH_F_LINKDOWN
);
1565 mpls_ifdown(dev
, event
);
1567 case NETDEV_UNREGISTER
:
1568 mpls_ifdown(dev
, event
);
1569 mdev
= mpls_dev_get(dev
);
1571 mpls_dev_sysctl_unregister(dev
, mdev
);
1572 RCU_INIT_POINTER(dev
->mpls_ptr
, NULL
);
1573 call_rcu(&mdev
->rcu
, mpls_dev_destroy_rcu
);
1576 case NETDEV_CHANGENAME
:
1577 mdev
= mpls_dev_get(dev
);
1581 mpls_dev_sysctl_unregister(dev
, mdev
);
1582 err
= mpls_dev_sysctl_register(dev
, mdev
);
1584 return notifier_from_errno(err
);
1591 static struct notifier_block mpls_dev_notifier
= {
1592 .notifier_call
= mpls_dev_notify
,
1595 static int nla_put_via(struct sk_buff
*skb
,
1596 u8 table
, const void *addr
, int alen
)
1598 static const int table_to_family
[NEIGH_NR_TABLES
+ 1] = {
1599 AF_INET
, AF_INET6
, AF_DECnet
, AF_PACKET
,
1603 int family
= AF_UNSPEC
;
1605 nla
= nla_reserve(skb
, RTA_VIA
, alen
+ 2);
1609 if (table
<= NEIGH_NR_TABLES
)
1610 family
= table_to_family
[table
];
1612 via
= nla_data(nla
);
1613 via
->rtvia_family
= family
;
1614 memcpy(via
->rtvia_addr
, addr
, alen
);
1618 int nla_put_labels(struct sk_buff
*skb
, int attrtype
,
1619 u8 labels
, const u32 label
[])
1622 struct mpls_shim_hdr
*nla_label
;
1625 nla
= nla_reserve(skb
, attrtype
, labels
*4);
1629 nla_label
= nla_data(nla
);
1631 for (i
= labels
- 1; i
>= 0; i
--) {
1632 nla_label
[i
] = mpls_entry_encode(label
[i
], 0, 0, bos
);
1638 EXPORT_SYMBOL_GPL(nla_put_labels
);
1640 int nla_get_labels(const struct nlattr
*nla
, u8 max_labels
, u8
*labels
,
1641 u32 label
[], struct netlink_ext_ack
*extack
)
1643 unsigned len
= nla_len(nla
);
1644 struct mpls_shim_hdr
*nla_label
;
1649 /* len needs to be an even multiple of 4 (the label size). Number
1650 * of labels is a u8 so check for overflow.
1652 if (len
& 3 || len
/ 4 > 255) {
1653 NL_SET_ERR_MSG_ATTR(extack
, nla
,
1654 "Invalid length for labels attribute");
1658 /* Limit the number of new labels allowed */
1660 if (nla_labels
> max_labels
) {
1661 NL_SET_ERR_MSG(extack
, "Too many labels");
1665 /* when label == NULL, caller wants number of labels */
1669 nla_label
= nla_data(nla
);
1671 for (i
= nla_labels
- 1; i
>= 0; i
--, bos
= false) {
1672 struct mpls_entry_decoded dec
;
1673 dec
= mpls_entry_decode(nla_label
+ i
);
1675 /* Ensure the bottom of stack flag is properly set
1676 * and ttl and tc are both clear.
1679 NL_SET_ERR_MSG_ATTR(extack
, nla
,
1680 "TTL in label must be 0");
1685 NL_SET_ERR_MSG_ATTR(extack
, nla
,
1686 "Traffic class in label must be 0");
1690 if (dec
.bos
!= bos
) {
1691 NL_SET_BAD_ATTR(extack
, nla
);
1693 NL_SET_ERR_MSG(extack
,
1694 "BOS bit must be set in first label");
1696 NL_SET_ERR_MSG(extack
,
1697 "BOS bit can only be set in first label");
1702 switch (dec
.label
) {
1703 case MPLS_LABEL_IMPLNULL
:
1704 /* RFC3032: This is a label that an LSR may
1705 * assign and distribute, but which never
1706 * actually appears in the encapsulation.
1708 NL_SET_ERR_MSG_ATTR(extack
, nla
,
1709 "Implicit NULL Label (3) can not be used in encapsulation");
1713 label
[i
] = dec
.label
;
1716 *labels
= nla_labels
;
1719 EXPORT_SYMBOL_GPL(nla_get_labels
);
1721 static int rtm_to_route_config(struct sk_buff
*skb
,
1722 struct nlmsghdr
*nlh
,
1723 struct mpls_route_config
*cfg
,
1724 struct netlink_ext_ack
*extack
)
1727 struct nlattr
*tb
[RTA_MAX
+1];
1731 err
= nlmsg_parse(nlh
, sizeof(*rtm
), tb
, RTA_MAX
, rtm_mpls_policy
,
1737 rtm
= nlmsg_data(nlh
);
1739 if (rtm
->rtm_family
!= AF_MPLS
) {
1740 NL_SET_ERR_MSG(extack
, "Invalid address family in rtmsg");
1743 if (rtm
->rtm_dst_len
!= 20) {
1744 NL_SET_ERR_MSG(extack
, "rtm_dst_len must be 20 for MPLS");
1747 if (rtm
->rtm_src_len
!= 0) {
1748 NL_SET_ERR_MSG(extack
, "rtm_src_len must be 0 for MPLS");
1751 if (rtm
->rtm_tos
!= 0) {
1752 NL_SET_ERR_MSG(extack
, "rtm_tos must be 0 for MPLS");
1755 if (rtm
->rtm_table
!= RT_TABLE_MAIN
) {
1756 NL_SET_ERR_MSG(extack
,
1757 "MPLS only supports the main route table");
1760 /* Any value is acceptable for rtm_protocol */
1762 /* As mpls uses destination specific addresses
1763 * (or source specific address in the case of multicast)
1764 * all addresses have universal scope.
1766 if (rtm
->rtm_scope
!= RT_SCOPE_UNIVERSE
) {
1767 NL_SET_ERR_MSG(extack
,
1768 "Invalid route scope - MPLS only supports UNIVERSE");
1771 if (rtm
->rtm_type
!= RTN_UNICAST
) {
1772 NL_SET_ERR_MSG(extack
,
1773 "Invalid route type - MPLS only supports UNICAST");
1776 if (rtm
->rtm_flags
!= 0) {
1777 NL_SET_ERR_MSG(extack
, "rtm_flags must be 0 for MPLS");
1781 cfg
->rc_label
= LABEL_NOT_SPECIFIED
;
1782 cfg
->rc_protocol
= rtm
->rtm_protocol
;
1783 cfg
->rc_via_table
= MPLS_NEIGH_TABLE_UNSPEC
;
1784 cfg
->rc_ttl_propagate
= MPLS_TTL_PROP_DEFAULT
;
1785 cfg
->rc_nlflags
= nlh
->nlmsg_flags
;
1786 cfg
->rc_nlinfo
.portid
= NETLINK_CB(skb
).portid
;
1787 cfg
->rc_nlinfo
.nlh
= nlh
;
1788 cfg
->rc_nlinfo
.nl_net
= sock_net(skb
->sk
);
1790 for (index
= 0; index
<= RTA_MAX
; index
++) {
1791 struct nlattr
*nla
= tb
[index
];
1797 cfg
->rc_ifindex
= nla_get_u32(nla
);
1800 if (nla_get_labels(nla
, MAX_NEW_LABELS
,
1801 &cfg
->rc_output_labels
,
1802 cfg
->rc_output_label
, extack
))
1808 if (nla_get_labels(nla
, 1, &label_count
,
1809 &cfg
->rc_label
, extack
))
1812 if (!mpls_label_ok(cfg
->rc_nlinfo
.nl_net
,
1813 cfg
->rc_label
, extack
))
1819 if (nla_get_via(nla
, &cfg
->rc_via_alen
,
1820 &cfg
->rc_via_table
, cfg
->rc_via
,
1827 cfg
->rc_mp
= nla_data(nla
);
1828 cfg
->rc_mp_len
= nla_len(nla
);
1831 case RTA_TTL_PROPAGATE
:
1833 u8 ttl_propagate
= nla_get_u8(nla
);
1835 if (ttl_propagate
> 1) {
1836 NL_SET_ERR_MSG_ATTR(extack
, nla
,
1837 "RTA_TTL_PROPAGATE can only be 0 or 1");
1840 cfg
->rc_ttl_propagate
= ttl_propagate
?
1841 MPLS_TTL_PROP_ENABLED
:
1842 MPLS_TTL_PROP_DISABLED
;
1846 NL_SET_ERR_MSG_ATTR(extack
, nla
, "Unknown attribute");
1847 /* Unsupported attribute */
1857 static int mpls_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1858 struct netlink_ext_ack
*extack
)
1860 struct mpls_route_config
*cfg
;
1863 cfg
= kzalloc(sizeof(*cfg
), GFP_KERNEL
);
1867 err
= rtm_to_route_config(skb
, nlh
, cfg
, extack
);
1871 err
= mpls_route_del(cfg
, extack
);
1879 static int mpls_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1880 struct netlink_ext_ack
*extack
)
1882 struct mpls_route_config
*cfg
;
1885 cfg
= kzalloc(sizeof(*cfg
), GFP_KERNEL
);
1889 err
= rtm_to_route_config(skb
, nlh
, cfg
, extack
);
1893 err
= mpls_route_add(cfg
, extack
);
1900 static int mpls_dump_route(struct sk_buff
*skb
, u32 portid
, u32 seq
, int event
,
1901 u32 label
, struct mpls_route
*rt
, int flags
)
1903 struct net_device
*dev
;
1904 struct nlmsghdr
*nlh
;
1907 nlh
= nlmsg_put(skb
, portid
, seq
, event
, sizeof(*rtm
), flags
);
1911 rtm
= nlmsg_data(nlh
);
1912 rtm
->rtm_family
= AF_MPLS
;
1913 rtm
->rtm_dst_len
= 20;
1914 rtm
->rtm_src_len
= 0;
1916 rtm
->rtm_table
= RT_TABLE_MAIN
;
1917 rtm
->rtm_protocol
= rt
->rt_protocol
;
1918 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
1919 rtm
->rtm_type
= RTN_UNICAST
;
1922 if (nla_put_labels(skb
, RTA_DST
, 1, &label
))
1923 goto nla_put_failure
;
1925 if (rt
->rt_ttl_propagate
!= MPLS_TTL_PROP_DEFAULT
) {
1926 bool ttl_propagate
=
1927 rt
->rt_ttl_propagate
== MPLS_TTL_PROP_ENABLED
;
1929 if (nla_put_u8(skb
, RTA_TTL_PROPAGATE
,
1931 goto nla_put_failure
;
1933 if (rt
->rt_nhn
== 1) {
1934 const struct mpls_nh
*nh
= rt
->rt_nh
;
1936 if (nh
->nh_labels
&&
1937 nla_put_labels(skb
, RTA_NEWDST
, nh
->nh_labels
,
1939 goto nla_put_failure
;
1940 if (nh
->nh_via_table
!= MPLS_NEIGH_TABLE_UNSPEC
&&
1941 nla_put_via(skb
, nh
->nh_via_table
, mpls_nh_via(rt
, nh
),
1943 goto nla_put_failure
;
1944 dev
= rtnl_dereference(nh
->nh_dev
);
1945 if (dev
&& nla_put_u32(skb
, RTA_OIF
, dev
->ifindex
))
1946 goto nla_put_failure
;
1947 if (nh
->nh_flags
& RTNH_F_LINKDOWN
)
1948 rtm
->rtm_flags
|= RTNH_F_LINKDOWN
;
1949 if (nh
->nh_flags
& RTNH_F_DEAD
)
1950 rtm
->rtm_flags
|= RTNH_F_DEAD
;
1952 struct rtnexthop
*rtnh
;
1957 mp
= nla_nest_start(skb
, RTA_MULTIPATH
);
1959 goto nla_put_failure
;
1962 dev
= rtnl_dereference(nh
->nh_dev
);
1966 rtnh
= nla_reserve_nohdr(skb
, sizeof(*rtnh
));
1968 goto nla_put_failure
;
1970 rtnh
->rtnh_ifindex
= dev
->ifindex
;
1971 if (nh
->nh_flags
& RTNH_F_LINKDOWN
) {
1972 rtnh
->rtnh_flags
|= RTNH_F_LINKDOWN
;
1975 if (nh
->nh_flags
& RTNH_F_DEAD
) {
1976 rtnh
->rtnh_flags
|= RTNH_F_DEAD
;
1980 if (nh
->nh_labels
&& nla_put_labels(skb
, RTA_NEWDST
,
1983 goto nla_put_failure
;
1984 if (nh
->nh_via_table
!= MPLS_NEIGH_TABLE_UNSPEC
&&
1985 nla_put_via(skb
, nh
->nh_via_table
,
1986 mpls_nh_via(rt
, nh
),
1988 goto nla_put_failure
;
1990 /* length of rtnetlink header + attributes */
1991 rtnh
->rtnh_len
= nlmsg_get_pos(skb
) - (void *)rtnh
;
1992 } endfor_nexthops(rt
);
1994 if (linkdown
== rt
->rt_nhn
)
1995 rtm
->rtm_flags
|= RTNH_F_LINKDOWN
;
1996 if (dead
== rt
->rt_nhn
)
1997 rtm
->rtm_flags
|= RTNH_F_DEAD
;
1999 nla_nest_end(skb
, mp
);
2002 nlmsg_end(skb
, nlh
);
2006 nlmsg_cancel(skb
, nlh
);
2010 static int mpls_dump_routes(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2012 struct net
*net
= sock_net(skb
->sk
);
2013 struct mpls_route __rcu
**platform_label
;
2014 size_t platform_labels
;
2019 index
= cb
->args
[0];
2020 if (index
< MPLS_LABEL_FIRST_UNRESERVED
)
2021 index
= MPLS_LABEL_FIRST_UNRESERVED
;
2023 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
2024 platform_labels
= net
->mpls
.platform_labels
;
2025 for (; index
< platform_labels
; index
++) {
2026 struct mpls_route
*rt
;
2027 rt
= rtnl_dereference(platform_label
[index
]);
2031 if (mpls_dump_route(skb
, NETLINK_CB(cb
->skb
).portid
,
2032 cb
->nlh
->nlmsg_seq
, RTM_NEWROUTE
,
2033 index
, rt
, NLM_F_MULTI
) < 0)
2036 cb
->args
[0] = index
;
2041 static inline size_t lfib_nlmsg_size(struct mpls_route
*rt
)
2044 NLMSG_ALIGN(sizeof(struct rtmsg
))
2045 + nla_total_size(4) /* RTA_DST */
2046 + nla_total_size(1); /* RTA_TTL_PROPAGATE */
2048 if (rt
->rt_nhn
== 1) {
2049 struct mpls_nh
*nh
= rt
->rt_nh
;
2052 payload
+= nla_total_size(4); /* RTA_OIF */
2053 if (nh
->nh_via_table
!= MPLS_NEIGH_TABLE_UNSPEC
) /* RTA_VIA */
2054 payload
+= nla_total_size(2 + nh
->nh_via_alen
);
2055 if (nh
->nh_labels
) /* RTA_NEWDST */
2056 payload
+= nla_total_size(nh
->nh_labels
* 4);
2058 /* each nexthop is packed in an attribute */
2062 if (!rtnl_dereference(nh
->nh_dev
))
2064 nhsize
+= nla_total_size(sizeof(struct rtnexthop
));
2066 if (nh
->nh_via_table
!= MPLS_NEIGH_TABLE_UNSPEC
)
2067 nhsize
+= nla_total_size(2 + nh
->nh_via_alen
);
2069 nhsize
+= nla_total_size(nh
->nh_labels
* 4);
2070 } endfor_nexthops(rt
);
2071 /* nested attribute */
2072 payload
+= nla_total_size(nhsize
);
2078 static void rtmsg_lfib(int event
, u32 label
, struct mpls_route
*rt
,
2079 struct nlmsghdr
*nlh
, struct net
*net
, u32 portid
,
2080 unsigned int nlm_flags
)
2082 struct sk_buff
*skb
;
2083 u32 seq
= nlh
? nlh
->nlmsg_seq
: 0;
2086 skb
= nlmsg_new(lfib_nlmsg_size(rt
), GFP_KERNEL
);
2090 err
= mpls_dump_route(skb
, portid
, seq
, event
, label
, rt
, nlm_flags
);
2092 /* -EMSGSIZE implies BUG in lfib_nlmsg_size */
2093 WARN_ON(err
== -EMSGSIZE
);
2097 rtnl_notify(skb
, net
, portid
, RTNLGRP_MPLS_ROUTE
, nlh
, GFP_KERNEL
);
2102 rtnl_set_sk_err(net
, RTNLGRP_MPLS_ROUTE
, err
);
2105 static int mpls_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
*in_nlh
,
2106 struct netlink_ext_ack
*extack
)
2108 struct net
*net
= sock_net(in_skb
->sk
);
2109 u32 portid
= NETLINK_CB(in_skb
).portid
;
2110 u32 in_label
= LABEL_NOT_SPECIFIED
;
2111 struct nlattr
*tb
[RTA_MAX
+ 1];
2112 u32 labels
[MAX_NEW_LABELS
];
2113 struct mpls_shim_hdr
*hdr
;
2114 unsigned int hdr_size
= 0;
2115 struct net_device
*dev
;
2116 struct mpls_route
*rt
;
2117 struct rtmsg
*rtm
, *r
;
2118 struct nlmsghdr
*nlh
;
2119 struct sk_buff
*skb
;
2124 err
= nlmsg_parse(in_nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
2125 rtm_mpls_policy
, extack
);
2129 rtm
= nlmsg_data(in_nlh
);
2134 if (nla_get_labels(tb
[RTA_DST
], 1, &label_count
,
2135 &in_label
, extack
)) {
2140 if (!mpls_label_ok(net
, in_label
, extack
)) {
2146 rt
= mpls_route_input_rcu(net
, in_label
);
2152 if (rtm
->rtm_flags
& RTM_F_FIB_MATCH
) {
2153 skb
= nlmsg_new(lfib_nlmsg_size(rt
), GFP_KERNEL
);
2159 err
= mpls_dump_route(skb
, portid
, in_nlh
->nlmsg_seq
,
2160 RTM_NEWROUTE
, in_label
, rt
, 0);
2162 /* -EMSGSIZE implies BUG in lfib_nlmsg_size */
2163 WARN_ON(err
== -EMSGSIZE
);
2167 return rtnl_unicast(skb
, net
, portid
);
2170 if (tb
[RTA_NEWDST
]) {
2171 if (nla_get_labels(tb
[RTA_NEWDST
], MAX_NEW_LABELS
, &n_labels
,
2172 labels
, extack
) != 0) {
2177 hdr_size
= n_labels
* sizeof(struct mpls_shim_hdr
);
2180 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
2186 skb
->protocol
= htons(ETH_P_MPLS_UC
);
2192 if (skb_cow(skb
, hdr_size
)) {
2197 skb_reserve(skb
, hdr_size
);
2198 skb_push(skb
, hdr_size
);
2199 skb_reset_network_header(skb
);
2201 /* Push new labels */
2202 hdr
= mpls_hdr(skb
);
2204 for (i
= n_labels
- 1; i
>= 0; i
--) {
2205 hdr
[i
] = mpls_entry_encode(labels
[i
],
2211 nh
= mpls_select_multipath(rt
, skb
);
2218 skb_pull(skb
, hdr_size
);
2219 skb_reset_network_header(skb
);
2222 nlh
= nlmsg_put(skb
, portid
, in_nlh
->nlmsg_seq
,
2223 RTM_NEWROUTE
, sizeof(*r
), 0);
2229 r
= nlmsg_data(nlh
);
2230 r
->rtm_family
= AF_MPLS
;
2231 r
->rtm_dst_len
= 20;
2233 r
->rtm_table
= RT_TABLE_MAIN
;
2234 r
->rtm_type
= RTN_UNICAST
;
2235 r
->rtm_scope
= RT_SCOPE_UNIVERSE
;
2236 r
->rtm_protocol
= rt
->rt_protocol
;
2239 if (nla_put_labels(skb
, RTA_DST
, 1, &in_label
))
2240 goto nla_put_failure
;
2242 if (nh
->nh_labels
&&
2243 nla_put_labels(skb
, RTA_NEWDST
, nh
->nh_labels
,
2245 goto nla_put_failure
;
2247 if (nh
->nh_via_table
!= MPLS_NEIGH_TABLE_UNSPEC
&&
2248 nla_put_via(skb
, nh
->nh_via_table
, mpls_nh_via(rt
, nh
),
2250 goto nla_put_failure
;
2251 dev
= rtnl_dereference(nh
->nh_dev
);
2252 if (dev
&& nla_put_u32(skb
, RTA_OIF
, dev
->ifindex
))
2253 goto nla_put_failure
;
2255 nlmsg_end(skb
, nlh
);
2257 err
= rtnl_unicast(skb
, net
, portid
);
2262 nlmsg_cancel(skb
, nlh
);
2269 static int resize_platform_label_table(struct net
*net
, size_t limit
)
2271 size_t size
= sizeof(struct mpls_route
*) * limit
;
2274 struct mpls_route __rcu
**labels
= NULL
, **old
;
2275 struct mpls_route
*rt0
= NULL
, *rt2
= NULL
;
2279 labels
= kvzalloc(size
, GFP_KERNEL
);
2284 /* In case the predefined labels need to be populated */
2285 if (limit
> MPLS_LABEL_IPV4NULL
) {
2286 struct net_device
*lo
= net
->loopback_dev
;
2287 rt0
= mpls_rt_alloc(1, lo
->addr_len
, 0);
2290 RCU_INIT_POINTER(rt0
->rt_nh
->nh_dev
, lo
);
2291 rt0
->rt_protocol
= RTPROT_KERNEL
;
2292 rt0
->rt_payload_type
= MPT_IPV4
;
2293 rt0
->rt_ttl_propagate
= MPLS_TTL_PROP_DEFAULT
;
2294 rt0
->rt_nh
->nh_via_table
= NEIGH_LINK_TABLE
;
2295 rt0
->rt_nh
->nh_via_alen
= lo
->addr_len
;
2296 memcpy(__mpls_nh_via(rt0
, rt0
->rt_nh
), lo
->dev_addr
,
2299 if (limit
> MPLS_LABEL_IPV6NULL
) {
2300 struct net_device
*lo
= net
->loopback_dev
;
2301 rt2
= mpls_rt_alloc(1, lo
->addr_len
, 0);
2304 RCU_INIT_POINTER(rt2
->rt_nh
->nh_dev
, lo
);
2305 rt2
->rt_protocol
= RTPROT_KERNEL
;
2306 rt2
->rt_payload_type
= MPT_IPV6
;
2307 rt2
->rt_ttl_propagate
= MPLS_TTL_PROP_DEFAULT
;
2308 rt2
->rt_nh
->nh_via_table
= NEIGH_LINK_TABLE
;
2309 rt2
->rt_nh
->nh_via_alen
= lo
->addr_len
;
2310 memcpy(__mpls_nh_via(rt2
, rt2
->rt_nh
), lo
->dev_addr
,
2315 /* Remember the original table */
2316 old
= rtnl_dereference(net
->mpls
.platform_label
);
2317 old_limit
= net
->mpls
.platform_labels
;
2319 /* Free any labels beyond the new table */
2320 for (index
= limit
; index
< old_limit
; index
++)
2321 mpls_route_update(net
, index
, NULL
, NULL
);
2323 /* Copy over the old labels */
2325 if (old_limit
< limit
)
2326 cp_size
= old_limit
* sizeof(struct mpls_route
*);
2328 memcpy(labels
, old
, cp_size
);
2330 /* If needed set the predefined labels */
2331 if ((old_limit
<= MPLS_LABEL_IPV6NULL
) &&
2332 (limit
> MPLS_LABEL_IPV6NULL
)) {
2333 RCU_INIT_POINTER(labels
[MPLS_LABEL_IPV6NULL
], rt2
);
2337 if ((old_limit
<= MPLS_LABEL_IPV4NULL
) &&
2338 (limit
> MPLS_LABEL_IPV4NULL
)) {
2339 RCU_INIT_POINTER(labels
[MPLS_LABEL_IPV4NULL
], rt0
);
2343 /* Update the global pointers */
2344 net
->mpls
.platform_labels
= limit
;
2345 rcu_assign_pointer(net
->mpls
.platform_label
, labels
);
2366 static int mpls_platform_labels(struct ctl_table
*table
, int write
,
2367 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
2369 struct net
*net
= table
->data
;
2370 int platform_labels
= net
->mpls
.platform_labels
;
2372 struct ctl_table tmp
= {
2373 .procname
= table
->procname
,
2374 .data
= &platform_labels
,
2375 .maxlen
= sizeof(int),
2376 .mode
= table
->mode
,
2378 .extra2
= &label_limit
,
2381 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
2383 if (write
&& ret
== 0)
2384 ret
= resize_platform_label_table(net
, platform_labels
);
2389 #define MPLS_NS_SYSCTL_OFFSET(field) \
2390 (&((struct net *)0)->field)
2392 static const struct ctl_table mpls_table
[] = {
2394 .procname
= "platform_labels",
2396 .maxlen
= sizeof(int),
2398 .proc_handler
= mpls_platform_labels
,
2401 .procname
= "ip_ttl_propagate",
2402 .data
= MPLS_NS_SYSCTL_OFFSET(mpls
.ip_ttl_propagate
),
2403 .maxlen
= sizeof(int),
2405 .proc_handler
= proc_dointvec_minmax
,
2410 .procname
= "default_ttl",
2411 .data
= MPLS_NS_SYSCTL_OFFSET(mpls
.default_ttl
),
2412 .maxlen
= sizeof(int),
2414 .proc_handler
= proc_dointvec_minmax
,
2421 static int mpls_net_init(struct net
*net
)
2423 struct ctl_table
*table
;
2426 net
->mpls
.platform_labels
= 0;
2427 net
->mpls
.platform_label
= NULL
;
2428 net
->mpls
.ip_ttl_propagate
= 1;
2429 net
->mpls
.default_ttl
= 255;
2431 table
= kmemdup(mpls_table
, sizeof(mpls_table
), GFP_KERNEL
);
2435 /* Table data contains only offsets relative to the base of
2436 * the mdev at this point, so make them absolute.
2438 for (i
= 0; i
< ARRAY_SIZE(mpls_table
) - 1; i
++)
2439 table
[i
].data
= (char *)net
+ (uintptr_t)table
[i
].data
;
2441 net
->mpls
.ctl
= register_net_sysctl(net
, "net/mpls", table
);
2442 if (net
->mpls
.ctl
== NULL
) {
2450 static void mpls_net_exit(struct net
*net
)
2452 struct mpls_route __rcu
**platform_label
;
2453 size_t platform_labels
;
2454 struct ctl_table
*table
;
2457 table
= net
->mpls
.ctl
->ctl_table_arg
;
2458 unregister_net_sysctl_table(net
->mpls
.ctl
);
2461 /* An rcu grace period has passed since there was a device in
2462 * the network namespace (and thus the last in flight packet)
2463 * left this network namespace. This is because
2464 * unregister_netdevice_many and netdev_run_todo has completed
2465 * for each network device that was in this network namespace.
2467 * As such no additional rcu synchronization is necessary when
2468 * freeing the platform_label table.
2471 platform_label
= rtnl_dereference(net
->mpls
.platform_label
);
2472 platform_labels
= net
->mpls
.platform_labels
;
2473 for (index
= 0; index
< platform_labels
; index
++) {
2474 struct mpls_route
*rt
= rtnl_dereference(platform_label
[index
]);
2475 RCU_INIT_POINTER(platform_label
[index
], NULL
);
2476 mpls_notify_route(net
, index
, rt
, NULL
, NULL
);
2481 kvfree(platform_label
);
2484 static struct pernet_operations mpls_net_ops
= {
2485 .init
= mpls_net_init
,
2486 .exit
= mpls_net_exit
,
2489 static struct rtnl_af_ops mpls_af_ops __read_mostly
= {
2491 .fill_stats_af
= mpls_fill_stats_af
,
2492 .get_stats_af_size
= mpls_get_stats_af_size
,
2495 static int __init
mpls_init(void)
2499 BUILD_BUG_ON(sizeof(struct mpls_shim_hdr
) != 4);
2501 err
= register_pernet_subsys(&mpls_net_ops
);
2505 err
= register_netdevice_notifier(&mpls_dev_notifier
);
2507 goto out_unregister_pernet
;
2509 dev_add_pack(&mpls_packet_type
);
2511 rtnl_af_register(&mpls_af_ops
);
2513 rtnl_register(PF_MPLS
, RTM_NEWROUTE
, mpls_rtm_newroute
, NULL
, 0);
2514 rtnl_register(PF_MPLS
, RTM_DELROUTE
, mpls_rtm_delroute
, NULL
, 0);
2515 rtnl_register(PF_MPLS
, RTM_GETROUTE
, mpls_getroute
, mpls_dump_routes
,
2517 rtnl_register(PF_MPLS
, RTM_GETNETCONF
, mpls_netconf_get_devconf
,
2518 mpls_netconf_dump_devconf
, 0);
2519 err
= ipgre_tunnel_encap_add_mpls_ops();
2521 pr_err("Can't add mpls over gre tunnel ops\n");
2527 out_unregister_pernet
:
2528 unregister_pernet_subsys(&mpls_net_ops
);
2531 module_init(mpls_init
);
2533 static void __exit
mpls_exit(void)
2535 rtnl_unregister_all(PF_MPLS
);
2536 rtnl_af_unregister(&mpls_af_ops
);
2537 dev_remove_pack(&mpls_packet_type
);
2538 unregister_netdevice_notifier(&mpls_dev_notifier
);
2539 unregister_pernet_subsys(&mpls_net_ops
);
2540 ipgre_tunnel_encap_del_mpls_ops();
2542 module_exit(mpls_exit
);
2544 MODULE_DESCRIPTION("MultiProtocol Label Switching");
2545 MODULE_LICENSE("GPL v2");
2546 MODULE_ALIAS_NETPROTO(PF_MPLS
);