[linux.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 <[email protected]>
 *
 * Written or modified by:
 *    Sridhar Samudrala <[email protected]>
 */

#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_ep_common *epb;
	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(epb, &head->chain) {
		ep = sctp_ep(epb);
		sk = epb->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,
			   epb->bind_addr.port,
			   from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
			   sock_i_ino(sk));

		sctp_seq_dump_local_addrs(seq, epb);
		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;

	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;

	++*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");

	sctp_transport_put(transport);

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

	sctp_transport_put(transport);

	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 <[email protected]>
1da177e4	10	*
1da177e4 LT	11	* Written or modified by:
1da177e4 LT	12	* Sridhar Samudrala <[email protected]>
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;
	164	struct sctp_ep_common *epb;
	165	struct sctp_endpoint *ep;
	166	struct sock *sk;
38b0e42a	167	int hash = (loff_t )v;
bca735bd	168
49392e5e	169	if (hash >= sctp_ep_hashsize)
bca735bd VY	170	return -ENOMEM;
bca735bd VY	171
49392e5e	172	head = &sctp_ep_hashtable[hash];
c0a4c2d1	173	read_lock_bh(&head->lock);
b67bfe0d	174	sctp_for_each_hentry(epb, &head->chain) {
bca735bd VY	175	ep = sctp_ep(epb);
bca735bd VY	176	sk = epb->sk;
6932f119	177	if (!net_eq(sock_net(sk), seq_file_net(seq)))
13d782f6	178	continue;
d14c5ab6	179	seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5lu ", ep, sk,
49392e5e	180	sctp_sk(sk)->type, sk->sk_state, hash,
bca735bd	181	epb->bind_addr.port,
a7cb5a49 EB	182	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
a7cb5a49 EB	183	sock_i_ino(sk));
bca735bd VY	184
	185	sctp_seq_dump_local_addrs(seq, epb);
	186	seq_printf(seq, "\n");
1da177e4	187	}
c0a4c2d1	188	read_unlock_bh(&head->lock);
1da177e4 LT	189
	190	return 0;
	191	}
	192
56b3d975	193	static const struct seq_operations sctp_eps_ops = {
bca735bd VY	194	.start = sctp_eps_seq_start,
	195	.next = sctp_eps_seq_next,
	196	.stop = sctp_eps_seq_stop,
	197	.show = sctp_eps_seq_show,
	198	};
	199
39f66a7d XL	200	struct sctp_ht_iter {
	201	struct seq_net_private p;
	202	struct rhashtable_iter hti;
	203	};
