[linux-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),
		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
47505b8b	1	// SPDX-License-Identifier: GPL-2.0-or-later
60c778b2	2	/* SCTP kernel implementation
1da177e4 LT	3	* Copyright (c) 2003 International Business Machines, Corp.
1da177e4 LT	4	*
60c778b2	5	* This file is part of the SCTP kernel implementation
1da177e4	6	*
1da177e4 LT	7	* Please send any bug reports or fixes you make to the
1da177e4 LT	8	* email address(es):
91705c61	9	* lksctp developers <linux-sctp@vger.kernel.org>
1da177e4	10	*
1da177e4 LT	11	* Written or modified by:
1da177e4 LT	12	* Sridhar Samudrala <sri@us.ibm.com>
1da177e4 LT	13	*/
	14
	15	#include <linux/types.h>
	16	#include <linux/seq_file.h>
	17	#include <linux/init.h>
bc3b2d7f	18	#include <linux/export.h>
1da177e4	19	#include <net/sctp/sctp.h>
3f5340a6	20	#include <net/ip.h> /* for snmp_fold_field */
1da177e4	21
5833929c	22	static const struct snmp_mib sctp_snmp_list[] = {
1da177e4 LT	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),
ac0b0462 SS	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),
d2287f84	55	SNMP_MIB_SENTINEL
1da177e4 LT	56	};
1da177e4 LT	57
1da177e4 LT	58	/* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
	59	static int sctp_snmp_seq_show(struct seq_file seq, void v)
	60	{
7d64a94b	61	unsigned long buff[SCTP_MIB_MAX];
13d782f6	62	struct net *net = seq->private;
1da177e4 LT	63	int i;
1da177e4 LT	64
7d64a94b JH	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);
6d4a741c	69	for (i = 0; sctp_snmp_list[i].name; i++)
1da177e4	70	seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
7d64a94b	71	buff[i]);
1da177e4 LT	72
	73	return 0;
	74	}
	75
1da177e4 LT	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	{
bca735bd	79	struct sctp_association *asoc;
1da177e4	80	struct sctp_sockaddr_entry *laddr;
bca735bd VY	81	struct sctp_transport *peer;
bca735bd VY	82	union sctp_addr addr, primary = NULL;
1da177e4 LT	83	struct sctp_af *af;
1da177e4 LT	84
bca735bd	85	if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
f9e42b85 DB	86	asoc = sctp_assoc(epb);
	87
	88	peer = asoc->peer.primary_path;
	89	if (unlikely(peer == NULL)) {
b527fe69	90	WARN(1, "Association %p with NULL primary path!\n", asoc);
f9e42b85 DB	91	return;
	92	}
	93
	94	primary = &peer->saddr;
bca735bd VY	95	}
bca735bd VY	96
0b0fe913 TG	97	rcu_read_lock();
	98	list_for_each_entry_rcu(laddr, &epb->bind_addr.address_list, list) {
	99	if (!laddr->valid)
	100	continue;
	101
5f242a13	102	addr = &laddr->a;
1da177e4	103	af = sctp_get_af_specific(addr->sa.sa_family);
bca735bd VY	104	if (primary && af->cmp_addr(addr, primary)) {
	105	seq_printf(seq, "*");
	106	}
5f242a13	107	af->seq_dump_addr(seq, addr);
1da177e4	108	}
0b0fe913	109	rcu_read_unlock();
1da177e4 LT	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	{
1da177e4	115	struct sctp_transport *transport;
bca735bd	116	union sctp_addr addr, primary;
1da177e4 LT	117	struct sctp_af *af;
1da177e4 LT	118
acd2bc96	119	primary = &assoc->peer.primary_addr;
45122ca2	120	list_for_each_entry_rcu(transport, &assoc->peer.transport_addr_list,
9dbc15f0	121	transports) {
5f242a13	122	addr = &transport->ipaddr;
45122ca2	123
1da177e4	124	af = sctp_get_af_specific(addr->sa.sa_family);
acd2bc96	125	if (af->cmp_addr(addr, primary)) {
bca735bd VY	126	seq_printf(seq, "*");
bca735bd VY	127	}
5f242a13	128	af->seq_dump_addr(seq, addr);
1da177e4 LT	129	}
	130	}
	131
26ac8e5f	132	static void sctp_eps_seq_start(struct seq_file seq, loff_t *pos)
bca735bd	133	{
49392e5e	134	if (*pos >= sctp_ep_hashsize)
bca735bd VY	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
bca735bd VY	143	return (void *)pos;
	144	}
	145
	146	static void sctp_eps_seq_stop(struct seq_file seq, void v)
	147	{
bca735bd VY	148	}
	149
	150
26ac8e5f	151	static void sctp_eps_seq_next(struct seq_file seq, void v, loff_t pos)
bca735bd	152	{
49392e5e	153	if (++*pos >= sctp_ep_hashsize)
bca735bd VY	154	return NULL;
bca735bd VY	155
bca735bd VY	156	return pos;
	157	}
	158
	159
1da177e4 LT	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;
1da177e4 LT	164	struct sctp_endpoint *ep;
1da177e4 LT	165	struct sock *sk;
38b0e42a	166	int hash = (loff_t )v;
bca735bd	167
49392e5e	168	if (hash >= sctp_ep_hashsize)
bca735bd VY	169	return -ENOMEM;
bca735bd VY	170
49392e5e	171	head = &sctp_ep_hashtable[hash];
c0a4c2d1	172	read_lock_bh(&head->lock);
3d3b2f57 XL	173	sctp_for_each_hentry(ep, &head->chain) {
3d3b2f57 XL	174	sk = ep->base.sk;
6932f119	175	if (!net_eq(sock_net(sk), seq_file_net(seq)))
13d782f6	176	continue;
d14c5ab6	177	seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5lu ", ep, sk,
49392e5e	178	sctp_sk(sk)->type, sk->sk_state, hash,
3d3b2f57	179	ep->base.bind_addr.port,
a7cb5a49 EB	180	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
a7cb5a49 EB	181	sock_i_ino(sk));
bca735bd	182
3d3b2f57	183	sctp_seq_dump_local_addrs(seq, &ep->base);
bca735bd	184	seq_printf(seq, "\n");
1da177e4	185	}
c0a4c2d1	186	read_unlock_bh(&head->lock);
1da177e4 LT	187
	188	return 0;
	189	}
	190
56b3d975	191	static const struct seq_operations sctp_eps_ops = {
bca735bd VY	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
39f66a7d XL	198	struct sctp_ht_iter {
	199	struct seq_net_private p;
	200	struct rhashtable_iter hti;
	201	};
bca735bd	202
b5e2f4e6	203	static void sctp_transport_seq_start(struct seq_file seq, loff_t *pos)
39f66a7d	204	{
626d16f5	205	struct sctp_ht_iter *iter = seq->private;
39f66a7d	206
97a6ec4a	207	sctp_transport_walk_start(&iter->hti);
39f66a7d	208
626d16f5	209	return sctp_transport_get_idx(seq_file_net(seq), &iter->hti, *pos);
39f66a7d XL	210	}
39f66a7d XL	211
b5e2f4e6	212	static void sctp_transport_seq_stop(struct seq_file seq, void v)
39f66a7d	213	{
626d16f5 XL	214	struct sctp_ht_iter *iter = seq->private;
626d16f5 XL	215
af8085f3 N	216	if (v && v != SEQ_START_TOKEN) {
	217	struct sctp_transport *transport = v;
	218
	219	sctp_transport_put(transport);
	220	}
	221
626d16f5	222	sctp_transport_walk_stop(&iter->hti);
39f66a7d	223	}
bca735bd	224
b5e2f4e6	225	static void sctp_transport_seq_next(struct seq_file seq, void v, loff_t pos)
bca735bd	226	{
626d16f5 XL	227	struct sctp_ht_iter *iter = seq->private;
626d16f5 XL	228
af8085f3 N	229	if (v && v != SEQ_START_TOKEN) {
	230	struct sctp_transport *transport = v;
	231
	232	sctp_transport_put(transport);
	233	}
	234
39f66a7d	235	++*pos;
bca735bd	236
626d16f5	237	return sctp_transport_get_next(seq_file_net(seq), &iter->hti);
bca735bd VY	238	}
bca735bd VY	239
1da177e4 LT	240	/* Display sctp associations (/proc/net/sctp/assocs). */
	241	static int sctp_assocs_seq_show(struct seq_file seq, void v)
	242	{
39f66a7d	243	struct sctp_transport *transport;
1da177e4	244	struct sctp_association *assoc;
39f66a7d	245	struct sctp_ep_common *epb;
1da177e4	246	struct sock *sk;
bca735bd	247
39f66a7d XL	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;
1da177e4	255	}
39f66a7d XL	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",
cee360ab XL	280	assoc->hbinterval, assoc->stream.incnt,
cee360ab XL	281	assoc->stream.outcnt, assoc->max_retrans,
39f66a7d XL	282	assoc->init_retries, assoc->shutdown_retries,
39f66a7d XL	283	assoc->rtx_data_chunks,
14afee4b	284	refcount_read(&sk->sk_wmem_alloc),
39f66a7d XL	285	sk->sk_wmem_queued,
	286	sk->sk_sndbuf,
	287	sk->sk_rcvbuf);
	288	seq_printf(seq, "\n");
