linux/net/sctp/proc.c
<<
>>
Prefs
   1/* SCTP kernel implementation
   2 * Copyright (c) 2003 International Business Machines, Corp.
   3 *
   4 * This file is part of the SCTP kernel implementation
   5 *
   6 * This SCTP implementation is free software;
   7 * you can redistribute it and/or modify it under the terms of
   8 * the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2, or (at your option)
  10 * any later version.
  11 *
  12 * This SCTP implementation is distributed in the hope that it
  13 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  14 *                 ************************
  15 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16 * See the GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with GNU CC; see the file COPYING.  If not, write to
  20 * the Free Software Foundation, 59 Temple Place - Suite 330,
  21 * Boston, MA 02111-1307, USA.
  22 *
  23 * Please send any bug reports or fixes you make to the
  24 * email address(es):
  25 *    lksctp developers <lksctp-developers@lists.sourceforge.net>
  26 *
  27 * Or submit a bug report through the following website:
  28 *    http://www.sf.net/projects/lksctp
  29 *
  30 * Written or modified by:
  31 *    Sridhar Samudrala <sri@us.ibm.com>
  32 *
  33 * Any bugs reported given to us we will try to fix... any fixes shared will
  34 * be incorporated into the next SCTP release.
  35 */
  36
  37#include <linux/types.h>
  38#include <linux/seq_file.h>
  39#include <linux/init.h>
  40#include <net/sctp/sctp.h>
  41#include <net/ip.h> /* for snmp_fold_field */
  42
  43static struct snmp_mib sctp_snmp_list[] = {
  44        SNMP_MIB_ITEM("SctpCurrEstab", SCTP_MIB_CURRESTAB),
  45        SNMP_MIB_ITEM("SctpActiveEstabs", SCTP_MIB_ACTIVEESTABS),
  46        SNMP_MIB_ITEM("SctpPassiveEstabs", SCTP_MIB_PASSIVEESTABS),
  47        SNMP_MIB_ITEM("SctpAborteds", SCTP_MIB_ABORTEDS),
  48        SNMP_MIB_ITEM("SctpShutdowns", SCTP_MIB_SHUTDOWNS),
  49        SNMP_MIB_ITEM("SctpOutOfBlues", SCTP_MIB_OUTOFBLUES),
  50        SNMP_MIB_ITEM("SctpChecksumErrors", SCTP_MIB_CHECKSUMERRORS),
  51        SNMP_MIB_ITEM("SctpOutCtrlChunks", SCTP_MIB_OUTCTRLCHUNKS),
  52        SNMP_MIB_ITEM("SctpOutOrderChunks", SCTP_MIB_OUTORDERCHUNKS),
  53        SNMP_MIB_ITEM("SctpOutUnorderChunks", SCTP_MIB_OUTUNORDERCHUNKS),
  54        SNMP_MIB_ITEM("SctpInCtrlChunks", SCTP_MIB_INCTRLCHUNKS),
  55        SNMP_MIB_ITEM("SctpInOrderChunks", SCTP_MIB_INORDERCHUNKS),
  56        SNMP_MIB_ITEM("SctpInUnorderChunks", SCTP_MIB_INUNORDERCHUNKS),
  57        SNMP_MIB_ITEM("SctpFragUsrMsgs", SCTP_MIB_FRAGUSRMSGS),
  58        SNMP_MIB_ITEM("SctpReasmUsrMsgs", SCTP_MIB_REASMUSRMSGS),
  59        SNMP_MIB_ITEM("SctpOutSCTPPacks", SCTP_MIB_OUTSCTPPACKS),
  60        SNMP_MIB_ITEM("SctpInSCTPPacks", SCTP_MIB_INSCTPPACKS),
  61        SNMP_MIB_ITEM("SctpT1InitExpireds", SCTP_MIB_T1_INIT_EXPIREDS),
  62        SNMP_MIB_ITEM("SctpT1CookieExpireds", SCTP_MIB_T1_COOKIE_EXPIREDS),
  63        SNMP_MIB_ITEM("SctpT2ShutdownExpireds", SCTP_MIB_T2_SHUTDOWN_EXPIREDS),
  64        SNMP_MIB_ITEM("SctpT3RtxExpireds", SCTP_MIB_T3_RTX_EXPIREDS),
  65        SNMP_MIB_ITEM("SctpT4RtoExpireds", SCTP_MIB_T4_RTO_EXPIREDS),
  66        SNMP_MIB_ITEM("SctpT5ShutdownGuardExpireds", SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS),
  67        SNMP_MIB_ITEM("SctpDelaySackExpireds", SCTP_MIB_DELAY_SACK_EXPIREDS),
  68        SNMP_MIB_ITEM("SctpAutocloseExpireds", SCTP_MIB_AUTOCLOSE_EXPIREDS),
  69        SNMP_MIB_ITEM("SctpT3Retransmits", SCTP_MIB_T3_RETRANSMITS),
  70        SNMP_MIB_ITEM("SctpPmtudRetransmits", SCTP_MIB_PMTUD_RETRANSMITS),
  71        SNMP_MIB_ITEM("SctpFastRetransmits", SCTP_MIB_FAST_RETRANSMITS),
  72        SNMP_MIB_ITEM("SctpInPktSoftirq", SCTP_MIB_IN_PKT_SOFTIRQ),
  73        SNMP_MIB_ITEM("SctpInPktBacklog", SCTP_MIB_IN_PKT_BACKLOG),
  74        SNMP_MIB_ITEM("SctpInPktDiscards", SCTP_MIB_IN_PKT_DISCARDS),
  75        SNMP_MIB_ITEM("SctpInDataChunkDiscards", SCTP_MIB_IN_DATA_CHUNK_DISCARDS),
  76        SNMP_MIB_SENTINEL
  77};
  78
  79/* Display sctp snmp mib statistics(/proc/net/sctp/snmp). */
  80static int sctp_snmp_seq_show(struct seq_file *seq, void *v)
  81{
  82        int i;
  83
  84        for (i = 0; sctp_snmp_list[i].name != NULL; i++)
  85                seq_printf(seq, "%-32s\t%ld\n", sctp_snmp_list[i].name,
  86                           snmp_fold_field((void **)sctp_statistics,
  87                                      sctp_snmp_list[i].entry));
  88
  89        return 0;
  90}
  91
  92/* Initialize the seq file operations for 'snmp' object. */
  93static int sctp_snmp_seq_open(struct inode *inode, struct file *file)
  94{
  95        return single_open(file, sctp_snmp_seq_show, NULL);
  96}
  97
  98static const struct file_operations sctp_snmp_seq_fops = {
  99        .owner   = THIS_MODULE,
 100        .open    = sctp_snmp_seq_open,
 101        .read    = seq_read,
 102        .llseek  = seq_lseek,
 103        .release = single_release,
 104};
 105
 106/* Set up the proc fs entry for 'snmp' object. */
 107int __init sctp_snmp_proc_init(void)
 108{
 109        struct proc_dir_entry *p;
 110
 111        p = proc_create("snmp", S_IRUGO, proc_net_sctp, &sctp_snmp_seq_fops);
 112        if (!p)
 113                return -ENOMEM;
 114
 115        return 0;
 116}
 117
 118/* Cleanup the proc fs entry for 'snmp' object. */
 119void sctp_snmp_proc_exit(void)
 120{
 121        remove_proc_entry("snmp", proc_net_sctp);
 122}
 123
 124/* Dump local addresses of an association/endpoint. */
 125static void sctp_seq_dump_local_addrs(struct seq_file *seq, struct sctp_ep_common *epb)
 126{
 127        struct sctp_association *asoc;
 128        struct sctp_sockaddr_entry *laddr;
 129        struct sctp_transport *peer;
 130        union sctp_addr *addr, *primary = NULL;
 131        struct sctp_af *af;
 132
 133        if (epb->type == SCTP_EP_TYPE_ASSOCIATION) {
 134            asoc = sctp_assoc(epb);
 135            peer = asoc->peer.primary_path;
 136            primary = &peer->saddr;
 137        }
 138
 139        list_for_each_entry(laddr, &epb->bind_addr.address_list, list) {
 140                addr = &laddr->a;
 141                af = sctp_get_af_specific(addr->sa.sa_family);
 142                if (primary && af->cmp_addr(addr, primary)) {
 143                        seq_printf(seq, "*");
 144                }
 145                af->seq_dump_addr(seq, addr);
 146        }
 147}
 148
 149/* Dump remote addresses of an association. */
 150static void sctp_seq_dump_remote_addrs(struct seq_file *seq, struct sctp_association *assoc)
 151{
 152        struct sctp_transport *transport;
 153        union sctp_addr *addr, *primary;
 154        struct sctp_af *af;
 155
 156        primary = &assoc->peer.primary_addr;
 157        list_for_each_entry(transport, &assoc->peer.transport_addr_list,
 158                        transports) {
 159                addr = &transport->ipaddr;
 160                af = sctp_get_af_specific(addr->sa.sa_family);
 161                if (af->cmp_addr(addr, primary)) {
 162                        seq_printf(seq, "*");
 163                }
 164                af->seq_dump_addr(seq, addr);
 165        }
 166}
 167
 168static void * sctp_eps_seq_start(struct seq_file *seq, loff_t *pos)
 169{
 170        if (*pos >= sctp_ep_hashsize)
 171                return NULL;
 172
 173        if (*pos < 0)
 174                *pos = 0;
 175
 176        if (*pos == 0)
 177                seq_printf(seq, " ENDPT     SOCK   STY SST HBKT LPORT   UID INODE LADDRS\n");
 178
 179        return (void *)pos;
 180}
 181
 182static void sctp_eps_seq_stop(struct seq_file *seq, void *v)
 183{
 184        return;
 185}
 186
 187
 188static void * sctp_eps_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 189{
 190        if (++*pos >= sctp_ep_hashsize)
 191                return NULL;
 192
 193        return pos;
 194}
 195
 196
 197/* Display sctp endpoints (/proc/net/sctp/eps). */
 198static int sctp_eps_seq_show(struct seq_file *seq, void *v)
 199{
 200        struct sctp_hashbucket *head;
 201        struct sctp_ep_common *epb;
 202        struct sctp_endpoint *ep;
 203        struct sock *sk;
 204        struct hlist_node *node;
 205        int    hash = *(loff_t *)v;
 206
 207        if (hash >= sctp_ep_hashsize)
 208                return -ENOMEM;
 209
 210        head = &sctp_ep_hashtable[hash];
 211        sctp_local_bh_disable();
 212        read_lock(&head->lock);
 213        sctp_for_each_hentry(epb, node, &head->chain) {
 214                ep = sctp_ep(epb);
 215                sk = epb->sk;
 216                seq_printf(seq, "%8p %8p %-3d %-3d %-4d %-5d %5d %5lu ", ep, sk,
 217                           sctp_sk(sk)->type, sk->sk_state, hash,
 218                           epb->bind_addr.port,
 219                           sock_i_uid(sk), sock_i_ino(sk));
 220
 221                sctp_seq_dump_local_addrs(seq, epb);
 222                seq_printf(seq, "\n");
 223        }
 224        read_unlock(&head->lock);
 225        sctp_local_bh_enable();
 226
 227        return 0;
 228}
 229
 230static const struct seq_operations sctp_eps_ops = {
 231        .start = sctp_eps_seq_start,
 232        .next  = sctp_eps_seq_next,
 233        .stop  = sctp_eps_seq_stop,
 234        .show  = sctp_eps_seq_show,
 235};
 236
 237
 238/* Initialize the seq file operations for 'eps' object. */
 239static int sctp_eps_seq_open(struct inode *inode, struct file *file)
 240{
 241        return seq_open(file, &sctp_eps_ops);
 242}
 243
 244static const struct file_operations sctp_eps_seq_fops = {
 245        .open    = sctp_eps_seq_open,
 246        .read    = seq_read,
 247        .llseek  = seq_lseek,
 248        .release = seq_release,
 249};
 250
 251/* Set up the proc fs entry for 'eps' object. */
 252int __init sctp_eps_proc_init(void)
 253{
 254        struct proc_dir_entry *p;
 255
 256        p = proc_create("eps", S_IRUGO, proc_net_sctp, &sctp_eps_seq_fops);
 257        if (!p)
 258                return -ENOMEM;
 259
 260        return 0;
 261}
 262
 263/* Cleanup the proc fs entry for 'eps' object. */
 264void sctp_eps_proc_exit(void)
 265{
 266        remove_proc_entry("eps", proc_net_sctp);
 267}
 268
 269
 270static void * sctp_assocs_seq_start(struct seq_file *seq, loff_t *pos)
 271{
 272        if (*pos >= sctp_assoc_hashsize)
 273                return NULL;
 274
 275        if (*pos < 0)
 276                *pos = 0;
 277
 278        if (*pos == 0)
 279                seq_printf(seq, " ASSOC     SOCK   STY SST ST HBKT "
 280                                "ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT "
 281                                "RPORT LADDRS <-> RADDRS "
 282                                "HBINT INS OUTS MAXRT T1X T2X RTXC\n");
 283
 284        return (void *)pos;
 285}
 286
 287static void sctp_assocs_seq_stop(struct seq_file *seq, void *v)
 288{
 289        return;
 290}
 291
 292
 293static void * sctp_assocs_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 294{
 295        if (++*pos >= sctp_assoc_hashsize)
 296                return NULL;
 297
 298        return pos;
 299}
 300
 301/* Display sctp associations (/proc/net/sctp/assocs). */
 302static int sctp_assocs_seq_show(struct seq_file *seq, void *v)
 303{
 304        struct sctp_hashbucket *head;
 305        struct sctp_ep_common *epb;
 306        struct sctp_association *assoc;
 307        struct sock *sk;
 308        struct hlist_node *node;
 309        int    hash = *(loff_t *)v;
 310
 311        if (hash >= sctp_assoc_hashsize)
 312                return -ENOMEM;
 313
 314        head = &sctp_assoc_hashtable[hash];
 315        sctp_local_bh_disable();
 316        read_lock(&head->lock);
 317        sctp_for_each_hentry(epb, node, &head->chain) {
 318                assoc = sctp_assoc(epb);
 319                sk = epb->sk;
 320                seq_printf(seq,
 321                           "%8p %8p %-3d %-3d %-2d %-4d "
 322                           "%4d %8d %8d %7d %5lu %-5d %5d ",
 323                           assoc, sk, sctp_sk(sk)->type, sk->sk_state,
 324                           assoc->state, hash,
 325                           assoc->assoc_id,
 326                           assoc->sndbuf_used,
 327                           atomic_read(&assoc->rmem_alloc),
 328                           sock_i_uid(sk), sock_i_ino(sk),
 329                           epb->bind_addr.port,
 330                           assoc->peer.port);
 331                seq_printf(seq, " ");
 332                sctp_seq_dump_local_addrs(seq, epb);
 333                seq_printf(seq, "<-> ");
 334                sctp_seq_dump_remote_addrs(seq, assoc);
 335                seq_printf(seq, "\t%8lu %5d %5d %4d %4d %4d %8d ",
 336                        assoc->hbinterval, assoc->c.sinit_max_instreams,
 337                        assoc->c.sinit_num_ostreams, assoc->max_retrans,
 338                        assoc->init_retries, assoc->shutdown_retries,
 339                        assoc->rtx_data_chunks);
 340                seq_printf(seq, "\n");
 341        }
 342        read_unlock(&head->lock);
 343        sctp_local_bh_enable();
 344
 345        return 0;
 346}
 347
 348static const struct seq_operations sctp_assoc_ops = {
 349        .start = sctp_assocs_seq_start,
 350        .next  = sctp_assocs_seq_next,
 351        .stop  = sctp_assocs_seq_stop,
 352        .show  = sctp_assocs_seq_show,
 353};
 354
 355/* Initialize the seq file operations for 'assocs' object. */
 356static int sctp_assocs_seq_open(struct inode *inode, struct file *file)
 357{
 358        return seq_open(file, &sctp_assoc_ops);
 359}
 360
 361static const struct file_operations sctp_assocs_seq_fops = {
 362        .open    = sctp_assocs_seq_open,
 363        .read    = seq_read,
 364        .llseek  = seq_lseek,
 365        .release = seq_release,
 366};
 367
 368/* Set up the proc fs entry for 'assocs' object. */
 369int __init sctp_assocs_proc_init(void)
 370{
 371        struct proc_dir_entry *p;
 372
 373        p = proc_create("assocs", S_IRUGO, proc_net_sctp,
 374                        &sctp_assocs_seq_fops);
 375        if (!p)
 376                return -ENOMEM;
 377
 378        return 0;
 379}
 380
 381/* Cleanup the proc fs entry for 'assocs' object. */
 382void sctp_assocs_proc_exit(void)
 383{
 384        remove_proc_entry("assocs", proc_net_sctp);
 385}
 386
 387static void *sctp_remaddr_seq_start(struct seq_file *seq, loff_t *pos)
 388{
 389        if (*pos >= sctp_assoc_hashsize)
 390                return NULL;
 391
 392        if (*pos < 0)
 393                *pos = 0;
 394
 395        if (*pos == 0)
 396                seq_printf(seq, "ADDR ASSOC_ID HB_ACT RTO MAX_PATH_RTX "
 397                                "REM_ADDR_RTX  START\n");
 398
 399        return (void *)pos;
 400}
 401
 402static void *sctp_remaddr_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 403{
 404        if (++*pos >= sctp_assoc_hashsize)
 405                return NULL;
 406
 407        return pos;
 408}
 409
 410static void sctp_remaddr_seq_stop(struct seq_file *seq, void *v)
 411{
 412        return;
 413}
 414
 415static int sctp_remaddr_seq_show(struct seq_file *seq, void *v)
 416{
 417        struct sctp_hashbucket *head;
 418        struct sctp_ep_common *epb;
 419        struct sctp_association *assoc;
 420        struct hlist_node *node;
 421        struct sctp_transport *tsp;
 422        int    hash = *(loff_t *)v;
 423
 424        if (hash >= sctp_assoc_hashsize)
 425                return -ENOMEM;
 426
 427        head = &sctp_assoc_hashtable[hash];
 428        sctp_local_bh_disable();
 429        read_lock(&head->lock);
 430        sctp_for_each_hentry(epb, node, &head->chain) {
 431                assoc = sctp_assoc(epb);
 432                list_for_each_entry(tsp, &assoc->peer.transport_addr_list,
 433                                        transports) {
 434                        /*
 435                         * The remote address (ADDR)
 436                         */
 437                        tsp->af_specific->seq_dump_addr(seq, &tsp->ipaddr);
 438                        seq_printf(seq, " ");
 439
 440                        /*
 441                         * The association ID (ASSOC_ID)
 442                         */
 443                        seq_printf(seq, "%d ", tsp->asoc->assoc_id);
 444
 445                        /*
 446                         * If the Heartbeat is active (HB_ACT)
 447                         * Note: 1 = Active, 0 = Inactive
 448                         */
 449                        seq_printf(seq, "%d ", timer_pending(&tsp->hb_timer));
 450
 451                        /*
 452                         * Retransmit time out (RTO)
 453                         */
 454                        seq_printf(seq, "%lu ", tsp->rto);
 455
 456                        /*
 457                         * Maximum path retransmit count (PATH_MAX_RTX)
 458                         */
 459                        seq_printf(seq, "%d ", tsp->pathmaxrxt);
 460
 461                        /*
 462                         * remote address retransmit count (REM_ADDR_RTX)
 463                         * Note: We don't have a way to tally this at the moment
 464                         * so lets just leave it as zero for the moment
 465                         */
 466                        seq_printf(seq, "0 ");
 467
 468                        /*
 469                         * remote address start time (START).  This is also not
 470                         * currently implemented, but we can record it with a
 471                         * jiffies marker in a subsequent patch
 472                         */
 473                        seq_printf(seq, "0");
 474
 475                        seq_printf(seq, "\n");
 476                }
 477        }
 478
 479        read_unlock(&head->lock);
 480        sctp_local_bh_enable();
 481
 482        return 0;
 483
 484}
 485
 486static const struct seq_operations sctp_remaddr_ops = {
 487        .start = sctp_remaddr_seq_start,
 488        .next  = sctp_remaddr_seq_next,
 489        .stop  = sctp_remaddr_seq_stop,
 490        .show  = sctp_remaddr_seq_show,
 491};
 492
 493/* Cleanup the proc fs entry for 'remaddr' object. */
 494void sctp_remaddr_proc_exit(void)
 495{
 496        remove_proc_entry("remaddr", proc_net_sctp);
 497}
 498
 499static int sctp_remaddr_seq_open(struct inode *inode, struct file *file)
 500{
 501        return seq_open(file, &sctp_remaddr_ops);
 502}
 503
 504static const struct file_operations sctp_remaddr_seq_fops = {
 505        .open = sctp_remaddr_seq_open,
 506        .read = seq_read,
 507        .llseek = seq_lseek,
 508        .release = seq_release,
 509};
 510
 511int __init sctp_remaddr_proc_init(void)
 512{
 513        struct proc_dir_entry *p;
 514
 515        p = create_proc_entry("remaddr", S_IRUGO, proc_net_sctp);
 516        if (!p)
 517                return -ENOMEM;
 518        p->proc_fops = &sctp_remaddr_seq_fops;
 519
 520        return 0;
 521}
 522