bca735bd	204
b5e2f4e6	205	static void sctp_transport_seq_start(struct seq_file seq, loff_t *pos)
39f66a7d	206	{
626d16f5	207	struct sctp_ht_iter *iter = seq->private;
39f66a7d	208
97a6ec4a	209	sctp_transport_walk_start(&iter->hti);
39f66a7d	210
626d16f5	211	return sctp_transport_get_idx(seq_file_net(seq), &iter->hti, *pos);
39f66a7d XL	212	}
39f66a7d XL	213
b5e2f4e6	214	static void sctp_transport_seq_stop(struct seq_file seq, void v)
39f66a7d	215	{
626d16f5 XL	216	struct sctp_ht_iter *iter = seq->private;
	217
	218	sctp_transport_walk_stop(&iter->hti);
39f66a7d	219	}
bca735bd	220
b5e2f4e6	221	static void sctp_transport_seq_next(struct seq_file seq, void v, loff_t pos)
bca735bd	222	{
626d16f5 XL	223	struct sctp_ht_iter *iter = seq->private;
626d16f5 XL	224
39f66a7d	225	++*pos;
bca735bd	226
626d16f5	227	return sctp_transport_get_next(seq_file_net(seq), &iter->hti);
bca735bd VY	228	}
bca735bd VY	229
1da177e4 LT	230	/* Display sctp associations (/proc/net/sctp/assocs). */
	231	static int sctp_assocs_seq_show(struct seq_file seq, void v)
	232	{
39f66a7d	233	struct sctp_transport *transport;
1da177e4	234	struct sctp_association *assoc;
39f66a7d	235	struct sctp_ep_common *epb;
1da177e4	236	struct sock *sk;
bca735bd	237
39f66a7d XL	238	if (v == SEQ_START_TOKEN) {
	239	seq_printf(seq, " ASSOC SOCK STY SST ST HBKT "
	240	"ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
	241	"RPORT LADDRS <-> RADDRS "
	242	"HBINT INS OUTS MAXRT T1X T2X RTXC "
	243	"wmema wmemq sndbuf rcvbuf\n");
	244	return 0;
1da177e4	245	}
39f66a7d XL	246
	247	transport = (struct sctp_transport *)v;
	248	assoc = transport->asoc;
	249	epb = &assoc->base;
	250	sk = epb->sk;
	251
	252	seq_printf(seq,
	253	"%8pK %8pK %-3d %-3d %-2d %-4d "
	254	"%4d %8d %8d %7u %5lu %-5d %5d ",
	255	assoc, sk, sctp_sk(sk)->type, sk->sk_state,
	256	assoc->state, 0,
	257	assoc->assoc_id,
	258	assoc->sndbuf_used,
	259	atomic_read(&assoc->rmem_alloc),
	260	from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
	261	sock_i_ino(sk),
	262	epb->bind_addr.port,
	263	assoc->peer.port);
	264	seq_printf(seq, " ");
	265	sctp_seq_dump_local_addrs(seq, epb);
	266	seq_printf(seq, "<-> ");
	267	sctp_seq_dump_remote_addrs(seq, assoc);
	268	seq_printf(seq, "\t%8lu %5d %5d %4d %4d %4d %8d "
	269	"%8d %8d %8d %8d",
cee360ab XL	270	assoc->hbinterval, assoc->stream.incnt,
cee360ab XL	271	assoc->stream.outcnt, assoc->max_retrans,
39f66a7d XL	272	assoc->init_retries, assoc->shutdown_retries,
39f66a7d XL	273	assoc->rtx_data_chunks,
14afee4b	274	refcount_read(&sk->sk_wmem_alloc),
39f66a7d XL	275	sk->sk_wmem_queued,
	276	sk->sk_sndbuf,
	277	sk->sk_rcvbuf);
	278	seq_printf(seq, "\n");
1da177e4	279
fba4c330 XL	280	sctp_transport_put(transport);
fba4c330 XL	281
1da177e4 LT	282	return 0;
	283	}
	284
56b3d975	285	static const struct seq_operations sctp_assoc_ops = {
b5e2f4e6 XL	286	.start = sctp_transport_seq_start,
	287	.next = sctp_transport_seq_next,
	288	.stop = sctp_transport_seq_stop,
bca735bd VY	289	.show = sctp_assocs_seq_show,
	290	};
	291
