1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Generic nexthop implementation 4 * 5 * Copyright (c) 2017-19 Cumulus Networks 6 * Copyright (c) 2017-19 David Ahern <dsa@cumulusnetworks.com> 7 */ 8 9 #ifndef __LINUX_NEXTHOP_H 10 #define __LINUX_NEXTHOP_H 11 12 #include <linux/netdevice.h> 13 #include <linux/notifier.h> 14 #include <linux/route.h> 15 #include <linux/types.h> 16 #include <net/ip_fib.h> 17 #include <net/ip6_fib.h> 18 #include <net/netlink.h> 19 20 #define NEXTHOP_VALID_USER_FLAGS RTNH_F_ONLINK 21 22 struct nexthop; 23 24 struct nh_config { 25 u32 nh_id; 26 27 u8 nh_family; 28 u8 nh_protocol; 29 u8 nh_blackhole; 30 u8 nh_fdb; 31 u32 nh_flags; 32 33 int nh_ifindex; 34 struct net_device *dev; 35 36 union { 37 __be32 ipv4; 38 struct in6_addr ipv6; 39 } gw; 40 41 struct nlattr *nh_grp; 42 u16 nh_grp_type; 43 44 struct nlattr *nh_encap; 45 u16 nh_encap_type; 46 47 u32 nlflags; 48 struct nl_info nlinfo; 49 }; 50 51 struct nh_info { 52 struct hlist_node dev_hash; /* entry on netns devhash */ 53 struct nexthop *nh_parent; 54 55 u8 family; 56 bool reject_nh; 57 bool fdb_nh; 58 59 union { 60 struct fib_nh_common fib_nhc; 61 struct fib_nh fib_nh; 62 struct fib6_nh fib6_nh; 63 }; 64 }; 65 66 struct nh_grp_entry { 67 struct nexthop *nh; 68 u8 weight; 69 atomic_t upper_bound; 70 71 struct list_head nh_list; 72 struct nexthop *nh_parent; /* nexthop of group with this entry */ 73 }; 74 75 struct nh_group { 76 struct nh_group *spare; /* spare group for removals */ 77 u16 num_nh; 78 bool mpath; 79 bool fdb_nh; 80 bool has_v4; 81 struct nh_grp_entry nh_entries[]; 82 }; 83 84 struct nexthop { 85 struct rb_node rb_node; /* entry on netns rbtree */ 86 struct list_head fi_list; /* v4 entries using nh */ 87 struct list_head f6i_list; /* v6 entries using nh */ 88 struct list_head fdb_list; /* fdb entries using this nh */ 89 struct list_head grp_list; /* nh group entries using this nh */ 90 struct net *net; 91 92 u32 id; 93 94 u8 protocol; /* app managing this nh */ 95 u8 nh_flags; 96 bool is_group; 97 98 refcount_t refcnt; 99 struct rcu_head rcu; 100 101 union { 102 struct nh_info __rcu *nh_info; 103 struct nh_group __rcu *nh_grp; 104 }; 105 }; 106 107 enum nexthop_event_type { 108 NEXTHOP_EVENT_ADD, 109 NEXTHOP_EVENT_DEL 110 }; 111 112 int call_nexthop_notifier(struct notifier_block *nb, struct net *net, 113 enum nexthop_event_type event_type, 114 struct nexthop *nh); 115 int register_nexthop_notifier(struct net *net, struct notifier_block *nb); 116 int unregister_nexthop_notifier(struct net *net, struct notifier_block *nb); 117 118 /* caller is holding rcu or rtnl; no reference taken to nexthop */ 119 struct nexthop *nexthop_find_by_id(struct net *net, u32 id); 120 void nexthop_free_rcu(struct rcu_head *head); 121 122 static inline bool nexthop_get(struct nexthop *nh) 123 { 124 return refcount_inc_not_zero(&nh->refcnt); 125 } 126 127 static inline void nexthop_put(struct nexthop *nh) 128 { 129 if (refcount_dec_and_test(&nh->refcnt)) 130 call_rcu(&nh->rcu, nexthop_free_rcu); 131 } 132 133 static inline bool nexthop_cmp(const struct nexthop *nh1, 134 const struct nexthop *nh2) 135 { 136 return nh1 == nh2; 137 } 138 139 static inline bool nexthop_is_fdb(const struct nexthop *nh) 140 { 141 if (nh->is_group) { 142 const struct nh_group *nh_grp; 143 144 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 145 return nh_grp->fdb_nh; 146 } else { 147 const struct nh_info *nhi; 148 149 nhi = rcu_dereference_rtnl(nh->nh_info); 150 return nhi->fdb_nh; 151 } 152 } 153 154 static inline bool nexthop_has_v4(const struct nexthop *nh) 155 { 156 if (nh->is_group) { 157 struct nh_group *nh_grp; 158 159 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 160 return nh_grp->has_v4; 161 } 162 return false; 163 } 164 165 static inline bool nexthop_is_multipath(const struct nexthop *nh) 166 { 167 if (nh->is_group) { 168 struct nh_group *nh_grp; 169 170 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 171 return nh_grp->mpath; 172 } 173 return false; 174 } 175 176 struct nexthop *nexthop_select_path(struct nexthop *nh, int hash); 177 178 static inline unsigned int nexthop_num_path(const struct nexthop *nh) 179 { 180 unsigned int rc = 1; 181 182 if (nh->is_group) { 183 struct nh_group *nh_grp; 184 185 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 186 if (nh_grp->mpath) 187 rc = nh_grp->num_nh; 188 } 189 190 return rc; 191 } 192 193 static inline 194 struct nexthop *nexthop_mpath_select(const struct nh_group *nhg, int nhsel) 195 { 196 /* for_nexthops macros in fib_semantics.c grabs a pointer to 197 * the nexthop before checking nhsel 198 */ 199 if (nhsel >= nhg->num_nh) 200 return NULL; 201 202 return nhg->nh_entries[nhsel].nh; 203 } 204 205 static inline 206 int nexthop_mpath_fill_node(struct sk_buff *skb, struct nexthop *nh, 207 u8 rt_family) 208 { 209 struct nh_group *nhg = rtnl_dereference(nh->nh_grp); 210 int i; 211 212 for (i = 0; i < nhg->num_nh; i++) { 213 struct nexthop *nhe = nhg->nh_entries[i].nh; 214 struct nh_info *nhi = rcu_dereference_rtnl(nhe->nh_info); 215 struct fib_nh_common *nhc = &nhi->fib_nhc; 216 int weight = nhg->nh_entries[i].weight; 217 218 if (fib_add_nexthop(skb, nhc, weight, rt_family) < 0) 219 return -EMSGSIZE; 220 } 221 222 return 0; 223 } 224 225 /* called with rcu lock */ 226 static inline bool nexthop_is_blackhole(const struct nexthop *nh) 227 { 228 const struct nh_info *nhi; 229 230 if (nh->is_group) { 231 struct nh_group *nh_grp; 232 233 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 234 if (nh_grp->num_nh > 1) 235 return false; 236 237 nh = nh_grp->nh_entries[0].nh; 238 } 239 240 nhi = rcu_dereference_rtnl(nh->nh_info); 241 return nhi->reject_nh; 242 } 243 244 static inline void nexthop_path_fib_result(struct fib_result *res, int hash) 245 { 246 struct nh_info *nhi; 247 struct nexthop *nh; 248 249 nh = nexthop_select_path(res->fi->nh, hash); 250 nhi = rcu_dereference(nh->nh_info); 251 res->nhc = &nhi->fib_nhc; 252 } 253 254 /* called with rcu read lock or rtnl held */ 255 static inline 256 struct fib_nh_common *nexthop_fib_nhc(struct nexthop *nh, int nhsel) 257 { 258 struct nh_info *nhi; 259 260 BUILD_BUG_ON(offsetof(struct fib_nh, nh_common) != 0); 261 BUILD_BUG_ON(offsetof(struct fib6_nh, nh_common) != 0); 262 263 if (nh->is_group) { 264 struct nh_group *nh_grp; 265 266 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 267 if (nh_grp->mpath) { 268 nh = nexthop_mpath_select(nh_grp, nhsel); 269 if (!nh) 270 return NULL; 271 } 272 } 273 274 nhi = rcu_dereference_rtnl(nh->nh_info); 275 return &nhi->fib_nhc; 276 } 277 278 /* called from fib_table_lookup with rcu_lock */ 279 static inline 280 struct fib_nh_common *nexthop_get_nhc_lookup(const struct nexthop *nh, 281 int fib_flags, 282 const struct flowi4 *flp, 283 int *nhsel) 284 { 285 struct nh_info *nhi; 286 287 if (nh->is_group) { 288 struct nh_group *nhg = rcu_dereference(nh->nh_grp); 289 int i; 290 291 for (i = 0; i < nhg->num_nh; i++) { 292 struct nexthop *nhe = nhg->nh_entries[i].nh; 293 294 nhi = rcu_dereference(nhe->nh_info); 295 if (fib_lookup_good_nhc(&nhi->fib_nhc, fib_flags, flp)) { 296 *nhsel = i; 297 return &nhi->fib_nhc; 298 } 299 } 300 } else { 301 nhi = rcu_dereference(nh->nh_info); 302 if (fib_lookup_good_nhc(&nhi->fib_nhc, fib_flags, flp)) { 303 *nhsel = 0; 304 return &nhi->fib_nhc; 305 } 306 } 307 308 return NULL; 309 } 310 311 static inline bool nexthop_uses_dev(const struct nexthop *nh, 312 const struct net_device *dev) 313 { 314 struct nh_info *nhi; 315 316 if (nh->is_group) { 317 struct nh_group *nhg = rcu_dereference(nh->nh_grp); 318 int i; 319 320 for (i = 0; i < nhg->num_nh; i++) { 321 struct nexthop *nhe = nhg->nh_entries[i].nh; 322 323 nhi = rcu_dereference(nhe->nh_info); 324 if (nhc_l3mdev_matches_dev(&nhi->fib_nhc, dev)) 325 return true; 326 } 327 } else { 328 nhi = rcu_dereference(nh->nh_info); 329 if (nhc_l3mdev_matches_dev(&nhi->fib_nhc, dev)) 330 return true; 331 } 332 333 return false; 334 } 335 336 static inline unsigned int fib_info_num_path(const struct fib_info *fi) 337 { 338 if (unlikely(fi->nh)) 339 return nexthop_num_path(fi->nh); 340 341 return fi->fib_nhs; 342 } 343 344 int fib_check_nexthop(struct nexthop *nh, u8 scope, 345 struct netlink_ext_ack *extack); 346 347 static inline struct fib_nh_common *fib_info_nhc(struct fib_info *fi, int nhsel) 348 { 349 if (unlikely(fi->nh)) 350 return nexthop_fib_nhc(fi->nh, nhsel); 351 352 return &fi->fib_nh[nhsel].nh_common; 353 } 354 355 /* only used when fib_nh is built into fib_info */ 356 static inline struct fib_nh *fib_info_nh(struct fib_info *fi, int nhsel) 357 { 358 WARN_ON(fi->nh); 359 360 return &fi->fib_nh[nhsel]; 361 } 362 363 /* 364 * IPv6 variants 365 */ 366 int fib6_check_nexthop(struct nexthop *nh, struct fib6_config *cfg, 367 struct netlink_ext_ack *extack); 368 369 static inline struct fib6_nh *nexthop_fib6_nh(struct nexthop *nh) 370 { 371 struct nh_info *nhi; 372 373 if (nh->is_group) { 374 struct nh_group *nh_grp; 375 376 nh_grp = rcu_dereference_rtnl(nh->nh_grp); 377 nh = nexthop_mpath_select(nh_grp, 0); 378 if (!nh) 379 return NULL; 380 } 381 382 nhi = rcu_dereference_rtnl(nh->nh_info); 383 if (nhi->family == AF_INET6) 384 return &nhi->fib6_nh; 385 386 return NULL; 387 } 388 389 static inline struct net_device *fib6_info_nh_dev(struct fib6_info *f6i) 390 { 391 struct fib6_nh *fib6_nh; 392 393 fib6_nh = f6i->nh ? nexthop_fib6_nh(f6i->nh) : f6i->fib6_nh; 394 return fib6_nh->fib_nh_dev; 395 } 396 397 static inline void nexthop_path_fib6_result(struct fib6_result *res, int hash) 398 { 399 struct nexthop *nh = res->f6i->nh; 400 struct nh_info *nhi; 401 402 nh = nexthop_select_path(nh, hash); 403 404 nhi = rcu_dereference_rtnl(nh->nh_info); 405 if (nhi->reject_nh) { 406 res->fib6_type = RTN_BLACKHOLE; 407 res->fib6_flags |= RTF_REJECT; 408 res->nh = nexthop_fib6_nh(nh); 409 } else { 410 res->nh = &nhi->fib6_nh; 411 } 412 } 413 414 int nexthop_for_each_fib6_nh(struct nexthop *nh, 415 int (*cb)(struct fib6_nh *nh, void *arg), 416 void *arg); 417 418 static inline int nexthop_get_family(struct nexthop *nh) 419 { 420 struct nh_info *nhi = rcu_dereference_rtnl(nh->nh_info); 421 422 return nhi->family; 423 } 424 425 static inline 426 struct fib_nh_common *nexthop_fdb_nhc(struct nexthop *nh) 427 { 428 struct nh_info *nhi = rcu_dereference_rtnl(nh->nh_info); 429 430 return &nhi->fib_nhc; 431 } 432 433 static inline struct fib_nh_common *nexthop_path_fdb_result(struct nexthop *nh, 434 int hash) 435 { 436 struct nh_info *nhi; 437 struct nexthop *nhp; 438 439 nhp = nexthop_select_path(nh, hash); 440 if (unlikely(!nhp)) 441 return NULL; 442 nhi = rcu_dereference(nhp->nh_info); 443 return &nhi->fib_nhc; 444 } 445 #endif 446