[linux.git] / net / kcm / kcmproc.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/net.h>
#include <linux/proc_fs.h>
#include <linux/rculist.h>
#include <linux/seq_file.h>
#include <linux/socket.h>
#include <net/inet_sock.h>
#include <net/kcm.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <net/tcp.h>

#ifdef CONFIG_PROC_FS
struct kcm_seq_muxinfo {
	char				*name;
	const struct file_operations	*seq_fops;
	const struct seq_operations	seq_ops;
};

static struct kcm_mux *kcm_get_first(struct seq_file *seq)
{
	struct net *net = seq_file_net(seq);
	struct kcm_net *knet = net_generic(net, kcm_net_id);

	return list_first_or_null_rcu(&knet->mux_list,
				      struct kcm_mux, kcm_mux_list);
}

static struct kcm_mux *kcm_get_next(struct kcm_mux *mux)
{
	struct kcm_net *knet = mux->knet;

	return list_next_or_null_rcu(&knet->mux_list, &mux->kcm_mux_list,
				     struct kcm_mux, kcm_mux_list);
}

static struct kcm_mux *kcm_get_idx(struct seq_file *seq, loff_t pos)
{
	struct net *net = seq_file_net(seq);
	struct kcm_net *knet = net_generic(net, kcm_net_id);
	struct kcm_mux *m;

	list_for_each_entry_rcu(m, &knet->mux_list, kcm_mux_list) {
		if (!pos)
			return m;
		--pos;
	}
	return NULL;
}

static void *kcm_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	void *p;

	if (v == SEQ_START_TOKEN)
		p = kcm_get_first(seq);
	else
		p = kcm_get_next(v);
	++*pos;
	return p;
}

static void *kcm_seq_start(struct seq_file *seq, loff_t *pos)
	__acquires(rcu)
{
	rcu_read_lock();

	if (!*pos)
		return SEQ_START_TOKEN;
	else
		return kcm_get_idx(seq, *pos - 1);
}

static void kcm_seq_stop(struct seq_file *seq, void *v)
	__releases(rcu)
{
	rcu_read_unlock();
}

struct kcm_proc_mux_state {
	struct seq_net_private p;
	int idx;
};

static int kcm_seq_open(struct inode *inode, struct file *file)
{
	struct kcm_seq_muxinfo *muxinfo = PDE_DATA(inode);

	return seq_open_net(inode, file, &muxinfo->seq_ops,
			   sizeof(struct kcm_proc_mux_state));
}

static void kcm_format_mux_header(struct seq_file *seq)
{
	struct net *net = seq_file_net(seq);
	struct kcm_net *knet = net_generic(net, kcm_net_id);

	seq_printf(seq,
		   "*** KCM statistics (%d MUX) ****\n",
		   knet->count);

	seq_printf(seq,
		   "%-14s %-10s %-16s %-10s %-16s %-8s %-8s %-8s %-8s %s",
		   "Object",
		   "RX-Msgs",
		   "RX-Bytes",
		   "TX-Msgs",
		   "TX-Bytes",
		   "Recv-Q",
		   "Rmem",
		   "Send-Q",
		   "Smem",
		   "Status");

	/* XXX: pdsts header stuff here */
	seq_puts(seq, "\n");
}

static void kcm_format_sock(struct kcm_sock *kcm, struct seq_file *seq,
			    int i, int *len)
{
	seq_printf(seq,
		   "   kcm-%-7u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8s ",
		   kcm->index,
		   kcm->stats.rx_msgs,
		   kcm->stats.rx_bytes,
		   kcm->stats.tx_msgs,
		   kcm->stats.tx_bytes,
		   kcm->sk.sk_receive_queue.qlen,
		   sk_rmem_alloc_get(&kcm->sk),
		   kcm->sk.sk_write_queue.qlen,
		   "-");

	if (kcm->tx_psock)
		seq_printf(seq, "Psck-%u ", kcm->tx_psock->index);

	if (kcm->tx_wait)
		seq_puts(seq, "TxWait ");

	if (kcm->tx_wait_more)
		seq_puts(seq, "WMore ");

	if (kcm->rx_wait)
		seq_puts(seq, "RxWait ");

	seq_puts(seq, "\n");
}

