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

#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.rx_msgs,
		   psock->strp.stats.rx_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,
		   atomic_read(&psock->sk->sk_wmem_alloc));

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

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

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

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

	if (!psock->strp.rx_paused && !psock->ready_rx_msg) {
		if (psock->sk->sk_receive_queue.qlen) {
			if (psock->strp.rx_need_bytes)
				seq_printf(seq, "RxWait=%u ",
					   psock->strp.rx_need_bytes);
			else
				seq_printf(seq, "RxWait ");
		}
	} else  {
		if (psock->strp.rx_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.rx_msgs,
		   strp_stats.rx_bytes,
		   psock_stats.tx_msgs,
		   psock_stats.tx_bytes,
		   psock_stats.reserved,
		   psock_stats.unreserved,
		   strp_stats.rx_aborts,
		   strp_stats.rx_interrupted,
		   strp_stats.rx_unrecov_intr,
		   strp_stats.rx_mem_fail,
		   strp_stats.rx_need_more_hdr,
		   strp_stats.rx_bad_hdr_len,
		   strp_stats.rx_msg_too_big,
		   strp_stats.rx_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 */
Commit	Line	Data
cd6e111b TH	1	#include <linux/in.h>
	2	#include <linux/inet.h>
	3	#include <linux/list.h>
	4	#include <linux/module.h>
	5	#include <linux/net.h>
	6	#include <linux/proc_fs.h>
	7	#include <linux/rculist.h>
	8	#include <linux/seq_file.h>
	9	#include <linux/socket.h>
	10	#include <net/inet_sock.h>
	11	#include <net/kcm.h>
	12	#include <net/net_namespace.h>
	13	#include <net/netns/generic.h>
	14	#include <net/tcp.h>
	15
	16	#ifdef CONFIG_PROC_FS
	17	struct kcm_seq_muxinfo {
	18	char *name;
	19	const struct file_operations *seq_fops;
	20	const struct seq_operations seq_ops;
	21	};
	22
	23	static struct kcm_mux kcm_get_first(struct seq_file seq)
	24	{
	25	struct net *net = seq_file_net(seq);
	26	struct kcm_net *knet = net_generic(net, kcm_net_id);
	27
	28	return list_first_or_null_rcu(&knet->mux_list,
	29	struct kcm_mux, kcm_mux_list);
	30	}
	31
	32	static struct kcm_mux kcm_get_next(struct kcm_mux mux)
	33	{
	34	struct kcm_net *knet = mux->knet;
	35
	36	return list_next_or_null_rcu(&knet->mux_list, &mux->kcm_mux_list,
	37	struct kcm_mux, kcm_mux_list);
	38	}
	39
	40	static struct kcm_mux kcm_get_idx(struct seq_file seq, loff_t pos)
	41	{
	42	struct net *net = seq_file_net(seq);
	43	struct kcm_net *knet = net_generic(net, kcm_net_id);
	44	struct kcm_mux *m;
	45
	46	list_for_each_entry_rcu(m, &knet->mux_list, kcm_mux_list) {
	47	if (!pos)
	48	return m;
	49	--pos;
	50	}
	51	return NULL;
	52	}
	53
	54	static void kcm_seq_next(struct seq_file seq, void v, loff_t pos)
	55	{
	56	void *p;
	57
	58	if (v == SEQ_START_TOKEN)
	59	p = kcm_get_first(seq);
	60	else
	61	p = kcm_get_next(v);
	62	++*pos;
	63	return p;
	64	}
65
66	static void kcm_seq_start(struct seq_file seq, loff_t *pos)
67	__acquires(rcu)
68	{
69	rcu_read_lock();
70
71	if (!*pos)
72	return SEQ_START_TOKEN;
73	else
74	return kcm_get_idx(seq, *pos - 1);
75	}
76
77	static void kcm_seq_stop(struct seq_file seq, void v)
78	__releases(rcu)
79	{
80	rcu_read_unlock();
81	}
82
83	struct kcm_proc_mux_state {
84	struct seq_net_private p;
85	int idx;
86	};
87
88	static int kcm_seq_open(struct inode inode, struct file file)
89	{
90	struct kcm_seq_muxinfo *muxinfo = PDE_DATA(inode);
cd6e111b	91
0a58f474	92	return seq_open_net(inode, file, &muxinfo->seq_ops,
cd6e111b	93	sizeof(struct kcm_proc_mux_state));
cd6e111b TH	94	}
	95
	96	static void kcm_format_mux_header(struct seq_file *seq)
	97	{
	98	struct net *net = seq_file_net(seq);
	99	struct kcm_net *knet = net_generic(net, kcm_net_id);
	100
	101	seq_printf(seq,
	102	"* KCM statistics (%d MUX) **\n",
	103	knet->count);
	104
	105	seq_printf(seq,
	106	"%-14s %-10s %-16s %-10s %-16s %-8s %-8s %-8s %-8s %s",
	107	"Object",
	108	"RX-Msgs",
	109	"RX-Bytes",
	110	"TX-Msgs",
	111	"TX-Bytes",
	112	"Recv-Q",
	113	"Rmem",
	114	"Send-Q",
	115	"Smem",
	116	"Status");
	117
	118	/* XXX: pdsts header stuff here */
	119	seq_puts(seq, "\n");
	120	}
	121
	122	static void kcm_format_sock(struct kcm_sock kcm, struct seq_file seq,
	123	int i, int *len)
	124	{
	125	seq_printf(seq,
	126	" kcm-%-7u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8s ",
	127	kcm->index,
	128	kcm->stats.rx_msgs,
	129	kcm->stats.rx_bytes,
	130	kcm->stats.tx_msgs,
	131	kcm->stats.tx_bytes,
	132	kcm->sk.sk_receive_queue.qlen,
	133	sk_rmem_alloc_get(&kcm->sk),
	134	kcm->sk.sk_write_queue.qlen,
	135	"-");
	136
	137	if (kcm->tx_psock)
	138	seq_printf(seq, "Psck-%u ", kcm->tx_psock->index);
	139
	140	if (kcm->tx_wait)
	141	seq_puts(seq, "TxWait ");
	142
	143	if (kcm->tx_wait_more)
	144	seq_puts(seq, "WMore ");
	145
	146	if (kcm->rx_wait)
	147	seq_puts(seq, "RxWait ");
	148
	149	seq_puts(seq, "\n");
	150	}
	151
	152	static void kcm_format_psock(struct kcm_psock psock, struct seq_file seq,
	153	int i, int *len)
	154	{
	155	seq_printf(seq,
	156	" psock-%-5u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8d ",
	157	psock->index,
9b73896a TH	158	psock->strp.stats.rx_msgs,
9b73896a TH	159	psock->strp.stats.rx_bytes,
cd6e111b TH	160	psock->stats.tx_msgs,
	161	psock->stats.tx_bytes,
	162	psock->sk->sk_receive_queue.qlen,
	163	atomic_read(&psock->sk->sk_rmem_alloc),
	164	psock->sk->sk_write_queue.qlen,
	165	atomic_read(&psock->sk->sk_wmem_alloc));
	166
	167	if (psock->done)
	168	seq_puts(seq, "Done ");
	169
	170	if (psock->tx_stopped)
	171	seq_puts(seq, "TxStop ");
	172
9b73896a	173	if (psock->strp.rx_stopped)
cd6e111b TH	174	seq_puts(seq, "RxStop ");
	175
	176	if (psock->tx_kcm)
	177	seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index);
	178
1616b38f TH	179	if (!psock->strp.rx_paused && !psock->ready_rx_msg) {
	180	if (psock->sk->sk_receive_queue.qlen) {
	181	if (psock->strp.rx_need_bytes)
	182	seq_printf(seq, "RxWait=%u ",
	183	psock->strp.rx_need_bytes);
	184	else
	185	seq_printf(seq, "RxWait ");
	186	}
	187	} else {
	188	if (psock->strp.rx_paused)
	189	seq_puts(seq, "RxPause ");
	190
	191	if (psock->ready_rx_msg)
	192	seq_puts(seq, "RdyRx ");
	193	}
cd6e111b TH	194
	195	seq_puts(seq, "\n");
	196	}
	197
	198	static void
	199	kcm_format_mux(struct kcm_mux mux, loff_t idx, struct seq_file seq)
	200	{
	201	int i, len;
	202	struct kcm_sock *kcm;
	203	struct kcm_psock *psock;
	204
	205	/* mux information */
	206	seq_printf(seq,
	207	"%-6s%-8s %-10llu %-16llu %-10llu %-16llu %-8s %-8s %-8s %-8s ",
	208	"mux", "",
	209	mux->stats.rx_msgs,
	210	mux->stats.rx_bytes,
	211	mux->stats.tx_msgs,
	212	mux->stats.tx_bytes,
	213	"-", "-", "-", "-");
	214
	215	seq_printf(seq, "KCMs: %d, Psocks %d\n",
	216	mux->kcm_socks_cnt, mux->psocks_cnt);
	217
	218	/* kcm sock information */
	219	i = 0;
	220	spin_lock_bh(&mux->lock);
	221	list_for_each_entry(kcm, &mux->kcm_socks, kcm_sock_list) {
	222	kcm_format_sock(kcm, seq, i, &len);
	223	i++;
	224	}
	225	i = 0;
	226	list_for_each_entry(psock, &mux->psocks, psock_list) {
	227	kcm_format_psock(psock, seq, i, &len);
	228	i++;
	229	}
	230	spin_unlock_bh(&mux->lock);
	231	}
	232
	233	static int kcm_seq_show(struct seq_file seq, void v)
	234	{
	235	struct kcm_proc_mux_state *mux_state;
	236
	237	mux_state = seq->private;
	238	if (v == SEQ_START_TOKEN) {
	239	mux_state->idx = 0;
	240	kcm_format_mux_header(seq);
	241	} else {
	242	kcm_format_mux(v, mux_state->idx, seq);
	243	mux_state->idx++;
	244	}
	245	return 0;
	246	}
	247
	248	static const struct file_operations kcm_seq_fops = {
	249	.owner = THIS_MODULE,
	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
	272	p = proc_create_data(muxinfo->name, S_IRUGO, net->proc_net,
	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	"",
9b73896a TH	374	strp_stats.rx_msgs,
9b73896a TH	375	strp_stats.rx_bytes,
cd6e111b TH	376	psock_stats.tx_msgs,
	377	psock_stats.tx_bytes,
	378	psock_stats.reserved,
	379	psock_stats.unreserved,
9b73896a TH	380	strp_stats.rx_aborts,
	381	strp_stats.rx_interrupted,
	382	strp_stats.rx_unrecov_intr,
	383	strp_stats.rx_mem_fail,
	384	strp_stats.rx_need_more_hdr,
	385	strp_stats.rx_bad_hdr_len,
	386	strp_stats.rx_msg_too_big,
	387	strp_stats.rx_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 = {
	399	.owner = THIS_MODULE,
	400	.open = kcm_stats_seq_open,
	401	.read = seq_read,
	402	.llseek = seq_lseek,
	403	.release = single_release_net,
	404	};
	405
	406	static int kcm_proc_init_net(struct net *net)
	407	{
	408	int err;
	409
	410	if (!proc_create("kcm_stats", S_IRUGO, net->proc_net,
	411	&kcm_stats_seq_fops)) {
	412	err = -ENOMEM;
	413	goto out_kcm_stats;
	414	}
	415
	416	err = kcm_proc_register(net, &kcm_seq_muxinfo);
	417	if (err)
	418	goto out_kcm;
	419
	420	return 0;
	421
	422	out_kcm:
	423	remove_proc_entry("kcm_stats", net->proc_net);
	424	out_kcm_stats:
	425	return err;
	426	}
	427
	428	static void kcm_proc_exit_net(struct net *net)
	429	{
	430	kcm_proc_unregister(net, &kcm_seq_muxinfo);
	431	remove_proc_entry("kcm_stats", net->proc_net);
	432	}
	433
	434	static struct pernet_operations kcm_net_ops = {
	435	.init = kcm_proc_init_net,
	436	.exit = kcm_proc_exit_net,
	437	};
	438
	439	int __init kcm_proc_init(void)
	440	{
	441	return register_pernet_subsys(&kcm_net_ops);
	442	}
	443
	444	void __exit kcm_proc_exit(void)
	445	{
	446	unregister_pernet_subsys(&kcm_net_ops);
	447	}
	448
	449	#endif /* CONFIG_PROC_FS */