cmd: add flags argument to create syntax function
[openafs.git] / src / libadmin / test / client.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 /*
11  * This file implements the client related funtions for afscp
12  */
13
14 #include <afsconfig.h>
15 #include <afs/param.h>
16
17 #include <roken.h>
18
19 #include "client.h"
20 #include <afs/cellconfig.h>
21 #include <afs/bosint.h>
22 #include <rx/rxstat.h>
23 #include <afs/afsint.h>
24 #define FSINT_COMMON_XG
25 #include <afs/afscbint.h>
26 #include <afs/kauth.h>
27 #include <afs/kautils.h>
28 #include <afs/ptint.h>
29 #include <afs/ptserver.h>
30 #include <afs/vldbint.h>
31 #include <afs/volint.h>
32 #include <afs/volser.h>
33 #include <ubik.h>
34 #include <ubik_int.h>
35 #ifdef AFS_NT40_ENV
36 #include <pthread.h>
37 #endif
38
39 /*
40  * This structure stores the client and server function lists.
41  * This is kept separate from the actual interface definitions
42  * since an rpc interface can be offered by several servers
43  * (e.g. ubik and rxstat)
44  *
45  * The purpose of these functions is to allow a mapping from interfaceId
46  * to text representations of server process names and function names.
47  */
48
49 typedef struct {
50     const char **functionList;
51     size_t functionListLen;
52 } interface_function_list_t, *interface_function_list_p;
53
54 #ifdef AFS_NT40_ENV
55
56 /*
57  * On NT, you cannot define an array of character pointers in a dll
58  * and then access this array outside the dll via a global initialization
59  * because the msvc compiler will complain that the initializer is not
60  * a constant (i.e. C2099: initializer is not a constant).  This is because
61  * the dllimport and dllexport c language extensions cause references
62  * to the character array to go through another level of indirection -
63  * and this indirection is unknown at compilation time.
64  *
65  * To get around this problem I hand initialize this array on NT only
66  */
67
68 static interface_function_list_t afs_server;
69 static interface_function_list_t afscb_server;
70 static interface_function_list_t bos_server;
71 static interface_function_list_t kauth_kaa_server;
72 static interface_function_list_t kauth_kam_server;
73 static interface_function_list_t kauth_kat_server;
74 static interface_function_list_t pts_server;
75 static interface_function_list_t rxstat_server;
76 static interface_function_list_t ubik_disk_server;
77 static interface_function_list_t ubik_vote_server;
78 static interface_function_list_t vl_server;
79 static interface_function_list_t vol_server;
80 static pthread_once_t pthread_func_list_once = PTHREAD_ONCE_INIT;
81 static int pthread_func_list_done;
82
83 static void
84 cr_list(void)
85 {
86     afs_server.functionList = RXAFS_function_names;
87     afs_server.functionListLen = RXAFS_NO_OF_STAT_FUNCS;
88     afscb_server.functionList = RXAFSCB_function_names;
89     afscb_server.functionListLen = RXAFSCB_NO_OF_STAT_FUNCS;
90     bos_server.functionList = BOZO_function_names;
91     bos_server.functionListLen = BOZO_NO_OF_STAT_FUNCS;
92     kauth_kaa_server.functionList = KAA_function_names;
93     kauth_kaa_server.functionListLen = KAA_NO_OF_STAT_FUNCS;
94     kauth_kam_server.functionList = KAM_function_names;
95     kauth_kam_server.functionListLen = KAM_NO_OF_STAT_FUNCS;
96     kauth_kat_server.functionList = KAT_function_names;
97     kauth_kat_server.functionListLen = KAT_NO_OF_STAT_FUNCS;
98     pts_server.functionList = PR_function_names;
99     pts_server.functionListLen = PR_NO_OF_STAT_FUNCS;
100     rxstat_server.functionList = RXSTATS_function_names;
101     rxstat_server.functionListLen = RXSTATS_NO_OF_STAT_FUNCS;
102     ubik_disk_server.functionList = DISK_function_names;
103     ubik_disk_server.functionListLen = DISK_NO_OF_STAT_FUNCS;
104     ubik_vote_server.functionList = VOTE_function_names;
105     ubik_vote_server.functionListLen = VOTE_NO_OF_STAT_FUNCS;
106     vl_server.functionList = VL_function_names;
107     vl_server.functionListLen = VL_NO_OF_STAT_FUNCS;
108     vol_server.functionList = AFSVolfunction_names;
109     vol_server.functionListLen = AFSVolNO_OF_STAT_FUNCS;
110     pthread_func_list_done = 1;
111 }
112
113 #else
114
115 static interface_function_list_t afs_server = {
116     RXAFS_function_names,
117     RXAFS_NO_OF_STAT_FUNCS
118 };
119
120 static interface_function_list_t afscb_server = {
121     RXAFSCB_function_names,
122     RXAFSCB_NO_OF_STAT_FUNCS
123 };
124
125 static interface_function_list_t bos_server = {
126     BOZO_function_names,
127     BOZO_NO_OF_STAT_FUNCS
128 };
129
130 static interface_function_list_t kauth_kaa_server = {
131     KAA_function_names,
132     KAA_NO_OF_STAT_FUNCS
133 };
134
135 static interface_function_list_t kauth_kam_server = {
136     KAM_function_names,
137     KAM_NO_OF_STAT_FUNCS
138 };
139
140 static interface_function_list_t kauth_kat_server = {
141     KAT_function_names,
142     KAT_NO_OF_STAT_FUNCS
143 };
144
145 static interface_function_list_t pts_server = {
146     PR_function_names,
147     PR_NO_OF_STAT_FUNCS
148 };
149
150 static interface_function_list_t rxstat_server = {
151     RXSTATS_function_names,
152     RXSTATS_NO_OF_STAT_FUNCS
153 };
154
155 static interface_function_list_t ubik_disk_server = {
156     DISK_function_names,
157     DISK_NO_OF_STAT_FUNCS,
158 };
159
160 static interface_function_list_t ubik_vote_server = {
161     VOTE_function_names,
162     VOTE_NO_OF_STAT_FUNCS,
163 };
164
165 static interface_function_list_t vl_server = {
166     VL_function_names,
167     VL_NO_OF_STAT_FUNCS
168 };
169
170 static interface_function_list_t vol_server = {
171     AFSVolfunction_names,
172     AFSVolNO_OF_STAT_FUNCS
173 };
174
175 #endif /* AFS_NT40_ENV */
176
177 static interface_function_list_t unknown_server = {
178     0,
179     0
180 };
181
182 typedef struct {
183     afs_uint32 interfaceId;
184     const char *interfaceName;
185     interface_function_list_p functionList;
186 } interface_t, *interface_p;
187
188 interface_t int_list[] = {
189     {RXAFS_STATINDEX,
190      "file server",
191      &afs_server},
192
193     {RXSTATS_STATINDEX,
194      "rx stats",
195      &rxstat_server},
196
197     {RXAFSCB_STATINDEX,
198      "cache manager",
199      &afscb_server},
200
201     {PR_STATINDEX,
202      "pts server",
203      &pts_server},
204
205     {DISK_STATINDEX,
206      "ubik disk server",
207      &ubik_disk_server},
208
209     {VOTE_STATINDEX,
210      "ubik vote server",
211      &ubik_vote_server},
212
213     {VL_STATINDEX,
214      "vldb server",
215      &vl_server},
216
217     {AFSVolSTATINDEX,
218      "vol server",
219      &vol_server},
220
221     {BOZO_STATINDEX,
222      "bos server",
223      &bos_server},
224
225     {KAA_STATINDEX,
226      "kas kaa server",
227      &kauth_kaa_server},
228
229     {KAM_STATINDEX,
230      "kas kam server",
231      &kauth_kam_server},
232
233     {KAT_STATINDEX,
234      "kas kat server",
235      &kauth_kat_server},
236
237     /*
238      * Note the code below assumes that the following entry is the last entry
239      * in this array
240      */
241
242     {0, "unknown", &unknown_server}
243 };
244
245 /*
246  * Utility functions
247  */
248
249 int
250 DoClientLocalCellGet(struct cmd_syndesc *as, void *arock)
251 {
252     afs_status_t st = 0;
253     char cellName[MAXCELLCHARS];
254
255     if (!afsclient_LocalCellGet(cellName, &st)) {
256         ERR_ST_EXT("afsclient_LocalCellGet", st);
257     }
258
259     printf("This machine belongs to cell: %s\n", cellName);
260
261     return 0;
262 }
263
264 int
265 DoClientMountPointCreate(struct cmd_syndesc *as, void *arock)
266 {
267     enum { DIRECTORY, VOLUME, READWRITE,
268         CHECK
269     };
270     afs_status_t st = 0;
271     const char *directory = NULL;
272     const char *volume = NULL;
273     vol_type_t vol_type = READ_ONLY;
274     vol_check_t vol_check = DONT_CHECK_VOLUME;
275
276     if (as->parms[DIRECTORY].items) {
277         directory = as->parms[DIRECTORY].items->data;
278     }
279
280     if (as->parms[VOLUME].items) {
281         volume = as->parms[VOLUME].items->data;
282     }
283
284     if (as->parms[READWRITE].items) {
285         vol_type = READ_WRITE;
286     }
287
288     if (as->parms[CHECK].items) {
289         vol_check = CHECK_VOLUME;
290     }
291
292     if (!afsclient_MountPointCreate
293         (cellHandle, directory, volume, vol_type, vol_check, &st)) {
294         ERR_ST_EXT("afsclient_MountPointCreate", st);
295     }
296
297     return 0;
298 }
299
300 static void
301 Print_afs_serverEntry_p(afs_serverEntry_p serv, const char *prefix)
302 {
303     int i = 0;
304
305     printf("%sInformation for server %s\n", prefix, serv->serverName);
306     if (serv->serverType & DATABASE_SERVER) {
307         printf("%s\tIt is a database server\n", prefix);
308     }
309     if (serv->serverType & FILE_SERVER) {
310         printf("%s\tIt is a file server\n", prefix);
311     }
312     printf("%s\tServer addresses:%s\n", prefix, serv->serverName);
313     while (serv->serverAddress[i] != 0) {
314         printf("\t\t%s%x\n", prefix, serv->serverAddress[i++]);
315     }
316 }
317
318 int
319 DoClientAFSServerGet(struct cmd_syndesc *as, void *arock)
320 {
321     enum { SERVER };
322     afs_status_t st = 0;
323     const char *server = NULL;
324     afs_serverEntry_t entry;
325
326     if (as->parms[SERVER].items) {
327         server = as->parms[SERVER].items->data;
328     }
329
330     if (!afsclient_AFSServerGet(cellHandle, server, &entry, &st)) {
331         ERR_ST_EXT("afsclient_AFSServerGet", st);
332     }
333
334     Print_afs_serverEntry_p(&entry, "");
335
336     return 0;
337 }
338
339 int
340 DoClientAFSServerList(struct cmd_syndesc *as, void *arock)
341 {
342     afs_status_t st = 0;
343     afs_serverEntry_t entry;
344     void *iter = NULL;
345
346     if (!afsclient_AFSServerGetBegin(cellHandle, &iter, &st)) {
347         ERR_ST_EXT("afsclient_AFSServerGetBegin", st);
348     }
349
350     while (afsclient_AFSServerGetNext(iter, &entry, &st)) {
351         Print_afs_serverEntry_p(&entry, "");
352     }
353
354     if (st != ADMITERATORDONE) {
355         ERR_ST_EXT("afsclient_AFSServerGetNext", st);
356     }
357
358     if (!afsclient_AFSServerGetDone(iter, &st)) {
359         ERR_ST_EXT("afsclient_AFSServerGetDone", st);
360     }
361
362
363     return 0;
364 }
365
366 static void
367 Print_afs_RPCStatsState_p(afs_RPCStatsState_p state, const char *prefix)
368 {
369     printf("%sThe rpc stats state is: ", prefix);
370     switch (*state) {
371     case AFS_RPC_STATS_DISABLED:
372         printf("disabled\n");
373         break;
374     case AFS_RPC_STATS_ENABLED:
375         printf("enabled\n");
376         break;
377     }
378 }
379
380 typedef struct {
381     const char *tag;
382     afs_stat_source_t value;
383 } afs_type_map_t, *afs_type_map_p;
384
385 static afs_type_map_t map[] = {
386     {"bosserver", AFS_BOSSERVER},
387     {"fileserver", AFS_FILESERVER},
388     {"kaserver", AFS_KASERVER},
389     {"ptserver", AFS_PTSERVER},
390     {"volserver", AFS_VOLSERVER},
391     {"vlserver", AFS_VLSERVER},
392     {"client", AFS_CLIENT},
393     {0, 0}
394 };
395
396 static int
397 GetStatPortFromString(const char *type, int *port)
398 {
399     char *end;
400     long tport;
401
402     errno = 0;
403     tport = strtol(type, &end, 0);
404     if (tport == 0 || end == type || *end != '\0') {
405         return 0;
406     }
407
408     *port = (int)tport;
409     return 1;
410 }
411
412 static int
413 GetStatSourceFromString(const char *type, afs_stat_source_t * src, int *port)
414 {
415     int i;
416     size_t type_len = strlen(type);
417
418     for (i = 0; (map[i].tag) && strncasecmp(type, map[i].tag, type_len); i++);
419
420     if (map[i].tag == 0) {
421         /*
422          * Try to convert string to port number
423          */
424         if (GetStatPortFromString(type, port)) {
425             return 0;
426         }
427
428         fprintf(stderr,
429                 "couldn't convert server to type, try one of the "
430                 "following:\n");
431         for (i = 0; map[i].tag; i++) {
432             fprintf(stderr, "%s ", map[i].tag);
433         }
434
435         ERR_EXT("");
436     } else {
437         *src = map[i].value;
438         return 1;
439     }
440 }
441
442 typedef enum {
443     AFS_PEER_STATS,
444     afs_proc_tESS_STATS
445 } afs_stat_type_t, *afs_stat_type_p;
446
447 static afs_stat_type_t
448 GetStatTypeFromString(const char *type)
449 {
450     afs_stat_type_t rc;
451
452     if (!strcmp(type, "peer")) {
453         rc = AFS_PEER_STATS;
454     } else if (!strcmp(type, "process")) {
455         rc = afs_proc_tESS_STATS;
456     } else {
457         ERR_EXT("stat_type must be process or peer");
458     }
459
460     return rc;
461 }
462
463 int
464 DoClientRPCStatsStateGet(struct cmd_syndesc *as, void *arock)
465 {
466     enum { SERVER, PROCESS,
467         STAT_TYPE
468     };
469     afs_status_t st = 0;
470     struct rx_connection *conn;
471     afs_stat_source_t type;
472     int srvrPort;
473     int typeIsValid = 0;
474     afs_stat_type_t which = 0;
475     afs_RPCStatsState_t state;
476
477     typeIsValid = GetStatSourceFromString(as->parms[PROCESS].items->data,
478                                           &type, &srvrPort);
479
480     which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
481
482     if (typeIsValid) {
483         if (!afsclient_RPCStatOpen(cellHandle,
484                                    as->parms[SERVER].items->data,
485                                    type, &conn, &st)) {
486             ERR_ST_EXT("afsclient_RPCStatOpen", st);
487         }
488     } else {
489         if (!afsclient_RPCStatOpenPort(cellHandle,
490                                        as->parms[SERVER].items->data,
491                                        srvrPort, &conn, &st)) {
492             ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
493         }
494     }
495
496     if (which == AFS_PEER_STATS) {
497         if (!util_RPCStatsStateGet
498             (conn, RXSTATS_QueryPeerRPCStats, &state, &st)) {
499             ERR_ST_EXT("util_RPCStatsStateGet", st);
500         }
501     } else {
502         if (!util_RPCStatsStateGet
503             (conn, RXSTATS_QueryProcessRPCStats, &state, &st)) {
504             ERR_ST_EXT("util_RPCStatsStateGet", st);
505         }
506     }
507
508     Print_afs_RPCStatsState_p(&state, "");
509
510     afsclient_RPCStatClose(conn, 0);
511
512     return 0;
513 }
514
515 int
516 DoClientRPCStatsStateEnable(struct cmd_syndesc *as, void *arock)
517 {
518     enum { SERVER, PROCESS, STAT_TYPE };
519     afs_status_t st = 0;
520     struct rx_connection *conn;
521     afs_stat_source_t type;
522     int srvrPort;
523     int typeIsValid;
524     afs_stat_type_t which;
525
526     typeIsValid = GetStatSourceFromString(as->parms[PROCESS].items->data,
527                                           &type, &srvrPort);
528
529     which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
530
531     if (typeIsValid) {
532         if (!afsclient_RPCStatOpen(cellHandle,
533                                    as->parms[SERVER].items->data,
534                                    type, &conn, &st)) {
535             ERR_ST_EXT("afsclient_RPCStatOpen", st);
536         }
537     } else {
538         if (!afsclient_RPCStatOpenPort(cellHandle,
539                                        as->parms[SERVER].items->data,
540                                        srvrPort, &conn, &st)) {
541             ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
542         }
543     }
544
545     if (which == AFS_PEER_STATS) {
546         if (!util_RPCStatsStateEnable(conn, RXSTATS_EnablePeerRPCStats, &st)) {
547             ERR_ST_EXT("util_RPCStatsStateEnable", st);
548         }
549     } else {
550         if (!util_RPCStatsStateEnable
551             (conn, RXSTATS_EnableProcessRPCStats, &st)) {
552             ERR_ST_EXT("util_RPCStatsStateEnable", st);
553         }
554     }
555
556     afsclient_RPCStatClose(conn, 0);
557
558     return 0;
559 }
560
561 int
562 DoClientRPCStatsStateDisable(struct cmd_syndesc *as, void *arock)
563 {
564     enum { SERVER, PROCESS,
565         STAT_TYPE
566     };
567     afs_status_t st = 0;
568     struct rx_connection *conn;
569     afs_stat_source_t type;
570     int srvrPort;
571     int typeIsValid;
572     afs_stat_type_t which;
573
574     typeIsValid = GetStatSourceFromString(as->parms[PROCESS].items->data,
575                                           &type, &srvrPort);
576
577     which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
578
579     if (typeIsValid) {
580         if (!afsclient_RPCStatOpen(cellHandle,
581                                    as->parms[SERVER].items->data,
582                                    type, &conn, &st)) {
583             ERR_ST_EXT("afsclient_RPCStatOpen", st);
584         }
585     } else {
586         if (!afsclient_RPCStatOpenPort(cellHandle,
587                                        as->parms[SERVER].items->data,
588                                        srvrPort, &conn, &st)) {
589             ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
590         }
591     }
592
593     if (which == AFS_PEER_STATS) {
594         if (!util_RPCStatsStateDisable
595             (conn, RXSTATS_DisablePeerRPCStats, &st)) {
596             ERR_ST_EXT("util_RPCStatsStateDisable", st);
597         }
598     } else {
599         if (!util_RPCStatsStateDisable
600             (conn, RXSTATS_DisableProcessRPCStats, &st)) {
601             ERR_ST_EXT("util_RPCStatsStateDisable", st);
602         }
603     }
604
605     afsclient_RPCStatClose(conn, 0);
606
607     return 0;
608 }
609
610 static void
611 Print_afs_RPCStats_p(afs_RPCStats_p stat, interface_function_list_p f_list,
612                      const char *prefix)
613 {
614     afs_int32 index = stat->s.stats_v1.func_index;
615
616     if (index > ((afs_int32) f_list->functionListLen - 1)) {
617         printf("%sUnknown function ", prefix);
618     } else {
619         printf("%s%s ", prefix,
620                f_list->functionList[stat->s.stats_v1.func_index]);
621     }
622
623     if (stat->s.stats_v1.invocations != 0) {
624         printf("%sinvoc %"AFS_UINT64_FMT
625                " bytes_sent %"AFS_UINT64_FMT
626                " bytes_rcvd %"AFS_UINT64_FMT"\n",
627                prefix,
628                stat->s.stats_v1.invocations,
629                stat->s.stats_v1.bytes_sent,
630                stat->s.stats_v1.bytes_rcvd
631               );
632         printf("\tqsum %d.%06d\tqsqr %d.%06d"
633                "\tqmin %d.%06d\tqmax %d.%06d\n",
634                stat->s.stats_v1.queue_time_sum.sec,
635                stat->s.stats_v1.queue_time_sum.usec,
636                stat->s.stats_v1.queue_time_sum_sqr.sec,
637                stat->s.stats_v1.queue_time_sum_sqr.usec,
638                stat->s.stats_v1.queue_time_min.sec,
639                stat->s.stats_v1.queue_time_min.usec,
640                stat->s.stats_v1.queue_time_max.sec,
641                stat->s.stats_v1.queue_time_max.usec);
642         printf("\txsum %d.%06d\txsqr %d.%06d"
643                "\txmin %d.%06d\txmax %d.%06d\n",
644                stat->s.stats_v1.execution_time_sum.sec,
645                stat->s.stats_v1.execution_time_sum.usec,
646                stat->s.stats_v1.execution_time_sum_sqr.sec,
647                stat->s.stats_v1.execution_time_sum_sqr.usec,
648                stat->s.stats_v1.execution_time_min.sec,
649                stat->s.stats_v1.execution_time_min.usec,
650                stat->s.stats_v1.execution_time_max.sec,
651                stat->s.stats_v1.execution_time_max.usec);
652     } else {
653         printf("never invoked\n");
654     }
655 }
656
657 int
658 DoClientRPCStatsList(struct cmd_syndesc *as, void *arock)
659 {
660     enum { SERVER, PROCESS, STAT_TYPE };
661     afs_status_t st = 0;
662     struct rx_connection *conn;
663     afs_stat_source_t type;
664     int srvrPort;
665     int typeIsValid;
666     afs_stat_type_t which;
667     afs_RPCStats_t stats;
668     void *iter;
669     int i = 0;
670
671 #ifdef AFS_NT40_ENV
672     (pthread_func_list_done
673      || pthread_once(&pthread_func_list_once, cr_list));
674 #endif
675
676     typeIsValid = GetStatSourceFromString(as->parms[PROCESS].items->data,
677                                           &type, &srvrPort);
678
679     which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
680
681     if (typeIsValid) {
682         if (!afsclient_RPCStatOpen(cellHandle,
683                                    as->parms[SERVER].items->data,
684                                    type, &conn, &st)) {
685             ERR_ST_EXT("afsclient_RPCStatOpen", st);
686         }
687     } else {
688         if (!afsclient_RPCStatOpenPort(cellHandle,
689                                        as->parms[SERVER].items->data,
690                                        srvrPort, &conn, &st)) {
691             ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
692         }
693     }
694
695     if (which == AFS_PEER_STATS) {
696         if (!util_RPCStatsGetBegin
697             (conn, RXSTATS_RetrievePeerRPCStats, &iter, &st)) {
698             ERR_ST_EXT("util_RPCStatsGetBegin", st);
699         }
700     } else {
701         if (!util_RPCStatsGetBegin
702             (conn, RXSTATS_RetrieveProcessRPCStats, &iter, &st)) {
703             ERR_ST_EXT("util_RPCStatsGetBegin", st);
704         }
705     }
706
707     printf("Listing rpc stats at server %s process %s:\n",
708            as->parms[SERVER].items->data, as->parms[PROCESS].items->data);
709
710     while (util_RPCStatsGetNext(iter, &stats, &st)) {
711
712         /*
713          * Print a new heading for each stat collection
714          */
715
716         if (stats.s.stats_v1.func_index == 0) {
717
718             printf("\n\n");
719
720             /*
721              * Look up the interface in our list
722              */
723
724             for (i = 0; i < ((sizeof(int_list) - 1) / sizeof(interface_t));
725                  i++) {
726                 if (stats.s.stats_v1.interfaceId == int_list[i].interfaceId) {
727                     break;
728                 }
729             }
730
731             /*
732              * Print out a meaningful header for each stat collection
733              */
734
735             if (which == AFS_PEER_STATS) {
736                 struct in_addr ina;
737                 ina.s_addr = htonl(stats.s.stats_v1.remote_peer);
738
739                 printf("%s stats for remote peer located at %s port %u "
740                        "%s %s as a %s via the %s interface\n",
741                        as->parms[PROCESS].items->data, inet_ntoa(ina),
742                        stats.s.stats_v1.remote_port,
743                        ((stats.s.stats_v1.
744                          remote_is_server) ? "accessed by" : "accessing"),
745                        as->parms[PROCESS].items->data,
746                        ((stats.s.stats_v1.
747                          remote_is_server) ? "client" : "server"),
748                        int_list[i].interfaceName);
749             } else {
750                 printf("%s stats for the %s interface " "accessed as a %s\n",
751                        as->parms[PROCESS].items->data,
752                        int_list[i].interfaceName,
753                        ((stats.s.stats_v1.
754                          remote_is_server) ? "client" : "server")
755                     );
756             }
757         }
758         Print_afs_RPCStats_p(&stats, int_list[i].functionList, "    ");
759     }
760
761     if (st != ADMITERATORDONE) {
762         ERR_ST_EXT("util_RPCStatsGetNext", st);
763     }
764
765     if (!util_RPCStatsGetDone(iter, &st)) {
766         ERR_ST_EXT("util_RPCStatsGetDone", st);
767     }
768
769     afsclient_RPCStatClose(conn, 0);
770
771     return 0;
772 }
773
774 int
775 DoClientRPCStatsClear(struct cmd_syndesc *as, void *arock)
776 {
777     enum { SERVER, PROCESS, STAT_TYPE, CLEAR_ALL, CLEAR_INVOCATIONS,
778         CLEAR_BYTES_SENT, CLEAR_BYTES_RCVD,
779         CLEAR_QUEUE_TIME_SUM, CLEAR_QUEUE_TIME_SQUARE,
780         CLEAR_QUEUE_TIME_MIN, CLEAR_QUEUE_TIME_MAX,
781         CLEAR_EXEC_TIME_SUM, CLEAR_EXEC_TIME_SQUARE,
782         CLEAR_EXEC_TIME_MIN, CLEAR_EXEC_TIME_MAX
783     };
784     afs_status_t st = 0;
785     struct rx_connection *conn;
786     afs_stat_source_t type;
787     int srvrPort;
788     int typeIsValid;
789     afs_stat_type_t which;
790     afs_RPCStatsClearFlag_t flag = 0;
791     int seen_all = 0;
792     int seen_any = 0;
793
794     typeIsValid = GetStatSourceFromString(as->parms[PROCESS].items->data,
795                                           &type, &srvrPort);
796
797     which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
798
799     if (typeIsValid) {
800         if (!afsclient_RPCStatOpen(cellHandle,
801                                    as->parms[SERVER].items->data,
802                                    type, &conn, &st)) {
803             ERR_ST_EXT("afsclient_RPCStatOpen", st);
804         }
805     } else {
806         if (!afsclient_RPCStatOpenPort(cellHandle,
807                                        as->parms[SERVER].items->data,
808                                        srvrPort, &conn, &st)) {
809             ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
810         }
811     }
812
813     if (as->parms[CLEAR_ALL].items) {
814         seen_all = 1;
815         seen_any = 1;
816         flag = AFS_RX_STATS_CLEAR_ALL;
817     }
818
819     if (as->parms[CLEAR_INVOCATIONS].items) {
820         if (seen_all) {
821             ERR_EXT("cannot specify additional flags when "
822                     "specifying clear_all");
823         }
824         seen_any = 1;
825         flag |= AFS_RX_STATS_CLEAR_INVOCATIONS;
826     }
827
828     if (as->parms[CLEAR_BYTES_SENT].items) {
829         if (seen_all) {
830             ERR_EXT("cannot specify additional flags when "
831                     "specifying clear_all");
832         }
833         seen_any = 1;
834         flag |= AFS_RX_STATS_CLEAR_BYTES_SENT;
835     }
836
837     if (as->parms[CLEAR_BYTES_RCVD].items) {
838         if (seen_all) {
839             ERR_EXT("cannot specify additional flags when "
840                     "specifying clear_all");
841         }
842         seen_any = 1;
843         flag |= AFS_RX_STATS_CLEAR_BYTES_RCVD;
844     }
845
846     if (as->parms[CLEAR_QUEUE_TIME_SUM].items) {
847         if (seen_all) {
848             ERR_EXT("cannot specify additional flags when "
849                     "specifying clear_all");
850         }
851         seen_any = 1;
852         flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM;
853     }
854
855     if (as->parms[CLEAR_QUEUE_TIME_SQUARE].items) {
856         if (seen_all) {
857             ERR_EXT("cannot specify additional flags when "
858                     "specifying clear_all");
859         }
860         seen_any = 1;
861         flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE;
862     }
863
864     if (as->parms[CLEAR_QUEUE_TIME_MIN].items) {
865         if (seen_all) {
866             ERR_EXT("cannot specify additional flags when "
867                     "specifying clear_all");
868         }
869         seen_any = 1;
870         flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN;
871     }
872
873     if (as->parms[CLEAR_QUEUE_TIME_MAX].items) {
874         if (seen_all) {
875             ERR_EXT("cannot specify additional flags when "
876                     "specifying clear_all");
877         }
878         seen_any = 1;
879         flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX;
880     }
881
882     if (as->parms[CLEAR_EXEC_TIME_SUM].items) {
883         if (seen_all) {
884             ERR_EXT("cannot specify additional flags when "
885                     "specifying clear_all");
886         }
887         seen_any = 1;
888         flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_SUM;
889     }
890
891     if (as->parms[CLEAR_EXEC_TIME_SQUARE].items) {
892         if (seen_all) {
893             ERR_EXT("cannot specify additional flags when "
894                     "specifying clear_all");
895         }
896         seen_any = 1;
897         flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE;
898     }
899
900     if (as->parms[CLEAR_EXEC_TIME_MIN].items) {
901         if (seen_all) {
902             ERR_EXT("cannot specify additional flags when "
903                     "specifying clear_all");
904         }
905         seen_any = 1;
906         flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_MIN;
907     }
908
909     if (as->parms[CLEAR_EXEC_TIME_MAX].items) {
910         if (seen_all) {
911             ERR_EXT("cannot specify additional flags when "
912                     "specifying clear_all");
913         }
914         seen_any = 1;
915         flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_MAX;
916     }
917
918     if (!seen_any) {
919         ERR_EXT("you must specify something to clear");
920     }
921
922     if (which == AFS_PEER_STATS) {
923         if (!util_RPCStatsClear(conn, RXSTATS_ClearPeerRPCStats, flag, &st)) {
924             ERR_ST_EXT("util_RPCStatsClear", st);
925         }
926     } else {
927         if (!util_RPCStatsClear
928             (conn, RXSTATS_ClearProcessRPCStats, flag, &st)) {
929             ERR_ST_EXT("util_RPCStatsClear", st);
930         }
931     }
932
933     afsclient_RPCStatClose(conn, 0);
934
935     return 0;
936 }
937
938 int
939 DoClientRPCStatsVersionGet(struct cmd_syndesc *as, void *arock)
940 {
941     enum { SERVER, PROCESS };
942     afs_status_t st = 0;
943     struct rx_connection *conn;
944     afs_stat_source_t type;
945     int srvrPort;
946     int typeIsValid;
947     afs_RPCStatsVersion_t version;
948
949     typeIsValid = GetStatSourceFromString(as->parms[PROCESS].items->data,
950                                           &type, &srvrPort);
951
952     if (typeIsValid) {
953         if (!afsclient_RPCStatOpen(cellHandle,
954                                    as->parms[SERVER].items->data,
955                                    type, &conn, &st)) {
956             ERR_ST_EXT("afsclient_RPCStatOpen", st);
957         }
958     } else {
959         if (!afsclient_RPCStatOpenPort(cellHandle,
960                                        as->parms[SERVER].items->data,
961                                        srvrPort, &conn, &st)) {
962             ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
963         }
964     }
965
966     if (!util_RPCStatsVersionGet(conn, &version, &st)) {
967         ERR_ST_EXT("util_RPCStatsVersionGet", st);
968     }
969
970     printf("the rpc stat version number is %u\n", version);
971
972     afsclient_RPCStatClose(conn, 0);
973
974     return 0;
975 }
976
977 static void
978 Print_afs_CMServerPref_p(afs_CMServerPref_p pref)
979 {
980     afs_uint32 taddr;
981
982     taddr = pref->ipAddr;
983     printf("%d.%d.%d.%d\t\t\t%d\n", (taddr >> 24) & 0xff,
984            (taddr >> 16) & 0xff, (taddr >> 8) & 0xff, taddr & 0xff,
985            pref->ipRank);
986 }
987
988 int
989 DoClientCMGetServerPrefs(struct cmd_syndesc *as, void *arock)
990 {
991     afs_status_t st = 0;
992     enum { SERVER, PORT };
993     struct rx_connection *conn;
994     int srvrPort = AFSCONF_CALLBACKPORT;
995     afs_CMServerPref_t prefs;
996     void *iter;
997
998 #ifdef AFS_NT40_ENV
999     (pthread_func_list_done
1000      || pthread_once(&pthread_func_list_once, cr_list));
1001 #endif
1002
1003     if (as->parms[PORT].items) {
1004         if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1005             ERR_EXT("Couldn't undertand port number");
1006         }
1007     }
1008
1009     if (!afsclient_CMStatOpenPort(cellHandle,
1010                                   as->parms[SERVER].items->data,
1011                                   srvrPort, &conn, &st)) {
1012         ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1013     }
1014
1015     if (!util_CMGetServerPrefsBegin(conn, &iter, &st)) {
1016         ERR_ST_EXT("util_CMGetServerPrefsBegin", st);
1017     }
1018
1019     printf("Listing CellServDB for %s at port %s:\n",
1020            as->parms[SERVER].items->data, as->parms[PORT].items->data);
1021
1022     while (util_CMGetServerPrefsNext(iter, &prefs, &st)) {
1023
1024         Print_afs_CMServerPref_p(&prefs);
1025     }
1026
1027     if (st != ADMITERATORDONE) {
1028         ERR_ST_EXT("util_CMGetServerPrefsNext", st);
1029     }
1030
1031     if (!util_CMGetServerPrefsDone(iter, &st)) {
1032         ERR_ST_EXT("util_CMGetServerPrefsDone", st);
1033     }
1034
1035     afsclient_CMStatClose(conn, 0);
1036
1037     return 0;
1038 }
1039
1040 static void
1041 Print_afs_CMListCell_p(afs_CMListCell_p cellInfo)
1042 {
1043     int i;
1044     afs_uint32 taddr;
1045
1046     printf("Cell %s on hosts", cellInfo->cellname);
1047     for (i = 0; i < UTIL_MAX_CELL_HOSTS && cellInfo->serverAddr[i]; i++) {
1048         taddr = cellInfo->serverAddr[i];
1049         printf(" %d.%d.%d.%d", (taddr >> 24) & 0xff, (taddr >> 16) & 0xff,
1050                (taddr >> 8) & 0xff, taddr & 0xff);
1051     }
1052     printf("\n");
1053 }
1054
1055 int
1056 DoClientCMListCells(struct cmd_syndesc *as, void *arock)
1057 {
1058     afs_status_t st = 0;
1059     enum { SERVER, PORT };
1060     struct rx_connection *conn;
1061     int srvrPort = AFSCONF_CALLBACKPORT;
1062     afs_CMListCell_t cellInfo;
1063     void *iter;
1064
1065 #ifdef AFS_NT40_ENV
1066     (pthread_func_list_done
1067      || pthread_once(&pthread_func_list_once, cr_list));
1068 #endif
1069
1070     if (as->parms[PORT].items) {
1071         if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1072             ERR_EXT("Couldn't undertand port number");
1073         }
1074     }
1075
1076     if (!afsclient_CMStatOpenPort(cellHandle,
1077                                   as->parms[SERVER].items->data,
1078                                   srvrPort, &conn, &st)) {
1079         ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1080     }
1081
1082     if (!util_CMListCellsBegin(conn, &iter, &st)) {
1083         ERR_ST_EXT("util_CMListCellsBegin", st);
1084     }
1085
1086     printf("Listing CellServDB for %s at port %s:\n",
1087            as->parms[SERVER].items->data, as->parms[PORT].items->data);
1088
1089     while (util_CMListCellsNext(iter, &cellInfo, &st)) {
1090
1091         Print_afs_CMListCell_p(&cellInfo);
1092     }
1093
1094     if (st != ADMITERATORDONE) {
1095         ERR_ST_EXT("util_CMListCellsNext", st);
1096     }
1097
1098     if (!util_CMListCellsDone(iter, &st)) {
1099         ERR_ST_EXT("util_CMListCellsDone", st);
1100     }
1101
1102     afsclient_CMStatClose(conn, 0);
1103
1104     return 0;
1105 }
1106
1107 int
1108 DoClientCMLocalCell(struct cmd_syndesc *as, void *arock)
1109 {
1110     afs_status_t st = 0;
1111     enum { SERVER, PORT };
1112     struct rx_connection *conn;
1113     int srvrPort = AFSCONF_CALLBACKPORT;
1114     afs_CMCellName_t cellname;
1115
1116 #ifdef AFS_NT40_ENV
1117     (pthread_func_list_done
1118      || pthread_once(&pthread_func_list_once, cr_list));
1119 #endif
1120
1121     if (as->parms[PORT].items) {
1122         if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1123             ERR_EXT("Couldn't undertand port number");
1124         }
1125     }
1126
1127     if (!afsclient_CMStatOpenPort(cellHandle,
1128                                   as->parms[SERVER].items->data,
1129                                   srvrPort, &conn, &st)) {
1130         ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1131     }
1132
1133     if (!util_CMLocalCell(conn, cellname, &st)) {
1134         ERR_ST_EXT("util_CMLocalCell", st);
1135     }
1136
1137     printf("Client %s (port %s) is in cell %s\n",
1138            as->parms[SERVER].items->data, as->parms[PORT].items->data,
1139            cellname);
1140
1141     afsclient_CMStatClose(conn, 0);
1142
1143     return 0;
1144 }
1145
1146 static void
1147 Print_afs_ClientConfig_p(afs_ClientConfig_p config)
1148 {
1149     printf("    clientVersion:  %d\n", config->clientVersion);
1150     printf("    serverVersion:  %d\n", config->serverVersion);
1151     printf("    nChunkFiles:    %d\n", config->c.config_v1.nChunkFiles);
1152     printf("    nStatCaches:    %d\n", config->c.config_v1.nStatCaches);
1153     printf("    nDataCaches:    %d\n", config->c.config_v1.nDataCaches);
1154     printf("    nVolumeCaches:  %d\n", config->c.config_v1.nVolumeCaches);
1155     printf("    firstChunkSize: %d\n", config->c.config_v1.firstChunkSize);
1156     printf("    otherChunkSize: %d\n", config->c.config_v1.otherChunkSize);
1157     printf("    cacheSize:      %d\n", config->c.config_v1.cacheSize);
1158     printf("    setTime:        %d\n", config->c.config_v1.setTime);
1159     printf("    memCache:       %d\n", config->c.config_v1.memCache);
1160
1161 }
1162
1163 int
1164 DoClientCMClientConfig(struct cmd_syndesc *as, void *arock)
1165 {
1166     afs_status_t st = 0;
1167     enum { SERVER, PORT };
1168     struct rx_connection *conn;
1169     int srvrPort = AFSCONF_CALLBACKPORT;
1170     afs_ClientConfig_t config;
1171
1172 #ifdef AFS_NT40_ENV
1173     (pthread_func_list_done
1174      || pthread_once(&pthread_func_list_once, cr_list));
1175 #endif
1176
1177     if (as->parms[PORT].items) {
1178         if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1179             ERR_EXT("Couldn't undertand port number");
1180         }
1181     }
1182
1183     if (!afsclient_CMStatOpenPort(cellHandle,
1184                                   as->parms[SERVER].items->data,
1185                                   srvrPort, &conn, &st)) {
1186         ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1187     }
1188
1189     if (!util_CMClientConfig(conn, &config, &st)) {
1190         ERR_ST_EXT("util_CMClientConfig", st);
1191     }
1192
1193     printf("Cache configuration for client %s (port %s):\n\n",
1194            as->parms[SERVER].items->data, as->parms[PORT].items->data);
1195
1196     Print_afs_ClientConfig_p(&config);
1197
1198     printf("\n");
1199
1200     afsclient_CMStatClose(conn, 0);
1201
1202     return 0;
1203 }
1204
1205 void
1206 SetupClientAdminCmd(void)
1207 {
1208     struct cmd_syndesc *ts;
1209
1210     ts = cmd_CreateSyntax("ClientLocalCellGet", DoClientLocalCellGet, NULL, 0,
1211                           "get the name of this machine's cell");
1212     SetupCommonCmdArgs(ts);
1213
1214     ts = cmd_CreateSyntax("ClientMountPointCreate", DoClientMountPointCreate,
1215                           NULL, 0, "create a mount point");
1216     cmd_AddParm(ts, "-directory", CMD_SINGLE, CMD_REQUIRED,
1217                 "directory where mount point will be created");
1218     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1219                 "the name of the volume to mount");
1220     cmd_AddParm(ts, "-readwrite", CMD_FLAG, CMD_OPTIONAL,
1221                 "mount a read write volume");
1222     cmd_AddParm(ts, "-check", CMD_FLAG, CMD_OPTIONAL,
1223                 "check that the volume exists before mounting");
1224     SetupCommonCmdArgs(ts);
1225
1226     ts = cmd_CreateSyntax("ClientAFSServerGet", DoClientAFSServerGet, NULL, 0,
1227                           "retrieve information about an afs server");
1228     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
1229     SetupCommonCmdArgs(ts);
1230
1231     ts = cmd_CreateSyntax("ClientAFSServerList", DoClientAFSServerList, NULL, 0,
1232                           "retrieve information about all afs "
1233                           "servers in a cell");
1234     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1235                 "server where command will execute");
1236     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1237                 "process to query <bosserver fileserver ptserver "
1238                 "kaserver client vlserver volserver>");
1239     cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1240                 "stats to retrieve <peer or process>");
1241     SetupCommonCmdArgs(ts);
1242
1243     ts = cmd_CreateSyntax("ClientRPCStatsStateGet", DoClientRPCStatsStateGet,
1244                           NULL, 0, "retrieve the rpc stat collection state");
1245     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1246                 "server where command will execute");
1247     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1248                 "process to query <bosserver fileserver ptserver "
1249                 "kaserver client vlserver volserver>");
1250     cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1251                 "stats to retrieve <peer or process>");
1252     SetupCommonCmdArgs(ts);
1253
1254     ts = cmd_CreateSyntax("ClientRPCStatsStateEnable",
1255                           DoClientRPCStatsStateEnable, NULL, 0,
1256                           "set the rpc stat collection state to on");
1257     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1258                 "server where command will execute");
1259     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1260                 "process to query <bosserver fileserver ptserver "
1261                 "kaserver client vlserver volserver>");
1262     cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1263                 "stats to retrieve <peer or process>");
1264     SetupCommonCmdArgs(ts);
1265
1266     ts = cmd_CreateSyntax("ClientRPCStatsStateDisable",
1267                           DoClientRPCStatsStateDisable, NULL, 0,
1268                           "set the rpc stat collection state to off");
1269     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1270                 "server where command will execute");
1271     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1272                 "process to query <bosserver fileserver ptserver "
1273                 "kaserver client vlserver volserver>");
1274     cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1275                 "stats to retrieve <peer or process>");
1276     SetupCommonCmdArgs(ts);
1277
1278     ts = cmd_CreateSyntax("ClientRPCStatsList", DoClientRPCStatsList, NULL, 0,
1279                           "list the rpc stats");
1280     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1281                 "server where command will execute");
1282     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1283                 "process to query <bosserver fileserver ptserver "
1284                 "kaserver client vlserver volserver>");
1285     cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1286                 "stats to retrieve <peer or process>");
1287     SetupCommonCmdArgs(ts);
1288
1289     ts = cmd_CreateSyntax("ClientRPCStatsClear", DoClientRPCStatsClear, NULL, 0,
1290                           "reset rpc stat counters");
1291     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1292                 "server where command will execute");
1293     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1294                 "process to query <bosserver fileserver ptserver "
1295                 "kaserver client vlserver volserver>");
1296     cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1297                 "stats to retrieve <peer or process>");
1298     cmd_AddParm(ts, "-clear_all", CMD_FLAG, CMD_OPTIONAL,
1299                 "clear all existing counters");
1300     cmd_AddParm(ts, "-clear_invocations", CMD_FLAG, CMD_OPTIONAL,
1301                 "clear invocation count");
1302     cmd_AddParm(ts, "-clear_bytes_sent", CMD_FLAG, CMD_OPTIONAL,
1303                 "clear bytes_sent count");
1304     cmd_AddParm(ts, "-clear_bytes_rcvd", CMD_FLAG, CMD_OPTIONAL,
1305                 "clear bytes_rcvd count");
1306     cmd_AddParm(ts, "-clear_queue_time_sum", CMD_FLAG, CMD_OPTIONAL,
1307                 "clear queue time sum");
1308     cmd_AddParm(ts, "-clear_queue_time_square", CMD_FLAG, CMD_OPTIONAL,
1309                 "clear queue time square");
1310     cmd_AddParm(ts, "-clear_queue_time_min", CMD_FLAG, CMD_OPTIONAL,
1311                 "clear queue time min");
1312     cmd_AddParm(ts, "-clear_queue_time_max", CMD_FLAG, CMD_OPTIONAL,
1313                 "clear queue time max");
1314     cmd_AddParm(ts, "-clear_exec_time_sum", CMD_FLAG, CMD_OPTIONAL,
1315                 "clear exec time sum");
1316     cmd_AddParm(ts, "-clear_exec_time_square", CMD_FLAG, CMD_OPTIONAL,
1317                 "clear exec time square");
1318     cmd_AddParm(ts, "-clear_exec_time_min", CMD_FLAG, CMD_OPTIONAL,
1319                 "clear exec time min");
1320     cmd_AddParm(ts, "-clear_exec_time_max", CMD_FLAG, CMD_OPTIONAL,
1321                 "clear exec time max");
1322     SetupCommonCmdArgs(ts);
1323
1324     ts = cmd_CreateSyntax("ClientRPCStatsVersionGet",
1325                           DoClientRPCStatsVersionGet, NULL, 0,
1326                           "list the server's rpc stats version");
1327     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1328                 "server where command will execute");
1329     cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1330                 "process to query <bosserver fileserver ptserver "
1331                 "kaserver client vlserver volserver>");
1332     SetupCommonCmdArgs(ts);
1333
1334     ts = cmd_CreateSyntax("ClientCMGetServerPrefs", DoClientCMGetServerPrefs,
1335                           NULL, 0, "list a client's server preferences ");
1336     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1337                 "server where command will execute");
1338     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1339     SetupCommonCmdArgs(ts);
1340
1341     ts = cmd_CreateSyntax("ClientCMListCells", DoClientCMListCells, NULL, 0,
1342                           "list a client's CellServDB ");
1343     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1344                 "server where command will execute");
1345     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1346     SetupCommonCmdArgs(ts);
1347
1348     ts = cmd_CreateSyntax("ClientCMLocalCell", DoClientCMLocalCell, NULL, 0,
1349                           "get the name of the client's local cell");
1350     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1351                 "server where command will execute");
1352     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1353     SetupCommonCmdArgs(ts);
1354
1355     ts = cmd_CreateSyntax("ClientCMClientConfig", DoClientCMClientConfig, NULL, 0,
1356                           "get the client's cache configuration");
1357     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1358                 "server where command will execute");
1359     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1360     SetupCommonCmdArgs(ts);
1361 }