[linux-block.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
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 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 seq_operations kcm_seq_ops = {
	.show	= kcm_seq_show,
	.start	= kcm_seq_start,
	.next	= kcm_seq_next,
	.stop	= kcm_seq_stop,
};

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(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_proc_init_net(struct net *net)
{
	if (!proc_create_net_single("kcm_stats", 0444, net->proc_net,
			 kcm_stats_seq_show, NULL))
		goto out_kcm_stats;

	if (!proc_create_net("kcm", 0444, net->proc_net, &kcm_seq_ops,
			sizeof(struct kcm_proc_mux_state)))
		goto out_kcm;

	return 0;

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

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