net/ipv4/proc.c

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              This file implements the various access functions for the
   7  *              PROC file system.  It is mainly used for debugging and
   8  *              statistics.
   9  *
  10  * Version:     $Id: proc.c,v 1.45 2001/05/16 16:45:35 davem Exp $
  11  *
  12  * Authors:     Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  13  *              Gerald J. Heim, <heim@peanuts.informatik.uni-tuebingen.de>
  14  *              Fred Baumgarten, <dc6iq@insu1.etec.uni-karlsruhe.de>
  15  *              Erik Schoenfelder, <schoenfr@ibr.cs.tu-bs.de>
  16  *
  17  * Fixes:
  18  *              Alan Cox        :       UDP sockets show the rxqueue/txqueue
  19  *                                      using hint flag for the netinfo.
  20  *      Pauline Middelink       :       identd support
  21  *              Alan Cox        :       Make /proc safer.
  22  *      Erik Schoenfelder       :       /proc/net/snmp
  23  *              Alan Cox        :       Handle dead sockets properly.
  24  *      Gerhard Koerting        :       Show both timers
  25  *              Alan Cox        :       Allow inode to be NULL (kernel socket)
  26  *      Andi Kleen              :       Add support for open_requests and
  27  *                                      split functions for more readibility.
  28  *      Andi Kleen              :       Add support for /proc/net/netstat
  29  *      Arnaldo C. Melo         :       Convert to seq_file
  30  *
  31  *              This program is free software; you can redistribute it and/or
  32  *              modify it under the terms of the GNU General Public License
  33  *              as published by the Free Software Foundation; either version
  34  *              2 of the License, or (at your option) any later version.
  35  */
  36 #include <linux/types.h>
  37 #include <net/icmp.h>
  38 #include <net/protocol.h>
  39 #include <net/tcp.h>
  40 #include <net/udp.h>
  41 #include <linux/proc_fs.h>
  42 #include <linux/seq_file.h>
  43 #include <net/sock.h>
  44 #include <net/raw.h>
  45
  46 static int fold_prot_inuse(struct proto *proto)
  47 {
  48         int res = 0;
  49         int cpu;
  50
  51         for (cpu = 0; cpu < NR_CPUS; cpu++)
  52                 res += proto->stats[cpu].inuse;
  53
  54         return res;
  55 }
  56
  57 /*
  58  *      Report socket allocation statistics [mea@utu.fi]
  59  */
  60 static int sockstat_seq_show(struct seq_file *seq, void *v)
  61 {
  62         /* From net/socket.c */
  63         extern void socket_seq_show(struct seq_file *seq);
  64
  65         socket_seq_show(seq);
  66         seq_printf(seq, "TCP: inuse %d orphan %d tw %d alloc %d mem %d\n",
  67                    fold_prot_inuse(&tcp_prot), atomic_read(&tcp_orphan_count),
  68                    tcp_tw_count, atomic_read(&tcp_sockets_allocated),
  69                    atomic_read(&tcp_memory_allocated));
  70         seq_printf(seq, "UDP: inuse %d\n", fold_prot_inuse(&udp_prot));
  71         seq_printf(seq, "RAW: inuse %d\n", fold_prot_inuse(&raw_prot));
  72         seq_printf(seq,  "FRAG: inuse %d memory %d\n", ip_frag_nqueues,
  73                    atomic_read(&ip_frag_mem));
  74         return 0;
  75 }
  76
  77 static int sockstat_seq_open(struct inode *inode, struct file *file)
  78 {
  79         return single_open(file, sockstat_seq_show, NULL);
  80 }
  81
  82 static struct file_operations sockstat_seq_fops = {
  83         .open    = sockstat_seq_open,
  84         .read    = seq_read,
  85         .llseek  = seq_lseek,
  86         .release = single_release,
  87 };
  88
  89 static unsigned long fold_field(unsigned long *begin, int sz, int nr)
  90 {
  91         unsigned long res = 0;
  92         int i;
  93
  94         sz /= sizeof(unsigned long);
  95
  96         for (i = 0; i < NR_CPUS; i++) {
  97                 res += begin[2 * i * sz + nr];
  98                 res += begin[(2 * i + 1) * sz + nr];
  99         }
 100         return res;
 101 }
 102
 103 /*
 104  *      Called from the PROCfs module. This outputs /proc/net/snmp.
 105  */
 106 static int snmp_seq_show(struct seq_file *seq, void *v)
 107 {
 108         extern int sysctl_ip_default_ttl;
 109         int i;
 110
 111         seq_printf(seq, "Ip: Forwarding DefaultTTL InReceives InHdrErrors "
 112                         "InAddrErrors ForwDatagrams InUnknownProtos "
 113                         "InDiscards InDelivers OutRequests OutDiscards "
 114                         "OutNoRoutes ReasmTimeout ReasmReqds ReasmOKs "
 115                         "ReasmFails FragOKs FragFails FragCreates\nIp: %d %d",
 116                         ipv4_devconf.forwarding ? 1 : 2, sysctl_ip_default_ttl);
 117
 118         for (i = 0;
 119              i < offsetof(struct ip_mib, __pad) / sizeof(unsigned long); i++)
 120                 seq_printf(seq, " %lu",
 121                            fold_field((unsigned long *)ip_statistics,
 122                                       sizeof(struct ip_mib), i));
 123
 124         seq_printf(seq, "\nIcmp: InMsgs InErrors InDestUnreachs InTimeExcds "
 125                         "InParmProbs InSrcQuenchs InRedirects InEchos "
 126                         "InEchoReps InTimestamps InTimestampReps InAddrMasks "
 127                         "InAddrMaskReps OutMsgs OutErrors OutDestUnreachs "
 128                         "OutTimeExcds OutParmProbs OutSrcQuenchs OutRedirects "
 129                         "OutEchos OutEchoReps OutTimestamps OutTimestampReps "
 130                         "OutAddrMasks OutAddrMaskReps\nIcmp:");
 131
 132         for (i = 0;
 133              i < offsetof(struct icmp_mib, dummy) / sizeof(unsigned long); i++)
 134                 seq_printf(seq, " %lu",
 135                            fold_field((unsigned long *)icmp_statistics,
 136                                       sizeof(struct icmp_mib), i));
 137
 138         seq_printf(seq, "\nTcp: RtoAlgorithm RtoMin RtoMax MaxConn ActiveOpens "
 139                         "PassiveOpens AttemptFails EstabResets CurrEstab "
 140                         "InSegs OutSegs RetransSegs InErrs OutRsts\nTcp:");
 141
 142         for (i = 0;
 143              i < offsetof(struct tcp_mib, __pad) / sizeof(unsigned long); i++)
 144                 seq_printf(seq, " %lu",
 145                            fold_field((unsigned long *)tcp_statistics,
 146                                       sizeof(struct tcp_mib), i));
 147
 148         seq_printf(seq, "\nUdp: InDatagrams NoPorts InErrors OutDatagrams\n"
 149                         "Udp:");
 150
 151         for (i = 0;
 152              i < offsetof(struct udp_mib, __pad) / sizeof(unsigned long); i++)
 153                 seq_printf(seq, " %lu",
 154                            fold_field((unsigned long *)udp_statistics,
 155                                       sizeof(struct udp_mib), i));
 156
 157         seq_putc(seq, '\n');
 158         return 0;
 159 }
 160
 161 static int snmp_seq_open(struct inode *inode, struct file *file)
 162 {
 163         return single_open(file, snmp_seq_show, NULL);
 164 }
 165
 166 static struct file_operations snmp_seq_fops = {
 167         .open    = snmp_seq_open,
 168         .read    = seq_read,
 169         .llseek  = seq_lseek,
 170         .release = single_release,
 171 };
 172
 173 /*
 174  *      Output /proc/net/netstat
 175  */
 176 static int netstat_seq_show(struct seq_file *seq, void *v)
 177 {
 178         int i;
 179
 180         seq_puts(seq, "TcpExt: SyncookiesSent SyncookiesRecv SyncookiesFailed"
 181                       " EmbryonicRsts PruneCalled RcvPruned OfoPruned"
 182                       " OutOfWindowIcmps LockDroppedIcmps ArpFilter"
 183                       " TW TWRecycled TWKilled"
 184                       " PAWSPassive PAWSActive PAWSEstab"
 185                       " DelayedACKs DelayedACKLocked DelayedACKLost"
 186                       " ListenOverflows ListenDrops"
 187                       " TCPPrequeued TCPDirectCopyFromBacklog"
 188                       " TCPDirectCopyFromPrequeue TCPPrequeueDropped"
 189                       " TCPHPHits TCPHPHitsToUser"
 190                       " TCPPureAcks TCPHPAcks"
 191                       " TCPRenoRecovery TCPSackRecovery"
 192                       " TCPSACKReneging"
 193                       " TCPFACKReorder TCPSACKReorder TCPRenoReorder"
 194                       " TCPTSReorder"
 195                       " TCPFullUndo TCPPartialUndo TCPDSACKUndo TCPLossUndo"
 196                       " TCPLoss TCPLostRetransmit"
 197                       " TCPRenoFailures TCPSackFailures TCPLossFailures"
 198                       " TCPFastRetrans TCPForwardRetrans TCPSlowStartRetrans"
 199                       " TCPTimeouts"
 200                       " TCPRenoRecoveryFail TCPSackRecoveryFail"
 201                       " TCPSchedulerFailed TCPRcvCollapsed"
 202                       " TCPDSACKOldSent TCPDSACKOfoSent TCPDSACKRecv"
 203                       " TCPDSACKOfoRecv"
 204                       " TCPAbortOnSyn TCPAbortOnData TCPAbortOnClose"
 205                       " TCPAbortOnMemory TCPAbortOnTimeout TCPAbortOnLinger"
 206                       " TCPAbortFailed TCPMemoryPressures\n"
 207                       "TcpExt:");
 208         for (i = 0;
 209              i < offsetof(struct linux_mib, __pad) / sizeof(unsigned long); i++)
 210                 seq_printf(seq, " %lu",
 211                            fold_field((unsigned long *)net_statistics,
 212                                       sizeof(struct linux_mib), i));
 213         seq_putc(seq, '\n');
 214         return 0;
 215 }
 216
 217 static int netstat_seq_open(struct inode *inode, struct file *file)
 218 {
 219         return single_open(file, netstat_seq_show, NULL);
 220 }
 221
 222 static struct file_operations netstat_seq_fops = {
 223         .open    = netstat_seq_open,
 224         .read    = seq_read,
 225         .llseek  = seq_lseek,
 226         .release = single_release,
 227 };
 228
 229 int __init ip_misc_proc_init(void)
 230 {
 231         int rc = 0;
 232         struct proc_dir_entry *p;
 233
 234         p = create_proc_entry("netstat", S_IRUGO, proc_net);
 235         if (!p)
 236                 goto out_netstat;
 237         p->proc_fops = &netstat_seq_fops;
 238
 239         p = create_proc_entry("snmp", S_IRUGO, proc_net);
 240         if (!p)
 241                 goto out_snmp;
 242         p->proc_fops = &snmp_seq_fops;
 243
 244         p = create_proc_entry("sockstat", S_IRUGO, proc_net);
 245         if (!p)
 246                 goto out_sockstat;
 247         p->proc_fops = &sockstat_seq_fops;
 248 out:
 249         return rc;
 250 out_sockstat:
 251         remove_proc_entry("snmp", proc_net);
 252 out_snmp:
 253         remove_proc_entry("netstat", proc_net);
 254 out_netstat:
 255         rc = -ENOMEM;
 256         goto out;
 257 }
 258
 259 int ip_seq_release(struct inode *inode, struct file *file)
 260 {
 261         struct seq_file *seq = (struct seq_file *)file->private_data;
 262
 263         kfree(seq->private);
 264         seq->private = NULL;
 265         return seq_release(inode, file);
 266 }