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/rtnh.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 rcu_read_unlock(); 128 129 if (found) { 130 ret = ops->build_state(encap, family, cfg, lws, extack); 131 if (ret) 132 module_put(ops->owner); 133 } else { 134 /* don't rely on -EOPNOTSUPP to detect match as build_state 135 * handlers could return it 136 */ 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 int encap_attr, int encap_type_attr) 228 { 229 const struct lwtunnel_encap_ops *ops; 230 struct nlattr *nest; 231 int ret; 232 233 if (!lwtstate) 234 return 0; 235 236 if (lwtstate->type == LWTUNNEL_ENCAP_NONE || 237 lwtstate->type > LWTUNNEL_ENCAP_MAX) 238 return 0; 239 240 nest = nla_nest_start_noflag(skb, encap_attr); 241 if (!nest) 242 return -EMSGSIZE; 243 244 ret = -EOPNOTSUPP; 245 rcu_read_lock(); 246 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); 247 if (likely(ops && ops->fill_encap)) 248 ret = ops->fill_encap(skb, lwtstate); 249 rcu_read_unlock(); 250 251 if (ret) 252 goto nla_put_failure; 253 nla_nest_end(skb, nest); 254 ret = nla_put_u16(skb, encap_type_attr, lwtstate->type); 255 if (ret) 256 goto nla_put_failure; 257 258 return 0; 259 260 nla_put_failure: 261 nla_nest_cancel(skb, nest); 262 263 return (ret == -EOPNOTSUPP ? 0 : ret); 264 } 265 EXPORT_SYMBOL_GPL(lwtunnel_fill_encap); 266 267 int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate) 268 { 269 const struct lwtunnel_encap_ops *ops; 270 int ret = 0; 271 272 if (!lwtstate) 273 return 0; 274 275 if (lwtstate->type == LWTUNNEL_ENCAP_NONE || 276 lwtstate->type > LWTUNNEL_ENCAP_MAX) 277 return 0; 278 279 rcu_read_lock(); 280 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); 281 if (likely(ops && ops->get_encap_size)) 282 ret = nla_total_size(ops->get_encap_size(lwtstate)); 283 rcu_read_unlock(); 284 285 return ret; 286 } 287 EXPORT_SYMBOL_GPL(lwtunnel_get_encap_size); 288 289 int lwtunnel_cmp_encap(struct lwtunnel_state *a, struct lwtunnel_state *b) 290 { 291 const struct lwtunnel_encap_ops *ops; 292 int ret = 0; 293 294 if (!a && !b) 295 return 0; 296 297 if (!a || !b) 298 return 1; 299 300 if (a->type != b->type) 301 return 1; 302 303 if (a->type == LWTUNNEL_ENCAP_NONE || 304 a->type > LWTUNNEL_ENCAP_MAX) 305 return 0; 306 307 rcu_read_lock(); 308 ops = rcu_dereference(lwtun_encaps[a->type]); 309 if (likely(ops && ops->cmp_encap)) 310 ret = ops->cmp_encap(a, b); 311 rcu_read_unlock(); 312 313 return ret; 314 } 315 EXPORT_SYMBOL_GPL(lwtunnel_cmp_encap); 316 317 int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb) 318 { 319 struct dst_entry *dst = skb_dst(skb); 320 const struct lwtunnel_encap_ops *ops; 321 struct lwtunnel_state *lwtstate; 322 int ret = -EINVAL; 323 324 if (!dst) 325 goto drop; 326 lwtstate = dst->lwtstate; 327 328 if (lwtstate->type == LWTUNNEL_ENCAP_NONE || 329 lwtstate->type > LWTUNNEL_ENCAP_MAX) 330 return 0; 331 332 ret = -EOPNOTSUPP; 333 rcu_read_lock(); 334 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); 335 if (likely(ops && ops->output)) 336 ret = ops->output(net, sk, skb); 337 rcu_read_unlock(); 338 339 if (ret == -EOPNOTSUPP) 340 goto drop; 341 342 return ret; 343 344 drop: 345 kfree_skb(skb); 346 347 return ret; 348 } 349 EXPORT_SYMBOL_GPL(lwtunnel_output); 350 351 int lwtunnel_xmit(struct sk_buff *skb) 352 { 353 struct dst_entry *dst = skb_dst(skb); 354 const struct lwtunnel_encap_ops *ops; 355 struct lwtunnel_state *lwtstate; 356 int ret = -EINVAL; 357 358 if (!dst) 359 goto drop; 360 361 lwtstate = dst->lwtstate; 362 363 if (lwtstate->type == LWTUNNEL_ENCAP_NONE || 364 lwtstate->type > LWTUNNEL_ENCAP_MAX) 365 return 0; 366 367 ret = -EOPNOTSUPP; 368 rcu_read_lock(); 369 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); 370 if (likely(ops && ops->xmit)) 371 ret = ops->xmit(skb); 372 rcu_read_unlock(); 373 374 if (ret == -EOPNOTSUPP) 375 goto drop; 376 377 return ret; 378 379 drop: 380 kfree_skb(skb); 381 382 return ret; 383 } 384 EXPORT_SYMBOL_GPL(lwtunnel_xmit); 385 386 int lwtunnel_input(struct sk_buff *skb) 387 { 388 struct dst_entry *dst = skb_dst(skb); 389 const struct lwtunnel_encap_ops *ops; 390 struct lwtunnel_state *lwtstate; 391 int ret = -EINVAL; 392 393 if (!dst) 394 goto drop; 395 lwtstate = dst->lwtstate; 396 397 if (lwtstate->type == LWTUNNEL_ENCAP_NONE || 398 lwtstate->type > LWTUNNEL_ENCAP_MAX) 399 return 0; 400 401 ret = -EOPNOTSUPP; 402 rcu_read_lock(); 403 ops = rcu_dereference(lwtun_encaps[lwtstate->type]); 404 if (likely(ops && ops->input)) 405 ret = ops->input(skb); 406 rcu_read_unlock(); 407 408 if (ret == -EOPNOTSUPP) 409 goto drop; 410 411 return ret; 412 413 drop: 414 kfree_skb(skb); 415 416 return ret; 417 } 418 EXPORT_SYMBOL_GPL(lwtunnel_input); 419