net/kcm/kcmproc.c - arm/linux - Git at Google

 // 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 = {
 	.owner		= THIS_MODULE,
 	.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, S_IRUGO, 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 = {
 	.owner   = THIS_MODULE,
 	.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", S_IRUGO, 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 */
	// 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 = {
	.owner = THIS_MODULE,
	.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, S_IRUGO, 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 = {
	.owner = THIS_MODULE,
	.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", S_IRUGO, 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 */