| 1 | #ifndef __LINUX_MROUTE_BASE_H |
| 2 | #define __LINUX_MROUTE_BASE_H |
| 3 | |
| 4 | #include <linux/netdevice.h> |
| 5 | #include <linux/rhashtable-types.h> |
| 6 | #include <linux/spinlock.h> |
| 7 | #include <net/net_namespace.h> |
| 8 | #include <net/sock.h> |
| 9 | #include <net/fib_notifier.h> |
| 10 | #include <net/ip_fib.h> |
| 11 | |
| 12 | /** |
| 13 | * struct vif_device - interface representor for multicast routing |
| 14 | * @dev: network device being used |
| 15 | * @dev_tracker: refcount tracker for @dev reference |
| 16 | * @bytes_in: statistic; bytes ingressing |
| 17 | * @bytes_out: statistic; bytes egresing |
| 18 | * @pkt_in: statistic; packets ingressing |
| 19 | * @pkt_out: statistic; packets egressing |
| 20 | * @rate_limit: Traffic shaping (NI) |
| 21 | * @threshold: TTL threshold |
| 22 | * @flags: Control flags |
| 23 | * @link: Physical interface index |
| 24 | * @dev_parent_id: device parent id |
| 25 | * @local: Local address |
| 26 | * @remote: Remote address for tunnels |
| 27 | */ |
| 28 | struct vif_device { |
| 29 | struct net_device __rcu *dev; |
| 30 | netdevice_tracker dev_tracker; |
| 31 | unsigned long bytes_in, bytes_out; |
| 32 | unsigned long pkt_in, pkt_out; |
| 33 | unsigned long rate_limit; |
| 34 | unsigned char threshold; |
| 35 | unsigned short flags; |
| 36 | int link; |
| 37 | |
| 38 | /* Currently only used by ipmr */ |
| 39 | struct netdev_phys_item_id dev_parent_id; |
| 40 | __be32 local, remote; |
| 41 | }; |
| 42 | |
| 43 | struct vif_entry_notifier_info { |
| 44 | struct fib_notifier_info info; |
| 45 | struct net_device *dev; |
| 46 | unsigned short vif_index; |
| 47 | unsigned short vif_flags; |
| 48 | u32 tb_id; |
| 49 | }; |
| 50 | |
| 51 | static inline int mr_call_vif_notifier(struct notifier_block *nb, |
| 52 | unsigned short family, |
| 53 | enum fib_event_type event_type, |
| 54 | struct vif_device *vif, |
| 55 | struct net_device *vif_dev, |
| 56 | unsigned short vif_index, u32 tb_id, |
| 57 | struct netlink_ext_ack *extack) |
| 58 | { |
| 59 | struct vif_entry_notifier_info info = { |
| 60 | .info = { |
| 61 | .family = family, |
| 62 | .extack = extack, |
| 63 | }, |
| 64 | .dev = vif_dev, |
| 65 | .vif_index = vif_index, |
| 66 | .vif_flags = vif->flags, |
| 67 | .tb_id = tb_id, |
| 68 | }; |
| 69 | |
| 70 | return call_fib_notifier(nb, event_type, &info.info); |
| 71 | } |
| 72 | |
| 73 | static inline int mr_call_vif_notifiers(struct net *net, |
| 74 | unsigned short family, |
| 75 | enum fib_event_type event_type, |
| 76 | struct vif_device *vif, |
| 77 | struct net_device *vif_dev, |
| 78 | unsigned short vif_index, u32 tb_id, |
| 79 | unsigned int *ipmr_seq) |
| 80 | { |
| 81 | struct vif_entry_notifier_info info = { |
| 82 | .info = { |
| 83 | .family = family, |
| 84 | }, |
| 85 | .dev = vif_dev, |
| 86 | .vif_index = vif_index, |
| 87 | .vif_flags = vif->flags, |
| 88 | .tb_id = tb_id, |
| 89 | }; |
| 90 | |
| 91 | ASSERT_RTNL(); |
| 92 | (*ipmr_seq)++; |
| 93 | return call_fib_notifiers(net, event_type, &info.info); |
| 94 | } |
| 95 | |
| 96 | #ifndef MAXVIFS |
| 97 | /* This one is nasty; value is defined in uapi using different symbols for |
| 98 | * mroute and morute6 but both map into same 32. |
| 99 | */ |
| 100 | #define MAXVIFS 32 |
| 101 | #endif |
| 102 | |
| 103 | /* Note: This helper is deprecated. */ |
| 104 | #define VIF_EXISTS(_mrt, _idx) (!!rcu_access_pointer((_mrt)->vif_table[_idx].dev)) |
| 105 | |
| 106 | /* mfc_flags: |
| 107 | * MFC_STATIC - the entry was added statically (not by a routing daemon) |
| 108 | * MFC_OFFLOAD - the entry was offloaded to the hardware |
| 109 | */ |
| 110 | enum { |
| 111 | MFC_STATIC = BIT(0), |
| 112 | MFC_OFFLOAD = BIT(1), |
| 113 | }; |
| 114 | |
| 115 | /** |
| 116 | * struct mr_mfc - common multicast routing entries |
| 117 | * @mnode: rhashtable list |
| 118 | * @mfc_parent: source interface (iif) |
| 119 | * @mfc_flags: entry flags |
| 120 | * @expires: unresolved entry expire time |
| 121 | * @unresolved: unresolved cached skbs |
| 122 | * @last_assert: time of last assert |
| 123 | * @minvif: minimum VIF id |
| 124 | * @maxvif: maximum VIF id |
| 125 | * @bytes: bytes that have passed for this entry |
| 126 | * @pkt: packets that have passed for this entry |
| 127 | * @wrong_if: number of wrong source interface hits |
| 128 | * @lastuse: time of last use of the group (traffic or update) |
| 129 | * @ttls: OIF TTL threshold array |
| 130 | * @refcount: reference count for this entry |
| 131 | * @list: global entry list |
| 132 | * @rcu: used for entry destruction |
| 133 | * @free: Operation used for freeing an entry under RCU |
| 134 | */ |
| 135 | struct mr_mfc { |
| 136 | struct rhlist_head mnode; |
| 137 | unsigned short mfc_parent; |
| 138 | int mfc_flags; |
| 139 | |
| 140 | union { |
| 141 | struct { |
| 142 | unsigned long expires; |
| 143 | struct sk_buff_head unresolved; |
| 144 | } unres; |
| 145 | struct { |
| 146 | unsigned long last_assert; |
| 147 | int minvif; |
| 148 | int maxvif; |
| 149 | unsigned long bytes; |
| 150 | unsigned long pkt; |
| 151 | unsigned long wrong_if; |
| 152 | unsigned long lastuse; |
| 153 | unsigned char ttls[MAXVIFS]; |
| 154 | refcount_t refcount; |
| 155 | } res; |
| 156 | } mfc_un; |
| 157 | struct list_head list; |
| 158 | struct rcu_head rcu; |
| 159 | void (*free)(struct rcu_head *head); |
| 160 | }; |
| 161 | |
| 162 | static inline void mr_cache_put(struct mr_mfc *c) |
| 163 | { |
| 164 | if (refcount_dec_and_test(&c->mfc_un.res.refcount)) |
| 165 | call_rcu(&c->rcu, c->free); |
| 166 | } |
| 167 | |
| 168 | static inline void mr_cache_hold(struct mr_mfc *c) |
| 169 | { |
| 170 | refcount_inc(&c->mfc_un.res.refcount); |
| 171 | } |
| 172 | |
| 173 | struct mfc_entry_notifier_info { |
| 174 | struct fib_notifier_info info; |
| 175 | struct mr_mfc *mfc; |
| 176 | u32 tb_id; |
| 177 | }; |
| 178 | |
| 179 | static inline int mr_call_mfc_notifier(struct notifier_block *nb, |
| 180 | unsigned short family, |
| 181 | enum fib_event_type event_type, |
| 182 | struct mr_mfc *mfc, u32 tb_id, |
| 183 | struct netlink_ext_ack *extack) |
| 184 | { |
| 185 | struct mfc_entry_notifier_info info = { |
| 186 | .info = { |
| 187 | .family = family, |
| 188 | .extack = extack, |
| 189 | }, |
| 190 | .mfc = mfc, |
| 191 | .tb_id = tb_id |
| 192 | }; |
| 193 | |
| 194 | return call_fib_notifier(nb, event_type, &info.info); |
| 195 | } |
| 196 | |
| 197 | static inline int mr_call_mfc_notifiers(struct net *net, |
| 198 | unsigned short family, |
| 199 | enum fib_event_type event_type, |
| 200 | struct mr_mfc *mfc, u32 tb_id, |
| 201 | unsigned int *ipmr_seq) |
| 202 | { |
| 203 | struct mfc_entry_notifier_info info = { |
| 204 | .info = { |
| 205 | .family = family, |
| 206 | }, |
| 207 | .mfc = mfc, |
| 208 | .tb_id = tb_id |
| 209 | }; |
| 210 | |
| 211 | ASSERT_RTNL(); |
| 212 | (*ipmr_seq)++; |
| 213 | return call_fib_notifiers(net, event_type, &info.info); |
| 214 | } |
| 215 | |
| 216 | struct mr_table; |
| 217 | |
| 218 | /** |
| 219 | * struct mr_table_ops - callbacks and info for protocol-specific ops |
| 220 | * @rht_params: parameters for accessing the MFC hash |
| 221 | * @cmparg_any: a hash key to be used for matching on (*,*) routes |
| 222 | */ |
| 223 | struct mr_table_ops { |
| 224 | const struct rhashtable_params *rht_params; |
| 225 | void *cmparg_any; |
| 226 | }; |
| 227 | |
| 228 | /** |
| 229 | * struct mr_table - a multicast routing table |
| 230 | * @list: entry within a list of multicast routing tables |
| 231 | * @net: net where this table belongs |
| 232 | * @ops: protocol specific operations |
| 233 | * @id: identifier of the table |
| 234 | * @mroute_sk: socket associated with the table |
| 235 | * @ipmr_expire_timer: timer for handling unresolved routes |
| 236 | * @mfc_unres_queue: list of unresolved MFC entries |
| 237 | * @vif_table: array containing all possible vifs |
| 238 | * @mfc_hash: Hash table of all resolved routes for easy lookup |
| 239 | * @mfc_cache_list: list of resovled routes for possible traversal |
| 240 | * @maxvif: Identifier of highest value vif currently in use |
| 241 | * @cache_resolve_queue_len: current size of unresolved queue |
| 242 | * @mroute_do_assert: Whether to inform userspace on wrong ingress |
| 243 | * @mroute_do_pim: Whether to receive IGMP PIMv1 |
| 244 | * @mroute_reg_vif_num: PIM-device vif index |
| 245 | */ |
| 246 | struct mr_table { |
| 247 | struct list_head list; |
| 248 | possible_net_t net; |
| 249 | struct mr_table_ops ops; |
| 250 | u32 id; |
| 251 | struct sock __rcu *mroute_sk; |
| 252 | struct timer_list ipmr_expire_timer; |
| 253 | struct list_head mfc_unres_queue; |
| 254 | struct vif_device vif_table[MAXVIFS]; |
| 255 | struct rhltable mfc_hash; |
| 256 | struct list_head mfc_cache_list; |
| 257 | int maxvif; |
| 258 | atomic_t cache_resolve_queue_len; |
| 259 | bool mroute_do_assert; |
| 260 | bool mroute_do_pim; |
| 261 | bool mroute_do_wrvifwhole; |
| 262 | int mroute_reg_vif_num; |
| 263 | }; |
| 264 | |
| 265 | #ifdef CONFIG_IP_MROUTE_COMMON |
| 266 | void vif_device_init(struct vif_device *v, |
| 267 | struct net_device *dev, |
| 268 | unsigned long rate_limit, |
| 269 | unsigned char threshold, |
| 270 | unsigned short flags, |
| 271 | unsigned short get_iflink_mask); |
| 272 | |
| 273 | struct mr_table * |
| 274 | mr_table_alloc(struct net *net, u32 id, |
| 275 | struct mr_table_ops *ops, |
| 276 | void (*expire_func)(struct timer_list *t), |
| 277 | void (*table_set)(struct mr_table *mrt, |
| 278 | struct net *net)); |
| 279 | |
| 280 | /* These actually return 'struct mr_mfc *', but to avoid need for explicit |
| 281 | * castings they simply return void. |
| 282 | */ |
| 283 | void *mr_mfc_find_parent(struct mr_table *mrt, |
| 284 | void *hasharg, int parent); |
| 285 | void *mr_mfc_find_any_parent(struct mr_table *mrt, int vifi); |
| 286 | void *mr_mfc_find_any(struct mr_table *mrt, int vifi, void *hasharg); |
| 287 | |
| 288 | int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb, |
| 289 | struct mr_mfc *c, struct rtmsg *rtm); |
| 290 | int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb, |
| 291 | struct netlink_callback *cb, |
| 292 | int (*fill)(struct mr_table *mrt, struct sk_buff *skb, |
| 293 | u32 portid, u32 seq, struct mr_mfc *c, |
| 294 | int cmd, int flags), |
| 295 | spinlock_t *lock, struct fib_dump_filter *filter); |
| 296 | int mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb, |
| 297 | struct mr_table *(*iter)(struct net *net, |
| 298 | struct mr_table *mrt), |
| 299 | int (*fill)(struct mr_table *mrt, |
| 300 | struct sk_buff *skb, |
| 301 | u32 portid, u32 seq, struct mr_mfc *c, |
| 302 | int cmd, int flags), |
| 303 | spinlock_t *lock, struct fib_dump_filter *filter); |
| 304 | |
| 305 | int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family, |
| 306 | int (*rules_dump)(struct net *net, |
| 307 | struct notifier_block *nb, |
| 308 | struct netlink_ext_ack *extack), |
| 309 | struct mr_table *(*mr_iter)(struct net *net, |
| 310 | struct mr_table *mrt), |
| 311 | struct netlink_ext_ack *extack); |
| 312 | #else |
| 313 | static inline void vif_device_init(struct vif_device *v, |
| 314 | struct net_device *dev, |
| 315 | unsigned long rate_limit, |
| 316 | unsigned char threshold, |
| 317 | unsigned short flags, |
| 318 | unsigned short get_iflink_mask) |
| 319 | { |
| 320 | } |
| 321 | |
| 322 | static inline void *mr_mfc_find_parent(struct mr_table *mrt, |
| 323 | void *hasharg, int parent) |
| 324 | { |
| 325 | return NULL; |
| 326 | } |
| 327 | |
| 328 | static inline void *mr_mfc_find_any_parent(struct mr_table *mrt, |
| 329 | int vifi) |
| 330 | { |
| 331 | return NULL; |
| 332 | } |
| 333 | |
| 334 | static inline struct mr_mfc *mr_mfc_find_any(struct mr_table *mrt, |
| 335 | int vifi, void *hasharg) |
| 336 | { |
| 337 | return NULL; |
| 338 | } |
| 339 | |
| 340 | static inline int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb, |
| 341 | struct mr_mfc *c, struct rtmsg *rtm) |
| 342 | { |
| 343 | return -EINVAL; |
| 344 | } |
| 345 | |
| 346 | static inline int |
| 347 | mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb, |
| 348 | struct mr_table *(*iter)(struct net *net, |
| 349 | struct mr_table *mrt), |
| 350 | int (*fill)(struct mr_table *mrt, |
| 351 | struct sk_buff *skb, |
| 352 | u32 portid, u32 seq, struct mr_mfc *c, |
| 353 | int cmd, int flags), |
| 354 | spinlock_t *lock, struct fib_dump_filter *filter) |
| 355 | { |
| 356 | return -EINVAL; |
| 357 | } |
| 358 | |
| 359 | static inline int mr_dump(struct net *net, struct notifier_block *nb, |
| 360 | unsigned short family, |
| 361 | int (*rules_dump)(struct net *net, |
| 362 | struct notifier_block *nb, |
| 363 | struct netlink_ext_ack *extack), |
| 364 | struct mr_table *(*mr_iter)(struct net *net, |
| 365 | struct mr_table *mrt), |
| 366 | struct netlink_ext_ack *extack) |
| 367 | { |
| 368 | return -EINVAL; |
| 369 | } |
| 370 | #endif |
| 371 | |
| 372 | static inline void *mr_mfc_find(struct mr_table *mrt, void *hasharg) |
| 373 | { |
| 374 | return mr_mfc_find_parent(mrt, hasharg, -1); |
| 375 | } |
| 376 | |
| 377 | #ifdef CONFIG_PROC_FS |
| 378 | struct mr_vif_iter { |
| 379 | struct seq_net_private p; |
| 380 | struct mr_table *mrt; |
| 381 | int ct; |
| 382 | }; |
| 383 | |
| 384 | struct mr_mfc_iter { |
| 385 | struct seq_net_private p; |
| 386 | struct mr_table *mrt; |
| 387 | struct list_head *cache; |
| 388 | |
| 389 | /* Lock protecting the mr_table's unresolved queue */ |
| 390 | spinlock_t *lock; |
| 391 | }; |
| 392 | |
| 393 | #ifdef CONFIG_IP_MROUTE_COMMON |
| 394 | void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, loff_t pos); |
| 395 | void *mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos); |
| 396 | |
| 397 | static inline void *mr_vif_seq_start(struct seq_file *seq, loff_t *pos) |
| 398 | { |
| 399 | return *pos ? mr_vif_seq_idx(seq_file_net(seq), |
| 400 | seq->private, *pos - 1) |
| 401 | : SEQ_START_TOKEN; |
| 402 | } |
| 403 | |
| 404 | /* These actually return 'struct mr_mfc *', but to avoid need for explicit |
| 405 | * castings they simply return void. |
| 406 | */ |
| 407 | void *mr_mfc_seq_idx(struct net *net, |
| 408 | struct mr_mfc_iter *it, loff_t pos); |
| 409 | void *mr_mfc_seq_next(struct seq_file *seq, void *v, |
| 410 | loff_t *pos); |
| 411 | |
| 412 | static inline void *mr_mfc_seq_start(struct seq_file *seq, loff_t *pos, |
| 413 | struct mr_table *mrt, spinlock_t *lock) |
| 414 | { |
| 415 | struct mr_mfc_iter *it = seq->private; |
| 416 | |
| 417 | it->mrt = mrt; |
| 418 | it->cache = NULL; |
| 419 | it->lock = lock; |
| 420 | |
| 421 | return *pos ? mr_mfc_seq_idx(seq_file_net(seq), |
| 422 | seq->private, *pos - 1) |
| 423 | : SEQ_START_TOKEN; |
| 424 | } |
| 425 | |
| 426 | static inline void mr_mfc_seq_stop(struct seq_file *seq, void *v) |
| 427 | { |
| 428 | struct mr_mfc_iter *it = seq->private; |
| 429 | struct mr_table *mrt = it->mrt; |
| 430 | |
| 431 | if (it->cache == &mrt->mfc_unres_queue) |
| 432 | spin_unlock_bh(it->lock); |
| 433 | else if (it->cache == &mrt->mfc_cache_list) |
| 434 | rcu_read_unlock(); |
| 435 | } |
| 436 | #else |
| 437 | static inline void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, |
| 438 | loff_t pos) |
| 439 | { |
| 440 | return NULL; |
| 441 | } |
| 442 | |
| 443 | static inline void *mr_vif_seq_next(struct seq_file *seq, |
| 444 | void *v, loff_t *pos) |
| 445 | { |
| 446 | return NULL; |
| 447 | } |
| 448 | |
| 449 | static inline void *mr_vif_seq_start(struct seq_file *seq, loff_t *pos) |
| 450 | { |
| 451 | return NULL; |
| 452 | } |
| 453 | |
| 454 | static inline void *mr_mfc_seq_idx(struct net *net, |
| 455 | struct mr_mfc_iter *it, loff_t pos) |
| 456 | { |
| 457 | return NULL; |
| 458 | } |
| 459 | |
| 460 | static inline void *mr_mfc_seq_next(struct seq_file *seq, void *v, |
| 461 | loff_t *pos) |
| 462 | { |
| 463 | return NULL; |
| 464 | } |
| 465 | |
| 466 | static inline void *mr_mfc_seq_start(struct seq_file *seq, loff_t *pos, |
| 467 | struct mr_table *mrt, spinlock_t *lock) |
| 468 | { |
| 469 | return NULL; |
| 470 | } |
| 471 | |
| 472 | static inline void mr_mfc_seq_stop(struct seq_file *seq, void *v) |
| 473 | { |
| 474 | } |
| 475 | #endif |
| 476 | #endif |
| 477 | #endif |