/* * INET An implementation of the TCP/IP protocol suite for the LINUX * operating system. INET is implemented using the BSD Socket * interface as the means of communication with the user level. * * This file implements the various access functions for the * PROC file system. It is mainly used for debugging and * statistics. * * Version: $Id: proc.c,v 1.34 1999/02/08 11:20:34 davem Exp $ * * Authors: Fred N. van Kempen, * Gerald J. Heim, * Fred Baumgarten, * Erik Schoenfelder, * * Fixes: * Alan Cox : UDP sockets show the rxqueue/txqueue * using hint flag for the netinfo. * Pauline Middelink : identd support * Alan Cox : Make /proc safer. * Erik Schoenfelder : /proc/net/snmp * Alan Cox : Handle dead sockets properly. * Gerhard Koerting : Show both timers * Alan Cox : Allow inode to be NULL (kernel socket) * Andi Kleen : Add support for open_requests and * split functions for more readibility. * Andi Kleen : Add support for /proc/net/netstat * * This program is free software; 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 of the License, or (at your option) any later version. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Format a single open_request into tmpbuf. */ static inline void get__openreq(struct sock *sk, struct open_request *req, char *tmpbuf, int i) { sprintf(tmpbuf, "%4d: %08lX:%04X %08lX:%04X" " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u", i, (long unsigned int)req->af.v4_req.loc_addr, ntohs(sk->sport), (long unsigned int)req->af.v4_req.rmt_addr, ntohs(req->rmt_port), TCP_SYN_RECV, 0,0, /* could print option size, but that is af dependent. */ 1, /* timers active (only the expire timer) */ (unsigned long)(req->expires - jiffies), req->retrans, sk->socket ? sk->socket->inode->i_uid : 0, 0, /* non standard timer */ 0 /* open_requests have no inode */ ); } /* Format a single socket into tmpbuf. */ static inline void get__sock(struct sock *sp, char *tmpbuf, int i, int format) { unsigned long dest, src; unsigned short destp, srcp; int timer_active, timer_active1, timer_active2; int tw_bucket = 0; unsigned long timer_expires; struct tcp_opt *tp = &sp->tp_pinfo.af_tcp; dest = sp->daddr; src = sp->rcv_saddr; destp = sp->dport; srcp = sp->sport; /* FIXME: The fact that retransmit_timer occurs as a field * in two different parts of the socket structure is, * to say the least, confusing. This code now uses the * right retransmit_timer variable, but I'm not sure * the rest of the timer stuff is still correct. * In particular I'm not sure what the timeout value * is suppose to reflect (as opposed to tm->when). -- erics */ destp = ntohs(destp); srcp = ntohs(srcp); if((format == 0) && (sp->state == TCP_TIME_WAIT)) { extern int tcp_tw_death_row_slot; struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sp; int slot_dist; tw_bucket = 1; timer_active1 = timer_active2 = 0; timer_active = 3; slot_dist = tw->death_slot; if(slot_dist > tcp_tw_death_row_slot) slot_dist = (TCP_TWKILL_SLOTS - slot_dist) + tcp_tw_death_row_slot; else slot_dist = tcp_tw_death_row_slot - slot_dist; timer_expires = jiffies + (slot_dist * TCP_TWKILL_PERIOD); } else { timer_active1 = del_timer(&tp->retransmit_timer); timer_active2 = del_timer(&sp->timer); if (!timer_active1) tp->retransmit_timer.expires=0; if (!timer_active2) sp->timer.expires=0; timer_active = 0; timer_expires = (unsigned) -1; } if (timer_active1 && tp->retransmit_timer.expires < timer_expires) { timer_active = 1; timer_expires = tp->retransmit_timer.expires; } if (timer_active2 && sp->timer.expires < timer_expires) { timer_active = 2; timer_expires = sp->timer.expires; } if(timer_active == 0) timer_expires = jiffies; sprintf(tmpbuf, "%4d: %08lX:%04X %08lX:%04X" " %02X %08X:%08X %02X:%08lX %08X %5d %8d %ld", i, src, srcp, dest, destp, sp->state, (tw_bucket ? 0 : (format == 0) ? tp->write_seq-tp->snd_una : atomic_read(&sp->wmem_alloc)), (tw_bucket ? 0 : (format == 0) ? tp->rcv_nxt-tp->copied_seq: atomic_read(&sp->rmem_alloc)), timer_active, timer_expires-jiffies, (tw_bucket ? 0 : tp->retransmits), (!tw_bucket && sp->socket) ? sp->socket->inode->i_uid : 0, (!tw_bucket && timer_active) ? sp->timeout : 0, (!tw_bucket && sp->socket) ? sp->socket->inode->i_ino : 0); if (timer_active1) add_timer(&tp->retransmit_timer); if (timer_active2) add_timer(&sp->timer); } /* * Get__netinfo returns the length of that string. * * KNOWN BUGS * As in get_unix_netinfo, the buffer might be too small. If this * happens, get__netinfo returns only part of the available infos. * * Assumes that buffer length is a multiply of 128 - if not it will * write past the end. */ static int get__netinfo(struct proto *pro, char *buffer, int format, char **start, off_t offset, int length) { struct sock *sp, *next; int len=0, i = 0; off_t pos=0; off_t begin; char tmpbuf[129]; if (offset < 128) len += sprintf(buffer, "%-127s\n", " sl local_address rem_address st tx_queue " "rx_queue tr tm->when retrnsmt uid timeout inode"); pos = 128; SOCKHASH_LOCK(); sp = pro->sklist_next; while(sp != (struct sock *)pro) { if (format == 0 && sp->state == TCP_LISTEN) { struct open_request *req; for (req = sp->tp_pinfo.af_tcp.syn_wait_queue; req; i++, req = req->dl_next) { if (req->sk) continue; pos += 128; if (pos < offset) continue; get__openreq(sp, req, tmpbuf, i); len += sprintf(buffer+len, "%-127s\n", tmpbuf); if(len >= length) goto out; } } pos += 128; if (pos < offset) goto next; get__sock(sp, tmpbuf, i, format); len += sprintf(buffer+len, "%-127s\n", tmpbuf); if(len >= length) break; next: next = sp->sklist_next; sp = next; i++; } out: SOCKHASH_UNLOCK(); begin = len - (pos - offset); *start = buffer + begin; len -= begin; if(len>length) len = length; if (len<0) len = 0; return len; } int tcp_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { return get__netinfo(&tcp_prot, buffer,0, start, offset, length); } int udp_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { return get__netinfo(&udp_prot, buffer,1, start, offset, length); } int raw_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { return get__netinfo(&raw_prot, buffer,1, start, offset, length); } /* * Report socket allocation statistics [mea@utu.fi] */ int afinet_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { /* From net/socket.c */ extern int socket_get_info(char *, char **, off_t, int); int len = socket_get_info(buffer,start,offset,length); len += sprintf(buffer+len,"TCP: inuse %d highest %d\n", tcp_prot.inuse, tcp_prot.highestinuse); len += sprintf(buffer+len,"UDP: inuse %d highest %d\n", udp_prot.inuse, udp_prot.highestinuse); len += sprintf(buffer+len,"RAW: inuse %d highest %d\n", raw_prot.inuse, raw_prot.highestinuse); if (offset >= len) { *start = buffer; return 0; } *start = buffer + offset; len -= offset; if (len > length) len = length; if (len < 0) len = 0; return len; } /* * Called from the PROCfs module. This outputs /proc/net/snmp. */ int snmp_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { extern struct tcp_mib tcp_statistics; extern struct udp_mib udp_statistics; int len; /* extern unsigned long tcp_rx_miss, tcp_rx_hit1,tcp_rx_hit2; */ len = sprintf (buffer, "Ip: Forwarding DefaultTTL InReceives InHdrErrors InAddrErrors ForwDatagrams InUnknownProtos InDiscards InDelivers OutRequests OutDiscards OutNoRoutes ReasmTimeout ReasmReqds ReasmOKs ReasmFails FragOKs FragFails FragCreates\n" "Ip: %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n", ip_statistics.IpForwarding, ip_statistics.IpDefaultTTL, ip_statistics.IpInReceives, ip_statistics.IpInHdrErrors, ip_statistics.IpInAddrErrors, ip_statistics.IpForwDatagrams, ip_statistics.IpInUnknownProtos, ip_statistics.IpInDiscards, ip_statistics.IpInDelivers, ip_statistics.IpOutRequests, ip_statistics.IpOutDiscards, ip_statistics.IpOutNoRoutes, ip_statistics.IpReasmTimeout, ip_statistics.IpReasmReqds, ip_statistics.IpReasmOKs, ip_statistics.IpReasmFails, ip_statistics.IpFragOKs, ip_statistics.IpFragFails, ip_statistics.IpFragCreates); len += sprintf (buffer + len, "Icmp: InMsgs InErrors InDestUnreachs InTimeExcds InParmProbs InSrcQuenchs InRedirects InEchos InEchoReps InTimestamps InTimestampReps InAddrMasks InAddrMaskReps OutMsgs OutErrors OutDestUnreachs OutTimeExcds OutParmProbs OutSrcQuenchs OutRedirects OutEchos OutEchoReps OutTimestamps OutTimestampReps OutAddrMasks OutAddrMaskReps\n" "Icmp: %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n", icmp_statistics.IcmpInMsgs, icmp_statistics.IcmpInErrors, icmp_statistics.IcmpInDestUnreachs, icmp_statistics.IcmpInTimeExcds, icmp_statistics.IcmpInParmProbs, icmp_statistics.IcmpInSrcQuenchs, icmp_statistics.IcmpInRedirects, icmp_statistics.IcmpInEchos, icmp_statistics.IcmpInEchoReps, icmp_statistics.IcmpInTimestamps, icmp_statistics.IcmpInTimestampReps, icmp_statistics.IcmpInAddrMasks, icmp_statistics.IcmpInAddrMaskReps, icmp_statistics.IcmpOutMsgs, icmp_statistics.IcmpOutErrors, icmp_statistics.IcmpOutDestUnreachs, icmp_statistics.IcmpOutTimeExcds, icmp_statistics.IcmpOutParmProbs, icmp_statistics.IcmpOutSrcQuenchs, icmp_statistics.IcmpOutRedirects, icmp_statistics.IcmpOutEchos, icmp_statistics.IcmpOutEchoReps, icmp_statistics.IcmpOutTimestamps, icmp_statistics.IcmpOutTimestampReps, icmp_statistics.IcmpOutAddrMasks, icmp_statistics.IcmpOutAddrMaskReps); len += sprintf (buffer + len, "Tcp: RtoAlgorithm RtoMin RtoMax MaxConn ActiveOpens PassiveOpens AttemptFails EstabResets CurrEstab InSegs OutSegs RetransSegs InErrs OutRsts\n" "Tcp: %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n", tcp_statistics.TcpRtoAlgorithm, tcp_statistics.TcpRtoMin, tcp_statistics.TcpRtoMax, tcp_statistics.TcpMaxConn, tcp_statistics.TcpActiveOpens, tcp_statistics.TcpPassiveOpens, tcp_statistics.TcpAttemptFails, tcp_statistics.TcpEstabResets, tcp_statistics.TcpCurrEstab, tcp_statistics.TcpInSegs, tcp_statistics.TcpOutSegs, tcp_statistics.TcpRetransSegs, tcp_statistics.TcpInErrs, tcp_statistics.TcpOutRsts); len += sprintf (buffer + len, "Udp: InDatagrams NoPorts InErrors OutDatagrams\nUdp: %lu %lu %lu %lu\n", udp_statistics.UdpInDatagrams, udp_statistics.UdpNoPorts, udp_statistics.UdpInErrors, udp_statistics.UdpOutDatagrams); /* len += sprintf( buffer + len, "TCP fast path RX: H2: %ul H1: %ul L: %ul\n", tcp_rx_hit2,tcp_rx_hit1,tcp_rx_miss); */ if (offset >= len) { *start = buffer; return 0; } *start = buffer + offset; len -= offset; if (len > length) len = length; if (len < 0) len = 0; return len; } /* * Output /proc/net/netstat */ int netstat_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { extern struct linux_mib net_statistics; int len; len = sprintf(buffer, "TcpExt: SyncookiesSent SyncookiesRecv SyncookiesFailed" " EmbryonicRsts PruneCalled RcvPruned OfoPruned" " OutOfWindowIcmps LockDroppedIcmps\n" "TcpExt: %lu %lu %lu %lu %lu %lu %lu %lu %lu\n", net_statistics.SyncookiesSent, net_statistics.SyncookiesRecv, net_statistics.SyncookiesFailed, net_statistics.EmbryonicRsts, net_statistics.PruneCalled, net_statistics.RcvPruned, net_statistics.OfoPruned, net_statistics.OutOfWindowIcmps, net_statistics.LockDroppedIcmps); if (offset >= len) { *start = buffer; return 0; } *start = buffer + offset; len -= offset; if (len > length) len = length; if (len < 0) len = 0; return len; }