Merge tag 'v3.9-rc3' into drm-intel-next-queued

Backmerge so that I can merge Imre Deak's coalesced sg entries fixes,
which depend upon the new for_each_sg_page introduce in

commit a321e91b6d73ed011ffceed384c40d2785cf723b
Author: Imre Deak <imre.deak@intel.com>
Date:   Wed Feb 27 17:02:56 2013 -0800

    lib/scatterlist: add simple page iterator

The merge itself is just two trivial conflicts:

Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>

1 files changed, 81 insertions, 9 deletions

diff --git a/include/net/inet_frag.h b/include/net/inet_frag.h
index 32786a044718..76c3fe5ecc2e 100644
--- a/include/net/inet_frag.h
+++ b/include/net/inet_frag.h
@@ -1,10 +1,17 @@
 #ifndef __NET_FRAG_H__
 #define __NET_FRAG_H__
 
+#include <linux/percpu_counter.h>
+
 struct netns_frags {
         int                     nqueues;
-        atomic_t                mem;
         struct list_head        lru_list;
+        spinlock_t              lru_lock;
+
+        /* The percpu_counter "mem" need to be cacheline aligned.
+         *  mem.count must not share cacheline with other writers
+         */
+        struct percpu_counter   mem ____cacheline_aligned_in_smp;
 
         /* sysctls */
         int                     timeout;
@@ -13,12 +20,11 @@ struct netns_frags {
 };
 
 struct inet_frag_queue {
-        struct hlist_node       list;
-        struct netns_frags      *net;
-        struct list_head        lru_list;   /* lru list member */
         spinlock_t              lock;
-        atomic_t                refcnt;
         struct timer_list       timer;      /* when will this queue expire? */
+        struct list_head        lru_list;   /* lru list member */
+        struct hlist_node       list;
+        atomic_t                refcnt;
         struct sk_buff          *fragments; /* list of received fragments */
         struct sk_buff          *fragments_tail;
         ktime_t                 stamp;
@@ -31,24 +37,29 @@ struct inet_frag_queue {
 #define INET_FRAG_LAST_IN       1
 
         u16                     max_size;
+
+        struct netns_frags      *net;
 };
 
 #define INETFRAGS_HASHSZ                64
 
 struct inet_frags {
         struct hlist_head       hash[INETFRAGS_HASHSZ];
-        rwlock_t                lock;
-        u32                     rnd;
-        int                     qsize;
+        /* This rwlock is a global lock (seperate per IPv4, IPv6 and
+         * netfilter). Important to keep this on a seperate cacheline.
+         */
+        rwlock_t                lock ____cacheline_aligned_in_smp;
         int                     secret_interval;
         struct timer_list       secret_timer;
+        u32                     rnd;
+        int                     qsize;
 
         unsigned int            (*hashfn)(struct inet_frag_queue *);
+        bool                    (*match)(struct inet_frag_queue *q, void *arg);
         void                    (*constructor)(struct inet_frag_queue *q,
                                                 void *arg);
         void                    (*destructor)(struct inet_frag_queue *);
         void                    (*skb_free)(struct sk_buff *);
-        bool                    (*match)(struct inet_frag_queue *q, void *arg);
         void                    (*frag_expire)(unsigned long data);
 };
 
@@ -72,4 +83,65 @@ static inline void inet_frag_put(struct inet_frag_queue *q, struct inet_frags *f
                 inet_frag_destroy(q, f, NULL);
 }
 
+/* Memory Tracking Functions. */
+
+/* The default percpu_counter batch size is not big enough to scale to
+ * fragmentation mem acct sizes.
+ * The mem size of a 64K fragment is approx:
+ *  (44 fragments * 2944 truesize) + frag_queue struct(200) = 129736 bytes
+ */
+static unsigned int frag_percpu_counter_batch = 130000;
+
+static inline int frag_mem_limit(struct netns_frags *nf)
+{
+        return percpu_counter_read(&nf->mem);
+}
+
+static inline void sub_frag_mem_limit(struct inet_frag_queue *q, int i)
+{
+        __percpu_counter_add(&q->net->mem, -i, frag_percpu_counter_batch);
+}
+
+static inline void add_frag_mem_limit(struct inet_frag_queue *q, int i)
+{
+        __percpu_counter_add(&q->net->mem, i, frag_percpu_counter_batch);
+}
+
+static inline void init_frag_mem_limit(struct netns_frags *nf)
+{
+        percpu_counter_init(&nf->mem, 0);
+}
+
+static inline int sum_frag_mem_limit(struct netns_frags *nf)
+{
+        int res;
+
+        local_bh_disable();
+        res = percpu_counter_sum_positive(&nf->mem);
+        local_bh_enable();
+
+        return res;
+}
+
+static inline void inet_frag_lru_move(struct inet_frag_queue *q)
+{
+        spin_lock(&q->net->lru_lock);
+        list_move_tail(&q->lru_list, &q->net->lru_list);
+        spin_unlock(&q->net->lru_lock);
+}
+
+static inline void inet_frag_lru_del(struct inet_frag_queue *q)
+{
+        spin_lock(&q->net->lru_lock);
+        list_del(&q->lru_list);
+        spin_unlock(&q->net->lru_lock);
+}
+
+static inline void inet_frag_lru_add(struct netns_frags *nf,
+                                     struct inet_frag_queue *q)
+{
+        spin_lock(&nf->lru_lock);
+        list_add_tail(&q->lru_list, &nf->lru_list);
+        spin_unlock(&nf->lru_lock);
+}
 #endif