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

This reverts commit 1bc87d2 ("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 <[email protected]>

Reviewed-by: Håkon Bugge <[email protected]>
Reviewed-by: Avinash Repaka <[email protected]>
Reviewed-by: Ajaykumar Hotchandani <[email protected]>

Orabug: 27364391

(cherry picked from commit d5c9b79)
cherry-pick-repo=linux-uek.git

Conflicts:
	net/rds/connection.c

Signed-off-by: Gerd Rausch <[email protected]>
Signed-off-by: Somasundaram Krishnasamy <[email protected]>

Author: Wei Lin Guay

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, <%pI4,%pI4,%d>\n",
 		conn->c_trans->t_type == RDS_TRANS_TCP ? "TCP" : "IB",
 		conn, &conn->c_laddr, &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, <%pI4,%pI4,%d>\n",
 			conn, &conn->c_laddr, &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, <%pI4,%pI4,%d>\n",
-				cp->cp_base_conn, conn, &conn->c_laddr,
-				&conn->c_faddr, conn->c_tos);
 	}
 }
 EXPORT_SYMBOL_GPL(rds_conn_path_connect_if_down);

net/rds/ib_cm.c

@@ -1144,24 +1144,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_conn_net(conn),

net/rds/rds.h

@@ -254,7 +254,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;
 
@@ -1142,7 +1142,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 *);

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;