2008-01-11 07:57:09 -07:00
|
|
|
/* SCTP kernel implementation
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (c) 2003 International Business Machines, Corp.
|
|
|
|
*
|
2008-01-11 07:57:09 -07:00
|
|
|
* This file is part of the SCTP kernel implementation
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-01-11 07:57:09 -07:00
|
|
|
* This SCTP implementation is free software;
|
2005-04-16 16:20:36 -06:00
|
|
|
* you can redistribute it and/or modify it under the terms of
|
|
|
|
* the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
2008-01-11 07:57:09 -07:00
|
|
|
* This SCTP implementation is distributed in the hope that it
|
2005-04-16 16:20:36 -06:00
|
|
|
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
|
|
* ************************
|
|
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
* See the GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2013-12-06 07:28:48 -07:00
|
|
|
* along with GNU CC; see the file COPYING. If not, see
|
|
|
|
* <http://www.gnu.org/licenses/>.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Please send any bug reports or fixes you make to the
|
|
|
|
* email address(es):
|
2013-07-23 06:51:47 -06:00
|
|
|
* lksctp developers <linux-sctp@vger.kernel.org>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Written or modified by:
|
|
|
|
* Sridhar Samudrala <sri@us.ibm.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/init.h>
|
2011-07-15 09:47:34 -06:00
|
|
|
#include <linux/export.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/sctp/sctp.h>
|
2008-02-10 00:23:44 -07:00
|
|
|
#include <net/ip.h> /* for snmp_fold_field */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-22 03:17:26 -07:00
|
|
|
static const struct snmp_mib sctp_snmp_list[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
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),
|
2006-08-22 01:15:33 -06:00
|
|
|
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),
|
2005-08-23 11:12:04 -06:00
|
|
|
SNMP_MIB_SENTINEL
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
|
|
|
|
static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2016-09-29 21:29:01 -06:00
|
|
|
unsigned long buff[SCTP_MIB_MAX];
|
2012-08-06 02:45:15 -06:00
|
|
|
struct net *net = seq->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
|
2016-09-29 21:29:01 -06:00
|
|
|
memset(buff, 0, sizeof(unsigned long) * SCTP_MIB_MAX);
|
|
|
|
|
|
|
|
snmp_get_cpu_field_batch(buff, sctp_snmp_list,
|
|
|
|
net->sctp.sctp_statistics);
|
2016-09-29 21:29:04 -06:00
|
|
|
for (i = 0; sctp_snmp_list[i].name; i++)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
|
2016-09-29 21:29:01 -06:00
|
|
|
buff[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the seq file operations for 'snmp' object. */
|
|
|
|
static int sctp_snmp_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2012-08-06 02:45:15 -06:00
|
|
|
return single_open_net(inode, file, sctp_snmp_seq_show);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:36 -07:00
|
|
|
static const struct file_operations sctp_snmp_seq_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = sctp_snmp_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2012-11-14 20:49:05 -07:00
|
|
|
.release = single_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Dump local addresses of an association/endpoint. */
|
|
|
|
static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
|
|
|
|
{
|
2005-06-13 16:11:57 -06:00
|
|
|
struct sctp_association *asoc;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_sockaddr_entry *laddr;
|
2005-06-13 16:11:57 -06:00
|
|
|
struct sctp_transport *peer;
|
|
|
|
union sctp_addr *addr, *primary = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_af *af;
|
|
|
|
|
2005-06-13 16:11:57 -06:00
|
|
|
if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
|
2013-06-14 10:24:04 -06:00
|
|
|
asoc = sctp_assoc(epb);
|
|
|
|
|
|
|
|
peer = asoc->peer.primary_path;
|
|
|
|
if (unlikely(peer == NULL)) {
|
2013-06-25 10:17:28 -06:00
|
|
|
WARN(1, "Association %p with NULL primary path!\n", asoc);
|
2013-06-14 10:24:04 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
primary = &peer->saddr;
|
2005-06-13 16:11:57 -06:00
|
|
|
}
|
|
|
|
|
2012-12-06 02:25:04 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(laddr, &epb->bind_addr.address_list, list) {
|
|
|
|
if (!laddr->valid)
|
|
|
|
continue;
|
|
|
|
|
2006-11-20 18:05:23 -07:00
|
|
|
addr = &laddr->a;
|
2005-04-16 16:20:36 -06:00
|
|
|
af = sctp_get_af_specific(addr->sa.sa_family);
|
2005-06-13 16:11:57 -06:00
|
|
|
if (primary && af->cmp_addr(addr, primary)) {
|
|
|
|
seq_printf(seq, "*");
|
|
|
|
}
|
2006-11-20 18:05:23 -07:00
|
|
|
af->seq_dump_addr(seq, addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-12-06 02:25:04 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
2005-06-13 16:11:57 -06:00
|
|
|
union sctp_addr *addr, *primary;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_af *af;
|
|
|
|
|
2006-11-20 18:06:04 -07:00
|
|
|
primary = &assoc->peer.primary_addr;
|
2012-12-06 02:25:05 -07:00
|
|
|
list_for_each_entry_rcu(transport, &assoc->peer.transport_addr_list,
|
2008-04-12 19:54:24 -06:00
|
|
|
transports) {
|
2006-11-20 18:05:23 -07:00
|
|
|
addr = &transport->ipaddr;
|
2012-12-06 02:25:05 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
af = sctp_get_af_specific(addr->sa.sa_family);
|
2006-11-20 18:06:04 -07:00
|
|
|
if (af->cmp_addr(addr, primary)) {
|
2005-06-13 16:11:57 -06:00
|
|
|
seq_printf(seq, "*");
|
|
|
|
}
|
2006-11-20 18:05:23 -07:00
|
|
|
af->seq_dump_addr(seq, addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-22 21:16:51 -07:00
|
|
|
static void *sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
|
2005-06-13 16:11:57 -06:00
|
|
|
{
|
2006-01-17 12:53:06 -07:00
|
|
|
if (*pos >= sctp_ep_hashsize)
|
2005-06-13 16:11:57 -06:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-22 21:16:51 -07:00
|
|
|
static void *sctp_eps_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
2005-06-13 16:11:57 -06:00
|
|
|
{
|
2006-01-17 12:53:06 -07:00
|
|
|
if (++*pos >= sctp_ep_hashsize)
|
2005-06-13 16:11:57 -06:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* 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;
|
2006-01-17 12:54:06 -07:00
|
|
|
int hash = *(loff_t *)v;
|
2005-06-13 16:11:57 -06:00
|
|
|
|
2006-01-17 12:53:06 -07:00
|
|
|
if (hash >= sctp_ep_hashsize)
|
2005-06-13 16:11:57 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-01-17 12:53:06 -07:00
|
|
|
head = &sctp_ep_hashtable[hash];
|
2017-06-10 01:13:32 -06:00
|
|
|
read_lock_bh(&head->lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
sctp_for_each_hentry(epb, &head->chain) {
|
2005-06-13 16:11:57 -06:00
|
|
|
ep = sctp_ep(epb);
|
|
|
|
sk = epb->sk;
|
2012-08-15 19:24:49 -06:00
|
|
|
if (!net_eq(sock_net(sk), seq_file_net(seq)))
|
2012-08-06 02:45:15 -06:00
|
|
|
continue;
|
2013-08-15 05:42:14 -06:00
|
|
|
seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5lu ", ep, sk,
|
2006-01-17 12:53:06 -07:00
|
|
|
sctp_sk(sk)->type, sk->sk_state, hash,
|
2005-06-13 16:11:57 -06:00
|
|
|
epb->bind_addr.port,
|
2012-05-24 01:10:10 -06:00
|
|
|
from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
|
|
|
|
sock_i_ino(sk));
|
2005-06-13 16:11:57 -06:00
|
|
|
|
|
|
|
sctp_seq_dump_local_addrs(seq, epb);
|
|
|
|
seq_printf(seq, "\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2017-06-10 01:13:32 -06:00
|
|
|
read_unlock_bh(&head->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-11 00:07:31 -06:00
|
|
|
static const struct seq_operations sctp_eps_ops = {
|
2005-06-13 16:11:57 -06:00
|
|
|
.start = sctp_eps_seq_start,
|
|
|
|
.next = sctp_eps_seq_next,
|
|
|
|
.stop = sctp_eps_seq_stop,
|
|
|
|
.show = sctp_eps_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Initialize the seq file operations for 'eps' object. */
|
|
|
|
static int sctp_eps_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2012-08-06 02:45:15 -06:00
|
|
|
return seq_open_net(inode, file, &sctp_eps_ops,
|
|
|
|
sizeof(struct seq_net_private));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:36 -07:00
|
|
|
static const struct file_operations sctp_eps_seq_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = sctp_eps_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2012-11-14 20:49:05 -07:00
|
|
|
.release = seq_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2015-12-30 08:50:48 -07:00
|
|
|
struct sctp_ht_iter {
|
|
|
|
struct seq_net_private p;
|
|
|
|
struct rhashtable_iter hti;
|
2016-04-14 01:35:35 -06:00
|
|
|
int start_fail;
|
2015-12-30 08:50:48 -07:00
|
|
|
};
|
2005-06-13 16:11:57 -06:00
|
|
|
|
2016-04-14 01:35:34 -06:00
|
|
|
static void *sctp_transport_seq_start(struct seq_file *seq, loff_t *pos)
|
2015-12-30 08:50:48 -07:00
|
|
|
{
|
2016-04-14 01:35:31 -06:00
|
|
|
struct sctp_ht_iter *iter = seq->private;
|
2015-12-30 08:50:48 -07:00
|
|
|
|
2017-12-04 11:31:41 -07:00
|
|
|
sctp_transport_walk_start(&iter->hti);
|
2015-12-30 08:50:48 -07:00
|
|
|
|
2016-08-12 01:50:51 -06:00
|
|
|
iter->start_fail = 0;
|
2016-04-14 01:35:31 -06:00
|
|
|
return sctp_transport_get_idx(seq_file_net(seq), &iter->hti, *pos);
|
2015-12-30 08:50:48 -07:00
|
|
|
}
|
|
|
|
|
2016-04-14 01:35:34 -06:00
|
|
|
static void sctp_transport_seq_stop(struct seq_file *seq, void *v)
|
2015-12-30 08:50:48 -07:00
|
|
|
{
|
2016-04-14 01:35:31 -06:00
|
|
|
struct sctp_ht_iter *iter = seq->private;
|
|
|
|
|
2016-04-14 01:35:35 -06:00
|
|
|
if (iter->start_fail)
|
|
|
|
return;
|
2016-04-14 01:35:31 -06:00
|
|
|
sctp_transport_walk_stop(&iter->hti);
|
2015-12-30 08:50:48 -07:00
|
|
|
}
|
2005-06-13 16:11:57 -06:00
|
|
|
|
2016-04-14 01:35:34 -06:00
|
|
|
static void *sctp_transport_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
2005-06-13 16:11:57 -06:00
|
|
|
{
|
2016-04-14 01:35:31 -06:00
|
|
|
struct sctp_ht_iter *iter = seq->private;
|
|
|
|
|
2015-12-30 08:50:48 -07:00
|
|
|
++*pos;
|
2005-06-13 16:11:57 -06:00
|
|
|
|
2016-04-14 01:35:31 -06:00
|
|
|
return sctp_transport_get_next(seq_file_net(seq), &iter->hti);
|
2005-06-13 16:11:57 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Display sctp associations (/proc/net/sctp/assocs). */
|
|
|
|
static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2015-12-30 08:50:48 -07:00
|
|
|
struct sctp_transport *transport;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_association *assoc;
|
2015-12-30 08:50:48 -07:00
|
|
|
struct sctp_ep_common *epb;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sock *sk;
|
2005-06-13 16:11:57 -06:00
|
|
|
|
2015-12-30 08:50:48 -07:00
|
|
|
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;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2015-12-30 08:50:48 -07:00
|
|
|
|
|
|
|
transport = (struct sctp_transport *)v;
|
2016-01-21 10:49:08 -07:00
|
|
|
if (!sctp_transport_hold(transport))
|
|
|
|
return 0;
|
2015-12-30 08:50:48 -07:00
|
|
|
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",
|
2017-05-31 02:36:31 -06:00
|
|
|
assoc->hbinterval, assoc->stream.incnt,
|
|
|
|
assoc->stream.outcnt, assoc->max_retrans,
|
2015-12-30 08:50:48 -07:00
|
|
|
assoc->init_retries, assoc->shutdown_retries,
|
|
|
|
assoc->rtx_data_chunks,
|
2017-06-30 04:08:00 -06:00
|
|
|
refcount_read(&sk->sk_wmem_alloc),
|
2015-12-30 08:50:48 -07:00
|
|
|
sk->sk_wmem_queued,
|
|
|
|
sk->sk_sndbuf,
|
|
|
|
sk->sk_rcvbuf);
|
|
|
|
seq_printf(seq, "\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-21 10:49:08 -07:00
|
|
|
sctp_transport_put(transport);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-11 00:07:31 -06:00
|
|
|
static const struct seq_operations sctp_assoc_ops = {
|
2016-04-14 01:35:34 -06:00
|
|
|
.start = sctp_transport_seq_start,
|
|
|
|
.next = sctp_transport_seq_next,
|
|
|
|
.stop = sctp_transport_seq_stop,
|
2005-06-13 16:11:57 -06:00
|
|
|
.show = sctp_assocs_seq_show,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Initialize the seq file operations for 'assocs' object. */
|
|
|
|
static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2012-08-06 02:45:15 -06:00
|
|
|
return seq_open_net(inode, file, &sctp_assoc_ops,
|
2015-12-30 08:50:48 -07:00
|
|
|
sizeof(struct sctp_ht_iter));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:36 -07:00
|
|
|
static const struct file_operations sctp_assocs_seq_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = sctp_assocs_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2012-11-14 20:49:05 -07:00
|
|
|
.release = seq_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2008-05-09 16:14:50 -06:00
|
|
|
static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct sctp_association *assoc;
|
2016-02-27 19:33:11 -07:00
|
|
|
struct sctp_transport *transport, *tsp;
|
2008-05-09 16:14:50 -06:00
|
|
|
|
2015-12-30 08:50:48 -07:00
|
|
|
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;
|
|
|
|
}
|
2008-05-09 16:14:50 -06:00
|
|
|
|
2016-02-27 19:33:11 -07:00
|
|
|
transport = (struct sctp_transport *)v;
|
|
|
|
if (!sctp_transport_hold(transport))
|
2016-01-21 10:49:08 -07:00
|
|
|
return 0;
|
2016-02-27 19:33:11 -07:00
|
|
|
assoc = transport->asoc;
|
2015-12-30 08:50:48 -07:00
|
|
|
|
|
|
|
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);
|
2012-12-06 02:25:05 -07:00
|
|
|
|
2015-12-30 08:50:48 -07:00
|
|
|
seq_printf(seq, "\n");
|
2008-05-09 16:14:50 -06:00
|
|
|
}
|
|
|
|
|
2016-02-27 19:33:11 -07:00
|
|
|
sctp_transport_put(transport);
|
2016-01-21 10:49:08 -07:00
|
|
|
|
2008-05-09 16:14:50 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations sctp_remaddr_ops = {
|
2016-04-14 01:35:34 -06:00
|
|
|
.start = sctp_transport_seq_start,
|
|
|
|
.next = sctp_transport_seq_next,
|
|
|
|
.stop = sctp_transport_seq_stop,
|
2008-05-09 16:14:50 -06:00
|
|
|
.show = sctp_remaddr_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int sctp_remaddr_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2012-08-06 02:45:15 -06:00
|
|
|
return seq_open_net(inode, file, &sctp_remaddr_ops,
|
2015-12-30 08:50:48 -07:00
|
|
|
sizeof(struct sctp_ht_iter));
|
2008-05-09 16:14:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations sctp_remaddr_seq_fops = {
|
|
|
|
.open = sctp_remaddr_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2012-11-14 20:49:05 -07:00
|
|
|
.release = seq_release_net,
|
2008-05-09 16:14:50 -06:00
|
|
|
};
|
|
|
|
|
2018-03-16 17:32:51 -06:00
|
|
|
/* Set up the proc fs entry for the SCTP protocol. */
|
|
|
|
int __net_init sctp_proc_init(struct net *net)
|
2008-05-09 16:14:50 -06:00
|
|
|
{
|
2018-03-16 17:32:51 -06:00
|
|
|
net->sctp.proc_net_sctp = proc_net_mkdir(net, "sctp", net->proc_net);
|
|
|
|
if (!net->sctp.proc_net_sctp)
|
2008-05-09 16:14:50 -06:00
|
|
|
return -ENOMEM;
|
2018-03-23 16:54:38 -06:00
|
|
|
if (!proc_create("snmp", 0444, net->sctp.proc_net_sctp,
|
|
|
|
&sctp_snmp_seq_fops))
|
2018-03-16 17:32:51 -06:00
|
|
|
goto cleanup;
|
2018-03-23 16:54:38 -06:00
|
|
|
if (!proc_create("eps", 0444, net->sctp.proc_net_sctp,
|
|
|
|
&sctp_eps_seq_fops))
|
2018-03-16 17:32:51 -06:00
|
|
|
goto cleanup;
|
2018-03-23 16:54:38 -06:00
|
|
|
if (!proc_create("assocs", 0444, net->sctp.proc_net_sctp,
|
|
|
|
&sctp_assocs_seq_fops))
|
2018-03-16 17:32:51 -06:00
|
|
|
goto cleanup;
|
2018-03-23 16:54:38 -06:00
|
|
|
if (!proc_create("remaddr", 0444, net->sctp.proc_net_sctp,
|
|
|
|
&sctp_remaddr_seq_fops))
|
2018-03-16 17:32:51 -06:00
|
|
|
goto cleanup;
|
2008-05-09 16:14:50 -06:00
|
|
|
return 0;
|
2018-03-16 17:32:51 -06:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
remove_proc_subtree("sctp", net->proc_net);
|
|
|
|
net->sctp.proc_net_sctp = NULL;
|
|
|
|
return -ENOMEM;
|
2008-05-09 16:14:50 -06:00
|
|
|
}
|