[linux-2.6-block.git] / net / sctp / proc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* SCTP kernel implementation
 * Copyright (c) 2003 International Business Machines, Corp.
 *
 * This file is part of the SCTP kernel implementation
 *
 * Please send any bug reports or fixes you make to the
 * email address(es):
 *    lksctp developers <linux-sctp@vger.kernel.org>
 *
 * Written or modified by:
 *    Sridhar Samudrala <sri@us.ibm.com>
 */

#include <linux/types.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/export.h>
#include <net/sctp/sctp.h>
#include <net/ip.h> /* for snmp_fold_field */

static const struct snmp_mib sctp_snmp_list[] = {
	SNMP_MIB_ITEM("SctpCurrEstab", SCTP_MIB_CURRESTAB),
	SNMP_MIB_ITEM("SctpActiveEstabs", SCTP_MIB_ACTIVEESTABS),
	SNMP_MIB_ITEM("SctpPassiveEstabs", SCTP_MIB_PASSIVEESTABS),
	SNMP_MIB_ITEM("SctpAborteds", SCTP_MIB_ABORTEDS),
	SNMP_MIB_ITEM("SctpShutdowns", SCTP_MIB_SHUTDOWNS),
	SNMP_MIB_ITEM("SctpOutOfBlues", SCTP_MIB_OUTOFBLUES),
	SNMP_MIB_ITEM("SctpChecksumErrors", SCTP_MIB_CHECKSUMERRORS),
	SNMP_MIB_ITEM("SctpOutCtrlChunks", SCTP_MIB_OUTCTRLCHUNKS),
	SNMP_MIB_ITEM("SctpOutOrderChunks", SCTP_MIB_OUTORDERCHUNKS),
	SNMP_MIB_ITEM("SctpOutUnorderChunks", SCTP_MIB_OUTUNORDERCHUNKS),
	SNMP_MIB_ITEM("SctpInCtrlChunks", SCTP_MIB_INCTRLCHUNKS),
	SNMP_MIB_ITEM("SctpInOrderChunks", SCTP_MIB_INORDERCHUNKS),
	SNMP_MIB_ITEM("SctpInUnorderChunks", SCTP_MIB_INUNORDERCHUNKS),
	SNMP_MIB_ITEM("SctpFragUsrMsgs", SCTP_MIB_FRAGUSRMSGS),
	SNMP_MIB_ITEM("SctpReasmUsrMsgs", SCTP_MIB_REASMUSRMSGS),
	SNMP_MIB_ITEM("SctpOutSCTPPacks", SCTP_MIB_OUTSCTPPACKS),
	SNMP_MIB_ITEM("SctpInSCTPPacks", SCTP_MIB_INSCTPPACKS),
	SNMP_MIB_ITEM("SctpT1InitExpireds", SCTP_MIB_T1_INIT_EXPIREDS),
	SNMP_MIB_ITEM("SctpT1CookieExpireds", SCTP_MIB_T1_COOKIE_EXPIREDS),
	SNMP_MIB_ITEM("SctpT2ShutdownExpireds", SCTP_MIB_T2_SHUTDOWN_EXPIREDS),
	SNMP_MIB_ITEM("SctpT3RtxExpireds", SCTP_MIB_T3_RTX_EXPIREDS),
	SNMP_MIB_ITEM("SctpT4RtoExpireds", SCTP_MIB_T4_RTO_EXPIREDS),
	SNMP_MIB_ITEM("SctpT5ShutdownGuardExpireds", SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS),
	SNMP_MIB_ITEM("SctpDelaySackExpireds", SCTP_MIB_DELAY_SACK_EXPIREDS),
	SNMP_MIB_ITEM("SctpAutocloseExpireds", SCTP_MIB_AUTOCLOSE_EXPIREDS),
	SNMP_MIB_ITEM("SctpT3Retransmits", SCTP_MIB_T3_RETRANSMITS),
	SNMP_MIB_ITEM("SctpPmtudRetransmits", SCTP_MIB_PMTUD_RETRANSMITS),
	SNMP_MIB_ITEM("SctpFastRetransmits", SCTP_MIB_FAST_RETRANSMITS),
	SNMP_MIB_ITEM("SctpInPktSoftirq", SCTP_MIB_IN_PKT_SOFTIRQ),
	SNMP_MIB_ITEM("SctpInPktBacklog", SCTP_MIB_IN_PKT_BACKLOG),
	SNMP_MIB_ITEM("SctpInPktDiscards", SCTP_MIB_IN_PKT_DISCARDS),
	SNMP_MIB_ITEM("SctpInDataChunkDiscards", SCTP_MIB_IN_DATA_CHUNK_DISCARDS),
	SNMP_MIB_SENTINEL
};

/* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
{
	unsigned long buff[SCTP_MIB_MAX];
	struct net *net = seq->private;
	int i;

	memset(buff, 0, sizeof(unsigned long) * SCTP_MIB_MAX);

	snmp_get_cpu_field_batch(buff, sctp_snmp_list,
				 net->sctp.sctp_statistics);
	for (i = 0; sctp_snmp_list[i].name; i++)
		seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
						buff[i]);

	return 0;
}

/* Dump local addresses of an association/endpoint. */
static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
{
	struct sctp_association *asoc;
	struct sctp_sockaddr_entry *laddr;
	struct sctp_transport *peer;
	union sctp_addr *addr, *primary = NULL;
	struct sctp_af *af;

	if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
		asoc = sctp_assoc(epb);

		peer = asoc->peer.primary_path;
		if (unlikely(peer == NULL)) {
			WARN(1, "Association %p with NULL primary path!\n", asoc);
			return;
		}

		primary = &peer->saddr;
	}

	rcu_read_lock();
	list_for_each_entry_rcu(laddr, &epb->bind_addr.address_list, list) {
		if (!laddr->valid)
			continue;

		addr = &laddr->a;
		af = sctp_get_af_specific(addr->sa.sa_family);
		if (primary && af->cmp_addr(addr, primary)) {
			seq_printf(seq, "*");
		}
		af->seq_dump_addr(seq, addr);
	}
	rcu_read_unlock();
}

/* Dump remote addresses of an association. */
static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_association *assoc)
{
	struct sctp_transport *transport;
	union sctp_addr *addr, *primary;
	struct sctp_af *af;

	primary = &assoc->peer.primary_addr;
	list_for_each_entry_rcu(transport, &assoc->peer.transport_addr_list,
			transports) {
		addr = &transport->ipaddr;

		af = sctp_get_af_specific(addr->sa.sa_family);
		if (af->cmp_addr(addr, primary)) {
			seq_printf(seq, "*");
		}
		af->seq_dump_addr(seq, addr);
	}
}

static void *sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
{
	if (*pos >= sctp_ep_hashsize)
		return NULL;

	if (*pos < 0)
		*pos = 0;

	if (*pos == 0)
		seq_printf(seq, " ENDPT     SOCK   STY SST HBKT LPORT   UID INODE LADDRS\n");

	return (void *)pos;
}

static void sctp_eps_seq_stop(struct seq_file *seq, void *v)
{
}


static void *sctp_eps_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	if (++*pos >= sctp_ep_hashsize)
		return NULL;

	return pos;
}


/* Display sctp endpoints (/proc/net/sctp/eps). */
static int sctp_eps_seq_show(struct seq_file *seq, void *v)
{
	struct sctp_hashbucket *head;
	struct sctp_endpoint *ep;
	struct sock *sk;
	int    hash = *(loff_t *)v;

	if (hash >= sctp_ep_hashsize)
		return -ENOMEM;

	head = &sctp_ep_hashtable[hash];
	read_lock_bh(&head->lock);
	sctp_for_each_hentry(ep, &head->chain) {
		sk = ep->base.sk;
		if (!net_eq(sock_net(sk), seq_file_net(seq)))
			continue;
		seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5lu ", ep, sk,
			   sctp_sk(sk)->type, sk->sk_state, hash,
			   ep->base.bind_addr.port,
			   from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
			   sock_i_ino(sk));

		sctp_seq_dump_local_addrs(seq, &ep->base);
		seq_printf(seq, "\n");
	}
	read_unlock_bh(&head->lock);

	return 0;
}

