]> www.infradead.org Git - users/jedix/linux-maple.git/commitdiff
rds: port to UEK4, Linux-3.18*
authorAjaykumar Hotchandani <ajaykumar.hotchandani@oracle.com>
Fri, 23 Jan 2015 02:27:30 +0000 (18:27 -0800)
committerMukesh Kacker <mukesh.kacker@oracle.com>
Wed, 8 Jul 2015 20:12:41 +0000 (13:12 -0700)
Signed-off-by: Ajaykumar Hotchandani <ajaykumar.hotchandani@oracle.com>
28 files changed:
net/rds/af_rds.c
net/rds/bind.c
net/rds/connection.c
net/rds/ib.c
net/rds/ib.h
net/rds/ib_cm.c
net/rds/ib_rdma.c
net/rds/ib_recv.c
net/rds/ib_sysctl.c
net/rds/info.c
net/rds/iw.c
net/rds/iw.h
net/rds/iw_cm.c
net/rds/iw_recv.c
net/rds/iw_sysctl.c
net/rds/loop.c
net/rds/page.c
net/rds/rdma.c
net/rds/rdma_transport.c
net/rds/rds.h
net/rds/recv.c
net/rds/send.c
net/rds/sysctl.c
net/rds/tcp.h
net/rds/tcp_listen.c
net/rds/tcp_recv.c
net/rds/tcp_send.c
net/rds/xlist.h

index 01af7ddfe9171dc441cc5398b1090716160247a1..36ce70f138761087d786398df60646301d37bdd6 100644 (file)
@@ -718,10 +718,10 @@ static void rds_qos_threshold_init(void)
                        qos = simple_strtol(qos_str, &end, 0);
                        if (*end) {
                                printk(KERN_WARNING "RDS: Warning: QoS "
-                                       "%s is improperly formatted\n", qos);
+                                       "%s is improperly formatted\n", qos_str);
                        } else if (qos > 255) {
                                printk(KERN_WARNING "RDS: Warning: QoS "
-                                       "%s out of range\n", qos);
+                                       "%s out of range\n", qos_str);
                        }
                        threshold = parse_ul(threshold_str, (u32)~0);
                        rds_qos_threshold_tbl[qos] = threshold;
