aboutsummaryrefslogtreecommitdiffstats
path: root/net/ipv4/ipmr.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/ipv4/ipmr.c')
-rw-r--r--net/ipv4/ipmr.c952
1 files changed, 669 insertions, 283 deletions
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index 54596f73eff5..179fcab866fc 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -22,7 +22,7 @@
22 * overflow. 22 * overflow.
23 * Carlos Picoto : PIMv1 Support 23 * Carlos Picoto : PIMv1 Support
24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header 24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
25 * Relax this requrement to work with older peers. 25 * Relax this requirement to work with older peers.
26 * 26 *
27 */ 27 */
28 28
@@ -47,6 +47,7 @@
47#include <linux/mroute.h> 47#include <linux/mroute.h>
48#include <linux/init.h> 48#include <linux/init.h>
49#include <linux/if_ether.h> 49#include <linux/if_ether.h>
50#include <linux/slab.h>
50#include <net/net_namespace.h> 51#include <net/net_namespace.h>
51#include <net/ip.h> 52#include <net/ip.h>
52#include <net/protocol.h> 53#include <net/protocol.h>
@@ -62,11 +63,40 @@
62#include <net/ipip.h> 63#include <net/ipip.h>
63#include <net/checksum.h> 64#include <net/checksum.h>
64#include <net/netlink.h> 65#include <net/netlink.h>
66#include <net/fib_rules.h>
65 67
66#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2) 68#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
67#define CONFIG_IP_PIMSM 1 69#define CONFIG_IP_PIMSM 1
68#endif 70#endif
69 71
72struct mr_table {
73 struct list_head list;
74#ifdef CONFIG_NET_NS
75 struct net *net;
76#endif
77 u32 id;
78 struct sock *mroute_sk;
79 struct timer_list ipmr_expire_timer;
80 struct list_head mfc_unres_queue;
81 struct list_head mfc_cache_array[MFC_LINES];
82 struct vif_device vif_table[MAXVIFS];
83 int maxvif;
84 atomic_t cache_resolve_queue_len;
85 int mroute_do_assert;
86 int mroute_do_pim;
87#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
88 int mroute_reg_vif_num;
89#endif
90};
91
92struct ipmr_rule {
93 struct fib_rule common;
94};
95
96struct ipmr_result {
97 struct mr_table *mrt;
98};
99
70/* Big lock, protecting vif table, mrt cache and mroute socket state. 100/* Big lock, protecting vif table, mrt cache and mroute socket state.
71 Note that the changes are semaphored via rtnl_lock. 101 Note that the changes are semaphored via rtnl_lock.
72 */ 102 */
@@ -77,9 +107,7 @@ static DEFINE_RWLOCK(mrt_lock);
77 * Multicast router control variables 107 * Multicast router control variables
78 */ 108 */
79 109
80#define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL) 110#define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
81
82static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */
83 111
84/* Special spinlock for queue of unresolved entries */ 112/* Special spinlock for queue of unresolved entries */
85static DEFINE_SPINLOCK(mfc_unres_lock); 113static DEFINE_SPINLOCK(mfc_unres_lock);
@@ -94,12 +122,217 @@ static DEFINE_SPINLOCK(mfc_unres_lock);
94 122
95static struct kmem_cache *mrt_cachep __read_mostly; 123static struct kmem_cache *mrt_cachep __read_mostly;
96 124
97static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local); 125static struct mr_table *ipmr_new_table(struct net *net, u32 id);
98static int ipmr_cache_report(struct net *net, 126static int ip_mr_forward(struct net *net, struct mr_table *mrt,
127 struct sk_buff *skb, struct mfc_cache *cache,
128 int local);
129static int ipmr_cache_report(struct mr_table *mrt,
99 struct sk_buff *pkt, vifi_t vifi, int assert); 130 struct sk_buff *pkt, vifi_t vifi, int assert);
100static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm); 131static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
132 struct mfc_cache *c, struct rtmsg *rtm);
133static void ipmr_expire_process(unsigned long arg);
134
135#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
136#define ipmr_for_each_table(mrt, net) \
137 list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
138
139static struct mr_table *ipmr_get_table(struct net *net, u32 id)
140{
141 struct mr_table *mrt;
142
143 ipmr_for_each_table(mrt, net) {
144 if (mrt->id == id)
145 return mrt;
146 }
147 return NULL;
148}
149
150static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
151 struct mr_table **mrt)
152{
153 struct ipmr_result res;
154 struct fib_lookup_arg arg = { .result = &res, };
155 int err;
156
157 err = fib_rules_lookup(net->ipv4.mr_rules_ops, flp, 0, &arg);
158 if (err < 0)
159 return err;
160 *mrt = res.mrt;
161 return 0;
162}
163
164static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
165 int flags, struct fib_lookup_arg *arg)
166{
167 struct ipmr_result *res = arg->result;
168 struct mr_table *mrt;
169
170 switch (rule->action) {
171 case FR_ACT_TO_TBL:
172 break;
173 case FR_ACT_UNREACHABLE:
174 return -ENETUNREACH;
175 case FR_ACT_PROHIBIT:
176 return -EACCES;
177 case FR_ACT_BLACKHOLE:
178 default:
179 return -EINVAL;
180 }
181
182 mrt = ipmr_get_table(rule->fr_net, rule->table);
183 if (mrt == NULL)
184 return -EAGAIN;
185 res->mrt = mrt;
186 return 0;
187}
188
189static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
190{
191 return 1;
192}
193
194static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
195 FRA_GENERIC_POLICY,
196};
197
198static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
199 struct fib_rule_hdr *frh, struct nlattr **tb)
200{
201 return 0;
202}
203
204static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
205 struct nlattr **tb)
206{
207 return 1;
208}
209
210static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
211 struct fib_rule_hdr *frh)
212{
213 frh->dst_len = 0;
214 frh->src_len = 0;
215 frh->tos = 0;
216 return 0;
217}
101 218
102static struct timer_list ipmr_expire_timer; 219static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
220 .family = RTNL_FAMILY_IPMR,
221 .rule_size = sizeof(struct ipmr_rule),
222 .addr_size = sizeof(u32),
223 .action = ipmr_rule_action,
224 .match = ipmr_rule_match,
225 .configure = ipmr_rule_configure,
226 .compare = ipmr_rule_compare,
227 .default_pref = fib_default_rule_pref,
228 .fill = ipmr_rule_fill,
229 .nlgroup = RTNLGRP_IPV4_RULE,
230 .policy = ipmr_rule_policy,
231 .owner = THIS_MODULE,
232};
233
234static int __net_init ipmr_rules_init(struct net *net)
235{
236 struct fib_rules_ops *ops;
237 struct mr_table *mrt;
238 int err;
239
240 ops = fib_rules_register(&ipmr_rules_ops_template, net);
241 if (IS_ERR(ops))
242 return PTR_ERR(ops);
243
244 INIT_LIST_HEAD(&net->ipv4.mr_tables);
245
246 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
247 if (mrt == NULL) {
248 err = -ENOMEM;
249 goto err1;
250 }
251
252 err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
253 if (err < 0)
254 goto err2;
255
256 net->ipv4.mr_rules_ops = ops;
257 return 0;
258
259err2:
260 kfree(mrt);
261err1:
262 fib_rules_unregister(ops);
263 return err;
264}
265
266static void __net_exit ipmr_rules_exit(struct net *net)
267{
268 struct mr_table *mrt, *next;
269
270 list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
271 list_del(&mrt->list);
272 kfree(mrt);
273 }
274 fib_rules_unregister(net->ipv4.mr_rules_ops);
275}
276#else
277#define ipmr_for_each_table(mrt, net) \
278 for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
279
280static struct mr_table *ipmr_get_table(struct net *net, u32 id)
281{
282 return net->ipv4.mrt;
283}
284
285static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
286 struct mr_table **mrt)
287{
288 *mrt = net->ipv4.mrt;
289 return 0;
290}
291
292static int __net_init ipmr_rules_init(struct net *net)
293{
294 net->ipv4.mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
295 return net->ipv4.mrt ? 0 : -ENOMEM;
296}
297
298static void __net_exit ipmr_rules_exit(struct net *net)
299{
300 kfree(net->ipv4.mrt);
301}
302#endif
303
304static struct mr_table *ipmr_new_table(struct net *net, u32 id)
305{
306 struct mr_table *mrt;
307 unsigned int i;
308
309 mrt = ipmr_get_table(net, id);
310 if (mrt != NULL)
311 return mrt;
312
313 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
314 if (mrt == NULL)
315 return NULL;
316 write_pnet(&mrt->net, net);
317 mrt->id = id;
318
319 /* Forwarding cache */
320 for (i = 0; i < MFC_LINES; i++)
321 INIT_LIST_HEAD(&mrt->mfc_cache_array[i]);
322
323 INIT_LIST_HEAD(&mrt->mfc_unres_queue);
324
325 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
326 (unsigned long)mrt);
327
328#ifdef CONFIG_IP_PIMSM
329 mrt->mroute_reg_vif_num = -1;
330#endif
331#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
332 list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
333#endif
334 return mrt;
335}
103 336
104/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */ 337/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
105 338
@@ -200,12 +433,24 @@ failure:
200static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev) 433static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
201{ 434{
202 struct net *net = dev_net(dev); 435 struct net *net = dev_net(dev);
436 struct mr_table *mrt;
437 struct flowi fl = {
438 .oif = dev->ifindex,
439 .iif = skb->skb_iif,
440 .mark = skb->mark,
441 };
442 int err;
443
444 err = ipmr_fib_lookup(net, &fl, &mrt);
445 if (err < 0) {
446 kfree_skb(skb);
447 return err;
448 }
203 449
204 read_lock(&mrt_lock); 450 read_lock(&mrt_lock);
205 dev->stats.tx_bytes += skb->len; 451 dev->stats.tx_bytes += skb->len;
206 dev->stats.tx_packets++; 452 dev->stats.tx_packets++;
207 ipmr_cache_report(net, skb, net->ipv4.mroute_reg_vif_num, 453 ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
208 IGMPMSG_WHOLEPKT);
209 read_unlock(&mrt_lock); 454 read_unlock(&mrt_lock);
210 kfree_skb(skb); 455 kfree_skb(skb);
211 return NETDEV_TX_OK; 456 return NETDEV_TX_OK;
@@ -225,12 +470,18 @@ static void reg_vif_setup(struct net_device *dev)
225 dev->features |= NETIF_F_NETNS_LOCAL; 470 dev->features |= NETIF_F_NETNS_LOCAL;
226} 471}
227 472
228static struct net_device *ipmr_reg_vif(struct net *net) 473static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
229{ 474{
230 struct net_device *dev; 475 struct net_device *dev;
231 struct in_device *in_dev; 476 struct in_device *in_dev;
477 char name[IFNAMSIZ];
478
479 if (mrt->id == RT_TABLE_DEFAULT)
480 sprintf(name, "pimreg");
481 else
482 sprintf(name, "pimreg%u", mrt->id);
232 483
233 dev = alloc_netdev(0, "pimreg", reg_vif_setup); 484 dev = alloc_netdev(0, name, reg_vif_setup);
234 485
235 if (dev == NULL) 486 if (dev == NULL)
236 return NULL; 487 return NULL;
@@ -275,17 +526,17 @@ failure:
275 * @notify: Set to 1, if the caller is a notifier_call 526 * @notify: Set to 1, if the caller is a notifier_call
276 */ 527 */
277 528
278static int vif_delete(struct net *net, int vifi, int notify, 529static int vif_delete(struct mr_table *mrt, int vifi, int notify,
279 struct list_head *head) 530 struct list_head *head)
280{ 531{
281 struct vif_device *v; 532 struct vif_device *v;
282 struct net_device *dev; 533 struct net_device *dev;
283 struct in_device *in_dev; 534 struct in_device *in_dev;
284 535
285 if (vifi < 0 || vifi >= net->ipv4.maxvif) 536 if (vifi < 0 || vifi >= mrt->maxvif)
286 return -EADDRNOTAVAIL; 537 return -EADDRNOTAVAIL;
287 538
288 v = &net->ipv4.vif_table[vifi]; 539 v = &mrt->vif_table[vifi];
289 540
290 write_lock_bh(&mrt_lock); 541 write_lock_bh(&mrt_lock);
291 dev = v->dev; 542 dev = v->dev;
@@ -297,17 +548,17 @@ static int vif_delete(struct net *net, int vifi, int notify,
297 } 548 }
298 549
299#ifdef CONFIG_IP_PIMSM 550#ifdef CONFIG_IP_PIMSM
300 if (vifi == net->ipv4.mroute_reg_vif_num) 551 if (vifi == mrt->mroute_reg_vif_num)
301 net->ipv4.mroute_reg_vif_num = -1; 552 mrt->mroute_reg_vif_num = -1;
302#endif 553#endif
303 554
304 if (vifi+1 == net->ipv4.maxvif) { 555 if (vifi+1 == mrt->maxvif) {
305 int tmp; 556 int tmp;
306 for (tmp=vifi-1; tmp>=0; tmp--) { 557 for (tmp=vifi-1; tmp>=0; tmp--) {
307 if (VIF_EXISTS(net, tmp)) 558 if (VIF_EXISTS(mrt, tmp))
308 break; 559 break;
309 } 560 }
310 net->ipv4.maxvif = tmp+1; 561 mrt->maxvif = tmp+1;
311 } 562 }
312 563
313 write_unlock_bh(&mrt_lock); 564 write_unlock_bh(&mrt_lock);
@@ -328,7 +579,6 @@ static int vif_delete(struct net *net, int vifi, int notify,
328 579
329static inline void ipmr_cache_free(struct mfc_cache *c) 580static inline void ipmr_cache_free(struct mfc_cache *c)
330{ 581{
331 release_net(mfc_net(c));
332 kmem_cache_free(mrt_cachep, c); 582 kmem_cache_free(mrt_cachep, c);
333} 583}
334 584
@@ -336,13 +586,13 @@ static inline void ipmr_cache_free(struct mfc_cache *c)
336 and reporting error to netlink readers. 586 and reporting error to netlink readers.
337 */ 587 */
338 588
339static void ipmr_destroy_unres(struct mfc_cache *c) 589static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
340{ 590{
591 struct net *net = read_pnet(&mrt->net);
341 struct sk_buff *skb; 592 struct sk_buff *skb;
342 struct nlmsgerr *e; 593 struct nlmsgerr *e;
343 struct net *net = mfc_net(c);
344 594
345 atomic_dec(&net->ipv4.cache_resolve_queue_len); 595 atomic_dec(&mrt->cache_resolve_queue_len);
346 596
347 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) { 597 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
348 if (ip_hdr(skb)->version == 0) { 598 if (ip_hdr(skb)->version == 0) {
@@ -363,42 +613,40 @@ static void ipmr_destroy_unres(struct mfc_cache *c)
363} 613}
364 614
365 615
366/* Single timer process for all the unresolved queue. */ 616/* Timer process for the unresolved queue. */
367 617
368static void ipmr_expire_process(unsigned long dummy) 618static void ipmr_expire_process(unsigned long arg)
369{ 619{
620 struct mr_table *mrt = (struct mr_table *)arg;
370 unsigned long now; 621 unsigned long now;
371 unsigned long expires; 622 unsigned long expires;
372 struct mfc_cache *c, **cp; 623 struct mfc_cache *c, *next;
373 624
374 if (!spin_trylock(&mfc_unres_lock)) { 625 if (!spin_trylock(&mfc_unres_lock)) {
375 mod_timer(&ipmr_expire_timer, jiffies+HZ/10); 626 mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
376 return; 627 return;
377 } 628 }
378 629
379 if (mfc_unres_queue == NULL) 630 if (list_empty(&mrt->mfc_unres_queue))
380 goto out; 631 goto out;
381 632
382 now = jiffies; 633 now = jiffies;
383 expires = 10*HZ; 634 expires = 10*HZ;
384 cp = &mfc_unres_queue;
385 635
386 while ((c=*cp) != NULL) { 636 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
387 if (time_after(c->mfc_un.unres.expires, now)) { 637 if (time_after(c->mfc_un.unres.expires, now)) {
388 unsigned long interval = c->mfc_un.unres.expires - now; 638 unsigned long interval = c->mfc_un.unres.expires - now;
389 if (interval < expires) 639 if (interval < expires)
390 expires = interval; 640 expires = interval;
391 cp = &c->next;
392 continue; 641 continue;
393 } 642 }
394 643
395 *cp = c->next; 644 list_del(&c->list);
396 645 ipmr_destroy_unres(mrt, c);
397 ipmr_destroy_unres(c);
398 } 646 }
399 647
400 if (mfc_unres_queue != NULL) 648 if (!list_empty(&mrt->mfc_unres_queue))
401 mod_timer(&ipmr_expire_timer, jiffies + expires); 649 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
402 650
403out: 651out:
404 spin_unlock(&mfc_unres_lock); 652 spin_unlock(&mfc_unres_lock);
@@ -406,17 +654,17 @@ out:
406 654
407/* Fill oifs list. It is called under write locked mrt_lock. */ 655/* Fill oifs list. It is called under write locked mrt_lock. */
408 656
409static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls) 657static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
658 unsigned char *ttls)
410{ 659{
411 int vifi; 660 int vifi;
412 struct net *net = mfc_net(cache);
413 661
414 cache->mfc_un.res.minvif = MAXVIFS; 662 cache->mfc_un.res.minvif = MAXVIFS;
415 cache->mfc_un.res.maxvif = 0; 663 cache->mfc_un.res.maxvif = 0;
416 memset(cache->mfc_un.res.ttls, 255, MAXVIFS); 664 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
417 665
418 for (vifi = 0; vifi < net->ipv4.maxvif; vifi++) { 666 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
419 if (VIF_EXISTS(net, vifi) && 667 if (VIF_EXISTS(mrt, vifi) &&
420 ttls[vifi] && ttls[vifi] < 255) { 668 ttls[vifi] && ttls[vifi] < 255) {
421 cache->mfc_un.res.ttls[vifi] = ttls[vifi]; 669 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
422 if (cache->mfc_un.res.minvif > vifi) 670 if (cache->mfc_un.res.minvif > vifi)
@@ -427,16 +675,17 @@ static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
427 } 675 }
428} 676}
429 677
430static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock) 678static int vif_add(struct net *net, struct mr_table *mrt,
679 struct vifctl *vifc, int mrtsock)
431{ 680{
432 int vifi = vifc->vifc_vifi; 681 int vifi = vifc->vifc_vifi;
433 struct vif_device *v = &net->ipv4.vif_table[vifi]; 682 struct vif_device *v = &mrt->vif_table[vifi];
434 struct net_device *dev; 683 struct net_device *dev;
435 struct in_device *in_dev; 684 struct in_device *in_dev;
436 int err; 685 int err;
437 686
438 /* Is vif busy ? */ 687 /* Is vif busy ? */
439 if (VIF_EXISTS(net, vifi)) 688 if (VIF_EXISTS(mrt, vifi))
440 return -EADDRINUSE; 689 return -EADDRINUSE;
441 690
442 switch (vifc->vifc_flags) { 691 switch (vifc->vifc_flags) {
@@ -446,9 +695,9 @@ static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
446 * Special Purpose VIF in PIM 695 * Special Purpose VIF in PIM
447 * All the packets will be sent to the daemon 696 * All the packets will be sent to the daemon
448 */ 697 */
449 if (net->ipv4.mroute_reg_vif_num >= 0) 698 if (mrt->mroute_reg_vif_num >= 0)
450 return -EADDRINUSE; 699 return -EADDRINUSE;
451 dev = ipmr_reg_vif(net); 700 dev = ipmr_reg_vif(net, mrt);
452 if (!dev) 701 if (!dev)
453 return -ENOBUFS; 702 return -ENOBUFS;
454 err = dev_set_allmulti(dev, 1); 703 err = dev_set_allmulti(dev, 1);
@@ -524,49 +773,47 @@ static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
524 v->dev = dev; 773 v->dev = dev;
525#ifdef CONFIG_IP_PIMSM 774#ifdef CONFIG_IP_PIMSM
526 if (v->flags&VIFF_REGISTER) 775 if (v->flags&VIFF_REGISTER)
527 net->ipv4.mroute_reg_vif_num = vifi; 776 mrt->mroute_reg_vif_num = vifi;
528#endif 777#endif
529 if (vifi+1 > net->ipv4.maxvif) 778 if (vifi+1 > mrt->maxvif)
530 net->ipv4.maxvif = vifi+1; 779 mrt->maxvif = vifi+1;
531 write_unlock_bh(&mrt_lock); 780 write_unlock_bh(&mrt_lock);
532 return 0; 781 return 0;
533} 782}
534 783
535static struct mfc_cache *ipmr_cache_find(struct net *net, 784static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
536 __be32 origin, 785 __be32 origin,
537 __be32 mcastgrp) 786 __be32 mcastgrp)
538{ 787{
539 int line = MFC_HASH(mcastgrp, origin); 788 int line = MFC_HASH(mcastgrp, origin);
540 struct mfc_cache *c; 789 struct mfc_cache *c;
541 790
542 for (c = net->ipv4.mfc_cache_array[line]; c; c = c->next) { 791 list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
543 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp) 792 if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
544 break; 793 return c;
545 } 794 }
546 return c; 795 return NULL;
547} 796}
548 797
549/* 798/*
550 * Allocate a multicast cache entry 799 * Allocate a multicast cache entry
551 */ 800 */
552static struct mfc_cache *ipmr_cache_alloc(struct net *net) 801static struct mfc_cache *ipmr_cache_alloc(void)
553{ 802{
554 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL); 803 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
555 if (c == NULL) 804 if (c == NULL)
556 return NULL; 805 return NULL;
557 c->mfc_un.res.minvif = MAXVIFS; 806 c->mfc_un.res.minvif = MAXVIFS;
558 mfc_net_set(c, net);
559 return c; 807 return c;
560} 808}
561 809
562static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net) 810static struct mfc_cache *ipmr_cache_alloc_unres(void)
563{ 811{
564 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC); 812 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
565 if (c == NULL) 813 if (c == NULL)
566 return NULL; 814 return NULL;
567 skb_queue_head_init(&c->mfc_un.unres.unresolved); 815 skb_queue_head_init(&c->mfc_un.unres.unresolved);
568 c->mfc_un.unres.expires = jiffies + 10*HZ; 816 c->mfc_un.unres.expires = jiffies + 10*HZ;
569 mfc_net_set(c, net);
570 return c; 817 return c;
571} 818}
572 819
@@ -574,7 +821,8 @@ static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net)
574 * A cache entry has gone into a resolved state from queued 821 * A cache entry has gone into a resolved state from queued
575 */ 822 */
576 823
577static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c) 824static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
825 struct mfc_cache *uc, struct mfc_cache *c)
578{ 826{
579 struct sk_buff *skb; 827 struct sk_buff *skb;
580 struct nlmsgerr *e; 828 struct nlmsgerr *e;
@@ -587,7 +835,7 @@ static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
587 if (ip_hdr(skb)->version == 0) { 835 if (ip_hdr(skb)->version == 0) {
588 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 836 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
589 837
590 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) { 838 if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
591 nlh->nlmsg_len = (skb_tail_pointer(skb) - 839 nlh->nlmsg_len = (skb_tail_pointer(skb) -
592 (u8 *)nlh); 840 (u8 *)nlh);
593 } else { 841 } else {
@@ -599,9 +847,9 @@ static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
599 memset(&e->msg, 0, sizeof(e->msg)); 847 memset(&e->msg, 0, sizeof(e->msg));
600 } 848 }
601 849
602 rtnl_unicast(skb, mfc_net(c), NETLINK_CB(skb).pid); 850 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
603 } else 851 } else
604 ip_mr_forward(skb, c, 0); 852 ip_mr_forward(net, mrt, skb, c, 0);
605 } 853 }
606} 854}
607 855
@@ -612,7 +860,7 @@ static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
612 * Called under mrt_lock. 860 * Called under mrt_lock.
613 */ 861 */
614 862
615static int ipmr_cache_report(struct net *net, 863static int ipmr_cache_report(struct mr_table *mrt,
616 struct sk_buff *pkt, vifi_t vifi, int assert) 864 struct sk_buff *pkt, vifi_t vifi, int assert)
617{ 865{
618 struct sk_buff *skb; 866 struct sk_buff *skb;
@@ -645,7 +893,7 @@ static int ipmr_cache_report(struct net *net,
645 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr)); 893 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
646 msg->im_msgtype = IGMPMSG_WHOLEPKT; 894 msg->im_msgtype = IGMPMSG_WHOLEPKT;
647 msg->im_mbz = 0; 895 msg->im_mbz = 0;
648 msg->im_vif = net->ipv4.mroute_reg_vif_num; 896 msg->im_vif = mrt->mroute_reg_vif_num;
649 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2; 897 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
650 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) + 898 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
651 sizeof(struct iphdr)); 899 sizeof(struct iphdr));
@@ -677,7 +925,7 @@ static int ipmr_cache_report(struct net *net,
677 skb->transport_header = skb->network_header; 925 skb->transport_header = skb->network_header;
678 } 926 }
679 927
680 if (net->ipv4.mroute_sk == NULL) { 928 if (mrt->mroute_sk == NULL) {
681 kfree_skb(skb); 929 kfree_skb(skb);
682 return -EINVAL; 930 return -EINVAL;
683 } 931 }
@@ -685,7 +933,7 @@ static int ipmr_cache_report(struct net *net,
685 /* 933 /*
686 * Deliver to mrouted 934 * Deliver to mrouted
687 */ 935 */
688 ret = sock_queue_rcv_skb(net->ipv4.mroute_sk, skb); 936 ret = sock_queue_rcv_skb(mrt->mroute_sk, skb);
689 if (ret < 0) { 937 if (ret < 0) {
690 if (net_ratelimit()) 938 if (net_ratelimit())
691 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n"); 939 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
@@ -700,27 +948,29 @@ static int ipmr_cache_report(struct net *net,
700 */ 948 */
701 949
702static int 950static int
703ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb) 951ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
704{ 952{
953 bool found = false;
705 int err; 954 int err;
706 struct mfc_cache *c; 955 struct mfc_cache *c;
707 const struct iphdr *iph = ip_hdr(skb); 956 const struct iphdr *iph = ip_hdr(skb);
708 957
709 spin_lock_bh(&mfc_unres_lock); 958 spin_lock_bh(&mfc_unres_lock);
710 for (c=mfc_unres_queue; c; c=c->next) { 959 list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
711 if (net_eq(mfc_net(c), net) && 960 if (c->mfc_mcastgrp == iph->daddr &&
712 c->mfc_mcastgrp == iph->daddr && 961 c->mfc_origin == iph->saddr) {
713 c->mfc_origin == iph->saddr) 962 found = true;
714 break; 963 break;
964 }
715 } 965 }
716 966
717 if (c == NULL) { 967 if (!found) {
718 /* 968 /*
719 * Create a new entry if allowable 969 * Create a new entry if allowable
720 */ 970 */
721 971
722 if (atomic_read(&net->ipv4.cache_resolve_queue_len) >= 10 || 972 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
723 (c = ipmr_cache_alloc_unres(net)) == NULL) { 973 (c = ipmr_cache_alloc_unres()) == NULL) {
724 spin_unlock_bh(&mfc_unres_lock); 974 spin_unlock_bh(&mfc_unres_lock);
725 975
726 kfree_skb(skb); 976 kfree_skb(skb);
@@ -737,7 +987,7 @@ ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
737 /* 987 /*
738 * Reflect first query at mrouted. 988 * Reflect first query at mrouted.
739 */ 989 */
740 err = ipmr_cache_report(net, skb, vifi, IGMPMSG_NOCACHE); 990 err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
741 if (err < 0) { 991 if (err < 0) {
742 /* If the report failed throw the cache entry 992 /* If the report failed throw the cache entry
743 out - Brad Parker 993 out - Brad Parker
@@ -749,11 +999,11 @@ ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
749 return err; 999 return err;
750 } 1000 }
751 1001
752 atomic_inc(&net->ipv4.cache_resolve_queue_len); 1002 atomic_inc(&mrt->cache_resolve_queue_len);
753 c->next = mfc_unres_queue; 1003 list_add(&c->list, &mrt->mfc_unres_queue);
754 mfc_unres_queue = c;
755 1004
756 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires); 1005 if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
1006 mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
757 } 1007 }
758 1008
759 /* 1009 /*
@@ -775,19 +1025,18 @@ ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
775 * MFC cache manipulation by user space mroute daemon 1025 * MFC cache manipulation by user space mroute daemon
776 */ 1026 */
777 1027
778static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc) 1028static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc)
779{ 1029{
780 int line; 1030 int line;
781 struct mfc_cache *c, **cp; 1031 struct mfc_cache *c, *next;
782 1032
783 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 1033 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
784 1034
785 for (cp = &net->ipv4.mfc_cache_array[line]; 1035 list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
786 (c = *cp) != NULL; cp = &c->next) {
787 if (c->mfc_origin == mfc->mfcc_origin.s_addr && 1036 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
788 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) { 1037 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
789 write_lock_bh(&mrt_lock); 1038 write_lock_bh(&mrt_lock);
790 *cp = c->next; 1039 list_del(&c->list);
791 write_unlock_bh(&mrt_lock); 1040 write_unlock_bh(&mrt_lock);
792 1041
793 ipmr_cache_free(c); 1042 ipmr_cache_free(c);
@@ -797,24 +1046,30 @@ static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
797 return -ENOENT; 1046 return -ENOENT;
798} 1047}
799 1048
800static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock) 1049static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
1050 struct mfcctl *mfc, int mrtsock)
801{ 1051{
1052 bool found = false;
802 int line; 1053 int line;
803 struct mfc_cache *uc, *c, **cp; 1054 struct mfc_cache *uc, *c;
1055
1056 if (mfc->mfcc_parent >= MAXVIFS)
1057 return -ENFILE;
804 1058
805 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 1059 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
806 1060
807 for (cp = &net->ipv4.mfc_cache_array[line]; 1061 list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
808 (c = *cp) != NULL; cp = &c->next) {
809 if (c->mfc_origin == mfc->mfcc_origin.s_addr && 1062 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
810 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) 1063 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
1064 found = true;
811 break; 1065 break;
1066 }
812 } 1067 }
813 1068
814 if (c != NULL) { 1069 if (found) {
815 write_lock_bh(&mrt_lock); 1070 write_lock_bh(&mrt_lock);
816 c->mfc_parent = mfc->mfcc_parent; 1071 c->mfc_parent = mfc->mfcc_parent;
817 ipmr_update_thresholds(c, mfc->mfcc_ttls); 1072 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
818 if (!mrtsock) 1073 if (!mrtsock)
819 c->mfc_flags |= MFC_STATIC; 1074 c->mfc_flags |= MFC_STATIC;
820 write_unlock_bh(&mrt_lock); 1075 write_unlock_bh(&mrt_lock);
@@ -824,43 +1079,42 @@ static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
824 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr)) 1079 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
825 return -EINVAL; 1080 return -EINVAL;
826 1081
827 c = ipmr_cache_alloc(net); 1082 c = ipmr_cache_alloc();
828 if (c == NULL) 1083 if (c == NULL)
829 return -ENOMEM; 1084 return -ENOMEM;
830 1085
831 c->mfc_origin = mfc->mfcc_origin.s_addr; 1086 c->mfc_origin = mfc->mfcc_origin.s_addr;
832 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr; 1087 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
833 c->mfc_parent = mfc->mfcc_parent; 1088 c->mfc_parent = mfc->mfcc_parent;
834 ipmr_update_thresholds(c, mfc->mfcc_ttls); 1089 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
835 if (!mrtsock) 1090 if (!mrtsock)
836 c->mfc_flags |= MFC_STATIC; 1091 c->mfc_flags |= MFC_STATIC;
837 1092
838 write_lock_bh(&mrt_lock); 1093 write_lock_bh(&mrt_lock);
839 c->next = net->ipv4.mfc_cache_array[line]; 1094 list_add(&c->list, &mrt->mfc_cache_array[line]);
840 net->ipv4.mfc_cache_array[line] = c;
841 write_unlock_bh(&mrt_lock); 1095 write_unlock_bh(&mrt_lock);
842 1096
843 /* 1097 /*
844 * Check to see if we resolved a queued list. If so we 1098 * Check to see if we resolved a queued list. If so we
845 * need to send on the frames and tidy up. 1099 * need to send on the frames and tidy up.
846 */ 1100 */
1101 found = false;
847 spin_lock_bh(&mfc_unres_lock); 1102 spin_lock_bh(&mfc_unres_lock);
848 for (cp = &mfc_unres_queue; (uc=*cp) != NULL; 1103 list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
849 cp = &uc->next) { 1104 if (uc->mfc_origin == c->mfc_origin &&
850 if (net_eq(mfc_net(uc), net) &&
851 uc->mfc_origin == c->mfc_origin &&
852 uc->mfc_mcastgrp == c->mfc_mcastgrp) { 1105 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
853 *cp = uc->next; 1106 list_del(&uc->list);
854 atomic_dec(&net->ipv4.cache_resolve_queue_len); 1107 atomic_dec(&mrt->cache_resolve_queue_len);
1108 found = true;
855 break; 1109 break;
856 } 1110 }
857 } 1111 }
858 if (mfc_unres_queue == NULL) 1112 if (list_empty(&mrt->mfc_unres_queue))
859 del_timer(&ipmr_expire_timer); 1113 del_timer(&mrt->ipmr_expire_timer);
860 spin_unlock_bh(&mfc_unres_lock); 1114 spin_unlock_bh(&mfc_unres_lock);
861 1115
862 if (uc) { 1116 if (found) {
863 ipmr_cache_resolve(uc, c); 1117 ipmr_cache_resolve(net, mrt, uc, c);
864 ipmr_cache_free(uc); 1118 ipmr_cache_free(uc);
865 } 1119 }
866 return 0; 1120 return 0;
@@ -870,53 +1124,41 @@ static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
870 * Close the multicast socket, and clear the vif tables etc 1124 * Close the multicast socket, and clear the vif tables etc
871 */ 1125 */
872 1126
873static void mroute_clean_tables(struct net *net) 1127static void mroute_clean_tables(struct mr_table *mrt)
874{ 1128{
875 int i; 1129 int i;
876 LIST_HEAD(list); 1130 LIST_HEAD(list);
1131 struct mfc_cache *c, *next;
877 1132
878 /* 1133 /*
879 * Shut down all active vif entries 1134 * Shut down all active vif entries
880 */ 1135 */
881 for (i = 0; i < net->ipv4.maxvif; i++) { 1136 for (i = 0; i < mrt->maxvif; i++) {
882 if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC)) 1137 if (!(mrt->vif_table[i].flags&VIFF_STATIC))
883 vif_delete(net, i, 0, &list); 1138 vif_delete(mrt, i, 0, &list);
884 } 1139 }
885 unregister_netdevice_many(&list); 1140 unregister_netdevice_many(&list);
886 1141
887 /* 1142 /*
888 * Wipe the cache 1143 * Wipe the cache
889 */ 1144 */
890 for (i=0; i<MFC_LINES; i++) { 1145 for (i = 0; i < MFC_LINES; i++) {
891 struct mfc_cache *c, **cp; 1146 list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
892 1147 if (c->mfc_flags&MFC_STATIC)
893 cp = &net->ipv4.mfc_cache_array[i];
894 while ((c = *cp) != NULL) {
895 if (c->mfc_flags&MFC_STATIC) {
896 cp = &c->next;
897 continue; 1148 continue;
898 }
899 write_lock_bh(&mrt_lock); 1149 write_lock_bh(&mrt_lock);
900 *cp = c->next; 1150 list_del(&c->list);
901 write_unlock_bh(&mrt_lock); 1151 write_unlock_bh(&mrt_lock);
902 1152
903 ipmr_cache_free(c); 1153 ipmr_cache_free(c);
904 } 1154 }
905 } 1155 }
906 1156
907 if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) { 1157 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
908 struct mfc_cache *c, **cp;
909
910 spin_lock_bh(&mfc_unres_lock); 1158 spin_lock_bh(&mfc_unres_lock);
911 cp = &mfc_unres_queue; 1159 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
912 while ((c = *cp) != NULL) { 1160 list_del(&c->list);
913 if (!net_eq(mfc_net(c), net)) { 1161 ipmr_destroy_unres(mrt, c);
914 cp = &c->next;
915 continue;
916 }
917 *cp = c->next;
918
919 ipmr_destroy_unres(c);
920 } 1162 }
921 spin_unlock_bh(&mfc_unres_lock); 1163 spin_unlock_bh(&mfc_unres_lock);
922 } 1164 }
@@ -925,16 +1167,19 @@ static void mroute_clean_tables(struct net *net)
925static void mrtsock_destruct(struct sock *sk) 1167static void mrtsock_destruct(struct sock *sk)
926{ 1168{
927 struct net *net = sock_net(sk); 1169 struct net *net = sock_net(sk);
1170 struct mr_table *mrt;
928 1171
929 rtnl_lock(); 1172 rtnl_lock();
930 if (sk == net->ipv4.mroute_sk) { 1173 ipmr_for_each_table(mrt, net) {
931 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--; 1174 if (sk == mrt->mroute_sk) {
1175 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
932 1176
933 write_lock_bh(&mrt_lock); 1177 write_lock_bh(&mrt_lock);
934 net->ipv4.mroute_sk = NULL; 1178 mrt->mroute_sk = NULL;
935 write_unlock_bh(&mrt_lock); 1179 write_unlock_bh(&mrt_lock);
936 1180
937 mroute_clean_tables(net); 1181 mroute_clean_tables(mrt);
1182 }
938 } 1183 }
939 rtnl_unlock(); 1184 rtnl_unlock();
940} 1185}
@@ -952,9 +1197,14 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
952 struct vifctl vif; 1197 struct vifctl vif;
953 struct mfcctl mfc; 1198 struct mfcctl mfc;
954 struct net *net = sock_net(sk); 1199 struct net *net = sock_net(sk);
1200 struct mr_table *mrt;
1201
1202 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1203 if (mrt == NULL)
1204 return -ENOENT;
955 1205
956 if (optname != MRT_INIT) { 1206 if (optname != MRT_INIT) {
957 if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN)) 1207 if (sk != mrt->mroute_sk && !capable(CAP_NET_ADMIN))
958 return -EACCES; 1208 return -EACCES;
959 } 1209 }
960 1210
@@ -967,7 +1217,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
967 return -ENOPROTOOPT; 1217 return -ENOPROTOOPT;
968 1218
969 rtnl_lock(); 1219 rtnl_lock();
970 if (net->ipv4.mroute_sk) { 1220 if (mrt->mroute_sk) {
971 rtnl_unlock(); 1221 rtnl_unlock();
972 return -EADDRINUSE; 1222 return -EADDRINUSE;
973 } 1223 }
@@ -975,7 +1225,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
975 ret = ip_ra_control(sk, 1, mrtsock_destruct); 1225 ret = ip_ra_control(sk, 1, mrtsock_destruct);
976 if (ret == 0) { 1226 if (ret == 0) {
977 write_lock_bh(&mrt_lock); 1227 write_lock_bh(&mrt_lock);
978 net->ipv4.mroute_sk = sk; 1228 mrt->mroute_sk = sk;
979 write_unlock_bh(&mrt_lock); 1229 write_unlock_bh(&mrt_lock);
980 1230
981 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++; 1231 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
@@ -983,7 +1233,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
983 rtnl_unlock(); 1233 rtnl_unlock();
984 return ret; 1234 return ret;
985 case MRT_DONE: 1235 case MRT_DONE:
986 if (sk != net->ipv4.mroute_sk) 1236 if (sk != mrt->mroute_sk)
987 return -EACCES; 1237 return -EACCES;
988 return ip_ra_control(sk, 0, NULL); 1238 return ip_ra_control(sk, 0, NULL);
989 case MRT_ADD_VIF: 1239 case MRT_ADD_VIF:
@@ -996,9 +1246,9 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
996 return -ENFILE; 1246 return -ENFILE;
997 rtnl_lock(); 1247 rtnl_lock();
998 if (optname == MRT_ADD_VIF) { 1248 if (optname == MRT_ADD_VIF) {
999 ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk); 1249 ret = vif_add(net, mrt, &vif, sk == mrt->mroute_sk);
1000 } else { 1250 } else {
1001 ret = vif_delete(net, vif.vifc_vifi, 0, NULL); 1251 ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
1002 } 1252 }
1003 rtnl_unlock(); 1253 rtnl_unlock();
1004 return ret; 1254 return ret;
@@ -1015,9 +1265,9 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
1015 return -EFAULT; 1265 return -EFAULT;
1016 rtnl_lock(); 1266 rtnl_lock();
1017 if (optname == MRT_DEL_MFC) 1267 if (optname == MRT_DEL_MFC)
1018 ret = ipmr_mfc_delete(net, &mfc); 1268 ret = ipmr_mfc_delete(mrt, &mfc);
1019 else 1269 else
1020 ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk); 1270 ret = ipmr_mfc_add(net, mrt, &mfc, sk == mrt->mroute_sk);
1021 rtnl_unlock(); 1271 rtnl_unlock();
1022 return ret; 1272 return ret;
1023 /* 1273 /*
@@ -1028,7 +1278,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
1028 int v; 1278 int v;
1029 if (get_user(v,(int __user *)optval)) 1279 if (get_user(v,(int __user *)optval))
1030 return -EFAULT; 1280 return -EFAULT;
1031 net->ipv4.mroute_do_assert = (v) ? 1 : 0; 1281 mrt->mroute_do_assert = (v) ? 1 : 0;
1032 return 0; 1282 return 0;
1033 } 1283 }
1034#ifdef CONFIG_IP_PIMSM 1284#ifdef CONFIG_IP_PIMSM
@@ -1042,14 +1292,35 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
1042 1292
1043 rtnl_lock(); 1293 rtnl_lock();
1044 ret = 0; 1294 ret = 0;
1045 if (v != net->ipv4.mroute_do_pim) { 1295 if (v != mrt->mroute_do_pim) {
1046 net->ipv4.mroute_do_pim = v; 1296 mrt->mroute_do_pim = v;
1047 net->ipv4.mroute_do_assert = v; 1297 mrt->mroute_do_assert = v;
1048 } 1298 }
1049 rtnl_unlock(); 1299 rtnl_unlock();
1050 return ret; 1300 return ret;
1051 } 1301 }
1052#endif 1302#endif
1303#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
1304 case MRT_TABLE:
1305 {
1306 u32 v;
1307
1308 if (optlen != sizeof(u32))
1309 return -EINVAL;
1310 if (get_user(v, (u32 __user *)optval))
1311 return -EFAULT;
1312 if (sk == mrt->mroute_sk)
1313 return -EBUSY;
1314
1315 rtnl_lock();
1316 ret = 0;
1317 if (!ipmr_new_table(net, v))
1318 ret = -ENOMEM;
1319 raw_sk(sk)->ipmr_table = v;
1320 rtnl_unlock();
1321 return ret;
1322 }
1323#endif
1053 /* 1324 /*
1054 * Spurious command, or MRT_VERSION which you cannot 1325 * Spurious command, or MRT_VERSION which you cannot
1055 * set. 1326 * set.
@@ -1068,6 +1339,11 @@ int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int
1068 int olr; 1339 int olr;
1069 int val; 1340 int val;
1070 struct net *net = sock_net(sk); 1341 struct net *net = sock_net(sk);
1342 struct mr_table *mrt;
1343
1344 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1345 if (mrt == NULL)
1346 return -ENOENT;
1071 1347
1072 if (optname != MRT_VERSION && 1348 if (optname != MRT_VERSION &&
1073#ifdef CONFIG_IP_PIMSM 1349#ifdef CONFIG_IP_PIMSM
@@ -1089,10 +1365,10 @@ int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int
1089 val = 0x0305; 1365 val = 0x0305;
1090#ifdef CONFIG_IP_PIMSM 1366#ifdef CONFIG_IP_PIMSM
1091 else if (optname == MRT_PIM) 1367 else if (optname == MRT_PIM)
1092 val = net->ipv4.mroute_do_pim; 1368 val = mrt->mroute_do_pim;
1093#endif 1369#endif
1094 else 1370 else
1095 val = net->ipv4.mroute_do_assert; 1371 val = mrt->mroute_do_assert;
1096 if (copy_to_user(optval, &val, olr)) 1372 if (copy_to_user(optval, &val, olr))
1097 return -EFAULT; 1373 return -EFAULT;
1098 return 0; 1374 return 0;
@@ -1109,16 +1385,21 @@ int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1109 struct vif_device *vif; 1385 struct vif_device *vif;
1110 struct mfc_cache *c; 1386 struct mfc_cache *c;
1111 struct net *net = sock_net(sk); 1387 struct net *net = sock_net(sk);
1388 struct mr_table *mrt;
1389
1390 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1391 if (mrt == NULL)
1392 return -ENOENT;
1112 1393
1113 switch (cmd) { 1394 switch (cmd) {
1114 case SIOCGETVIFCNT: 1395 case SIOCGETVIFCNT:
1115 if (copy_from_user(&vr, arg, sizeof(vr))) 1396 if (copy_from_user(&vr, arg, sizeof(vr)))
1116 return -EFAULT; 1397 return -EFAULT;
1117 if (vr.vifi >= net->ipv4.maxvif) 1398 if (vr.vifi >= mrt->maxvif)
1118 return -EINVAL; 1399 return -EINVAL;
1119 read_lock(&mrt_lock); 1400 read_lock(&mrt_lock);
1120 vif = &net->ipv4.vif_table[vr.vifi]; 1401 vif = &mrt->vif_table[vr.vifi];
1121 if (VIF_EXISTS(net, vr.vifi)) { 1402 if (VIF_EXISTS(mrt, vr.vifi)) {
1122 vr.icount = vif->pkt_in; 1403 vr.icount = vif->pkt_in;
1123 vr.ocount = vif->pkt_out; 1404 vr.ocount = vif->pkt_out;
1124 vr.ibytes = vif->bytes_in; 1405 vr.ibytes = vif->bytes_in;
@@ -1136,7 +1417,7 @@ int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1136 return -EFAULT; 1417 return -EFAULT;
1137 1418
1138 read_lock(&mrt_lock); 1419 read_lock(&mrt_lock);
1139 c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr); 1420 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
1140 if (c) { 1421 if (c) {
1141 sr.pktcnt = c->mfc_un.res.pkt; 1422 sr.pktcnt = c->mfc_un.res.pkt;
1142 sr.bytecnt = c->mfc_un.res.bytes; 1423 sr.bytecnt = c->mfc_un.res.bytes;
@@ -1159,19 +1440,20 @@ static int ipmr_device_event(struct notifier_block *this, unsigned long event, v
1159{ 1440{
1160 struct net_device *dev = ptr; 1441 struct net_device *dev = ptr;
1161 struct net *net = dev_net(dev); 1442 struct net *net = dev_net(dev);
1443 struct mr_table *mrt;
1162 struct vif_device *v; 1444 struct vif_device *v;
1163 int ct; 1445 int ct;
1164 LIST_HEAD(list); 1446 LIST_HEAD(list);
1165 1447
1166 if (!net_eq(dev_net(dev), net))
1167 return NOTIFY_DONE;
1168
1169 if (event != NETDEV_UNREGISTER) 1448 if (event != NETDEV_UNREGISTER)
1170 return NOTIFY_DONE; 1449 return NOTIFY_DONE;
1171 v = &net->ipv4.vif_table[0]; 1450
1172 for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) { 1451 ipmr_for_each_table(mrt, net) {
1173 if (v->dev == dev) 1452 v = &mrt->vif_table[0];
1174 vif_delete(net, ct, 1, &list); 1453 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1454 if (v->dev == dev)
1455 vif_delete(mrt, ct, 1, &list);
1456 }
1175 } 1457 }
1176 unregister_netdevice_many(&list); 1458 unregister_netdevice_many(&list);
1177 return NOTIFY_DONE; 1459 return NOTIFY_DONE;
@@ -1230,11 +1512,11 @@ static inline int ipmr_forward_finish(struct sk_buff *skb)
1230 * Processing handlers for ipmr_forward 1512 * Processing handlers for ipmr_forward
1231 */ 1513 */
1232 1514
1233static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi) 1515static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
1516 struct sk_buff *skb, struct mfc_cache *c, int vifi)
1234{ 1517{
1235 struct net *net = mfc_net(c);
1236 const struct iphdr *iph = ip_hdr(skb); 1518 const struct iphdr *iph = ip_hdr(skb);
1237 struct vif_device *vif = &net->ipv4.vif_table[vifi]; 1519 struct vif_device *vif = &mrt->vif_table[vifi];
1238 struct net_device *dev; 1520 struct net_device *dev;
1239 struct rtable *rt; 1521 struct rtable *rt;
1240 int encap = 0; 1522 int encap = 0;
@@ -1248,7 +1530,7 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1248 vif->bytes_out += skb->len; 1530 vif->bytes_out += skb->len;
1249 vif->dev->stats.tx_bytes += skb->len; 1531 vif->dev->stats.tx_bytes += skb->len;
1250 vif->dev->stats.tx_packets++; 1532 vif->dev->stats.tx_packets++;
1251 ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT); 1533 ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
1252 goto out_free; 1534 goto out_free;
1253 } 1535 }
1254#endif 1536#endif
@@ -1273,9 +1555,9 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1273 goto out_free; 1555 goto out_free;
1274 } 1556 }
1275 1557
1276 dev = rt->u.dst.dev; 1558 dev = rt->dst.dev;
1277 1559
1278 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) { 1560 if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
1279 /* Do not fragment multicasts. Alas, IPv4 does not 1561 /* Do not fragment multicasts. Alas, IPv4 does not
1280 allow to send ICMP, so that packets will disappear 1562 allow to send ICMP, so that packets will disappear
1281 to blackhole. 1563 to blackhole.
@@ -1286,7 +1568,7 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1286 goto out_free; 1568 goto out_free;
1287 } 1569 }
1288 1570
1289 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len; 1571 encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
1290 1572
1291 if (skb_cow(skb, encap)) { 1573 if (skb_cow(skb, encap)) {
1292 ip_rt_put(rt); 1574 ip_rt_put(rt);
@@ -1297,7 +1579,7 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1297 vif->bytes_out += skb->len; 1579 vif->bytes_out += skb->len;
1298 1580
1299 skb_dst_drop(skb); 1581 skb_dst_drop(skb);
1300 skb_dst_set(skb, &rt->u.dst); 1582 skb_dst_set(skb, &rt->dst);
1301 ip_decrease_ttl(ip_hdr(skb)); 1583 ip_decrease_ttl(ip_hdr(skb));
1302 1584
1303 /* FIXME: forward and output firewalls used to be called here. 1585 /* FIXME: forward and output firewalls used to be called here.
@@ -1322,21 +1604,20 @@ static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1322 * not mrouter) cannot join to more than one interface - it will 1604 * not mrouter) cannot join to more than one interface - it will
1323 * result in receiving multiple packets. 1605 * result in receiving multiple packets.
1324 */ 1606 */
1325 NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev, 1607 NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
1326 ipmr_forward_finish); 1608 ipmr_forward_finish);
1327 return; 1609 return;
1328 1610
1329out_free: 1611out_free:
1330 kfree_skb(skb); 1612 kfree_skb(skb);
1331 return;
1332} 1613}
1333 1614
1334static int ipmr_find_vif(struct net_device *dev) 1615static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
1335{ 1616{
1336 struct net *net = dev_net(dev);
1337 int ct; 1617 int ct;
1338 for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) { 1618
1339 if (net->ipv4.vif_table[ct].dev == dev) 1619 for (ct = mrt->maxvif-1; ct >= 0; ct--) {
1620 if (mrt->vif_table[ct].dev == dev)
1340 break; 1621 break;
1341 } 1622 }
1342 return ct; 1623 return ct;
@@ -1344,11 +1625,12 @@ static int ipmr_find_vif(struct net_device *dev)
1344 1625
1345/* "local" means that we should preserve one skb (for local delivery) */ 1626/* "local" means that we should preserve one skb (for local delivery) */
1346 1627
1347static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local) 1628static int ip_mr_forward(struct net *net, struct mr_table *mrt,
1629 struct sk_buff *skb, struct mfc_cache *cache,
1630 int local)
1348{ 1631{
1349 int psend = -1; 1632 int psend = -1;
1350 int vif, ct; 1633 int vif, ct;
1351 struct net *net = mfc_net(cache);
1352 1634
1353 vif = cache->mfc_parent; 1635 vif = cache->mfc_parent;
1354 cache->mfc_un.res.pkt++; 1636 cache->mfc_un.res.pkt++;
@@ -1357,7 +1639,7 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
1357 /* 1639 /*
1358 * Wrong interface: drop packet and (maybe) send PIM assert. 1640 * Wrong interface: drop packet and (maybe) send PIM assert.
1359 */ 1641 */
1360 if (net->ipv4.vif_table[vif].dev != skb->dev) { 1642 if (mrt->vif_table[vif].dev != skb->dev) {
1361 int true_vifi; 1643 int true_vifi;
1362 1644
1363 if (skb_rtable(skb)->fl.iif == 0) { 1645 if (skb_rtable(skb)->fl.iif == 0) {
@@ -1376,26 +1658,26 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
1376 } 1658 }
1377 1659
1378 cache->mfc_un.res.wrong_if++; 1660 cache->mfc_un.res.wrong_if++;
1379 true_vifi = ipmr_find_vif(skb->dev); 1661 true_vifi = ipmr_find_vif(mrt, skb->dev);
1380 1662
1381 if (true_vifi >= 0 && net->ipv4.mroute_do_assert && 1663 if (true_vifi >= 0 && mrt->mroute_do_assert &&
1382 /* pimsm uses asserts, when switching from RPT to SPT, 1664 /* pimsm uses asserts, when switching from RPT to SPT,
1383 so that we cannot check that packet arrived on an oif. 1665 so that we cannot check that packet arrived on an oif.
1384 It is bad, but otherwise we would need to move pretty 1666 It is bad, but otherwise we would need to move pretty
1385 large chunk of pimd to kernel. Ough... --ANK 1667 large chunk of pimd to kernel. Ough... --ANK
1386 */ 1668 */
1387 (net->ipv4.mroute_do_pim || 1669 (mrt->mroute_do_pim ||
1388 cache->mfc_un.res.ttls[true_vifi] < 255) && 1670 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1389 time_after(jiffies, 1671 time_after(jiffies,
1390 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) { 1672 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1391 cache->mfc_un.res.last_assert = jiffies; 1673 cache->mfc_un.res.last_assert = jiffies;
1392 ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF); 1674 ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
1393 } 1675 }
1394 goto dont_forward; 1676 goto dont_forward;
1395 } 1677 }
1396 1678
1397 net->ipv4.vif_table[vif].pkt_in++; 1679 mrt->vif_table[vif].pkt_in++;
1398 net->ipv4.vif_table[vif].bytes_in += skb->len; 1680 mrt->vif_table[vif].bytes_in += skb->len;
1399 1681
1400 /* 1682 /*
1401 * Forward the frame 1683 * Forward the frame
@@ -1405,7 +1687,8 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
1405 if (psend != -1) { 1687 if (psend != -1) {
1406 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 1688 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1407 if (skb2) 1689 if (skb2)
1408 ipmr_queue_xmit(skb2, cache, psend); 1690 ipmr_queue_xmit(net, mrt, skb2, cache,
1691 psend);
1409 } 1692 }
1410 psend = ct; 1693 psend = ct;
1411 } 1694 }
@@ -1414,9 +1697,9 @@ static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local
1414 if (local) { 1697 if (local) {
1415 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 1698 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1416 if (skb2) 1699 if (skb2)
1417 ipmr_queue_xmit(skb2, cache, psend); 1700 ipmr_queue_xmit(net, mrt, skb2, cache, psend);
1418 } else { 1701 } else {
1419 ipmr_queue_xmit(skb, cache, psend); 1702 ipmr_queue_xmit(net, mrt, skb, cache, psend);
1420 return 0; 1703 return 0;
1421 } 1704 }
1422 } 1705 }
@@ -1437,6 +1720,8 @@ int ip_mr_input(struct sk_buff *skb)
1437 struct mfc_cache *cache; 1720 struct mfc_cache *cache;
1438 struct net *net = dev_net(skb->dev); 1721 struct net *net = dev_net(skb->dev);
1439 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL; 1722 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1723 struct mr_table *mrt;
1724 int err;
1440 1725
1441 /* Packet is looped back after forward, it should not be 1726 /* Packet is looped back after forward, it should not be
1442 forwarded second time, but still can be delivered locally. 1727 forwarded second time, but still can be delivered locally.
@@ -1444,6 +1729,12 @@ int ip_mr_input(struct sk_buff *skb)
1444 if (IPCB(skb)->flags&IPSKB_FORWARDED) 1729 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1445 goto dont_forward; 1730 goto dont_forward;
1446 1731
1732 err = ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt);
1733 if (err < 0) {
1734 kfree_skb(skb);
1735 return err;
1736 }
1737
1447 if (!local) { 1738 if (!local) {
1448 if (IPCB(skb)->opt.router_alert) { 1739 if (IPCB(skb)->opt.router_alert) {
1449 if (ip_call_ra_chain(skb)) 1740 if (ip_call_ra_chain(skb))
@@ -1456,9 +1747,9 @@ int ip_mr_input(struct sk_buff *skb)
1456 that we can forward NO IGMP messages. 1747 that we can forward NO IGMP messages.
1457 */ 1748 */
1458 read_lock(&mrt_lock); 1749 read_lock(&mrt_lock);
1459 if (net->ipv4.mroute_sk) { 1750 if (mrt->mroute_sk) {
1460 nf_reset(skb); 1751 nf_reset(skb);
1461 raw_rcv(net->ipv4.mroute_sk, skb); 1752 raw_rcv(mrt->mroute_sk, skb);
1462 read_unlock(&mrt_lock); 1753 read_unlock(&mrt_lock);
1463 return 0; 1754 return 0;
1464 } 1755 }
@@ -1467,7 +1758,7 @@ int ip_mr_input(struct sk_buff *skb)
1467 } 1758 }
1468 1759
1469 read_lock(&mrt_lock); 1760 read_lock(&mrt_lock);
1470 cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 1761 cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1471 1762
1472 /* 1763 /*
1473 * No usable cache entry 1764 * No usable cache entry
@@ -1485,19 +1776,19 @@ int ip_mr_input(struct sk_buff *skb)
1485 skb = skb2; 1776 skb = skb2;
1486 } 1777 }
1487 1778
1488 vif = ipmr_find_vif(skb->dev); 1779 vif = ipmr_find_vif(mrt, skb->dev);
1489 if (vif >= 0) { 1780 if (vif >= 0) {
1490 int err = ipmr_cache_unresolved(net, vif, skb); 1781 int err2 = ipmr_cache_unresolved(mrt, vif, skb);
1491 read_unlock(&mrt_lock); 1782 read_unlock(&mrt_lock);
1492 1783
1493 return err; 1784 return err2;
1494 } 1785 }
1495 read_unlock(&mrt_lock); 1786 read_unlock(&mrt_lock);
1496 kfree_skb(skb); 1787 kfree_skb(skb);
1497 return -ENODEV; 1788 return -ENODEV;
1498 } 1789 }
1499 1790
1500 ip_mr_forward(skb, cache, local); 1791 ip_mr_forward(net, mrt, skb, cache, local);
1501 1792
1502 read_unlock(&mrt_lock); 1793 read_unlock(&mrt_lock);
1503 1794
@@ -1514,11 +1805,11 @@ dont_forward:
1514} 1805}
1515 1806
1516#ifdef CONFIG_IP_PIMSM 1807#ifdef CONFIG_IP_PIMSM
1517static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen) 1808static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
1809 unsigned int pimlen)
1518{ 1810{
1519 struct net_device *reg_dev = NULL; 1811 struct net_device *reg_dev = NULL;
1520 struct iphdr *encap; 1812 struct iphdr *encap;
1521 struct net *net = dev_net(skb->dev);
1522 1813
1523 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen); 1814 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
1524 /* 1815 /*
@@ -1533,8 +1824,8 @@ static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
1533 return 1; 1824 return 1;
1534 1825
1535 read_lock(&mrt_lock); 1826 read_lock(&mrt_lock);
1536 if (net->ipv4.mroute_reg_vif_num >= 0) 1827 if (mrt->mroute_reg_vif_num >= 0)
1537 reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev; 1828 reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
1538 if (reg_dev) 1829 if (reg_dev)
1539 dev_hold(reg_dev); 1830 dev_hold(reg_dev);
1540 read_unlock(&mrt_lock); 1831 read_unlock(&mrt_lock);
@@ -1545,14 +1836,12 @@ static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
1545 skb->mac_header = skb->network_header; 1836 skb->mac_header = skb->network_header;
1546 skb_pull(skb, (u8*)encap - skb->data); 1837 skb_pull(skb, (u8*)encap - skb->data);
1547 skb_reset_network_header(skb); 1838 skb_reset_network_header(skb);
1548 skb->dev = reg_dev;
1549 skb->protocol = htons(ETH_P_IP); 1839 skb->protocol = htons(ETH_P_IP);
1550 skb->ip_summed = 0; 1840 skb->ip_summed = 0;
1551 skb->pkt_type = PACKET_HOST; 1841 skb->pkt_type = PACKET_HOST;
1552 skb_dst_drop(skb); 1842
1553 reg_dev->stats.rx_bytes += skb->len; 1843 skb_tunnel_rx(skb, reg_dev);
1554 reg_dev->stats.rx_packets++; 1844
1555 nf_reset(skb);
1556 netif_rx(skb); 1845 netif_rx(skb);
1557 dev_put(reg_dev); 1846 dev_put(reg_dev);
1558 1847
@@ -1569,17 +1858,21 @@ int pim_rcv_v1(struct sk_buff * skb)
1569{ 1858{
1570 struct igmphdr *pim; 1859 struct igmphdr *pim;
1571 struct net *net = dev_net(skb->dev); 1860 struct net *net = dev_net(skb->dev);
1861 struct mr_table *mrt;
1572 1862
1573 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 1863 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1574 goto drop; 1864 goto drop;
1575 1865
1576 pim = igmp_hdr(skb); 1866 pim = igmp_hdr(skb);
1577 1867
1578 if (!net->ipv4.mroute_do_pim || 1868 if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
1869 goto drop;
1870
1871 if (!mrt->mroute_do_pim ||
1579 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER) 1872 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1580 goto drop; 1873 goto drop;
1581 1874
1582 if (__pim_rcv(skb, sizeof(*pim))) { 1875 if (__pim_rcv(mrt, skb, sizeof(*pim))) {
1583drop: 1876drop:
1584 kfree_skb(skb); 1877 kfree_skb(skb);
1585 } 1878 }
@@ -1591,6 +1884,8 @@ drop:
1591static int pim_rcv(struct sk_buff * skb) 1884static int pim_rcv(struct sk_buff * skb)
1592{ 1885{
1593 struct pimreghdr *pim; 1886 struct pimreghdr *pim;
1887 struct net *net = dev_net(skb->dev);
1888 struct mr_table *mrt;
1594 1889
1595 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 1890 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1596 goto drop; 1891 goto drop;
@@ -1602,7 +1897,10 @@ static int pim_rcv(struct sk_buff * skb)
1602 csum_fold(skb_checksum(skb, 0, skb->len, 0)))) 1897 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1603 goto drop; 1898 goto drop;
1604 1899
1605 if (__pim_rcv(skb, sizeof(*pim))) { 1900 if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
1901 goto drop;
1902
1903 if (__pim_rcv(mrt, skb, sizeof(*pim))) {
1606drop: 1904drop:
1607 kfree_skb(skb); 1905 kfree_skb(skb);
1608 } 1906 }
@@ -1610,29 +1908,31 @@ drop:
1610} 1908}
1611#endif 1909#endif
1612 1910
1613static int 1911static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
1614ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm) 1912 struct mfc_cache *c, struct rtmsg *rtm)
1615{ 1913{
1616 int ct; 1914 int ct;
1617 struct rtnexthop *nhp; 1915 struct rtnexthop *nhp;
1618 struct net *net = mfc_net(c);
1619 struct net_device *dev = net->ipv4.vif_table[c->mfc_parent].dev;
1620 u8 *b = skb_tail_pointer(skb); 1916 u8 *b = skb_tail_pointer(skb);
1621 struct rtattr *mp_head; 1917 struct rtattr *mp_head;
1622 1918
1623 if (dev) 1919 /* If cache is unresolved, don't try to parse IIF and OIF */
1624 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex); 1920 if (c->mfc_parent >= MAXVIFS)
1921 return -ENOENT;
1922
1923 if (VIF_EXISTS(mrt, c->mfc_parent))
1924 RTA_PUT(skb, RTA_IIF, 4, &mrt->vif_table[c->mfc_parent].dev->ifindex);
1625 1925
1626 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0)); 1926 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1627 1927
1628 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 1928 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1629 if (c->mfc_un.res.ttls[ct] < 255) { 1929 if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
1630 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4)) 1930 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1631 goto rtattr_failure; 1931 goto rtattr_failure;
1632 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp))); 1932 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1633 nhp->rtnh_flags = 0; 1933 nhp->rtnh_flags = 0;
1634 nhp->rtnh_hops = c->mfc_un.res.ttls[ct]; 1934 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1635 nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex; 1935 nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
1636 nhp->rtnh_len = sizeof(*nhp); 1936 nhp->rtnh_len = sizeof(*nhp);
1637 } 1937 }
1638 } 1938 }
@@ -1650,11 +1950,16 @@ int ipmr_get_route(struct net *net,
1650 struct sk_buff *skb, struct rtmsg *rtm, int nowait) 1950 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1651{ 1951{
1652 int err; 1952 int err;
1953 struct mr_table *mrt;
1653 struct mfc_cache *cache; 1954 struct mfc_cache *cache;
1654 struct rtable *rt = skb_rtable(skb); 1955 struct rtable *rt = skb_rtable(skb);
1655 1956
1957 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
1958 if (mrt == NULL)
1959 return -ENOENT;
1960
1656 read_lock(&mrt_lock); 1961 read_lock(&mrt_lock);
1657 cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst); 1962 cache = ipmr_cache_find(mrt, rt->rt_src, rt->rt_dst);
1658 1963
1659 if (cache == NULL) { 1964 if (cache == NULL) {
1660 struct sk_buff *skb2; 1965 struct sk_buff *skb2;
@@ -1668,7 +1973,7 @@ int ipmr_get_route(struct net *net,
1668 } 1973 }
1669 1974
1670 dev = skb->dev; 1975 dev = skb->dev;
1671 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) { 1976 if (dev == NULL || (vif = ipmr_find_vif(mrt, dev)) < 0) {
1672 read_unlock(&mrt_lock); 1977 read_unlock(&mrt_lock);
1673 return -ENODEV; 1978 return -ENODEV;
1674 } 1979 }
@@ -1685,24 +1990,107 @@ int ipmr_get_route(struct net *net,
1685 iph->saddr = rt->rt_src; 1990 iph->saddr = rt->rt_src;
1686 iph->daddr = rt->rt_dst; 1991 iph->daddr = rt->rt_dst;
1687 iph->version = 0; 1992 iph->version = 0;
1688 err = ipmr_cache_unresolved(net, vif, skb2); 1993 err = ipmr_cache_unresolved(mrt, vif, skb2);
1689 read_unlock(&mrt_lock); 1994 read_unlock(&mrt_lock);
1690 return err; 1995 return err;
1691 } 1996 }
1692 1997
1693 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY)) 1998 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1694 cache->mfc_flags |= MFC_NOTIFY; 1999 cache->mfc_flags |= MFC_NOTIFY;
1695 err = ipmr_fill_mroute(skb, cache, rtm); 2000 err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
1696 read_unlock(&mrt_lock); 2001 read_unlock(&mrt_lock);
1697 return err; 2002 return err;
1698} 2003}
1699 2004
2005static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2006 u32 pid, u32 seq, struct mfc_cache *c)
2007{
2008 struct nlmsghdr *nlh;
2009 struct rtmsg *rtm;
2010
2011 nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
2012 if (nlh == NULL)
2013 return -EMSGSIZE;
2014
2015 rtm = nlmsg_data(nlh);
2016 rtm->rtm_family = RTNL_FAMILY_IPMR;
2017 rtm->rtm_dst_len = 32;
2018 rtm->rtm_src_len = 32;
2019 rtm->rtm_tos = 0;
2020 rtm->rtm_table = mrt->id;
2021 NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
2022 rtm->rtm_type = RTN_MULTICAST;
2023 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2024 rtm->rtm_protocol = RTPROT_UNSPEC;
2025 rtm->rtm_flags = 0;
2026
2027 NLA_PUT_BE32(skb, RTA_SRC, c->mfc_origin);
2028 NLA_PUT_BE32(skb, RTA_DST, c->mfc_mcastgrp);
2029
2030 if (__ipmr_fill_mroute(mrt, skb, c, rtm) < 0)
2031 goto nla_put_failure;
2032
2033 return nlmsg_end(skb, nlh);
2034
2035nla_put_failure:
2036 nlmsg_cancel(skb, nlh);
2037 return -EMSGSIZE;
2038}
2039
2040static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2041{
2042 struct net *net = sock_net(skb->sk);
2043 struct mr_table *mrt;
2044 struct mfc_cache *mfc;
2045 unsigned int t = 0, s_t;
2046 unsigned int h = 0, s_h;
2047 unsigned int e = 0, s_e;
2048
2049 s_t = cb->args[0];
2050 s_h = cb->args[1];
2051 s_e = cb->args[2];
2052
2053 read_lock(&mrt_lock);
2054 ipmr_for_each_table(mrt, net) {
2055 if (t < s_t)
2056 goto next_table;
2057 if (t > s_t)
2058 s_h = 0;
2059 for (h = s_h; h < MFC_LINES; h++) {
2060 list_for_each_entry(mfc, &mrt->mfc_cache_array[h], list) {
2061 if (e < s_e)
2062 goto next_entry;
2063 if (ipmr_fill_mroute(mrt, skb,
2064 NETLINK_CB(cb->skb).pid,
2065 cb->nlh->nlmsg_seq,
2066 mfc) < 0)
2067 goto done;
2068next_entry:
2069 e++;
2070 }
2071 e = s_e = 0;
2072 }
2073 s_h = 0;
2074next_table:
2075 t++;
2076 }
2077done:
2078 read_unlock(&mrt_lock);
2079
2080 cb->args[2] = e;
2081 cb->args[1] = h;
2082 cb->args[0] = t;
2083
2084 return skb->len;
2085}
2086
1700#ifdef CONFIG_PROC_FS 2087#ifdef CONFIG_PROC_FS
1701/* 2088/*
1702 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif 2089 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1703 */ 2090 */
1704struct ipmr_vif_iter { 2091struct ipmr_vif_iter {
1705 struct seq_net_private p; 2092 struct seq_net_private p;
2093 struct mr_table *mrt;
1706 int ct; 2094 int ct;
1707}; 2095};
1708 2096
@@ -1710,11 +2098,13 @@ static struct vif_device *ipmr_vif_seq_idx(struct net *net,
1710 struct ipmr_vif_iter *iter, 2098 struct ipmr_vif_iter *iter,
1711 loff_t pos) 2099 loff_t pos)
1712{ 2100{
1713 for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) { 2101 struct mr_table *mrt = iter->mrt;
1714 if (!VIF_EXISTS(net, iter->ct)) 2102
2103 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
2104 if (!VIF_EXISTS(mrt, iter->ct))
1715 continue; 2105 continue;
1716 if (pos-- == 0) 2106 if (pos-- == 0)
1717 return &net->ipv4.vif_table[iter->ct]; 2107 return &mrt->vif_table[iter->ct];
1718 } 2108 }
1719 return NULL; 2109 return NULL;
1720} 2110}
@@ -1722,7 +2112,15 @@ static struct vif_device *ipmr_vif_seq_idx(struct net *net,
1722static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos) 2112static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1723 __acquires(mrt_lock) 2113 __acquires(mrt_lock)
1724{ 2114{
2115 struct ipmr_vif_iter *iter = seq->private;
1725 struct net *net = seq_file_net(seq); 2116 struct net *net = seq_file_net(seq);
2117 struct mr_table *mrt;
2118
2119 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2120 if (mrt == NULL)
2121 return ERR_PTR(-ENOENT);
2122
2123 iter->mrt = mrt;
1726 2124
1727 read_lock(&mrt_lock); 2125 read_lock(&mrt_lock);
1728 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1) 2126 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
@@ -1733,15 +2131,16 @@ static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1733{ 2131{
1734 struct ipmr_vif_iter *iter = seq->private; 2132 struct ipmr_vif_iter *iter = seq->private;
1735 struct net *net = seq_file_net(seq); 2133 struct net *net = seq_file_net(seq);
2134 struct mr_table *mrt = iter->mrt;
1736 2135
1737 ++*pos; 2136 ++*pos;
1738 if (v == SEQ_START_TOKEN) 2137 if (v == SEQ_START_TOKEN)
1739 return ipmr_vif_seq_idx(net, iter, 0); 2138 return ipmr_vif_seq_idx(net, iter, 0);
1740 2139
1741 while (++iter->ct < net->ipv4.maxvif) { 2140 while (++iter->ct < mrt->maxvif) {
1742 if (!VIF_EXISTS(net, iter->ct)) 2141 if (!VIF_EXISTS(mrt, iter->ct))
1743 continue; 2142 continue;
1744 return &net->ipv4.vif_table[iter->ct]; 2143 return &mrt->vif_table[iter->ct];
1745 } 2144 }
1746 return NULL; 2145 return NULL;
1747} 2146}
@@ -1754,7 +2153,8 @@ static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1754 2153
1755static int ipmr_vif_seq_show(struct seq_file *seq, void *v) 2154static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1756{ 2155{
1757 struct net *net = seq_file_net(seq); 2156 struct ipmr_vif_iter *iter = seq->private;
2157 struct mr_table *mrt = iter->mrt;
1758 2158
1759 if (v == SEQ_START_TOKEN) { 2159 if (v == SEQ_START_TOKEN) {
1760 seq_puts(seq, 2160 seq_puts(seq,
@@ -1765,7 +2165,7 @@ static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1765 2165
1766 seq_printf(seq, 2166 seq_printf(seq,
1767 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 2167 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1768 vif - net->ipv4.vif_table, 2168 vif - mrt->vif_table,
1769 name, vif->bytes_in, vif->pkt_in, 2169 name, vif->bytes_in, vif->pkt_in,
1770 vif->bytes_out, vif->pkt_out, 2170 vif->bytes_out, vif->pkt_out,
1771 vif->flags, vif->local, vif->remote); 2171 vif->flags, vif->local, vif->remote);
@@ -1796,7 +2196,8 @@ static const struct file_operations ipmr_vif_fops = {
1796 2196
1797struct ipmr_mfc_iter { 2197struct ipmr_mfc_iter {
1798 struct seq_net_private p; 2198 struct seq_net_private p;
1799 struct mfc_cache **cache; 2199 struct mr_table *mrt;
2200 struct list_head *cache;
1800 int ct; 2201 int ct;
1801}; 2202};
1802 2203
@@ -1804,22 +2205,22 @@ struct ipmr_mfc_iter {
1804static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net, 2205static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
1805 struct ipmr_mfc_iter *it, loff_t pos) 2206 struct ipmr_mfc_iter *it, loff_t pos)
1806{ 2207{
2208 struct mr_table *mrt = it->mrt;
1807 struct mfc_cache *mfc; 2209 struct mfc_cache *mfc;
1808 2210
1809 it->cache = net->ipv4.mfc_cache_array;
1810 read_lock(&mrt_lock); 2211 read_lock(&mrt_lock);
1811 for (it->ct = 0; it->ct < MFC_LINES; it->ct++) 2212 for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
1812 for (mfc = net->ipv4.mfc_cache_array[it->ct]; 2213 it->cache = &mrt->mfc_cache_array[it->ct];
1813 mfc; mfc = mfc->next) 2214 list_for_each_entry(mfc, it->cache, list)
1814 if (pos-- == 0) 2215 if (pos-- == 0)
1815 return mfc; 2216 return mfc;
2217 }
1816 read_unlock(&mrt_lock); 2218 read_unlock(&mrt_lock);
1817 2219
1818 it->cache = &mfc_unres_queue;
1819 spin_lock_bh(&mfc_unres_lock); 2220 spin_lock_bh(&mfc_unres_lock);
1820 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next) 2221 it->cache = &mrt->mfc_unres_queue;
1821 if (net_eq(mfc_net(mfc), net) && 2222 list_for_each_entry(mfc, it->cache, list)
1822 pos-- == 0) 2223 if (pos-- == 0)
1823 return mfc; 2224 return mfc;
1824 spin_unlock_bh(&mfc_unres_lock); 2225 spin_unlock_bh(&mfc_unres_lock);
1825 2226
@@ -1832,7 +2233,13 @@ static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1832{ 2233{
1833 struct ipmr_mfc_iter *it = seq->private; 2234 struct ipmr_mfc_iter *it = seq->private;
1834 struct net *net = seq_file_net(seq); 2235 struct net *net = seq_file_net(seq);
2236 struct mr_table *mrt;
1835 2237
2238 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2239 if (mrt == NULL)
2240 return ERR_PTR(-ENOENT);
2241
2242 it->mrt = mrt;
1836 it->cache = NULL; 2243 it->cache = NULL;
1837 it->ct = 0; 2244 it->ct = 0;
1838 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1) 2245 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
@@ -1844,37 +2251,36 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1844 struct mfc_cache *mfc = v; 2251 struct mfc_cache *mfc = v;
1845 struct ipmr_mfc_iter *it = seq->private; 2252 struct ipmr_mfc_iter *it = seq->private;
1846 struct net *net = seq_file_net(seq); 2253 struct net *net = seq_file_net(seq);
2254 struct mr_table *mrt = it->mrt;
1847 2255
1848 ++*pos; 2256 ++*pos;
1849 2257
1850 if (v == SEQ_START_TOKEN) 2258 if (v == SEQ_START_TOKEN)
1851 return ipmr_mfc_seq_idx(net, seq->private, 0); 2259 return ipmr_mfc_seq_idx(net, seq->private, 0);
1852 2260
1853 if (mfc->next) 2261 if (mfc->list.next != it->cache)
1854 return mfc->next; 2262 return list_entry(mfc->list.next, struct mfc_cache, list);
1855 2263
1856 if (it->cache == &mfc_unres_queue) 2264 if (it->cache == &mrt->mfc_unres_queue)
1857 goto end_of_list; 2265 goto end_of_list;
1858 2266
1859 BUG_ON(it->cache != net->ipv4.mfc_cache_array); 2267 BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
1860 2268
1861 while (++it->ct < MFC_LINES) { 2269 while (++it->ct < MFC_LINES) {
1862 mfc = net->ipv4.mfc_cache_array[it->ct]; 2270 it->cache = &mrt->mfc_cache_array[it->ct];
1863 if (mfc) 2271 if (list_empty(it->cache))
1864 return mfc; 2272 continue;
2273 return list_first_entry(it->cache, struct mfc_cache, list);
1865 } 2274 }
1866 2275
1867 /* exhausted cache_array, show unresolved */ 2276 /* exhausted cache_array, show unresolved */
1868 read_unlock(&mrt_lock); 2277 read_unlock(&mrt_lock);
1869 it->cache = &mfc_unres_queue; 2278 it->cache = &mrt->mfc_unres_queue;
1870 it->ct = 0; 2279 it->ct = 0;
1871 2280
1872 spin_lock_bh(&mfc_unres_lock); 2281 spin_lock_bh(&mfc_unres_lock);
1873 mfc = mfc_unres_queue; 2282 if (!list_empty(it->cache))
1874 while (mfc && !net_eq(mfc_net(mfc), net)) 2283 return list_first_entry(it->cache, struct mfc_cache, list);
1875 mfc = mfc->next;
1876 if (mfc)
1877 return mfc;
1878 2284
1879 end_of_list: 2285 end_of_list:
1880 spin_unlock_bh(&mfc_unres_lock); 2286 spin_unlock_bh(&mfc_unres_lock);
@@ -1886,18 +2292,17 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1886static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v) 2292static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1887{ 2293{
1888 struct ipmr_mfc_iter *it = seq->private; 2294 struct ipmr_mfc_iter *it = seq->private;
1889 struct net *net = seq_file_net(seq); 2295 struct mr_table *mrt = it->mrt;
1890 2296
1891 if (it->cache == &mfc_unres_queue) 2297 if (it->cache == &mrt->mfc_unres_queue)
1892 spin_unlock_bh(&mfc_unres_lock); 2298 spin_unlock_bh(&mfc_unres_lock);
1893 else if (it->cache == net->ipv4.mfc_cache_array) 2299 else if (it->cache == &mrt->mfc_cache_array[it->ct])
1894 read_unlock(&mrt_lock); 2300 read_unlock(&mrt_lock);
1895} 2301}
1896 2302
1897static int ipmr_mfc_seq_show(struct seq_file *seq, void *v) 2303static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1898{ 2304{
1899 int n; 2305 int n;
1900 struct net *net = seq_file_net(seq);
1901 2306
1902 if (v == SEQ_START_TOKEN) { 2307 if (v == SEQ_START_TOKEN) {
1903 seq_puts(seq, 2308 seq_puts(seq,
@@ -1905,20 +2310,21 @@ static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1905 } else { 2310 } else {
1906 const struct mfc_cache *mfc = v; 2311 const struct mfc_cache *mfc = v;
1907 const struct ipmr_mfc_iter *it = seq->private; 2312 const struct ipmr_mfc_iter *it = seq->private;
2313 const struct mr_table *mrt = it->mrt;
1908 2314
1909 seq_printf(seq, "%08lX %08lX %-3hd", 2315 seq_printf(seq, "%08X %08X %-3hd",
1910 (unsigned long) mfc->mfc_mcastgrp, 2316 (__force u32) mfc->mfc_mcastgrp,
1911 (unsigned long) mfc->mfc_origin, 2317 (__force u32) mfc->mfc_origin,
1912 mfc->mfc_parent); 2318 mfc->mfc_parent);
1913 2319
1914 if (it->cache != &mfc_unres_queue) { 2320 if (it->cache != &mrt->mfc_unres_queue) {
1915 seq_printf(seq, " %8lu %8lu %8lu", 2321 seq_printf(seq, " %8lu %8lu %8lu",
1916 mfc->mfc_un.res.pkt, 2322 mfc->mfc_un.res.pkt,
1917 mfc->mfc_un.res.bytes, 2323 mfc->mfc_un.res.bytes,
1918 mfc->mfc_un.res.wrong_if); 2324 mfc->mfc_un.res.wrong_if);
1919 for (n = mfc->mfc_un.res.minvif; 2325 for (n = mfc->mfc_un.res.minvif;
1920 n < mfc->mfc_un.res.maxvif; n++ ) { 2326 n < mfc->mfc_un.res.maxvif; n++ ) {
1921 if (VIF_EXISTS(net, n) && 2327 if (VIF_EXISTS(mrt, n) &&
1922 mfc->mfc_un.res.ttls[n] < 255) 2328 mfc->mfc_un.res.ttls[n] < 255)
1923 seq_printf(seq, 2329 seq_printf(seq,
1924 " %2d:%-3d", 2330 " %2d:%-3d",
@@ -1970,27 +2376,11 @@ static const struct net_protocol pim_protocol = {
1970 */ 2376 */
1971static int __net_init ipmr_net_init(struct net *net) 2377static int __net_init ipmr_net_init(struct net *net)
1972{ 2378{
1973 int err = 0; 2379 int err;
1974 2380
1975 net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device), 2381 err = ipmr_rules_init(net);
1976 GFP_KERNEL); 2382 if (err < 0)
1977 if (!net->ipv4.vif_table) {
1978 err = -ENOMEM;
1979 goto fail; 2383 goto fail;
1980 }
1981
1982 /* Forwarding cache */
1983 net->ipv4.mfc_cache_array = kcalloc(MFC_LINES,
1984 sizeof(struct mfc_cache *),
1985 GFP_KERNEL);
1986 if (!net->ipv4.mfc_cache_array) {
1987 err = -ENOMEM;
1988 goto fail_mfc_cache;
1989 }
1990
1991#ifdef CONFIG_IP_PIMSM
1992 net->ipv4.mroute_reg_vif_num = -1;
1993#endif
1994 2384
1995#ifdef CONFIG_PROC_FS 2385#ifdef CONFIG_PROC_FS
1996 err = -ENOMEM; 2386 err = -ENOMEM;
@@ -2005,10 +2395,8 @@ static int __net_init ipmr_net_init(struct net *net)
2005proc_cache_fail: 2395proc_cache_fail:
2006 proc_net_remove(net, "ip_mr_vif"); 2396 proc_net_remove(net, "ip_mr_vif");
2007proc_vif_fail: 2397proc_vif_fail:
2008 kfree(net->ipv4.mfc_cache_array); 2398 ipmr_rules_exit(net);
2009#endif 2399#endif
2010fail_mfc_cache:
2011 kfree(net->ipv4.vif_table);
2012fail: 2400fail:
2013 return err; 2401 return err;
2014} 2402}
@@ -2019,8 +2407,7 @@ static void __net_exit ipmr_net_exit(struct net *net)
2019 proc_net_remove(net, "ip_mr_cache"); 2407 proc_net_remove(net, "ip_mr_cache");
2020 proc_net_remove(net, "ip_mr_vif"); 2408 proc_net_remove(net, "ip_mr_vif");
2021#endif 2409#endif
2022 kfree(net->ipv4.mfc_cache_array); 2410 ipmr_rules_exit(net);
2023 kfree(net->ipv4.vif_table);
2024} 2411}
2025 2412
2026static struct pernet_operations ipmr_net_ops = { 2413static struct pernet_operations ipmr_net_ops = {
@@ -2043,7 +2430,6 @@ int __init ip_mr_init(void)
2043 if (err) 2430 if (err)
2044 goto reg_pernet_fail; 2431 goto reg_pernet_fail;
2045 2432
2046 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
2047 err = register_netdevice_notifier(&ip_mr_notifier); 2433 err = register_netdevice_notifier(&ip_mr_notifier);
2048 if (err) 2434 if (err)
2049 goto reg_notif_fail; 2435 goto reg_notif_fail;
@@ -2054,6 +2440,7 @@ int __init ip_mr_init(void)
2054 goto add_proto_fail; 2440 goto add_proto_fail;
2055 } 2441 }
2056#endif 2442#endif
2443 rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE, NULL, ipmr_rtm_dumproute);
2057 return 0; 2444 return 0;
2058 2445
2059#ifdef CONFIG_IP_PIMSM_V2 2446#ifdef CONFIG_IP_PIMSM_V2
@@ -2061,7 +2448,6 @@ add_proto_fail:
2061 unregister_netdevice_notifier(&ip_mr_notifier); 2448 unregister_netdevice_notifier(&ip_mr_notifier);
2062#endif 2449#endif
2063reg_notif_fail: 2450reg_notif_fail:
2064 del_timer(&ipmr_expire_timer);
2065 unregister_pernet_subsys(&ipmr_net_ops); 2451 unregister_pernet_subsys(&ipmr_net_ops);
2066reg_pernet_fail: 2452reg_pernet_fail:
2067 kmem_cache_destroy(mrt_cachep); 2453 kmem_cache_destroy(mrt_cachep);
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-11 21:22:19 -0500