mroute*: Make mr_table a common struct

Following previous changes to ip6mr, mr_table and mr6_table are
basically the same [up to mr6_table having additional '6' suffixes to
its variable names].
Move the common structure definition into a common header; This
requires renaming all references in ip6mr to variables that had the
distinct suffix.

Signed-off-by: Yuval Mintz <yuvalm@mellanox.com>
Acked-by: Nikolay Aleksandrov <nikolay@cumulusnetworks.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/mroute.h b/include/linux/mroute.h
index b8aadffe6237cc1540394595d060569a4f91f8db..8688c5d03a243f6d2116da1766b63717d96b8ca5 100644 (file)
--- a/include/linux/mroute.h
+++ b/include/linux/mroute.h
@@ -4,8 +4,6 @@
 
 #include <linux/in.h>
 #include <linux/pim.h>
-#include <linux/rhashtable.h>
-#include <net/sock.h>
 #include <net/fib_rules.h>
 #include <net/fib_notifier.h>
 #include <uapi/linux/mroute.h>
@@ -67,25 +65,6 @@ struct vif_entry_notifier_info {
 
 #define VIFF_STATIC 0x8000
 
-#define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
-
-struct mr_table {
-       struct list_head        list;
-       possible_net_t          net;
-       u32                     id;
-       struct sock __rcu       *mroute_sk;
-       struct timer_list       ipmr_expire_timer;
-       struct list_head        mfc_unres_queue;
-       struct vif_device       vif_table[MAXVIFS];
-       struct rhltable         mfc_hash;
-       struct list_head        mfc_cache_list;
-       int                     maxvif;
-       atomic_t                cache_resolve_queue_len;
-       bool                    mroute_do_assert;
-       bool                    mroute_do_pim;
-       int                     mroute_reg_vif_num;
-};
-
 /* mfc_flags:
  * MFC_STATIC - the entry was added statically (not by a routing daemon)
  * MFC_OFFLOAD - the entry was offloaded to the hardware

diff --git a/include/linux/mroute6.h b/include/linux/mroute6.h
index e2dac199861e354b069913fdbce1bde763da6c62..d5c8dc155a422eb22d183d87d3387a91d62a1fea 100644 (file)
--- a/include/linux/mroute6.h
+++ b/include/linux/mroute6.h
@@ -8,7 +8,6 @@
 #include <net/net_namespace.h>
 #include <uapi/linux/mroute6.h>
 #include <linux/mroute_base.h>
-#include <linux/rhashtable.h>
 
 #ifdef CONFIG_IPV6_MROUTE
 static inline int ip6_mroute_opt(int opt)

diff --git a/include/linux/mroute_base.h b/include/linux/mroute_base.h
index 0de651e15f27c1df14959c7758f2b5d13f71b682..1cc944a14df528370bf579bfb39e26af3f5a99fe 100644 (file)
--- a/include/linux/mroute_base.h
+++ b/include/linux/mroute_base.h
@@ -2,6 +2,9 @@
 #define __LINUX_MROUTE_BASE_H
 
 #include <linux/netdevice.h>
+#include <linux/rhashtable.h>
+#include <net/net_namespace.h>
+#include <net/sock.h>
 
 /**
  * struct vif_device - interface representor for multicast routing
@@ -32,6 +35,49 @@ struct vif_device {
        __be32 local, remote;
 };
 
+#ifndef MAXVIFS
+/* This one is nasty; value is defined in uapi using different symbols for
+ * mroute and morute6 but both map into same 32.
+ */
+#define MAXVIFS        32
+#endif
+
+#define VIF_EXISTS(_mrt, _idx) (!!((_mrt)->vif_table[_idx].dev))
+
+/**
+ * struct mr_table - a multicast routing table
+ * @list: entry within a list of multicast routing tables
+ * @net: net where this table belongs
+ * @id: identifier of the table
+ * @mroute_sk: socket associated with the table
+ * @ipmr_expire_timer: timer for handling unresolved routes
+ * @mfc_unres_queue: list of unresolved MFC entries
+ * @vif_table: array containing all possible vifs
+ * @mfc_hash: Hash table of all resolved routes for easy lookup
+ * @mfc_cache_list: list of resovled routes for possible traversal
+ * @maxvif: Identifier of highest value vif currently in use
+ * @cache_resolve_queue_len: current size of unresolved queue
+ * @mroute_do_assert: Whether to inform userspace on wrong ingress
+ * @mroute_do_pim: Whether to receive IGMP PIMv1
+ * @mroute_reg_vif_num: PIM-device vif index
+ */
+struct mr_table {
+       struct list_head        list;
+       possible_net_t          net;
+       u32                     id;
+       struct sock __rcu       *mroute_sk;
+       struct timer_list       ipmr_expire_timer;
+       struct list_head        mfc_unres_queue;
+       struct vif_device       vif_table[MAXVIFS];
+       struct rhltable         mfc_hash;
+       struct list_head        mfc_cache_list;
+       int                     maxvif;
+       atomic_t                cache_resolve_queue_len;
+       bool                    mroute_do_assert;
+       bool                    mroute_do_pim;
+       int                     mroute_reg_vif_num;
+};
+
 #ifdef CONFIG_IP_MROUTE_COMMON
 void vif_device_init(struct vif_device *v,
                     struct net_device *dev,

diff --git a/include/net/netns/ipv6.h b/include/net/netns/ipv6.h
index 2b9194229a56465f5de899118dca05392b753137..e286fda09fcfe7d466029cc4bdb793cfc6ab6029 100644 (file)
--- a/include/net/netns/ipv6.h
+++ b/include/net/netns/ipv6.h
@@ -85,7 +85,7 @@ struct netns_ipv6 {
        struct sock             *mc_autojoin_sk;
 #ifdef CONFIG_IPV6_MROUTE
 #ifndef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
-       struct mr6_table        *mrt6;
+       struct mr_table         *mrt6;
 #else
        struct list_head        mr6_tables;
        struct fib_rules_ops    *mr6_rules_ops;

diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index 1370edad64bfe7999f374c7e11e8d5d6e9eaab82..a1bf0020cad1ba7670e36187425caf87ac140b20 100644 (file)
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -31,7 +31,6 @@
 #include <linux/cache.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
-#include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/kernel.h>
 #include <linux/fcntl.h>
@@ -53,7 +52,6 @@
 #include <net/protocol.h>
 #include <linux/skbuff.h>
 #include <net/route.h>
-#include <net/sock.h>
 #include <net/icmp.h>
 #include <net/udp.h>
 #include <net/raw.h>

diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 6f0b7f4894b28743528b878190a8a6c0cebb946b..adbb826ca8fdc1a48ad3272753270df0ea41a170 100644 (file)
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -20,7 +20,6 @@
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
-#include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/kernel.h>
 #include <linux/fcntl.h>
@@ -36,7 +35,6 @@
 #include <linux/compat.h>
 #include <net/protocol.h>
 #include <linux/skbuff.h>
-#include <net/sock.h>
 #include <net/raw.h>
 #include <linux/notifier.h>
 #include <linux/if_arp.h>
@@ -54,31 +52,12 @@
 #include <net/ip6_checksum.h>
 #include <linux/netconf.h>
 
-struct mr6_table {
-       struct list_head        list;
-       possible_net_t          net;
-       u32                     id;
-       struct sock __rcu       *mroute6_sk;
-       struct timer_list       ipmr_expire_timer;
-       struct list_head        mfc6_unres_queue;
-       struct vif_device       vif6_table[MAXMIFS];
-       struct rhltable         mfc6_hash;
-       struct list_head        mfc6_cache_list;
-       int                     maxvif;
-       atomic_t                cache_resolve_queue_len;
-       bool                    mroute_do_assert;
-       bool                    mroute_do_pim;
-#ifdef CONFIG_IPV6_PIMSM_V2
-       int                     mroute_reg_vif_num;
-#endif
-};
-
 struct ip6mr_rule {
        struct fib_rule         common;
 };
 
 struct ip6mr_result {
-       struct mr6_table        *mrt;
+       struct mr_table *mrt;
 };
 
 /* Big lock, protecting vif table, mrt cache and mroute socket state.
@@ -87,11 +66,7 @@ struct ip6mr_result {
 
 static DEFINE_RWLOCK(mrt_lock);
 
-/*
- *     Multicast router control variables
- */
-
-#define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
+/* Multicast router control variables */
 
 /* Special spinlock for queue of unresolved entries */
 static DEFINE_SPINLOCK(mfc_unres_lock);
@@ -106,30 +81,30 @@ static DEFINE_SPINLOCK(mfc_unres_lock);
 
 static struct kmem_cache *mrt_cachep __read_mostly;
 
-static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
-static void ip6mr_free_table(struct mr6_table *mrt);
+static struct mr_table *ip6mr_new_table(struct net *net, u32 id);
+static void ip6mr_free_table(struct mr_table *mrt);
 
-static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
+static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
                           struct sk_buff *skb, struct mfc6_cache *cache);
-static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
+static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
                              mifi_t mifi, int assert);
-static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
+static int __ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
                               struct mfc6_cache *c, struct rtmsg *rtm);
