cmdebug-getce64-support-20030304
[openafs.git] / src / venus / cmdebug.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 RCSID("$Header$");
14
15
16 #include <sys/types.h>
17 #include <netinet/in.h>
18 #include <sys/socket.h>
19 #include <netdb.h>
20 #include <stdio.h>
21 #ifdef HAVE_STRING_H
22 #include <string.h>
23 #else
24 #ifdef HAVE_STRINGS_H
25 #include <strings.h>
26 #endif
27 #endif
28 #ifdef  AFS_AIX32_ENV
29 #include <signal.h>
30 #endif
31 #include <afs/afscbint.h>
32 #include <afs/cmd.h>
33 #include <rx/rx.h>
34 #include <lock.h>
35 #include <afs/afs_args.h>
36
37 extern struct hostent *hostutil_GetHostByName();
38
39 static PrintCacheConfig(aconn)
40     struct rx_connection *aconn;
41 {
42     struct cacheConfig c;
43     afs_uint32 srv_ver, conflen;
44     int code;
45
46     c.cacheConfig_len = 0;
47     c.cacheConfig_val = NULL;
48     code = RXAFSCB_GetCacheConfig(aconn, 1, &srv_ver, &conflen, &c);
49     if (code) {
50         printf("cmdebug: error checking cache config: %s\n",
51                error_message(code));
52         return 0;
53     }
54
55     if (srv_ver == AFS_CLIENT_RETRIEVAL_FIRST_EDITION) {
56         struct cm_initparams_v1 *c1;
57
58         if (c.cacheConfig_len != sizeof(*c1) / sizeof(afs_uint32)) {
59             printf("cmdebug: configuration data size mismatch (%d != %d)\n",
60                    c.cacheConfig_len, sizeof(*c1) / sizeof(afs_uint32));
61             return 0;
62         }
63
64         c1 = (struct cm_initparams_v1 *) c.cacheConfig_val;
65         printf("Chunk files:   %d\n", c1->nChunkFiles);
66         printf("Stat caches:   %d\n", c1->nStatCaches);
67         printf("Data caches:   %d\n", c1->nDataCaches);
68         printf("Volume caches: %d\n", c1->nVolumeCaches);
69         printf("Chunk size:    %d", c1->otherChunkSize);
70         if (c1->firstChunkSize != c1->otherChunkSize)
71             printf(" (first: %d)", c1->firstChunkSize);
72         printf("\n");
73         printf("Cache size:    %d kB\n", c1->cacheSize);
74         printf("Set time:      %s\n", c1->setTime ? "yes" : "no");
75         printf("Cache type:    %s\n", c1->memCache ? "memory" : "disk");
76     } else {
77         printf("cmdebug: unsupported server version %d\n", srv_ver);
78     }
79 }
80
81 static PrintInterfaces(aconn)
82     struct rx_connection *aconn;
83 {
84     struct interfaceAddr addr;
85     int i, code;
86
87     code = RXAFSCB_WhoAreYou(aconn, &addr);
88     if (code) {
89         printf("cmdebug: error checking interfaces: %s\n", error_message(code));
90         return 0;
91     }
92
93     printf("Host interfaces:\n");
94     for (i=0; i<addr.numberOfInterfaces; i++) {
95         printf("%s", afs_inet_ntoa(htonl(addr.addr_in[i])));
96         if (addr.subnetmask[i])
97             printf(", netmask %s", afs_inet_ntoa(htonl(addr.subnetmask[i])));
98         if (addr.mtu[i])
99             printf(", MTU %d", addr.mtu[i]);
100         printf("\n");
101     }
102
103     return 0;
104 }
105
106 static IsLocked(alock)
107 register struct AFSDBLockDesc *alock; {
108     if (alock->waitStates || alock->exclLocked
109         || alock->numWaiting || alock->readersReading)
110         return 1;
111     return 0;
112 }
113
114 static PrintLock(alock)
115 register struct AFSDBLockDesc *alock; {
116     printf("(");
117     if (alock->waitStates) {
118         if (alock->waitStates & READ_LOCK)
119             printf("reader_waiting");
120         if (alock->waitStates & WRITE_LOCK)
121             printf("writer_waiting");
122         if (alock->waitStates & SHARED_LOCK)
123             printf("upgrade_waiting");
124     }
125     else
126         printf("none_waiting");
127     if (alock->exclLocked) {
128         if (alock->exclLocked & WRITE_LOCK)
129             printf(", write_locked");
130         if (alock->exclLocked & SHARED_LOCK)
131             printf(", upgrade_locked");
132         printf("(pid:%d at:%d)", alock->pid_writer, alock->src_indicator);
133     }
134     if (alock->readersReading)
135         printf(", %d read_locks(pid:%d)", alock->readersReading,alock->pid_last_reader);
136     if (alock->numWaiting) printf(", %d waiters", alock->numWaiting);
137     printf(")");
138     return 0;
139 }
140
141 static PrintLocks(aconn, aint32)
142 int aint32;
143 register struct rx_connection *aconn; {
144     register int i;
145     struct AFSDBLock lock;
146     afs_int32 code;
147
148     for(i=0;i<1000;i++) {
149         code = RXAFSCB_GetLock(aconn, i, &lock);
150         if (code) {
151             if (code == 1) break;
152             /* otherwise we have an unrecognized error */
153             printf("cmdebug: error checking locks: %s\n", error_message(code));
154             return code;
155         }
156         /* here we have the lock information, so display it, perhaps */
157         if (aint32 || IsLocked(&lock.lock)) {
158             printf("Lock %s status: ", lock.name);
159             PrintLock(&lock.lock);
160             printf("\n");
161         }
162     }
163     return 0;
164 }
165
166 struct cell_cache {
167     afs_int32 cellnum;
168     char *cellname;
169     struct cell_cache *next;
170 };
171
172 static char *GetCellName(struct rx_connection *aconn, afs_int32 cellnum)
173 {
174     static int no_getcellbynum;
175     static struct cell_cache *cache;
176     struct cell_cache *tcp;
177     int code;
178     char *cellname;
179     serverList sl;
180
181     if (no_getcellbynum)
182         return NULL;
183
184     for (tcp = cache; tcp; tcp = tcp->next)
185         if (tcp->cellnum == cellnum)
186             return tcp->cellname;
187
188     cellname = NULL;
189     sl.serverList_len = 0;
190     sl.serverList_val = NULL;
191     code = RXAFSCB_GetCellByNum(aconn, cellnum, &cellname, &sl);
192     if (code) {
193         if (code == RXGEN_OPCODE)
194             no_getcellbynum = 1;
195         return NULL;
196     }
197
198     if (sl.serverList_val)
199         free (sl.serverList_val);
200     tcp = malloc(sizeof(struct cell_cache));
201     tcp->next = cache;
202     tcp->cellnum = cellnum;
203     tcp->cellname = cellname;
204     cache = tcp;
205
206     return cellname;
207 }
208
209 static int PrintCacheEntries32(struct rx_connection *aconn, int aint32)
210 {
211     register int i;
212     register afs_int32 code;
213     struct AFSDBCacheEntry centry;
214     char *cellname;
215     
216     for(i=0;i<10000;i++) {
217         code = RXAFSCB_GetCE(aconn, i, &centry);
218         if (code) {
219             if (code == 1) break;
220             printf("cmdebug: failed to get cache entry %d (%s)\n", i,
221                    error_message(code));
222             return code;
223         }
224
225         if (centry.addr == 0) {
226             /* PS output */
227             printf("Proc %4d sleeping at %08x, pri %3d\n",
228                    centry.netFid.Vnode, centry.netFid.Volume, centry.netFid.Unique-25);
229             continue;
230         }
231
232         if (!aint32 && !IsLocked(&centry.lock)) continue;
233
234         /* otherwise print this entry */
235         printf("** Cache entry @ 0x%08x for %d.%d.%d.%d", centry.addr,
236                centry.cell, centry.netFid.Volume, centry.netFid.Vnode,
237                centry.netFid.Unique);
238
239         cellname = GetCellName(aconn, centry.cell);
240         if (cellname)
241             printf(" [%s]\n", cellname);
242         else
243             printf("\n");
244
245         if (IsLocked(&centry.lock)) {
246             printf("    locks: ");
247             PrintLock(&centry.lock);
248             printf("\n");
249         }
250         printf("    %d bytes\tDV %d refcnt %d\n", centry.Length, centry.DataVersion, centry.refCount);
251         printf("    callback %08x\texpires %u\n", centry.callback, centry.cbExpires);
252         printf("    %d opens\t%d writers\n", centry.opens, centry.writers);
253
254         /* now display states */
255         printf("    ");
256         if (centry.mvstat == 0) printf("normal file");
257         else if (centry.mvstat == 1) printf("mount point");
258         else if (centry.mvstat == 2) printf("volume root");
259         else printf("bogus mvstat %d", centry.mvstat);
260         printf("\n    states (0x%x)", centry.states);
261         if (centry.states & 1) printf(", stat'd");
262         if (centry.states & 2) printf(", backup");
263         if (centry.states & 4) printf(", read-only");
264         if (centry.states & 8) printf(", mt pt valid");
265         if (centry.states & 0x10) printf(", pending core");
266         if (centry.states & 0x40) printf(", wait-for-store");
267         if (centry.states & 0x80) printf(", mapped");
268         printf("\n");
269     }
270     return 0;
271 }
272
273 static int PrintCacheEntries64(struct rx_connection *aconn, int aint32)
274 {
275     register int i;
276     register afs_int32 code;
277     struct AFSDBCacheEntry64 centry;
278     char *cellname;
279     int ce64 = 0;
280     
281     for(i=0;i<10000;i++) {
282         code = RXAFSCB_GetCE64(aconn, i, &centry);
283         if (code) {
284             if (code == 1) break;
285             printf("cmdebug: failed to get cache entry %d (%s)\n", i,
286                    error_message(code));
287             return code;
288         }
289
290         if (centry.addr == 0) {
291             /* PS output */
292             printf("Proc %4d sleeping at %08x, pri %3d\n",
293                    centry.netFid.Vnode, centry.netFid.Volume, centry.netFid.Unique-25);
294             continue;
295         }
296
297         if (!aint32 && !IsLocked(&centry.lock)) continue;
298
299         /* otherwise print this entry */
300         printf("** Cache entry @ 0x%08x for %d.%d.%d.%d", centry.addr,
301                centry.cell, centry.netFid.Volume, centry.netFid.Vnode,
302                centry.netFid.Unique);
303
304         cellname = GetCellName(aconn, centry.cell);
305         if (cellname)
306             printf(" [%s]\n", cellname);
307         else
308             printf("\n");
309
310         if (IsLocked(&centry.lock)) {
311             printf("    locks: ");
312             PrintLock(&centry.lock);
313             printf("\n");
314         }
315 #ifdef AFS_64BIT_ENV
316         printf("    %lld bytes\tDV %d refcnt %d\n", centry.Length, centry.DataVersion, centry.refCount);
317 #else
318         printf("    %d bytes\tDV %d refcnt %d\n", centry.Length, centry.DataVersion, centry.refCount);
319 #endif
320         printf("    callback %08x\texpires %u\n", centry.callback, centry.cbExpires);
321         printf("    %d opens\t%d writers\n", centry.opens, centry.writers);
322
323         /* now display states */
324         printf("    ");
325         if (centry.mvstat == 0) printf("normal file");
326         else if (centry.mvstat == 1) printf("mount point");
327         else if (centry.mvstat == 2) printf("volume root");
328         else printf("bogus mvstat %d", centry.mvstat);
329         printf("\n    states (0x%x)", centry.states);
330         if (centry.states & 1) printf(", stat'd");
331         if (centry.states & 2) printf(", backup");
332         if (centry.states & 4) printf(", read-only");
333         if (centry.states & 8) printf(", mt pt valid");
334         if (centry.states & 0x10) printf(", pending core");
335         if (centry.states & 0x40) printf(", wait-for-store");
336         if (centry.states & 0x80) printf(", mapped");
337         printf("\n");
338     }
339     return 0;
340 }
341
342 static int PrintCacheEntries(struct rx_connection *aconn, int aint32)
343 {
344     register afs_int32 code;
345     struct AFSDBCacheEntry64 centry64;
346     
347     code = RXAFSCB_GetCE64(aconn, 0, &centry64);
348     if (code != RXGEN_OPCODE) 
349         return PrintCacheEntries64(aconn, aint32);
350     else
351         return PrintCacheEntries32(aconn, aint32);
352 }
353
354 static CommandProc(as)
355 struct cmd_syndesc *as; {
356     struct rx_connection *conn;
357     register char *hostName;
358     register struct hostent *thp;
359     afs_int32 port;
360     struct rx_securityClass *secobj;
361     int int32p;
362     afs_int32 addr;
363
364     hostName = as->parms[0].items->data;
365     if (as->parms[1].items)
366         port = atoi(as->parms[1].items->data);
367     else
368         port = 7001;
369     thp = hostutil_GetHostByName(hostName);
370     if (!thp) {
371         printf("cmdebug: can't resolve address for host %s.\n", hostName);
372         exit(1);
373     }
374     memcpy(&addr, thp->h_addr, sizeof(afs_int32));
375     secobj = rxnull_NewServerSecurityObject();
376     conn = rx_NewConnection(addr, htons(port), 1, secobj, 0);
377     if (!conn) {
378         printf("cmdebug: failed to create connection for host %s\n", hostName);
379         exit(1);
380     }
381     if (as->parms[3].items) {
382         /* -addrs */
383         PrintInterfaces(conn);
384         return 0;
385     }
386     if (as->parms[4].items) {
387         /* -cache */
388         PrintCacheConfig(conn);
389         return 0;
390     }
391     if (as->parms[2].items) int32p = 1;
392     else int32p = 0;
393     PrintLocks(conn, int32p);
394     PrintCacheEntries(conn, int32p);
395     return 0;
396 }
397
398 #include "AFS_component_version_number.c"
399
400 main(argc, argv)
401 int argc;
402 char **argv; {
403     register struct cmd_syndesc *ts;
404
405 #ifdef  AFS_AIX32_ENV
406     /*
407      * The following signal action for AIX is necessary so that in case of a 
408      * crash (i.e. core is generated) we can include the user's data section 
409      * in the core dump. Unfortunately, by default, only a partial core is
410      * generated which, in many cases, isn't too useful.
411      */
412     struct sigaction nsa;
413     
414     sigemptyset(&nsa.sa_mask);
415     nsa.sa_handler = SIG_DFL;
416     nsa.sa_flags = SA_FULLDUMP;
417     sigaction(SIGSEGV, &nsa, NULL);
418 #endif
419     rx_Init(0);
420
421     ts = cmd_CreateSyntax(NULL, CommandProc, 0, "probe unik server");
422     cmd_AddParm(ts, "-servers", CMD_SINGLE, CMD_REQUIRED, "server machine");
423     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
424     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "print all info");
425     cmd_AddParm(ts, "-addrs", CMD_FLAG, CMD_OPTIONAL, "print only host interfaces");
426     cmd_AddParm(ts, "-cache", CMD_FLAG, CMD_OPTIONAL, "print only cache configuration");
427
428     cmd_Dispatch(argc, argv);
429     exit(0);
430 }