1da177e4 LT	289
	290	return 0;
	291	}
	292
56b3d975	293	static const struct seq_operations sctp_assoc_ops = {
b5e2f4e6 XL	294	.start = sctp_transport_seq_start,
	295	.next = sctp_transport_seq_next,
	296	.stop = sctp_transport_seq_stop,
bca735bd VY	297	.show = sctp_assocs_seq_show,
	298	};
	299
20c2c1fd NH	300	static int sctp_remaddr_seq_show(struct seq_file seq, void v)
20c2c1fd NH	301	{
20c2c1fd	302	struct sctp_association *assoc;
3d73e8fa	303	struct sctp_transport transport, tsp;
20c2c1fd	304
39f66a7d XL	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	}
20c2c1fd	310
3d73e8fa	311	transport = (struct sctp_transport *)v;
3d73e8fa	312	assoc = transport->asoc;
39f66a7d XL	313
	314	list_for_each_entry_rcu(tsp, &assoc->peer.transport_addr_list,
	315	transports) {
39f66a7d XL	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);
45122ca2	361
39f66a7d	362	seq_printf(seq, "\n");
20c2c1fd NH	363	}
20c2c1fd NH	364
20c2c1fd	365	return 0;
20c2c1fd NH	366	}
	367
	368	static const struct seq_operations sctp_remaddr_ops = {
b5e2f4e6 XL	369	.start = sctp_transport_seq_start,
	370	.next = sctp_transport_seq_next,
	371	.stop = sctp_transport_seq_stop,
20c2c1fd NH	372	.show = sctp_remaddr_seq_show,
	373	};
	374