index 9f3a9df0dc1b9e7bcb04aadf4188da87c19e8685..02975163bd0652816fe46bb1050e4218e6b3280b 100644 (file)
@@ -54,12 +54,11 @@ static struct rds_sock *rds_bind_lookup(__be32 addr, __be16 port,
                                        struct rds_sock *insert)
 {
        struct rds_sock *rs;
-       struct hlist_node *node;
        struct hlist_head *head = hash_to_bucket(addr, port);
        u64 cmp;
        u64 needle = ((u64)be32_to_cpu(addr) << 32) | be16_to_cpu(port);
 
-       hlist_for_each_entry(rs, node, head, rs_bound_node) {
+       hlist_for_each_entry(rs, head, rs_bound_node) {
                cmp = ((u64)be32_to_cpu(rs->rs_bound_addr) << 32) |
                      be16_to_cpu(rs->rs_bound_port);
 
@@ -120,7 +119,7 @@ static int rds_add_bound(struct rds_sock *rs, __be32 addr, __be16 *port)
                rover = be16_to_cpu(*port);
                last = rover;
        } else {
-               rover = max_t(u16, net_random(), 2);
+               rover = max_t(u16, prandom_u32(), 2);
                last = rover - 1;
        }
 
index 71edccf40fc51fca98086d116893a728a8130407..b0ed223b97cbd6dec0493e5376895e1eef5d1418 100644 (file)
@@ -50,10 +50,16 @@ static struct kmem_cache *rds_conn_slab;
 
 static struct hlist_head *rds_conn_bucket(__be32 laddr, __be32 faddr)
 {
+       static u32 rds_hash_secret __read_mostly;
+
+       unsigned long hash;
+
+       net_get_random_once(&rds_hash_secret, sizeof(rds_hash_secret));
+
        /* Pass NULL, don't need struct net for hash */
-       unsigned long hash = inet_ehashfn(NULL,
-                                         be32_to_cpu(laddr), 0,
-                                         be32_to_cpu(faddr), 0);
+       hash = __inet_ehashfn(be32_to_cpu(laddr), 0,
+                       be32_to_cpu(faddr), 0,
+                       rds_hash_secret);
        return &rds_conn_hash[hash & RDS_CONNECTION_HASH_MASK];
 }
 
@@ -69,9 +75,8 @@ static struct rds_connection *rds_conn_lookup(struct hlist_head *head,
                                              u8 tos)
 {
        struct rds_connection *conn, *ret = NULL;
-       struct hlist_node *pos;
 
-       hlist_for_each_entry_rcu(conn, pos, head, c_hash_node) {
+       hlist_for_each_entry_rcu(conn, head, c_hash_node) {
                if (conn->c_faddr == faddr && conn->c_laddr == laddr &&
                                conn->c_tos == tos &&
                                conn->c_trans == trans) {
@@ -410,7 +415,6 @@ static void rds_conn_message_info(struct socket *sock, unsigned int len,
                                  int want_send)
 {
        struct hlist_head *head;
-       struct hlist_node *pos;
        struct list_head *list;
        struct rds_connection *conn;
        struct rds_message *rm;
@@ -424,7 +428,7 @@ static void rds_conn_message_info(struct socket *sock, unsigned int len,
 
        for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash);
             i++, head++) {
-               hlist_for_each_entry_rcu(conn, pos, head, c_hash_node) {
+               hlist_for_each_entry_rcu(conn, head, c_hash_node) {
                        if (want_send)
                                list = &conn->c_send_queue;
                        else
@@ -473,7 +477,6 @@ void rds_for_each_conn_info(struct socket *sock, unsigned int len,
 {
        uint64_t buffer[(item_len + 7) / 8];
        struct hlist_head *head;
-       struct hlist_node *pos;
        struct rds_connection *conn;
        size_t i;
 
@@ -484,7 +487,7 @@ void rds_for_each_conn_info(struct socket *sock, unsigned int len,
 
        for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash);
             i++, head++) {
-               hlist_for_each_entry_rcu(conn, pos, head, c_hash_node) {
+               hlist_for_each_entry_rcu(conn, head, c_hash_node) {
 
                        /* XXX no c_lock usage.. */
                        if (!visitor(conn, buffer))
index 9822c8ac3446409dfa3ec11b3d728594703bd2c6..3d6dc66df8f71409a023a577560e95ad47f6fd53 100644 (file)
@@ -311,7 +311,7 @@ static int rds_ib_laddr_check(__be32 addr)
        /* Create a CMA ID and try to bind it. This catches both
         * IB and iWARP capable NICs.
         */
-       cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
+       cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP, IB_QPT_RC);
        if (IS_ERR(cm_id))
                return -EADDRNOTAVAIL;
 
@@ -996,7 +996,7 @@ out:
 
 void rds_ib_ip_failover_groups_init(void)
 {
-       char *tok, *grp, *nxt_tok, *nxt_grp, *end;
+       char *tok, *grp, *nxt_tok, *nxt_grp;
        char str[1024];
        unsigned int    grp_id = 1;
        int i;
index 6e939b3d14015a00cf5706c122d9bd0d8abdfa4e..8799ddb371739679316940809fb86dc467611cc1 100644 (file)
@@ -557,6 +557,5 @@ extern unsigned long rds_ib_sysctl_max_unsig_wrs;
 extern unsigned long rds_ib_sysctl_max_unsig_bytes;
 extern unsigned long rds_ib_sysctl_max_recv_allocation;
 extern unsigned int rds_ib_sysctl_flow_control;
-extern ctl_table rds_ib_sysctl_table[];
 
 #endif
index ef88af4c4ae5197811373268e28791617c40cb33..b140d671e1b87064b45842e3c3eab0aadd31d61b 100644 (file)
@@ -1000,7 +1000,7 @@ int rds_ib_conn_connect(struct rds_connection *conn)
        /* XXX I wonder what affect the port space has */
        /* delegate cm event handler to rdma_transport */
        ic->i_cm_id = rdma_create_id(rds_rdma_cm_event_handler, conn,
-                                    RDMA_PS_TCP);
+                                    RDMA_PS_TCP, IB_QPT_RC);
        if (IS_ERR(ic->i_cm_id)) {
                ret = PTR_ERR(ic->i_cm_id);
                ic->i_cm_id = NULL;
@@ -1192,7 +1192,7 @@ void rds_ib_conn_shutdown(struct rds_connection *conn)
 
        ic->i_recvs = NULL;
 
-       INIT_COMPLETION(ic->i_last_wqe_complete);
+       reinit_completion(&ic->i_last_wqe_complete);
 
        ic->i_active_side = 0;
 }
index f59272e43372e1f02545099303869e3459b2a85a..1ac02fdb90a52743f4c6d4f0678fd1c30c645949 100644 (file)
@@ -544,7 +544,7 @@ static void __rds_ib_teardown_mr(struct rds_ib_mr *ibmr)
 
                        /* FIXME we need a way to tell a r/w MR
                         * from a r/o MR */
-                       WARN_ON_ONCE(page_mapping(page) && irqs_disabled());
+                       WARN_ON_ONCE(!page->mapping && irqs_disabled());
                        set_page_dirty(page);
                        put_page(page);
                }
index d7636d671877b8f3696cd417e2324604ca6f933f..a22d9097081e50203ee9092871e97a094113f94d 100644 (file)
@@ -514,7 +514,7 @@ static int acquire_refill(struct rds_connection *conn)
 static void release_refill(struct rds_connection *conn)
 {
        clear_bit(RDS_RECV_REFILL, &conn->c_flags);
-       smp_mb__after_clear_bit();
+       smp_mb__after_atomic();
        /*
         * We don't use wait_on_bit()/wake_up_bit() because our waking is in a
         * hot path and finding waiters is very rare.  We don't want to walk
@@ -830,7 +830,7 @@ void rds_ib_set_ack(struct rds_ib_connection *ic, u64 seq,
 {
        atomic64_set(&ic->i_ack_next, seq);
        if (ack_required) {
-               smp_mb__before_clear_bit();
+               smp_mb__before_atomic();
                set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
        }
 }
@@ -838,7 +838,7 @@ void rds_ib_set_ack(struct rds_ib_connection *ic, u64 seq,
 static u64 rds_ib_get_ack(struct rds_ib_connection *ic)
 {
        clear_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
-       smp_mb__after_clear_bit();
+       smp_mb__after_atomic();
 
        return atomic64_read(&ic->i_ack_next);
 }
@@ -999,7 +999,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), KM_SOFTIRQ0);
+               addr = kmap_atomic(sg_page(&frag->f_sg));
 
                src = addr + frag_off;
                dst = (void *)map->m_page_addrs[map_page] + map_off;
@@ -1009,7 +1009,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
                        uncongested |= ~(*src) & *dst;
                        *dst++ = *src++;
                }
-               kunmap_atomic(addr, KM_SOFTIRQ0);
+               kunmap_atomic(addr);
 
                copied += to_copy;
 
@@ -1142,8 +1142,7 @@ 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,
-                                         KM_SOFTIRQ0);
+                                         &ibinc->ii_inc, GFP_ATOMIC);
                        state->ack_next = be64_to_cpu(hdr->h_sequence);
                        state->ack_next_valid = 1;
                }
@@ -1240,8 +1239,7 @@ void rds_ib_srq_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,
-                                       KM_SOFTIRQ0);
+                                       &ibinc->ii_inc, GFP_ATOMIC);
 
                        state->ack_next = be64_to_cpu(hdr->h_sequence);
                        state->ack_next_valid = 1;
index 2cb2aa1439b8a91d11c9b4da3dbdf23d4db4af99..f5467cc13dc32e4780825b1061b8e0e5740826c2 100644 (file)
@@ -62,13 +62,13 @@ static unsigned long rds_ib_sysctl_max_unsig_wr_max = 64;
 
 unsigned int rds_ib_sysctl_flow_control = 0;
 
-ctl_table rds_ib_sysctl_table[] = {
+static struct ctl_table rds_ib_sysctl_table[] = {
        {
                .procname       = "max_send_wr",
                .data           = &rds_ib_sysctl_max_send_wr,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_ib_sysctl_max_wr_min,
                .extra2         = &rds_ib_sysctl_max_wr_max,
        },
@@ -77,7 +77,7 @@ ctl_table rds_ib_sysctl_table[] = {
                .data           = &rds_ib_sysctl_max_recv_wr,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_ib_sysctl_max_wr_min,
                .extra2         = &rds_ib_sysctl_max_wr_max,
        },
@@ -86,7 +86,7 @@ ctl_table rds_ib_sysctl_table[] = {
                .data           = &rds_ib_sysctl_max_unsig_wrs,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_ib_sysctl_max_unsig_wr_min,
                .extra2         = &rds_ib_sysctl_max_unsig_wr_max,
        },
@@ -95,34 +95,26 @@ ctl_table rds_ib_sysctl_table[] = {
                .data           = &rds_ib_sysctl_max_recv_allocation,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
        },
        {
                .procname       = "flow_control",
                .data           = &rds_ib_sysctl_flow_control,
                .maxlen         = sizeof(rds_ib_sysctl_flow_control),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        { }
 };
 
-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_sysctl_table(rds_ib_sysctl_hdr);
+       unregister_net_sysctl_table(rds_ib_sysctl_hdr);
 }
 
 int rds_ib_sysctl_init(void)
 {
-       rds_ib_sysctl_hdr = register_sysctl_paths(rds_ib_sysctl_path, rds_ib_sysctl_table);
+       rds_ib_sysctl_hdr = register_net_sysctl(&init_net, "net/rds/ib", rds_ib_sysctl_table);
        if (!rds_ib_sysctl_hdr)
                return -ENOMEM;
        return 0;
index 3dc8410173733ae9d2d931f6c409efb5ceaf4a2c..41be175c98e105af4625a599ea66190ba351dfda 100644 (file)
@@ -102,7 +102,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, KM_USER0);
+               kunmap_atomic(iter->addr);
                iter->addr = NULL;
        }
 }
@@ -117,7 +117,7 @@ void rds_info_copy(struct rds_info_iterator *iter, void *data,
 
        while (bytes) {
                if (!iter->addr)
-                       iter->addr = kmap_atomic(*iter->pages, KM_USER0);
+                       iter->addr = kmap_atomic(*iter->pages);
 
                this = min(bytes, PAGE_SIZE - iter->offset);
 
@@ -132,7 +132,7 @@ void rds_info_copy(struct rds_info_iterator *iter, void *data,
                iter->offset += this;
 
                if (iter->offset == PAGE_SIZE) {
-                       kunmap_atomic(iter->addr, KM_USER0);
+                       kunmap_atomic(iter->addr);
                        iter->addr = NULL;
                        iter->offset = 0;
                        iter->pages++;
index 13f4c4bc9df7e6b06e9f9e2f5187014d24dc3d07..bca67d0ff4afe90c07c15a84419849d9abf8f820 100644 (file)
@@ -225,7 +225,7 @@ static int rds_iw_laddr_check(__be32 addr)
        /* Create a CMA ID and try to bind it. This catches both
         * IB and iWARP capable NICs.
         */
-       cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
+       cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP, IB_QPT_RC);
        if (IS_ERR(cm_id))
                return -EADDRNOTAVAIL;
 
index d3a4adafcde9a8c0d4e117ccfc246edce9853e58..1e59190809c25be56c6eb0012afb3daa5f532a7a 100644 (file)
@@ -378,7 +378,6 @@ extern unsigned long rds_iw_sysctl_max_unsig_wrs;
 extern unsigned long rds_iw_sysctl_max_unsig_bytes;
 extern unsigned long rds_iw_sysctl_max_recv_allocation;
 extern unsigned int rds_iw_sysctl_flow_control;
-extern ctl_table rds_iw_sysctl_table[];
 
 /*
  * Helper functions for getting/setting the header and data SGEs in
index f80dac1ff1b16e86dcbe89fb4efc94d46aa306ff..5be52ba4f8359c696c660fe2ed849a31ef926ae2 100644 (file)
@@ -520,7 +520,7 @@ int rds_iw_conn_connect(struct rds_connection *conn)
        /* XXX I wonder what affect the port space has */
        /* delegate cm event handler to rdma_transport */
        ic->i_cm_id = rdma_create_id(rds_rdma_cm_event_handler, conn,
-                                    RDMA_PS_TCP);
+                                    RDMA_PS_TCP, IB_QPT_RC);
        if (IS_ERR(ic->i_cm_id)) {
                ret = PTR_ERR(ic->i_cm_id);
                ic->i_cm_id = NULL;
index bedba05864c9a334037f4d5fd0a8a510c548453f..b1b3aa66c30d0f804ac6a5508eb848d81466dbbc 100644 (file)
@@ -428,7 +428,7 @@ static void rds_iw_set_ack(struct rds_iw_connection *ic, u64 seq,
 {
        atomic64_set(&ic->i_ack_next, seq);
        if (ack_required) {
-               smp_mb__before_clear_bit();
+               smp_mb__before_atomic();
                set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
        }
 }
@@ -436,7 +436,7 @@ static void rds_iw_set_ack(struct rds_iw_connection *ic, u64 seq,
 static u64 rds_iw_get_ack(struct rds_iw_connection *ic)
 {
        clear_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
-       smp_mb__after_clear_bit();
+       smp_mb__after_atomic();
 
        return atomic64_read(&ic->i_ack_next);
 }
@@ -597,7 +597,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, KM_SOFTIRQ0);
+               addr = kmap_atomic(frag->f_page);
 
                src = addr + frag_off;
                dst = (void *)map->m_page_addrs[map_page] + map_off;
@@ -607,7 +607,7 @@ static void rds_iw_cong_recv(struct rds_connection *conn,
                        uncongested |= ~(*src) & *dst;
                        *dst++ = *src++;
                }
-               kunmap_atomic(addr, KM_SOFTIRQ0);
+               kunmap_atomic(addr);
 
                copied += to_copy;
 
@@ -753,8 +753,7 @@ 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,
-                                         KM_SOFTIRQ0);
+                                         &iwinc->ii_inc, GFP_ATOMIC);
                        state->ack_next = be64_to_cpu(hdr->h_sequence);
                        state->ack_next_valid = 1;
                }
index c5ed1c37a7bb1b55254742e93745db987d574eea..139239d2cb228438e29f347b33035da15d5396c0 100644 (file)
@@ -55,13 +55,13 @@ static unsigned long rds_iw_sysctl_max_unsig_bytes_max = ~0UL;
 
 unsigned int rds_iw_sysctl_flow_control = 1;
 
-ctl_table rds_iw_sysctl_table[] = {
+static struct ctl_table rds_iw_sysctl_table[] = {
        {
                .procname       = "max_send_wr",
                .data           = &rds_iw_sysctl_max_send_wr,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_iw_sysctl_max_wr_min,
                .extra2         = &rds_iw_sysctl_max_wr_max,
        },
@@ -70,7 +70,7 @@ ctl_table rds_iw_sysctl_table[] = {
                .data           = &rds_iw_sysctl_max_recv_wr,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_iw_sysctl_max_wr_min,
                .extra2         = &rds_iw_sysctl_max_wr_max,
        },
@@ -79,7 +79,7 @@ ctl_table rds_iw_sysctl_table[] = {
                .data           = &rds_iw_sysctl_max_unsig_wrs,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_iw_sysctl_max_unsig_wr_min,
                .extra2         = &rds_iw_sysctl_max_unsig_wr_max,
        },
@@ -88,7 +88,7 @@ ctl_table rds_iw_sysctl_table[] = {
                .data           = &rds_iw_sysctl_max_unsig_bytes,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
                .extra1         = &rds_iw_sysctl_max_unsig_bytes_min,
                .extra2         = &rds_iw_sysctl_max_unsig_bytes_max,
        },
@@ -97,34 +97,26 @@ ctl_table rds_iw_sysctl_table[] = {
                .data           = &rds_iw_sysctl_max_recv_allocation,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_minmax,
+               .proc_handler   = proc_doulongvec_minmax,
        },
        {
                .procname       = "flow_control",
                .data           = &rds_iw_sysctl_flow_control,
                .maxlen         = sizeof(rds_iw_sysctl_flow_control),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        { }
 };
 
-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_sysctl_table(rds_iw_sysctl_hdr);
+       unregister_net_sysctl_table(rds_iw_sysctl_hdr);
 }
 
 int rds_iw_sysctl_init(void)
 {
-       rds_iw_sysctl_hdr = register_sysctl_paths(rds_iw_sysctl_path, rds_iw_sysctl_table);
+       rds_iw_sysctl_hdr = register_net_sysctl(&init_net, "net/rds/iw", rds_iw_sysctl_table);
        if (!rds_iw_sysctl_hdr)
                return -ENOMEM;
        return 0;
index 640f669e745d6180f7a6c470381085eb11417a58..272acad9722434c678a30dfb4bbb6daffd5bcf48 100644 (file)
@@ -73,7 +73,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, KM_USER0);
+                         GFP_KERNEL);
 
        rds_send_drop_acked(conn, be64_to_cpu(rm->m_inc.i_hdr.h_sequence),
                            NULL);
index fe5adbb5aa4172a1842fda952447d2406f4f6789..fad4f8cf7a71b16bb7b4619c7281722edd9f2d86 100644 (file)
@@ -31,6 +31,7 @@
  *
  */
 #include <linux/highmem.h>
+#include <linux/cpu.h>
 
 #include "rds.h"
 
@@ -69,12 +70,12 @@ int rds_page_copy_user(struct page *page, unsigned long offset,
        else
                rds_stats_add(s_copy_from_user, bytes);
 
-       addr = kmap_atomic(page, KM_USER0);
+       addr = kmap_atomic(page);
        if (to_user)
                ret = __copy_to_user_inatomic(ptr, addr + offset, bytes);
        else
                ret = __copy_from_user_inatomic(addr + offset, ptr, bytes);
-       kunmap_atomic(addr, KM_USER0);
+       kunmap_atomic(addr);
 
        if (ret) {
                addr = kmap(page);
index 6dd7bb7e9ea9284a1d55b66ae32c9859c9e29728..fd1f0f71dd44663ab1b0a286a21739b4c50a0495 100644 (file)
@@ -450,7 +450,7 @@ void rds_rdma_free_op(struct rm_rdma_op *ro)
                 * is the case for a RDMA_READ which copies from remote
                 * to local memory */
                if (!ro->op_write) {
-                       WARN_ON_ONCE(page_mapping(page) && irqs_disabled());
+                       WARN_ON_ONCE(!page->mapping && irqs_disabled());
                        set_page_dirty(page);
                }
                put_page(page);
index 53a0300023ece5a27a62f935c24eb442b267118a..c24b640801f94e91f819be16183b2b2381bbd33f 100644 (file)
@@ -204,7 +204,8 @@ static int rds_rdma_listen_init(void)
        struct rdma_cm_id *cm_id;
        int ret;
 
-       cm_id = rdma_create_id(rds_rdma_cm_event_handler, NULL, RDMA_PS_TCP);
+       cm_id = rdma_create_id(rds_rdma_cm_event_handler, NULL, RDMA_PS_TCP,
+                              IB_QPT_RC);
        if (IS_ERR(cm_id)) {
                ret = PTR_ERR(cm_id);
                printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
index d2c2fe19021db5a211fdfc39ed0d906fdf615c2e..6c44c38f3467b2db012cd87e04f9d8ba62daaa32 100644 (file)
@@ -6,7 +6,9 @@
 #include <linux/highmem.h>
 #include <rdma/rdma_cm.h>
 #include <linux/mutex.h>
-#include <linux/rds.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <uapi/linux/rds.h>
 
 #include "info.h"
 
@@ -744,7 +746,7 @@ void rds_inc_init(struct rds_incoming *inc, struct rds_connection *conn,
 void rds_inc_addref(struct rds_incoming *inc);
 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, enum km_type km);
+                      struct rds_incoming *inc, gfp_t gfp);
 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);
index a298aadc2fd45ca0aee04b6c9dfadd16af9b9c0d..cd25beb6870174c89398a18cc8b338d7a8e46c12 100644 (file)
@@ -154,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, enum km_type km)
+                      struct rds_incoming *inc, gfp_t gfp)
 {
        struct rds_sock *rs = NULL;
        struct sock *sk;
index 8d454bd0576e2267ba5899ae78553a3a0a575e65..f1408f39cbe96162bd7ee057396969b6944efe0e 100644 (file)
@@ -155,7 +155,7 @@ static int acquire_in_xmit(struct rds_connection *conn)
 static void release_in_xmit(struct rds_connection *conn)
 {
        clear_bit(RDS_IN_XMIT, &conn->c_flags);
-       smp_mb__after_clear_bit();
+       smp_mb__after_atomic();
        /*
         * We don't use wait_on_bit()/wake_up_bit() because our waking is in a
         * hot path and finding waiters is very rare.  We don't want to walk
@@ -851,7 +851,7 @@ void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
 
        /* order flag updates with spin locks */
        if (!list_empty(&list))
-               smp_mb__after_clear_bit();
+               smp_mb__after_atomic();
 
        spin_unlock_irqrestore(&conn->c_lock, flags);
 
@@ -881,7 +881,7 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)
        }
 
        /* order flag updates with the rs lock */
-       smp_mb__after_clear_bit();
+       smp_mb__after_atomic();
 
        spin_unlock_irqrestore(&rs->rs_lock, flags);
 
@@ -1232,8 +1232,6 @@ int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
 
        /* Attach data to the rm */
        if (payload_len) {
-               struct user_hdr *uhdr = msg->msg_iov->iov_base;
-
                rm->data.op_sg = rds_message_alloc_sgs(rm, ceil(payload_len, PAGE_SIZE));
                ret = rds_message_copy_from_user(rm, msg->msg_iov, payload_len);
                if (ret)
index 0505bda27a45dc2633d895df3b5b60d3bda352bb..4716649d8c2dbd34271100a848d12f05e24741e9 100644 (file)
@@ -56,13 +56,13 @@ unsigned int rds_sysctl_ping_enable = 1;
 static int rds_sysctl_pf_rds = PF_RDS;
 static int rds_sysctl_sol_rds = SOL_RDS;
 
-static ctl_table rds_sysctl_rds_table[] = {
+static struct ctl_table rds_sysctl_rds_table[] = {
        {
                .procname       = "reconnect_min_delay_ms",
                .data           = &rds_sysctl_reconnect_min_jiffies,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+               .proc_handler   = proc_doulongvec_ms_jiffies_minmax,
                .extra1         = &rds_sysctl_reconnect_min,
                .extra2         = &rds_sysctl_reconnect_max_jiffies,
        },
@@ -71,7 +71,7 @@ static ctl_table rds_sysctl_rds_table[] = {
                .data           = &rds_sysctl_reconnect_max_jiffies,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
+               .proc_handler   = proc_doulongvec_ms_jiffies_minmax,
                .extra1         = &rds_sysctl_reconnect_min_jiffies,
                .extra2         = &rds_sysctl_reconnect_max,
        },
@@ -80,50 +80,42 @@ static ctl_table rds_sysctl_rds_table[] = {
                .data           = &rds_sysctl_pf_rds,
                .maxlen         = sizeof(int),
                .mode           = 0444,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
                .procname       = "sol_rds",
                .data           = &rds_sysctl_sol_rds,
                .maxlen         = sizeof(int),
                .mode           = 0444,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
                .procname       = "max_unacked_packets",
                .data           = &rds_sysctl_max_unacked_packets,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
                .procname       = "max_unacked_bytes",
                .data           = &rds_sysctl_max_unacked_bytes,
                .maxlen         = sizeof(unsigned long),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        {
                .procname       = "ping_enable",
                .data           = &rds_sysctl_ping_enable,
                .maxlen         = sizeof(int),
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .proc_handler   = proc_dointvec,
        },
        { }
 };
 
-static struct ctl_path rds_sysctl_path[] = {
-       { .procname = "net", },
-       { .procname = "rds", },
-       { }
-};
-
-
 void rds_sysctl_exit(void)
 {
-       if (rds_sysctl_reg_table)
-               unregister_sysctl_table(rds_sysctl_reg_table);
+       unregister_net_sysctl_table(rds_sysctl_reg_table);
 }
 
 int rds_sysctl_init(void)
@@ -131,7 +123,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_sysctl_paths(rds_sysctl_path, rds_sysctl_rds_table);
+       rds_sysctl_reg_table = register_net_sysctl(&init_net, "net/rds", rds_sysctl_rds_table);
        if (!rds_sysctl_reg_table)
                return -ENOMEM;
        return 0;
index 9421ad4b9100ca62c5424d5396b07a37abcc682f..8b1975b54a02e0c5c40f306cf4bd07fa20ea14a1 100644 (file)
@@ -63,12 +63,12 @@ void rds_tcp_state_change(struct sock *sk);
 /* tcp_listen.c */
 int rds_tcp_listen_init(void);
 void rds_tcp_listen_stop(void);
-void rds_tcp_listen_data_ready(struct sock *sk, int bytes);
+void rds_tcp_listen_data_ready(struct sock *sk);
 
 /* tcp_recv.c */
 int rds_tcp_recv_init(void);
 void rds_tcp_recv_exit(void);
-void rds_tcp_data_ready(struct sock *sk, int bytes);
+void rds_tcp_data_ready(struct sock *sk);
 int rds_tcp_recv(struct rds_connection *conn);
 void rds_tcp_inc_free(struct rds_incoming *inc);
 int rds_tcp_inc_copy_to_user(struct rds_incoming *inc, struct iovec *iov,
index b61efbd1bf75809e391f2d800714fb5122037a93..2f9ed7c151ada851c045ba0c4f97e59f709db15f 100644 (file)
@@ -107,9 +107,9 @@ static void rds_tcp_accept_worker(struct work_struct *work)
                cond_resched();
 }
 
-void rds_tcp_listen_data_ready(struct sock *sk, int bytes)
+void rds_tcp_listen_data_ready(struct sock *sk)
 {
-       void (*ready)(struct sock *sk, int bytes);
+       void (*ready)(struct sock *sk);
 
        rdsdebug("listen data ready sk %p\n", sk);
 
@@ -131,7 +131,7 @@ void rds_tcp_listen_data_ready(struct sock *sk, int bytes)
 
 out:
        read_unlock(&sk->sk_callback_lock);
-       ready(sk, bytes);
+       ready(sk);
 }
 
 int rds_tcp_listen_init(void)
index 19056f1cfbb67d91158f89fcb8e6139fc430d5a3..7cbe929153c8b63323ccf11f3b6a7545f31fd48a 100644 (file)
@@ -168,7 +168,6 @@ 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 +253,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->km);
+                                                 arg->gfp);
 
                        tc->t_tinc_hdr_rem = sizeof(struct rds_header);
                        tc->t_tinc_data_rem = 0;
@@ -271,7 +270,7 @@ out:
 }
 
 /* the caller has to hold the sock lock */
-int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp, enum km_type km)
+int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp)
 {
        struct rds_tcp_connection *tc = conn->c_transport_data;
        struct socket *sock = tc->t_sock;
@@ -281,7 +280,6 @@ int rds_tcp_read_sock(struct rds_connection *conn, gfp_t gfp, enum km_type km)
        /* 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 */
@@ -309,19 +307,19 @@ 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, KM_USER0);
+       ret = rds_tcp_read_sock(conn, GFP_KERNEL);
        release_sock(sock->sk);
 
        return ret;
 }
 
-void rds_tcp_data_ready(struct sock *sk, int bytes)
+void rds_tcp_data_ready(struct sock *sk)
 {
-       void (*ready)(struct sock *sk, int bytes);
+       void (*ready)(struct sock *sk);
        struct rds_connection *conn;
        struct rds_tcp_connection *tc;
 
-       rdsdebug("data ready sk %p bytes %d\n", sk, bytes);
+       rdsdebug("data ready sk %p\n", sk);
 
        read_lock(&sk->sk_callback_lock);
        conn = sk->sk_user_data;
@@ -334,11 +332,11 @@ 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, KM_SOFTIRQ0) == -ENOMEM)
+       if (rds_tcp_read_sock(conn, GFP_ATOMIC) == -ENOMEM)
                queue_delayed_work(rds_wq, &conn->c_recv_w, 0);
 out:
        read_unlock(&sk->sk_callback_lock);
-       ready(sk, bytes);
+       ready(sk);
 }
 
 int rds_tcp_recv_init(void)
index 017aa83c140079e1dcebdc3441c0a2d48d04acd8..850a2cfb82521f099ef58d00515a9102f9b1d6f3 100644 (file)
@@ -93,7 +93,7 @@ int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
                rm->m_ack_seq = tc->t_last_sent_nxt +
                                sizeof(struct rds_header) +
                                be32_to_cpu(rm->m_inc.i_hdr.h_len) - 1;
-               smp_mb__before_clear_bit();
+               smp_mb__before_atomic();
                set_bit(RDS_MSG_HAS_ACK_SEQ, &rm->m_flags);
                tc->t_last_expected_una = rm->m_ack_seq + 1;
 
index e6b5190dadddc7307d80bc0bc87bc2dc4436ded6..9e1e9cec03e6a8c5630aab328b4837e30a1eb92e 100644 (file)
@@ -4,7 +4,6 @@
 #include <linux/stddef.h>
 #include <linux/poison.h>
 #include <linux/prefetch.h>
-#include <asm/system.h>
 
 struct xlist_head {
        struct xlist_head *next;