u32));
 static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
 {
-       if (dst->obsolete)
+       if (READ_ONCE(dst->obsolete))
                dst = INDIRECT_CALL_INET(dst->ops->check, ip6_dst_check,
                                         ipv4_dst_check, dst, cookie);
        return dst;
 
 {
        struct net_device *dev = dst->dev;
 
-       dst->obsolete = DST_OBSOLETE_DEAD;
+       WRITE_ONCE(dst->obsolete, DST_OBSOLETE_DEAD);
        if (dst->ops->ifdown)
                dst->ops->ifdown(dst, dev);
        dst->input = dst_discard;
 
 
        if (unlikely(!time_after(idst->refresh_ts,
                                 READ_ONCE(dst_cache->reset_ts)) ||
-                    (dst->obsolete && !dst->ops->check(dst, idst->cookie)))) {
+                    (READ_ONCE(dst->obsolete) && !dst->ops->check(dst, idst->cookie)))) {
                dst_cache_per_cpu_dst_set(idst, NULL, 0);
                dst_release(dst);
                goto fail;
 
                         * we can reinject the packet there.
                         */
                        n2 = NULL;
-                       if (dst && dst->obsolete != DST_OBSOLETE_DEAD) {
+                       if (dst &&
+                           READ_ONCE(dst->obsolete) != DST_OBSOLETE_DEAD) {
                                n2 = dst_neigh_lookup_skb(dst, skb);
                                if (n2)
                                        n1 = n2;
 
 {
        struct dst_entry *dst = __sk_dst_get(sk);
 
-       if (dst && dst->obsolete &&
+       if (dst && READ_ONCE(dst->obsolete) &&
            INDIRECT_CALL_INET(dst->ops->check, ip6_dst_check, ipv4_dst_check,
                               dst, cookie) == NULL) {
                sk_tx_queue_clear(sk);
 {
        struct dst_entry *dst = sk_dst_get(sk);
 
-       if (dst && dst->obsolete &&
+       if (dst && READ_ONCE(dst->obsolete) &&
            INDIRECT_CALL_INET(dst->ops->check, ip6_dst_check, ipv4_dst_check,
                               dst, cookie) == NULL) {
                sk_dst_reset(sk);
 
        rcu_read_lock();
 
        dst = __sk_dst_get(sk);
-       if (!dst || !dst->obsolete || dst->ops->check(dst, 0)) {
+       if (!dst || !READ_ONCE(dst->obsolete) || dst->ops->check(dst, 0)) {
                rcu_read_unlock();
                return;
        }
 
                 */
                rt = rcu_dereference(nhc->nhc_rth_input);
                if (rt)
-                       rt->dst.obsolete = DST_OBSOLETE_KILL;
+                       WRITE_ONCE(rt->dst.obsolete, DST_OBSOLETE_KILL);
 
                for_each_possible_cpu(i) {
                        struct rtable __rcu **prt;
                        prt = per_cpu_ptr(nhc->nhc_pcpu_rth_output, i);
                        rt = rcu_dereference(*prt);
                        if (rt)
-                               rt->dst.obsolete = DST_OBSOLETE_KILL;
+                               WRITE_ONCE(rt->dst.obsolete, DST_OBSOLETE_KILL);
                }
        }
 
                                                jiffies + ip_rt_gc_timeout);
                        }
                        if (kill_route)
-                               rt->dst.obsolete = DST_OBSOLETE_KILL;
+                               WRITE_ONCE(rt->dst.obsolete, DST_OBSOLETE_KILL);
                        call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
                }
                neigh_release(n);
 {
        struct rtable *rt = dst_rtable(dst);
 
-       if ((dst->obsolete > 0) ||
+       if ((READ_ONCE(dst->obsolete) > 0) ||
            (rt->rt_flags & RTCF_REDIRECTED) ||
            rt->dst.expires)
                sk_dst_reset(sk);
        __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
 
        rt = dst_rtable(odst);
-       if (odst->obsolete && !odst->ops->check(odst, 0)) {
+       if (READ_ONCE(odst->obsolete) && !odst->ops->check(odst, 0)) {
                rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
                if (IS_ERR(rt))
                        goto out;
         * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
         * DST_OBSOLETE_DEAD.
         */
-       if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
+       if (READ_ONCE(dst->obsolete) != DST_OBSOLETE_FORCE_CHK ||
+           rt_is_expired(rt))
                return NULL;
        return dst;
 }
 static bool rt_cache_valid(const struct rtable *rt)
 {
        return  rt &&
-               rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
+               READ_ONCE(rt->dst.obsolete) == DST_OBSOLETE_FORCE_CHK &&
                !rt_is_expired(rt);
 }
 
 
 
        rcu_read_lock();
        dst = __sk_dst_get(sk);
-       if (!dst || !dst->obsolete ||
+       if (!dst || !READ_ONCE(dst->obsolete) ||
            dst->ops->check(dst, inet6_sk(sk)->dst_cookie)) {
                rcu_read_unlock();
                return;
 
                if (time_after(jiffies, rt->dst.expires))
                        return true;
        } else if (from) {
-               return rt->dst.obsolete != DST_OBSOLETE_FORCE_CHK ||
+               return READ_ONCE(rt->dst.obsolete) != DST_OBSOLETE_FORCE_CHK ||
                        fib6_check_expired(from);
        }
        return false;
                                            u32 cookie)
 {
        if (!__rt6_check_expired(rt) &&
-           rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
+           READ_ONCE(rt->dst.obsolete) == DST_OBSOLETE_FORCE_CHK &&
            fib6_check(from, cookie))
                return &rt->dst;
-       else
-               return NULL;
+       return NULL;
 }
 
 INDIRECT_CALLABLE_SCOPE struct dst_entry *ip6_dst_check(struct dst_entry *dst,
                        sk_uid(sk));
 
        dst = __sk_dst_get(sk);
-       if (!dst || !dst->obsolete ||
+       if (!dst || !READ_ONCE(dst->obsolete) ||
            dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
                return;
 
 
        if (!dest_dst)
                return NULL;
        dst = dest_dst->dst_cache;
-       if (dst->obsolete &&
+       if (READ_ONCE(dst->obsolete) &&
            dst->ops->check(dst, dest_dst->dst_cookie) == NULL)
                return NULL;
        return dest_dst;
 
 void sctp_transport_pmtu(struct sctp_transport *transport, struct sock *sk)
 {
        /* If we don't have a fresh route, look one up */
-       if (!transport->dst || transport->dst->obsolete) {
+       if (!transport->dst || READ_ONCE(transport->dst->obsolete)) {
                sctp_transport_dst_release(transport);
                transport->af_specific->get_dst(transport, &transport->saddr,
                                                &transport->fl, sk);
 
         * This will force stale_bundle() to fail on any xdst bundle with
         * this dst linked in it.
         */
-       if (dst->obsolete < 0 && !stale_bundle(dst))
+       if (READ_ONCE(dst->obsolete) < 0 && !stale_bundle(dst))
                return dst;
 
        return NULL;
 
 static void xfrm_negative_advice(struct sock *sk, struct dst_entry *dst)
 {
-       if (dst->obsolete)
+       if (READ_ONCE(dst->obsolete))
                sk_dst_reset(sk);
 }