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