d47d08c8 AV	375	/* Set up the proc fs entry for the SCTP protocol. */
d47d08c8 AV	376	int __net_init sctp_proc_init(struct net *net)
20c2c1fd	377	{
d47d08c8 AV	378	net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
d47d08c8 AV	379	if (!net->sctp.proc_net_sctp)
20c2c1fd	380	return -ENOMEM;
3617d949 CH	381	if (!proc_create_net_single("snmp", 0444, net->sctp.proc_net_sctp,
3617d949 CH	382	sctp_snmp_seq_show, NULL))
d47d08c8	383	goto cleanup;
c3506372 CH	384	if (!proc_create_net("eps", 0444, net->sctp.proc_net_sctp,
c3506372 CH	385	&sctp_eps_ops, sizeof(struct seq_net_private)))
d47d08c8	386	goto cleanup;
c3506372 CH	387	if (!proc_create_net("assocs", 0444, net->sctp.proc_net_sctp,
c3506372 CH	388	&sctp_assoc_ops, sizeof(struct sctp_ht_iter)))
d47d08c8	389	goto cleanup;
c3506372 CH	390	if (!proc_create_net("remaddr", 0444, net->sctp.proc_net_sctp,
c3506372 CH	391	&sctp_remaddr_ops, sizeof(struct sctp_ht_iter)))
d47d08c8	392	goto cleanup;
20c2c1fd	393	return 0;
d47d08c8 AV	394
	395	cleanup:
	396	remove_proc_subtree("sctp", net->proc_net);
	397	net->sctp.proc_net_sctp = NULL;
	398	return -ENOMEM;
20c2c1fd	399	}