From: Derrick Brashear Date: Thu, 11 Nov 2004 07:12:42 +0000 (+0000) Subject: kdump-in-kernel-20041111 X-Git-Tag: BP-disconnected~147 X-Git-Url: https://git.michaelhowe.org/gitweb/?a=commitdiff_plain;h=32c55d118baa6315402d896d6b874705fe1189a5;p=packages%2Fo%2Fopenafs.git kdump-in-kernel-20041111 first step at integrating kdump functionality into the kernel; all the rx stats. --- diff --git a/src/afs/LINUX/osi_module.c b/src/afs/LINUX/osi_module.c index c999d91f2..35624d101 100644 --- a/src/afs/LINUX/osi_module.c +++ b/src/afs/LINUX/osi_module.c @@ -178,13 +178,354 @@ csdbproc_read(char *buffer, char **start, off_t offset, int count, return len; } +int +peerproc_read(char *buffer, char **start, off_t offset, int count, + int *eof, void *data) +{ + int len, i, j; + struct rx_peer *sep; + void *ret = NULL; + char tbuffer[16]; + afs_uint32 addr; + + len = 0; + for (i = 0, j = 0; i < 256; i++) { + for (sep = rx_peerHashTable[i]; sep; sep = sep->next, j++) { + len += sprintf(buffer + len, "%lx: next=0x%lx, host=0x%x, ", sep, sep->next, + sep->host); + len += sprintf(buffer + len, "ifMTU=%d, natMTU=%d, maxMTU=%d\n", sep->ifMTU, + sep->natMTU, sep->maxMTU); + len += sprintf(buffer + len, "\trtt=%d:%d, timeout(%d:%d), nSent=%d, reSends=%d\n", + sep->rtt, sep->rtt_dev, sep->timeout.sec, + sep->timeout.usec, sep->nSent, sep->reSends); + len += sprintf(buffer + len, "\trefCount=%d, port=%d, idleWhen=0x%x\n", + sep->refCount, sep->port, sep->idleWhen); + len += sprintf(buffer + len, "\tCongestionQueue (0x%x:0x%x), inPacketSkew=0x%x, outPacketSkew=0x%x\n", + sep->congestionQueue.prev, sep->congestionQueue.next, + sep->inPacketSkew, sep->outPacketSkew); +#ifdef RX_ENABLE_LOCKS + len += sprintf(buffer + len, "\tpeer_lock=%d\n", sep->peer_lock); +#endif /* RX_ENABLE_LOCKS */ + } + } + + if (offset >= len) { + *start = buffer; + *eof = 1; + return 0; + } + *start = buffer + offset; + if ((len -= offset) > count) + return count; + *eof = 1; + return len; +} + +int +rxstatsproc_read(char *buffer, char **start, off_t offset, int count, + int *eof, void *data) +{ + int len, i, j; + void *ret = NULL; + char tbuffer[16]; + afs_uint32 addr; + + len = 0; + len += sprintf(buffer + len, "packetRequests = %d\n", rx_stats.packetRequests); + len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_RECEIVE, + rx_stats.receivePktAllocFailures); + len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_SEND, + rx_stats.sendPktAllocFailures); + len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_SPECIAL, + rx_stats.specialPktAllocFailures); + len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_RECV_CBUF, + rx_stats.receiveCbufPktAllocFailures); + len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_SEND_CBUF, + rx_stats.sendCbufPktAllocFailures); + len += sprintf(buffer + len, "socketGreedy = %d\n", rx_stats.socketGreedy); + len += sprintf(buffer + len, "bogusPacketOnRead = %d\n", rx_stats.bogusPacketOnRead); + len += sprintf(buffer + len, "bogusHost = %d\n", rx_stats.bogusHost); + len += sprintf(buffer + len, "noPacketOnRead = %d\n", rx_stats.noPacketOnRead); + len += sprintf(buffer + len, "noPacketBuffersOnRead = %d\n", + rx_stats.noPacketBuffersOnRead); + len += sprintf(buffer + len, "selects = %d\n", rx_stats.selects); + len += sprintf(buffer + len, "sendSelects = %d\n", rx_stats.sendSelects); + for (i = 0; i < RX_N_PACKET_TYPES; i++) + len += sprintf(buffer + len, "packetsRead[%d] = %d\n", i, rx_stats.packetsRead[i]); + len += sprintf(buffer + len, "dataPacketsRead = %d\n", rx_stats.dataPacketsRead); + len += sprintf(buffer + len, "ackPacketsRead = %d\n", rx_stats.ackPacketsRead); + len += sprintf(buffer + len, "dupPacketsRead = %d\n", rx_stats.dupPacketsRead); + len += sprintf(buffer + len, "spuriousPacketsRead = %d\n", rx_stats.spuriousPacketsRead); + for (i = 0; i < RX_N_PACKET_TYPES; i++) + len += sprintf(buffer + len, "packetsSent[%d] = %d\n", i, rx_stats.packetsSent[i]); + len += sprintf(buffer + len, "ackPacketsSent = %d\n", rx_stats.ackPacketsSent); + len += sprintf(buffer + len, "pingPacketsSent = %d\n", rx_stats.pingPacketsSent); + len += sprintf(buffer + len, "abortPacketsSent = %d\n", rx_stats.abortPacketsSent); + len += sprintf(buffer + len, "busyPacketsSent = %d\n", rx_stats.busyPacketsSent); + len += sprintf(buffer + len, "dataPacketsSent = %d\n", rx_stats.dataPacketsSent); + len += sprintf(buffer + len, "dataPacketsReSent = %d\n", rx_stats.dataPacketsReSent); + len += sprintf(buffer + len, "dataPacketsPushed = %d\n", rx_stats.dataPacketsPushed); + len += sprintf(buffer + len, "ignoreAckedPacket = %d\n", rx_stats.ignoreAckedPacket); + len += sprintf(buffer + len, "totalRtt = %d sec, %d usec\n", rx_stats.totalRtt.sec, + rx_stats.totalRtt.usec); + len += sprintf(buffer + len, "minRtt = %d sec, %d usec\n", rx_stats.minRtt.sec, + rx_stats.minRtt.usec); + len += sprintf(buffer + len, "maxRtt = %d sec, %d usec\n", rx_stats.maxRtt.sec, + rx_stats.maxRtt.usec); + len += sprintf(buffer + len, "nRttSamples = %d\n", rx_stats.nRttSamples); + len += sprintf(buffer + len, "nServerConns = %d\n", rx_stats.nServerConns); + len += sprintf(buffer + len, "nClientConns = %d\n", rx_stats.nClientConns); + len += sprintf(buffer + len, "nPeerStructs = %d\n", rx_stats.nPeerStructs); + len += sprintf(buffer + len, "nCallStructs = %d\n", rx_stats.nCallStructs); + len += sprintf(buffer + len, "nFreeCallStructs = %d\n", rx_stats.nFreeCallStructs); + len += sprintf(buffer + len, "netSendFailures = %d\n", rx_stats.netSendFailures); + len += sprintf(buffer + len, "fatalErrors = %d\n", rx_stats.fatalErrors); + + if (offset >= len) { + *start = buffer; + *eof = 1; + return 0; + } + *start = buffer + offset; + if ((len -= offset) > count) + return count; + *eof = 1; + return len; +} + +int +rxproc_read(char *buffer, char **start, off_t offset, int count, + int *eof, void *data) +{ + int len, i, j; + struct rx_peer *sep; + void *ret = NULL; + char tbuffer[16]; + afs_uint32 addr; + + len = 0; + len += sprintf(buffer + len, "rx_extraQuota = %d\n", rx_extraQuota); + len += sprintf(buffer + len, "rx_extraPackets = %d\n", rx_extraPackets); + len += sprintf(buffer + len, "rx_stackSize = %d\n", rx_stackSize); + len += sprintf(buffer + len, "rx_connDeadTime = %d\n", rx_connDeadTime); + len += sprintf(buffer + len, "rx_idleConnectionTime = %d\n", rx_idleConnectionTime); + len += sprintf(buffer + len, "rx_idlePeerTime = %d\n", rx_idlePeerTime); + len += sprintf(buffer + len, "rx_initSendWindow = %d\n", rx_initSendWindow); + len += sprintf(buffer + len, "rxi_nSendFrags = %d\n", rxi_nSendFrags); + len += sprintf(buffer + len, "rx_nPackets = %d\n", rx_nPackets); + len += sprintf(buffer + len, "rx_nFreePackets = %d\n", rx_nFreePackets); + len += sprintf(buffer + len, "rx_socket = 0x%x\n", rx_socket); + len += sprintf(buffer + len, "rx_Port = %d\n", rx_port); + for (i = 0; i < RX_N_PACKET_CLASSES; i++) + len += sprintf(buffer + len, "\trx_packetQuota[%d] = %d\n", i, rx_packetQuota[i]); + + len += sprintf(buffer + len, "rx_nextCid = 0x%x\n", rx_nextCid); + len += sprintf(buffer + len, "rx_epoch = 0u%u\n", rx_epoch); + len += sprintf(buffer + len, "rx_waitingForPackets = %x\n", rx_waitingForPackets); + len += sprintf(buffer + len, "rxi_nCalls = %d\n", rxi_nCalls); + len += sprintf(buffer + len, "rxi_dataQuota = %d\n", rxi_dataQuota); + len += sprintf(buffer + len, "rxi_availProcs = %d\n", rxi_availProcs); + len += sprintf(buffer + len, "rxi_totalMin = %d\n", rxi_totalMin); + len += sprintf(buffer + len, "rxi_minDeficit = %d\n", rxi_minDeficit); + + len += sprintf(buffer + len, "rxevent_nFree = %d\nrxevent_nPosted = %d\n", rxevent_nFree, rxevent_nPosted); + + if (offset >= len) { + *start = buffer; + *eof = 1; + return 0; + } + *start = buffer + offset; + if ((len -= offset) > count) + return count; + *eof = 1; + return len; +} + +int +connproc_read(char *buffer, char **start, off_t offset, int count, + int *eof, void *data) +{ + int len, i, j; + struct rx_connection *sep; + void *ret = NULL; + char tbuffer[16]; + afs_uint32 addr; + + len = 0; + for (i = 0, j = 0; i < 256; i++) { + for (sep = rx_connHashTable[i]; sep; sep = sep->next, j++) { + len += sprintf(buffer + len, "%lx: next=0x%lx, peer=0x%lx, epoch=0x%x, cid=0x%x, ackRate=%d\n", + sep, sep->next, sep->peer, sep->epoch, sep->cid, + sep->ackRate); + len += sprintf(buffer + len, "\tcall[%x=%d, %x=%d, %x=%d, %x=%d]\n", + sep->call[0], sep->callNumber[0], sep->call[1], + sep->callNumber[1], sep->call[2], + sep->callNumber[2], sep->call[3], + sep->callNumber[3]); + len += sprintf(buffer + len, "\ttimeout=%d, flags=0x%x, type=0x%x, serviceId=%d, service=0x%lx, refCount=%d\n", + sep->timeout, sep->flags, sep->type, + sep->serviceId, sep->service, sep->refCount); + len += sprintf(buffer + len, "\tserial=%d, lastSerial=%d, secsUntilDead=%d, secsUntilPing=%d, secIndex=%d\n", + sep->serial, sep->lastSerial, sep->secondsUntilDead, + sep->secondsUntilPing, sep->securityIndex); + len += sprintf(buffer + len, "\terror=%d, secObject=0x%lx, secData=0x%lx, secHeaderSize=%d, secmaxTrailerSize=%d\n", + sep->error, sep->securityObject, sep->securityData, + sep->securityHeaderSize, + sep->securityMaxTrailerSize); + len += sprintf(buffer + len, "\tchallEvent=0x%lx, lastSendTime=0x%x, maxSerial=%d, hardDeadTime=%d\n", + sep->challengeEvent, sep->lastSendTime, + sep->maxSerial, sep->hardDeadTime); + if (sep->flags & RX_CONN_MAKECALL_WAITING) + len += sprintf(buffer + len, "\t***** Conn in RX_CONN_MAKECALL_WAITING state *****\n"); +#ifdef RX_ENABLE_LOCKS + len += sprintf(buffer + len, "\tcall_lock=%d, call_cv=%d, data_lock=%d, refCount=%d\n", + sep->conn_call_lock, sep->conn_call_cv, + sep->conn_data_lock, sep->refCount); +#endif /* RX_ENABLE_LOCKS */ + } + } + + if (offset >= len) { + *start = buffer; + *eof = 1; + return 0; + } + *start = buffer + offset; + if ((len -= offset) > count) + return count; + *eof = 1; + return len; +} + +int +servicesproc_read(char *buffer, char **start, off_t offset, int count, + int *eof, void *data) +{ + int len, i, j; + struct rx_service *sentry; + void *ret = NULL; + char tbuffer[16]; + afs_uint32 addr; + + len = 0; + for (i = 0, j = 0; i < RX_MAX_SERVICES; i++) { + if (sentry = rx_services[i]) { + j++; + len += sprintf(buffer + len, + "\t%lx: serviceId=%d, port=%d, serviceName=%s, socket=0x%x\n", + sentry, sentry->serviceId, sentry->servicePort, + sentry->serviceName, sentry->socket); + len += sprintf(buffer + len, + "\t\tnSecObj=%d, nReqRunning=%d, maxProcs=%d, minProcs=%d, connDeadTime=%d, idleDeadTime=%d\n", + sentry->nSecurityObjects, sentry->nRequestsRunning, + sentry->maxProcs, sentry->minProcs, + sentry->connDeadTime, sentry->idleDeadTime); + } + } + + if (offset >= len) { + *start = buffer; + *eof = 1; + return 0; + } + *start = buffer + offset; + if ((len -= offset) > count) + return count; + *eof = 1; + return len; +} + +int +callproc_read(char *buffer, char **start, off_t offset, int count, + int *eof, void *data) +{ + int len, i, j, k; + struct rx_connection *sep; + void *ret = NULL; + char tbuffer[16]; + afs_uint32 addr; + + len = 0; + for (i = 0, j = 0; i < 256; i++) { + for (sep = rx_connHashTable[i]; sep; sep = sep->next) { + for (k = 0; k < RX_MAXCALLS; k++) { + struct rx_call *call = sep->call[k]; + if (call) { + j++; + len += sprintf(buffer + len, + "%lx: conn=0x%lx, qiheader(0x%lx:0x%lx), tq(0x%lx:0x%lx), rq(0x%lx:0x%lx)\n", + call, call->conn, call->queue_item_header.prev, + call->queue_item_header.next, call->tq.prev, + call->tq.next, call->rq.prev, call->rq.next); + len += sprintf(buffer + len, + "\t: curvec=%d, curpos=%d, nLeft=%d, nFree=%d, currPacket=0x%lx, callNumber=0x%x\n", + call->curvec, call->curpos, call->nLeft, + call->nFree, call->currentPacket, + call->callNumber); + len += sprintf(buffer + len, + "\t: channel=%d, state=0x%x, mode=0x%x, flags=0x%x, localStatus=0x%x, remStatus=0x%x\n", + call->channel, call->state, call->mode, + call->flags, call->localStatus, + call->remoteStatus); + len += sprintf(buffer + len, + "\t: error=%d, timeout=0x%x, rnext=0x%x, rprev=0x%x, rwind=0x%x, tfirst=0x%x, tnext=0x%x\n", + call->error, call->timeout, call->rnext, + call->rprev, call->rwind, call->tfirst, + call->tnext); + len += sprintf(buffer + len, + "\t: twind=%d, resendEvent=0x%lx, timeoutEvent=0x%lx, keepAliveEvent=0x%lx, delayedAckEvent=0x%lx\n", + call->twind, call->resendEvent, + call->timeoutEvent, call->keepAliveEvent, + call->delayedAckEvent); + len += sprintf(buffer + len, + "\t: lastSendTime=0x%x, lastReceiveTime=0x%x, lastAcked=0x%x, startTime=0x%x, startWait=0x%x\n", + call->lastSendTime, call->lastReceiveTime, + call->lastAcked, call->startTime, + call->startWait); + if (call->flags & RX_CALL_WAIT_PROC) + len += sprintf(buffer + len, + "\t******** Call in RX_CALL_WAIT_PROC state **********\n"); + if (call->flags & RX_CALL_WAIT_WINDOW_ALLOC) + len += sprintf(buffer + len, + "\t******** Call in RX_CALL_WAIT_WINDOW_ALLOC state **********\n"); + if (call->flags & RX_CALL_READER_WAIT) + len += sprintf(buffer + len, + "\t******** Conn in RX_CALL_READER_WAIT state **********\n"); + if (call->flags & RX_CALL_WAIT_PACKETS) + len += sprintf(buffer + len, + "\t******** Conn in RX_CALL_WAIT_PACKETS state **********\n"); +#ifdef RX_ENABLE_LOCKS + len += sprintf(buffer + len, + "\t: lock=0x%x, cv_twind=0x%x, cv_rq=0x%x, refCount= %d\n", + call->lock, call->cv_twind, call->cv_rq, + call->refCount); +#endif /* RX_ENABLE_LOCKS */ + len += sprintf(buffer + len, "\t: MTU=%d\n", call->MTU); + } + } + } + } + + if (offset >= len) { + *start = buffer; + *eof = 1; + return 0; + } + *start = buffer + offset; + if ((len -= offset) > count) + return count; + *eof = 1; + return len; +} + static struct proc_dir_entry *openafs_procfs; static int afsproc_init() { struct proc_dir_entry *entry1; - struct proc_dir_entry *entry2; + struct proc_dir_entry *entry; openafs_procfs = proc_mkdir(PROC_FSDIRNAME, proc_root_fs); entry1 = create_proc_entry(PROC_SYSCALL_NAME, 0666, openafs_procfs); @@ -193,7 +534,19 @@ afsproc_init() entry1->owner = THIS_MODULE; - entry2 = create_proc_read_entry(PROC_CELLSERVDB_NAME, (S_IFREG|S_IRUGO), openafs_procfs, csdbproc_read, NULL); + entry = create_proc_read_entry(PROC_CELLSERVDB_NAME, (S_IFREG|S_IRUGO), openafs_procfs, csdbproc_read, NULL); + + entry = create_proc_read_entry(PROC_PEER_NAME, (S_IFREG|S_IRUGO), openafs_procfs, peerproc_read, NULL); + + entry = create_proc_read_entry(PROC_CONN_NAME, (S_IFREG|S_IRUGO), openafs_procfs, connproc_read, NULL); + + entry = create_proc_read_entry(PROC_CALL_NAME, (S_IFREG|S_IRUGO), openafs_procfs, connproc_read, NULL); + + entry = create_proc_read_entry(PROC_RX_NAME, (S_IFREG|S_IRUGO), openafs_procfs, rxproc_read, NULL); + + entry = create_proc_read_entry(PROC_SERVICES_NAME, (S_IFREG|S_IRUGO), openafs_procfs, servicesproc_read, NULL); + + entry = create_proc_read_entry(PROC_RXSTATS_NAME, (S_IFREG|S_IRUGO), openafs_procfs, rxstatsproc_read, NULL); return 0; } @@ -201,6 +554,12 @@ afsproc_init() static void afsproc_exit() { + remove_proc_entry(PROC_RXSTATS_NAME, openafs_procfs); + remove_proc_entry(PROC_SERVICES_NAME, openafs_procfs); + remove_proc_entry(PROC_RX_NAME, openafs_procfs); + remove_proc_entry(PROC_CALL_NAME, openafs_procfs); + remove_proc_entry(PROC_CONN_NAME, openafs_procfs); + remove_proc_entry(PROC_PEER_NAME, openafs_procfs); remove_proc_entry(PROC_CELLSERVDB_NAME, openafs_procfs); remove_proc_entry(PROC_SYSCALL_NAME, openafs_procfs); remove_proc_entry(PROC_FSDIRNAME, proc_root_fs); diff --git a/src/config/afs_args.h b/src/config/afs_args.h index e28eae5ff..cd86d43ca 100644 --- a/src/config/afs_args.h +++ b/src/config/afs_args.h @@ -181,6 +181,12 @@ typedef struct cm_initparams_v1 { #define PROC_SYSCALL_FNAME "/proc/fs/openafs/afs_ioctl" #define PROC_SYSCALL_ARLA_FNAME "/proc/fs/nnpfs/afs_ioctl" #define PROC_CELLSERVDB_NAME "CellServDB" +#define PROC_PEER_NAME "rx_peer" +#define PROC_CONN_NAME "rx_conn" +#define PROC_CALL_NAME "rx_call" +#define PROC_RX_NAME "rx" +#define PROC_SERVICES_NAME "rx_services" +#define PROC_RXSTATS_NAME "rx_stats" #define VIOC_SYSCALL_TYPE 'C' #define VIOC_SYSCALL _IOW(VIOC_SYSCALL_TYPE,1,void *) diff --git a/src/rx/rx_prototypes.h b/src/rx/rx_prototypes.h index 6d57e165e..85164313a 100644 --- a/src/rx/rx_prototypes.h +++ b/src/rx/rx_prototypes.h @@ -273,6 +273,8 @@ extern void rx_ReleaseCachedConnection(struct rx_connection *conn); /* rx_event.c */ +extern int rxevent_nFree; +extern int rxevent_nPosted; #if 0 extern struct rxevent *rxevent_Post(struct clock *when, void (*func) (struct rxevent * event,