Revert "net/rds: Track "rds_tcp" module statistics per network namespace"

This reverts commit 4f9a0378bf6367ee54f124c629f003ebb4392f35.

Orabug: 35811116

Signed-off-by: Greg Jumper <[email protected]>
Reviewed-by: Sharath Srinivasan <[email protected]>

Author: Greg Jumper

include/uapi/linux/rds.h

@@ -501,7 +501,6 @@ struct rds_rdma_send_notify {
 enum {
 	RDS_MOD_UNSPEC,
 	RDS_MOD_RDS,	/* rds module */
-	RDS_MOD_TCP,	/* rds_tcp module */
 
 	/* Add new module before this. */
 	RDS_MOD_MAX,

net/rds/rds.h

@@ -1527,10 +1527,6 @@ DECLARE_PER_CPU_SHARED_ALIGNED(struct rds_statistics, rds_stats);
 	rds_stats_add_which(stats, member, count)
 int rds_stats_net_init(struct net *net);
 void rds_stats_net_exit(struct net *net);
-int rds_mod_stats_register(struct net *net, int module,
-			   struct rds_stats_struct *stats);
-struct rds_stats_struct *rds_mod_stats_unregister(struct net *net,
-						  int module);
 void rds_stats_info_copy(struct rds_info_iterator *iter,
 			 uint64_t *values, char **names, size_t nr);
 void rds_stats_print(const char *where);

net/rds/tcp.c

@@ -386,7 +386,6 @@ static int rds_tcp_conn_alloc(struct rds_connection *conn, gfp_t gfp)
 		tc->t_tinc_data_rem = 0;
 		INIT_WORK(&tc->t_fan_out_w, rds_tcp_fan_out_w);
 		init_waitqueue_head(&tc->t_recv_done_waitq);
-		tc->t_stats = __rds_get_mod_stats(conn->c_rns, RDS_MOD_TCP);
 
 		/* Once set, they will never change until the conn is dead. */
 		conn->c_path[i].cp_transport_data = tc;
@@ -413,7 +412,6 @@ static void rds_tcp_conn_free(void *arg)
 	list_del(&tc->t_tcp_node);
 	spin_unlock_irqrestore(&rds_tcp_conn_lock, flags);
 
-	tc->t_stats = NULL;
 	kmem_cache_free(rds_tcp_conn_slab, tc);
 }
 
@@ -513,23 +511,17 @@ void rds_tcp_accept_work(struct rds_tcp_net *rtn)
 static __net_init int rds_tcp_init_net(struct net *net)
 {
 	struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
-	struct ctl_table *tbl = NULL;
+	struct ctl_table *tbl;
 	int err = 0;
 
 	memset(rtn, 0, sizeof(*rtn));
 
 	mutex_init(&rtn->rds_tcp_accept_lock);
 
-	err = rds_tcp_stats_net_init(net);
-	if (err)
-		return err;
-
 	rtn->rds_tcp_accept_wq =
 		create_singlethread_workqueue("rds_tcp_accept");
-	if (!rtn->rds_tcp_accept_wq) {
-		err = -ENOMEM;
-		goto fail;
-	}
+	if (!rtn->rds_tcp_accept_wq)
+		return -ENOMEM;
 
 	/* {snd, rcv}buf_size default to 0, which implies we let the
 	 * stack pick the value, and permit auto-tuning of buffer size.
@@ -541,8 +533,7 @@ static __net_init int rds_tcp_init_net(struct net *net)
 			      sizeof(rds_tcp_sysctl_table), GFP_KERNEL);
 		if (!tbl) {
 			pr_warn("could not set allocate syctl table\n");
-			err = -ENOMEM;
-			goto fail;
+			return -ENOMEM;
 		}
 		rtn->ctl_table = tbl;
 	}
@@ -579,7 +570,6 @@ static __net_init int rds_tcp_init_net(struct net *net)
 	return 0;
 
 fail:
-	rds_tcp_stats_net_exit(net);
 	if (net != &init_net)
 		kfree(tbl);
 	return err;
@@ -635,7 +625,6 @@ static void __net_exit rds_tcp_exit_net(struct net *net)
 	struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
 
 	rds_tcp_kill_sock(net, rtn);
-	rds_tcp_stats_net_exit(net);
 
 	if (rtn->rds_tcp_sysctl)
 		unregister_net_sysctl_table(rtn->rds_tcp_sysctl);

net/rds/tcp.h

@@ -25,15 +25,6 @@ struct rds_tcp_incoming {
 	struct sk_buff_head	ti_skb_list;
 };
 
-struct rds_tcp_statistics {
-	u64	s_tcp_data_ready_calls;
-	u64	s_tcp_write_space_calls;
-	u64	s_tcp_sndbuf_full;
-	u64	s_tcp_connect_raced;
-	u64	s_tcp_listen_closed_stale;
-	u64	s_tcp_ka_timeout;
-};
-
 struct rds_tcp_connection {
 
 	struct list_head	t_tcp_node;
@@ -63,8 +54,15 @@ struct rds_tcp_connection {
 
 	/* for rds_tcp_conn_path_shutdown */
 	wait_queue_head_t	t_recv_done_waitq;
+};
 
-	struct rds_tcp_statistics __percpu	*t_stats;
+struct rds_tcp_statistics {
+	uint64_t	s_tcp_data_ready_calls;
+	uint64_t	s_tcp_write_space_calls;
+	uint64_t	s_tcp_sndbuf_full;
+	uint64_t	s_tcp_connect_raced;
+	uint64_t	s_tcp_listen_closed_stale;
+	uint64_t        s_tcp_ka_timeout;
 };
 
 /* tcp.c */
@@ -117,11 +115,8 @@ void rds_tcp_write_space(struct sock *sk);
 
 /* tcp_stats.c */
 DECLARE_PER_CPU(struct rds_tcp_statistics, rds_tcp_stats);
-#define rds_tcp_stats_inc(stats, member) rds_stats_inc_which(stats, member)
+#define rds_tcp_stats_inc(member) rds_stats_inc_which(&rds_tcp_stats, member)
 unsigned int rds_tcp_stats_info_copy(struct rds_info_iterator *iter,
 				     unsigned int avail);
-int rds_tcp_stats_net_init(struct net *net);
-void rds_tcp_stats_net_exit(struct net *net);
-
 
 #endif

net/rds/tcp_connect.c

@@ -88,7 +88,7 @@ void rds_tcp_state_change(struct sock *sk)
 			wake_up(&tc->t_recv_done_waitq);
 		if (sk->sk_err == ETIMEDOUT &&
 		    icsk->icsk_probes_out >= keepalive_probes(tsock)) {
-			rds_tcp_stats_inc(tc->t_stats, s_tcp_ka_timeout);
+			rds_tcp_stats_inc(s_tcp_ka_timeout);
 			rds_conn_path_drop(cp,
 					   DR_TCP_STATE_CLOSE_KA_TIMEOUT, 0);
 		} else {
@@ -179,7 +179,7 @@ int rds_tcp_conn_path_connect(struct rds_conn_path *cp)
 			tc->t_client_port_group = 0;
 		port =  port_low +
 			tc->t_client_port_group * RDS_MPATH_WORKERS +
-			cp->cp_index;
+			cp->cp_index; 
 
 		if (isv6)
 			sin6.sin6_port = htons(port);

net/rds/tcp_recv.c

@@ -467,7 +467,7 @@ void rds_tcp_data_ready(struct sock *sk)
 
 	tc = cp->cp_transport_data;
 	ready = tc->t_orig_data_ready;
-	rds_tcp_stats_inc(tc->t_stats, s_tcp_data_ready_calls);
+	rds_tcp_stats_inc(s_tcp_data_ready_calls);
 
 	if (rds_tcp_read_sock(cp, GFP_ATOMIC) == -ENOMEM)
 		rds_cond_queue_recv_work(cp, 0);

net/rds/tcp_send.c

@@ -152,7 +152,7 @@ int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
 					      reason);
 		/* write_space will hit after EAGAIN, all else fatal */
 		if (ret == -EAGAIN) {
-			rds_tcp_stats_inc(tc->t_stats, s_tcp_sndbuf_full);
+			rds_tcp_stats_inc(s_tcp_sndbuf_full);
 			ret = 0;
 		} else {
 			/* No need to disconnect/reconnect if path_drop
@@ -203,7 +203,7 @@ void rds_tcp_write_space(struct sock *sk)
 	tc = cp->cp_transport_data;
 	rdsdebug("write_space for tc %p\n", tc);
 	write_space = tc->t_orig_write_space;
-	rds_tcp_stats_inc(tc->t_stats, s_tcp_write_space_calls);
+	rds_tcp_stats_inc(s_tcp_write_space_calls);
 
 	rdsdebug("tcp una %u\n", rds_tcp_snd_una(tc));
 	tc->t_last_seen_una = rds_tcp_snd_una(tc);

net/rds/tcp_stats.c

@@ -53,8 +53,6 @@ unsigned int rds_tcp_stats_info_copy(struct rds_info_iterator *iter,
 				     unsigned int avail)
 {
 	struct rds_tcp_statistics stats = {0, };
-	struct rds_tcp_statistics *per_cpu_ns_ptr;
-	struct rds_net *rns;
 	uint64_t *src;
 	uint64_t *sum;
 	size_t i;
@@ -63,11 +61,8 @@ unsigned int rds_tcp_stats_info_copy(struct rds_info_iterator *iter,
 	if (avail < ARRAY_SIZE(rds_tcp_stat_names))
 		goto out;
 
-	rns = rds_ns(iter->net);
-	per_cpu_ns_ptr = __rds_get_mod_stats(rns, RDS_MOD_TCP);
-
 	for_each_online_cpu(cpu) {
-		src = (uint64_t *)per_cpu_ptr(per_cpu_ns_ptr, cpu);
+		src = (uint64_t *)&(per_cpu(rds_tcp_stats, cpu));
 		sum = (uint64_t *)&stats;
 		for (i = 0; i < sizeof(stats) / sizeof(uint64_t); i++)
 			*(sum++) += *(src++);
@@ -78,47 +73,3 @@ unsigned int rds_tcp_stats_info_copy(struct rds_info_iterator *iter,
 out:
 	return ARRAY_SIZE(rds_tcp_stat_names);
 }
-
-void rds_tcp_stats_net_exit(struct net *net)
-{
-	struct rds_stats_struct *stats;
-
-	stats = rds_mod_stats_unregister(net, RDS_MOD_TCP);
-	if (!net_eq(net, &init_net))
-		free_percpu(stats->rs_stats);
-	kfree(stats);
-}
-
-int rds_tcp_stats_net_init(struct net *net)
-{
-	struct rds_stats_struct *stats;
-	int ret = 0;
-
-	stats = kmalloc(sizeof(*stats), GFP_KERNEL);
-	if (!stats)
-		return -ENOMEM;
-
-	stats->rs_names = rds_tcp_stat_names;
-	stats->rs_num_stats = sizeof(struct rds_tcp_statistics) /
-		sizeof(uint64_t);
-
-	if (net_eq(net, &init_net)) {
-		stats->rs_stats = &rds_tcp_stats;
-		ret = rds_mod_stats_register(net, RDS_MOD_TCP, stats);
-	} else {
-		stats->rs_stats =
-			__alloc_percpu(sizeof(struct rds_tcp_statistics),
-				       cache_line_size());
-		if (stats->rs_stats) {
-			ret = rds_mod_stats_register(net, RDS_MOD_TCP, stats);
-			if (ret)
-				free_percpu(stats->rs_stats);
-		} else {
-			ret = -ENOMEM;
-		}
-	}
-
-	if (ret)
-		kfree(stats);
-	return ret;
-}