static const struct seq_operations sctp_eps_ops = {
	.start = sctp_eps_seq_start,
	.next  = sctp_eps_seq_next,
	.stop  = sctp_eps_seq_stop,
	.show  = sctp_eps_seq_show,
};

struct sctp_ht_iter {
	struct seq_net_private p;
	struct rhashtable_iter hti;
};

static void *sctp_transport_seq_start(struct seq_file *seq, loff_t *pos)
{
	struct sctp_ht_iter *iter = seq->private;

	sctp_transport_walk_start(&iter->hti);

	return sctp_transport_get_idx(seq_file_net(seq), &iter->hti, *pos);
}

static void sctp_transport_seq_stop(struct seq_file *seq, void *v)
{
	struct sctp_ht_iter *iter = seq->private;

	if (v && v != SEQ_START_TOKEN) {
		struct sctp_transport *transport = v;

		sctp_transport_put(transport);
	}

	sctp_transport_walk_stop(&iter->hti);
}

static void *sctp_transport_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct sctp_ht_iter *iter = seq->private;

	if (v && v != SEQ_START_TOKEN) {
		struct sctp_transport *transport = v;

		sctp_transport_put(transport);
	}

	++*pos;

	return sctp_transport_get_next(seq_file_net(seq), &iter->hti);
}

/* Display sctp associations (/proc/net/sctp/assocs). */
static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
{
	struct sctp_transport *transport;
	struct sctp_association *assoc;
	struct sctp_ep_common *epb;
	struct sock *sk;

	if (v == SEQ_START_TOKEN) {
		seq_printf(seq, " ASSOC     SOCK   STY SST ST HBKT "
				"ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
				"RPORT LADDRS <-> RADDRS "
				"HBINT INS OUTS MAXRT T1X T2X RTXC "
				"wmema wmemq sndbuf rcvbuf\n");
		return 0;
	}

	transport = (struct sctp_transport *)v;
	assoc = transport->asoc;
	epb = &assoc->base;
	sk = epb->sk;

	seq_printf(seq,
		   "%8pK %8pK %-3d %-3d %-2d %-4d "
		   "%4d %8d %8d %7u %5lu %-5d %5d ",
		   assoc, sk, sctp_sk(sk)->type, sk->sk_state,
		   assoc->state, 0,
		   assoc->assoc_id,
		   assoc->sndbuf_used,
		   atomic_read(&assoc->rmem_alloc),
		   from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
		   sock_i_ino(sk),
		   epb->bind_addr.port,
		   assoc->peer.port);
	seq_printf(seq, " ");
	sctp_seq_dump_local_addrs(seq, epb);
	seq_printf(seq, "<-> ");
	sctp_seq_dump_remote_addrs(seq, assoc);
	seq_printf(seq, "\t%8lu %5d %5d %4d %4d %4d %8d "
		   "%8d %8d %8d %8d",
		assoc->hbinterval, assoc->stream.incnt,
		assoc->stream.outcnt, assoc->max_retrans,
		assoc->init_retries, assoc->shutdown_retries,
		assoc->rtx_data_chunks,
		refcount_read(&sk->sk_wmem_alloc),
		READ_ONCE(sk->sk_wmem_queued),
		sk->sk_sndbuf,
		sk->sk_rcvbuf);
	seq_printf(seq, "\n");

	return 0;
}

static const struct seq_operations sctp_assoc_ops = {
	.start = sctp_transport_seq_start,
	.next  = sctp_transport_seq_next,
	.stop  = sctp_transport_seq_stop,
	.show  = sctp_assocs_seq_show,
};

