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

This reverts commit 68b8a1f112495b8d6aea6c57280d40fa91914324.

Orabug: 35811116

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

Orabug: 35811116

LUCI => v6.6-rc7

Conflicts:
  - Resolved conflict at (*inc_copy_to_user)() line in net/rds/rds.h due to
    following new context line introducing (*recv_need_bufs)().

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

Author: Greg Jumper

net/rds/af_rds.c

@@ -1077,9 +1077,7 @@ static int __rds_create(struct socket *sock, struct sock *sk, int protocol)
 	rs->rs_rx_traces = 0;
 	rs->rs_pid = current->pid;
 	net = sock_net(sk);
-
 	rs->rs_rns = rds_ns(net);
-	rs->rs_stats = __rds_get_mod_stats(rs->rs_rns, RDS_MOD_RDS);
 
 	spin_lock_init(&rs->rs_snd_lock);
 	ret = rhashtable_init(&rs->rs_buf_info_tbl, &rs_buf_info_params);
@@ -1364,8 +1362,7 @@ static unsigned long parse_ul(char *ptr, unsigned long max)
 	return 0;
 }
 
-int rds_check_qos_threshold(struct rds_statistics __percpu *stats, u8 tos,
-			    size_t payload_len)
+int rds_check_qos_threshold(u8 tos, size_t payload_len)
 {
 	if (rds_qos_threshold_action == 0)
 		return 0;
@@ -1375,10 +1372,10 @@ int rds_check_qos_threshold(struct rds_statistics __percpu *stats, u8 tos,
 		if (rds_qos_threshold_action == 1)
 			return 1;
 		else if (rds_qos_threshold_action == 2) {
-			rds_stats_inc(stats, s_qos_threshold_exceeded);
+			rds_stats_inc(s_qos_threshold_exceeded);
 			return 0;
 		} else if (rds_qos_threshold_action == 3) {
-			rds_stats_inc(stats, s_qos_threshold_exceeded);
+			rds_stats_inc(s_qos_threshold_exceeded);
 			return 1;
 		} else
 			return 0;
@@ -1450,6 +1447,7 @@ static void __exit rds_exit(void)
 	rds_conn_exit();
 	rds_sysctl_exit();
 	rds_threads_exit();
+	rds_stats_exit();
 	rds_page_exit();
 	rds_info_deregister_func(RDS_INFO_SOCKETS, rds_sock_info);
 	rds_info_deregister_func(RDS_INFO_RECV_MESSAGES, rds_sock_inc_info);
@@ -1491,9 +1489,12 @@ static int __init rds_init(void)
 	ret = rds_sysctl_init();
 	if (ret)
 		goto out_threads;
-	ret = proto_register(&rds_proto, 1);
+	ret = rds_stats_init();
 	if (ret)
 		goto out_sysctl;
+	ret = proto_register(&rds_proto, 1);
+	if (ret)
+		goto out_stats;
 	ret = sock_register(&rds_family_ops);
 	if (ret)
 		goto out_proto;
@@ -1511,6 +1512,8 @@ static int __init rds_init(void)
 
 out_proto:
 	proto_unregister(&rds_proto);
+out_stats:
+	rds_stats_exit();
 out_sysctl:
 	rds_sysctl_exit();
 out_threads:

net/rds/cong.c

@@ -322,16 +322,15 @@ void rds_cong_queue_updates(struct rds_cong_map *map)
 	list_for_each_entry(conn, &map->m_conn_list, c_map_item) {
 		if (!test_and_set_bit(RCMQ_BITOFF_CONGU_PENDING,
 				      &conn->c_map_queued)) {
-			rds_stats_inc(conn->c_stats, s_cong_update_queued);
+			rds_stats_inc(s_cong_update_queued);
 			rds_cond_queue_send_work(conn->c_path, 0);
 		}
 	}
 
 	spin_unlock_irqrestore(&map->m_rns->rns_cong_lock, flags);
 }
 
-void rds_cong_map_updated(struct rds_connection *conn,
-			  struct rds_cong_map *map, uint64_t portmask)
+void rds_cong_map_updated(struct rds_cong_map *map, uint64_t portmask)
 {
 	bool qwork = false;
 	struct rds_net *rns;
@@ -341,7 +340,7 @@ void rds_cong_map_updated(struct rds_connection *conn,
 		 map, &map->m_addr);
 	rns = map->m_rns;
 	rds_cong_monitor = rns->rns_cong_monitor;
-	rds_stats_inc(conn->c_stats, s_cong_update_received);
+	rds_stats_inc(s_cong_update_received);
 	atomic_inc(&rns->rns_cong_generation);
 	if (waitqueue_active(&map->m_waitq))
 		wake_up(&map->m_waitq);
@@ -458,16 +457,8 @@ void rds_cong_remove_socket(struct rds_sock *rs)
 int rds_cong_wait(struct rds_cong_map *map, __be16 port, int nonblock,
 		  struct rds_sock *rs)
 {
-	struct rds_statistics __percpu *stats;
-
 	if (!rds_cong_test_bit(map, port))
 		return 0;
-
-	if (rs)
-		stats = rs->rs_stats;
-	else
-		stats = __rds_get_mod_stats(rds_ns(current->nsproxy->net_ns),
-					    RDS_MOD_RDS);
 	if (nonblock) {
 		if (rs && rs->rs_cong_monitor) {
 			atomic64_or(RDS_CONG_MONITOR_MASK(ntohs(port)), &rs->rs_cong_mask);
@@ -477,11 +468,11 @@ int rds_cong_wait(struct rds_cong_map *map, __be16 port, int nonblock,
 			if (!rds_cong_test_bit(map, port))
 				return 0;
 		}
-		rds_stats_inc(stats, s_cong_send_error);
+		rds_stats_inc(s_cong_send_error);
 		return -ENOBUFS;
 	}
 
-	rds_stats_inc(stats, s_cong_send_blocked);
+	rds_stats_inc(s_cong_send_blocked);
 	rdsdebug("waiting on map %p for port %u\n", map, be16_to_cpu(port));
 
 	return wait_event_interruptible(map->m_waitq,

net/rds/connection.c

@@ -169,7 +169,7 @@ static void rds_conn_path_reset(struct rds_conn_path *cp)
 	rdsdebug("connection %pI6c to %pI6c reset\n",
 		 &conn->c_laddr, &conn->c_faddr);
 
-	rds_stats_inc(conn->c_stats, s_conn_reset);
+	rds_stats_inc(s_conn_reset);
 	rds_send_path_reset(cp);
 
 	/* This function used to just set "cp->cp_flags = 0".

net/rds/ib.h

@@ -791,8 +791,7 @@ void rds_ib_recv_rebuild_caches(struct rds_ib_connection *ic);
 void rds_ib_recv_free_frag(struct rds_page_frag *frag, int nent);
 void __rds_ib_recv_refill(struct rds_connection *conn, int prefill, gfp_t gfp);
 void rds_ib_inc_free(struct rds_incoming *inc);
-int rds_ib_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
-			    struct iov_iter *to);
+int rds_ib_inc_copy_to_user(struct rds_incoming *inc, struct iov_iter *to);
 void rds_ib_recv_cqe_handler(struct rds_ib_connection *ic,
 			    struct ib_wc *wc,
 			    struct rds_ib_ack_state *state);
@@ -861,10 +860,10 @@ int rds_ib_xmit_atomic(struct rds_connection *conn, struct rm_atomic_op *op);
 
 /* ib_stats.c */
 DECLARE_PER_CPU(struct rds_ib_statistics, rds_ib_stats);
-#define rds_ib_stats_inc(member) rds_stats_inc_which(&rds_ib_stats, member)
+#define rds_ib_stats_inc(member) rds_stats_inc_which(rds_ib_stats, member)
 #define rds_ib_stats_dec(member) rds_stats_dec_which(rds_ib_stats, member)
 #define rds_ib_stats_add(member, count) \
-		rds_stats_add_which(&rds_ib_stats, member, count)
+		rds_stats_add_which(rds_ib_stats, member, count)
 unsigned int rds_ib_stats_info_copy(struct rds_info_iterator *iter,
 				    unsigned int avail);
 void rds_ib_stats_print(const char *where);

net/rds/ib_recv.c

@@ -765,8 +765,7 @@ static struct lfstack_el *rds_ib_recv_cache_get(struct rds_ib_refill_cache *cach
 	return item;
 }
 
-int rds_ib_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
-			    struct iov_iter *to)
+int rds_ib_inc_copy_to_user(struct rds_incoming *inc, struct iov_iter *to)
 {
 	struct rds_csum csum;
 	struct rds_ib_connection *ic = inc->i_conn->c_transport_data;
@@ -803,7 +802,7 @@ int rds_ib_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
 		if (ret != to_copy)
 			return -EFAULT;
 
-		rds_stats_add(rs->rs_stats, s_copy_to_user, to_copy);
+		rds_stats_add(s_copy_to_user, to_copy);
 		atomic64_add(to_copy, &conn->c_recv_bytes);
 		frag_off += to_copy;
 		copied += to_copy;
@@ -829,7 +828,7 @@ int rds_ib_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
 	}
 
 	if (unlikely(inc->i_payload_csum.csum_enabled) && copied) {
-		rds_stats_inc(rs->rs_stats, s_recv_payload_csum_ib);
+		rds_stats_inc(s_recv_payload_csum_ib);
 		rds_check_csum(inc, &csum);
 	}
 
@@ -1129,7 +1128,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn,
 	trace_rds_receive(&ibinc->ii_inc, NULL, conn, NULL,
 			  &conn->c_faddr, &conn->c_laddr);
 
-	rds_cong_map_updated(conn, map, uncongested);
+	rds_cong_map_updated(map, uncongested);
 }
 
 static void rds_ib_process_recv(struct rds_connection *conn,
@@ -1168,7 +1167,7 @@ static void rds_ib_process_recv(struct rds_connection *conn,
 		rds_conn_drop(conn, DR_IB_HEADER_CORRUPTED, 0);
 		pr_warn("RDS/IB: incoming message from %pI6c has corrupted header - forcing a reconnect\n",
 			&conn->c_faddr);
-		rds_stats_inc(conn->c_stats, s_recv_drop_bad_checksum);
+		rds_stats_inc(s_recv_drop_bad_checksum);
 		return;
 	}
 
@@ -1269,7 +1268,7 @@ static void rds_ib_process_recv(struct rds_connection *conn,
 		 * the complete frame, and after bumping the next_rx
 		 * sequence. */
 		if (hdr->h_flags & RDS_FLAG_ACK_REQUIRED) {
-			rds_stats_inc(conn->c_stats, s_recv_ack_required);
+			rds_stats_inc(s_recv_ack_required);
 			state->ack_required = 1;
 		}
 
@@ -1309,7 +1308,7 @@ void rds_ib_srq_process_recv(struct rds_connection *conn,
 		printk(KERN_WARNING "RDS: from %pI6c has corrupted header - "
 			"forcing a reconnect\n",
 			&conn->c_faddr);
-		rds_stats_inc(conn->c_stats, s_recv_drop_bad_checksum);
+		rds_stats_inc(s_recv_drop_bad_checksum);
 		rds_ib_frag_free(ic, recv->r_frag);
 		recv->r_frag = NULL;
 		return;
@@ -1374,7 +1373,7 @@ void rds_ib_srq_process_recv(struct rds_connection *conn,
 			state->ack_next_valid = 1;
 		}
 		if (hdr->h_flags & RDS_FLAG_ACK_REQUIRED) {
-			rds_stats_inc(conn->c_stats, s_recv_ack_required);
+			rds_stats_inc(s_recv_ack_required);
 			state->ack_required = 1;
 		}
 		rds_inc_put(&ibinc->ii_inc);

net/rds/ib_send.c

@@ -162,12 +162,10 @@ static void rds_ib_send_unmap_rdma(struct rds_ib_connection *ic,
 			     wc_status, rds_rdma_send_complete);
 
 	if (op->op_write) {
-		rds_stats_add(ic->conn->c_stats, s_send_rdma_bytes,
-			      op->op_bytes);
+		rds_stats_add(s_send_rdma_bytes, op->op_bytes);
 		atomic64_add(op->op_bytes, &ic->i_r_write_bytes);
 	} else {
-		rds_stats_add(ic->conn->c_stats, s_recv_rdma_bytes,
-			      op->op_bytes);
+		rds_stats_add(s_recv_rdma_bytes, op->op_bytes);
 		atomic64_add(op->op_bytes, &ic->i_r_read_bytes);
 	}
 }
@@ -615,7 +613,7 @@ int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
 	/* Do not send cong updates to IB loopback */
 	if (conn->c_loopback
 	    && rm->m_inc.i_hdr.h_flags & RDS_FLAG_CONG_BITMAP) {
-		rds_cong_map_updated(conn, conn->c_fcong, ~(u64)0);
+		rds_cong_map_updated(conn->c_fcong, ~(u64) 0);
 		return sizeof(struct rds_header) + RDS_CONG_MAP_BYTES;
 	}
 

net/rds/info.c

@@ -59,6 +59,12 @@
  * - info source copy must be pinned, may be "large"
  */
 
+struct rds_info_iterator {
+	struct page **pages;
+	void *addr;
+	unsigned long offset;
+};
+
 static DEFINE_SPINLOCK(rds_info_lock);
 static rds_info_func rds_info_funcs[RDS_INFO_LAST - RDS_INFO_FIRST + 1];
 
@@ -206,7 +212,6 @@ int rds_info_getsockopt(struct socket *sock, int optname, char __user *optval,
 	iter.pages = pages;
 	iter.addr = NULL;
 	iter.offset = start & (PAGE_SIZE - 1);
-	iter.net = sock_net(sock->sk);
 
 	func(sock, len, &iter, &lens);
 	BUG_ON(lens.each == 0);

net/rds/loop.c

@@ -64,7 +64,7 @@ static int rds_loop_xmit(struct rds_connection *conn, struct rds_message *rm,
 {
 	/* Do not send cong updates to loopback */
 	if (rm->m_inc.i_hdr.h_flags & RDS_FLAG_CONG_BITMAP) {
-		rds_cong_map_updated(conn, conn->c_fcong, ~(u64)0);
+		rds_cong_map_updated(conn->c_fcong, ~(u64) 0);
 		return sizeof(struct rds_header) + RDS_CONG_MAP_BYTES;
 	}
 

net/rds/message.c

@@ -301,8 +301,7 @@ struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents)
 	return sg_ret;
 }
 
-int rds_message_copy_from_user(struct rds_sock *rs, struct rds_message *rm,
-			       struct iov_iter *from)
+int rds_message_copy_from_user(struct rds_message *rm, struct iov_iter *from)
 {
 	unsigned long to_copy, nbytes;
 	unsigned long sg_off;
@@ -345,7 +344,7 @@ int rds_message_copy_from_user(struct rds_sock *rs, struct rds_message *rm,
 		if (nbytes != to_copy)
 			return -EFAULT;
 
-		rds_stats_add(rs->rs_stats, s_copy_from_user, to_copy);
+		rds_stats_add(s_copy_from_user, to_copy);
 		sg_off += to_copy;
 
 		if (sg_off == sg->length)
@@ -355,8 +354,7 @@ int rds_message_copy_from_user(struct rds_sock *rs, struct rds_message *rm,
 	return ret;
 }
 
-int rds_message_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
-				 struct iov_iter *to)
+int rds_message_inc_copy_to_user(struct rds_incoming *inc, struct iov_iter *to)
 {
 	struct rds_csum csum;
 	struct rds_connection *conn;
@@ -393,7 +391,7 @@ int rds_message_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
 		if (ret != to_copy)
 			return -EFAULT;
 
-		rds_stats_add(rs->rs_stats, s_copy_to_user, to_copy);
+		rds_stats_add(s_copy_to_user, to_copy);
 		atomic64_add(to_copy, &conn->c_recv_bytes);
 		vec_off += to_copy;
 		copied += to_copy;
@@ -405,7 +403,7 @@ int rds_message_inc_copy_to_user(struct rds_sock *rs, struct rds_incoming *inc,
 	}
 
 	if (unlikely(inc->i_payload_csum.csum_enabled) && copied) {
-		rds_stats_inc(rs->rs_stats, s_recv_payload_csum_loopback);
+		rds_stats_inc(s_recv_payload_csum_loopback);
 		rds_check_csum(inc, &csum);
 	}
 

net/rds/page.c

@@ -78,7 +78,7 @@ int rds_page_remainder_alloc(struct scatterlist *scat, unsigned long bytes,
 			ret = -ENOMEM;
 		} else {
 			sg_set_page(scat, page, PAGE_SIZE, 0);
-			rds_stats_inc(&rds_stats, s_page_allocs);
+			rds_stats_inc(s_page_allocs);
 			ret = 0;
 		}
 		goto out;
@@ -90,7 +90,7 @@ int rds_page_remainder_alloc(struct scatterlist *scat, unsigned long bytes,
 	while (1) {
 		/* avoid a tiny region getting stuck by tossing it */
 		if (rem->r_page && bytes > (PAGE_SIZE - rem->r_offset)) {
-			rds_stats_inc(&rds_stats, s_page_remainder_miss);
+			rds_stats_inc(s_page_remainder_miss);
 			rds_page_free(rem->r_page);
 			rem->r_page = NULL;
 		}
@@ -99,10 +99,10 @@ int rds_page_remainder_alloc(struct scatterlist *scat, unsigned long bytes,
 		if (rem->r_page && bytes <= (PAGE_SIZE - rem->r_offset)) {
 			sg_set_page(scat, rem->r_page, bytes, rem->r_offset);
 			get_page(sg_page(scat));
-			rds_stats_inc(&rds_stats, s_page_gets);
+			rds_stats_inc(s_page_gets);
 
 			if (rem->r_offset != 0)
-				rds_stats_inc(&rds_stats, s_page_remainder_hit);
+				rds_stats_inc(s_page_remainder_hit);
 
 			/* some hw (e.g. sparc) require aligned memory */
 			rem->r_offset += ALIGN(bytes, 8);
@@ -127,7 +127,7 @@ int rds_page_remainder_alloc(struct scatterlist *scat, unsigned long bytes,
 			ret = -ENOMEM;
 			break;
 		}
-		rds_stats_inc(&rds_stats, s_page_allocs);
+		rds_stats_inc(s_page_allocs);
 
 		/* did someone race to fill the remainder before us? */
 		if (rem->r_page) {

net/rds/rdma.c

@@ -721,7 +721,7 @@ static int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
 	if (ret)
 		rds_rdma_free_op(op);
 
-	rds_stats_inc(rs->rs_stats, s_send_rdma);
+	rds_stats_inc(s_send_rdma);
 
 	return ret;
 }