2 files changed, 49 insertions, 6 deletions

diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index a17a7018db19..3cf0457f5c69 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -152,6 +152,7 @@ struct tun_flow_entry {
         struct tun_struct *tun;
 
         u32 rxhash;
+        u32 rps_rxhash;
         int queue_index;
         unsigned long updated;
 };
@@ -220,6 +221,7 @@ static struct tun_flow_entry *tun_flow_create(struct tun_struct *tun,
                           rxhash, queue_index);
                 e->updated = jiffies;
                 e->rxhash = rxhash;
+                e->rps_rxhash = 0;
                 e->queue_index = queue_index;
                 e->tun = tun;
                 hlist_add_head_rcu(&e->hash_link, head);
@@ -232,6 +234,7 @@ static void tun_flow_delete(struct tun_struct *tun, struct tun_flow_entry *e)
 {
         tun_debug(KERN_INFO, tun, "delete flow: hash %u index %u\n",
                   e->rxhash, e->queue_index);
+        sock_rps_reset_flow_hash(e->rps_rxhash);
         hlist_del_rcu(&e->hash_link);
         kfree_rcu(e, rcu);
         --tun->flow_count;
@@ -325,6 +328,7 @@ static void tun_flow_update(struct tun_struct *tun, u32 rxhash,
                 /* TODO: keep queueing to old queue until it's empty? */
                 e->queue_index = queue_index;
                 e->updated = jiffies;
+                sock_rps_record_flow_hash(e->rps_rxhash);
         } else {
                 spin_lock_bh(&tun->lock);
                 if (!tun_flow_find(head, rxhash) &&
@@ -341,6 +345,18 @@ unlock:
         rcu_read_unlock();
 }
 
+/**
+ * Save the hash received in the stack receive path and update the
+ * flow_hash table accordingly.
+ */
+static inline void tun_flow_save_rps_rxhash(struct tun_flow_entry *e, u32 hash)
+{
+        if (unlikely(e->rps_rxhash != hash)) {
+                sock_rps_reset_flow_hash(e->rps_rxhash);
+                e->rps_rxhash = hash;
+        }
+}
+
 /* We try to identify a flow through its rxhash first. The reason that
  * we do not check rxq no. is because some cards(e.g 82599), chooses
  * the rxq based on the txq where the last packet of the flow comes. As
@@ -361,9 +377,10 @@ static u16 tun_select_queue(struct net_device *dev, struct sk_buff *skb)
         txq = skb_get_hash(skb);
         if (txq) {
                 e = tun_flow_find(&tun->flows[tun_hashfn(txq)], txq);
-                if (e)
+                if (e) {
                         txq = e->queue_index;
-                else
+                        tun_flow_save_rps_rxhash(e, txq);
+                } else
                         /* use multiply and shift instead of expensive divide */
                         txq = ((u64)txq * numqueues) >> 32;
         } else if (likely(skb_rx_queue_recorded(skb))) {
@@ -728,6 +745,22 @@ static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
         if (txq >= tun->numqueues)
                 goto drop;
 
+        if (tun->numqueues == 1) {
+                /* Select queue was not called for the skbuff, so we extract the
+                 * RPS hash and save it into the flow_table here.
+                 */
+                __u32 rxhash;
+
+                rxhash = skb_get_hash(skb);
+                if (rxhash) {
+                        struct tun_flow_entry *e;
+                        e = tun_flow_find(&tun->flows[tun_hashfn(rxhash)],
+                                        rxhash);
+                        if (e)
+                                tun_flow_save_rps_rxhash(e, rxhash);
+                }
+        }
+
         tun_debug(KERN_INFO, tun, "tun_net_xmit %d\n", skb->len);
 
         BUG_ON(!tfile);
diff --git a/include/net/sock.h b/include/net/sock.h
index 2ef3c3eca47a..8ee90add69d2 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -820,30 +820,40 @@ static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
         return sk->sk_backlog_rcv(sk, skb);
 }
 
-static inline void sock_rps_record_flow(const struct sock *sk)
+static inline void sock_rps_record_flow_hash(__u32 hash)
 {
 #ifdef CONFIG_RPS
         struct rps_sock_flow_table *sock_flow_table;
 
         rcu_read_lock();
         sock_flow_table = rcu_dereference(rps_sock_flow_table);
-        rps_record_sock_flow(sock_flow_table, sk->sk_rxhash);
+        rps_record_sock_flow(sock_flow_table, hash);
         rcu_read_unlock();
 #endif
 }
 
-static inline void sock_rps_reset_flow(const struct sock *sk)
+static inline void sock_rps_reset_flow_hash(__u32 hash)
 {
 #ifdef CONFIG_RPS
         struct rps_sock_flow_table *sock_flow_table;
 
         rcu_read_lock();
         sock_flow_table = rcu_dereference(rps_sock_flow_table);
-        rps_reset_sock_flow(sock_flow_table, sk->sk_rxhash);
+        rps_reset_sock_flow(sock_flow_table, hash);
         rcu_read_unlock();
 #endif
 }
 
+static inline void sock_rps_record_flow(const struct sock *sk)
+{
+        sock_rps_record_flow_hash(sk->sk_rxhash);
+}
+
+static inline void sock_rps_reset_flow(const struct sock *sk)
+{
+        sock_rps_reset_flow_hash(sk->sk_rxhash);
+}
+
 static inline void sock_rps_save_rxhash(struct sock *sk,
                                         const struct sk_buff *skb)
 {