Patched in Tegra support.

29 files changed, 174 insertions, 143 deletions

diff --git a/net/rds/cong.c b/net/rds/cong.c
index e5b65acd650..6daaa49d133 100644
--- a/net/rds/cong.c
+++ b/net/rds/cong.c
@@ -34,7 +34,6 @@
 #include <linux/types.h>
 #include <linux/rbtree.h>
 #include <linux/bitops.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
diff --git a/net/rds/connection.c b/net/rds/connection.c
index 9e07c756d1f..9334d892366 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -33,7 +33,6 @@
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/slab.h>
-#include <linux/export.h>
 #include <net/inet_hashtables.h>
 
 #include "rds.h"
diff --git a/net/rds/ib.c b/net/rds/ib.c
index b4c8b0022fe..3b83086bcc3 100644
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -38,7 +38,6 @@
 #include <linux/if_arp.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include "rds.h"
 #include "ib.h"
diff --git a/net/rds/ib.h b/net/rds/ib.h
index 7280ab8810c..edfaaaf164e 100644
--- a/net/rds/ib.h
+++ b/net/rds/ib.h
@@ -50,7 +50,7 @@ struct rds_ib_cache_head {
 };
 
 struct rds_ib_refill_cache {
-        struct rds_ib_cache_head __percpu *percpu;
+        struct rds_ib_cache_head *percpu;
         struct list_head         *xfer;
         struct list_head         *ready;
 };
@@ -186,7 +186,8 @@ struct rds_ib_device {
         struct work_struct      free_work;
 };
 
-#define ibdev_to_node(ibdev) dev_to_node(ibdev->dma_device)
+#define pcidev_to_node(pcidev) pcibus_to_node(pcidev->bus)
+#define ibdev_to_node(ibdev) pcidev_to_node(to_pci_dev(ibdev->dma_device))
 #define rdsibdev_to_node(rdsibdev) ibdev_to_node(rdsibdev->dev)
 
 /* bits for i_ack_flags */
diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index 31b74f5e61a..cd67026be2d 100644
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -375,21 +375,23 @@ static int rds_ib_setup_qp(struct rds_connection *conn)
                 goto out;
         }
 
-        ic->i_sends = vzalloc_node(ic->i_send_ring.w_nr * sizeof(struct rds_ib_send_work),
+        ic->i_sends = vmalloc_node(ic->i_send_ring.w_nr * sizeof(struct rds_ib_send_work),
                                    ibdev_to_node(dev));
         if (!ic->i_sends) {
                 ret = -ENOMEM;
                 rdsdebug("send allocation failed\n");
                 goto out;
         }
+        memset(ic->i_sends, 0, ic->i_send_ring.w_nr * sizeof(struct rds_ib_send_work));
 
-        ic->i_recvs = vzalloc_node(ic->i_recv_ring.w_nr * sizeof(struct rds_ib_recv_work),
+        ic->i_recvs = vmalloc_node(ic->i_recv_ring.w_nr * sizeof(struct rds_ib_recv_work),
                                    ibdev_to_node(dev));
         if (!ic->i_recvs) {
                 ret = -ENOMEM;
                 rdsdebug("recv allocation failed\n");
                 goto out;
         }
+        memset(ic->i_recvs, 0, ic->i_recv_ring.w_nr * sizeof(struct rds_ib_recv_work));
 
         rds_ib_recv_init_ack(ic);
 
@@ -434,11 +436,12 @@ static u32 rds_ib_protocol_compatible(struct rdma_cm_event *event)
                 version = RDS_PROTOCOL_3_0;
                 while ((common >>= 1) != 0)
                         version++;
-        } else
-                printk_ratelimited(KERN_NOTICE "RDS: Connection from %pI4 using incompatible protocol version %u.%u\n",
-                                &dp->dp_saddr,
-                                dp->dp_protocol_major,
-                                dp->dp_protocol_minor);
+        }
+        printk_ratelimited(KERN_NOTICE "RDS: Connection from %pI4 using "
+                        "incompatible protocol version %u.%u\n",
+                        &dp->dp_saddr,
+                        dp->dp_protocol_major,
+                        dp->dp_protocol_minor);
         return version;
 }
 
@@ -748,7 +751,7 @@ int rds_ib_conn_alloc(struct rds_connection *conn, gfp_t gfp)
         int ret;
 
         /* XXX too lazy? */
-        ic = kzalloc(sizeof(struct rds_ib_connection), gfp);
+        ic = kzalloc(sizeof(struct rds_ib_connection), GFP_KERNEL);
         if (!ic)
                 return -ENOMEM;
 
diff --git a/net/rds/ib_rdma.c b/net/rds/ib_rdma.c
index e8fdb172adb..819c35a0d9c 100644
--- a/net/rds/ib_rdma.c
+++ b/net/rds/ib_rdma.c
@@ -33,10 +33,10 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/rculist.h>
-#include <linux/llist.h>
 
 #include "rds.h"
 #include "ib.h"
+#include "xlist.h"
 
 static DEFINE_PER_CPU(unsigned long, clean_list_grace);
 #define CLEAN_LIST_BUSY_BIT 0
