static struct kmem_cache *fib6_node_kmem __read_mostly;
 
-enum fib_walk_state_t {
-#ifdef CONFIG_IPV6_SUBTREES
-       FWS_S,
-#endif
-       FWS_L,
-       FWS_R,
-       FWS_C,
-       FWS_U
-};
-
-struct fib6_cleaner_t {
-       struct fib6_walker_t w;
+struct fib6_cleaner {
+       struct fib6_walker w;
        struct net *net;
        int (*func)(struct rt6_info *, void *arg);
        void *arg;
 static void fib6_prune_clones(struct net *net, struct fib6_node *fn);
 static struct rt6_info *fib6_find_prefix(struct net *net, struct fib6_node *fn);
 static struct fib6_node *fib6_repair_tree(struct net *net, struct fib6_node *fn);
-static int fib6_walk(struct fib6_walker_t *w);
-static int fib6_walk_continue(struct fib6_walker_t *w);
+static int fib6_walk(struct fib6_walker *w);
+static int fib6_walk_continue(struct fib6_walker *w);
 
 /*
  *     A routing update causes an increase of the serial number on the
 static LIST_HEAD(fib6_walkers);
 #define FOR_WALKERS(w) list_for_each_entry(w, &fib6_walkers, lh)
 
-static inline void fib6_walker_link(struct fib6_walker_t *w)
+static void fib6_walker_link(struct fib6_walker *w)
 {
        write_lock_bh(&fib6_walker_lock);
        list_add(&w->lh, &fib6_walkers);
        write_unlock_bh(&fib6_walker_lock);
 }
 
-static inline void fib6_walker_unlink(struct fib6_walker_t *w)
+static void fib6_walker_unlink(struct fib6_walker *w)
 {
        write_lock_bh(&fib6_walker_lock);
        list_del(&w->lh);
        write_unlock_bh(&fib6_walker_lock);
 }
-static __inline__ u32 fib6_new_sernum(void)
+
+static u32 fib6_new_sernum(void)
 {
        u32 n = ++rt_sernum;
        if ((__s32)n <= 0)
 # define BITOP_BE32_SWIZZLE    0
 #endif
 
-static __inline__ __be32 addr_bit_set(const void *token, int fn_bit)
+static __be32 addr_bit_set(const void *token, int fn_bit)
 {
        const __be32 *addr = token;
        /*
               addr[fn_bit >> 5];
 }
 
-static __inline__ struct fib6_node *node_alloc(void)
+static struct fib6_node *node_alloc(void)
 {
        struct fib6_node *fn;
 
        return fn;
 }
 
-static __inline__ void node_free(struct fib6_node *fn)
+static void node_free(struct fib6_node *fn)
 {
        kmem_cache_free(fib6_node_kmem, fn);
 }
 
-static __inline__ void rt6_release(struct rt6_info *rt)
+static void rt6_release(struct rt6_info *rt)
 {
        if (atomic_dec_and_test(&rt->rt6i_ref))
                dst_free(&rt->dst);
 
 #endif
 
-static int fib6_dump_node(struct fib6_walker_t *w)
+static int fib6_dump_node(struct fib6_walker *w)
 {
        int res;
        struct rt6_info *rt;
 
 static void fib6_dump_end(struct netlink_callback *cb)
 {
-       struct fib6_walker_t *w = (void *)cb->args[2];
+       struct fib6_walker *w = (void *)cb->args[2];
 
        if (w) {
                if (cb->args[4]) {
 static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb,
                           struct netlink_callback *cb)
 {
-       struct fib6_walker_t *w;
+       struct fib6_walker *w;
        int res;
 
        w = (void *)cb->args[2];
        unsigned int h, s_h;
        unsigned int e = 0, s_e;
        struct rt6_rtnl_dump_arg arg;
-       struct fib6_walker_t *w;
+       struct fib6_walker *w;
        struct fib6_table *tb;
        struct hlist_head *head;
        int res = 0;
        return ln;
 }
 
-static inline bool rt6_qualify_for_ecmp(struct rt6_info *rt)
+static bool rt6_qualify_for_ecmp(struct rt6_info *rt)
 {
        return (rt->rt6i_flags & (RTF_GATEWAY|RTF_ADDRCONF|RTF_DYNAMIC)) ==
               RTF_GATEWAY;
        return 0;
 }
 
-static __inline__ void fib6_start_gc(struct net *net, struct rt6_info *rt)
+static void fib6_start_gc(struct net *net, struct rt6_info *rt)
 {
        if (!timer_pending(&net->ipv6.ip6_fib_timer) &&
            (rt->rt6i_flags & (RTF_EXPIRES | RTF_CACHE)))
        int children;
        int nstate;
        struct fib6_node *child, *pn;
-       struct fib6_walker_t *w;
+       struct fib6_walker *w;
        int iter = 0;
 
        for (;;) {
 static void fib6_del_route(struct fib6_node *fn, struct rt6_info **rtp,
                           struct nl_info *info)
 {
-       struct fib6_walker_t *w;
+       struct fib6_walker *w;
        struct rt6_info *rt = *rtp;
        struct net *net = info->nl_net;
 
  *     <0  -> walk is terminated by an error.
  */
 
-static int fib6_walk_continue(struct fib6_walker_t *w)
+static int fib6_walk_continue(struct fib6_walker *w)
 {
        struct fib6_node *fn, *pn;
 
        }
 }
 
-static int fib6_walk(struct fib6_walker_t *w)
+static int fib6_walk(struct fib6_walker *w)
 {
        int res;
 
        return res;
 }
 
-static int fib6_clean_node(struct fib6_walker_t *w)
+static int fib6_clean_node(struct fib6_walker *w)
 {
        int res;
        struct rt6_info *rt;
-       struct fib6_cleaner_t *c = container_of(w, struct fib6_cleaner_t, w);
+       struct fib6_cleaner *c = container_of(w, struct fib6_cleaner, w);
        struct nl_info info = {
                .nl_net = c->net,
        };
 
 static void fib6_clean_tree(struct net *net, struct fib6_node *root,
                            int (*func)(struct rt6_info *, void *arg),
-                           int prune, void *arg)
+                           bool prune, void *arg)
 {
-       struct fib6_cleaner_t c;
+       struct fib6_cleaner c;
 
        c.w.root = root;
        c.w.func = fib6_clean_node;
                hlist_for_each_entry_rcu(table, head, tb6_hlist) {
                        write_lock_bh(&table->tb6_lock);
                        fib6_clean_tree(net, &table->tb6_root,
-                                       func, 0, arg);
+                                       func, false, arg);
                        write_unlock_bh(&table->tb6_lock);
                }
        }
 
 static void fib6_prune_clones(struct net *net, struct fib6_node *fn)
 {
-       fib6_clean_tree(net, fn, fib6_prune_clone, 1, NULL);
+       fib6_clean_tree(net, fn, fib6_prune_clone, true, NULL);
 }
 
 static int fib6_update_sernum(struct rt6_info *rt, void *arg)
 
 struct ipv6_route_iter {
        struct seq_net_private p;
-       struct fib6_walker_t w;
+       struct fib6_walker w;
        loff_t skip;
        struct fib6_table *tbl;
        __u32 sernum;
        return 0;
 }
 
-static int ipv6_route_yield(struct fib6_walker_t *w)
+static int ipv6_route_yield(struct fib6_walker *w)
 {
        struct ipv6_route_iter *iter = w->args;
 
 
 static bool ipv6_route_iter_active(struct ipv6_route_iter *iter)
 {
-       struct fib6_walker_t *w = &iter->w;
+       struct fib6_walker *w = &iter->w;
        return w->node && !(w->state == FWS_U && w->node == w->root);
 }