static void kcm_format_psock(struct kcm_psock *psock, struct seq_file *seq,
			     int i, int *len)
{
	seq_printf(seq,
		   "   psock-%-5u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8d ",
		   psock->index,
		   psock->strp.stats.msgs,
		   psock->strp.stats.bytes,
		   psock->stats.tx_msgs,
		   psock->stats.tx_bytes,
		   psock->sk->sk_receive_queue.qlen,
		   atomic_read(&psock->sk->sk_rmem_alloc),
		   psock->sk->sk_write_queue.qlen,
		   refcount_read(&psock->sk->sk_wmem_alloc));

	if (psock->done)
		seq_puts(seq, "Done ");

	if (psock->tx_stopped)
		seq_puts(seq, "TxStop ");

	if (psock->strp.stopped)
		seq_puts(seq, "RxStop ");

	if (psock->tx_kcm)
		seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index);

	if (!psock->strp.paused && !psock->ready_rx_msg) {
		if (psock->sk->sk_receive_queue.qlen) {
			if (psock->strp.need_bytes)
				seq_printf(seq, "RxWait=%u ",
					   psock->strp.need_bytes);
			else
				seq_printf(seq, "RxWait ");
		}
	} else  {
		if (psock->strp.paused)
			seq_puts(seq, "RxPause ");

		if (psock->ready_rx_msg)
			seq_puts(seq, "RdyRx ");
	}

	seq_puts(seq, "\n");
}

static void
kcm_format_mux(struct kcm_mux *mux, loff_t idx, struct seq_file *seq)
{
	int i, len;
	struct kcm_sock *kcm;
	struct kcm_psock *psock;

	/* mux information */
	seq_printf(seq,
		   "%-6s%-8s %-10llu %-16llu %-10llu %-16llu %-8s %-8s %-8s %-8s ",
		   "mux", "",
		   mux->stats.rx_msgs,
		   mux->stats.rx_bytes,
		   mux->stats.tx_msgs,
		   mux->stats.tx_bytes,
		   "-", "-", "-", "-");

	seq_printf(seq, "KCMs: %d, Psocks %d\n",
		   mux->kcm_socks_cnt, mux->psocks_cnt);

	/* kcm sock information */
	i = 0;
	spin_lock_bh(&mux->lock);
	list_for_each_entry(kcm, &mux->kcm_socks, kcm_sock_list) {
		kcm_format_sock(kcm, seq, i, &len);
		i++;
	}
	i = 0;
	list_for_each_entry(psock, &mux->psocks, psock_list) {
		kcm_format_psock(psock, seq, i, &len);
		i++;
	}
	spin_unlock_bh(&mux->lock);
}

static int kcm_seq_show(struct seq_file *seq, void *v)
{
	struct kcm_proc_mux_state *mux_state;

	mux_state = seq->private;
	if (v == SEQ_START_TOKEN) {
		mux_state->idx = 0;
		kcm_format_mux_header(seq);
	} else {
		kcm_format_mux(v, mux_state->idx, seq);
		mux_state->idx++;
	}
	return 0;
}

static const struct file_operations kcm_seq_fops = {
	.open		= kcm_seq_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release_net,
};

static struct kcm_seq_muxinfo kcm_seq_muxinfo = {
	.name		= "kcm",
	.seq_fops	= &kcm_seq_fops,
	.seq_ops	= {
		.show	= kcm_seq_show,
		.start	= kcm_seq_start,
		.next	= kcm_seq_next,
		.stop	= kcm_seq_stop,
	}
};

static int kcm_proc_register(struct net *net, struct kcm_seq_muxinfo *muxinfo)
{
	struct proc_dir_entry *p;
	int rc = 0;

	p = proc_create_data(muxinfo->name, 0444, net->proc_net,
			     muxinfo->seq_fops, muxinfo);
	if (!p)
		rc = -ENOMEM;
	return rc;
}
EXPORT_SYMBOL(kcm_proc_register);

static void kcm_proc_unregister(struct net *net,
				struct kcm_seq_muxinfo *muxinfo)
{
	remove_proc_entry(muxinfo->name, net->proc_net);
}
EXPORT_SYMBOL(kcm_proc_unregister);

