~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/mroute_base.h

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.3 ] ~ [ linux-5.13.16 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.64 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.145 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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
473 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp