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