GNU Linux-libre 6.9.2-gnu
[releases.git] / 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 #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