root/include/linux/mroute_base.h

INCLUDED FROM

DEFINITIONS

1. mr_call_vif_notifier
2. mr_call_vif_notifiers
3. mr_cache_put
4. mr_cache_hold
5. mr_call_mfc_notifier
6. mr_call_mfc_notifiers
7. vif_device_init
8. mr_mfc_find_parent
9. mr_mfc_find_any_parent
10. mr_mfc_find_any
11. mr_fill_mroute
12. mr_rtm_dumproute
13. mr_dump
14. mr_mfc_find
15. mr_vif_seq_start
16. mr_mfc_seq_start
17. mr_mfc_seq_stop
18. mr_vif_seq_idx
19. mr_vif_seq_next
20. mr_vif_seq_start
21. mr_mfc_seq_idx
22. mr_mfc_seq_next
23. mr_mfc_seq_start
24. mr_mfc_seq_stop

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