20c2c1fd NH	292	static int sctp_remaddr_seq_show(struct seq_file seq, void v)
20c2c1fd NH	293	{
20c2c1fd	294	struct sctp_association *assoc;
3d73e8fa	295	struct sctp_transport transport, tsp;
20c2c1fd	296
39f66a7d XL	297	if (v == SEQ_START_TOKEN) {
	298	seq_printf(seq, "ADDR ASSOC_ID HB_ACT RTO MAX_PATH_RTX "
	299	"REM_ADDR_RTX START STATE\n");
	300	return 0;
	301	}
20c2c1fd	302
3d73e8fa	303	transport = (struct sctp_transport *)v;
3d73e8fa	304	assoc = transport->asoc;
39f66a7d XL	305
	306	list_for_each_entry_rcu(tsp, &assoc->peer.transport_addr_list,
	307	transports) {
39f66a7d XL	308	/*
	309	* The remote address (ADDR)
	310	*/
	311	tsp->af_specific->seq_dump_addr(seq, &tsp->ipaddr);
	312	seq_printf(seq, " ");
	313	/*
	314	* The association ID (ASSOC_ID)
	315	*/
	316	seq_printf(seq, "%d ", tsp->asoc->assoc_id);
	317
	318	/*
	319	* If the Heartbeat is active (HB_ACT)
	320	* Note: 1 = Active, 0 = Inactive
	321	*/
	322	seq_printf(seq, "%d ", timer_pending(&tsp->hb_timer));
	323
	324	/*
	325	* Retransmit time out (RTO)
	326	*/
	327	seq_printf(seq, "%lu ", tsp->rto);
	328
	329	/*
	330	* Maximum path retransmit count (PATH_MAX_RTX)
	331	*/
	332	seq_printf(seq, "%d ", tsp->pathmaxrxt);
	333
	334	/*
	335	* remote address retransmit count (REM_ADDR_RTX)
	336	* Note: We don't have a way to tally this at the moment
	337	* so lets just leave it as zero for the moment
	338	*/
	339	seq_puts(seq, "0 ");
	340
	341	/*
	342	* remote address start time (START). This is also not
	343	* currently implemented, but we can record it with a
	344	* jiffies marker in a subsequent patch
	345	*/
	346	seq_puts(seq, "0 ");
	347
	348	/*
	349	* The current state of this destination. I.e.
	350	* SCTP_ACTIVE, SCTP_INACTIVE, ...
	351	*/
	352	seq_printf(seq, "%d", tsp->state);
45122ca2	353
39f66a7d	354	seq_printf(seq, "\n");
20c2c1fd NH	355	}
20c2c1fd NH	356
3d73e8fa	357	sctp_transport_put(transport);
fba4c330	358
20c2c1fd	359	return 0;
20c2c1fd NH	360	}
	361
	362	static const struct seq_operations sctp_remaddr_ops = {
b5e2f4e6 XL	363	.start = sctp_transport_seq_start,
	364	.next = sctp_transport_seq_next,
	365	.stop = sctp_transport_seq_stop,
20c2c1fd NH	366	.show = sctp_remaddr_seq_show,
	367	};
	368
d47d08c8 AV	369	/* Set up the proc fs entry for the SCTP protocol. */
d47d08c8 AV	370	int __net_init sctp_proc_init(struct net *net)
20c2c1fd	371	{
d47d08c8 AV	372	net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
d47d08c8 AV	373	if (!net->sctp.proc_net_sctp)
20c2c1fd	374	return -ENOMEM;
3617d949 CH	375	if (!proc_create_net_single("snmp", 0444, net->sctp.proc_net_sctp,
3617d949 CH	376	sctp_snmp_seq_show, NULL))
d47d08c8	377	goto cleanup;
c3506372 CH	378	if (!proc_create_net("eps", 0444, net->sctp.proc_net_sctp,
c3506372 CH	379	&sctp_eps_ops, sizeof(struct seq_net_private)))
d47d08c8	380	goto cleanup;
c3506372 CH	381	if (!proc_create_net("assocs", 0444, net->sctp.proc_net_sctp,
c3506372 CH	382	&sctp_assoc_ops, sizeof(struct sctp_ht_iter)))
d47d08c8	383	goto cleanup;
c3506372 CH	384	if (!proc_create_net("remaddr", 0444, net->sctp.proc_net_sctp,
c3506372 CH	385	&sctp_remaddr_ops, sizeof(struct sctp_ht_iter)))
d47d08c8	386	goto cleanup;
20c2c1fd	387	return 0;
d47d08c8 AV	388
	389	cleanup:
	390	remove_proc_subtree("sctp", net->proc_net);
	391	net->sctp.proc_net_sctp = NULL;
	392	return -ENOMEM;
20c2c1fd	393	}