static int kcm_stats_seq_show(struct seq_file *seq, void *v)
{
	struct kcm_psock_stats psock_stats;
	struct kcm_mux_stats mux_stats;
	struct strp_aggr_stats strp_stats;
	struct kcm_mux *mux;
	struct kcm_psock *psock;
	struct net *net = seq->private;
	struct kcm_net *knet = net_generic(net, kcm_net_id);

	memset(&mux_stats, 0, sizeof(mux_stats));
	memset(&psock_stats, 0, sizeof(psock_stats));
	memset(&strp_stats, 0, sizeof(strp_stats));

	mutex_lock(&knet->mutex);

	aggregate_mux_stats(&knet->aggregate_mux_stats, &mux_stats);
	aggregate_psock_stats(&knet->aggregate_psock_stats,
			      &psock_stats);
	aggregate_strp_stats(&knet->aggregate_strp_stats,
			     &strp_stats);

	list_for_each_entry_rcu(mux, &knet->mux_list, kcm_mux_list) {
		spin_lock_bh(&mux->lock);
		aggregate_mux_stats(&mux->stats, &mux_stats);
		aggregate_psock_stats(&mux->aggregate_psock_stats,
				      &psock_stats);
		aggregate_strp_stats(&mux->aggregate_strp_stats,
				     &strp_stats);
		list_for_each_entry(psock, &mux->psocks, psock_list) {
			aggregate_psock_stats(&psock->stats, &psock_stats);
			save_strp_stats(&psock->strp, &strp_stats);
		}

		spin_unlock_bh(&mux->lock);
	}

	mutex_unlock(&knet->mutex);

	seq_printf(seq,
		   "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s\n",
		   "MUX",
		   "RX-Msgs",
		   "RX-Bytes",
		   "TX-Msgs",
		   "TX-Bytes",
		   "TX-Retries",
		   "Attach",
		   "Unattach",
		   "UnattchRsvd",
		   "RX-RdyDrops");

	seq_printf(seq,
		   "%-8s %-10llu %-16llu %-10llu %-16llu %-10u %-10u %-10u %-10u %-10u\n",
		   "",
		   mux_stats.rx_msgs,
		   mux_stats.rx_bytes,
		   mux_stats.tx_msgs,
		   mux_stats.tx_bytes,
		   mux_stats.tx_retries,
		   mux_stats.psock_attach,
		   mux_stats.psock_unattach_rsvd,
		   mux_stats.psock_unattach,
		   mux_stats.rx_ready_drops);

	seq_printf(seq,
		   "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n",
		   "Psock",
		   "RX-Msgs",
		   "RX-Bytes",
		   "TX-Msgs",
		   "TX-Bytes",
		   "Reserved",
		   "Unreserved",
		   "RX-Aborts",
		   "RX-Intr",
		   "RX-Unrecov",
		   "RX-MemFail",
		   "RX-NeedMor",
		   "RX-BadLen",
		   "RX-TooBig",
		   "RX-Timeout",
		   "TX-Aborts");

	seq_printf(seq,
		   "%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n",
		   "",
		   strp_stats.msgs,
		   strp_stats.bytes,
		   psock_stats.tx_msgs,
		   psock_stats.tx_bytes,
		   psock_stats.reserved,
		   psock_stats.unreserved,
		   strp_stats.aborts,
		   strp_stats.interrupted,
		   strp_stats.unrecov_intr,
		   strp_stats.mem_fail,
		   strp_stats.need_more_hdr,
		   strp_stats.bad_hdr_len,
		   strp_stats.msg_too_big,
		   strp_stats.msg_timeouts,
		   psock_stats.tx_aborts);

	return 0;
}

static int kcm_stats_seq_open(struct inode *inode, struct file *file)
{
	return single_open_net(inode, file, kcm_stats_seq_show);
}

static const struct file_operations kcm_stats_seq_fops = {
	.open    = kcm_stats_seq_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = single_release_net,
};

static int kcm_proc_init_net(struct net *net)
{
	int err;

	if (!proc_create("kcm_stats", 0444, net->proc_net,
			 &kcm_stats_seq_fops)) {
		err = -ENOMEM;
		goto out_kcm_stats;
	}

	err = kcm_proc_register(net, &kcm_seq_muxinfo);
	if (err)
		goto out_kcm;

	return 0;

out_kcm:
	remove_proc_entry("kcm_stats", net->proc_net);
out_kcm_stats:
	return err;
}

static void kcm_proc_exit_net(struct net *net)
{
	kcm_proc_unregister(net, &kcm_seq_muxinfo);
	remove_proc_entry("kcm_stats", net->proc_net);
}