-static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
+static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
                              int cmd);
-static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt);
+static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt);
 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
                               struct netlink_callback *cb);
-static void mroute_clean_tables(struct mr6_table *mrt, bool all);
+static void mroute_clean_tables(struct mr_table *mrt, bool all);
 static void ipmr_expire_process(struct timer_list *t);
 
 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
 #define ip6mr_for_each_table(mrt, net) \
        list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
 
-static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
+static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
 {
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        ip6mr_for_each_table(mrt, net) {
                if (mrt->id == id)
@@ -139,7 +114,7 @@ static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
 }
 
 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
-                           struct mr6_table **mrt)
+                           struct mr_table **mrt)
 {
        int err;
        struct ip6mr_result res;
@@ -160,7 +135,7 @@ static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
                             int flags, struct fib_lookup_arg *arg)
 {
        struct ip6mr_result *res = arg->result;
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        switch (rule->action) {
        case FR_ACT_TO_TBL:
@@ -228,7 +203,7 @@ static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
 static int __net_init ip6mr_rules_init(struct net *net)
 {
        struct fib_rules_ops *ops;
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        int err;
 
        ops = fib_rules_register(&ip6mr_rules_ops_template, net);
@@ -259,7 +234,7 @@ err1:
 
 static void __net_exit ip6mr_rules_exit(struct net *net)
 {
-       struct mr6_table *mrt, *next;
+       struct mr_table *mrt, *next;
 
        rtnl_lock();
        list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
@@ -273,13 +248,13 @@ static void __net_exit ip6mr_rules_exit(struct net *net)
 #define ip6mr_for_each_table(mrt, net) \
        for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
 
-static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
+static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
 {
        return net->ipv6.mrt6;
 }
 
 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
-                           struct mr6_table **mrt)
+                           struct mr_table **mrt)
 {
        *mrt = net->ipv6.mrt6;
        return 0;
@@ -320,9 +295,9 @@ static const struct rhashtable_params ip6mr_rht_params = {
        .automatic_shrinking = true,
 };
 
-static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
+static struct mr_table *ip6mr_new_table(struct net *net, u32 id)
 {
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        mrt = ip6mr_get_table(net, id);
        if (mrt)
@@ -334,9 +309,9 @@ static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
        mrt->id = id;
        write_pnet(&mrt->net, net);
 
-       rhltable_init(&mrt->mfc6_hash, &ip6mr_rht_params);
-       INIT_LIST_HEAD(&mrt->mfc6_cache_list);
-       INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
+       rhltable_init(&mrt->mfc_hash, &ip6mr_rht_params);
+       INIT_LIST_HEAD(&mrt->mfc_cache_list);
+       INIT_LIST_HEAD(&mrt->mfc_unres_queue);
 
        timer_setup(&mrt->ipmr_expire_timer, ipmr_expire_process, 0);
 
@@ -349,11 +324,11 @@ static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
        return mrt;
 }
 
-static void ip6mr_free_table(struct mr6_table *mrt)
+static void ip6mr_free_table(struct mr_table *mrt)
 {
        del_timer_sync(&mrt->ipmr_expire_timer);
        mroute_clean_tables(mrt, true);
-       rhltable_destroy(&mrt->mfc6_hash);
+       rhltable_destroy(&mrt->mfc_hash);
        kfree(mrt);
 }
 
@@ -361,7 +336,7 @@ static void ip6mr_free_table(struct mr6_table *mrt)
 
 struct ipmr_mfc_iter {
        struct seq_net_private p;
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct list_head *cache;
 };
 
@@ -369,18 +344,18 @@ struct ipmr_mfc_iter {
 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
                                           struct ipmr_mfc_iter *it, loff_t pos)
 {
-       struct mr6_table *mrt = it->mrt;
+       struct mr_table *mrt = it->mrt;
        struct mfc6_cache *mfc;
 
        rcu_read_lock();
-       it->cache = &mrt->mfc6_cache_list;
-       list_for_each_entry_rcu(mfc, &mrt->mfc6_cache_list, list)
+       it->cache = &mrt->mfc_cache_list;
+       list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list)
                if (pos-- == 0)
                        return mfc;
        rcu_read_unlock();
 
        spin_lock_bh(&mfc_unres_lock);
-       it->cache = &mrt->mfc6_unres_queue;
+       it->cache = &mrt->mfc_unres_queue;
        list_for_each_entry(mfc, it->cache, list)
                if (pos-- == 0)
                        return mfc;
@@ -396,7 +371,7 @@ static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
 
 struct ipmr_vif_iter {
        struct seq_net_private p;
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        int ct;
 };
 
@@ -404,13 +379,13 @@ static struct vif_device *ip6mr_vif_seq_idx(struct net *net,
                                            struct ipmr_vif_iter *iter,
                                            loff_t pos)
 {
-       struct mr6_table *mrt = iter->mrt;
+       struct mr_table *mrt = iter->mrt;
 
        for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
-               if (!MIF_EXISTS(mrt, iter->ct))
+               if (!VIF_EXISTS(mrt, iter->ct))
                        continue;
                if (pos-- == 0)
-                       return &mrt->vif6_table[iter->ct];
+                       return &mrt->vif_table[iter->ct];
        }
        return NULL;
 }
@@ -420,7 +395,7 @@ static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
 {
        struct ipmr_vif_iter *iter = seq->private;
        struct net *net = seq_file_net(seq);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
        if (!mrt)
@@ -437,16 +412,16 @@ static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
        struct ipmr_vif_iter *iter = seq->private;
        struct net *net = seq_file_net(seq);
-       struct mr6_table *mrt = iter->mrt;
+       struct mr_table *mrt = iter->mrt;
 
        ++*pos;
        if (v == SEQ_START_TOKEN)
                return ip6mr_vif_seq_idx(net, iter, 0);
 
        while (++iter->ct < mrt->maxvif) {
-               if (!MIF_EXISTS(mrt, iter->ct))
+               if (!VIF_EXISTS(mrt, iter->ct))
                        continue;
-               return &mrt->vif6_table[iter->ct];
+               return &mrt->vif_table[iter->ct];
        }
        return NULL;
 }
@@ -460,7 +435,7 @@ static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
 {
        struct ipmr_vif_iter *iter = seq->private;
-       struct mr6_table *mrt = iter->mrt;
+       struct mr_table *mrt = iter->mrt;
 
        if (v == SEQ_START_TOKEN) {
                seq_puts(seq,
@@ -471,7 +446,7 @@ static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
 
                seq_printf(seq,
                           "%2td %-10s %8ld %7ld  %8ld %7ld %05X\n",
-                          vif - mrt->vif6_table,
+                          vif - mrt->vif_table,
                           name, vif->bytes_in, vif->pkt_in,
                           vif->bytes_out, vif->pkt_out,
                           vif->flags);
@@ -503,7 +478,7 @@ static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
 {
        struct ipmr_mfc_iter *it = seq->private;
        struct net *net = seq_file_net(seq);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
        if (!mrt)
@@ -520,7 +495,7 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
        struct mfc6_cache *mfc = v;
        struct ipmr_mfc_iter *it = seq->private;
        struct net *net = seq_file_net(seq);
-       struct mr6_table *mrt = it->mrt;
+       struct mr_table *mrt = it->mrt;
 
        ++*pos;
 
@@ -530,12 +505,12 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
        if (mfc->list.next != it->cache)
                return list_entry(mfc->list.next, struct mfc6_cache, list);
 
-       if (it->cache == &mrt->mfc6_unres_queue)
+       if (it->cache == &mrt->mfc_unres_queue)
                goto end_of_list;
 
        /* exhausted cache_array, show unresolved */
        rcu_read_unlock();
-       it->cache = &mrt->mfc6_unres_queue;
+       it->cache = &mrt->mfc_unres_queue;
 
        spin_lock_bh(&mfc_unres_lock);
        if (!list_empty(it->cache))
@@ -551,11 +526,11 @@ static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
 {
        struct ipmr_mfc_iter *it = seq->private;
-       struct mr6_table *mrt = it->mrt;
+       struct mr_table *mrt = it->mrt;
 
-       if (it->cache == &mrt->mfc6_unres_queue)
+       if (it->cache == &mrt->mfc_unres_queue)
                spin_unlock_bh(&mfc_unres_lock);
-       else if (it->cache == &mrt->mfc6_cache_list)
+       else if (it->cache == &mrt->mfc_cache_list)
                rcu_read_unlock();
 }
 
@@ -571,20 +546,20 @@ static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
        } else {
                const struct mfc6_cache *mfc = v;
                const struct ipmr_mfc_iter *it = seq->private;
-               struct mr6_table *mrt = it->mrt;
+               struct mr_table *mrt = it->mrt;
 
                seq_printf(seq, "%pI6 %pI6 %-3hd",
                           &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
                           mfc->mf6c_parent);
 
-               if (it->cache != &mrt->mfc6_unres_queue) {
+               if (it->cache != &mrt->mfc_unres_queue) {
                        seq_printf(seq, " %8lu %8lu %8lu",
                                   mfc->mfc_un.res.pkt,
                                   mfc->mfc_un.res.bytes,
                                   mfc->mfc_un.res.wrong_if);
                        for (n = mfc->mfc_un.res.minvif;
                             n < mfc->mfc_un.res.maxvif; n++) {
-                               if (MIF_EXISTS(mrt, n) &&
+                               if (VIF_EXISTS(mrt, n) &&
                                    mfc->mfc_un.res.ttls[n] < 255)
                                        seq_printf(seq,
                                                   " %2d:%-3d",
@@ -630,7 +605,7 @@ static int pim6_rcv(struct sk_buff *skb)
        struct ipv6hdr   *encap;
        struct net_device  *reg_dev = NULL;
        struct net *net = dev_net(skb->dev);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct flowi6 fl6 = {
                .flowi6_iif     = skb->dev->ifindex,
                .flowi6_mark    = skb->mark,
@@ -664,7 +639,7 @@ static int pim6_rcv(struct sk_buff *skb)
 
        read_lock(&mrt_lock);
        if (reg_vif_num >= 0)
-               reg_dev = mrt->vif6_table[reg_vif_num].dev;
+               reg_dev = mrt->vif_table[reg_vif_num].dev;
        if (reg_dev)
                dev_hold(reg_dev);
        read_unlock(&mrt_lock);
@@ -699,7 +674,7 @@ static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
                                      struct net_device *dev)
 {
        struct net *net = dev_net(dev);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct flowi6 fl6 = {
                .flowi6_oif     = dev->ifindex,
                .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
@@ -742,7 +717,7 @@ static void reg_vif_setup(struct net_device *dev)
        dev->features           |= NETIF_F_NETNS_LOCAL;
 }
 
-static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
+static struct net_device *ip6mr_reg_vif(struct net *net, struct mr_table *mrt)
 {
        struct net_device *dev;
        char name[IFNAMSIZ];
@@ -779,7 +754,7 @@ failure:
  *     Delete a VIF entry
  */
 
-static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
+static int mif6_delete(struct mr_table *mrt, int vifi, int notify,
                       struct list_head *head)
 {
        struct vif_device *v;
@@ -789,7 +764,7 @@ static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
        if (vifi < 0 || vifi >= mrt->maxvif)
                return -EADDRNOTAVAIL;
 
-       v = &mrt->vif6_table[vifi];
+       v = &mrt->vif_table[vifi];
 
        write_lock_bh(&mrt_lock);
        dev = v->dev;
@@ -808,7 +783,7 @@ static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
        if (vifi + 1 == mrt->maxvif) {
                int tmp;
                for (tmp = vifi - 1; tmp >= 0; tmp--) {
-                       if (MIF_EXISTS(mrt, tmp))
+                       if (VIF_EXISTS(mrt, tmp))
                                break;
                }
                mrt->maxvif = tmp + 1;
@@ -849,7 +824,7 @@ static inline void ip6mr_cache_free(struct mfc6_cache *c)
    and reporting error to netlink readers.
  */
 
-static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
+static void ip6mr_destroy_unres(struct mr_table *mrt, struct mfc6_cache *c)
 {
        struct net *net = read_pnet(&mrt->net);
        struct sk_buff *skb;
@@ -875,13 +850,13 @@ static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
 
 /* Timer process for all the unresolved queue. */
 
-static void ipmr_do_expire_process(struct mr6_table *mrt)
+static void ipmr_do_expire_process(struct mr_table *mrt)
 {
        unsigned long now = jiffies;
        unsigned long expires = 10 * HZ;
        struct mfc6_cache *c, *next;
 
-       list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
+       list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
                if (time_after(c->mfc_un.unres.expires, now)) {
                        /* not yet... */
                        unsigned long interval = c->mfc_un.unres.expires - now;
@@ -895,20 +870,20 @@ static void ipmr_do_expire_process(struct mr6_table *mrt)
                ip6mr_destroy_unres(mrt, c);
        }
 
-       if (!list_empty(&mrt->mfc6_unres_queue))
+       if (!list_empty(&mrt->mfc_unres_queue))
                mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
 }
 
 static void ipmr_expire_process(struct timer_list *t)
 {
-       struct mr6_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
+       struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
 
        if (!spin_trylock(&mfc_unres_lock)) {
                mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
                return;
        }
 
-       if (!list_empty(&mrt->mfc6_unres_queue))
+       if (!list_empty(&mrt->mfc_unres_queue))
                ipmr_do_expire_process(mrt);
 
        spin_unlock(&mfc_unres_lock);
@@ -916,7 +891,8 @@ static void ipmr_expire_process(struct timer_list *t)
 
 /* Fill oifs list. It is called under write locked mrt_lock. */
 
-static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
+static void ip6mr_update_thresholds(struct mr_table *mrt,
+                                   struct mfc6_cache *cache,
                                    unsigned char *ttls)
 {
        int vifi;
@@ -926,7 +902,7 @@ static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *ca
        memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
 
        for (vifi = 0; vifi < mrt->maxvif; vifi++) {
-               if (MIF_EXISTS(mrt, vifi) &&
+               if (VIF_EXISTS(mrt, vifi) &&
                    ttls[vifi] && ttls[vifi] < 255) {
                        cache->mfc_un.res.ttls[vifi] = ttls[vifi];
                        if (cache->mfc_un.res.minvif > vifi)
@@ -938,17 +914,17 @@ static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *ca
        cache->mfc_un.res.lastuse = jiffies;
 }
 
-static int mif6_add(struct net *net, struct mr6_table *mrt,
+static int mif6_add(struct net *net, struct mr_table *mrt,
                    struct mif6ctl *vifc, int mrtsock)
 {
        int vifi = vifc->mif6c_mifi;
-       struct vif_device *v = &mrt->vif6_table[vifi];
+       struct vif_device *v = &mrt->vif_table[vifi];
        struct net_device *dev;
        struct inet6_dev *in6_dev;
        int err;
 
        /* Is vif busy ? */
-       if (MIF_EXISTS(mrt, vifi))
+       if (VIF_EXISTS(mrt, vifi))
                return -EADDRINUSE;
 
        switch (vifc->mif6c_flags) {
@@ -1011,7 +987,7 @@ static int mif6_add(struct net *net, struct mr6_table *mrt,
        return 0;
 }
 
-static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
+static struct mfc6_cache *ip6mr_cache_find(struct mr_table *mrt,
                                           const struct in6_addr *origin,
                                           const struct in6_addr *mcastgrp)
 {
@@ -1022,7 +998,7 @@ static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
        struct rhlist_head *tmp, *list;
        struct mfc6_cache *c;
 
-       list = rhltable_lookup(&mrt->mfc6_hash, &arg, ip6mr_rht_params);
+       list = rhltable_lookup(&mrt->mfc_hash, &arg, ip6mr_rht_params);
        rhl_for_each_entry_rcu(c, tmp, list, mnode)
                return c;
 
@@ -1030,7 +1006,7 @@ static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
 }
 
 /* Look for a (*,*,oif) entry */
-static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
+static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr_table *mrt,
                                                      mifi_t mifi)
 {
        struct mfc6_cache_cmp_arg arg = {
@@ -1040,7 +1016,7 @@ static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
        struct rhlist_head *tmp, *list;
        struct mfc6_cache *c;
 
-       list = rhltable_lookup(&mrt->mfc6_hash, &arg, ip6mr_rht_params);
+       list = rhltable_lookup(&mrt->mfc_hash, &arg, ip6mr_rht_params);
        rhl_for_each_entry_rcu(c, tmp, list, mnode)
                if (c->mfc_un.res.ttls[mifi] < 255)
                        return c;
@@ -1049,7 +1025,7 @@ static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
 }
 
 /* Look for a (*,G) entry */
-static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
+static struct mfc6_cache *ip6mr_cache_find_any(struct mr_table *mrt,
                                               struct in6_addr *mcastgrp,
                                               mifi_t mifi)
 {
@@ -1063,7 +1039,7 @@ static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
        if (ipv6_addr_any(mcastgrp))
                goto skip;
 
-       list = rhltable_lookup(&mrt->mfc6_hash, &arg, ip6mr_rht_params);
+       list = rhltable_lookup(&mrt->mfc_hash, &arg, ip6mr_rht_params);
        rhl_for_each_entry_rcu(c, tmp, list, mnode) {
                if (c->mfc_un.res.ttls[mifi] < 255)
                        return c;
@@ -1080,7 +1056,7 @@ skip:
 
 /* Look for a (S,G,iif) entry if parent != -1 */
 static struct mfc6_cache *
-ip6mr_cache_find_parent(struct mr6_table *mrt,
+ip6mr_cache_find_parent(struct mr_table *mrt,
                        const struct in6_addr *origin,
                        const struct in6_addr *mcastgrp,
                        int parent)
@@ -1092,7 +1068,7 @@ ip6mr_cache_find_parent(struct mr6_table *mrt,
        struct rhlist_head *tmp, *list;
        struct mfc6_cache *c;
 
-       list = rhltable_lookup(&mrt->mfc6_hash, &arg, ip6mr_rht_params);
+       list = rhltable_lookup(&mrt->mfc_hash, &arg, ip6mr_rht_params);
        rhl_for_each_entry_rcu(c, tmp, list, mnode)
                if (parent == -1 || parent == c->mf6c_parent)
                        return c;
@@ -1127,7 +1103,7 @@ static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
  *     A cache entry has gone into a resolved state from queued
  */
 
-static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
+static void ip6mr_cache_resolve(struct net *net, struct mr_table *mrt,
                                struct mfc6_cache *uc, struct mfc6_cache *c)
 {
        struct sk_buff *skb;
@@ -1161,7 +1137,7 @@ static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
  *     Called under mrt_lock.
  */
 
-static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
+static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
                              mifi_t mifi, int assert)
 {
        struct sock *mroute6_sk;
@@ -1235,7 +1211,7 @@ static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
        }
 
        rcu_read_lock();
-       mroute6_sk = rcu_dereference(mrt->mroute6_sk);
+       mroute6_sk = rcu_dereference(mrt->mroute_sk);
        if (!mroute6_sk) {
                rcu_read_unlock();
                kfree_skb(skb);
@@ -1260,14 +1236,14 @@ static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
  */
 
 static int
-ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
+ip6mr_cache_unresolved(struct mr_table *mrt, mifi_t mifi, struct sk_buff *skb)
 {
        bool found = false;
        int err;
        struct mfc6_cache *c;
 
        spin_lock_bh(&mfc_unres_lock);
-       list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
+       list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
                if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
                    ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
                        found = true;
@@ -1311,7 +1287,7 @@ ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
                }
 
                atomic_inc(&mrt->cache_resolve_queue_len);
-               list_add(&c->list, &mrt->mfc6_unres_queue);
+               list_add(&c->list, &mrt->mfc_unres_queue);
                mr6_netlink_event(mrt, c, RTM_NEWROUTE);
 
                ipmr_do_expire_process(mrt);
@@ -1336,7 +1312,7 @@ ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
  *     MFC6 cache manipulation by user space
  */
 
-static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
+static int ip6mr_mfc_delete(struct mr_table *mrt, struct mf6cctl *mfc,
                            int parent)
 {
        struct mfc6_cache *c;
@@ -1348,7 +1324,7 @@ static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
        rcu_read_unlock();
        if (!c)
                return -ENOENT;
-       rhltable_remove(&mrt->mfc6_hash, &c->mnode, ip6mr_rht_params);
+       rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
        list_del_rcu(&c->list);
 
        mr6_netlink_event(mrt, c, RTM_DELROUTE);
@@ -1361,7 +1337,7 @@ static int ip6mr_device_event(struct notifier_block *this,
 {
        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct vif_device *v;
        int ct;
 
@@ -1369,7 +1345,7 @@ static int ip6mr_device_event(struct notifier_block *this,
                return NOTIFY_DONE;
 
        ip6mr_for_each_table(mrt, net) {
-               v = &mrt->vif6_table[0];
+               v = &mrt->vif_table[0];
                for (ct = 0; ct < mrt->maxvif; ct++, v++) {
                        if (v->dev == dev)
                                mif6_delete(mrt, ct, 1, NULL);
@@ -1483,7 +1459,7 @@ void ip6_mr_cleanup(void)
        kmem_cache_destroy(mrt_cachep);
 }
 
-static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
+static int ip6mr_mfc_add(struct net *net, struct mr_table *mrt,
                         struct mf6cctl *mfc, int mrtsock, int parent)
 {
        unsigned char ttls[MAXMIFS];
@@ -1531,21 +1507,21 @@ static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
        if (!mrtsock)
                c->mfc_flags |= MFC_STATIC;
 
-       err = rhltable_insert_key(&mrt->mfc6_hash, &c->cmparg, &c->mnode,
+       err = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->mnode,
                                  ip6mr_rht_params);
        if (err) {
                pr_err("ip6mr: rhtable insert error %d\n", err);
                ip6mr_cache_free(c);
                return err;
        }
-       list_add_tail_rcu(&c->list, &mrt->mfc6_cache_list);
+       list_add_tail_rcu(&c->list, &mrt->mfc_cache_list);
 
        /* Check to see if we resolved a queued list. If so we
         * need to send on the frames and tidy up.
         */
        found = false;
        spin_lock_bh(&mfc_unres_lock);
-       list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
+       list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
                if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
                    ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
                        list_del(&uc->list);
@@ -1554,7 +1530,7 @@ static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
                        break;
                }
        }
-       if (list_empty(&mrt->mfc6_unres_queue))
+       if (list_empty(&mrt->mfc_unres_queue))
                del_timer(&mrt->ipmr_expire_timer);
        spin_unlock_bh(&mfc_unres_lock);
 
@@ -1570,7 +1546,7 @@ static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
  *     Close the multicast socket, and clear the vif tables etc
  */
 
-static void mroute_clean_tables(struct mr6_table *mrt, bool all)
+static void mroute_clean_tables(struct mr_table *mrt, bool all)
 {
        struct mfc6_cache *c, *tmp;
        LIST_HEAD(list);
@@ -1578,17 +1554,17 @@ static void mroute_clean_tables(struct mr6_table *mrt, bool all)
 
        /* Shut down all active vif entries */
        for (i = 0; i < mrt->maxvif; i++) {
-               if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
+               if (!all && (mrt->vif_table[i].flags & VIFF_STATIC))
                        continue;
                mif6_delete(mrt, i, 0, &list);
        }
        unregister_netdevice_many(&list);
 
        /* Wipe the cache */
-       list_for_each_entry_safe(c, tmp, &mrt->mfc6_cache_list, list) {
+       list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
                if (!all && (c->mfc_flags & MFC_STATIC))
                        continue;
-               rhltable_remove(&mrt->mfc6_hash, &c->mnode, ip6mr_rht_params);
+               rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
                list_del_rcu(&c->list);
                mr6_netlink_event(mrt, c, RTM_DELROUTE);
                ip6mr_cache_free(c);
@@ -1596,7 +1572,7 @@ static void mroute_clean_tables(struct mr6_table *mrt, bool all)
 
        if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
                spin_lock_bh(&mfc_unres_lock);
-               list_for_each_entry_safe(c, tmp, &mrt->mfc6_unres_queue, list) {
+               list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
                        list_del(&c->list);
                        mr6_netlink_event(mrt, c, RTM_DELROUTE);
                        ip6mr_destroy_unres(mrt, c);
@@ -1605,17 +1581,17 @@ static void mroute_clean_tables(struct mr6_table *mrt, bool all)
        }
 }
 
-static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
+static int ip6mr_sk_init(struct mr_table *mrt, struct sock *sk)
 {
        int err = 0;
        struct net *net = sock_net(sk);
 
        rtnl_lock();
        write_lock_bh(&mrt_lock);
-       if (rtnl_dereference(mrt->mroute6_sk)) {
+       if (rtnl_dereference(mrt->mroute_sk)) {
                err = -EADDRINUSE;
        } else {
-               rcu_assign_pointer(mrt->mroute6_sk, sk);
+               rcu_assign_pointer(mrt->mroute_sk, sk);
                net->ipv6.devconf_all->mc_forwarding++;
        }
        write_unlock_bh(&mrt_lock);
@@ -1634,7 +1610,7 @@ int ip6mr_sk_done(struct sock *sk)
 {
        int err = -EACCES;
        struct net *net = sock_net(sk);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        if (sk->sk_type != SOCK_RAW ||
            inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
@@ -1642,9 +1618,9 @@ int ip6mr_sk_done(struct sock *sk)
 
        rtnl_lock();
        ip6mr_for_each_table(mrt, net) {
-               if (sk == rtnl_dereference(mrt->mroute6_sk)) {
+               if (sk == rtnl_dereference(mrt->mroute_sk)) {
                        write_lock_bh(&mrt_lock);
-                       RCU_INIT_POINTER(mrt->mroute6_sk, NULL);
+                       RCU_INIT_POINTER(mrt->mroute_sk, NULL);
                        net->ipv6.devconf_all->mc_forwarding--;
                        write_unlock_bh(&mrt_lock);
                        inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
@@ -1665,7 +1641,7 @@ int ip6mr_sk_done(struct sock *sk)
 
 bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
 {
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct flowi6 fl6 = {
                .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
                .flowi6_oif     = skb->dev->ifindex,
@@ -1675,7 +1651,7 @@ bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
        if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
                return NULL;
 
-       return rcu_access_pointer(mrt->mroute6_sk);
+       return rcu_access_pointer(mrt->mroute_sk);
 }
 EXPORT_SYMBOL(mroute6_is_socket);
 
@@ -1693,7 +1669,7 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, uns
        struct mf6cctl mfc;
        mifi_t mifi;
        struct net *net = sock_net(sk);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        if (sk->sk_type != SOCK_RAW ||
            inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
@@ -1704,7 +1680,7 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, uns
                return -ENOENT;
 
        if (optname != MRT6_INIT) {
-               if (sk != rcu_access_pointer(mrt->mroute6_sk) &&
+               if (sk != rcu_access_pointer(mrt->mroute_sk) &&
                    !ns_capable(net->user_ns, CAP_NET_ADMIN))
                        return -EACCES;
        }
@@ -1728,7 +1704,7 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, uns
                        return -ENFILE;
                rtnl_lock();
                ret = mif6_add(net, mrt, &vif,
-                              sk == rtnl_dereference(mrt->mroute6_sk));
+                              sk == rtnl_dereference(mrt->mroute_sk));
                rtnl_unlock();
                return ret;
 
@@ -1764,7 +1740,7 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, uns
                else
                        ret = ip6mr_mfc_add(net, mrt, &mfc,
                                            sk ==
-                                           rtnl_dereference(mrt->mroute6_sk),
+                                           rtnl_dereference(mrt->mroute_sk),
                                            parent);
                rtnl_unlock();
                return ret;
@@ -1817,7 +1793,7 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, uns
                /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
                if (v != RT_TABLE_DEFAULT && v >= 100000000)
                        return -EINVAL;
-               if (sk == rcu_access_pointer(mrt->mroute6_sk))
+               if (sk == rcu_access_pointer(mrt->mroute_sk))
                        return -EBUSY;
 
                rtnl_lock();
@@ -1848,7 +1824,7 @@ int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
        int olr;
        int val;
        struct net *net = sock_net(sk);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        if (sk->sk_type != SOCK_RAW ||
            inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
@@ -1899,7 +1875,7 @@ int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
        struct vif_device *vif;
        struct mfc6_cache *c;
        struct net *net = sock_net(sk);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
        if (!mrt)
@@ -1912,8 +1888,8 @@ int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
                if (vr.mifi >= mrt->maxvif)
                        return -EINVAL;
                read_lock(&mrt_lock);
-               vif = &mrt->vif6_table[vr.mifi];
-               if (MIF_EXISTS(mrt, vr.mifi)) {
+               vif = &mrt->vif_table[vr.mifi];
+               if (VIF_EXISTS(mrt, vr.mifi)) {
                        vr.icount = vif->pkt_in;
                        vr.ocount = vif->pkt_out;
                        vr.ibytes = vif->bytes_in;
@@ -1973,7 +1949,7 @@ int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
        struct vif_device *vif;
        struct mfc6_cache *c;
        struct net *net = sock_net(sk);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
 
        mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
        if (!mrt)
@@ -1986,8 +1962,8 @@ int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
                if (vr.mifi >= mrt->maxvif)
                        return -EINVAL;
                read_lock(&mrt_lock);
-               vif = &mrt->vif6_table[vr.mifi];
-               if (MIF_EXISTS(mrt, vr.mifi)) {
+               vif = &mrt->vif_table[vr.mifi];
+               if (VIF_EXISTS(mrt, vr.mifi)) {
                        vr.icount = vif->pkt_in;
                        vr.ocount = vif->pkt_out;
                        vr.ibytes = vif->bytes_in;
@@ -2037,11 +2013,11 @@ static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct
  *     Processing handlers for ip6mr_forward
  */
 
-static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
+static int ip6mr_forward2(struct net *net, struct mr_table *mrt,
                          struct sk_buff *skb, struct mfc6_cache *c, int vifi)
 {
        struct ipv6hdr *ipv6h;
-       struct vif_device *vif = &mrt->vif6_table[vifi];
+       struct vif_device *vif = &mrt->vif_table[vifi];
        struct net_device *dev;
        struct dst_entry *dst;
        struct flowi6 fl6;
@@ -2111,18 +2087,18 @@ out_free:
        return 0;
 }
 
-static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
+static int ip6mr_find_vif(struct mr_table *mrt, struct net_device *dev)
 {
        int ct;
 
        for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
-               if (mrt->vif6_table[ct].dev == dev)
+               if (mrt->vif_table[ct].dev == dev)
                        break;
        }
        return ct;
 }
 
-static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
+static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
                           struct sk_buff *skb, struct mfc6_cache *cache)
 {
        int psend = -1;
@@ -2153,7 +2129,7 @@ static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
        /*
         * Wrong interface: drop packet and (maybe) send PIM assert.
         */
-       if (mrt->vif6_table[vif].dev != skb->dev) {
+       if (mrt->vif_table[vif].dev != skb->dev) {
                cache->mfc_un.res.wrong_if++;
 
                if (true_vifi >= 0 && mrt->mroute_do_assert &&
@@ -2173,8 +2149,8 @@ static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
        }
 
 forward:
-       mrt->vif6_table[vif].pkt_in++;
-       mrt->vif6_table[vif].bytes_in += skb->len;
+       mrt->vif_table[vif].pkt_in++;
+       mrt->vif_table[vif].bytes_in += skb->len;
 
        /*
         *      Forward the frame
@@ -2225,7 +2201,7 @@ int ip6_mr_input(struct sk_buff *skb)
 {
        struct mfc6_cache *cache;
        struct net *net = dev_net(skb->dev);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct flowi6 fl6 = {
                .flowi6_iif     = skb->dev->ifindex,
                .flowi6_mark    = skb->mark,
@@ -2276,7 +2252,7 @@ int ip6_mr_input(struct sk_buff *skb)
 }
 
 
-static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
+static int __ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
                               struct mfc6_cache *c, struct rtmsg *rtm)
 {
        struct rta_mfc_stats mfcs;
@@ -2291,15 +2267,16 @@ static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
                return -ENOENT;
        }
 
-       if (MIF_EXISTS(mrt, c->mf6c_parent) &&
-           nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
+       if (VIF_EXISTS(mrt, c->mf6c_parent) &&
+           nla_put_u32(skb, RTA_IIF,
+                       mrt->vif_table[c->mf6c_parent].dev->ifindex) < 0)
                return -EMSGSIZE;
        mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
        if (!mp_attr)
                return -EMSGSIZE;
 
        for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
-               if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
+               if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
                        nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
                        if (!nhp) {
                                nla_nest_cancel(skb, mp_attr);
@@ -2308,7 +2285,7 @@ static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
 
                        nhp->rtnh_flags = 0;
                        nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
-                       nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
+                       nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
                        nhp->rtnh_len = sizeof(*nhp);
                }
        }
@@ -2334,7 +2311,7 @@ int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
                    u32 portid)
 {
        int err;
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct mfc6_cache *cache;
        struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
 
@@ -2403,7 +2380,7 @@ int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
        return err;
 }
 
-static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
+static int ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
                             u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
                             int flags)
 {
@@ -2468,7 +2445,7 @@ static int mr6_msgsize(bool unresolved, int maxvif)
        return len;
 }
 
-static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
+static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
                              int cmd)
 {
        struct net *net = read_pnet(&mrt->net);
@@ -2510,7 +2487,7 @@ static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
        return len;
 }
 
-static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt)
+static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt)
 {
        struct net *net = read_pnet(&mrt->net);
        struct nlmsghdr *nlh;
@@ -2561,7 +2538,7 @@ errout:
 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
 {
        struct net *net = sock_net(skb->sk);
-       struct mr6_table *mrt;
+       struct mr_table *mrt;
        struct mfc6_cache *mfc;
        unsigned int t = 0, s_t;
        unsigned int e = 0, s_e;
@@ -2573,7 +2550,7 @@ static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
        ip6mr_for_each_table(mrt, net) {
                if (t < s_t)
                        goto next_table;
-               list_for_each_entry_rcu(mfc, &mrt->mfc6_cache_list, list) {
+               list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) {
                        if (e < s_e)
                                goto next_entry;
                        if (ip6mr_fill_mroute(mrt, skb,
@@ -2589,7 +2566,7 @@ next_entry:
                s_e = 0;
 
                spin_lock_bh(&mfc_unres_lock);
-               list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
+               list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
                        if (e < s_e)
                                goto next_entry2;
                        if (ip6mr_fill_mroute(mrt, skb,