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 c999d91f2f681f4b3b429816c4913cc1aecd4241..35624d101f67856b33e7a2eb643edf860592a025 100644 (file)
--- 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 e28eae5ffb507e64feb4ce06aa0932fdf9f9706f..cd86d43ca15e7707964d539262f95fb5042b6630 100644 (file)
--- 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 6d57e165ef07882ce3a54db9190d79b2892fc4ee..85164313a9e9a0d0b014ac032366d6a70ab6dfe5 100644 (file)
--- 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,