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