Revert "net/rds: prioritize the base connection establishment"

This reverts commit 1bc87d23681a ("net/rds: prioritize the base connection
establishment"). This patch is reverted because the RDS path record caching
is replaced by the underlying ibacm path record caching. By doing so, all
the TOS connections can be established without depending on its base
connection to perform SA query. Thus, it is not required to prioritize
the base connection establishment.

Orabug: 26497333

Signed-off-by: Wei Lin Guay <wei.lin.guay@oracle.com>
Reviewed-by: Håkon Bugge <haakon.bugge@oracle.com>
Reviewed-by: Avinash Repaka <avinash.repaka@oracle.com>
Reviewed-by: Ajaykumar Hotchandani <ajaykumar.hotchandani@oracle.com>

diff --git a/net/rds/connection.c b/net/rds/connection.c
index 6e8f807694832e10672544db2daf55364fc47db7..6a565fe9f324c008ae57ca678fe27675dbd5b60c 100644 (file)
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -159,7 +159,7 @@ static void __rds_conn_path_init(struct rds_connection *conn,
        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_DELAYED_WORK(&cp->cp_down_w, rds_shutdown_worker);
+       INIT_WORK(&cp->cp_down_w, rds_shutdown_worker);
        mutex_init(&cp->cp_cm_lock);
        cp->cp_flags = 0;
 }
@@ -434,7 +434,7 @@ void rds_conn_shutdown(struct rds_conn_path *cp, int restart)
        rcu_read_lock();
        if (!hlist_unhashed(&conn->c_hash_node) && restart) {
                rcu_read_unlock();
-               rds_queue_reconnect(cp, DR_DEFAULT);
+               rds_queue_reconnect(cp);
        } else {
                rcu_read_unlock();
        }
@@ -455,7 +455,7 @@ static void rds_conn_path_destroy(struct rds_conn_path *cp, int shutdown)
                return;
 
        rds_conn_path_drop(cp, DR_CONN_DESTROY);
-       flush_delayed_work(&cp->cp_down_w);
+       flush_work(&cp->cp_down_w);
 
        /* now that conn down worker is flushed; there cannot be any
         * more posting of reconn timeout work. But cancel any already
@@ -871,7 +871,6 @@ void rds_conn_path_drop(struct rds_conn_path *cp, int reason)
        unsigned long now = get_seconds();
        struct rds_connection *conn = cp->cp_conn;
 
-       unsigned long delay = 0;
        cp->cp_drop_source = reason;
        if (rds_conn_path_state(cp) == RDS_CONN_UP) {
                cp->cp_reconnect_start = now;
@@ -911,16 +910,13 @@ void rds_conn_path_drop(struct rds_conn_path *cp, int reason)
 
        atomic_set(&cp->cp_state, RDS_CONN_ERROR);
 
-       if ((conn->c_tos && reason == DR_IB_ADDR_CHANGE) ||
-           reason == DR_IB_BASE_CONN_DOWN)
-               delay = msecs_to_jiffies(100);
        rds_rtd(RDS_RTD_CM_EXT,
                "RDS/%s: queueing shutdown work, conn %p, <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
                conn->c_trans->t_type == RDS_TRANS_TCP ? "TCP" : "IB",
                conn, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr),
                conn->c_tos);
 
-       queue_delayed_work(cp->cp_wq, &cp->cp_down_w, delay);
+       queue_work(cp->cp_wq, &cp->cp_down_w);
 }
 EXPORT_SYMBOL_GPL(rds_conn_path_drop);
 
@@ -941,18 +937,11 @@ void rds_conn_path_connect_if_down(struct rds_conn_path *cp)
 
        if (rds_conn_path_state(cp) == RDS_CONN_DOWN &&
            !test_and_set_bit(RDS_RECONNECT_PENDING, &cp->cp_flags)) {
-               if (conn->c_tos == 0 ||
-                   (conn->c_tos && rds_conn_state(cp->cp_base_conn) == RDS_CONN_UP)) {
                rds_rtd(RDS_RTD_CM_EXT,
                        "queueing connect work, conn %p, <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
                        conn, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr),
                        conn->c_tos);
                queue_delayed_work(cp->cp_wq, &cp->cp_conn_w, 0);
-               } else
-                       rds_rtd(RDS_RTD_CM_EXT,
-                               "skip, base conn %p down, conn %p, <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
-                               cp->cp_base_conn, conn, NIPQUAD(conn->c_laddr),
-                               NIPQUAD(conn->c_faddr), conn->c_tos);
        }
 }
 EXPORT_SYMBOL_GPL(rds_conn_path_connect_if_down);

diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index 437d83e25655aef8935b3fd51536f9b81f5e7ca4..3fcf0734920086e2828d59548642b662899de31b 100644 (file)
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -1115,24 +1115,9 @@ int rds_ib_conn_path_connect(struct rds_conn_path *cp)
        struct rds_connection *conn = cp->cp_conn;
        struct rds_ib_connection *ic = conn->c_transport_data;
        struct sockaddr_in src, dest;
-       int ret = 0;
+       int ret;
 
        conn->c_route_resolved = 0;
-
-       if (conn->c_tos) {
-                       mutex_lock(&conn->c_base_conn->c_cm_lock);
-                       if (!rds_conn_transition(conn->c_base_conn, RDS_CONN_UP,
-                                                RDS_CONN_UP)) {
-                               rds_rtd(RDS_RTD_CM_EXT,
-                                       "RDS/IB: base conn %p (%p) is not up\n",
-                                       conn->c_base_conn, conn);
-                               ret = DR_IB_BASE_CONN_DOWN;
-                       }
-                       mutex_unlock(&conn->c_base_conn->c_cm_lock);
-                       if (ret)
-                               goto out;
-       }
-
        /* 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,

diff --git a/net/rds/rds.h b/net/rds/rds.h
index d26eb01463e61514d53dbebeef43724c9e8af0e1..69ec690a99a5e31136980a4dd7cabaae6f03031f 100644 (file)
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -253,7 +253,7 @@ struct rds_conn_path {
        struct delayed_work     cp_reject_w;
        struct delayed_work     cp_hb_w;
        struct delayed_work     cp_reconn_w;
-       struct delayed_work     cp_down_w;
+       struct work_struct      cp_down_w;
        struct mutex            cp_cm_lock;     /* protect cp_state & cm */
        wait_queue_head_t       cp_waitq;
 
@@ -1141,7 +1141,7 @@ int rds_threads_init(void);
 void rds_threads_exit(void);
 extern struct workqueue_struct *rds_wq;
 extern struct workqueue_struct *rds_local_wq;
-void rds_queue_reconnect(struct rds_conn_path *cp, int reason);
+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 *);

