[deliverable/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);
	int err;

	err = seq_open_net(inode, file, &muxinfo->seq_ops,
			   sizeof(struct kcm_proc_mux_state));
	if (err < 0)
		return err;
	return err;
}

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->stats.rx_msgs,
		   psock->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->rx_stopped)
		seq_puts(seq, "RxStop ");

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

	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 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));

	mutex_lock(&knet->mutex);

	aggregate_mux_stats(&knet->aggregate_mux_stats, &mux_stats);
	aggregate_psock_stats(&knet->aggregate_psock_stats,
			      &psock_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);
		list_for_each_entry(psock, &mux->psocks, psock_list)
			aggregate_psock_stats(&psock->stats, &psock_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\n",
		   "Psock",
		   "RX-Msgs",
		   "RX-Bytes",
		   "TX-Msgs",
		   "TX-Bytes",
		   "Reserved",
		   "Unreserved",
		   "RX-Aborts",
		   "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\n",
		   "",
		   psock_stats.rx_msgs,
		   psock_stats.rx_bytes,
		   psock_stats.tx_msgs,
		   psock_stats.tx_bytes,
		   psock_stats.reserved,
		   psock_stats.unreserved,
		   psock_stats.rx_aborts,
		   psock_stats.rx_mem_fail,
		   psock_stats.rx_need_more_hdr,
		   psock_stats.rx_bad_hdr_len,
		   psock_stats.rx_msg_too_big,
		   psock_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);
