Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

The UDP offload conflict is dealt with by simply taking what is
in net-next where we have removed all of the UFO handling code
entirely.

The TCP conflict was a case of local variables in a function
being removed from both net and net-next.

In netvsc we had an assignment right next to where a missing
set of u64 stats sync object inits were added.

Signed-off-by: David S. Miller <davem@davemloft.net>

11 files changed, 112 insertions, 65 deletions

diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index e1133bc634b5..8a3ce79b1307 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -1549,9 +1549,41 @@ batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
         return found;
 }
 
+/**
+ * batadv_tt_global_sync_flags - update TT sync flags
+ * @tt_global: the TT global entry to update sync flags in
+ *
+ * Updates the sync flag bits in the tt_global flag attribute with a logical
+ * OR of all sync flags from any of its TT orig entries.
+ */
+static void
+batadv_tt_global_sync_flags(struct batadv_tt_global_entry *tt_global)
+{
+        struct batadv_tt_orig_list_entry *orig_entry;
+        const struct hlist_head *head;
+        u16 flags = BATADV_NO_FLAGS;
+
+        rcu_read_lock();
+        head = &tt_global->orig_list;
+        hlist_for_each_entry_rcu(orig_entry, head, list)
+                flags |= orig_entry->flags;
+        rcu_read_unlock();
+
+        flags |= tt_global->common.flags & (~BATADV_TT_SYNC_MASK);
+        tt_global->common.flags = flags;
+}
+
+/**
+ * batadv_tt_global_orig_entry_add - add or update a TT orig entry
+ * @tt_global: the TT global entry to add an orig entry in
+ * @orig_node: the originator to add an orig entry for
+ * @ttvn: translation table version number of this changeset
+ * @flags: TT sync flags
+ */
 static void
 batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
-                                struct batadv_orig_node *orig_node, int ttvn)
+                                struct batadv_orig_node *orig_node, int ttvn,
+                                u8 flags)
 {
         struct batadv_tt_orig_list_entry *orig_entry;
 
@@ -1561,7 +1593,8 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
                  * was added during a "temporary client detection"
                  */
                 orig_entry->ttvn = ttvn;
-                goto out;
+                orig_entry->flags = flags;
+                goto sync_flags;
         }
 
         orig_entry = kmem_cache_zalloc(batadv_tt_orig_cache, GFP_ATOMIC);
@@ -1573,6 +1606,7 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
         batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
         orig_entry->orig_node = orig_node;
         orig_entry->ttvn = ttvn;
+        orig_entry->flags = flags;
         kref_init(&orig_entry->refcount);
 
         spin_lock_bh(&tt_global->list_lock);
@@ -1582,6 +1616,8 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
         spin_unlock_bh(&tt_global->list_lock);
         atomic_inc(&tt_global->orig_list_count);
 
+sync_flags:
+        batadv_tt_global_sync_flags(tt_global);
 out:
         if (orig_entry)
                 batadv_tt_orig_list_entry_put(orig_entry);
@@ -1703,10 +1739,10 @@ static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
                 }
 
                 /* the change can carry possible "attribute" flags like the
-                 * TT_CLIENT_WIFI, therefore they have to be copied in the
+                 * TT_CLIENT_TEMP, therefore they have to be copied in the
                  * client entry
                  */
-                common->flags |= flags;
+                common->flags |= flags & (~BATADV_TT_SYNC_MASK);
 
                 /* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
                  * one originator left in the list and we previously received a
@@ -1723,7 +1759,8 @@ static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
         }
 add_orig_entry:
         /* add the new orig_entry (if needed) or update it */
-        batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);
+        batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn,
+                                        flags & BATADV_TT_SYNC_MASK);
 
         batadv_dbg(BATADV_DBG_TT, bat_priv,
                    "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
@@ -1946,6 +1983,7 @@ batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
                                struct batadv_tt_orig_list_entry *orig,
                                bool best)
 {
+        u16 flags = (common->flags & (~BATADV_TT_SYNC_MASK)) | orig->flags;
         void *hdr;
         struct batadv_orig_node_vlan *vlan;
         u8 last_ttvn;
@@ -1975,7 +2013,7 @@ batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
             nla_put_u8(msg, BATADV_ATTR_TT_LAST_TTVN, last_ttvn) ||
             nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
             nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) ||
-            nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, common->flags))
+            nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, flags))
                 goto nla_put_failure;
 
         if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
