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

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

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ 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                                        unsigned short family,
 51                                        enum fib_event_type event_type,
 52                                        struct vif_device *vif,
 53                                        unsigned short vif_index, u32 tb_id,
 54                                        struct netlink_ext_ack *extack)
 55 {
 56         struct vif_entry_notifier_info info = {
 57                 .info = {
 58                         .family = family,
 59                         .extack = extack,
 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, 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                 },
 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                                        unsigned short family,
176                                        enum fib_event_type event_type,
177                                        struct mr_mfc *mfc, u32 tb_id,
178                                        struct netlink_ext_ack *extack)
179 {
180         struct mfc_entry_notifier_info info = {
181                 .info = {
182                         .family = family,
183                         .extack = extack,
184                 },
185                 .mfc = mfc,
186                 .tb_id = tb_id
187         };
188 
189         return call_fib_notifier(nb, 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                 },
202                 .mfc = mfc,
203                 .tb_id = tb_id
204         };
205 
206         ASSERT_RTNL();
207         (*ipmr_seq)++;
208         return call_fib_notifiers(net, event_type, &info.info);
209 }
210 
211 struct mr_table;
212 
213 /**
214  * struct mr_table_ops - callbacks and info for protocol-specific ops
215  * @rht_params: parameters for accessing the MFC hash
216  * @cmparg_any: a hash key to be used for matching on (*,*) routes
217  */
218 struct mr_table_ops {
219         const struct rhashtable_params *rht_params;
220         void *cmparg_any;
221 };
222 
223 /**
224  * struct mr_table - a multicast routing table
225  * @list: entry within a list of multicast routing tables
226  * @net: net where this table belongs
227  * @ops: protocol specific operations
228  * @id: identifier of the table
229  * @mroute_sk: socket associated with the table
230  * @ipmr_expire_timer: timer for handling unresolved routes
231  * @mfc_unres_queue: list of unresolved MFC entries
232  * @vif_table: array containing all possible vifs
233  * @mfc_hash: Hash table of all resolved routes for easy lookup
234  * @mfc_cache_list: list of resovled routes for possible traversal
235  * @maxvif: Identifier of highest value vif currently in use
236  * @cache_resolve_queue_len: current size of unresolved queue
237  * @mroute_do_assert: Whether to inform userspace on wrong ingress
238  * @mroute_do_pim: Whether to receive IGMP PIMv1
239  * @mroute_reg_vif_num: PIM-device vif index
240  */
241 struct mr_table {
242         struct list_head        list;
243         possible_net_t          net;
244         struct mr_table_ops     ops;
245         u32                     id;
246         struct sock __rcu       *mroute_sk;
247         struct timer_list       ipmr_expire_timer;
248         struct list_head        mfc_unres_queue;
249         struct vif_device       vif_table[MAXVIFS];
250         struct rhltable         mfc_hash;
251         struct list_head        mfc_cache_list;
252         int                     maxvif;
253         atomic_t                cache_resolve_queue_len;
254         bool                    mroute_do_assert;
255         bool                    mroute_do_pim;
256         bool                    mroute_do_wrvifwhole;
257         int                     mroute_reg_vif_num;
258 };
259 
260 #ifdef CONFIG_IP_MROUTE_COMMON
261 void vif_device_init(struct vif_device *v,
262                      struct net_device *dev,
263                      unsigned long rate_limit,
264                      unsigned char threshold,
265                      unsigned short flags,
266                      unsigned short get_iflink_mask);
267 
268 struct mr_table *
269 mr_table_alloc(struct net *net, u32 id,
270                struct mr_table_ops *ops,
271                void (*expire_func)(struct timer_list *t),
272                void (*table_set)(struct mr_table *mrt,
273                                  struct net *net));
274 
275 /* These actually return 'struct mr_mfc *', but to avoid need for explicit
276  * castings they simply return void.
277  */
278 void *mr_mfc_find_parent(struct mr_table *mrt,
279                          void *hasharg, int parent);
280 void *mr_mfc_find_any_parent(struct mr_table *mrt, int vifi);
281 void *mr_mfc_find_any(struct mr_table *mrt, int vifi, void *hasharg);
282 
283 int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
284                    struct mr_mfc *c, struct rtmsg *rtm);
285 int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb,
286                   struct netlink_callback *cb,
287                   int (*fill)(struct mr_table *mrt, struct sk_buff *skb,
288                               u32 portid, u32 seq, struct mr_mfc *c,
289                               int cmd, int flags),
290                   spinlock_t *lock, struct fib_dump_filter *filter);
291 int mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
292                      struct mr_table *(*iter)(struct net *net,
293                                               struct mr_table *mrt),
294                      int (*fill)(struct mr_table *mrt,
295                                  struct sk_buff *skb,
296                                  u32 portid, u32 seq, struct mr_mfc *c,
297                                  int cmd, int flags),
298                      spinlock_t *lock, struct fib_dump_filter *filter);
299 
300 int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family,
301             int (*rules_dump)(struct net *net,
302                               struct notifier_block *nb,
303                               struct netlink_ext_ack *extack),
304             struct mr_table *(*mr_iter)(struct net *net,
305                                         struct mr_table *mrt),
306             rwlock_t *mrt_lock, struct netlink_ext_ack *extack);
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, struct fib_dump_filter *filter)
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 netlink_ext_ack *extack),
359                           struct mr_table *(*mr_iter)(struct net *net,
360                                                       struct mr_table *mrt),
361                           rwlock_t *mrt_lock, struct netlink_ext_ack *extack)
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