91	int err;
92
93	err = seq_open_net(inode, file, &muxinfo->seq_ops,
94	sizeof(struct kcm_proc_mux_state));
95	if (err < 0)
96	return err;
97	return err;
98	}
99
100	static void kcm_format_mux_header(struct seq_file *seq)
101	{
102	struct net *net = seq_file_net(seq);
103	struct kcm_net *knet = net_generic(net, kcm_net_id);
104
105	seq_printf(seq,
106	"* KCM statistics (%d MUX) **\n",
107	knet->count);
108
109	seq_printf(seq,
110	"%-14s %-10s %-16s %-10s %-16s %-8s %-8s %-8s %-8s %s",
111	"Object",
112	"RX-Msgs",
113	"RX-Bytes",
114	"TX-Msgs",
115	"TX-Bytes",
116	"Recv-Q",
117	"Rmem",
118	"Send-Q",
119	"Smem",
120	"Status");
121
122	/* XXX: pdsts header stuff here */
123	seq_puts(seq, "\n");
124	}
125
126	static void kcm_format_sock(struct kcm_sock kcm, struct seq_file seq,
127	int i, int *len)
128	{
129	seq_printf(seq,
130	" kcm-%-7u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8s ",
131	kcm->index,
132	kcm->stats.rx_msgs,
133	kcm->stats.rx_bytes,
134	kcm->stats.tx_msgs,
135	kcm->stats.tx_bytes,
136	kcm->sk.sk_receive_queue.qlen,
137	sk_rmem_alloc_get(&kcm->sk),
138	kcm->sk.sk_write_queue.qlen,
139	"-");
140
141	if (kcm->tx_psock)
142	seq_printf(seq, "Psck-%u ", kcm->tx_psock->index);
143
144	if (kcm->tx_wait)
145	seq_puts(seq, "TxWait ");
146
147	if (kcm->tx_wait_more)
148	seq_puts(seq, "WMore ");
149
150	if (kcm->rx_wait)
151	seq_puts(seq, "RxWait ");
152
153	seq_puts(seq, "\n");
154	}
155
156	static void kcm_format_psock(struct kcm_psock psock, struct seq_file seq,
157	int i, int *len)
158	{
159	seq_printf(seq,
160	" psock-%-5u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8d ",
161	psock->index,
162	psock->stats.rx_msgs,
163	psock->stats.rx_bytes,
164	psock->stats.tx_msgs,
165	psock->stats.tx_bytes,
166	psock->sk->sk_receive_queue.qlen,
167	atomic_read(&psock->sk->sk_rmem_alloc),
168	psock->sk->sk_write_queue.qlen,
169	atomic_read(&psock->sk->sk_wmem_alloc));
170
171	if (psock->done)
172	seq_puts(seq, "Done ");
173
174	if (psock->tx_stopped)
175	seq_puts(seq, "TxStop ");
176
177	if (psock->rx_stopped)
178	seq_puts(seq, "RxStop ");
179
180	if (psock->tx_kcm)
181	seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index);
182
183	if (psock->ready_rx_msg)
184	seq_puts(seq, "RdyRx ");
185
186	seq_puts(seq, "\n");
187	}
188
189	static void
190	kcm_format_mux(struct kcm_mux mux, loff_t idx, struct seq_file seq)
191	{
192	int i, len;
193	struct kcm_sock *kcm;
194	struct kcm_psock *psock;
195
196	/* mux information */
197	seq_printf(seq,
198	"%-6s%-8s %-10llu %-16llu %-10llu %-16llu %-8s %-8s %-8s %-8s ",
199	"mux", "",
200	mux->stats.rx_msgs,
201	mux->stats.rx_bytes,
202	mux->stats.tx_msgs,
203	mux->stats.tx_bytes,
204	"-", "-", "-", "-");
205
206	seq_printf(seq, "KCMs: %d, Psocks %d\n",
207	mux->kcm_socks_cnt, mux->psocks_cnt);
208
209	/* kcm sock information */
210	i = 0;
211	spin_lock_bh(&mux->lock);
212	list_for_each_entry(kcm, &mux->kcm_socks, kcm_sock_list) {
213	kcm_format_sock(kcm, seq, i, &len);
214	i++;
215	}
216	i = 0;
217	list_for_each_entry(psock, &mux->psocks, psock_list) {
218	kcm_format_psock(psock, seq, i, &len);
219	i++;
220	}
221	spin_unlock_bh(&mux->lock);
222	}
223
224	static int kcm_seq_show(struct seq_file seq, void v)
225	{
226	struct kcm_proc_mux_state *mux_state;
227
228	mux_state = seq->private;
229	if (v == SEQ_START_TOKEN) {
230	mux_state->idx = 0;
231	kcm_format_mux_header(seq);
232	} else {
233	kcm_format_mux(v, mux_state->idx, seq);
234	mux_state->idx++;
235	}
236	return 0;
237	}
238
239	static const struct file_operations kcm_seq_fops = {
240	.owner = THIS_MODULE,
241	.open = kcm_seq_open,
242	.read = seq_read,
243	.llseek = seq_lseek,
d19af0a7	244	.release = seq_release_net,
cd6e111b TH	245	};
	246
	247	static struct kcm_seq_muxinfo kcm_seq_muxinfo = {
	248	.name = "kcm",
	249	.seq_fops = &kcm_seq_fops,
	250	.seq_ops = {
	251	.show = kcm_seq_show,
	252	.start = kcm_seq_start,
	253	.next = kcm_seq_next,
	254	.stop = kcm_seq_stop,
	255	}
	256	};
	257
	258	static int kcm_proc_register(struct net net, struct kcm_seq_muxinfo muxinfo)
	259	{
	260	struct proc_dir_entry *p;
	261	int rc = 0;
	262
	263	p = proc_create_data(muxinfo->name, S_IRUGO, net->proc_net,
	264	muxinfo->seq_fops, muxinfo);
	265	if (!p)
	266	rc = -ENOMEM;
	267	return rc;
	268	}
	269	EXPORT_SYMBOL(kcm_proc_register);
	270
	271	static void kcm_proc_unregister(struct net *net,
	272	struct kcm_seq_muxinfo *muxinfo)
	273	{
	274	remove_proc_entry(muxinfo->name, net->proc_net);
	275	}
	276	EXPORT_SYMBOL(kcm_proc_unregister);
	277
	278	static int kcm_stats_seq_show(struct seq_file seq, void v)
	279	{
	280	struct kcm_psock_stats psock_stats;
	281	struct kcm_mux_stats mux_stats;
	282	struct kcm_mux *mux;
	283	struct kcm_psock *psock;
	284	struct net *net = seq->private;
	285	struct kcm_net *knet = net_generic(net, kcm_net_id);
	286
	287	memset(&mux_stats, 0, sizeof(mux_stats));
	288	memset(&psock_stats, 0, sizeof(psock_stats));
	289
	290	mutex_lock(&knet->mutex);
	291
	292	aggregate_mux_stats(&knet->aggregate_mux_stats, &mux_stats);
	293	aggregate_psock_stats(&knet->aggregate_psock_stats,
	294	&psock_stats);
	295
	296	list_for_each_entry_rcu(mux, &knet->mux_list, kcm_mux_list) {
	297	spin_lock_bh(&mux->lock);
	298	aggregate_mux_stats(&mux->stats, &mux_stats);
	299	aggregate_psock_stats(&mux->aggregate_psock_stats,
	300	&psock_stats);
	301	list_for_each_entry(psock, &mux->psocks, psock_list)
	302	aggregate_psock_stats(&psock->stats, &psock_stats);
	303	spin_unlock_bh(&mux->lock);
	304	}
	305
	306	mutex_unlock(&knet->mutex);
	307
	308	seq_printf(seq,
309	"%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s\n",
310	"MUX",
311	"RX-Msgs",
312	"RX-Bytes",
313	"TX-Msgs",
314	"TX-Bytes",
315	"TX-Retries",
316	"Attach",
317	"Unattach",
318	"UnattchRsvd",
319	"RX-RdyDrops");
320
321	seq_printf(seq,
322	"%-8s %-10llu %-16llu %-10llu %-16llu %-10u %-10u %-10u %-10u %-10u\n",
323	"",
324	mux_stats.rx_msgs,
325	mux_stats.rx_bytes,
326	mux_stats.tx_msgs,
327	mux_stats.tx_bytes,
328	mux_stats.tx_retries,
329	mux_stats.psock_attach,
330	mux_stats.psock_unattach_rsvd,
331	mux_stats.psock_unattach,
332	mux_stats.rx_ready_drops);
333
334	seq_printf(seq,
29152a34	335	"%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n",
cd6e111b TH	336	"Psock",
	337	"RX-Msgs",
	338	"RX-Bytes",
	339	"TX-Msgs",
	340	"TX-Bytes",
	341	"Reserved",
	342	"Unreserved",
	343	"RX-Aborts",
	344	"RX-MemFail",
	345	"RX-NeedMor",
	346	"RX-BadLen",
7ced95ef	347	"RX-TooBig",
29152a34	348	"RX-Timeout",
cd6e111b TH	349	"TX-Aborts");
	350
	351	seq_printf(seq,
29152a34	352	"%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n",
cd6e111b TH	353	"",
	354	psock_stats.rx_msgs,
	355	psock_stats.rx_bytes,
	356	psock_stats.tx_msgs,
	357	psock_stats.tx_bytes,
	358	psock_stats.reserved,
	359	psock_stats.unreserved,
	360	psock_stats.rx_aborts,
	361	psock_stats.rx_mem_fail,
	362	psock_stats.rx_need_more_hdr,
	363	psock_stats.rx_bad_hdr_len,
7ced95ef	364	psock_stats.rx_msg_too_big,
29152a34	365	psock_stats.rx_msg_timeouts,
cd6e111b TH	366	psock_stats.tx_aborts);
	367
	368	return 0;
	369	}
	370
	371	static int kcm_stats_seq_open(struct inode inode, struct file file)
	372	{
	373	return single_open_net(inode, file, kcm_stats_seq_show);
	374	}
	375
	376	static const struct file_operations kcm_stats_seq_fops = {
	377	.owner = THIS_MODULE,
	378	.open = kcm_stats_seq_open,
	379	.read = seq_read,
	380	.llseek = seq_lseek,
	381	.release = single_release_net,
	382	};
	383
	384	static int kcm_proc_init_net(struct net *net)
	385	{
	386	int err;
	387
	388	if (!proc_create("kcm_stats", S_IRUGO, net->proc_net,
	389	&kcm_stats_seq_fops)) {
	390	err = -ENOMEM;
	391	goto out_kcm_stats;
	392	}
	393
	394	err = kcm_proc_register(net, &kcm_seq_muxinfo);
	395	if (err)
	396	goto out_kcm;
	397
	398	return 0;
	399
	400	out_kcm:
	401	remove_proc_entry("kcm_stats", net->proc_net);
	402	out_kcm_stats:
	403	return err;
	404	}
	405
	406	static void kcm_proc_exit_net(struct net *net)
	407	{
	408	kcm_proc_unregister(net, &kcm_seq_muxinfo);
	409	remove_proc_entry("kcm_stats", net->proc_net);
	410	}
	411
	412	static struct pernet_operations kcm_net_ops = {
	413	.init = kcm_proc_init_net,
	414	.exit = kcm_proc_exit_net,
	415	};
	416
	417	int __init kcm_proc_init(void)
	418	{
	419	return register_pernet_subsys(&kcm_net_ops);
	420	}
	421
	422	void __exit kcm_proc_exit(void)
	423	{
	424	unregister_pernet_subsys(&kcm_net_ops);
	425	}
	426
	427	#endif /* CONFIG_PROC_FS */