Revert "RDS: base connection dependency needed for rolling downgrade from version...

This commit partially revert commit 5e86bae96237 ("RDMA CM: Add reason code
for IB_CM_REJ_CONSUMER_DEFINED") as it contains two changes in a single
commit. The rolling downgrade support from 4.1 to 3.1 is no longer needed
because there is no practical use case for this feature. This commit removes
the base connection dependency for rolling downgrade, or changes the code
back to its original form before 5e86bae96237. The clean-up of the RDS
backward compatibility issue is not addresssed in this patch, and please
refer to bugdb #26772473 for more details.

Orabug: 26124147

Suggested-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>
Signed-off-by: Wei Lin Guay <wei.lin.guay@oracle.com>
Reviewed-by: Ajaykumar Hotchandani <ajaykumar.hotchandani@oracle.com>

diff --git a/net/rds/connection.c b/net/rds/connection.c
index d476d59051978cc31f9db4d7990e314a9c8560c5..d6d3d1dcb04b63a59692e29f4216d1f2d0dc655c 100644 (file)
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -157,7 +157,6 @@ static void __rds_conn_path_init(struct rds_connection *conn,
        INIT_DELAYED_WORK(&cp->cp_conn_w, rds_connect_worker);
        INIT_DELAYED_WORK(&cp->cp_hb_w, rds_hb_worker);
        INIT_DELAYED_WORK(&cp->cp_reconn_w, rds_reconnect_timeout);
-       INIT_DELAYED_WORK(&cp->cp_reject_w, rds_reject_worker);
        INIT_WORK(&cp->cp_down_w, rds_shutdown_worker);
        mutex_init(&cp->cp_cm_lock);
        cp->cp_flags = 0;
@@ -368,7 +367,7 @@ struct rds_connection *rds_conn_find(struct net *net, __be32 laddr,
 }
 EXPORT_SYMBOL_GPL(rds_conn_find);
 
-void rds_conn_shutdown(struct rds_conn_path *cp, int restart)
+void rds_conn_shutdown(struct rds_conn_path *cp)
 {
        struct rds_connection *conn = cp->cp_conn;
 
@@ -434,7 +433,7 @@ void rds_conn_shutdown(struct rds_conn_path *cp, int restart)
         * conn - the reconnect is always triggered by the active peer. */
        cancel_delayed_work_sync(&cp->cp_conn_w);
        rcu_read_lock();
-       if (!hlist_unhashed(&conn->c_hash_node) && restart) {
+       if (!hlist_unhashed(&conn->c_hash_node)) {
                rcu_read_unlock();
                rds_queue_reconnect(cp);
        } else {

diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index 9ab0471d5ba11c77ada6a860eefba635195506fd..69f81c2a550b220cfe3d4cd2af96c3bb38384641 100644 (file)
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -878,16 +878,6 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
        conn->c_acl_en = acl_ret;
        conn->c_acl_init = 1;
 
-       if (dp->dp_tos && !conn->c_base_conn) {
-               conn->c_base_conn = rds_conn_create(&init_net,
-                                       dp->dp_daddr, dp->dp_saddr,
-                                       &rds_ib_transport, 0, GFP_KERNEL);
-               if (IS_ERR(conn->c_base_conn)) {
-                       conn = NULL;
-                       goto out;
-               }
-       }
-
        /*
         * The connection request may occur while the
         * previous connection exist, e.g. in case of failover.

diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index 6c1578ed9718859945f8af3ca07f6a705666602f..3ca32fc165d3850374a380a81f50d822a1b72a02 100644 (file)
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -237,16 +237,11 @@ int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
                                pr_warn("Rejected: CSR_DEF err 0, calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
                                        NIPQUAD(conn->c_laddr),
                                        NIPQUAD(conn->c_faddr), conn->c_tos);
-                               if (!conn->c_tos) {
+                               if (!conn->c_tos)
                                        conn->c_proposed_version =
                                                RDS_PROTOCOL_COMPAT_VERSION;
-                                       rds_conn_drop(conn,
-                                               DR_IB_CONSUMER_DEFINED_REJ);
-                               } else  {
-                                       queue_delayed_work(conn->c_path[0].cp_wq,
-                                                          &conn->c_reject_w,
-                                                          msecs_to_jiffies(10));
-                               }
+                               rds_conn_drop(conn,
+                                       DR_IB_CONSUMER_DEFINED_REJ);
                        } else if (event->status == RDS_REJ_CONSUMER_DEFINED &&
                                   (*err) == RDS_ACL_FAILURE) {
                                /* Rejection due to ACL violation */

diff --git a/net/rds/rds.h b/net/rds/rds.h
index 623e5d1806a82c9ad285b094f94ef6d7d1943551..76c8f190d7f93fc301519c3e6d7fa8340aec5aee 100644 (file)
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -249,7 +249,6 @@ struct rds_conn_path {
        struct delayed_work     cp_send_w;
        struct delayed_work     cp_recv_w;
        struct delayed_work     cp_conn_w;
-       struct delayed_work     cp_reject_w;
        struct delayed_work     cp_hb_w;
        struct delayed_work     cp_reconn_w;
        struct work_struct      cp_down_w;
@@ -279,10 +278,6 @@ struct rds_conn_path {
 
        unsigned long           cp_hb_start;
 
-       struct rds_connection   *cp_base_conn;
-
-       unsigned int            cp_route_to_base;
-
        unsigned int            cp_rdsinfo_pending;
 
        unsigned int            cp_reconnect_racing;
@@ -898,7 +893,7 @@ struct rds_connection *rds_conn_create_outgoing(struct net *net,
 struct rds_connection *rds_conn_find(struct net *net, __be32 laddr,
                                     __be32 faddr,
                                        struct rds_transport *trans, u8 tos);
-void rds_conn_shutdown(struct rds_conn_path *cp, int restart);
+void rds_conn_shutdown(struct rds_conn_path *cp);
 void rds_conn_destroy(struct rds_connection *conn, int shutdown);
 void rds_conn_reset(struct rds_connection *conn);
 void rds_conn_drop(struct rds_connection *conn, int reason);
@@ -1058,7 +1053,6 @@ struct rds_message *rds_send_get_message(struct rds_connection *,
                                         struct rm_rdma_op *);
 int rds_send_internal(struct rds_connection *conn, struct rds_sock *rs,
                      struct sk_buff *skb, gfp_t gfp);
-void rds_route_to_base(struct rds_connection *conn);
 
 extern unsigned int rds_async_send_enabled;
 
@@ -1136,7 +1130,6 @@ void rds_queue_reconnect(struct rds_conn_path *cp);
 void rds_connect_worker(struct work_struct *);
 void rds_shutdown_worker(struct work_struct *);
 void rds_send_worker(struct work_struct *);
-void rds_reject_worker(struct work_struct *);
 void rds_recv_worker(struct work_struct *);
 void rds_hb_worker(struct work_struct *);
 void rds_reconnect_timeout(struct work_struct *);

diff --git a/net/rds/rds_single_path.h b/net/rds/rds_single_path.h
index 314c7a57e50fe2ec8b0edef9c595ce81afc3c4cc..4b6f6398eb8808f994bd4732e46424cf4e1dc452 100644 (file)
--- a/net/rds/rds_single_path.h
+++ b/net/rds/rds_single_path.h
@@ -36,9 +36,7 @@
 #define c_reconn_flags         c_path[0].cp_reconn_flags
 #define c_reconnect            c_path[0].cp_reconnect
 #define c_to_index             c_path[0].cp_to_index
-#define c_base_conn            c_path[0].cp_base_conn
 #define c_acl_en               c_path[0].cp_acl_en
 #define c_reconnect_err                c_path[0].cp_reconnect_err
-#define c_reject_w             c_path[0].cp_reject_w
 
 #endif /* _RDS_RDS_SINGLE_H */

diff --git a/net/rds/send.c b/net/rds/send.c
index b907486cb9e4694b76b23d546b4ccd898cdbd9b7..325cae8f55d083b6a2a28ba1ad0ebeee02e84a11 100644 (file)
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -1305,45 +1305,9 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
                        ret = PTR_ERR(conn);
                        goto out;
                }
-
-               if (rs->rs_tos && !conn->c_path[0].cp_base_conn) {
-                       struct rds_conn_path *cp0 = &conn->c_path[0];
-
-                       WARN_ON(conn->c_trans->t_mp_capable);
-                       cp0->cp_base_conn = rds_conn_create_outgoing(
-                                       sock_net(sock->sk),
-                                       rs->rs_bound_addr, daddr,
-                                       rs->rs_transport, 0,
-                                       sock->sk->sk_allocation);
-                       if (IS_ERR(cp0->cp_base_conn)) {
-                               ret = PTR_ERR(cp0->cp_base_conn);
-                               goto out;
-                       }
-                       rds_rtd(RDS_RTD_CM_EXT, "checking conn %p\n",
-                               cp0->cp_base_conn);
-                       rds_conn_connect_if_down(cp0->cp_base_conn);
-               }
                rs->rs_conn = conn;
        }
 
-       if (conn->c_tos && !rds_conn_up(conn)) {
-               struct rds_conn_path *cp0 = &conn->c_path[0];
-
-               WARN_ON(conn->c_trans->t_mp_capable);
-               if (!rds_conn_up(cp0->cp_base_conn)) {
-                       ret = -EAGAIN;
-                       goto out;
-               } else if (cp0->cp_base_conn->c_version ==
-                               RDS_PROTOCOL_COMPAT_VERSION) {
-                       if (!cp0->cp_reconnect || cp0->cp_route_to_base)
-                               conn = cp0->cp_base_conn;
-                       else {
-                               ret = -EAGAIN;
-                               goto out;
-                       }
-               }
-       }
-
        /* Parse any control messages the user may have included. */
        ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
        if (ret) {
@@ -1691,31 +1655,6 @@ rds_send_hb(struct rds_connection *conn, int response)
        return 0;
 }
 
-void rds_route_to_base(struct rds_connection *conn)
-{
-       struct rds_message *rm, *tmp;
-       struct rds_conn_path *cp = &conn->c_path[0];
-       struct rds_connection *base_conn = cp->cp_base_conn;
-       unsigned long flags;
-
-       WARN_ON(conn->c_trans->t_mp_capable);
-       BUG_ON(!conn->c_tos || rds_conn_up(conn) || !base_conn ||
-               !list_empty(&cp->cp_retrans));
-
-       spin_lock_irqsave(&base_conn->c_path[0].cp_lock, flags);
-       list_for_each_entry_safe(rm, tmp, &cp->cp_send_queue, m_conn_item) {
-               list_del_init(&rm->m_conn_item);
-               rm->m_inc.i_conn = base_conn;
-               rm->m_inc.i_hdr.h_sequence =
-                       cpu_to_be64(base_conn->c_path[0].cp_next_tx_seq++);
-               list_add_tail(&rm->m_conn_item,
-                             &base_conn->c_path[0].cp_send_queue);
-       }
-       spin_unlock_irqrestore(&base_conn->c_path[0].cp_lock, flags);
-       cp->cp_route_to_base = 1;
-       queue_delayed_work(rds_wq, &base_conn->c_path[0].cp_send_w, 0);
-}
-
 int
 rds_send_pong(struct rds_conn_path *cp, __be16 dport)
 {

diff --git a/net/rds/threads.c b/net/rds/threads.c
index 28b2f03948320ef4bb979a97c9b40ac6e8b995ff..b49889cf7407eae7205a2c5a6c84385e5aded322 100644 (file)
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -104,7 +104,6 @@ void rds_connect_path_complete(struct rds_conn_path *cp, int curr)
        cp->cp_connection_start = get_seconds();
        cp->cp_reconnect = 1;
        conn->c_proposed_version = RDS_PROTOCOL_VERSION;
-       cp->cp_route_to_base = 0;
 }
 EXPORT_SYMBOL_GPL(rds_connect_path_complete);
 
@@ -263,20 +262,6 @@ void rds_recv_worker(struct work_struct *work)
        }
 }
 
-void rds_reject_worker(struct work_struct *work)
-{
-       struct rds_conn_path *cp = container_of(work,
-                                               struct rds_conn_path,
-                                               cp_reject_w.work);
-
-       WARN_ON(cp->cp_conn->c_trans->t_mp_capable);
-       atomic_set(&cp->cp_state, RDS_CONN_ERROR);
-       rds_rtd(RDS_RTD_CM, "calling rds_conn_shutdown, conn %p:0\n",
-               cp->cp_conn);
-       rds_conn_shutdown(cp, 0);
-       rds_route_to_base(cp->cp_conn);
-}
-
 void rds_hb_worker(struct work_struct *work)
 {
        struct rds_conn_path *cp = container_of(work,
@@ -365,7 +350,7 @@ void rds_shutdown_worker(struct work_struct *work)
                                conn->c_tos,
                                conn_drop_reason_str(cp->cp_drop_source));
 
-       rds_conn_shutdown(cp, 1);
+       rds_conn_shutdown(cp);
 }
 
 void rds_threads_exit(void)