static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
{
	struct sctp_association *assoc;
	struct sctp_transport *transport, *tsp;

	if (v == SEQ_START_TOKEN) {
		seq_printf(seq, "ADDR ASSOC_ID HB_ACT RTO MAX_PATH_RTX "
				"REM_ADDR_RTX START STATE\n");
		return 0;
	}

	transport = (struct sctp_transport *)v;
	assoc = transport->asoc;

	list_for_each_entry_rcu(tsp, &assoc->peer.transport_addr_list,
				transports) {
		/*
		 * The remote address (ADDR)
		 */
		tsp->af_specific->seq_dump_addr(seq, &tsp->ipaddr);
		seq_printf(seq, " ");
		/*
		 * The association ID (ASSOC_ID)
		 */
		seq_printf(seq, "%d ", tsp->asoc->assoc_id);

		/*
		 * If the Heartbeat is active (HB_ACT)
		 * Note: 1 = Active, 0 = Inactive
		 */
		seq_printf(seq, "%d ", timer_pending(&tsp->hb_timer));

		/*
		 * Retransmit time out (RTO)
		 */
		seq_printf(seq, "%lu ", tsp->rto);

		/*
		 * Maximum path retransmit count (PATH_MAX_RTX)
		 */
		seq_printf(seq, "%d ", tsp->pathmaxrxt);

		/*
		 * remote address retransmit count (REM_ADDR_RTX)
		 * Note: We don't have a way to tally this at the moment
		 * so lets just leave it as zero for the moment
		 */
		seq_puts(seq, "0 ");

		/*
		 * remote address start time (START).  This is also not
		 * currently implemented, but we can record it with a
		 * jiffies marker in a subsequent patch
		 */
		seq_puts(seq, "0 ");

		/*
		 * The current state of this destination. I.e.
		 * SCTP_ACTIVE, SCTP_INACTIVE, ...
		 */
		seq_printf(seq, "%d", tsp->state);

		seq_printf(seq, "\n");
	}

	return 0;
}

static const struct seq_operations sctp_remaddr_ops = {
	.start = sctp_transport_seq_start,
	.next  = sctp_transport_seq_next,
	.stop  = sctp_transport_seq_stop,
	.show  = sctp_remaddr_seq_show,
};

