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