diff --git a/net/rds/threads.c b/net/rds/threads.c
index f112359ff494a90246491509dd6114ea5cd8b47b..dc76c0c90df30760458f7ee19d47477b4951b9ee 100644 (file)
--- a/net/rds/threads.c
+++ b/net/rds/threads.c
@@ -130,16 +130,16 @@ EXPORT_SYMBOL_GPL(rds_connect_complete);
  * We should *always* start with a random backoff; otherwise a broken connection
  * will always take several iterations to be re-established.
  */
-void rds_queue_reconnect(struct rds_conn_path *cp, int reason)
+void rds_queue_reconnect(struct rds_conn_path *cp)
 {
        unsigned long rand;
        struct rds_connection *conn = cp->cp_conn;
        bool is_tcp = conn->c_trans->t_type == RDS_TRANS_TCP;
 
        rds_rtd(RDS_RTD_CM_EXT,
-               "conn %p for %pI4 to %pI4 tos %d reconnect jiffies %lu %s\n", conn,
+               "conn %p for %pI4 to %pI4 tos %d reconnect jiffies %lu\n", conn,
                &conn->c_laddr, &conn->c_faddr, conn->c_tos,
-               cp->cp_reconnect_jiffies, conn_drop_reason_str(reason));
+               cp->cp_reconnect_jiffies);
 
        /* let peer with smaller addr initiate reconnect, to avoid duels */
        if (is_tcp && !IS_CANONICAL(conn->c_laddr, conn->c_faddr))
@@ -198,8 +198,7 @@ void rds_connect_worker(struct work_struct *work)
                                                     RDS_CONN_DOWN)) {
                                rds_rtd(RDS_RTD_CM_EXT,
                                        "reconnecting..., conn %p\n", conn);
-                               rds_queue_reconnect(cp, ret == DR_IB_BASE_CONN_DOWN ?
-                                               DR_IB_BASE_CONN_DOWN : DR_DEFAULT);
+                               rds_queue_reconnect(cp);
                        } else {
                                rds_conn_path_drop(cp, DR_CONN_CONNECT_FAIL);
                        }
@@ -330,7 +329,7 @@ void rds_shutdown_worker(struct work_struct *work)
 {
        struct rds_conn_path *cp = container_of(work,
                                                struct rds_conn_path,
-                                               cp_down_w.work);
+                                               cp_down_w);
        unsigned long now = get_seconds();
        bool is_tcp = cp->cp_conn->c_trans->t_type == RDS_TRANS_TCP;
        struct rds_connection *conn = cp->cp_conn;