@@ -2589,6 +2627,7 @@ static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
                                 unsigned short vid)
 {
         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
+        struct batadv_tt_orig_list_entry *tt_orig;
         struct batadv_tt_common_entry *tt_common;
         struct batadv_tt_global_entry *tt_global;
         struct hlist_head *head;
@@ -2627,8 +2666,9 @@ static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
                         /* find out if this global entry is announced by this
                          * originator
                          */
-                        if (!batadv_tt_global_entry_has_orig(tt_global,
-                                                             orig_node))
+                        tt_orig = batadv_tt_global_orig_entry_find(tt_global,
+                                                                   orig_node);
+                        if (!tt_orig)
                                 continue;
 
                         /* use network order to read the VID: this ensures that
@@ -2640,10 +2680,12 @@ static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
                         /* compute the CRC on flags that have to be kept in sync
                          * among nodes
                          */
-                        flags = tt_common->flags & BATADV_TT_SYNC_MASK;
+                        flags = tt_orig->flags;
                         crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
 
                         crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
+
+                        batadv_tt_orig_list_entry_put(tt_orig);
                 }
                 rcu_read_unlock();
         }
diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h
index ea43a6449247..a62795868794 100644
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@ -1260,6 +1260,7 @@ struct batadv_tt_global_entry {
  * struct batadv_tt_orig_list_entry - orig node announcing a non-mesh client
  * @orig_node: pointer to orig node announcing this non-mesh client
  * @ttvn: translation table version number which added the non-mesh client
+ * @flags: per orig entry TT sync flags
  * @list: list node for batadv_tt_global_entry::orig_list
  * @refcount: number of contexts the object is used
  * @rcu: struct used for freeing in an RCU-safe manner
@@ -1267,6 +1268,7 @@ struct batadv_tt_global_entry {
 struct batadv_tt_orig_list_entry {
         struct batadv_orig_node *orig_node;
         u8 ttvn;
+        u8 flags;
         struct hlist_node list;
         struct kref refcount;
         struct rcu_head rcu;
diff --git a/net/core/dev.c b/net/core/dev.c
index 1d75499add72..3f69f6e71824 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -2732,7 +2732,7 @@ static inline bool skb_needs_check(struct sk_buff *skb, bool tx_path)
 {
         if (tx_path)
                 return skb->ip_summed != CHECKSUM_PARTIAL &&
-                       skb->ip_summed != CHECKSUM_NONE;
+                       skb->ip_summed != CHECKSUM_UNNECESSARY;
 
         return skb->ip_summed == CHECKSUM_NONE;
 }
diff --git a/net/ipv4/cipso_ipv4.c b/net/ipv4/cipso_ipv4.c
index c4c6e1969ed0..2ae8f54cb321 100644
--- a/net/ipv4/cipso_ipv4.c
+++ b/net/ipv4/cipso_ipv4.c
@@ -1523,9 +1523,17 @@ unsigned char *cipso_v4_optptr(const struct sk_buff *skb)
         int taglen;
 
         for (optlen = iph->ihl*4 - sizeof(struct iphdr); optlen > 0; ) {
-                if (optptr[0] == IPOPT_CIPSO)
+                switch (optptr[0]) {
+                case IPOPT_CIPSO:
                         return optptr;
-                taglen = optptr[1];
+                case IPOPT_END:
+                        return NULL;
+                case IPOPT_NOOP:
+                        taglen = 1;
+                        break;
+                default:
+                        taglen = optptr[1];
+                }
                 optlen -= taglen;
                 optptr += taglen;
         }
diff --git a/net/ipv4/fou.c b/net/ipv4/fou.c
index 8e0257d01200..1540db65241a 100644
--- a/net/ipv4/fou.c
+++ b/net/ipv4/fou.c
@@ -450,6 +450,7 @@ out_unlock:
 out:
         NAPI_GRO_CB(skb)->flush |= flush;
         skb_gro_remcsum_cleanup(skb, &grc);
+        skb->remcsum_offload = 0;
 
         return pp;
 }
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 842ed75ccb25..d73903fe8c83 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -106,6 +106,7 @@ int sysctl_tcp_invalid_ratelimit __read_mostly = HZ/2;
 #define FLAG_ORIG_SACK_ACKED    0x200 /* Never retransmitted data are (s)acked  */
 #define FLAG_SND_UNA_ADVANCED   0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
 #define FLAG_DSACKING_ACK       0x800 /* SACK blocks contained D-SACK info */
+#define FLAG_SET_XMIT_TIMER     0x1000 /* Set TLP or RTO timer */
 #define FLAG_SACK_RENEGING      0x2000 /* snd_una advanced to a sacked seq */
 #define FLAG_UPDATE_TS_RECENT   0x4000 /* tcp_replace_ts_recent() */
 #define FLAG_NO_CHALLENGE_ACK   0x8000 /* do not call tcp_send_challenge_ack()  */
@@ -2520,8 +2521,8 @@ static inline void tcp_end_cwnd_reduction(struct sock *sk)
                 return;
 
         /* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
-        if (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR ||
-            (tp->undo_marker && tp->snd_ssthresh < TCP_INFINITE_SSTHRESH)) {
+        if (tp->snd_ssthresh < TCP_INFINITE_SSTHRESH &&
+            (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR || tp->undo_marker)) {
                 tp->snd_cwnd = tp->snd_ssthresh;
                 tp->snd_cwnd_stamp = tcp_jiffies32;
         }
@@ -3004,10 +3005,7 @@ void tcp_rearm_rto(struct sock *sk)
                 /* Offset the time elapsed after installing regular RTO */
                 if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
                     icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
-                        struct sk_buff *skb = tcp_write_queue_head(sk);
-                        u64 rto_time_stamp = skb->skb_mstamp +
-                                             jiffies_to_usecs(rto);
-                        s64 delta_us = rto_time_stamp - tp->tcp_mstamp;
+                        s64 delta_us = tcp_rto_delta_us(sk);
                         /* delta_us may not be positive if the socket is locked
                          * when the retrans timer fires and is rescheduled.
                          */
@@ -3019,6 +3017,13 @@ void tcp_rearm_rto(struct sock *sk)
         }
 }
 
