net-next: remove useless union keyword

[net-next-2.6.git] / net / decnet / dn_route.c

diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 812e6dff60675d5971b03d2d4b834ac530121e82..6585ea6d1182798ef399c61950e06044b5180027 100644 (file)
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -146,13 +146,13 @@ static __inline__ unsigned dn_hash(__le16 src, __le16 dst)
 
 static inline void dnrt_free(struct dn_route *rt)
 {
-       call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
+       call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
 }
 
 static inline void dnrt_drop(struct dn_route *rt)
 {
-       dst_release(&rt->u.dst);
-       call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
+       dst_release(&rt->dst);
+       call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
 }
 
 static void dn_dst_check_expire(unsigned long dummy)
@@ -167,13 +167,13 @@ static void dn_dst_check_expire(unsigned long dummy)
 
                spin_lock(&dn_rt_hash_table[i].lock);
                while((rt=*rtp) != NULL) {
-                       if (atomic_read(&rt->u.dst.__refcnt) ||
-                                       (now - rt->u.dst.lastuse) < expire) {
-                               rtp = &rt->u.dst.dn_next;
+                       if (atomic_read(&rt->dst.__refcnt) ||
+                                       (now - rt->dst.lastuse) < expire) {
+                               rtp = &rt->dst.dn_next;
                                continue;
                        }
-                       *rtp = rt->u.dst.dn_next;
-                       rt->u.dst.dn_next = NULL;
+                       *rtp = rt->dst.dn_next;
+                       rt->dst.dn_next = NULL;
                        dnrt_free(rt);
                }
                spin_unlock(&dn_rt_hash_table[i].lock);
@@ -198,13 +198,13 @@ static int dn_dst_gc(struct dst_ops *ops)
                rtp = &dn_rt_hash_table[i].chain;
 
                while((rt=*rtp) != NULL) {
-                       if (atomic_read(&rt->u.dst.__refcnt) ||
-                                       (now - rt->u.dst.lastuse) < expire) {
-                               rtp = &rt->u.dst.dn_next;
+                       if (atomic_read(&rt->dst.__refcnt) ||
+                                       (now - rt->dst.lastuse) < expire) {
+                               rtp = &rt->dst.dn_next;
                                continue;
                        }
-                       *rtp = rt->u.dst.dn_next;
-                       rt->u.dst.dn_next = NULL;
+                       *rtp = rt->dst.dn_next;
+                       rt->dst.dn_next = NULL;
                        dnrt_drop(rt);
                        break;
                }
@@ -287,25 +287,25 @@ static int dn_insert_route(struct dn_route *rt, unsigned hash, struct dn_route *
        while((rth = *rthp) != NULL) {
                if (compare_keys(&rth->fl, &rt->fl)) {
                        /* Put it first */
-                       *rthp = rth->u.dst.dn_next;
-                       rcu_assign_pointer(rth->u.dst.dn_next,
+                       *rthp = rth->dst.dn_next;
+                       rcu_assign_pointer(rth->dst.dn_next,
                                           dn_rt_hash_table[hash].chain);
                        rcu_assign_pointer(dn_rt_hash_table[hash].chain, rth);
 
-                       dst_use(&rth->u.dst, now);
+                       dst_use(&rth->dst, now);
                        spin_unlock_bh(&dn_rt_hash_table[hash].lock);
 
                        dnrt_drop(rt);
                        *rp = rth;
                        return 0;
                }
-               rthp = &rth->u.dst.dn_next;
+               rthp = &rth->dst.dn_next;
        }
 
-       rcu_assign_pointer(rt->u.dst.dn_next, dn_rt_hash_table[hash].chain);
+       rcu_assign_pointer(rt->dst.dn_next, dn_rt_hash_table[hash].chain);
        rcu_assign_pointer(dn_rt_hash_table[hash].chain, rt);
 
-       dst_use(&rt->u.dst, now);
+       dst_use(&rt->dst, now);
        spin_unlock_bh(&dn_rt_hash_table[hash].lock);
        *rp = rt;
        return 0;
@@ -323,8 +323,8 @@ static void dn_run_flush(unsigned long dummy)
                        goto nothing_to_declare;
 
                for(; rt; rt=next) {
-                       next = rt->u.dst.dn_next;
-                       rt->u.dst.dn_next = NULL;
+                       next = rt->dst.dn_next;
+                       rt->dst.dn_next = NULL;
                        dst_free((struct dst_entry *)rt);
                }
 
@@ -743,7 +743,7 @@ static int dn_forward(struct sk_buff *skb)
        /* Ensure that we have enough space for headers */
        rt = (struct dn_route *)skb_dst(skb);
        header_len = dn_db->use_long ? 21 : 6;
-       if (skb_cow(skb, LL_RESERVED_SPACE(rt->u.dst.dev)+header_len))
+       if (skb_cow(skb, LL_RESERVED_SPACE(rt->dst.dev)+header_len))
                goto drop;
 
        /*
@@ -752,7 +752,7 @@ static int dn_forward(struct sk_buff *skb)
        if (++cb->hops > 30)
                goto drop;
 
-       skb->dev = rt->u.dst.dev;
+       skb->dev = rt->dst.dev;
 
        /*
         * If packet goes out same interface it came in on, then set
@@ -792,7 +792,7 @@ static int dn_rt_bug(struct sk_buff *skb)
 static int dn_rt_set_next_hop(struct dn_route *rt, struct dn_fib_res *res)
 {
        struct dn_fib_info *fi = res->fi;
-       struct net_device *dev = rt->u.dst.dev;
+       struct net_device *dev = rt->dst.dev;
        struct neighbour *n;
        unsigned mss;
 
@@ -800,25 +800,25 @@ static int dn_rt_set_next_hop(struct dn_route *rt, struct dn_fib_res *res)
                if (DN_FIB_RES_GW(*res) &&
                    DN_FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
                        rt->rt_gateway = DN_FIB_RES_GW(*res);
-               memcpy(rt->u.dst.metrics, fi->fib_metrics,
-                      sizeof(rt->u.dst.metrics));
+               memcpy(rt->dst.metrics, fi->fib_metrics,
+                      sizeof(rt->dst.metrics));
        }
        rt->rt_type = res->type;
 
-       if (dev != NULL && rt->u.dst.neighbour == NULL) {
+       if (dev != NULL && rt->dst.neighbour == NULL) {
                n = __neigh_lookup_errno(&dn_neigh_table, &rt->rt_gateway, dev);
                if (IS_ERR(n))
                        return PTR_ERR(n);
-               rt->u.dst.neighbour = n;
+               rt->dst.neighbour = n;
        }
 
-       if (dst_metric(&rt->u.dst, RTAX_MTU) == 0 ||
-           dst_metric(&rt->u.dst, RTAX_MTU) > rt->u.dst.dev->mtu)
-               rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
-       mss = dn_mss_from_pmtu(dev, dst_mtu(&rt->u.dst));
-       if (dst_metric(&rt->u.dst, RTAX_ADVMSS) == 0 ||
-           dst_metric(&rt->u.dst, RTAX_ADVMSS) > mss)
-               rt->u.dst.metrics[RTAX_ADVMSS-1] = mss;
+       if (dst_metric(&rt->dst, RTAX_MTU) == 0 ||
+           dst_metric(&rt->dst, RTAX_MTU) > rt->dst.dev->mtu)
+               rt->dst.metrics[RTAX_MTU-1] = rt->dst.dev->mtu;
+       mss = dn_mss_from_pmtu(dev, dst_mtu(&rt->dst));
+       if (dst_metric(&rt->dst, RTAX_ADVMSS) == 0 ||
+           dst_metric(&rt->dst, RTAX_ADVMSS) > mss)
+               rt->dst.metrics[RTAX_ADVMSS-1] = mss;
        return 0;
 }
 
@@ -1096,8 +1096,8 @@ make_route:
        if (rt == NULL)
                goto e_nobufs;
 
-       atomic_set(&rt->u.dst.__refcnt, 1);
-       rt->u.dst.flags   = DST_HOST;
+       atomic_set(&rt->dst.__refcnt, 1);
+       rt->dst.flags   = DST_HOST;
 
        rt->fl.fld_src    = oldflp->fld_src;
        rt->fl.fld_dst    = oldflp->fld_dst;
@@ -1113,17 +1113,17 @@ make_route:
        rt->rt_dst_map    = fl.fld_dst;
        rt->rt_src_map    = fl.fld_src;
 
-       rt->u.dst.dev = dev_out;
+       rt->dst.dev = dev_out;
        dev_hold(dev_out);
-       rt->u.dst.neighbour = neigh;
+       rt->dst.neighbour = neigh;
        neigh = NULL;
 
-       rt->u.dst.lastuse = jiffies;
-       rt->u.dst.output  = dn_output;
-       rt->u.dst.input   = dn_rt_bug;
+       rt->dst.lastuse = jiffies;
+       rt->dst.output  = dn_output;
+       rt->dst.input   = dn_rt_bug;
        rt->rt_flags      = flags;
        if (flags & RTCF_LOCAL)
-               rt->u.dst.input = dn_nsp_rx;
+               rt->dst.input = dn_nsp_rx;
 
        err = dn_rt_set_next_hop(rt, &res);
        if (err)
@@ -1152,7 +1152,7 @@ e_nobufs:
        err = -ENOBUFS;
        goto done;
 e_neighbour:
-       dst_free(&rt->u.dst);
+       dst_free(&rt->dst);
        goto e_nobufs;
 }
 
@@ -1168,15 +1168,15 @@ static int __dn_route_output_key(struct dst_entry **pprt, const struct flowi *fl
        if (!(flags & MSG_TRYHARD)) {
                rcu_read_lock_bh();
                for (rt = rcu_dereference_bh(dn_rt_hash_table[hash].chain); rt;
-                       rt = rcu_dereference_bh(rt->u.dst.dn_next)) {
+                       rt = rcu_dereference_bh(rt->dst.dn_next)) {
                        if ((flp->fld_dst == rt->fl.fld_dst) &&
                            (flp->fld_src == rt->fl.fld_src) &&
                            (flp->mark == rt->fl.mark) &&
                            (rt->fl.iif == 0) &&
                            (rt->fl.oif == flp->oif)) {
-                               dst_use(&rt->u.dst, jiffies);
+                               dst_use(&rt->dst, jiffies);
                                rcu_read_unlock_bh();
-                               *pprt = &rt->u.dst;
+                               *pprt = &rt->dst;
                                return 0;
                        }
                }
@@ -1375,29 +1375,29 @@ make_route:
        rt->fl.iif        = in_dev->ifindex;
        rt->fl.mark       = fl.mark;
 
-       rt->u.dst.flags = DST_HOST;
-       rt->u.dst.neighbour = neigh;
-       rt->u.dst.dev = out_dev;
-       rt->u.dst.lastuse = jiffies;
-       rt->u.dst.output = dn_rt_bug;
+       rt->dst.flags = DST_HOST;
+       rt->dst.neighbour = neigh;
+       rt->dst.dev = out_dev;
+       rt->dst.lastuse = jiffies;
+       rt->dst.output = dn_rt_bug;
        switch(res.type) {
                case RTN_UNICAST:
-                       rt->u.dst.input = dn_forward;
+                       rt->dst.input = dn_forward;
                        break;
                case RTN_LOCAL:
-                       rt->u.dst.output = dn_output;
-                       rt->u.dst.input = dn_nsp_rx;
-                       rt->u.dst.dev = in_dev;
+                       rt->dst.output = dn_output;
+                       rt->dst.input = dn_nsp_rx;
+                       rt->dst.dev = in_dev;
                        flags |= RTCF_LOCAL;
                        break;
                default:
                case RTN_UNREACHABLE:
                case RTN_BLACKHOLE:
-                       rt->u.dst.input = dst_discard;
+                       rt->dst.input = dst_discard;
        }
        rt->rt_flags = flags;
-       if (rt->u.dst.dev)
-               dev_hold(rt->u.dst.dev);
+       if (rt->dst.dev)
+               dev_hold(rt->dst.dev);
 
        err = dn_rt_set_next_hop(rt, &res);
        if (err)
@@ -1405,7 +1405,7 @@ make_route:
 
        hash = dn_hash(rt->fl.fld_src, rt->fl.fld_dst);
        dn_insert_route(rt, hash, &rt);
-       skb_dst_set(skb, &rt->u.dst);
+       skb_dst_set(skb, &rt->dst);
 
 done:
        if (neigh)
@@ -1427,7 +1427,7 @@ e_nobufs:
        goto done;
 
 e_neighbour:
-       dst_free(&rt->u.dst);
+       dst_free(&rt->dst);
        goto done;
 }
 
@@ -1442,13 +1442,13 @@ static int dn_route_input(struct sk_buff *skb)
 
        rcu_read_lock();
        for(rt = rcu_dereference(dn_rt_hash_table[hash].chain); rt != NULL;
-           rt = rcu_dereference(rt->u.dst.dn_next)) {
+           rt = rcu_dereference(rt->dst.dn_next)) {
                if ((rt->fl.fld_src == cb->src) &&
                    (rt->fl.fld_dst == cb->dst) &&
                    (rt->fl.oif == 0) &&
                    (rt->fl.mark == skb->mark) &&
                    (rt->fl.iif == cb->iif)) {
-                       dst_use(&rt->u.dst, jiffies);
+                       dst_use(&rt->dst, jiffies);
                        rcu_read_unlock();
                        skb_dst_set(skb, (struct dst_entry *)rt);
                        return 0;
@@ -1487,8 +1487,8 @@ static int dn_rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
                r->rtm_src_len = 16;
                RTA_PUT(skb, RTA_SRC, 2, &rt->fl.fld_src);
        }
-       if (rt->u.dst.dev)
-               RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->u.dst.dev->ifindex);
+       if (rt->dst.dev)
+               RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->dst.dev->ifindex);
        /*
         * Note to self - change this if input routes reverse direction when
         * they deal only with inputs and not with replies like they do
@@ -1497,11 +1497,11 @@ static int dn_rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
        RTA_PUT(skb, RTA_PREFSRC, 2, &rt->rt_local_src);
        if (rt->rt_daddr != rt->rt_gateway)
                RTA_PUT(skb, RTA_GATEWAY, 2, &rt->rt_gateway);
-       if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
+       if (rtnetlink_put_metrics(skb, rt->dst.metrics) < 0)
                goto rtattr_failure;
-       expires = rt->u.dst.expires ? rt->u.dst.expires - jiffies : 0;
-       if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0, expires,
-                              rt->u.dst.error) < 0)
+       expires = rt->dst.expires ? rt->dst.expires - jiffies : 0;
+       if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0, expires,
+                              rt->dst.error) < 0)
                goto rtattr_failure;
        if (rt->fl.iif)
                RTA_PUT(skb, RTA_IIF, sizeof(int), &rt->fl.iif);
@@ -1568,8 +1568,8 @@ static int dn_cache_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void
                local_bh_enable();
                memset(cb, 0, sizeof(struct dn_skb_cb));
                rt = (struct dn_route *)skb_dst(skb);
-               if (!err && -rt->u.dst.error)
-                       err = rt->u.dst.error;
+               if (!err && -rt->dst.error)
+                       err = rt->dst.error;
        } else {
                int oif = 0;
                if (rta[RTA_OIF - 1])
@@ -1583,7 +1583,7 @@ static int dn_cache_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void
        skb->dev = NULL;
        if (err)
                goto out_free;
-       skb_dst_set(skb, &rt->u.dst);
+       skb_dst_set(skb, &rt->dst);
        if (rtm->rtm_flags & RTM_F_NOTIFY)
                rt->rt_flags |= RTCF_NOTIFY;
 
@@ -1632,10 +1632,10 @@ int dn_cache_dump(struct sk_buff *skb, struct netlink_callback *cb)
                rcu_read_lock_bh();
                for(rt = rcu_dereference_bh(dn_rt_hash_table[h].chain), idx = 0;
                        rt;
-                       rt = rcu_dereference_bh(rt->u.dst.dn_next), idx++) {
+                       rt = rcu_dereference_bh(rt->dst.dn_next), idx++) {
                        if (idx < s_idx)
                                continue;
-                       skb_dst_set(skb, dst_clone(&rt->u.dst));
+                       skb_dst_set(skb, dst_clone(&rt->dst));
                        if (dn_rt_fill_info(skb, NETLINK_CB(cb->skb).pid,
                                        cb->nlh->nlmsg_seq, RTM_NEWROUTE,
                                        1, NLM_F_MULTI) <= 0) {
@@ -1678,7 +1678,7 @@ static struct dn_route *dn_rt_cache_get_next(struct seq_file *seq, struct dn_rou
 {
        struct dn_rt_cache_iter_state *s = seq->private;
 
-       rt = rt->u.dst.dn_next;
+       rt = rt->dst.dn_next;
        while(!rt) {
                rcu_read_unlock_bh();
                if (--s->bucket < 0)
@@ -1719,12 +1719,12 @@ static int dn_rt_cache_seq_show(struct seq_file *seq, void *v)
        char buf1[DN_ASCBUF_LEN], buf2[DN_ASCBUF_LEN];
 
        seq_printf(seq, "%-8s %-7s %-7s %04d %04d %04d\n",
-                       rt->u.dst.dev ? rt->u.dst.dev->name : "*",
+                       rt->dst.dev ? rt->dst.dev->name : "*",
                        dn_addr2asc(le16_to_cpu(rt->rt_daddr), buf1),
                        dn_addr2asc(le16_to_cpu(rt->rt_saddr), buf2),
-                       atomic_read(&rt->u.dst.__refcnt),
-                       rt->u.dst.__use,
-                       (int) dst_metric(&rt->u.dst, RTAX_RTT));
+                       atomic_read(&rt->dst.__refcnt),
+                       rt->dst.__use,
+                       (int) dst_metric(&rt->dst, RTAX_RTT));
        return 0;
 }