static struct pernet_operations kcm_net_ops = {
	.init = kcm_proc_init_net,
	.exit = kcm_proc_exit_net,
};

int __init kcm_proc_init(void)
{
	return register_pernet_subsys(&kcm_net_ops);
}

void __exit kcm_proc_exit(void)
{
	unregister_pernet_subsys(&kcm_net_ops);
}

#endif /* CONFIG_PROC_FS */
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
cd6e111b TH	2	#include <linux/in.h>
	3	#include <linux/inet.h>
	4	#include <linux/list.h>
	5	#include <linux/module.h>
	6	#include <linux/net.h>
	7	#include <linux/proc_fs.h>
	8	#include <linux/rculist.h>
	9	#include <linux/seq_file.h>
	10	#include <linux/socket.h>
	11	#include <net/inet_sock.h>
	12	#include <net/kcm.h>
	13	#include <net/net_namespace.h>
	14	#include <net/netns/generic.h>
	15	#include <net/tcp.h>
	16
	17	#ifdef CONFIG_PROC_FS
	18	struct kcm_seq_muxinfo {
	19	char *name;
	20	const struct file_operations *seq_fops;
	21	const struct seq_operations seq_ops;
	22	};
	23
	24	static struct kcm_mux kcm_get_first(struct seq_file seq)
	25	{
	26	struct net *net = seq_file_net(seq);
	27	struct kcm_net *knet = net_generic(net, kcm_net_id);
	28
	29	return list_first_or_null_rcu(&knet->mux_list,
	30	struct kcm_mux, kcm_mux_list);
	31	}
	32
	33	static struct kcm_mux kcm_get_next(struct kcm_mux mux)
	34	{
	35	struct kcm_net *knet = mux->knet;
	36
	37	return list_next_or_null_rcu(&knet->mux_list, &mux->kcm_mux_list,
	38	struct kcm_mux, kcm_mux_list);
	39	}
	40
	41	static struct kcm_mux kcm_get_idx(struct seq_file seq, loff_t pos)
	42	{
	43	struct net *net = seq_file_net(seq);
	44	struct kcm_net *knet = net_generic(net, kcm_net_id);
	45	struct kcm_mux *m;
	46
	47	list_for_each_entry_rcu(m, &knet->mux_list, kcm_mux_list) {
	48	if (!pos)
	49	return m;
	50	--pos;
	51	}
	52	return NULL;
	53	}
	54
	55	static void kcm_seq_next(struct seq_file seq, void v, loff_t pos)
	56	{
	57	void *p;
	58
	59	if (v == SEQ_START_TOKEN)
	60	p = kcm_get_first(seq);
	61	else
	62	p = kcm_get_next(v);
	63	++*pos;
	64	return p;
	65	}
