include/linux/mroute_base.h

   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_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
 287                      struct mr_table *(*iter)(struct net *net,
 288                                               struct mr_table *mrt),
 289                      int (*fill)(struct mr_table *mrt,
 290                                  struct sk_buff *skb,
 291                                  u32 portid, u32 seq, struct mr_mfc *c,
 292                                  int cmd, int flags),
 293                      spinlock_t *lock);
 294
 295 int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family,
 296             int (*rules_dump)(struct net *net,
 297                               struct notifier_block *nb),
 298             struct mr_table *(*mr_iter)(struct net *net,
 299                                         struct mr_table *mrt),
 300             rwlock_t *mrt_lock);
 301 #else
 302 static inline void vif_device_init(struct vif_device *v,
 303                                    struct net_device *dev,
 304                                    unsigned long rate_limit,
 305                                    unsigned char threshold,
 306                                    unsigned short flags,
 307                                    unsigned short get_iflink_mask)
 308 {
 309 }
 310
 311 static inline void *mr_mfc_find_parent(struct mr_table *mrt,
 312                                        void *hasharg, int parent)
 313 {
 314         return NULL;
 315 }
 316
 317 static inline void *mr_mfc_find_any_parent(struct mr_table *mrt,
 318                                            int vifi)
 319 {
 320         return NULL;
 321 }
 322
 323 static inline struct mr_mfc *mr_mfc_find_any(struct mr_table *mrt,
 324                                              int vifi, void *hasharg)
 325 {
 326         return NULL;
 327 }
 328
 329 static inline int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
 330                                  struct mr_mfc *c, struct rtmsg *rtm)
 331 {
 332         return -EINVAL;
 333 }
 334
 335 static inline int
 336 mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
 337                  struct mr_table *(*iter)(struct net *net,
 338                                           struct mr_table *mrt),
 339                  int (*fill)(struct mr_table *mrt,
 340                              struct sk_buff *skb,
 341                              u32 portid, u32 seq, struct mr_mfc *c,
 342                              int cmd, int flags),
 343                  spinlock_t *lock)
 344 {
 345         return -EINVAL;
 346 }
 347
 348 static inline int mr_dump(struct net *net, struct notifier_block *nb,
 349                           unsigned short family,
 350                           int (*rules_dump)(struct net *net,
 351                                             struct notifier_block *nb),
 352                           struct mr_table *(*mr_iter)(struct net *net,
 353                                                       struct mr_table *mrt),
 354                           rwlock_t *mrt_lock)
 355 {
 356         return -EINVAL;
 357 }
 358 #endif
 359
 360 static inline void *mr_mfc_find(struct mr_table *mrt, void *hasharg)
 361 {
 362         return mr_mfc_find_parent(mrt, hasharg, -1);
 363 }
 364
 365 #ifdef CONFIG_PROC_FS
 366 struct mr_vif_iter {
 367         struct seq_net_private p;
 368         struct mr_table *mrt;
 369         int ct;
 370 };
 371
 372 struct mr_mfc_iter {
 373         struct seq_net_private p;
 374         struct mr_table *mrt;
 375         struct list_head *cache;
 376
 377         /* Lock protecting the mr_table's unresolved queue */
 378         spinlock_t *lock;
 379 };
 380
 381 #ifdef CONFIG_IP_MROUTE_COMMON
 382 void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, loff_t pos);
 383 void *mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos);
 384
 385 static inline void *mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
 386 {
 387         return *pos ? mr_vif_seq_idx(seq_file_net(seq),
 388                                      seq->private, *pos - 1)
 389                     : SEQ_START_TOKEN;
 390 }
 391
 392 /* These actually return 'struct mr_mfc *', but to avoid need for explicit
 393  * castings they simply return void.
 394  */
 395 void *mr_mfc_seq_idx(struct net *net,
 396                      struct mr_mfc_iter *it, loff_t pos);
 397 void *mr_mfc_seq_next(struct seq_file *seq, void *v,
 398                       loff_t *pos);
 399
 400 static inline void *mr_mfc_seq_start(struct seq_file *seq, loff_t *pos,
 401                                      struct mr_table *mrt, spinlock_t *lock)
 402 {
 403         struct mr_mfc_iter *it = seq->private;
 404
 405         it->mrt = mrt;
 406         it->cache = NULL;
 407         it->lock = lock;
 408
 409         return *pos ? mr_mfc_seq_idx(seq_file_net(seq),
 410                                      seq->private, *pos - 1)
 411                     : SEQ_START_TOKEN;
 412 }
 413
 414 static inline void mr_mfc_seq_stop(struct seq_file *seq, void *v)
 415 {
 416         struct mr_mfc_iter *it = seq->private;
 417         struct mr_table *mrt = it->mrt;
 418
 419         if (it->cache == &mrt->mfc_unres_queue)
 420                 spin_unlock_bh(it->lock);
 421         else if (it->cache == &mrt->mfc_cache_list)
 422                 rcu_read_unlock();
 423 }
 424 #else
 425 static inline void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter,
 426                                    loff_t pos)
 427 {
 428         return NULL;
 429 }
 430
 431 static inline void *mr_vif_seq_next(struct seq_file *seq,
 432                                     void *v, loff_t *pos)
 433 {
 434         return NULL;
 435 }
 436
 437 static inline void *mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
 438 {
 439         return NULL;
 440 }
 441
 442 static inline void *mr_mfc_seq_idx(struct net *net,
 443                                    struct mr_mfc_iter *it, loff_t pos)
 444 {
 445         return NULL;
 446 }
 447
 448 static inline void *mr_mfc_seq_next(struct seq_file *seq, void *v,
 449                                     loff_t *pos)
 450 {
 451         return NULL;
 452 }
 453
 454 static inline void *mr_mfc_seq_start(struct seq_file *seq, loff_t *pos,
 455                                      struct mr_table *mrt, spinlock_t *lock)
 456 {
 457         return NULL;
 458 }
 459
 460 static inline void mr_mfc_seq_stop(struct seq_file *seq, void *v)
 461 {
 462 }
 463 #endif
 464 #endif
 465 #endif