/* Set up the proc fs entry for the SCTP protocol. */
int __net_init sctp_proc_init(struct net *net)
{
	net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
	if (!net->sctp.proc_net_sctp)
		return -ENOMEM;
	if (!proc_create_net_single("snmp", 0444, net->sctp.proc_net_sctp,
			 sctp_snmp_seq_show, NULL))
		goto cleanup;
	if (!proc_create_net("eps", 0444, net->sctp.proc_net_sctp,
			&sctp_eps_ops, sizeof(struct seq_net_private)))
		goto cleanup;
	if (!proc_create_net("assocs", 0444, net->sctp.proc_net_sctp,
			&sctp_assoc_ops, sizeof(struct sctp_ht_iter)))
		goto cleanup;
	if (!proc_create_net("remaddr", 0444, net->sctp.proc_net_sctp,
			&sctp_remaddr_ops, sizeof(struct sctp_ht_iter)))
		goto cleanup;
	return 0;

cleanup:
	remove_proc_subtree("sctp", net->proc_net);
	net->sctp.proc_net_sctp = NULL;
	return -ENOMEM;
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/* SCTP kernel implementation
	3	* Copyright (c) 2003 International Business Machines, Corp.
	4	*
	5	* This file is part of the SCTP kernel implementation
	6	*
	7	* Please send any bug reports or fixes you make to the
	8	* email address(es):
	9	* lksctp developers <linux-sctp@vger.kernel.org>
	10	*
	11	* Written or modified by:
	12	* Sridhar Samudrala <sri@us.ibm.com>
	13	*/
	14
	15	#include <linux/types.h>
	16	#include <linux/seq_file.h>
	17	#include <linux/init.h>
	18	#include <linux/export.h>
	19	#include <net/sctp/sctp.h>
	20	#include <net/ip.h> /* for snmp_fold_field */
	21
	22	static const struct snmp_mib sctp_snmp_list[] = {
	23	SNMP_MIB_ITEM("SctpCurrEstab", SCTP_MIB_CURRESTAB),
	24	SNMP_MIB_ITEM("SctpActiveEstabs", SCTP_MIB_ACTIVEESTABS),
	25	SNMP_MIB_ITEM("SctpPassiveEstabs", SCTP_MIB_PASSIVEESTABS),
	26	SNMP_MIB_ITEM("SctpAborteds", SCTP_MIB_ABORTEDS),
	27	SNMP_MIB_ITEM("SctpShutdowns", SCTP_MIB_SHUTDOWNS),
	28	SNMP_MIB_ITEM("SctpOutOfBlues", SCTP_MIB_OUTOFBLUES),
	29	SNMP_MIB_ITEM("SctpChecksumErrors", SCTP_MIB_CHECKSUMERRORS),
	30	SNMP_MIB_ITEM("SctpOutCtrlChunks", SCTP_MIB_OUTCTRLCHUNKS),
	31	SNMP_MIB_ITEM("SctpOutOrderChunks", SCTP_MIB_OUTORDERCHUNKS),
	32	SNMP_MIB_ITEM("SctpOutUnorderChunks", SCTP_MIB_OUTUNORDERCHUNKS),
	33	SNMP_MIB_ITEM("SctpInCtrlChunks", SCTP_MIB_INCTRLCHUNKS),
	34	SNMP_MIB_ITEM("SctpInOrderChunks", SCTP_MIB_INORDERCHUNKS),
	35	SNMP_MIB_ITEM("SctpInUnorderChunks", SCTP_MIB_INUNORDERCHUNKS),
	36	SNMP_MIB_ITEM("SctpFragUsrMsgs", SCTP_MIB_FRAGUSRMSGS),
	37	SNMP_MIB_ITEM("SctpReasmUsrMsgs", SCTP_MIB_REASMUSRMSGS),
	38	SNMP_MIB_ITEM("SctpOutSCTPPacks", SCTP_MIB_OUTSCTPPACKS),
	39	SNMP_MIB_ITEM("SctpInSCTPPacks", SCTP_MIB_INSCTPPACKS),
	40	SNMP_MIB_ITEM("SctpT1InitExpireds", SCTP_MIB_T1_INIT_EXPIREDS),
	41	SNMP_MIB_ITEM("SctpT1CookieExpireds", SCTP_MIB_T1_COOKIE_EXPIREDS),
	42	SNMP_MIB_ITEM("SctpT2ShutdownExpireds", SCTP_MIB_T2_SHUTDOWN_EXPIREDS),
	43	SNMP_MIB_ITEM("SctpT3RtxExpireds", SCTP_MIB_T3_RTX_EXPIREDS),
	44	SNMP_MIB_ITEM("SctpT4RtoExpireds", SCTP_MIB_T4_RTO_EXPIREDS),
	45	SNMP_MIB_ITEM("SctpT5ShutdownGuardExpireds", SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS),
	46	SNMP_MIB_ITEM("SctpDelaySackExpireds", SCTP_MIB_DELAY_SACK_EXPIREDS),
	47	SNMP_MIB_ITEM("SctpAutocloseExpireds", SCTP_MIB_AUTOCLOSE_EXPIREDS),
	48	SNMP_MIB_ITEM("SctpT3Retransmits", SCTP_MIB_T3_RETRANSMITS),
	49	SNMP_MIB_ITEM("SctpPmtudRetransmits", SCTP_MIB_PMTUD_RETRANSMITS),
	50	SNMP_MIB_ITEM("SctpFastRetransmits", SCTP_MIB_FAST_RETRANSMITS),
	51	SNMP_MIB_ITEM("SctpInPktSoftirq", SCTP_MIB_IN_PKT_SOFTIRQ),
	52	SNMP_MIB_ITEM("SctpInPktBacklog", SCTP_MIB_IN_PKT_BACKLOG),
	53	SNMP_MIB_ITEM("SctpInPktDiscards", SCTP_MIB_IN_PKT_DISCARDS),
	54	SNMP_MIB_ITEM("SctpInDataChunkDiscards", SCTP_MIB_IN_DATA_CHUNK_DISCARDS),
	55	SNMP_MIB_SENTINEL
	56	};
	57
	58	/* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
	59	static int sctp_snmp_seq_show(struct seq_file seq, void v)
	60	{
	61	unsigned long buff[SCTP_MIB_MAX];
	62	struct net *net = seq->private;
	63	int i;
	64
	65	memset(buff, 0, sizeof(unsigned long) * SCTP_MIB_MAX);
	66
	67	snmp_get_cpu_field_batch(buff, sctp_snmp_list,
	68	net->sctp.sctp_statistics);
	69	for (i = 0; sctp_snmp_list[i].name; i++)
	70	seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
	71	buff[i]);
	72
	73	return 0;
	74	}
	75
	76	/* Dump local addresses of an association/endpoint. */
	77	static void sctp_seq_dump_local_addrs(struct seq_file seq, struct sctp_ep_common epb)
	78	{
	79	struct sctp_association *asoc;
	80	struct sctp_sockaddr_entry *laddr;
	81	struct sctp_transport *peer;
	82	union sctp_addr addr, primary = NULL;
	83	struct sctp_af *af;
	84
	85	if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
	86	asoc = sctp_assoc(epb);
	87
	88	peer = asoc->peer.primary_path;
	89	if (unlikely(peer == NULL)) {
	90	WARN(1, "Association %p with NULL primary path!\n", asoc);
	91	return;
	92	}
	93
	94	primary = &peer->saddr;
	95	}
	96
	97	rcu_read_lock();
	98	list_for_each_entry_rcu(laddr, &epb->bind_addr.address_list, list) {
	99	if (!laddr->valid)
	100	continue;
	101
	102	addr = &laddr->a;
	103	af = sctp_get_af_specific(addr->sa.sa_family);
	104	if (primary && af->cmp_addr(addr, primary)) {
	105	seq_printf(seq, "*");
	106	}
	107	af->seq_dump_addr(seq, addr);
	108	}
	109	rcu_read_unlock();
	110	}
	111
	112	/* Dump remote addresses of an association. */
	113	static void sctp_seq_dump_remote_addrs(struct seq_file seq, struct sctp_association assoc)
	114	{
	115	struct sctp_transport *transport;
	116	union sctp_addr addr, primary;
	117	struct sctp_af *af;
	118
	119	primary = &assoc->peer.primary_addr;
	120	list_for_each_entry_rcu(transport, &assoc->peer.transport_addr_list,
	121	transports) {
	122	addr = &transport->ipaddr;
	123
	124	af = sctp_get_af_specific(addr->sa.sa_family);
	125	if (af->cmp_addr(addr, primary)) {
	126	seq_printf(seq, "*");
	127	}
	128	af->seq_dump_addr(seq, addr);
	129	}
	130	}
	131
	132	static void sctp_eps_seq_start(struct seq_file seq, loff_t *pos)
	133	{
	134	if (*pos >= sctp_ep_hashsize)
	135	return NULL;
	136
	137	if (*pos < 0)
	138	*pos = 0;
	139
	140	if (*pos == 0)
	141	seq_printf(seq, " ENDPT SOCK STY SST HBKT LPORT UID INODE LADDRS\n");
	142
	143	return (void *)pos;
	144	}
	145
	146	static void sctp_eps_seq_stop(struct seq_file seq, void v)
	147	{
	148	}
	149
	150
	151	static void sctp_eps_seq_next(struct seq_file seq, void v, loff_t pos)
	152	{
	153	if (++*pos >= sctp_ep_hashsize)
	154	return NULL;
	155
	156	return pos;
	157	}
	158
	159
	160	/* Display sctp endpoints (/proc/net/sctp/eps). */
	161	static int sctp_eps_seq_show(struct seq_file seq, void v)
	162	{
	163	struct sctp_hashbucket *head;
	164	struct sctp_endpoint *ep;
	165	struct sock *sk;
	166	int hash = (loff_t )v;
	167
	168	if (hash >= sctp_ep_hashsize)
	169	return -ENOMEM;
	170
	171	head = &sctp_ep_hashtable[hash];
	172	read_lock_bh(&head->lock);
	173	sctp_for_each_hentry(ep, &head->chain) {
	174	sk = ep->base.sk;
	175	if (!net_eq(sock_net(sk), seq_file_net(seq)))
	176	continue;
	177	seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5lu ", ep, sk,
	178	sctp_sk(sk)->type, sk->sk_state, hash,
	179	ep->base.bind_addr.port,
	180	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
	181	sock_i_ino(sk));
	182
	183	sctp_seq_dump_local_addrs(seq, &ep->base);
	184	seq_printf(seq, "\n");
	185	}
	186	read_unlock_bh(&head->lock);
	187
	188	return 0;
	189	}
	190
	191	static const struct seq_operations sctp_eps_ops = {
	192	.start = sctp_eps_seq_start,
	193	.next = sctp_eps_seq_next,
	194	.stop = sctp_eps_seq_stop,
	195	.show = sctp_eps_seq_show,
	196	};
	197
	198	struct sctp_ht_iter {
	199	struct seq_net_private p;
	200	struct rhashtable_iter hti;
	201	};
	202
	203	static void sctp_transport_seq_start(struct seq_file seq, loff_t *pos)
	204	{
	205	struct sctp_ht_iter *iter = seq->private;
	206
	207	sctp_transport_walk_start(&iter->hti);
	208
	209	return sctp_transport_get_idx(seq_file_net(seq), &iter->hti, *pos);
	210	}
	211
	212	static void sctp_transport_seq_stop(struct seq_file seq, void v)
	213	{
	214	struct sctp_ht_iter *iter = seq->private;
	215
	216	if (v && v != SEQ_START_TOKEN) {
	217	struct sctp_transport *transport = v;
	218
	219	sctp_transport_put(transport);
	220	}
	221
	222	sctp_transport_walk_stop(&iter->hti);
	223	}
	224
	225	static void sctp_transport_seq_next(struct seq_file seq, void v, loff_t pos)
	226	{
	227	struct sctp_ht_iter *iter = seq->private;
	228
	229	if (v && v != SEQ_START_TOKEN) {
	230	struct sctp_transport *transport = v;
	231
	232	sctp_transport_put(transport);
	233	}
	234
	235	++*pos;
	236
	237	return sctp_transport_get_next(seq_file_net(seq), &iter->hti);
	238	}
	239
	240	/* Display sctp associations (/proc/net/sctp/assocs). */
	241	static int sctp_assocs_seq_show(struct seq_file seq, void v)
	242	{
	243	struct sctp_transport *transport;
	244	struct sctp_association *assoc;
	245	struct sctp_ep_common *epb;
	246	struct sock *sk;
	247
	248	if (v == SEQ_START_TOKEN) {
	249	seq_printf(seq, " ASSOC SOCK STY SST ST HBKT "
	250	"ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
	251	"RPORT LADDRS <-> RADDRS "
	252	"HBINT INS OUTS MAXRT T1X T2X RTXC "
	253	"wmema wmemq sndbuf rcvbuf\n");
	254	return 0;
	255	}
	256
	257	transport = (struct sctp_transport *)v;
	258	assoc = transport->asoc;
	259	epb = &assoc->base;
	260	sk = epb->sk;
	261
	262	seq_printf(seq,
	263	"%8pK %8pK %-3d %-3d %-2d %-4d "
	264	"%4d %8d %8d %7u %5lu %-5d %5d ",
	265	assoc, sk, sctp_sk(sk)->type, sk->sk_state,
	266	assoc->state, 0,
	267	assoc->assoc_id,
	268	assoc->sndbuf_used,
	269	atomic_read(&assoc->rmem_alloc),
	270	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
	271	sock_i_ino(sk),
	272	epb->bind_addr.port,
	273	assoc->peer.port);
	274	seq_printf(seq, " ");
	275	sctp_seq_dump_local_addrs(seq, epb);
	276	seq_printf(seq, "<-> ");
	277	sctp_seq_dump_remote_addrs(seq, assoc);
	278	seq_printf(seq, "\t%8lu %5d %5d %4d %4d %4d %8d "
	279	"%8d %8d %8d %8d",
	280	assoc->hbinterval, assoc->stream.incnt,
	281	assoc->stream.outcnt, assoc->max_retrans,
	282	assoc->init_retries, assoc->shutdown_retries,
	283	assoc->rtx_data_chunks,
	284	refcount_read(&sk->sk_wmem_alloc),
	285	READ_ONCE(sk->sk_wmem_queued),
	286	sk->sk_sndbuf,
	287	sk->sk_rcvbuf);
	288	seq_printf(seq, "\n");
	289
	290	return 0;
	291	}
	292
	293	static const struct seq_operations sctp_assoc_ops = {
	294	.start = sctp_transport_seq_start,
	295	.next = sctp_transport_seq_next,
	296	.stop = sctp_transport_seq_stop,
	297	.show = sctp_assocs_seq_show,
	298	};
	299
	300	static int sctp_remaddr_seq_show(struct seq_file seq, void v)
	301	{
	302	struct sctp_association *assoc;
	303	struct sctp_transport transport, tsp;
	304
	305	if (v == SEQ_START_TOKEN) {
	306	seq_printf(seq, "ADDR ASSOC_ID HB_ACT RTO MAX_PATH_RTX "
	307	"REM_ADDR_RTX START STATE\n");
	308	return 0;
	309	}
	310
	311	transport = (struct sctp_transport *)v;
	312	assoc = transport->asoc;
	313
	314	list_for_each_entry_rcu(tsp, &assoc->peer.transport_addr_list,
	315	transports) {
	316	/*
	317	* The remote address (ADDR)
	318	*/
	319	tsp->af_specific->seq_dump_addr(seq, &tsp->ipaddr);
	320	seq_printf(seq, " ");
	321	/*
	322	* The association ID (ASSOC_ID)
	323	*/
	324	seq_printf(seq, "%d ", tsp->asoc->assoc_id);
	325
	326	/*
	327	* If the Heartbeat is active (HB_ACT)
	328	* Note: 1 = Active, 0 = Inactive
	329	*/
	330	seq_printf(seq, "%d ", timer_pending(&tsp->hb_timer));
	331
	332	/*
	333	* Retransmit time out (RTO)
	334	*/
	335	seq_printf(seq, "%lu ", tsp->rto);
	336
	337	/*
	338	* Maximum path retransmit count (PATH_MAX_RTX)
	339	*/
	340	seq_printf(seq, "%d ", tsp->pathmaxrxt);
	341
	342	/*
	343	* remote address retransmit count (REM_ADDR_RTX)
	344	* Note: We don't have a way to tally this at the moment
	345	* so lets just leave it as zero for the moment
	346	*/
	347	seq_puts(seq, "0 ");
	348
	349	/*
	350	* remote address start time (START). This is also not
	351	* currently implemented, but we can record it with a
	352	* jiffies marker in a subsequent patch
	353	*/
	354	seq_puts(seq, "0 ");
	355
	356	/*
	357	* The current state of this destination. I.e.
	358	* SCTP_ACTIVE, SCTP_INACTIVE, ...
	359	*/
	360	seq_printf(seq, "%d", tsp->state);
	361
	362	seq_printf(seq, "\n");
	363	}
	364
	365	return 0;
	366	}
	367
	368	static const struct seq_operations sctp_remaddr_ops = {
	369	.start = sctp_transport_seq_start,
	370	.next = sctp_transport_seq_next,
	371	.stop = sctp_transport_seq_stop,
	372	.show = sctp_remaddr_seq_show,
	373	};
	374
	375	/* Set up the proc fs entry for the SCTP protocol. */
	376	int __net_init sctp_proc_init(struct net *net)
	377	{
	378	net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
	379	if (!net->sctp.proc_net_sctp)
	380	return -ENOMEM;
	381	if (!proc_create_net_single("snmp", 0444, net->sctp.proc_net_sctp,
	382	sctp_snmp_seq_show, NULL))
	383	goto cleanup;
	384	if (!proc_create_net("eps", 0444, net->sctp.proc_net_sctp,
	385	&sctp_eps_ops, sizeof(struct seq_net_private)))
	386	goto cleanup;
	387	if (!proc_create_net("assocs", 0444, net->sctp.proc_net_sctp,
	388	&sctp_assoc_ops, sizeof(struct sctp_ht_iter)))
	389	goto cleanup;
	390	if (!proc_create_net("remaddr", 0444, net->sctp.proc_net_sctp,
	391	&sctp_remaddr_ops, sizeof(struct sctp_ht_iter)))
	392	goto cleanup;
	393	return 0;
	394
	395	cleanup:
	396	remove_proc_subtree("sctp", net->proc_net);
	397	net->sctp.proc_net_sctp = NULL;
	398	return -ENOMEM;
	399	}