net/core/lwtunnel.c

   1 /*
   2  * lwtunnel     Infrastructure for light weight tunnels like mpls
   3  *
   4  * Authors:     Roopa Prabhu, <roopa@cumulusnetworks.com>
   5  *
   6  *              This program is free software; you can redistribute it and/or
   7  *              modify it under the terms of the GNU General Public License
   8  *              as published by the Free Software Foundation; either version
   9  *              2 of the License, or (at your option) any later version.
  10  *
  11  */
  12
  13 #include <linux/capability.h>
  14 #include <linux/module.h>
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/slab.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/skbuff.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/lwtunnel.h>
  22 #include <linux/in.h>
  23 #include <linux/init.h>
  24 #include <linux/err.h>
  25
  26 #include <net/lwtunnel.h>
  27 #include <net/rtnetlink.h>
  28 #include <net/ip6_fib.h>
  29 #include <net/nexthop.h>
  30
  31 #ifdef CONFIG_MODULES
  32
  33 static const char *lwtunnel_encap_str(enum lwtunnel_encap_types encap_type)
  34 {
  35         /* Only lwt encaps implemented without using an interface for
  36          * the encap need to return a string here.
  37          */
  38         switch (encap_type) {
  39         case LWTUNNEL_ENCAP_MPLS:
  40                 return "MPLS";
  41         case LWTUNNEL_ENCAP_ILA:
  42                 return "ILA";
  43         case LWTUNNEL_ENCAP_SEG6:
  44                 return "SEG6";
  45         case LWTUNNEL_ENCAP_BPF:
  46                 return "BPF";
  47         case LWTUNNEL_ENCAP_SEG6_LOCAL:
  48                 return "SEG6LOCAL";
  49         case LWTUNNEL_ENCAP_IP6:
  50         case LWTUNNEL_ENCAP_IP:
  51         case LWTUNNEL_ENCAP_NONE:
  52         case __LWTUNNEL_ENCAP_MAX:
  53                 /* should not have got here */
  54                 WARN_ON(1);
  55                 break;
  56         }
  57         return NULL;
  58 }
  59
  60 #endif /* CONFIG_MODULES */
  61
  62 struct lwtunnel_state *lwtunnel_state_alloc(int encap_len)
  63 {
  64         struct lwtunnel_state *lws;
  65
  66         lws = kzalloc(sizeof(*lws) + encap_len, GFP_ATOMIC);
  67
  68         return lws;
  69 }
  70 EXPORT_SYMBOL_GPL(lwtunnel_state_alloc);
  71
  72 static const struct lwtunnel_encap_ops __rcu *
  73                 lwtun_encaps[LWTUNNEL_ENCAP_MAX + 1] __read_mostly;
  74
  75 int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *ops,
  76                            unsigned int num)
  77 {
  78         if (num > LWTUNNEL_ENCAP_MAX)
  79                 return -ERANGE;
  80
  81         return !cmpxchg((const struct lwtunnel_encap_ops **)
  82                         &lwtun_encaps[num],
  83                         NULL, ops) ? 0 : -1;
  84 }
  85 EXPORT_SYMBOL_GPL(lwtunnel_encap_add_ops);
  86
  87 int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *ops,
  88                            unsigned int encap_type)
  89 {
  90         int ret;
  91
  92         if (encap_type == LWTUNNEL_ENCAP_NONE ||
  93             encap_type > LWTUNNEL_ENCAP_MAX)
  94                 return -ERANGE;
  95
  96         ret = (cmpxchg((const struct lwtunnel_encap_ops **)
  97                        &lwtun_encaps[encap_type],
  98                        ops, NULL) == ops) ? 0 : -1;
  99
 100         synchronize_net();
 101
 102         return ret;
 103 }
 104 EXPORT_SYMBOL_GPL(lwtunnel_encap_del_ops);
 105
 106 int lwtunnel_build_state(u16 encap_type,
 107                          struct nlattr *encap, unsigned int family,
 108                          const void *cfg, struct lwtunnel_state **lws,
 109                          struct netlink_ext_ack *extack)
 110 {
 111         const struct lwtunnel_encap_ops *ops;
 112         bool found = false;
 113         int ret = -EINVAL;
 114
 115         if (encap_type == LWTUNNEL_ENCAP_NONE ||
 116             encap_type > LWTUNNEL_ENCAP_MAX) {
 117                 NL_SET_ERR_MSG_ATTR(extack, encap,
 118                                     "Unknown LWT encapsulation type");
 119                 return ret;
 120         }
 121
 122         ret = -EOPNOTSUPP;
 123         rcu_read_lock();
 124         ops = rcu_dereference(lwtun_encaps[encap_type]);
 125         if (likely(ops && ops->build_state && try_module_get(ops->owner))) {
 126                 found = true;
 127                 ret = ops->build_state(encap, family, cfg, lws, extack);
 128                 if (ret)
 129                         module_put(ops->owner);
 130         }
 131         rcu_read_unlock();
 132
 133         /* don't rely on -EOPNOTSUPP to detect match as build_state
 134          * handlers could return it
 135          */
 136         if (!found) {
 137                 NL_SET_ERR_MSG_ATTR(extack, encap,
 138                                     "LWT encapsulation type not supported");
 139         }
 140
 141         return ret;
 142 }
 143 EXPORT_SYMBOL_GPL(lwtunnel_build_state);
 144
 145 int lwtunnel_valid_encap_type(u16 encap_type, struct netlink_ext_ack *extack)
 146 {
 147         const struct lwtunnel_encap_ops *ops;
 148         int ret = -EINVAL;
 149
 150         if (encap_type == LWTUNNEL_ENCAP_NONE ||
 151             encap_type > LWTUNNEL_ENCAP_MAX) {
 152                 NL_SET_ERR_MSG(extack, "Unknown lwt encapsulation type");
 153                 return ret;
 154         }
 155
 156         rcu_read_lock();
 157         ops = rcu_dereference(lwtun_encaps[encap_type]);
 158         rcu_read_unlock();
 159 #ifdef CONFIG_MODULES
 160         if (!ops) {
 161                 const char *encap_type_str = lwtunnel_encap_str(encap_type);
 162
 163                 if (encap_type_str) {
 164                         __rtnl_unlock();
 165                         request_module("rtnl-lwt-%s", encap_type_str);
 166                         rtnl_lock();
 167
 168                         rcu_read_lock();
 169                         ops = rcu_dereference(lwtun_encaps[encap_type]);
 170                         rcu_read_unlock();
 171                 }
 172         }
 173 #endif
 174         ret = ops ? 0 : -EOPNOTSUPP;
 175         if (ret < 0)
 176                 NL_SET_ERR_MSG(extack, "lwt encapsulation type not supported");
 177
 178         return ret;
 179 }
 180 EXPORT_SYMBOL_GPL(lwtunnel_valid_encap_type);
 181
 182 int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int remaining,
 183                                    struct netlink_ext_ack *extack)
 184 {
 185         struct rtnexthop *rtnh = (struct rtnexthop *)attr;
 186         struct nlattr *nla_entype;
 187         struct nlattr *attrs;
 188         u16 encap_type;
 189         int attrlen;
 190
 191         while (rtnh_ok(rtnh, remaining)) {
 192                 attrlen = rtnh_attrlen(rtnh);
 193                 if (attrlen > 0) {
 194                         attrs = rtnh_attrs(rtnh);
 195                         nla_entype = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
 196
 197                         if (nla_entype) {
 198                                 encap_type = nla_get_u16(nla_entype);
 199
 200                                 if (lwtunnel_valid_encap_type(encap_type,
 201                                                               extack) != 0)
 202                                         return -EOPNOTSUPP;
 203                         }
 204                 }
 205                 rtnh = rtnh_next(rtnh, &remaining);
 206         }
 207
 208         return 0;
 209 }
 210 EXPORT_SYMBOL_GPL(lwtunnel_valid_encap_type_attr);
 211
 212 void lwtstate_free(struct lwtunnel_state *lws)
 213 {
 214         const struct lwtunnel_encap_ops *ops = lwtun_encaps[lws->type];
 215
 216         if (ops->destroy_state) {
 217                 ops->destroy_state(lws);
 218                 kfree_rcu(lws, rcu);
 219         } else {
 220                 kfree(lws);
 221         }
 222         module_put(ops->owner);
 223 }
 224 EXPORT_SYMBOL_GPL(lwtstate_free);
 225
 226 int lwtunnel_fill_encap(struct sk_buff *skb, struct lwtunnel_state *lwtstate)
 227 {
 228         const struct lwtunnel_encap_ops *ops;
 229         struct nlattr *nest;
 230         int ret;
 231
 232         if (!lwtstate)
 233                 return 0;
 234
 235         if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
 236             lwtstate->type > LWTUNNEL_ENCAP_MAX)
 237                 return 0;
 238
 239         nest = nla_nest_start(skb, RTA_ENCAP);
 240         if (!nest)
 241                 return -EMSGSIZE;
 242
 243         ret = -EOPNOTSUPP;
 244         rcu_read_lock();
 245         ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
 246         if (likely(ops && ops->fill_encap))
 247                 ret = ops->fill_encap(skb, lwtstate);
 248         rcu_read_unlock();
 249
 250         if (ret)
 251                 goto nla_put_failure;
 252         nla_nest_end(skb, nest);
 253         ret = nla_put_u16(skb, RTA_ENCAP_TYPE, lwtstate->type);
 254         if (ret)
 255                 goto nla_put_failure;
 256
 257         return 0;
 258
 259 nla_put_failure:
 260         nla_nest_cancel(skb, nest);
 261
 262         return (ret == -EOPNOTSUPP ? 0 : ret);
 263 }
 264 EXPORT_SYMBOL_GPL(lwtunnel_fill_encap);
 265
 266 int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
 267 {
 268         const struct lwtunnel_encap_ops *ops;
 269         int ret = 0;
 270
 271         if (!lwtstate)
 272                 return 0;
 273
 274         if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
 275             lwtstate->type > LWTUNNEL_ENCAP_MAX)
 276                 return 0;
 277
 278         rcu_read_lock();
 279         ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
 280         if (likely(ops && ops->get_encap_size))
 281                 ret = nla_total_size(ops->get_encap_size(lwtstate));
 282         rcu_read_unlock();
 283
 284         return ret;
 285 }
 286 EXPORT_SYMBOL_GPL(lwtunnel_get_encap_size);
 287
 288 int lwtunnel_cmp_encap(struct lwtunnel_state *a, struct lwtunnel_state *b)
 289 {
 290         const struct lwtunnel_encap_ops *ops;
 291         int ret = 0;
 292
 293         if (!a && !b)
 294                 return 0;
 295
 296         if (!a || !b)
 297                 return 1;
 298
 299         if (a->type != b->type)
 300                 return 1;
 301
 302         if (a->type == LWTUNNEL_ENCAP_NONE ||
 303             a->type > LWTUNNEL_ENCAP_MAX)
 304                 return 0;
 305
 306         rcu_read_lock();
 307         ops = rcu_dereference(lwtun_encaps[a->type]);
 308         if (likely(ops && ops->cmp_encap))
 309                 ret = ops->cmp_encap(a, b);
 310         rcu_read_unlock();
 311
 312         return ret;
 313 }
 314 EXPORT_SYMBOL_GPL(lwtunnel_cmp_encap);
 315
 316 int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb)
 317 {
 318         struct dst_entry *dst = skb_dst(skb);
 319         const struct lwtunnel_encap_ops *ops;
 320         struct lwtunnel_state *lwtstate;
 321         int ret = -EINVAL;
 322
 323         if (!dst)
 324                 goto drop;
 325         lwtstate = dst->lwtstate;
 326
 327         if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
 328             lwtstate->type > LWTUNNEL_ENCAP_MAX)
 329                 return 0;
 330
 331         ret = -EOPNOTSUPP;
 332         rcu_read_lock();
 333         ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
 334         if (likely(ops && ops->output))
 335                 ret = ops->output(net, sk, skb);
 336         rcu_read_unlock();
 337
 338         if (ret == -EOPNOTSUPP)
 339                 goto drop;
 340
 341         return ret;
 342
 343 drop:
 344         kfree_skb(skb);
 345
 346         return ret;
 347 }
 348 EXPORT_SYMBOL_GPL(lwtunnel_output);
 349
 350 int lwtunnel_xmit(struct sk_buff *skb)
 351 {
 352         struct dst_entry *dst = skb_dst(skb);
 353         const struct lwtunnel_encap_ops *ops;
 354         struct lwtunnel_state *lwtstate;
 355         int ret = -EINVAL;
 356
 357         if (!dst)
 358                 goto drop;
 359
 360         lwtstate = dst->lwtstate;
 361
 362         if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
 363             lwtstate->type > LWTUNNEL_ENCAP_MAX)
 364                 return 0;
 365
 366         ret = -EOPNOTSUPP;
 367         rcu_read_lock();
 368         ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
 369         if (likely(ops && ops->xmit))
 370                 ret = ops->xmit(skb);
 371         rcu_read_unlock();
 372
 373         if (ret == -EOPNOTSUPP)
 374                 goto drop;
 375
 376         return ret;
 377
 378 drop:
 379         kfree_skb(skb);
 380
 381         return ret;
 382 }
 383 EXPORT_SYMBOL_GPL(lwtunnel_xmit);
 384
 385 int lwtunnel_input(struct sk_buff *skb)
 386 {
 387         struct dst_entry *dst = skb_dst(skb);
 388         const struct lwtunnel_encap_ops *ops;
 389         struct lwtunnel_state *lwtstate;
 390         int ret = -EINVAL;
 391
 392         if (!dst)
 393                 goto drop;
 394         lwtstate = dst->lwtstate;
 395
 396         if (lwtstate->type == LWTUNNEL_ENCAP_NONE ||
 397             lwtstate->type > LWTUNNEL_ENCAP_MAX)
 398                 return 0;
 399
 400         ret = -EOPNOTSUPP;
 401         rcu_read_lock();
 402         ops = rcu_dereference(lwtun_encaps[lwtstate->type]);
 403         if (likely(ops && ops->input))
 404                 ret = ops->input(skb);
 405         rcu_read_unlock();
 406
 407         if (ret == -EOPNOTSUPP)
 408                 goto drop;
 409
 410         return ret;
 411
 412 drop:
 413         kfree_skb(skb);
 414
 415         return ret;
 416 }
 417 EXPORT_SYMBOL_GPL(lwtunnel_input);