Rx: Remove conn_call_lock contention between rx_NewCall and rx_EndCall
[openafs.git] / src / rxdebug / rxdebug.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13
14 #include <sys/types.h>
15 #include <errno.h>
16 #ifdef AFS_NT40_ENV
17 #include <winsock2.h>
18 #else
19 #include <sys/socket.h>
20 #include <sys/file.h>
21 #include <netdb.h>
22 #include <arpa/inet.h>
23 #endif
24 #ifdef HAVE_NETINET_IN_H
25 #include <netinet/in.h>
26 #endif
27 #ifdef HAVE_SYS_TIME_H
28 #include <sys/time.h>
29 #endif
30 #ifdef HAVE_UNISTD_H
31 #include <unistd.h>
32 #endif
33 #include <string.h>
34 #include <sys/stat.h>
35 #include <afs/afsutil.h>
36 #include <afs/stds.h>
37 #include <afs/cmd.h>
38
39 #include <stdio.h>
40
41 #include <rx/rx_user.h>
42 #include <rx/rx_clock.h>
43 #include <rx/rx_queue.h>
44 #include <rx/rx.h>
45 #include <rx/rx_globals.h>
46
47
48 #define TIMEOUT     20
49
50 static short
51 PortNumber(char *aport)
52 {
53     register int tc;
54     register short total;
55
56     total = 0;
57     while ((tc = *aport++)) {
58         if (tc < '0' || tc > '9')
59             return -1;          /* bad port number */
60         total *= 10;
61         total += tc - (int)'0';
62     }
63     return htons(total);
64 }
65
66 static short
67 PortName(char *aname)
68 {
69     register struct servent *ts;
70     ts = getservbyname(aname, NULL);
71     if (!ts)
72         return -1;
73     return ts->s_port;          /* returns it in network byte order */
74 }
75
76 int
77 MainCommand(struct cmd_syndesc *as, void *arock)
78 {
79     register int i;
80     osi_socket s;
81     int j;
82     struct sockaddr_in taddr;
83     afs_int32 host;
84     struct in_addr hostAddr;
85     short port;
86     struct hostent *th;
87     register afs_int32 code;
88     int nodally;
89     int allconns;
90     int rxstats;
91     int onlyClient, onlyServer;
92     afs_int32 onlyHost;
93     short onlyPort;
94     int onlyAuth;
95     int flag;
96     int dallyCounter;
97     int withSecStats;
98     int withAllConn;
99     int withRxStats;
100     int withWaiters;
101     int withIdleThreads;
102     int withWaited;
103     int withPeers;
104     int withPackets;
105     struct rx_debugStats tstats;
106     char *portName, *hostName;
107     char hoststr[20];
108     struct rx_debugConn tconn;
109     short noConns;
110     short showPeers;
111     short showLong;
112     int version_flag;
113     char version[64];
114     afs_int32 length = 64;
115
116     afs_uint32 supportedDebugValues = 0;
117     afs_uint32 supportedStatValues = 0;
118     afs_uint32 supportedConnValues = 0;
119     afs_uint32 supportedPeerValues = 0;
120     afs_int32 nextconn = 0;
121     afs_int32 nextpeer = 0;
122
123     nodally = (as->parms[2].items ? 1 : 0);
124     allconns = (as->parms[3].items ? 1 : 0);
125     rxstats = (as->parms[4].items ? 1 : 0);
126     onlyServer = (as->parms[5].items ? 1 : 0);
127     onlyClient = (as->parms[6].items ? 1 : 0);
128     version_flag = (as->parms[10].items ? 1 : 0);
129     noConns = (as->parms[11].items ? 1 : 0);
130     showPeers = (as->parms[12].items ? 1 : 0);
131     showLong = (as->parms[13].items ? 1 : 0);
132
133     if (as->parms[0].items)
134         hostName = as->parms[0].items->data;
135     else
136         hostName = NULL;
137
138     if (as->parms[1].items)
139         portName = as->parms[1].items->data;
140     else
141         portName = NULL;
142
143     if (as->parms[7].items) {
144         char *name = as->parms[7].items->data;
145         if ((onlyPort = PortNumber(name)) == -1)
146             onlyPort = PortName(name);
147         if (onlyPort == -1) {
148             printf("rxdebug: can't resolve port name %s\n", name);
149             exit(1);
150         }
151     } else
152         onlyPort = -1;
153
154     if (as->parms[8].items) {
155         char *name = as->parms[8].items->data;
156         struct hostent *th;
157         th = hostutil_GetHostByName(name);
158         if (!th) {
159             printf("rxdebug: host %s not found in host table\n", name);
160             exit(1);
161         }
162         memcpy(&onlyHost, th->h_addr, sizeof(afs_int32));
163     } else
164         onlyHost = -1;
165
166     if (as->parms[9].items) {
167         char *name = as->parms[9].items->data;
168         if (strcmp(name, "clear") == 0)
169             onlyAuth = 0;
170         else if (strcmp(name, "auth") == 0)
171             onlyAuth = 1;
172         else if (strcmp(name, "crypt") == 0)
173             onlyAuth = 2;
174         else if ((strcmp(name, "null") == 0) || (strcmp(name, "none") == 0)
175                  || (strncmp(name, "noauth", 6) == 0)
176                  || (strncmp(name, "unauth", 6) == 0))
177             onlyAuth = -1;
178         else {
179             fprintf(stderr, "Unknown authentication level: %s\n", name);
180             exit(1);
181         }
182     } else
183         onlyAuth = 999;
184
185     /* lookup host */
186     if (hostName) {
187         th = hostutil_GetHostByName(hostName);
188         if (!th) {
189             printf("rxdebug: host %s not found in host table\n", hostName);
190             exit(1);
191         }
192         memcpy(&host, th->h_addr, sizeof(afs_int32));
193     } else
194         host = htonl(0x7f000001);       /* IP localhost */
195
196     if (!portName)
197         port = htons(7000);     /* default is fileserver */
198     else {
199         if ((port = PortNumber(portName)) == -1)
200             port = PortName(portName);
201         if (port == -1) {
202             printf("rxdebug: can't resolve port name %s\n", portName);
203             exit(1);
204         }
205     }
206
207     dallyCounter = 0;
208
209     hostAddr.s_addr = host;
210     afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
211     printf("Trying %s (port %d):\n", hoststr, ntohs(port));
212     s = socket(AF_INET, SOCK_DGRAM, 0);
213     taddr.sin_family = AF_INET;
214     taddr.sin_port = 0;
215     taddr.sin_addr.s_addr = 0;
216 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
217     taddr.sin_len = sizeof(struct sockaddr_in);
218 #endif
219     code = bind(s, (struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
220     if (code) {
221         perror("bind");
222         exit(1);
223     }
224
225     if (version_flag) {
226
227         code = rx_GetServerVersion(s, host, port, length, version);
228         if (code < 0) {
229             printf("get version call failed with code %d, errno %d\n", code,
230                    errno);
231             exit(1);
232         }
233         printf("AFS version: %s\n", version);
234         fflush(stdout);
235
236         exit(0);
237
238     }
239
240
241     code = rx_GetServerDebug(s, host, port, &tstats, &supportedDebugValues);
242     if (code < 0) {
243         printf("getstats call failed with code %d\n", code);
244         exit(1);
245     }
246
247     withSecStats = (supportedDebugValues & RX_SERVER_DEBUG_SEC_STATS);
248     withAllConn = (supportedDebugValues & RX_SERVER_DEBUG_ALL_CONN);
249     withRxStats = (supportedDebugValues & RX_SERVER_DEBUG_RX_STATS);
250     withWaiters = (supportedDebugValues & RX_SERVER_DEBUG_WAITER_CNT);
251     withIdleThreads = (supportedDebugValues & RX_SERVER_DEBUG_IDLE_THREADS);
252     withWaited = (supportedDebugValues & RX_SERVER_DEBUG_WAITED_CNT);
253     withPeers = (supportedDebugValues & RX_SERVER_DEBUG_ALL_PEER);
254     withPackets = (supportedDebugValues & RX_SERVER_DEBUG_PACKETS_CNT);
255
256     if (withPackets)
257         printf("Free packets: %d/%d, packet reclaims: %d, calls: %d, used FDs: %d\n",
258                tstats.nFreePackets, tstats.nPackets, tstats.packetReclaims, 
259                tstats.callsExecuted, tstats.usedFDs);
260     else
261         printf("Free packets: %d, packet reclaims: %d, calls: %d, used FDs: %d\n",
262                tstats.nFreePackets, tstats.packetReclaims, tstats.callsExecuted,
263                tstats.usedFDs);
264     if (!tstats.waitingForPackets)
265         printf("not ");
266     printf("waiting for packets.\n");
267     if (withWaiters)
268         printf("%d calls waiting for a thread\n", tstats.nWaiting);
269     if (withIdleThreads)
270         printf("%d threads are idle\n", tstats.idleThreads);
271     if (withWaited)
272         printf("%d calls have waited for a thread\n", tstats.nWaited);
273
274     if (rxstats) {
275         if (!withRxStats) {
276           noRxStats:
277             withRxStats = 0;
278             fprintf(stderr,
279                     "WARNING: Server doesn't support retrieval of Rx statistics\n");
280         } else {
281             union {
282                 struct rx_statistics rxstats;
283                 struct rx_debugIn debug;
284             } packet;
285
286             /* should gracefully handle the case where rx_stats grows */
287             code =
288                 rx_GetServerStats(s, host, port, &packet.rxstats,
289                                   &supportedStatValues);
290             if (code < 0) {
291                 printf("rxstats call failed with code %d\n", code);
292                 exit(1);
293             }
294             if (code != sizeof(packet.rxstats)) {
295                 if (packet.debug.type == RX_DEBUGI_BADTYPE)
296                     goto noRxStats;
297                 printf
298                     ("WARNING: returned Rx statistics of unexpected size (got %d)\n",
299                      code);
300                 /* handle other versions?... */
301             }
302
303             rx_PrintTheseStats(stdout, &packet.rxstats, sizeof(packet.rxstats),
304                                tstats.nFreePackets, tstats.version);
305         }
306     }
307
308     if (!noConns) {
309         if (allconns) {
310             if (!withAllConn)
311                 fprintf(stderr,
312                         "WARNING: Server doesn't support retrieval of all connections,\n         getting only interesting instead.\n");
313         }
314
315         if (onlyServer)
316             printf("Showing only server connections\n");
317         if (onlyClient)
318             printf("Showing only client connections\n");
319         if (onlyAuth != 999) {
320             static char *name[] =
321                 { "unauthenticated", "rxkad_clear", "rxkad_auth",
322                 "rxkad_crypt"
323             };
324             printf("Showing only %s connections\n", name[onlyAuth + 1]);
325         }
326         if (onlyHost != -1) {
327             hostAddr.s_addr = onlyHost;
328             afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
329             printf("Showing only connections from host %s\n",
330                    hoststr);
331         }
332         if (onlyPort != -1)
333             printf("Showing only connections on port %u\n", ntohs(onlyPort));
334
335         for (i = 0;; i++) {
336             code =
337                 rx_GetServerConnections(s, host, port, &nextconn, allconns,
338                                         supportedDebugValues, &tconn,
339                                         &supportedConnValues);
340             if (code < 0) {
341                 printf("getconn call failed with code %d\n", code);
342                 break;
343             }
344             if (tconn.cid == (afs_int32) 0xffffffff) {
345                 printf("Done.\n");
346                 break;
347             }
348
349             /* see if we're in nodally mode and all calls are dallying */
350             if (nodally) {
351                 flag = 0;
352                 for (j = 0; j < RX_MAXCALLS; j++) {
353                     if (tconn.callState[j] != RX_STATE_NOTINIT
354                         && tconn.callState[j] != RX_STATE_DALLY) {
355                         flag = 1;
356                         break;
357                     }
358                 }
359                 if (flag == 0) {
360                     /* this call looks too ordinary, bump skipped count and go
361                      * around again */
362                     dallyCounter++;
363                     continue;
364                 }
365             }
366             if ((onlyHost != -1) && (onlyHost != tconn.host))
367                 continue;
368             if ((onlyPort != -1) && (onlyPort != tconn.port))
369                 continue;
370             if (onlyServer && (tconn.type != RX_SERVER_CONNECTION))
371                 continue;
372             if (onlyClient && (tconn.type != RX_CLIENT_CONNECTION))
373                 continue;
374             if (onlyAuth != 999) {
375                 if (onlyAuth == -1) {
376                     if (tconn.securityIndex != 0)
377                         continue;
378                 } else {
379                     if (tconn.securityIndex != 2)
380                         continue;
381                     if (withSecStats && (tconn.secStats.type == 3)
382                         && (tconn.secStats.level != onlyAuth))
383                         continue;
384                 }
385             }
386
387             /* now display the connection */
388             hostAddr.s_addr = tconn.host;
389             afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
390             printf("Connection from host %s, port %hu, ", hoststr,
391                    ntohs(tconn.port));
392             if (tconn.epoch)
393                 printf("Cuid %x/%x", tconn.epoch, tconn.cid);
394             else
395                 printf("cid %x", tconn.cid);
396             if (tconn.error)
397                 printf(", error %d", tconn.error);
398             printf("\n  serial %d, ", tconn.serial);
399             printf(" natMTU %d, ", tconn.natMTU);
400
401             if (tconn.flags) {
402                 printf("flags");
403                 if (tconn.flags & RX_CONN_MAKECALL_WAITING)
404                     printf(" MAKECALL_WAITING");
405                 if (tconn.flags & RX_CONN_DESTROY_ME)
406                     printf(" DESTROYED");
407                 if (tconn.flags & RX_CONN_USING_PACKET_CKSUM)
408                     printf(" pktCksum");
409                 if (tconn.flags & RX_CONN_KNOW_WINDOW)
410                     printf(" knowWindow");
411                 if (tconn.flags & RX_CONN_RESET)
412                     printf(" reset");
413                 if (tconn.flags & RX_CONN_BUSY)
414                     printf(" busy");
415                 if (tconn.flags & RX_CONN_ATTACHWAIT)
416                     printf(" attachWait");
417                 printf(", ");
418             }
419             printf("security index %d, ", tconn.securityIndex);
420             if (tconn.type == RX_CLIENT_CONNECTION)
421                 printf("client conn\n");
422             else
423                 printf("server conn\n");
424
425             if (withSecStats) {
426                 switch ((int)tconn.secStats.type) {
427                 case 0:
428                     if (tconn.securityIndex == 2)
429                         printf
430                             ("  no GetStats procedure for security object\n");
431                     break;
432                 case 1:
433                     printf("  rxnull level=%d, flags=%d\n",
434                            tconn.secStats.level, tconn.secStats.flags);
435                     break;
436                 case 2:
437                     printf("  rxvab level=%d, flags=%d\n",
438                            tconn.secStats.level, tconn.secStats.flags);
439                     break;
440                 case 3:{
441                         char *level;
442                         char flags = tconn.secStats.flags;
443                         if (tconn.secStats.level == 0)
444                             level = "clear";
445                         else if (tconn.secStats.level == 1)
446                             level = "auth";
447                         else if (tconn.secStats.level == 2)
448                             level = "crypt";
449                         else
450                             level = "unknown";
451                         printf("  rxkad: level %s", level);
452                         if (flags)
453                             printf(", flags");
454                         if (flags & 1)
455                             printf(" unalloc");
456                         if (flags & 2)
457                             printf(" authenticated");
458                         if (flags & 4)
459                             printf(" expired");
460                         if (flags & 8)
461                             printf(" pktCksum");
462                         if (tconn.secStats.expires)
463                             /* Apparently due to a bug in the RT compiler that
464                              * prevents (afs_uint32)0xffffffff => (double) from working,
465                              * this code produces negative lifetimes when run on the
466                              * RT. */
467                             printf(", expires in %.1f hours",
468                                    ((afs_uint32) tconn.secStats.expires -
469                                     time(0)) / 3600.0);
470                         if (!(flags & 1)) {
471                             printf("\n  Received %u bytes in %u packets\n",
472                                    tconn.secStats.bytesReceived,
473                                    tconn.secStats.packetsReceived);
474                             printf("  Sent %u bytes in %u packets\n",
475                                    tconn.secStats.bytesSent,
476                                    tconn.secStats.packetsSent);
477                         } else
478                             printf("\n");
479                         break;
480                     }
481
482                 default:
483                     printf("  unknown\n");
484                 }
485             }
486
487             for (j = 0; j < RX_MAXCALLS; j++) {
488                 printf("    call %d: # %d, state ", j, tconn.callNumber[j]);
489                 if (tconn.callState[j] == RX_STATE_NOTINIT) {
490                     printf("not initialized\n");
491                     continue;
492                 } else if (tconn.callState[j] == RX_STATE_PRECALL)
493                     printf("precall, ");
494                 else if (tconn.callState[j] == RX_STATE_ACTIVE)
495                     printf("active, ");
496                 else if (tconn.callState[j] == RX_STATE_DALLY)
497                     printf("dally, ");
498                 else if (tconn.callState[j] == RX_STATE_HOLD)
499                     printf("hold, ");
500                 else if (tconn.callState[j] == RX_STATE_RESET)
501                     printf("reset, ");
502                 printf("mode: ");
503                 if (tconn.callMode[j] == RX_MODE_SENDING)
504                     printf("sending");
505                 else if (tconn.callMode[j] == RX_MODE_RECEIVING)
506                     printf("receiving");
507                 else if (tconn.callMode[j] == RX_MODE_ERROR)
508                     printf("error");
509                 else if (tconn.callMode[j] == RX_MODE_EOF)
510                     printf("eof");
511                 else
512                     printf("unknown");
513                 if (tconn.callFlags[j]) {
514                     printf(", flags:");
515                     if (tconn.callFlags[j] & RX_CALL_READER_WAIT)
516                         printf(" reader_wait");
517                     if (tconn.callFlags[j] & RX_CALL_WAIT_WINDOW_ALLOC)
518                         printf(" window_alloc");
519                     if (tconn.callFlags[j] & RX_CALL_WAIT_WINDOW_SEND)
520                         printf(" window_send");
521                     if (tconn.callFlags[j] & RX_CALL_WAIT_PACKETS)
522                         printf(" wait_packets");
523                     if (tconn.callFlags[j] & RX_CALL_WAIT_PROC)
524                         printf(" waiting_for_process");
525                     if (tconn.callFlags[j] & RX_CALL_RECEIVE_DONE)
526                         printf(" receive_done");
527                     if (tconn.callFlags[j] & RX_CALL_CLEARED)
528                         printf(" call_cleared");
529                 }
530                 if (tconn.callOther[j] & RX_OTHER_IN)
531                     printf(", has_input_packets");
532                 if (tconn.callOther[j] & RX_OTHER_OUT)
533                     printf(", has_output_packets");
534                 printf("\n");
535             }
536         }
537         if (nodally)
538             printf("Skipped %d dallying connections.\n", dallyCounter);
539     }
540     if (showPeers && withPeers) {
541         for (i = 0;; i++) {
542             struct rx_debugPeer tpeer;
543             code =
544                 rx_GetServerPeers(s, host, port, &nextpeer, allconns, &tpeer,
545                                   &supportedPeerValues);
546             if (code < 0) {
547                 printf("getpeer call failed with code %d\n", code);
548                 break;
549             }
550             if (tpeer.host == 0xffffffff) {
551                 printf("Done.\n");
552                 break;
553             }
554
555             if ((onlyHost != -1) && (onlyHost != tpeer.host))
556                 continue;
557             if ((onlyPort != -1) && (onlyPort != tpeer.port))
558                 continue;
559
560             /* now display the peer */
561             hostAddr.s_addr = tpeer.host;
562             afs_inet_ntoa_r(hostAddr.s_addr, hoststr);
563             printf("Peer at host %s, port %hu\n", hoststr, 
564                    ntohs(tpeer.port));
565             printf("\tifMTU %hu\tnatMTU %hu\tmaxMTU %hu\n", tpeer.ifMTU,
566                    tpeer.natMTU, tpeer.maxMTU);
567             printf("\tpackets sent %u\tpacket resends %u\n", tpeer.nSent,
568                    tpeer.reSends);
569             printf("\tbytes sent high %u low %u\n", tpeer.bytesSent.high,
570                    tpeer.bytesSent.low);
571             printf("\tbytes received high %u low %u\n",
572                    tpeer.bytesReceived.high, tpeer.bytesReceived.low);
573             printf("\trtt %u msec, rtt_dev %u msec\n", tpeer.rtt >> 3,
574                    tpeer.rtt_dev >> 2);
575             printf("\ttimeout %u.%03u sec\n", tpeer.timeout.sec,
576                    tpeer.timeout.usec / 1000);
577             if (!showLong)
578                 continue;
579
580             printf("\tin/out packet skew: %d/%d\n", tpeer.inPacketSkew,
581                     tpeer.outPacketSkew);
582             printf("\tcongestion window %d, MTU %d\n", tpeer.cwind,
583                    tpeer.MTU);
584             printf("\tcurrent/if/max jumbogram size: %d/%d/%d\n",
585                    tpeer.nDgramPackets, tpeer.ifDgramPackets,
586                    tpeer.maxDgramPackets);
587         }
588     }
589     exit(0);
590 }
591
592 /* simple main program */
593 #ifndef AFS_NT40_ENV
594 #include "AFS_component_version_number.c"
595 #endif
596 int
597 main(int argc, char **argv)
598 {
599     struct cmd_syndesc *ts;
600
601 #ifdef RXDEBUG
602     rxi_DebugInit();
603 #endif
604 #ifdef AFS_NT40_ENV
605     if (afs_winsockInit() < 0) {
606         printf("%s: Couldn't initialize winsock. Exiting...\n", argv[0]);
607         return 1;
608     }
609 #endif
610
611     ts = cmd_CreateSyntax(NULL, MainCommand, NULL, "probe RX server");
612     cmd_AddParm(ts, "-servers", CMD_SINGLE, CMD_REQUIRED, "server machine");
613     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
614     cmd_AddParm(ts, "-nodally", CMD_FLAG, CMD_OPTIONAL,
615                 "don't show dallying conns");
616     cmd_AddParm(ts, "-allconnections", CMD_FLAG, CMD_OPTIONAL,
617                 "don't filter out uninteresting connections on server");
618     cmd_AddParm(ts, "-rxstats", CMD_FLAG, CMD_OPTIONAL, "show Rx statistics");
619     cmd_AddParm(ts, "-onlyserver", CMD_FLAG, CMD_OPTIONAL,
620                 "only show server conns");
621     cmd_AddParm(ts, "-onlyclient", CMD_FLAG, CMD_OPTIONAL,
622                 "only show client conns");
623     cmd_AddParm(ts, "-onlyport", CMD_SINGLE, CMD_OPTIONAL,
624                 "show only <port>");
625     cmd_AddParm(ts, "-onlyhost", CMD_SINGLE, CMD_OPTIONAL,
626                 "show only <host>");
627     cmd_AddParm(ts, "-onlyauth", CMD_SINGLE, CMD_OPTIONAL,
628                 "show only <auth level>");
629
630     cmd_AddParm(ts, "-version", CMD_FLAG, CMD_OPTIONAL,
631                 "show AFS version id");
632     cmd_AddParm(ts, "-noconns", CMD_FLAG, CMD_OPTIONAL,
633                 "show no connections");
634     cmd_AddParm(ts, "-peers", CMD_FLAG, CMD_OPTIONAL, "show peers");
635     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "detailed output");
636
637     cmd_Dispatch(argc, argv);
638     exit(0);
639 }