2 * Copyright 2000, International Business Machines Corporation and others.
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
11 * This file implements the client related funtions for afscp
14 #include <afsconfig.h>
15 #include <afs/param.h>
19 #include <afs/cellconfig.h>
20 #include <afs/bosint.h>
21 #include <rx/rxstat.h>
22 #include <afs/afsint.h>
23 #define FSINT_COMMON_XG
24 #include <afs/afscbint.h>
25 #include <afs/kauth.h>
26 #include <afs/kautils.h>
27 #include <afs/ptint.h>
28 #include <afs/ptserver.h>
29 #include <afs/vldbint.h>
30 #include <afs/volint.h>
31 #include <afs/volser.h>
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)
45 * The purpose of these functions is to allow a mapping from interfaceId
46 * to text representations of server process names and function names.
50 const char **functionList;
51 size_t functionListLen;
52 } interface_function_list_t, *interface_function_list_p;
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.
65 * To get around this problem I hand initialize this array on NT only
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;
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;
115 static interface_function_list_t afs_server = {
116 RXAFS_function_names,
117 RXAFS_NO_OF_STAT_FUNCS
120 static interface_function_list_t afscb_server = {
121 RXAFSCB_function_names,
122 RXAFSCB_NO_OF_STAT_FUNCS
125 static interface_function_list_t bos_server = {
127 BOZO_NO_OF_STAT_FUNCS
130 static interface_function_list_t kauth_kaa_server = {
135 static interface_function_list_t kauth_kam_server = {
140 static interface_function_list_t kauth_kat_server = {
145 static interface_function_list_t pts_server = {
150 static interface_function_list_t rxstat_server = {
151 RXSTATS_function_names,
152 RXSTATS_NO_OF_STAT_FUNCS
155 static interface_function_list_t ubik_disk_server = {
157 DISK_NO_OF_STAT_FUNCS,
160 static interface_function_list_t ubik_vote_server = {
162 VOTE_NO_OF_STAT_FUNCS,
165 static interface_function_list_t vl_server = {
170 static interface_function_list_t vol_server = {
171 AFSVolfunction_names,
172 AFSVolNO_OF_STAT_FUNCS
175 #endif /* AFS_NT40_ENV */
177 static interface_function_list_t unknown_server = {
183 afs_uint32 interfaceId;
184 const char *interfaceName;
185 interface_function_list_p functionList;
186 } interface_t, *interface_p;
188 interface_t int_list[] = {
238 * Note the code below assumes that the following entry is the last entry
242 {0, "unknown", &unknown_server}
250 DoClientLocalCellGet(struct cmd_syndesc *as, void *arock)
253 char cellName[MAXCELLCHARS];
255 if (!afsclient_LocalCellGet(cellName, &st)) {
256 ERR_ST_EXT("afsclient_LocalCellGet", st);
259 printf("This machine belongs to cell: %s\n", cellName);
265 DoClientMountPointCreate(struct cmd_syndesc *as, void *arock)
267 typedef enum { DIRECTORY, VOLUME, READWRITE,
269 } DoClientMountPointCreate_parm_t;
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;
276 if (as->parms[DIRECTORY].items) {
277 directory = as->parms[DIRECTORY].items->data;
280 if (as->parms[VOLUME].items) {
281 volume = as->parms[VOLUME].items->data;
284 if (as->parms[READWRITE].items) {
285 vol_type = READ_WRITE;
288 if (as->parms[CHECK].items) {
289 vol_check = CHECK_VOLUME;
292 if (!afsclient_MountPointCreate
293 (cellHandle, directory, volume, vol_type, vol_check, &st)) {
294 ERR_ST_EXT("afsclient_MountPointCreate", st);
301 Print_afs_serverEntry_p(afs_serverEntry_p serv, const char *prefix)
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);
309 if (serv->serverType & FILE_SERVER) {
310 printf("%s\tIt is a file server\n", prefix);
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++]);
319 DoClientAFSServerGet(struct cmd_syndesc *as, void *arock)
321 typedef enum { SERVER } DoClientAFSServerGet_parm_t;
323 const char *server = NULL;
324 afs_serverEntry_t entry;
326 if (as->parms[SERVER].items) {
327 server = as->parms[SERVER].items->data;
330 if (!afsclient_AFSServerGet(cellHandle, server, &entry, &st)) {
331 ERR_ST_EXT("afsclient_AFSServerGet", st);
334 Print_afs_serverEntry_p(&entry, "");
340 DoClientAFSServerList(struct cmd_syndesc *as, void *arock)
343 afs_serverEntry_t entry;
346 if (!afsclient_AFSServerGetBegin(cellHandle, &iter, &st)) {
347 ERR_ST_EXT("afsclient_AFSServerGetBegin", st);
350 while (afsclient_AFSServerGetNext(iter, &entry, &st)) {
351 Print_afs_serverEntry_p(&entry, "");
354 if (st != ADMITERATORDONE) {
355 ERR_ST_EXT("afsclient_AFSServerGetNext", st);
358 if (!afsclient_AFSServerGetDone(iter, &st)) {
359 ERR_ST_EXT("afsclient_AFSServerGetDone", st);
367 Print_afs_RPCStatsState_p(afs_RPCStatsState_p state, const char *prefix)
369 printf("%sThe rpc stats state is: ", prefix);
371 case AFS_RPC_STATS_DISABLED:
372 printf("disabled\n");
374 case AFS_RPC_STATS_ENABLED:
382 afs_stat_source_t value;
383 } afs_type_map_t, *afs_type_map_p;
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},
397 GetStatPortFromString(const char *type, int *port)
403 tport = strtol(type, &end, 0);
404 if (tport == 0 || end == type || *end != '\0') {
413 GetStatSourceFromString(const char *type, afs_stat_source_t * src, int *port)
416 size_t type_len = strlen(type);
418 for (i = 0; (map[i].tag) && strncasecmp(type, map[i].tag, type_len); i++);
420 if (map[i].tag == 0) {
422 * Try to convert string to port number
424 if (GetStatPortFromString(type, port)) {
429 "couldn't convert server to type, try one of the "
431 for (i = 0; map[i].tag; i++) {
432 fprintf(stderr, "%s ", map[i].tag);
445 } afs_stat_type_t, *afs_stat_type_p;
447 static afs_stat_type_t
448 GetStatTypeFromString(const char *type)
452 if (!strcmp(type, "peer")) {
454 } else if (!strcmp(type, "process")) {
455 rc = AFS_PROCESS_STATS;
457 ERR_EXT("stat_type must be process or peer");
464 DoClientRPCStatsStateGet(struct cmd_syndesc *as, void *arock)
466 typedef enum { SERVER, PROCESS,
468 } DoClientRPCStatsStateGet_parm_t;
470 struct rx_connection *conn;
471 afs_stat_source_t type;
474 afs_stat_type_t which = 0;
475 afs_RPCStatsState_t state;
477 if (as->parms[PROCESS].items) {
479 GetStatSourceFromString(as->parms[PROCESS].items->data, &type,
483 if (as->parms[STAT_TYPE].items) {
484 which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
487 if (as->parms[SERVER].items) {
489 if (!afsclient_RPCStatOpen
490 (cellHandle, as->parms[SERVER].items->data, type, &conn,
492 ERR_ST_EXT("afsclient_RPCStatOpen", st);
495 if (!afsclient_RPCStatOpenPort
496 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
498 ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
503 if (which == AFS_PEER_STATS) {
504 if (!util_RPCStatsStateGet
505 (conn, RXSTATS_QueryPeerRPCStats, &state, &st)) {
506 ERR_ST_EXT("util_RPCStatsStateGet", st);
509 if (!util_RPCStatsStateGet
510 (conn, RXSTATS_QueryProcessRPCStats, &state, &st)) {
511 ERR_ST_EXT("util_RPCStatsStateGet", st);
515 Print_afs_RPCStatsState_p(&state, "");
517 afsclient_RPCStatClose(conn, 0);
523 DoClientRPCStatsStateEnable(struct cmd_syndesc *as, void *arock)
525 typedef enum { SERVER, PROCESS, STAT_TYPE } DoClientRPCStatsEnable_parm_t;
527 struct rx_connection *conn;
528 afs_stat_source_t type;
531 afs_stat_type_t which = 0;
533 if (as->parms[PROCESS].items) {
535 GetStatSourceFromString(as->parms[PROCESS].items->data, &type,
539 if (as->parms[STAT_TYPE].items) {
540 which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
543 if (as->parms[SERVER].items) {
545 if (!afsclient_RPCStatOpen
546 (cellHandle, as->parms[SERVER].items->data, type, &conn,
548 ERR_ST_EXT("afsclient_RPCStatOpen", st);
551 if (!afsclient_RPCStatOpenPort
552 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
554 ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
559 if (which == AFS_PEER_STATS) {
560 if (!util_RPCStatsStateEnable(conn, RXSTATS_EnablePeerRPCStats, &st)) {
561 ERR_ST_EXT("util_RPCStatsStateEnable", st);
564 if (!util_RPCStatsStateEnable
565 (conn, RXSTATS_EnableProcessRPCStats, &st)) {
566 ERR_ST_EXT("util_RPCStatsStateEnable", st);
570 afsclient_RPCStatClose(conn, 0);
576 DoClientRPCStatsStateDisable(struct cmd_syndesc *as, void *arock)
578 typedef enum { SERVER, PROCESS,
580 } DoClientRPCStatsDisable_parm_t;
582 struct rx_connection *conn;
583 afs_stat_source_t type;
586 afs_stat_type_t which = 0;
588 if (as->parms[PROCESS].items) {
590 GetStatSourceFromString(as->parms[PROCESS].items->data, &type,
594 if (as->parms[STAT_TYPE].items) {
595 which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
598 if (as->parms[SERVER].items) {
600 if (!afsclient_RPCStatOpen
601 (cellHandle, as->parms[SERVER].items->data, type, &conn,
603 ERR_ST_EXT("afsclient_RPCStatOpen", st);
606 if (!afsclient_RPCStatOpenPort
607 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
609 ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
614 if (which == AFS_PEER_STATS) {
615 if (!util_RPCStatsStateDisable
616 (conn, RXSTATS_DisablePeerRPCStats, &st)) {
617 ERR_ST_EXT("util_RPCStatsStateDisable", st);
620 if (!util_RPCStatsStateDisable
621 (conn, RXSTATS_DisableProcessRPCStats, &st)) {
622 ERR_ST_EXT("util_RPCStatsStateDisable", st);
626 afsclient_RPCStatClose(conn, 0);
632 Print_afs_RPCStats_p(afs_RPCStats_p stat, interface_function_list_p f_list,
635 afs_int32 index = stat->s.stats_v1.func_index;
637 if (index > ((afs_int32) f_list->functionListLen - 1)) {
638 printf("%sUnknown function ", prefix);
640 printf("%s%s ", prefix,
641 f_list->functionList[stat->s.stats_v1.func_index]);
644 if (!hiszero(stat->s.stats_v1.invocations)) {
645 printf("%sinvoc (%u.%u) bytes_sent (%u.%u) bytes_rcvd (%u.%u)\n",
646 prefix, hgethi(stat->s.stats_v1.invocations),
647 hgetlo(stat->s.stats_v1.invocations),
648 hgethi(stat->s.stats_v1.bytes_sent),
649 hgetlo(stat->s.stats_v1.bytes_sent),
650 hgethi(stat->s.stats_v1.bytes_rcvd),
651 hgetlo(stat->s.stats_v1.bytes_rcvd)
653 printf("\tqsum %d.%06d\tqsqr %d.%06d"
654 "\tqmin %d.%06d\tqmax %d.%06d\n",
655 stat->s.stats_v1.queue_time_sum.sec,
656 stat->s.stats_v1.queue_time_sum.usec,
657 stat->s.stats_v1.queue_time_sum_sqr.sec,
658 stat->s.stats_v1.queue_time_sum_sqr.usec,
659 stat->s.stats_v1.queue_time_min.sec,
660 stat->s.stats_v1.queue_time_min.usec,
661 stat->s.stats_v1.queue_time_max.sec,
662 stat->s.stats_v1.queue_time_max.usec);
663 printf("\txsum %d.%06d\txsqr %d.%06d"
664 "\txmin %d.%06d\txmax %d.%06d\n",
665 stat->s.stats_v1.execution_time_sum.sec,
666 stat->s.stats_v1.execution_time_sum.usec,
667 stat->s.stats_v1.execution_time_sum_sqr.sec,
668 stat->s.stats_v1.execution_time_sum_sqr.usec,
669 stat->s.stats_v1.execution_time_min.sec,
670 stat->s.stats_v1.execution_time_min.usec,
671 stat->s.stats_v1.execution_time_max.sec,
672 stat->s.stats_v1.execution_time_max.usec);
674 printf("never invoked\n");
679 DoClientRPCStatsList(struct cmd_syndesc *as, void *arock)
681 typedef enum { SERVER, PROCESS, STAT_TYPE } DoClientRPCStatsList_parm_t;
683 struct rx_connection *conn;
684 afs_stat_source_t type;
687 afs_stat_type_t which = 0;
688 afs_RPCStats_t stats;
693 (pthread_func_list_done
694 || pthread_once(&pthread_func_list_once, cr_list));
697 if (as->parms[PROCESS].items) {
699 GetStatSourceFromString(as->parms[PROCESS].items->data, &type,
703 if (as->parms[STAT_TYPE].items) {
704 which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
707 if (as->parms[SERVER].items) {
709 if (!afsclient_RPCStatOpen
710 (cellHandle, as->parms[SERVER].items->data, type, &conn,
712 ERR_ST_EXT("afsclient_RPCStatOpen", st);
715 if (!afsclient_RPCStatOpenPort
716 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
718 ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
723 if (which == AFS_PEER_STATS) {
724 if (!util_RPCStatsGetBegin
725 (conn, RXSTATS_RetrievePeerRPCStats, &iter, &st)) {
726 ERR_ST_EXT("util_RPCStatsGetBegin", st);
729 if (!util_RPCStatsGetBegin
730 (conn, RXSTATS_RetrieveProcessRPCStats, &iter, &st)) {
731 ERR_ST_EXT("util_RPCStatsGetBegin", st);
735 printf("Listing rpc stats at server %s process %s:\n",
736 as->parms[SERVER].items->data, as->parms[PROCESS].items->data);
738 while (util_RPCStatsGetNext(iter, &stats, &st)) {
741 * Print a new heading for each stat collection
744 if (stats.s.stats_v1.func_index == 0) {
749 * Look up the interface in our list
752 for (i = 0; i < ((sizeof(int_list) - 1) / sizeof(interface_t));
754 if (stats.s.stats_v1.interfaceId == int_list[i].interfaceId) {
760 * Print out a meaningful header for each stat collection
763 if (which == AFS_PEER_STATS) {
765 ina.s_addr = htonl(stats.s.stats_v1.remote_peer);
767 printf("%s stats for remote peer located at %s port %u "
768 "%s %s as a %s via the %s interface\n",
769 as->parms[PROCESS].items->data, inet_ntoa(ina),
770 stats.s.stats_v1.remote_port,
772 remote_is_server) ? "accessed by" : "accessing"),
773 as->parms[PROCESS].items->data,
775 remote_is_server) ? "client" : "server"),
776 int_list[i].interfaceName);
778 printf("%s stats for the %s interface " "accessed as a %s\n",
779 as->parms[PROCESS].items->data,
780 int_list[i].interfaceName,
782 remote_is_server) ? "client" : "server")
786 Print_afs_RPCStats_p(&stats, int_list[i].functionList, " ");
789 if (st != ADMITERATORDONE) {
790 ERR_ST_EXT("util_RPCStatsGetNext", st);
793 if (!util_RPCStatsGetDone(iter, &st)) {
794 ERR_ST_EXT("util_RPCStatsGetDone", st);
797 afsclient_RPCStatClose(conn, 0);
803 DoClientRPCStatsClear(struct cmd_syndesc *as, void *arock)
805 typedef enum { SERVER, PROCESS, STAT_TYPE, CLEAR_ALL, CLEAR_INVOCATIONS,
806 CLEAR_BYTES_SENT, CLEAR_BYTES_RCVD,
807 CLEAR_QUEUE_TIME_SUM, CLEAR_QUEUE_TIME_SQUARE,
808 CLEAR_QUEUE_TIME_MIN, CLEAR_QUEUE_TIME_MAX,
809 CLEAR_EXEC_TIME_SUM, CLEAR_EXEC_TIME_SQUARE,
810 CLEAR_EXEC_TIME_MIN, CLEAR_EXEC_TIME_MAX
811 } DoClientRPCStatsClear_parm_t;
813 struct rx_connection *conn;
814 afs_stat_source_t type;
817 afs_stat_type_t which = 0;
818 afs_RPCStatsClearFlag_t flag = 0;
822 if (as->parms[PROCESS].items) {
824 GetStatSourceFromString(as->parms[PROCESS].items->data, &type,
828 if (as->parms[STAT_TYPE].items) {
829 which = GetStatTypeFromString(as->parms[STAT_TYPE].items->data);
832 if (as->parms[SERVER].items) {
834 if (!afsclient_RPCStatOpen
835 (cellHandle, as->parms[SERVER].items->data, type, &conn,
837 ERR_ST_EXT("afsclient_RPCStatOpen", st);
840 if (!afsclient_RPCStatOpenPort
841 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
843 ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
848 if (as->parms[CLEAR_ALL].items) {
851 flag = AFS_RX_STATS_CLEAR_ALL;
854 if (as->parms[CLEAR_INVOCATIONS].items) {
856 ERR_EXT("cannot specify additional flags when "
857 "specifying clear_all");
860 flag |= AFS_RX_STATS_CLEAR_INVOCATIONS;
863 if (as->parms[CLEAR_BYTES_SENT].items) {
865 ERR_EXT("cannot specify additional flags when "
866 "specifying clear_all");
869 flag |= AFS_RX_STATS_CLEAR_BYTES_SENT;
872 if (as->parms[CLEAR_BYTES_RCVD].items) {
874 ERR_EXT("cannot specify additional flags when "
875 "specifying clear_all");
878 flag |= AFS_RX_STATS_CLEAR_BYTES_RCVD;
881 if (as->parms[CLEAR_QUEUE_TIME_SUM].items) {
883 ERR_EXT("cannot specify additional flags when "
884 "specifying clear_all");
887 flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM;
890 if (as->parms[CLEAR_QUEUE_TIME_SQUARE].items) {
892 ERR_EXT("cannot specify additional flags when "
893 "specifying clear_all");
896 flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE;
899 if (as->parms[CLEAR_QUEUE_TIME_MIN].items) {
901 ERR_EXT("cannot specify additional flags when "
902 "specifying clear_all");
905 flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN;
908 if (as->parms[CLEAR_QUEUE_TIME_MAX].items) {
910 ERR_EXT("cannot specify additional flags when "
911 "specifying clear_all");
914 flag |= AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX;
917 if (as->parms[CLEAR_EXEC_TIME_SUM].items) {
919 ERR_EXT("cannot specify additional flags when "
920 "specifying clear_all");
923 flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_SUM;
926 if (as->parms[CLEAR_EXEC_TIME_SQUARE].items) {
928 ERR_EXT("cannot specify additional flags when "
929 "specifying clear_all");
932 flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE;
935 if (as->parms[CLEAR_EXEC_TIME_MIN].items) {
937 ERR_EXT("cannot specify additional flags when "
938 "specifying clear_all");
941 flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_MIN;
944 if (as->parms[CLEAR_EXEC_TIME_MAX].items) {
946 ERR_EXT("cannot specify additional flags when "
947 "specifying clear_all");
950 flag |= AFS_RX_STATS_CLEAR_EXEC_TIME_MAX;
954 ERR_EXT("you must specify something to clear");
957 if (which == AFS_PEER_STATS) {
958 if (!util_RPCStatsClear(conn, RXSTATS_ClearPeerRPCStats, flag, &st)) {
959 ERR_ST_EXT("util_RPCStatsClear", st);
962 if (!util_RPCStatsClear
963 (conn, RXSTATS_ClearProcessRPCStats, flag, &st)) {
964 ERR_ST_EXT("util_RPCStatsClear", st);
968 afsclient_RPCStatClose(conn, 0);
974 DoClientRPCStatsVersionGet(struct cmd_syndesc *as, void *arock)
976 typedef enum { SERVER, PROCESS } DoClientRPCStatsVersionGet_parm_t;
978 struct rx_connection *conn;
979 afs_stat_source_t type;
982 afs_RPCStatsVersion_t version;
984 if (as->parms[PROCESS].items) {
986 GetStatSourceFromString(as->parms[PROCESS].items->data, &type,
990 if (as->parms[SERVER].items) {
992 if (!afsclient_RPCStatOpen
993 (cellHandle, as->parms[SERVER].items->data, type, &conn,
995 ERR_ST_EXT("afsclient_RPCStatOpen", st);
998 if (!afsclient_RPCStatOpenPort
999 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
1001 ERR_ST_EXT("afsclient_RPCStatOpenPort", st);
1006 if (!util_RPCStatsVersionGet(conn, &version, &st)) {
1007 ERR_ST_EXT("util_RPCStatsVersionGet", st);
1010 printf("the rpc stat version number is %u\n", version);
1012 afsclient_RPCStatClose(conn, 0);
1018 Print_afs_CMServerPref_p(afs_CMServerPref_p pref)
1022 taddr = pref->ipAddr;
1023 printf("%d.%d.%d.%d\t\t\t%d\n", (taddr >> 24) & 0xff,
1024 (taddr >> 16) & 0xff, (taddr >> 8) & 0xff, taddr & 0xff,
1029 DoClientCMGetServerPrefs(struct cmd_syndesc *as, void *arock)
1031 afs_status_t st = 0;
1032 typedef enum { SERVER, PORT } DoClientCMGetServerPrefs_parm_t;
1033 struct rx_connection *conn;
1034 int srvrPort = AFSCONF_CALLBACKPORT;
1035 afs_CMServerPref_t prefs;
1039 (pthread_func_list_done
1040 || pthread_once(&pthread_func_list_once, cr_list));
1043 if (as->parms[PORT].items) {
1044 if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1045 ERR_EXT("Couldn't undertand port number");
1049 if (as->parms[SERVER].items) {
1050 if (!afsclient_CMStatOpenPort
1051 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
1053 ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1057 if (!util_CMGetServerPrefsBegin(conn, &iter, &st)) {
1058 ERR_ST_EXT("util_CMGetServerPrefsBegin", st);
1061 printf("Listing CellServDB for %s at port %s:\n",
1062 as->parms[SERVER].items->data, as->parms[PORT].items->data);
1064 while (util_CMGetServerPrefsNext(iter, &prefs, &st)) {
1066 Print_afs_CMServerPref_p(&prefs);
1069 if (st != ADMITERATORDONE) {
1070 ERR_ST_EXT("util_CMGetServerPrefsNext", st);
1073 if (!util_CMGetServerPrefsDone(iter, &st)) {
1074 ERR_ST_EXT("util_CMGetServerPrefsDone", st);
1077 afsclient_CMStatClose(conn, 0);
1083 Print_afs_CMListCell_p(afs_CMListCell_p cellInfo)
1088 printf("Cell %s on hosts", cellInfo->cellname);
1089 for (i = 0; i < UTIL_MAX_CELL_HOSTS && cellInfo->serverAddr[i]; i++) {
1090 taddr = cellInfo->serverAddr[i];
1091 printf(" %d.%d.%d.%d", (taddr >> 24) & 0xff, (taddr >> 16) & 0xff,
1092 (taddr >> 8) & 0xff, taddr & 0xff);
1098 DoClientCMListCells(struct cmd_syndesc *as, void *arock)
1100 afs_status_t st = 0;
1101 typedef enum { SERVER, PORT } DoClientCMListCells_parm_t;
1102 struct rx_connection *conn;
1103 int srvrPort = AFSCONF_CALLBACKPORT;
1104 afs_CMListCell_t cellInfo;
1108 (pthread_func_list_done
1109 || pthread_once(&pthread_func_list_once, cr_list));
1112 if (as->parms[PORT].items) {
1113 if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1114 ERR_EXT("Couldn't undertand port number");
1118 if (as->parms[SERVER].items) {
1119 if (!afsclient_CMStatOpenPort
1120 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
1122 ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1126 if (!util_CMListCellsBegin(conn, &iter, &st)) {
1127 ERR_ST_EXT("util_CMListCellsBegin", st);
1130 printf("Listing CellServDB for %s at port %s:\n",
1131 as->parms[SERVER].items->data, as->parms[PORT].items->data);
1133 while (util_CMListCellsNext(iter, &cellInfo, &st)) {
1135 Print_afs_CMListCell_p(&cellInfo);
1138 if (st != ADMITERATORDONE) {
1139 ERR_ST_EXT("util_CMListCellsNext", st);
1142 if (!util_CMListCellsDone(iter, &st)) {
1143 ERR_ST_EXT("util_CMListCellsDone", st);
1146 afsclient_CMStatClose(conn, 0);
1152 DoClientCMLocalCell(struct cmd_syndesc *as, void *arock)
1154 afs_status_t st = 0;
1155 typedef enum { SERVER, PORT } DoClientCMLocalCell_parm_t;
1156 struct rx_connection *conn;
1157 int srvrPort = AFSCONF_CALLBACKPORT;
1158 afs_CMCellName_t cellname;
1161 (pthread_func_list_done
1162 || pthread_once(&pthread_func_list_once, cr_list));
1165 if (as->parms[PORT].items) {
1166 if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1167 ERR_EXT("Couldn't undertand port number");
1171 if (as->parms[SERVER].items) {
1172 if (!afsclient_CMStatOpenPort
1173 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
1175 ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1179 if (!util_CMLocalCell(conn, cellname, &st)) {
1180 ERR_ST_EXT("util_CMLocalCell", st);
1183 printf("Client %s (port %s) is in cell %s\n",
1184 as->parms[SERVER].items->data, as->parms[PORT].items->data,
1187 afsclient_CMStatClose(conn, 0);
1193 Print_afs_ClientConfig_p(afs_ClientConfig_p config)
1195 printf(" clientVersion: %d\n", config->clientVersion);
1196 printf(" serverVersion: %d\n", config->serverVersion);
1197 printf(" nChunkFiles: %d\n", config->c.config_v1.nChunkFiles);
1198 printf(" nStatCaches: %d\n", config->c.config_v1.nStatCaches);
1199 printf(" nDataCaches: %d\n", config->c.config_v1.nDataCaches);
1200 printf(" nVolumeCaches: %d\n", config->c.config_v1.nVolumeCaches);
1201 printf(" firstChunkSize: %d\n", config->c.config_v1.firstChunkSize);
1202 printf(" otherChunkSize: %d\n", config->c.config_v1.otherChunkSize);
1203 printf(" cacheSize: %d\n", config->c.config_v1.cacheSize);
1204 printf(" setTime: %d\n", config->c.config_v1.setTime);
1205 printf(" memCache: %d\n", config->c.config_v1.memCache);
1210 DoClientCMClientConfig(struct cmd_syndesc *as, void *arock)
1212 afs_status_t st = 0;
1213 typedef enum { SERVER, PORT } DoClientCMLocalCell_parm_t;
1214 struct rx_connection *conn;
1215 int srvrPort = AFSCONF_CALLBACKPORT;
1216 afs_ClientConfig_t config;
1219 (pthread_func_list_done
1220 || pthread_once(&pthread_func_list_once, cr_list));
1223 if (as->parms[PORT].items) {
1224 if (!GetStatPortFromString(as->parms[PORT].items->data, &srvrPort)) {
1225 ERR_EXT("Couldn't undertand port number");
1229 if (as->parms[SERVER].items) {
1230 if (!afsclient_CMStatOpenPort
1231 (cellHandle, as->parms[SERVER].items->data, srvrPort, &conn,
1233 ERR_ST_EXT("afsclient_CMStatOpenPort", st);
1237 if (!util_CMClientConfig(conn, &config, &st)) {
1238 ERR_ST_EXT("util_CMClientConfig", st);
1241 printf("Cache configuration for client %s (port %s):\n\n",
1242 as->parms[SERVER].items->data, as->parms[PORT].items->data);
1244 Print_afs_ClientConfig_p(&config);
1248 afsclient_CMStatClose(conn, 0);
1254 SetupClientAdminCmd(void)
1256 struct cmd_syndesc *ts;
1258 ts = cmd_CreateSyntax("ClientLocalCellGet", DoClientLocalCellGet, NULL,
1259 "get the name of this machine's cell");
1260 SetupCommonCmdArgs(ts);
1262 ts = cmd_CreateSyntax("ClientMountPointCreate", DoClientMountPointCreate,
1263 NULL, "create a mount point");
1264 cmd_AddParm(ts, "-directory", CMD_SINGLE, CMD_REQUIRED,
1265 "directory where mount point will be created");
1266 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
1267 "the name of the volume to mount");
1268 cmd_AddParm(ts, "-readwrite", CMD_FLAG, CMD_OPTIONAL,
1269 "mount a read write volume");
1270 cmd_AddParm(ts, "-check", CMD_FLAG, CMD_OPTIONAL,
1271 "check that the volume exists before mounting");
1272 SetupCommonCmdArgs(ts);
1274 ts = cmd_CreateSyntax("ClientAFSServerGet", DoClientAFSServerGet, NULL,
1275 "retrieve information about an afs server");
1276 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
1277 SetupCommonCmdArgs(ts);
1279 ts = cmd_CreateSyntax("ClientAFSServerList", DoClientAFSServerList, NULL,
1280 "retrieve information about all afs "
1281 "servers in a cell");
1282 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1283 "server where command will execute");
1284 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1285 "process to query <bosserver fileserver ptserver "
1286 "kaserver client vlserver volserver>");
1287 cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1288 "stats to retrieve <peer or process>");
1289 SetupCommonCmdArgs(ts);
1291 ts = cmd_CreateSyntax("ClientRPCStatsStateGet", DoClientRPCStatsStateGet,
1292 NULL, "retrieve the rpc stat collection state");
1293 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1294 "server where command will execute");
1295 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1296 "process to query <bosserver fileserver ptserver "
1297 "kaserver client vlserver volserver>");
1298 cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1299 "stats to retrieve <peer or process>");
1300 SetupCommonCmdArgs(ts);
1302 ts = cmd_CreateSyntax("ClientRPCStatsStateEnable",
1303 DoClientRPCStatsStateEnable, NULL,
1304 "set the rpc stat collection state to on");
1305 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1306 "server where command will execute");
1307 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1308 "process to query <bosserver fileserver ptserver "
1309 "kaserver client vlserver volserver>");
1310 cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1311 "stats to retrieve <peer or process>");
1312 SetupCommonCmdArgs(ts);
1314 ts = cmd_CreateSyntax("ClientRPCStatsStateDisable",
1315 DoClientRPCStatsStateDisable, NULL,
1316 "set the rpc stat collection state to off");
1317 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1318 "server where command will execute");
1319 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1320 "process to query <bosserver fileserver ptserver "
1321 "kaserver client vlserver volserver>");
1322 cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1323 "stats to retrieve <peer or process>");
1324 SetupCommonCmdArgs(ts);
1326 ts = cmd_CreateSyntax("ClientRPCStatsList", DoClientRPCStatsList, NULL,
1327 "list the rpc stats");
1328 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1329 "server where command will execute");
1330 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1331 "process to query <bosserver fileserver ptserver "
1332 "kaserver client vlserver volserver>");
1333 cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1334 "stats to retrieve <peer or process>");
1335 SetupCommonCmdArgs(ts);
1337 ts = cmd_CreateSyntax("ClientRPCStatsClear", DoClientRPCStatsClear, NULL,
1338 "reset rpc stat counters");
1339 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1340 "server where command will execute");
1341 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1342 "process to query <bosserver fileserver ptserver "
1343 "kaserver client vlserver volserver>");
1344 cmd_AddParm(ts, "-stat_type", CMD_SINGLE, CMD_REQUIRED,
1345 "stats to retrieve <peer or process>");
1346 cmd_AddParm(ts, "-clear_all", CMD_FLAG, CMD_OPTIONAL,
1347 "clear all existing counters");
1348 cmd_AddParm(ts, "-clear_invocations", CMD_FLAG, CMD_OPTIONAL,
1349 "clear invocation count");
1350 cmd_AddParm(ts, "-clear_bytes_sent", CMD_FLAG, CMD_OPTIONAL,
1351 "clear bytes_sent count");
1352 cmd_AddParm(ts, "-clear_bytes_rcvd", CMD_FLAG, CMD_OPTIONAL,
1353 "clear bytes_rcvd count");
1354 cmd_AddParm(ts, "-clear_queue_time_sum", CMD_FLAG, CMD_OPTIONAL,
1355 "clear queue time sum");
1356 cmd_AddParm(ts, "-clear_queue_time_square", CMD_FLAG, CMD_OPTIONAL,
1357 "clear queue time square");
1358 cmd_AddParm(ts, "-clear_queue_time_min", CMD_FLAG, CMD_OPTIONAL,
1359 "clear queue time min");
1360 cmd_AddParm(ts, "-clear_queue_time_max", CMD_FLAG, CMD_OPTIONAL,
1361 "clear queue time max");
1362 cmd_AddParm(ts, "-clear_exec_time_sum", CMD_FLAG, CMD_OPTIONAL,
1363 "clear exec time sum");
1364 cmd_AddParm(ts, "-clear_exec_time_square", CMD_FLAG, CMD_OPTIONAL,
1365 "clear exec time square");
1366 cmd_AddParm(ts, "-clear_exec_time_min", CMD_FLAG, CMD_OPTIONAL,
1367 "clear exec time min");
1368 cmd_AddParm(ts, "-clear_exec_time_max", CMD_FLAG, CMD_OPTIONAL,
1369 "clear exec time max");
1370 SetupCommonCmdArgs(ts);
1372 ts = cmd_CreateSyntax("ClientRPCStatsVersionGet",
1373 DoClientRPCStatsVersionGet, NULL,
1374 "list the server's rpc stats version");
1375 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1376 "server where command will execute");
1377 cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
1378 "process to query <bosserver fileserver ptserver "
1379 "kaserver client vlserver volserver>");
1380 SetupCommonCmdArgs(ts);
1382 ts = cmd_CreateSyntax("ClientCMGetServerPrefs", DoClientCMGetServerPrefs,
1383 NULL, "list a client's server preferences ");
1384 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1385 "server where command will execute");
1386 cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1387 SetupCommonCmdArgs(ts);
1389 ts = cmd_CreateSyntax("ClientCMListCells", DoClientCMListCells, NULL,
1390 "list a client's CellServDB ");
1391 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1392 "server where command will execute");
1393 cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1394 SetupCommonCmdArgs(ts);
1396 ts = cmd_CreateSyntax("ClientCMLocalCell", DoClientCMLocalCell, NULL,
1397 "get the name of the client's local cell");
1398 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1399 "server where command will execute");
1400 cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1401 SetupCommonCmdArgs(ts);
1403 ts = cmd_CreateSyntax("ClientCMClientConfig", DoClientCMClientConfig, NULL,
1404 "get the client's cache configuration");
1405 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1406 "server where command will execute");
1407 cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
1408 SetupCommonCmdArgs(ts);