66
67	static void kcm_seq_start(struct seq_file seq, loff_t *pos)
68	__acquires(rcu)
69	{
70	rcu_read_lock();
71
72	if (!*pos)
73	return SEQ_START_TOKEN;
74	else
75	return kcm_get_idx(seq, *pos - 1);
76	}
77
78	static void kcm_seq_stop(struct seq_file seq, void v)
79	__releases(rcu)
80	{
81	rcu_read_unlock();
82	}
83
84	struct kcm_proc_mux_state {
85	struct seq_net_private p;
86	int idx;
87	};
88
89	static int kcm_seq_open(struct inode inode, struct file file)
90	{
91	struct kcm_seq_muxinfo *muxinfo = PDE_DATA(inode);
cd6e111b	92
0a58f474	93	return seq_open_net(inode, file, &muxinfo->seq_ops,
cd6e111b	94	sizeof(struct kcm_proc_mux_state));
cd6e111b TH	95	}
	96
	97	static void kcm_format_mux_header(struct seq_file *seq)
	98	{
	99	struct net *net = seq_file_net(seq);
	100	struct kcm_net *knet = net_generic(net, kcm_net_id);
	101
	102	seq_printf(seq,
	103	"* KCM statistics (%d MUX) **\n",
	104	knet->count);
	105
	106	seq_printf(seq,
	107	"%-14s %-10s %-16s %-10s %-16s %-8s %-8s %-8s %-8s %s",
	108	"Object",
	109	"RX-Msgs",
	110	"RX-Bytes",
	111	"TX-Msgs",
	112	"TX-Bytes",
	113	"Recv-Q",
	114	"Rmem",
	115	"Send-Q",
	116	"Smem",
	117	"Status");
	118
	119	/* XXX: pdsts header stuff here */
	120	seq_puts(seq, "\n");
	121	}
	122
	123	static void kcm_format_sock(struct kcm_sock kcm, struct seq_file seq,
	124	int i, int *len)
	125	{
	126	seq_printf(seq,
	127	" kcm-%-7u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8s ",
	128	kcm->index,
	129	kcm->stats.rx_msgs,
	130	kcm->stats.rx_bytes,
	131	kcm->stats.tx_msgs,
	132	kcm->stats.tx_bytes,
	133	kcm->sk.sk_receive_queue.qlen,
	134	sk_rmem_alloc_get(&kcm->sk),
	135	kcm->sk.sk_write_queue.qlen,
	136	"-");
	137
	138	if (kcm->tx_psock)
	139	seq_printf(seq, "Psck-%u ", kcm->tx_psock->index);
	140
	141	if (kcm->tx_wait)
	142	seq_puts(seq, "TxWait ");
	143
	144	if (kcm->tx_wait_more)
	145	seq_puts(seq, "WMore ");
	146
	147	if (kcm->rx_wait)
	148	seq_puts(seq, "RxWait ");
	149
	150	seq_puts(seq, "\n");
	151	}
	152
	153	static void kcm_format_psock(struct kcm_psock psock, struct seq_file seq,
	154	int i, int *len)
	155	{
	156	seq_printf(seq,
	157	" psock-%-5u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8d ",
	158	psock->index,
bbb03029 TH	159	psock->strp.stats.msgs,
bbb03029 TH	160	psock->strp.stats.bytes,
cd6e111b TH	161	psock->stats.tx_msgs,
	162	psock->stats.tx_bytes,
	163	psock->sk->sk_receive_queue.qlen,
	164	atomic_read(&psock->sk->sk_rmem_alloc),
	165	psock->sk->sk_write_queue.qlen,
14afee4b	166	refcount_read(&psock->sk->sk_wmem_alloc));
cd6e111b TH	167
	168	if (psock->done)
	169	seq_puts(seq, "Done ");
	170
	171	if (psock->tx_stopped)
	172	seq_puts(seq, "TxStop ");
	173
bbb03029	174	if (psock->strp.stopped)
cd6e111b TH	175	seq_puts(seq, "RxStop ");
	176
	177	if (psock->tx_kcm)
	178	seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index);
	179
bbb03029	180	if (!psock->strp.paused && !psock->ready_rx_msg) {
1616b38f	181	if (psock->sk->sk_receive_queue.qlen) {
bbb03029	182	if (psock->strp.need_bytes)
1616b38f	183	seq_printf(seq, "RxWait=%u ",
bbb03029	184	psock->strp.need_bytes);
1616b38f TH	185	else
	186	seq_printf(seq, "RxWait ");
	187	}
	188	} else {
bbb03029	189	if (psock->strp.paused)
1616b38f TH	190	seq_puts(seq, "RxPause ");
	191
	192	if (psock->ready_rx_msg)
	193	seq_puts(seq, "RdyRx ");
	194	}