+/* Try to schedule a loss probe; if that doesn't work, then schedule an RTO. */
+static void tcp_set_xmit_timer(struct sock *sk)
+{
+        if (!tcp_schedule_loss_probe(sk))
+                tcp_rearm_rto(sk);
+}
+
 /* If we get here, the whole TSO packet has not been acked. */
 static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
 {
@@ -3180,7 +3185,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
                                         ca_rtt_us, sack->rate);
 
         if (flag & FLAG_ACKED) {
-                tcp_rearm_rto(sk);
+                flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
                 if (unlikely(icsk->icsk_mtup.probe_size &&
                              !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
                         tcp_mtup_probe_success(sk);
@@ -3208,7 +3213,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
                  * after when the head was last (re)transmitted. Otherwise the
                  * timeout may continue to extend in loss recovery.
                  */
-                tcp_rearm_rto(sk);
+                flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
         }
 
         if (icsk->icsk_ca_ops->pkts_acked) {
@@ -3575,9 +3580,6 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         if (after(ack, tp->snd_nxt))
                 goto invalid_ack;
 
-        if (icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)
-                tcp_rearm_rto(sk);
-
         if (after(ack, prior_snd_una)) {
                 flag |= FLAG_SND_UNA_ADVANCED;
                 icsk->icsk_retransmits = 0;
@@ -3626,18 +3628,20 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una, &acked,
                                     &sack_state);
 
+        if (tp->tlp_high_seq)
+                tcp_process_tlp_ack(sk, ack, flag);
+        /* If needed, reset TLP/RTO timer; RACK may later override this. */
+        if (flag & FLAG_SET_XMIT_TIMER)
+                tcp_set_xmit_timer(sk);
+
         if (tcp_ack_is_dubious(sk, flag)) {
                 is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
                 tcp_fastretrans_alert(sk, acked, is_dupack, &flag, &rexmit);
         }
-        if (tp->tlp_high_seq)
-                tcp_process_tlp_ack(sk, ack, flag);
 
         if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
                 sk_dst_confirm(sk);
 
-        if (icsk->icsk_pending == ICSK_TIME_RETRANS)
-                tcp_schedule_loss_probe(sk);
         delivered = tp->delivered - delivered;  /* freshly ACKed or SACKed */
         lost = tp->lost - lost;                 /* freshly marked lost */
         tcp_rate_gen(sk, delivered, lost, sack_state.rate);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index d49bff51bdb7..3e0d19631534 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2375,23 +2375,14 @@ bool tcp_schedule_loss_probe(struct sock *sk)
 {
         struct inet_connection_sock *icsk = inet_csk(sk);
         struct tcp_sock *tp = tcp_sk(sk);
-        u32 timeout, tlp_time_stamp, rto_time_stamp;
+        u32 timeout, rto_delta_us;
 
-        /* No consecutive loss probes. */
-        if (WARN_ON(icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)) {
-                tcp_rearm_rto(sk);
-                return false;
-        }
         /* Don't do any loss probe on a Fast Open connection before 3WHS
          * finishes.
          */
         if (tp->fastopen_rsk)
                 return false;
 
-        /* TLP is only scheduled when next timer event is RTO. */
-        if (icsk->icsk_pending != ICSK_TIME_RETRANS)
-                return false;
-
         /* Schedule a loss probe in 2*RTT for SACK capable connections
          * in Open state, that are either limited by cwnd or application.
          */
@@ -2418,14 +2409,10 @@ bool tcp_schedule_loss_probe(struct sock *sk)
                 timeout = TCP_TIMEOUT_INIT;
         }
 
-        /* If RTO is shorter, just schedule TLP in its place. */
-        tlp_time_stamp = tcp_jiffies32 + timeout;
-        rto_time_stamp = (u32)inet_csk(sk)->icsk_timeout;
-        if ((s32)(tlp_time_stamp - rto_time_stamp) > 0) {
-                s32 delta = rto_time_stamp - tcp_jiffies32;
-                if (delta > 0)
-                        timeout = delta;
-        }
+        /* If the RTO formula yields an earlier time, then use that time. */
+        rto_delta_us = tcp_rto_delta_us(sk);  /* How far in future is RTO? */
+        if (rto_delta_us > 0)
+                timeout = min_t(u32, timeout, usecs_to_jiffies(rto_delta_us));
 
         inet_csk_reset_xmit_timer(sk, ICSK_TIME_LOSS_PROBE, timeout,
                                   TCP_RTO_MAX);
@@ -3450,6 +3437,10 @@ int tcp_connect(struct sock *sk)
         int err;
 
         tcp_call_bpf(sk, BPF_SOCK_OPS_TCP_CONNECT_CB);
+
+        if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
+                return -EHOSTUNREACH; /* Routing failure or similar. */
+
         tcp_connect_init(sk);
 
         if (unlikely(tp->repair)) {
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index f753f9d2fee3..655dd8d7f064 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -640,7 +640,8 @@ static void tcp_keepalive_timer (unsigned long data)
                 goto death;
         }
 
-        if (!sock_flag(sk, SOCK_KEEPOPEN) || sk->sk_state == TCP_CLOSE)
+        if (!sock_flag(sk, SOCK_KEEPOPEN) ||
+            ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)))
                 goto out;
 
         elapsed = keepalive_time_when(tp);
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 7ecbe5eb19f8..c73e61750642 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -2356,6 +2356,7 @@ static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_bu
         if (on_link)
                 nrt->rt6i_flags &= ~RTF_GATEWAY;
 
+        nrt->rt6i_protocol = RTPROT_REDIRECT;
         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
 
         if (ip6_ins_rt(nrt))
@@ -2466,6 +2467,7 @@ static struct rt6_info *rt6_add_route_info(struct net *net,
                 .fc_dst_len     = prefixlen,
                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
                                   RTF_UP | RTF_PREF(pref),
+                .fc_protocol = RTPROT_RA,
                 .fc_nlinfo.portid = 0,
                 .fc_nlinfo.nlh = NULL,
                 .fc_nlinfo.nl_net = net,
@@ -2518,6 +2520,7 @@ struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
                 .fc_ifindex     = dev->ifindex,
                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
+                .fc_protocol = RTPROT_RA,
                 .fc_nlinfo.portid = 0,
                 .fc_nlinfo.nlh = NULL,
                 .fc_nlinfo.nl_net = dev_net(dev),
@@ -3432,14 +3435,6 @@ static int rt6_fill_node(struct net *net,
         rtm->rtm_flags = 0;
         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
         rtm->rtm_protocol = rt->rt6i_protocol;
-        if (rt->rt6i_flags & RTF_DYNAMIC)
-                rtm->rtm_protocol = RTPROT_REDIRECT;
-        else if (rt->rt6i_flags & RTF_ADDRCONF) {
-                if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
-                        rtm->rtm_protocol = RTPROT_RA;
-                else
-                        rtm->rtm_protocol = RTPROT_KERNEL;
-        }
 
         if (rt->rt6i_flags & RTF_CACHE)
                 rtm->rtm_flags |= RTM_F_CLONED;
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index e10624aa6959..9722bf839d9d 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -1015,8 +1015,10 @@ void rds_ib_recv_cqe_handler(struct rds_ib_connection *ic,
         if (rds_ib_ring_empty(&ic->i_recv_ring))
                 rds_ib_stats_inc(s_ib_rx_ring_empty);
 
-        if (rds_ib_ring_low(&ic->i_recv_ring))
+        if (rds_ib_ring_low(&ic->i_recv_ring)) {
                 rds_ib_recv_refill(conn, 0, GFP_NOWAIT);
+                rds_ib_stats_inc(s_ib_rx_refill_from_cq);
+        }
 }
 
 int rds_ib_recv_path(struct rds_conn_path *cp)
@@ -1029,6 +1031,7 @@ int rds_ib_recv_path(struct rds_conn_path *cp)
         if (rds_conn_up(conn)) {
                 rds_ib_attempt_ack(ic);
                 rds_ib_recv_refill(conn, 0, GFP_KERNEL);
+                rds_ib_stats_inc(s_ib_rx_refill_from_thread);
         }
 
         return ret;
diff --git a/net/sched/act_ipt.c b/net/sched/act_ipt.c
index 36f0ced9e60c..94ba5cfab860 100644
--- a/net/sched/act_ipt.c
+++ b/net/sched/act_ipt.c
@@ -36,8 +36,8 @@ static struct tc_action_ops act_ipt_ops;
 static unsigned int xt_net_id;
 static struct tc_action_ops act_xt_ops;
 
-static int ipt_init_target(struct xt_entry_target *t, char *table,
-                           unsigned int hook)
+static int ipt_init_target(struct net *net, struct xt_entry_target *t,
+                           char *table, unsigned int hook)
 {
         struct xt_tgchk_param par;
         struct xt_target *target;
@@ -49,6 +49,7 @@ static int ipt_init_target(struct xt_entry_target *t, char *table,
                 return PTR_ERR(target);
 
         t->u.kernel.target = target;
+        par.net       = net;
         par.table     = table;
         par.entryinfo = NULL;
         par.target    = target;
@@ -91,10 +92,11 @@ static const struct nla_policy ipt_policy[TCA_IPT_MAX + 1] = {
         [TCA_IPT_TARG]  = { .len = sizeof(struct xt_entry_target) },
 };
 
-static int __tcf_ipt_init(struct tc_action_net *tn, struct nlattr *nla,
+static int __tcf_ipt_init(struct net *net, unsigned int id, struct nlattr *nla,
                           struct nlattr *est, struct tc_action **a,
                           const struct tc_action_ops *ops, int ovr, int bind)
 {
+        struct tc_action_net *tn = net_generic(net, id);
         struct nlattr *tb[TCA_IPT_MAX + 1];
         struct tcf_ipt *ipt;
         struct xt_entry_target *td, *t;
@@ -159,7 +161,7 @@ static int __tcf_ipt_init(struct tc_action_net *tn, struct nlattr *nla,
         if (unlikely(!t))
                 goto err2;
 
-        err = ipt_init_target(t, tname, hook);
+        err = ipt_init_target(net, t, tname, hook);
         if (err < 0)
                 goto err3;
 
@@ -193,18 +195,16 @@ static int tcf_ipt_init(struct net *net, struct nlattr *nla,
                         struct nlattr *est, struct tc_action **a, int ovr,
                         int bind)
 {
-        struct tc_action_net *tn = net_generic(net, ipt_net_id);
-
-        return __tcf_ipt_init(tn, nla, est, a, &act_ipt_ops, ovr, bind);
+        return __tcf_ipt_init(net, ipt_net_id, nla, est, a, &act_ipt_ops, ovr,
+                              bind);
 }
 
 static int tcf_xt_init(struct net *net, struct nlattr *nla,
                        struct nlattr *est, struct tc_action **a, int ovr,
                        int bind)
 {
-        struct tc_action_net *tn = net_generic(net, xt_net_id);
-
-        return __tcf_ipt_init(tn, nla, est, a, &act_xt_ops, ovr, bind);
+        return __tcf_ipt_init(net, xt_net_id, nla, est, a, &act_xt_ops, ovr,
+                              bind);
 }
 
 static int tcf_ipt(struct sk_buff *skb, const struct tc_action *a,