Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Bareudp: UDP  tunnel encasulation for different Payload types like
0003  * MPLS, NSH, IP, etc.
0004  * Copyright (c) 2019 Nokia, Inc.
0005  * Authors:  Martin Varghese, <martin.varghese@nokia.com>
0006  */
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/etherdevice.h>
0013 #include <linux/hash.h>
0014 #include <net/dst_metadata.h>
0015 #include <net/gro_cells.h>
0016 #include <net/rtnetlink.h>
0017 #include <net/protocol.h>
0018 #include <net/ip6_tunnel.h>
0019 #include <net/ip_tunnels.h>
0020 #include <net/udp_tunnel.h>
0021 #include <net/bareudp.h>
0022 
0023 #define BAREUDP_BASE_HLEN sizeof(struct udphdr)
0024 #define BAREUDP_IPV4_HLEN (sizeof(struct iphdr) + \
0025                sizeof(struct udphdr))
0026 #define BAREUDP_IPV6_HLEN (sizeof(struct ipv6hdr) + \
0027                sizeof(struct udphdr))
0028 
0029 static bool log_ecn_error = true;
0030 module_param(log_ecn_error, bool, 0644);
0031 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
0032 
0033 /* per-network namespace private data for this module */
0034 
0035 static unsigned int bareudp_net_id;
0036 
0037 struct bareudp_net {
0038     struct list_head        bareudp_list;
0039 };
0040 
0041 struct bareudp_conf {
0042     __be16 ethertype;
0043     __be16 port;
0044     u16 sport_min;
0045     bool multi_proto_mode;
0046 };
0047 
0048 /* Pseudo network device */
0049 struct bareudp_dev {
0050     struct net         *net;        /* netns for packet i/o */
0051     struct net_device  *dev;        /* netdev for bareudp tunnel */
0052     __be16         ethertype;
0053     __be16             port;
0054     u16            sport_min;
0055     bool               multi_proto_mode;
0056     struct socket      __rcu *sock;
0057     struct list_head   next;        /* bareudp node  on namespace list */
0058     struct gro_cells   gro_cells;
0059 };
0060 
0061 static int bareudp_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
0062 {
0063     struct metadata_dst *tun_dst = NULL;
0064     struct bareudp_dev *bareudp;
0065     unsigned short family;
0066     unsigned int len;
0067     __be16 proto;
0068     void *oiph;
0069     int err;
0070 
0071     bareudp = rcu_dereference_sk_user_data(sk);
0072     if (!bareudp)
0073         goto drop;
0074 
0075     if (skb->protocol ==  htons(ETH_P_IP))
0076         family = AF_INET;
0077     else
0078         family = AF_INET6;
0079 
0080     if (bareudp->ethertype == htons(ETH_P_IP)) {
0081         __u8 ipversion;
0082 
0083         if (skb_copy_bits(skb, BAREUDP_BASE_HLEN, &ipversion,
0084                   sizeof(ipversion))) {
0085             bareudp->dev->stats.rx_dropped++;
0086             goto drop;
0087         }
0088         ipversion >>= 4;
0089 
0090         if (ipversion == 4) {
0091             proto = htons(ETH_P_IP);
0092         } else if (ipversion == 6 && bareudp->multi_proto_mode) {
0093             proto = htons(ETH_P_IPV6);
0094         } else {
0095             bareudp->dev->stats.rx_dropped++;
0096             goto drop;
0097         }
0098     } else if (bareudp->ethertype == htons(ETH_P_MPLS_UC)) {
0099         struct iphdr *tunnel_hdr;
0100 
0101         tunnel_hdr = (struct iphdr *)skb_network_header(skb);
0102         if (tunnel_hdr->version == 4) {
0103             if (!ipv4_is_multicast(tunnel_hdr->daddr)) {
0104                 proto = bareudp->ethertype;
0105             } else if (bareudp->multi_proto_mode &&
0106                    ipv4_is_multicast(tunnel_hdr->daddr)) {
0107                 proto = htons(ETH_P_MPLS_MC);
0108             } else {
0109                 bareudp->dev->stats.rx_dropped++;
0110                 goto drop;
0111             }
0112         } else {
0113             int addr_type;
0114             struct ipv6hdr *tunnel_hdr_v6;
0115 
0116             tunnel_hdr_v6 = (struct ipv6hdr *)skb_network_header(skb);
0117             addr_type =
0118             ipv6_addr_type((struct in6_addr *)&tunnel_hdr_v6->daddr);
0119             if (!(addr_type & IPV6_ADDR_MULTICAST)) {
0120                 proto = bareudp->ethertype;
0121             } else if (bareudp->multi_proto_mode &&
0122                    (addr_type & IPV6_ADDR_MULTICAST)) {
0123                 proto = htons(ETH_P_MPLS_MC);
0124             } else {
0125                 bareudp->dev->stats.rx_dropped++;
0126                 goto drop;
0127             }
0128         }
0129     } else {
0130         proto = bareudp->ethertype;
0131     }
0132 
0133     if (iptunnel_pull_header(skb, BAREUDP_BASE_HLEN,
0134                  proto,
0135                  !net_eq(bareudp->net,
0136                  dev_net(bareudp->dev)))) {
0137         bareudp->dev->stats.rx_dropped++;
0138         goto drop;
0139     }
0140     tun_dst = udp_tun_rx_dst(skb, family, TUNNEL_KEY, 0, 0);
0141     if (!tun_dst) {
0142         bareudp->dev->stats.rx_dropped++;
0143         goto drop;
0144     }
0145     skb_dst_set(skb, &tun_dst->dst);
0146     skb->dev = bareudp->dev;
0147     oiph = skb_network_header(skb);
0148     skb_reset_network_header(skb);
0149     skb_reset_mac_header(skb);
0150 
0151     if (!ipv6_mod_enabled() || family == AF_INET)
0152         err = IP_ECN_decapsulate(oiph, skb);
0153     else
0154         err = IP6_ECN_decapsulate(oiph, skb);
0155 
0156     if (unlikely(err)) {
0157         if (log_ecn_error) {
0158             if  (!ipv6_mod_enabled() || family == AF_INET)
0159                 net_info_ratelimited("non-ECT from %pI4 "
0160                              "with TOS=%#x\n",
0161                              &((struct iphdr *)oiph)->saddr,
0162                              ((struct iphdr *)oiph)->tos);
0163             else
0164                 net_info_ratelimited("non-ECT from %pI6\n",
0165                              &((struct ipv6hdr *)oiph)->saddr);
0166         }
0167         if (err > 1) {
0168             ++bareudp->dev->stats.rx_frame_errors;
0169             ++bareudp->dev->stats.rx_errors;
0170             goto drop;
0171         }
0172     }
0173 
0174     len = skb->len;
0175     err = gro_cells_receive(&bareudp->gro_cells, skb);
0176     if (likely(err == NET_RX_SUCCESS))
0177         dev_sw_netstats_rx_add(bareudp->dev, len);
0178 
0179     return 0;
0180 drop:
0181     /* Consume bad packet */
0182     kfree_skb(skb);
0183 
0184     return 0;
0185 }
0186 
0187 static int bareudp_err_lookup(struct sock *sk, struct sk_buff *skb)
0188 {
0189     return 0;
0190 }
0191 
0192 static int bareudp_init(struct net_device *dev)
0193 {
0194     struct bareudp_dev *bareudp = netdev_priv(dev);
0195     int err;
0196 
0197     dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
0198     if (!dev->tstats)
0199         return -ENOMEM;
0200 
0201     err = gro_cells_init(&bareudp->gro_cells, dev);
0202     if (err) {
0203         free_percpu(dev->tstats);
0204         return err;
0205     }
0206     return 0;
0207 }
0208 
0209 static void bareudp_uninit(struct net_device *dev)
0210 {
0211     struct bareudp_dev *bareudp = netdev_priv(dev);
0212 
0213     gro_cells_destroy(&bareudp->gro_cells);
0214     free_percpu(dev->tstats);
0215 }
0216 
0217 static struct socket *bareudp_create_sock(struct net *net, __be16 port)
0218 {
0219     struct udp_port_cfg udp_conf;
0220     struct socket *sock;
0221     int err;
0222 
0223     memset(&udp_conf, 0, sizeof(udp_conf));
0224 
0225     if (ipv6_mod_enabled())
0226         udp_conf.family = AF_INET6;
0227     else
0228         udp_conf.family = AF_INET;
0229 
0230     udp_conf.local_udp_port = port;
0231     /* Open UDP socket */
0232     err = udp_sock_create(net, &udp_conf, &sock);
0233     if (err < 0)
0234         return ERR_PTR(err);
0235 
0236     udp_allow_gso(sock->sk);
0237     return sock;
0238 }
0239 
0240 /* Create new listen socket if needed */
0241 static int bareudp_socket_create(struct bareudp_dev *bareudp, __be16 port)
0242 {
0243     struct udp_tunnel_sock_cfg tunnel_cfg;
0244     struct socket *sock;
0245 
0246     sock = bareudp_create_sock(bareudp->net, port);
0247     if (IS_ERR(sock))
0248         return PTR_ERR(sock);
0249 
0250     /* Mark socket as an encapsulation socket */
0251     memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
0252     tunnel_cfg.sk_user_data = bareudp;
0253     tunnel_cfg.encap_type = 1;
0254     tunnel_cfg.encap_rcv = bareudp_udp_encap_recv;
0255     tunnel_cfg.encap_err_lookup = bareudp_err_lookup;
0256     tunnel_cfg.encap_destroy = NULL;
0257     setup_udp_tunnel_sock(bareudp->net, sock, &tunnel_cfg);
0258 
0259     rcu_assign_pointer(bareudp->sock, sock);
0260     return 0;
0261 }
0262 
0263 static int bareudp_open(struct net_device *dev)
0264 {
0265     struct bareudp_dev *bareudp = netdev_priv(dev);
0266     int ret = 0;
0267 
0268     ret =  bareudp_socket_create(bareudp, bareudp->port);
0269     return ret;
0270 }
0271 
0272 static void bareudp_sock_release(struct bareudp_dev *bareudp)
0273 {
0274     struct socket *sock;
0275 
0276     sock = bareudp->sock;
0277     rcu_assign_pointer(bareudp->sock, NULL);
0278     synchronize_net();
0279     udp_tunnel_sock_release(sock);
0280 }
0281 
0282 static int bareudp_stop(struct net_device *dev)
0283 {
0284     struct bareudp_dev *bareudp = netdev_priv(dev);
0285 
0286     bareudp_sock_release(bareudp);
0287     return 0;
0288 }
0289 
0290 static int bareudp_xmit_skb(struct sk_buff *skb, struct net_device *dev,
0291                 struct bareudp_dev *bareudp,
0292                 const struct ip_tunnel_info *info)
0293 {
0294     bool xnet = !net_eq(bareudp->net, dev_net(bareudp->dev));
0295     bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
0296     struct socket *sock = rcu_dereference(bareudp->sock);
0297     bool udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
0298     const struct ip_tunnel_key *key = &info->key;
0299     struct rtable *rt;
0300     __be16 sport, df;
0301     int min_headroom;
0302     __u8 tos, ttl;
0303     __be32 saddr;
0304     int err;
0305 
0306     if (!sock)
0307         return -ESHUTDOWN;
0308 
0309     rt = ip_route_output_tunnel(skb, dev, bareudp->net, &saddr, info,
0310                     IPPROTO_UDP, use_cache);
0311 
0312     if (IS_ERR(rt))
0313         return PTR_ERR(rt);
0314 
0315     skb_tunnel_check_pmtu(skb, &rt->dst,
0316                   BAREUDP_IPV4_HLEN + info->options_len, false);
0317 
0318     sport = udp_flow_src_port(bareudp->net, skb,
0319                   bareudp->sport_min, USHRT_MAX,
0320                   true);
0321     tos = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
0322     ttl = key->ttl;
0323     df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
0324     skb_scrub_packet(skb, xnet);
0325 
0326     err = -ENOSPC;
0327     if (!skb_pull(skb, skb_network_offset(skb)))
0328         goto free_dst;
0329 
0330     min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len +
0331         BAREUDP_BASE_HLEN + info->options_len + sizeof(struct iphdr);
0332 
0333     err = skb_cow_head(skb, min_headroom);
0334     if (unlikely(err))
0335         goto free_dst;
0336 
0337     err = udp_tunnel_handle_offloads(skb, udp_sum);
0338     if (err)
0339         goto free_dst;
0340 
0341     skb_set_inner_protocol(skb, bareudp->ethertype);
0342     udp_tunnel_xmit_skb(rt, sock->sk, skb, saddr, info->key.u.ipv4.dst,
0343                 tos, ttl, df, sport, bareudp->port,
0344                 !net_eq(bareudp->net, dev_net(bareudp->dev)),
0345                 !(info->key.tun_flags & TUNNEL_CSUM));
0346     return 0;
0347 
0348 free_dst:
0349     dst_release(&rt->dst);
0350     return err;
0351 }
0352 
0353 static int bareudp6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
0354                  struct bareudp_dev *bareudp,
0355                  const struct ip_tunnel_info *info)
0356 {
0357     bool xnet = !net_eq(bareudp->net, dev_net(bareudp->dev));
0358     bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
0359     struct socket *sock  = rcu_dereference(bareudp->sock);
0360     bool udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
0361     const struct ip_tunnel_key *key = &info->key;
0362     struct dst_entry *dst = NULL;
0363     struct in6_addr saddr, daddr;
0364     int min_headroom;
0365     __u8 prio, ttl;
0366     __be16 sport;
0367     int err;
0368 
0369     if (!sock)
0370         return -ESHUTDOWN;
0371 
0372     dst = ip6_dst_lookup_tunnel(skb, dev, bareudp->net, sock, &saddr, info,
0373                     IPPROTO_UDP, use_cache);
0374     if (IS_ERR(dst))
0375         return PTR_ERR(dst);
0376 
0377     skb_tunnel_check_pmtu(skb, dst, BAREUDP_IPV6_HLEN + info->options_len,
0378                   false);
0379 
0380     sport = udp_flow_src_port(bareudp->net, skb,
0381                   bareudp->sport_min, USHRT_MAX,
0382                   true);
0383     prio = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
0384     ttl = key->ttl;
0385 
0386     skb_scrub_packet(skb, xnet);
0387 
0388     err = -ENOSPC;
0389     if (!skb_pull(skb, skb_network_offset(skb)))
0390         goto free_dst;
0391 
0392     min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
0393         BAREUDP_BASE_HLEN + info->options_len + sizeof(struct ipv6hdr);
0394 
0395     err = skb_cow_head(skb, min_headroom);
0396     if (unlikely(err))
0397         goto free_dst;
0398 
0399     err = udp_tunnel_handle_offloads(skb, udp_sum);
0400     if (err)
0401         goto free_dst;
0402 
0403     daddr = info->key.u.ipv6.dst;
0404     udp_tunnel6_xmit_skb(dst, sock->sk, skb, dev,
0405                  &saddr, &daddr, prio, ttl,
0406                  info->key.label, sport, bareudp->port,
0407                  !(info->key.tun_flags & TUNNEL_CSUM));
0408     return 0;
0409 
0410 free_dst:
0411     dst_release(dst);
0412     return err;
0413 }
0414 
0415 static bool bareudp_proto_valid(struct bareudp_dev *bareudp, __be16 proto)
0416 {
0417     if (bareudp->ethertype == proto)
0418         return true;
0419 
0420     if (!bareudp->multi_proto_mode)
0421         return false;
0422 
0423     if (bareudp->ethertype == htons(ETH_P_MPLS_UC) &&
0424         proto == htons(ETH_P_MPLS_MC))
0425         return true;
0426 
0427     if (bareudp->ethertype == htons(ETH_P_IP) &&
0428         proto == htons(ETH_P_IPV6))
0429         return true;
0430 
0431     return false;
0432 }
0433 
0434 static netdev_tx_t bareudp_xmit(struct sk_buff *skb, struct net_device *dev)
0435 {
0436     struct bareudp_dev *bareudp = netdev_priv(dev);
0437     struct ip_tunnel_info *info = NULL;
0438     int err;
0439 
0440     if (!bareudp_proto_valid(bareudp, skb->protocol)) {
0441         err = -EINVAL;
0442         goto tx_error;
0443     }
0444 
0445     info = skb_tunnel_info(skb);
0446     if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
0447         err = -EINVAL;
0448         goto tx_error;
0449     }
0450 
0451     rcu_read_lock();
0452     if (ipv6_mod_enabled() && info->mode & IP_TUNNEL_INFO_IPV6)
0453         err = bareudp6_xmit_skb(skb, dev, bareudp, info);
0454     else
0455         err = bareudp_xmit_skb(skb, dev, bareudp, info);
0456 
0457     rcu_read_unlock();
0458 
0459     if (likely(!err))
0460         return NETDEV_TX_OK;
0461 tx_error:
0462     dev_kfree_skb(skb);
0463 
0464     if (err == -ELOOP)
0465         dev->stats.collisions++;
0466     else if (err == -ENETUNREACH)
0467         dev->stats.tx_carrier_errors++;
0468 
0469     dev->stats.tx_errors++;
0470     return NETDEV_TX_OK;
0471 }
0472 
0473 static int bareudp_fill_metadata_dst(struct net_device *dev,
0474                      struct sk_buff *skb)
0475 {
0476     struct ip_tunnel_info *info = skb_tunnel_info(skb);
0477     struct bareudp_dev *bareudp = netdev_priv(dev);
0478     bool use_cache;
0479 
0480     use_cache = ip_tunnel_dst_cache_usable(skb, info);
0481 
0482     if (!ipv6_mod_enabled() || ip_tunnel_info_af(info) == AF_INET) {
0483         struct rtable *rt;
0484         __be32 saddr;
0485 
0486         rt = ip_route_output_tunnel(skb, dev, bareudp->net, &saddr,
0487                         info, IPPROTO_UDP, use_cache);
0488         if (IS_ERR(rt))
0489             return PTR_ERR(rt);
0490 
0491         ip_rt_put(rt);
0492         info->key.u.ipv4.src = saddr;
0493     } else if (ip_tunnel_info_af(info) == AF_INET6) {
0494         struct dst_entry *dst;
0495         struct in6_addr saddr;
0496         struct socket *sock = rcu_dereference(bareudp->sock);
0497 
0498         dst = ip6_dst_lookup_tunnel(skb, dev, bareudp->net, sock,
0499                         &saddr, info, IPPROTO_UDP,
0500                         use_cache);
0501         if (IS_ERR(dst))
0502             return PTR_ERR(dst);
0503 
0504         dst_release(dst);
0505         info->key.u.ipv6.src = saddr;
0506     } else {
0507         return -EINVAL;
0508     }
0509 
0510     info->key.tp_src = udp_flow_src_port(bareudp->net, skb,
0511                          bareudp->sport_min,
0512             USHRT_MAX, true);
0513     info->key.tp_dst = bareudp->port;
0514     return 0;
0515 }
0516 
0517 static const struct net_device_ops bareudp_netdev_ops = {
0518     .ndo_init               = bareudp_init,
0519     .ndo_uninit             = bareudp_uninit,
0520     .ndo_open               = bareudp_open,
0521     .ndo_stop               = bareudp_stop,
0522     .ndo_start_xmit         = bareudp_xmit,
0523     .ndo_get_stats64        = dev_get_tstats64,
0524     .ndo_fill_metadata_dst  = bareudp_fill_metadata_dst,
0525 };
0526 
0527 static const struct nla_policy bareudp_policy[IFLA_BAREUDP_MAX + 1] = {
0528     [IFLA_BAREUDP_PORT]                = { .type = NLA_U16 },
0529     [IFLA_BAREUDP_ETHERTYPE]       = { .type = NLA_U16 },
0530     [IFLA_BAREUDP_SRCPORT_MIN]         = { .type = NLA_U16 },
0531     [IFLA_BAREUDP_MULTIPROTO_MODE]     = { .type = NLA_FLAG },
0532 };
0533 
0534 /* Info for udev, that this is a virtual tunnel endpoint */
0535 static const struct device_type bareudp_type = {
0536     .name = "bareudp",
0537 };
0538 
0539 /* Initialize the device structure. */
0540 static void bareudp_setup(struct net_device *dev)
0541 {
0542     dev->netdev_ops = &bareudp_netdev_ops;
0543     dev->needs_free_netdev = true;
0544     SET_NETDEV_DEVTYPE(dev, &bareudp_type);
0545     dev->features    |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;
0546     dev->features    |= NETIF_F_RXCSUM;
0547     dev->features    |= NETIF_F_LLTX;
0548     dev->features    |= NETIF_F_GSO_SOFTWARE;
0549     dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;
0550     dev->hw_features |= NETIF_F_RXCSUM;
0551     dev->hw_features |= NETIF_F_GSO_SOFTWARE;
0552     dev->hard_header_len = 0;
0553     dev->addr_len = 0;
0554     dev->mtu = ETH_DATA_LEN;
0555     dev->min_mtu = IPV4_MIN_MTU;
0556     dev->max_mtu = IP_MAX_MTU - BAREUDP_BASE_HLEN;
0557     dev->type = ARPHRD_NONE;
0558     netif_keep_dst(dev);
0559     dev->priv_flags |= IFF_NO_QUEUE;
0560     dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
0561 }
0562 
0563 static int bareudp_validate(struct nlattr *tb[], struct nlattr *data[],
0564                 struct netlink_ext_ack *extack)
0565 {
0566     if (!data) {
0567         NL_SET_ERR_MSG(extack,
0568                    "Not enough attributes provided to perform the operation");
0569         return -EINVAL;
0570     }
0571     return 0;
0572 }
0573 
0574 static int bareudp2info(struct nlattr *data[], struct bareudp_conf *conf,
0575             struct netlink_ext_ack *extack)
0576 {
0577     memset(conf, 0, sizeof(*conf));
0578 
0579     if (!data[IFLA_BAREUDP_PORT]) {
0580         NL_SET_ERR_MSG(extack, "port not specified");
0581         return -EINVAL;
0582     }
0583     if (!data[IFLA_BAREUDP_ETHERTYPE]) {
0584         NL_SET_ERR_MSG(extack, "ethertype not specified");
0585         return -EINVAL;
0586     }
0587 
0588     conf->port = nla_get_u16(data[IFLA_BAREUDP_PORT]);
0589     conf->ethertype = nla_get_u16(data[IFLA_BAREUDP_ETHERTYPE]);
0590 
0591     if (data[IFLA_BAREUDP_SRCPORT_MIN])
0592         conf->sport_min =  nla_get_u16(data[IFLA_BAREUDP_SRCPORT_MIN]);
0593 
0594     if (data[IFLA_BAREUDP_MULTIPROTO_MODE])
0595         conf->multi_proto_mode = true;
0596 
0597     return 0;
0598 }
0599 
0600 static struct bareudp_dev *bareudp_find_dev(struct bareudp_net *bn,
0601                         const struct bareudp_conf *conf)
0602 {
0603     struct bareudp_dev *bareudp, *t = NULL;
0604 
0605     list_for_each_entry(bareudp, &bn->bareudp_list, next) {
0606         if (conf->port == bareudp->port)
0607             t = bareudp;
0608     }
0609     return t;
0610 }
0611 
0612 static int bareudp_configure(struct net *net, struct net_device *dev,
0613                  struct bareudp_conf *conf,
0614                  struct netlink_ext_ack *extack)
0615 {
0616     struct bareudp_net *bn = net_generic(net, bareudp_net_id);
0617     struct bareudp_dev *t, *bareudp = netdev_priv(dev);
0618     int err;
0619 
0620     bareudp->net = net;
0621     bareudp->dev = dev;
0622     t = bareudp_find_dev(bn, conf);
0623     if (t) {
0624         NL_SET_ERR_MSG(extack, "Another bareudp device using the same port already exists");
0625         return -EBUSY;
0626     }
0627 
0628     if (conf->multi_proto_mode &&
0629         (conf->ethertype != htons(ETH_P_MPLS_UC) &&
0630          conf->ethertype != htons(ETH_P_IP))) {
0631         NL_SET_ERR_MSG(extack, "Cannot set multiproto mode for this ethertype (only IPv4 and unicast MPLS are supported)");
0632         return -EINVAL;
0633     }
0634 
0635     bareudp->port = conf->port;
0636     bareudp->ethertype = conf->ethertype;
0637     bareudp->sport_min = conf->sport_min;
0638     bareudp->multi_proto_mode = conf->multi_proto_mode;
0639 
0640     err = register_netdevice(dev);
0641     if (err)
0642         return err;
0643 
0644     list_add(&bareudp->next, &bn->bareudp_list);
0645     return 0;
0646 }
0647 
0648 static int bareudp_link_config(struct net_device *dev,
0649                    struct nlattr *tb[])
0650 {
0651     int err;
0652 
0653     if (tb[IFLA_MTU]) {
0654         err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
0655         if (err)
0656             return err;
0657     }
0658     return 0;
0659 }
0660 
0661 static void bareudp_dellink(struct net_device *dev, struct list_head *head)
0662 {
0663     struct bareudp_dev *bareudp = netdev_priv(dev);
0664 
0665     list_del(&bareudp->next);
0666     unregister_netdevice_queue(dev, head);
0667 }
0668 
0669 static int bareudp_newlink(struct net *net, struct net_device *dev,
0670                struct nlattr *tb[], struct nlattr *data[],
0671                struct netlink_ext_ack *extack)
0672 {
0673     struct bareudp_conf conf;
0674     int err;
0675 
0676     err = bareudp2info(data, &conf, extack);
0677     if (err)
0678         return err;
0679 
0680     err = bareudp_configure(net, dev, &conf, extack);
0681     if (err)
0682         return err;
0683 
0684     err = bareudp_link_config(dev, tb);
0685     if (err)
0686         goto err_unconfig;
0687 
0688     return 0;
0689 
0690 err_unconfig:
0691     bareudp_dellink(dev, NULL);
0692     return err;
0693 }
0694 
0695 static size_t bareudp_get_size(const struct net_device *dev)
0696 {
0697     return  nla_total_size(sizeof(__be16)) +  /* IFLA_BAREUDP_PORT */
0698         nla_total_size(sizeof(__be16)) +  /* IFLA_BAREUDP_ETHERTYPE */
0699         nla_total_size(sizeof(__u16))  +  /* IFLA_BAREUDP_SRCPORT_MIN */
0700         nla_total_size(0)              +  /* IFLA_BAREUDP_MULTIPROTO_MODE */
0701         0;
0702 }
0703 
0704 static int bareudp_fill_info(struct sk_buff *skb, const struct net_device *dev)
0705 {
0706     struct bareudp_dev *bareudp = netdev_priv(dev);
0707 
0708     if (nla_put_be16(skb, IFLA_BAREUDP_PORT, bareudp->port))
0709         goto nla_put_failure;
0710     if (nla_put_be16(skb, IFLA_BAREUDP_ETHERTYPE, bareudp->ethertype))
0711         goto nla_put_failure;
0712     if (nla_put_u16(skb, IFLA_BAREUDP_SRCPORT_MIN, bareudp->sport_min))
0713         goto nla_put_failure;
0714     if (bareudp->multi_proto_mode &&
0715         nla_put_flag(skb, IFLA_BAREUDP_MULTIPROTO_MODE))
0716         goto nla_put_failure;
0717 
0718     return 0;
0719 
0720 nla_put_failure:
0721     return -EMSGSIZE;
0722 }
0723 
0724 static struct rtnl_link_ops bareudp_link_ops __read_mostly = {
0725     .kind           = "bareudp",
0726     .maxtype        = IFLA_BAREUDP_MAX,
0727     .policy         = bareudp_policy,
0728     .priv_size      = sizeof(struct bareudp_dev),
0729     .setup          = bareudp_setup,
0730     .validate       = bareudp_validate,
0731     .newlink        = bareudp_newlink,
0732     .dellink        = bareudp_dellink,
0733     .get_size       = bareudp_get_size,
0734     .fill_info      = bareudp_fill_info,
0735 };
0736 
0737 static __net_init int bareudp_init_net(struct net *net)
0738 {
0739     struct bareudp_net *bn = net_generic(net, bareudp_net_id);
0740 
0741     INIT_LIST_HEAD(&bn->bareudp_list);
0742     return 0;
0743 }
0744 
0745 static void bareudp_destroy_tunnels(struct net *net, struct list_head *head)
0746 {
0747     struct bareudp_net *bn = net_generic(net, bareudp_net_id);
0748     struct bareudp_dev *bareudp, *next;
0749 
0750     list_for_each_entry_safe(bareudp, next, &bn->bareudp_list, next)
0751         unregister_netdevice_queue(bareudp->dev, head);
0752 }
0753 
0754 static void __net_exit bareudp_exit_batch_net(struct list_head *net_list)
0755 {
0756     struct net *net;
0757     LIST_HEAD(list);
0758 
0759     rtnl_lock();
0760     list_for_each_entry(net, net_list, exit_list)
0761         bareudp_destroy_tunnels(net, &list);
0762 
0763     /* unregister the devices gathered above */
0764     unregister_netdevice_many(&list);
0765     rtnl_unlock();
0766 }
0767 
0768 static struct pernet_operations bareudp_net_ops = {
0769     .init = bareudp_init_net,
0770     .exit_batch = bareudp_exit_batch_net,
0771     .id   = &bareudp_net_id,
0772     .size = sizeof(struct bareudp_net),
0773 };
0774 
0775 static int __init bareudp_init_module(void)
0776 {
0777     int rc;
0778 
0779     rc = register_pernet_subsys(&bareudp_net_ops);
0780     if (rc)
0781         goto out1;
0782 
0783     rc = rtnl_link_register(&bareudp_link_ops);
0784     if (rc)
0785         goto out2;
0786 
0787     return 0;
0788 out2:
0789     unregister_pernet_subsys(&bareudp_net_ops);
0790 out1:
0791     return rc;
0792 }
0793 late_initcall(bareudp_init_module);
0794 
0795 static void __exit bareudp_cleanup_module(void)
0796 {
0797     rtnl_link_unregister(&bareudp_link_ops);
0798     unregister_pernet_subsys(&bareudp_net_ops);
0799 }
0800 module_exit(bareudp_cleanup_module);
0801 
0802 MODULE_ALIAS_RTNL_LINK("bareudp");
0803 MODULE_LICENSE("GPL");
0804 MODULE_AUTHOR("Martin Varghese <martin.varghese@nokia.com>");
0805 MODULE_DESCRIPTION("Interface driver for UDP encapsulated traffic");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!