cd6e111b TH	195
	196	seq_puts(seq, "\n");
	197	}
	198
	199	static void
	200	kcm_format_mux(struct kcm_mux mux, loff_t idx, struct seq_file seq)
	201	{
	202	int i, len;
	203	struct kcm_sock *kcm;
	204	struct kcm_psock *psock;
	205
	206	/* mux information */
	207	seq_printf(seq,
	208	"%-6s%-8s %-10llu %-16llu %-10llu %-16llu %-8s %-8s %-8s %-8s ",
	209	"mux", "",
	210	mux->stats.rx_msgs,
	211	mux->stats.rx_bytes,
	212	mux->stats.tx_msgs,
	213	mux->stats.tx_bytes,
	214	"-", "-", "-", "-");
	215
	216	seq_printf(seq, "KCMs: %d, Psocks %d\n",
	217	mux->kcm_socks_cnt, mux->psocks_cnt);
	218
	219	/* kcm sock information */
	220	i = 0;
	221	spin_lock_bh(&mux->lock);
	222	list_for_each_entry(kcm, &mux->kcm_socks, kcm_sock_list) {
	223	kcm_format_sock(kcm, seq, i, &len);
	224	i++;
	225	}
	226	i = 0;
	227	list_for_each_entry(psock, &mux->psocks, psock_list) {
	228	kcm_format_psock(psock, seq, i, &len);
	229	i++;
	230	}
	231	spin_unlock_bh(&mux->lock);
	232	}
	233
	234	static int kcm_seq_show(struct seq_file seq, void v)
	235	{
	236	struct kcm_proc_mux_state *mux_state;
	237
	238	mux_state = seq->private;
	239	if (v == SEQ_START_TOKEN) {
	240	mux_state->idx = 0;
	241	kcm_format_mux_header(seq);
	242	} else {
	243	kcm_format_mux(v, mux_state->idx, seq);
	244	mux_state->idx++;
	245	}
	246	return 0;
	247	}
	248
	249	static const struct file_operations kcm_seq_fops = {
cd6e111b TH	250	.open = kcm_seq_open,
	251	.read = seq_read,
	252	.llseek = seq_lseek,
d19af0a7	253	.release = seq_release_net,
cd6e111b TH	254	};
	255
	256	static struct kcm_seq_muxinfo kcm_seq_muxinfo = {
	257	.name = "kcm",
	258	.seq_fops = &kcm_seq_fops,
	259	.seq_ops = {
	260	.show = kcm_seq_show,
	261	.start = kcm_seq_start,
	262	.next = kcm_seq_next,
	263	.stop = kcm_seq_stop,
	264	}
	265	};
	266
	267	static int kcm_proc_register(struct net net, struct kcm_seq_muxinfo muxinfo)
	268	{
	269	struct proc_dir_entry *p;
	270	int rc = 0;
	271
d6444062	272	p = proc_create_data(muxinfo->name, 0444, net->proc_net,
cd6e111b TH	273	muxinfo->seq_fops, muxinfo);
	274	if (!p)
	275	rc = -ENOMEM;
	276	return rc;
	277	}
	278	EXPORT_SYMBOL(kcm_proc_register);
	279
	280	static void kcm_proc_unregister(struct net *net,
	281	struct kcm_seq_muxinfo *muxinfo)
	282	{
	283	remove_proc_entry(muxinfo->name, net->proc_net);
	284	}
	285	EXPORT_SYMBOL(kcm_proc_unregister);
	286
	287	static int kcm_stats_seq_show(struct seq_file seq, void v)
	288	{
	289	struct kcm_psock_stats psock_stats;
	290	struct kcm_mux_stats mux_stats;
9b73896a	291	struct strp_aggr_stats strp_stats;
cd6e111b TH	292	struct kcm_mux *mux;
	293	struct kcm_psock *psock;
	294	struct net *net = seq->private;
	295	struct kcm_net *knet = net_generic(net, kcm_net_id);
	296
	297	memset(&mux_stats, 0, sizeof(mux_stats));
	298	memset(&psock_stats, 0, sizeof(psock_stats));
9b73896a	299	memset(&strp_stats, 0, sizeof(strp_stats));
cd6e111b TH	300
	301	mutex_lock(&knet->mutex);
	302
	303	aggregate_mux_stats(&knet->aggregate_mux_stats, &mux_stats);
	304	aggregate_psock_stats(&knet->aggregate_psock_stats,
	305	&psock_stats);
9b73896a TH	306	aggregate_strp_stats(&knet->aggregate_strp_stats,
9b73896a TH	307	&strp_stats);
cd6e111b TH	308
	309	list_for_each_entry_rcu(mux, &knet->mux_list, kcm_mux_list) {
	310	spin_lock_bh(&mux->lock);
	311	aggregate_mux_stats(&mux->stats, &mux_stats);
	312	aggregate_psock_stats(&mux->aggregate_psock_stats,
	313	&psock_stats);
9b73896a TH	314	aggregate_strp_stats(&mux->aggregate_strp_stats,
	315	&strp_stats);
	316	list_for_each_entry(psock, &mux->psocks, psock_list) {
cd6e111b	317	aggregate_psock_stats(&psock->stats, &psock_stats);
9b73896a TH	318	save_strp_stats(&psock->strp, &strp_stats);
	319	}
	320
cd6e111b TH	321	spin_unlock_bh(&mux->lock);
	322	}
	323
	324	mutex_unlock(&knet->mutex);
	325
	326	seq_printf(seq,
	327	"%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s\n",
	328	"MUX",
	329	"RX-Msgs",
	330	"RX-Bytes",
	331	"TX-Msgs",
	332	"TX-Bytes",
	333	"TX-Retries",
	334	"Attach",
	335	"Unattach",
	336	"UnattchRsvd",
	337	"RX-RdyDrops");
	338
	339	seq_printf(seq,
	340	"%-8s %-10llu %-16llu %-10llu %-16llu %-10u %-10u %-10u %-10u %-10u\n",
	341	"",
	342	mux_stats.rx_msgs,
	343	mux_stats.rx_bytes,
	344	mux_stats.tx_msgs,
	345	mux_stats.tx_bytes,
	346	mux_stats.tx_retries,
	347	mux_stats.psock_attach,
	348	mux_stats.psock_unattach_rsvd,
	349	mux_stats.psock_unattach,
	350	mux_stats.rx_ready_drops);
	351
	352	seq_printf(seq,
9b73896a	353	"%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n",
cd6e111b TH	354	"Psock",
	355	"RX-Msgs",
	356	"RX-Bytes",
	357	"TX-Msgs",
	358	"TX-Bytes",
	359	"Reserved",
	360	"Unreserved",
	361	"RX-Aborts",
9b73896a TH	362	"RX-Intr",
9b73896a TH	363	"RX-Unrecov",
cd6e111b TH	364	"RX-MemFail",
	365	"RX-NeedMor",
	366	"RX-BadLen",
7ced95ef	367	"RX-TooBig",
29152a34	368	"RX-Timeout",
cd6e111b TH	369	"TX-Aborts");
	370
	371	seq_printf(seq,
9b73896a	372	"%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n",
cd6e111b	373	"",
bbb03029 TH	374	strp_stats.msgs,
bbb03029 TH	375	strp_stats.bytes,
cd6e111b TH	376	psock_stats.tx_msgs,
	377	psock_stats.tx_bytes,
	378	psock_stats.reserved,
	379	psock_stats.unreserved,
bbb03029 TH	380	strp_stats.aborts,
	381	strp_stats.interrupted,
	382	strp_stats.unrecov_intr,
	383	strp_stats.mem_fail,
	384	strp_stats.need_more_hdr,
	385	strp_stats.bad_hdr_len,
	386	strp_stats.msg_too_big,
	387	strp_stats.msg_timeouts,
cd6e111b TH	388	psock_stats.tx_aborts);
	389
	390	return 0;
	391	}
	392
	393	static int kcm_stats_seq_open(struct inode inode, struct file file)
	394	{
	395	return single_open_net(inode, file, kcm_stats_seq_show);
	396	}
	397
	398	static const struct file_operations kcm_stats_seq_fops = {
cd6e111b TH	399	.open = kcm_stats_seq_open,
	400	.read = seq_read,
	401	.llseek = seq_lseek,
	402	.release = single_release_net,
	403	};
	404
	405	static int kcm_proc_init_net(struct net *net)
	406	{
	407	int err;
	408
d6444062	409	if (!proc_create("kcm_stats", 0444, net->proc_net,
cd6e111b TH	410	&kcm_stats_seq_fops)) {
	411	err = -ENOMEM;
	412	goto out_kcm_stats;
	413	}
	414
	415	err = kcm_proc_register(net, &kcm_seq_muxinfo);
	416	if (err)
	417	goto out_kcm;
	418
	419	return 0;
	420
	421	out_kcm:
	422	remove_proc_entry("kcm_stats", net->proc_net);
	423	out_kcm_stats:
	424	return err;
	425	}
	426
	427	static void kcm_proc_exit_net(struct net *net)
	428	{
	429	kcm_proc_unregister(net, &kcm_seq_muxinfo);
	430	remove_proc_entry("kcm_stats", net->proc_net);
	431	}
	432
	433	static struct pernet_operations kcm_net_ops = {
	434	.init = kcm_proc_init_net,
	435	.exit = kcm_proc_exit_net,
	436	};
	437
	438	int __init kcm_proc_init(void)
	439	{
	440	return register_pernet_subsys(&kcm_net_ops);
	441	}
	442
	443	void __exit kcm_proc_exit(void)
	444	{
	445	unregister_pernet_subsys(&kcm_net_ops);
	446	}
	447
	448	#endif /* CONFIG_PROC_FS */