@@ -49,7 +49,7 @@ struct rds_ib_mr {
         struct rds_ib_mr_pool   *pool;
         struct ib_fmr           *fmr;
 
-        struct llist_node       llnode;
+        struct xlist_head       xlist;
 
         /* unmap_list is for freeing */
         struct list_head        unmap_list;
@@ -71,9 +71,9 @@ struct rds_ib_mr_pool {
         atomic_t                item_count;             /* total # of MRs */
         atomic_t                dirty_count;            /* # dirty of MRs */
 
-        struct llist_head       drop_list;              /* MRs that have reached their max_maps limit */
-        struct llist_head       free_list;              /* unused MRs */
-        struct llist_head       clean_list;             /* global unused & unamapped MRs */
+        struct xlist_head       drop_list;              /* MRs that have reached their max_maps limit */
+        struct xlist_head       free_list;              /* unused MRs */
+        struct xlist_head       clean_list;             /* global unused & unamapped MRs */
         wait_queue_head_t       flush_wait;
 
         atomic_t                free_pinned;            /* memory pinned by free MRs */
@@ -220,9 +220,9 @@ struct rds_ib_mr_pool *rds_ib_create_mr_pool(struct rds_ib_device *rds_ibdev)
         if (!pool)
                 return ERR_PTR(-ENOMEM);
 
-        init_llist_head(&pool->free_list);
-        init_llist_head(&pool->drop_list);
-        init_llist_head(&pool->clean_list);
+        INIT_XLIST_HEAD(&pool->free_list);
+        INIT_XLIST_HEAD(&pool->drop_list);
+        INIT_XLIST_HEAD(&pool->clean_list);
         mutex_init(&pool->flush_lock);
         init_waitqueue_head(&pool->flush_wait);
         INIT_DELAYED_WORK(&pool->flush_worker, rds_ib_mr_pool_flush_worker);
@@ -260,18 +260,26 @@ void rds_ib_destroy_mr_pool(struct rds_ib_mr_pool *pool)
         kfree(pool);
 }
 
+static void refill_local(struct rds_ib_mr_pool *pool, struct xlist_head *xl,
+                         struct rds_ib_mr **ibmr_ret)
+{
+        struct xlist_head *ibmr_xl;
+        ibmr_xl = xlist_del_head_fast(xl);
+        *ibmr_ret = list_entry(ibmr_xl, struct rds_ib_mr, xlist);
+}
+
 static inline struct rds_ib_mr *rds_ib_reuse_fmr(struct rds_ib_mr_pool *pool)
 {
         struct rds_ib_mr *ibmr = NULL;
-        struct llist_node *ret;
+        struct xlist_head *ret;
         unsigned long *flag;
 
         preempt_disable();
         flag = &__get_cpu_var(clean_list_grace);
         set_bit(CLEAN_LIST_BUSY_BIT, flag);
-        ret = llist_del_first(&pool->clean_list);
+        ret = xlist_del_head(&pool->clean_list);
         if (ret)
-                ibmr = llist_entry(ret, struct rds_ib_mr, llnode);
+                ibmr = list_entry(ret, struct rds_ib_mr, xlist);
 
         clear_bit(CLEAN_LIST_BUSY_BIT, flag);
         preempt_enable();
@@ -521,44 +529,46 @@ static inline unsigned int rds_ib_flush_goal(struct rds_ib_mr_pool *pool, int fr
 }
 
 /*
- * given an llist of mrs, put them all into the list_head for more processing
+ * given an xlist of mrs, put them all into the list_head for more processing
  */
-static void llist_append_to_list(struct llist_head *llist, struct list_head *list)
+static void xlist_append_to_list(struct xlist_head *xlist, struct list_head *list)
 {
         struct rds_ib_mr *ibmr;
-        struct llist_node *node;
-        struct llist_node *next;
-
-        node = llist_del_all(llist);
-        while (node) {
-                next = node->next;
-                ibmr = llist_entry(node, struct rds_ib_mr, llnode);
+        struct xlist_head splice;
+        struct xlist_head *cur;
+        struct xlist_head *next;
+
+        splice.next = NULL;
+        xlist_splice(xlist, &splice);
+        cur = splice.next;
+        while (cur) {
+                next = cur->next;
+                ibmr = list_entry(cur, struct rds_ib_mr, xlist);
                 list_add_tail(&ibmr->unmap_list, list);
-                node = next;
+                cur = next;
         }
 }
 
 /*
- * this takes a list head of mrs and turns it into linked llist nodes
- * of clusters.  Each cluster has linked llist nodes of
- * MR_CLUSTER_SIZE mrs that are ready for reuse.
+ * this takes a list head of mrs and turns it into an xlist of clusters.
+ * each cluster has an xlist of MR_CLUSTER_SIZE mrs that are ready for
+ * reuse.
  */
-static void list_to_llist_nodes(struct rds_ib_mr_pool *pool,
-                                struct list_head *list,
-                                struct llist_node **nodes_head,
-                                struct llist_node **nodes_tail)
+static void list_append_to_xlist(struct rds_ib_mr_pool *pool,
+                                struct list_head *list, struct xlist_head *xlist,
+                                struct xlist_head **tail_ret)
 {
         struct rds_ib_mr *ibmr;
-        struct llist_node *cur = NULL;
-        struct llist_node **next = nodes_head;
+        struct xlist_head *cur_mr = xlist;
+        struct xlist_head *tail_mr = NULL;
 
         list_for_each_entry(ibmr, list, unmap_list) {
-                cur = &ibmr->llnode;
-                *next = cur;
-                next = &cur->next;
+                tail_mr = &ibmr->xlist;
+                tail_mr->next = NULL;
+                cur_mr->next = tail_mr;
+                cur_mr = tail_mr;
         }
-        *next = NULL;
-        *nodes_tail = cur;
+        *tail_ret = tail_mr;
 }
 
 /*
@@ -571,8 +581,8 @@ static int rds_ib_flush_mr_pool(struct rds_ib_mr_pool *pool,
                                 int free_all, struct rds_ib_mr **ibmr_ret)
 {
         struct rds_ib_mr *ibmr, *next;
-        struct llist_node *clean_nodes;
-        struct llist_node *clean_tail;
+        struct xlist_head clean_xlist;
+        struct xlist_head *clean_tail;
         LIST_HEAD(unmap_list);
         LIST_HEAD(fmr_list);
         unsigned long unpinned = 0;
@@ -593,7 +603,7 @@ static int rds_ib_flush_mr_pool(struct rds_ib_mr_pool *pool,
 
                         prepare_to_wait(&pool->flush_wait, &wait,
                                         TASK_UNINTERRUPTIBLE);
-                        if (llist_empty(&pool->clean_list))
+                        if (xlist_empty(&pool->clean_list))
                                 schedule();
 
                         ibmr = rds_ib_reuse_fmr(pool);
@@ -618,10 +628,10 @@ static int rds_ib_flush_mr_pool(struct rds_ib_mr_pool *pool,
         /* Get the list of all MRs to be dropped. Ordering matters -
          * we want to put drop_list ahead of free_list.
          */
-        llist_append_to_list(&pool->drop_list, &unmap_list);
-        llist_append_to_list(&pool->free_list, &unmap_list);
+        xlist_append_to_list(&pool->drop_list, &unmap_list);
+        xlist_append_to_list(&pool->free_list, &unmap_list);
         if (free_all)
-                llist_append_to_list(&pool->clean_list, &unmap_list);
+                xlist_append_to_list(&pool->clean_list, &unmap_list);
 
         free_goal = rds_ib_flush_goal(pool, free_all);
 
@@ -653,22 +663,22 @@ static int rds_ib_flush_mr_pool(struct rds_ib_mr_pool *pool,
         if (!list_empty(&unmap_list)) {
                 /* we have to make sure that none of the things we're about
                  * to put on the clean list would race with other cpus trying
-                 * to pull items off.  The llist would explode if we managed to
+                 * to pull items off.  The xlist would explode if we managed to
                  * remove something from the clean list and then add it back again
-                 * while another CPU was spinning on that same item in llist_del_first.
+                 * while another CPU was spinning on that same item in xlist_del_head.
                  *
-                 * This is pretty unlikely, but just in case  wait for an llist grace period
+                 * This is pretty unlikely, but just in case  wait for an xlist grace period
                  * here before adding anything back into the clean list.
                  */
                 wait_clean_list_grace();
 
-                list_to_llist_nodes(pool, &unmap_list, &clean_nodes, &clean_tail);
+                list_append_to_xlist(pool, &unmap_list, &clean_xlist, &clean_tail);
                 if (ibmr_ret)
-                        *ibmr_ret = llist_entry(clean_nodes, struct rds_ib_mr, llnode);
+                        refill_local(pool, &clean_xlist, ibmr_ret);
 
-                /* more than one entry in llist nodes */
-                if (clean_nodes->next)
-                        llist_add_batch(clean_nodes->next, clean_tail, &pool->clean_list);
+                /* refill_local may have emptied our list */
+                if (!xlist_empty(&clean_xlist))
+                        xlist_add(clean_xlist.next, clean_tail, &pool->clean_list);
 
         }
 
@@ -701,9 +711,9 @@ void rds_ib_free_mr(void *trans_private, int invalidate)
 
         /* Return it to the pool's free list */
         if (ibmr->remap_count >= pool->fmr_attr.max_maps)
-                llist_add(&ibmr->llnode, &pool->drop_list);
+                xlist_add(&ibmr->xlist, &ibmr->xlist, &pool->drop_list);
         else
-                llist_add(&ibmr->llnode, &pool->free_list);
+                xlist_add(&ibmr->xlist, &ibmr->xlist, &pool->free_list);
 
         atomic_add(ibmr->sg_len, &pool->free_pinned);
         atomic_inc(&pool->dirty_count);
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index 8eb9501e3d6..e29e0ca32f7 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -339,8 +339,8 @@ static int rds_ib_recv_refill_one(struct rds_connection *conn,
         sge->length = sizeof(struct rds_header);
 
         sge = &recv->r_sge[1];
-        sge->addr = ib_sg_dma_address(ic->i_cm_id->device, &recv->r_frag->f_sg);
-        sge->length = ib_sg_dma_len(ic->i_cm_id->device, &recv->r_frag->f_sg);
+        sge->addr = sg_dma_address(&recv->r_frag->f_sg);
+        sge->length = sg_dma_len(&recv->r_frag->f_sg);
 
         ret = 0;
 out:
@@ -381,10 +381,7 @@ void rds_ib_recv_refill(struct rds_connection *conn, int prefill)
                 ret = ib_post_recv(ic->i_cm_id->qp, &recv->r_wr, &failed_wr);
                 rdsdebug("recv %p ibinc %p page %p addr %lu ret %d\n", recv,
                          recv->r_ibinc, sg_page(&recv->r_frag->f_sg),
-                         (long) ib_sg_dma_address(
-                                ic->i_cm_id->device,
-                                &recv->r_frag->f_sg),
-                        ret);
+                         (long) sg_dma_address(&recv->r_frag->f_sg), ret);
                 if (ret) {
                         rds_ib_conn_error(conn, "recv post on "
                                "%pI4 returned %d, disconnecting and "
@@ -421,21 +418,20 @@ static void rds_ib_recv_cache_put(struct list_head *new_item,
                                  struct rds_ib_refill_cache *cache)
 {
         unsigned long flags;
+        struct rds_ib_cache_head *chp;
         struct list_head *old;
-        struct list_head __percpu *chpfirst;
 
         local_irq_save(flags);
 
-        chpfirst = __this_cpu_read(cache->percpu->first);
-        if (!chpfirst)
+        chp = per_cpu_ptr(cache->percpu, smp_processor_id());
+        if (!chp->first)
                 INIT_LIST_HEAD(new_item);
         else /* put on front */
-                list_add_tail(new_item, chpfirst);
+                list_add_tail(new_item, chp->first);
+        chp->first = new_item;
+        chp->count++;
 
-        __this_cpu_write(chpfirst, new_item);
-        __this_cpu_inc(cache->percpu->count);
-
-        if (__this_cpu_read(cache->percpu->count) < RDS_IB_RECYCLE_BATCH_COUNT)
+        if (chp->count < RDS_IB_RECYCLE_BATCH_COUNT)
                 goto end;
 
         /*
@@ -447,13 +443,12 @@ static void rds_ib_recv_cache_put(struct list_head *new_item,
         do {
                 old = xchg(&cache->xfer, NULL);
                 if (old)
-                        list_splice_entire_tail(old, chpfirst);
-                old = cmpxchg(&cache->xfer, NULL, chpfirst);
+                        list_splice_entire_tail(old, chp->first);
+                old = cmpxchg(&cache->xfer, NULL, chp->first);
         } while (old);
 
-
-        __this_cpu_write(chpfirst, NULL);
-        __this_cpu_write(cache->percpu->count, 0);
+        chp->first = NULL;
+        chp->count = 0;
 end:
         local_irq_restore(flags);
 }
@@ -768,7 +763,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
                 to_copy = min(RDS_FRAG_SIZE - frag_off, PAGE_SIZE - map_off);
                 BUG_ON(to_copy & 7); /* Must be 64bit aligned. */
 
-                addr = kmap_atomic(sg_page(&frag->f_sg));
+                addr = kmap_atomic(sg_page(&frag->f_sg), KM_SOFTIRQ0);
 
                 src = addr + frag_off;
                 dst = (void *)map->m_page_addrs[map_page] + map_off;
@@ -778,7 +773,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
                         uncongested |= ~(*src) & *dst;
                         *dst++ = *src++;
                 }
-                kunmap_atomic(addr);
+                kunmap_atomic(addr, KM_SOFTIRQ0);
 
                 copied += to_copy;
 
@@ -831,7 +826,7 @@ static void rds_ib_process_recv(struct rds_connection *conn,
 
         if (data_len < sizeof(struct rds_header)) {
                 rds_ib_conn_error(conn, "incoming message "
-                       "from %pI4 didn't include a "
+                       "from %pI4 didn't inclue a "
                        "header, disconnecting and "
                        "reconnecting\n",
                        &conn->c_faddr);
@@ -924,7 +919,8 @@ static void rds_ib_process_recv(struct rds_connection *conn,
                         rds_ib_cong_recv(conn, ibinc);
                 else {
                         rds_recv_incoming(conn, conn->c_faddr, conn->c_laddr,
-                                          &ibinc->ii_inc, GFP_ATOMIC);
+                                          &ibinc->ii_inc, GFP_ATOMIC,
+                                          KM_SOFTIRQ0);
                         state->ack_next = be64_to_cpu(hdr->h_sequence);
                         state->ack_next_valid = 1;
                 }
diff --git a/net/rds/ib_sysctl.c b/net/rds/ib_sysctl.c
index 7e643bafb4a..1253b006efd 100644
--- a/net/rds/ib_sysctl.c
+++ b/net/rds/ib_sysctl.c
@@ -106,15 +106,22 @@ static ctl_table rds_ib_sysctl_table[] = {
         { }
 };
 
+static struct ctl_path rds_ib_sysctl_path[] = {
+        { .procname = "net", },
+        { .procname = "rds", },
+        { .procname = "ib", },
+        { }
+};
+
 void rds_ib_sysctl_exit(void)
 {
         if (rds_ib_sysctl_hdr)
-                unregister_net_sysctl_table(rds_ib_sysctl_hdr);
+                unregister_sysctl_table(rds_ib_sysctl_hdr);
 }
 
 int rds_ib_sysctl_init(void)
 {
-        rds_ib_sysctl_hdr = register_net_sysctl(&init_net, "net/rds/ib", rds_ib_sysctl_table);
+        rds_ib_sysctl_hdr = register_sysctl_paths(rds_ib_sysctl_path, rds_ib_sysctl_table);
         if (!rds_ib_sysctl_hdr)
                 return -ENOMEM;
         return 0;
diff --git a/net/rds/info.c b/net/rds/info.c
index 9a6b4f66187..4fdf1b6e84f 100644
--- a/net/rds/info.c
+++ b/net/rds/info.c
@@ -34,7 +34,6 @@
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
@@ -104,7 +103,7 @@ EXPORT_SYMBOL_GPL(rds_info_deregister_func);
 void rds_info_iter_unmap(struct rds_info_iterator *iter)
 {
         if (iter->addr) {
-                kunmap_atomic(iter->addr);
+                kunmap_atomic(iter->addr, KM_USER0);
                 iter->addr = NULL;
         }
 }
@@ -119,7 +118,7 @@ void rds_info_copy(struct rds_info_iterator *iter, void *data,
 
         while (bytes) {
                 if (!iter->addr)
-                        iter->addr = kmap_atomic(*iter->pages);
+                        iter->addr = kmap_atomic(*iter->pages, KM_USER0);
 
                 this = min(bytes, PAGE_SIZE - iter->offset);
 
@@ -134,7 +133,7 @@ void rds_info_copy(struct rds_info_iterator *iter, void *data,
                 iter->offset += this;
 
                 if (iter->offset == PAGE_SIZE) {
-                        kunmap_atomic(iter->addr);
+                        kunmap_atomic(iter->addr, KM_USER0);
                         iter->addr = NULL;
                         iter->offset = 0;
                         iter->pages++;
diff --git a/net/rds/iw.c b/net/rds/iw.c
index 7826d46baa7..f7474844f09 100644
--- a/net/rds/iw.c
+++ b/net/rds/iw.c
@@ -38,7 +38,6 @@
 #include <linux/if_arp.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include "rds.h"
 #include "iw.h"
diff --git a/net/rds/iw_cm.c b/net/rds/iw_cm.c
index a91e1db62ee..9556d2895f7 100644
--- a/net/rds/iw_cm.c
+++ b/net/rds/iw_cm.c
@@ -694,7 +694,7 @@ int rds_iw_conn_alloc(struct rds_connection *conn, gfp_t gfp)
         unsigned long flags;
 
         /* XXX too lazy? */
-        ic = kzalloc(sizeof(struct rds_iw_connection), gfp);
+        ic = kzalloc(sizeof(struct rds_iw_connection), GFP_KERNEL);
         if (!ic)
                 return -ENOMEM;
 
diff --git a/net/rds/iw_rdma.c b/net/rds/iw_rdma.c
index a817705ce2d..4e1de171866 100644
--- a/net/rds/iw_rdma.c
+++ b/net/rds/iw_rdma.c
@@ -477,6 +477,17 @@ void rds_iw_sync_mr(void *trans_private, int direction)
         }
 }
 
+static inline unsigned int rds_iw_flush_goal(struct rds_iw_mr_pool *pool, int free_all)
+{
+        unsigned int item_count;
+
+        item_count = atomic_read(&pool->item_count);
+        if (free_all)
+                return item_count;
+
+        return 0;
+}
+
 /*
  * Flush our pool of MRs.
  * At a minimum, all currently unused MRs are unmapped.
@@ -489,7 +500,7 @@ static int rds_iw_flush_mr_pool(struct rds_iw_mr_pool *pool, int free_all)
         LIST_HEAD(unmap_list);
         LIST_HEAD(kill_list);
         unsigned long flags;
-        unsigned int nfreed = 0, ncleaned = 0, unpinned = 0;
+        unsigned int nfreed = 0, ncleaned = 0, unpinned = 0, free_goal;
         int ret = 0;
 
         rds_iw_stats_inc(s_iw_rdma_mr_pool_flush);
@@ -503,6 +514,8 @@ static int rds_iw_flush_mr_pool(struct rds_iw_mr_pool *pool, int free_all)
                 list_splice_init(&pool->clean_list, &kill_list);
         spin_unlock_irqrestore(&pool->list_lock, flags);
 
+        free_goal = rds_iw_flush_goal(pool, free_all);
+
         /* Batched invalidate of dirty MRs.
          * For FMR based MRs, the mappings on the unmap list are
          * actually members of an ibmr (ibmr->mapping). They either
diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index 45033358358..5e57347f49f 100644
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -598,7 +598,7 @@ static void rds_iw_cong_recv(struct rds_connection *conn,
                 to_copy = min(RDS_FRAG_SIZE - frag_off, PAGE_SIZE - map_off);
                 BUG_ON(to_copy & 7); /* Must be 64bit aligned. */
 
-                addr = kmap_atomic(frag->f_page);
+                addr = kmap_atomic(frag->f_page, KM_SOFTIRQ0);
 
                 src = addr + frag_off;
                 dst = (void *)map->m_page_addrs[map_page] + map_off;
@@ -608,7 +608,7 @@ static void rds_iw_cong_recv(struct rds_connection *conn,
                         uncongested |= ~(*src) & *dst;
                         *dst++ = *src++;
                 }
-                kunmap_atomic(addr);
+                kunmap_atomic(addr, KM_SOFTIRQ0);
 
                 copied += to_copy;
 
@@ -661,7 +661,7 @@ static void rds_iw_process_recv(struct rds_connection *conn,
 
         if (byte_len < sizeof(struct rds_header)) {
                 rds_iw_conn_error(conn, "incoming message "
-                       "from %pI4 didn't include a "
+                       "from %pI4 didn't inclue a "
                        "header, disconnecting and "
                        "reconnecting\n",
                        &conn->c_faddr);
@@ -754,7 +754,8 @@ static void rds_iw_process_recv(struct rds_connection *conn,
                         rds_iw_cong_recv(conn, iwinc);
                 else {
                         rds_recv_incoming(conn, conn->c_faddr, conn->c_laddr,
-                                          &iwinc->ii_inc, GFP_ATOMIC);
+                                          &iwinc->ii_inc, GFP_ATOMIC,
+                                          KM_SOFTIRQ0);
                         state->ack_next = be64_to_cpu(hdr->h_sequence);
                         state->ack_next_valid = 1;
                 }
diff --git a/net/rds/iw_sysctl.c b/net/rds/iw_sysctl.c
index 5d5ebd576f3..e2e47176e72 100644
--- a/net/rds/iw_sysctl.c
+++ b/net/rds/iw_sysctl.c
@@ -109,15 +109,22 @@ static ctl_table rds_iw_sysctl_table[] = {
         { }
 };
 
+static struct ctl_path rds_iw_sysctl_path[] = {
+        { .procname = "net", },
+        { .procname = "rds", },
+        { .procname = "iw", },
+        { }
+};
+
 void rds_iw_sysctl_exit(void)
 {
         if (rds_iw_sysctl_hdr)
-                unregister_net_sysctl_table(rds_iw_sysctl_hdr);
+                unregister_sysctl_table(rds_iw_sysctl_hdr);
 }
 
 int rds_iw_sysctl_init(void)
 {
-        rds_iw_sysctl_hdr = register_net_sysctl(&init_net, "net/rds/iw", rds_iw_sysctl_table);
+        rds_iw_sysctl_hdr = register_sysctl_paths(rds_iw_sysctl_path, rds_iw_sysctl_table);
         if (!rds_iw_sysctl_hdr)
                 return -ENOMEM;
         return 0;
diff --git a/net/rds/loop.c b/net/rds/loop.c
index 6b12b68541a..bca6761a3ca 100644
--- a/net/rds/loop.c
+++ b/net/rds/loop.c
@@ -79,7 +79,7 @@ static int rds_loop_xmit(struct rds_connection *conn, struct rds_message *rm,
         rds_message_addref(rm);
 
         rds_recv_incoming(conn, conn->c_laddr, conn->c_faddr, &rm->m_inc,
-                          GFP_KERNEL);
+                          GFP_KERNEL, KM_USER0);
 
         rds_send_drop_acked(conn, be64_to_cpu(rm->m_inc.i_hdr.h_sequence),
                             NULL);
@@ -121,7 +121,7 @@ static int rds_loop_conn_alloc(struct rds_connection *conn, gfp_t gfp)
         struct rds_loop_connection *lc;
         unsigned long flags;
 
-        lc = kzalloc(sizeof(struct rds_loop_connection), gfp);
+        lc = kzalloc(sizeof(struct rds_loop_connection), GFP_KERNEL);
         if (!lc)
                 return -ENOMEM;
 
diff --git a/net/rds/message.c b/net/rds/message.c
index f0a4658f327..1fd3d29023d 100644
--- a/net/rds/message.c
+++ b/net/rds/message.c
@@ -32,7 +32,6 @@
  */
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
diff --git a/net/rds/page.c b/net/rds/page.c
index 9005a2c920e..b82d63e77b0 100644
--- a/net/rds/page.c
+++ b/net/rds/page.c
@@ -33,7 +33,6 @@
 #include <linux/highmem.h>
 #include <linux/gfp.h>
 #include <linux/cpu.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
@@ -74,12 +73,11 @@ int rds_page_copy_user(struct page *page, unsigned long offset,
 }
 EXPORT_SYMBOL_GPL(rds_page_copy_user);
 
-/**
- * rds_page_remainder_alloc - build up regions of a message.
+/*
+ * Message allocation uses this to build up regions of a message.
  *
- * @scat: Scatter list for message
- * @bytes: the number of bytes needed.
- * @gfp: the waiting behaviour of the allocation
+ * @bytes - the number of bytes needed.
+ * @gfp - the waiting behaviour of the allocation
  *
  * @gfp is always ored with __GFP_HIGHMEM.  Callers must be prepared to
  * kmap the pages, etc.
diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index c2be901d19e..f8760e1b668 100644
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -30,7 +30,6 @@
  * SOFTWARE.
  *
  */
-#include <linux/module.h>
 #include <rdma/rdma_cm.h>
 
 #include "rdma_transport.h"
diff --git a/net/rds/rds.h b/net/rds/rds.h
index ec1d731ecff..da8adac2bf0 100644
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -36,8 +36,8 @@
 #define rdsdebug(fmt, args...) pr_debug("%s(): " fmt, __func__ , ##args)
 #else
 /* sigh, pr_debug() causes unused variable warnings */
-static inline __printf(1, 2)
-void rdsdebug(char *fmt, ...)
+static inline void __attribute__ ((format (printf, 1, 2)))
+rdsdebug(char *fmt, ...)
 {
 }
 #endif
@@ -625,8 +625,8 @@ void rds_for_each_conn_info(struct socket *sock, unsigned int len,
                           struct rds_info_lengths *lens,
                           int (*visitor)(struct rds_connection *, void *),
                           size_t item_len);
-__printf(2, 3)
-void __rds_conn_error(struct rds_connection *conn, const char *, ...);
+void __rds_conn_error(struct rds_connection *conn, const char *, ...)
+                                __attribute__ ((format (printf, 2, 3)));
 #define rds_conn_error(conn, fmt...) \
         __rds_conn_error(conn, KERN_WARNING "RDS: " fmt)
 
@@ -704,7 +704,7 @@ void rds_inc_init(struct rds_incoming *inc, struct rds_connection *conn,
                   __be32 saddr);
 void rds_inc_put(struct rds_incoming *inc);
 void rds_recv_incoming(struct rds_connection *conn, __be32 saddr, __be32 daddr,
-                       struct rds_incoming *inc, gfp_t gfp);
+                       struct rds_incoming *inc, gfp_t gfp, enum km_type km);
 int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                 size_t size, int msg_flags);
 void rds_clear_recv_queue(struct rds_sock *rs);
diff --git a/net/rds/recv.c b/net/rds/recv.c
index 9f0f17cf6bf..596689e5927 100644
--- a/net/rds/recv.c
+++ b/net/rds/recv.c
@@ -34,7 +34,6 @@
 #include <linux/slab.h>
 #include <net/sock.h>
 #include <linux/in.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
@@ -155,7 +154,7 @@ static void rds_recv_incoming_exthdrs(struct rds_incoming *inc, struct rds_sock
  * tell us which roles the addrs in the conn are playing for this message.
  */
 void rds_recv_incoming(struct rds_connection *conn, __be32 saddr, __be32 daddr,
-                       struct rds_incoming *inc, gfp_t gfp)
+                       struct rds_incoming *inc, gfp_t gfp, enum km_type km)
 {
         struct rds_sock *rs = NULL;
         struct sock *sk;
@@ -410,8 +409,6 @@ int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 
         rdsdebug("size %zu flags 0x%x timeo %ld\n", size, msg_flags, timeo);
 
-        msg->msg_namelen = 0;
-
         if (msg_flags & MSG_OOB)
                 goto out;
 
@@ -487,7 +484,6 @@ int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                         sin->sin_port = inc->i_hdr.h_sport;
                         sin->sin_addr.s_addr = inc->i_saddr;
                         memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
-                        msg->msg_namelen = sizeof(*sin);
                 }
                 break;
         }
diff --git a/net/rds/send.c b/net/rds/send.c
index 88eace57dd6..aa57e22539e 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -31,13 +31,11 @@
  *
  */
 #include <linux/kernel.h>
-#include <linux/moduleparam.h>
 #include <linux/gfp.h>
 #include <net/sock.h>
 #include <linux/in.h>
 #include <linux/list.h>
 #include <linux/ratelimit.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
@@ -935,6 +933,7 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
         /* Mirror Linux UDP mirror of BSD error message compatibility */
         /* XXX: Perhaps MSG_MORE someday */
         if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_CMSG_COMPAT)) {
+                printk(KERN_INFO "msg_flags 0x%08X\n", msg->msg_flags);
                 ret = -EOPNOTSUPP;
                 goto out;
         }
@@ -1122,7 +1121,7 @@ rds_send_pong(struct rds_connection *conn, __be16 dport)
         rds_stats_inc(s_send_pong);
 
         if (!test_bit(RDS_LL_SEND_FULL, &conn->c_flags))
-                queue_delayed_work(rds_wq, &conn->c_send_w, 0);
+                rds_send_xmit(conn);
 
         rds_message_put(rm);
         return 0;
diff --git a/net/rds/stats.c b/net/rds/stats.c
index 7be790d60b9..10c759ccac0 100644
--- a/net/rds/stats.c
+++ b/net/rds/stats.c
@@ -33,7 +33,6 @@
 #include <linux/percpu.h>
 #include <linux/seq_file.h>
 #include <linux/proc_fs.h>
-#include <linux/export.h>
 
 #include "rds.h"
 
diff --git a/net/rds/sysctl.c b/net/rds/sysctl.c
index 907214b4c4d..25ad0c77a26 100644
--- a/net/rds/sysctl.c
+++ b/net/rds/sysctl.c
@@ -92,10 +92,17 @@ static ctl_table rds_sysctl_rds_table[] = {
         { }
 };
 
+static struct ctl_path rds_sysctl_path[] = {
+        { .procname = "net", },
+        { .procname = "rds", },
+        { }
+};
+
+
 void rds_sysctl_exit(void)
 {
         if (rds_sysctl_reg_table)
-                unregister_net_sysctl_table(rds_sysctl_reg_table);
+                unregister_sysctl_table(rds_sysctl_reg_table);
 }
 
 int rds_sysctl_init(void)
@@ -103,7 +110,7 @@ int rds_sysctl_init(void)
         rds_sysctl_reconnect_min = msecs_to_jiffies(1);
         rds_sysctl_reconnect_min_jiffies = rds_sysctl_reconnect_min;
 
-        rds_sysctl_reg_table = register_net_sysctl(&init_net,"net/rds", rds_sysctl_rds_table);
+        rds_sysctl_reg_table = register_sysctl_paths(rds_sysctl_path, rds_sysctl_rds_table);
         if (!rds_sysctl_reg_table)
                 return -ENOMEM;
         return 0;
diff --git a/net/rds/tcp.c b/net/rds/tcp.c
index edac9ef2bc8..8e0a32001c9 100644
--- a/net/rds/tcp.c
+++ b/net/rds/tcp.c
@@ -33,7 +33,6 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/in.h>
-#include <linux/module.h>
 #include <net/tcp.h>
 
 #include "rds.h"
diff --git a/net/rds/tcp_connect.c b/net/rds/tcp_connect.c
index a65ee78db0c..af95c8e058f 100644
--- a/net/rds/tcp_connect.c
+++ b/net/rds/tcp_connect.c
@@ -43,7 +43,7 @@ void rds_tcp_state_change(struct sock *sk)
         struct rds_connection *conn;
         struct rds_tcp_connection *tc;
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         conn = sk->sk_user_data;
         if (!conn) {
                 state_change = sk->sk_state_change;
@@ -68,7 +68,7 @@ void rds_tcp_state_change(struct sock *sk)
                         break;
         }
 out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
         state_change(sk);
 }
 
diff --git a/net/rds/tcp_listen.c b/net/rds/tcp_listen.c
index 7787537e9c2..8b5cc4aa886 100644
--- a/net/rds/tcp_listen.c
+++ b/net/rds/tcp_listen.c
@@ -114,7 +114,7 @@ void rds_tcp_listen_data_ready(struct sock *sk, int bytes)
 
         rdsdebug("listen data ready sk %p\n", sk);
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         ready = sk->sk_user_data;
         if (!ready) { /* check for teardown race */
                 ready = sk->sk_data_ready;
@@ -131,7 +131,7 @@ void rds_tcp_listen_data_ready(struct sock *sk, int bytes)
                 queue_work(rds_wq, &rds_tcp_listen_work);
 
 out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
         ready(sk, bytes);
 }
 
@@ -145,7 +145,7 @@ int rds_tcp_listen_init(void)
         if (ret < 0)
                 goto out;
 
-        sock->sk->sk_reuse = SK_CAN_REUSE;
+        sock->sk->sk_reuse = 1;
         rds_tcp_nonagle(sock);
 
         write_lock_bh(&sock->sk->sk_callback_lock);
diff --git a/net/rds/tcp_recv.c b/net/rds/tcp_recv.c
index 4fac4f2bb9d..78205e25500 100644
--- a/net/rds/tcp_recv.c
+++ b/net/rds/tcp_recv.c
@@ -169,6 +169,7 @@ static void rds_tcp_cong_recv(struct rds_connection *conn,
 struct rds_tcp_desc_arg {
         struct rds_connection *conn;
         gfp_t gfp;
+        enum km_type km;
 };
 
 static int rds_tcp_data_recv(read_descriptor_t *desc, struct sk_buff *skb,
@@ -254,7 +255,7 @@ static int rds_tcp_data_recv(read_descriptor_t *desc, struct sk_buff *skb,
                         else
                                 rds_recv_incoming(conn, conn->c_faddr,
                                                   conn->c_laddr, &tinc->ti_inc,
-                                                  arg->gfp);
+                                                  arg->gfp, arg->km);
 
                         tc->t_tinc_hdr_rem = sizeof(struct rds_header);
                         tc->t_tinc_data_rem = 0;
@@ -271,7 +272,8 @@ out:
 }
 
 /* the caller has to hold the sock lock */
-static int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp)
+static int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp,
+                             enum km_type km)
 {
         struct rds_tcp_connection *tc = conn->c_transport_data;
         struct socket *sock = tc->t_sock;
@@ -281,6 +283,7 @@ static int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp)
         /* It's like glib in the kernel! */
         arg.conn = conn;
         arg.gfp = gfp;
+        arg.km = km;
         desc.arg.data = &arg;
         desc.error = 0;
         desc.count = 1; /* give more than one skb per call */
@@ -308,7 +311,7 @@ int rds_tcp_recv(struct rds_connection *conn)
         rdsdebug("recv worker conn %p tc %p sock %p\n", conn, tc, sock);
 
         lock_sock(sock->sk);
-        ret = rds_tcp_read_sock(conn, GFP_KERNEL);
+        ret = rds_tcp_read_sock(conn, GFP_KERNEL, KM_USER0);
         release_sock(sock->sk);
 
         return ret;
@@ -322,7 +325,7 @@ void rds_tcp_data_ready(struct sock *sk, int bytes)
 
         rdsdebug("data ready sk %p bytes %d\n", sk, bytes);
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         conn = sk->sk_user_data;
         if (!conn) { /* check for teardown race */
                 ready = sk->sk_data_ready;
@@ -333,10 +336,10 @@ void rds_tcp_data_ready(struct sock *sk, int bytes)
         ready = tc->t_orig_data_ready;
         rds_tcp_stats_inc(s_tcp_data_ready_calls);
 
-        if (rds_tcp_read_sock(conn, GFP_ATOMIC) == -ENOMEM)
+        if (rds_tcp_read_sock(conn, GFP_ATOMIC, KM_SOFTIRQ0) == -ENOMEM)
                 queue_delayed_work(rds_wq, &conn->c_recv_w, 0);
 out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
         ready(sk, bytes);
 }
 
diff --git a/net/rds/tcp_send.c b/net/rds/tcp_send.c
index 81cf5a4c5e4..1b4fd68f0c7 100644
--- a/net/rds/tcp_send.c
+++ b/net/rds/tcp_send.c
@@ -174,7 +174,7 @@ void rds_tcp_write_space(struct sock *sk)
         struct rds_connection *conn;
         struct rds_tcp_connection *tc;
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         conn = sk->sk_user_data;
         if (!conn) {
                 write_space = sk->sk_write_space;
@@ -194,7 +194,7 @@ void rds_tcp_write_space(struct sock *sk)
                 queue_delayed_work(rds_wq, &conn->c_send_w, 0);
 
 out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 
         /*
          * write_space is only called when data leaves tcp's send queue if
diff --git a/net/rds/threads.c b/net/rds/threads.c
index 65eaefcab24..0fd90f8c5f5 100644
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -32,7 +32,6 @@
  */
 #include <linux/kernel.h>
 #include <linux/random.h>
-#include <linux/export.h>
 
 #include "rds.h"