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>
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>
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 enum { DIRECTORY
, VOLUME
, READWRITE
,
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
)
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_proc_tESS_STATS
;
457 ERR_EXT("stat_type must be process or peer");
464 DoClientRPCStatsStateGet(struct cmd_syndesc
*as
, void *arock
)
466 enum { SERVER
, PROCESS
,
470 struct rx_connection
*conn
;
471 afs_stat_source_t type
;
474 afs_stat_type_t which
= 0;
475 afs_RPCStatsState_t state
;
477 typeIsValid
= GetStatSourceFromString(as
->parms
[PROCESS
].items
->data
,
480 which
= GetStatTypeFromString(as
->parms
[STAT_TYPE
].items
->data
);
483 if (!afsclient_RPCStatOpen(cellHandle
,
484 as
->parms
[SERVER
].items
->data
,
486 ERR_ST_EXT("afsclient_RPCStatOpen", st
);
489 if (!afsclient_RPCStatOpenPort(cellHandle
,
490 as
->parms
[SERVER
].items
->data
,
491 srvrPort
, &conn
, &st
)) {
492 ERR_ST_EXT("afsclient_RPCStatOpenPort", st
);
496 if (which
== AFS_PEER_STATS
) {
497 if (!util_RPCStatsStateGet
498 (conn
, RXSTATS_QueryPeerRPCStats
, &state
, &st
)) {
499 ERR_ST_EXT("util_RPCStatsStateGet", st
);
502 if (!util_RPCStatsStateGet
503 (conn
, RXSTATS_QueryProcessRPCStats
, &state
, &st
)) {
504 ERR_ST_EXT("util_RPCStatsStateGet", st
);
508 Print_afs_RPCStatsState_p(&state
, "");
510 afsclient_RPCStatClose(conn
, 0);
516 DoClientRPCStatsStateEnable(struct cmd_syndesc
*as
, void *arock
)
518 enum { SERVER
, PROCESS
, STAT_TYPE
};
520 struct rx_connection
*conn
;
521 afs_stat_source_t type
;
524 afs_stat_type_t which
;
526 typeIsValid
= GetStatSourceFromString(as
->parms
[PROCESS
].items
->data
,
529 which
= GetStatTypeFromString(as
->parms
[STAT_TYPE
].items
->data
);
532 if (!afsclient_RPCStatOpen(cellHandle
,
533 as
->parms
[SERVER
].items
->data
,
535 ERR_ST_EXT("afsclient_RPCStatOpen", st
);
538 if (!afsclient_RPCStatOpenPort(cellHandle
,
539 as
->parms
[SERVER
].items
->data
,
540 srvrPort
, &conn
, &st
)) {
541 ERR_ST_EXT("afsclient_RPCStatOpenPort", st
);
545 if (which
== AFS_PEER_STATS
) {
546 if (!util_RPCStatsStateEnable(conn
, RXSTATS_EnablePeerRPCStats
, &st
)) {
547 ERR_ST_EXT("util_RPCStatsStateEnable", st
);
550 if (!util_RPCStatsStateEnable
551 (conn
, RXSTATS_EnableProcessRPCStats
, &st
)) {
552 ERR_ST_EXT("util_RPCStatsStateEnable", st
);
556 afsclient_RPCStatClose(conn
, 0);
562 DoClientRPCStatsStateDisable(struct cmd_syndesc
*as
, void *arock
)
564 enum { SERVER
, PROCESS
,
568 struct rx_connection
*conn
;
569 afs_stat_source_t type
;
572 afs_stat_type_t which
;
574 typeIsValid
= GetStatSourceFromString(as
->parms
[PROCESS
].items
->data
,
577 which
= GetStatTypeFromString(as
->parms
[STAT_TYPE
].items
->data
);
580 if (!afsclient_RPCStatOpen(cellHandle
,
581 as
->parms
[SERVER
].items
->data
,
583 ERR_ST_EXT("afsclient_RPCStatOpen", st
);
586 if (!afsclient_RPCStatOpenPort(cellHandle
,
587 as
->parms
[SERVER
].items
->data
,
588 srvrPort
, &conn
, &st
)) {
589 ERR_ST_EXT("afsclient_RPCStatOpenPort", st
);
593 if (which
== AFS_PEER_STATS
) {
594 if (!util_RPCStatsStateDisable
595 (conn
, RXSTATS_DisablePeerRPCStats
, &st
)) {
596 ERR_ST_EXT("util_RPCStatsStateDisable", st
);
599 if (!util_RPCStatsStateDisable
600 (conn
, RXSTATS_DisableProcessRPCStats
, &st
)) {
601 ERR_ST_EXT("util_RPCStatsStateDisable", st
);
605 afsclient_RPCStatClose(conn
, 0);
611 Print_afs_RPCStats_p(afs_RPCStats_p stat
, interface_function_list_p f_list
,
614 afs_int32 index
= stat
->s
.stats_v1
.func_index
;
616 if (index
> ((afs_int32
) f_list
->functionListLen
- 1)) {
617 printf("%sUnknown function ", prefix
);
619 printf("%s%s ", prefix
,
620 f_list
->functionList
[stat
->s
.stats_v1
.func_index
]);
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",
628 stat
->s
.stats_v1
.invocations
,
629 stat
->s
.stats_v1
.bytes_sent
,
630 stat
->s
.stats_v1
.bytes_rcvd
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
);
653 printf("never invoked\n");
658 DoClientRPCStatsList(struct cmd_syndesc
*as
, void *arock
)
660 enum { SERVER
, PROCESS
, STAT_TYPE
};
662 struct rx_connection
*conn
;
663 afs_stat_source_t type
;
666 afs_stat_type_t which
;
667 afs_RPCStats_t stats
;
672 (pthread_func_list_done
673 || pthread_once(&pthread_func_list_once
, cr_list
));
676 typeIsValid
= GetStatSourceFromString(as
->parms
[PROCESS
].items
->data
,
679 which
= GetStatTypeFromString(as
->parms
[STAT_TYPE
].items
->data
);
682 if (!afsclient_RPCStatOpen(cellHandle
,
683 as
->parms
[SERVER
].items
->data
,
685 ERR_ST_EXT("afsclient_RPCStatOpen", st
);
688 if (!afsclient_RPCStatOpenPort(cellHandle
,
689 as
->parms
[SERVER
].items
->data
,
690 srvrPort
, &conn
, &st
)) {
691 ERR_ST_EXT("afsclient_RPCStatOpenPort", st
);
695 if (which
== AFS_PEER_STATS
) {
696 if (!util_RPCStatsGetBegin
697 (conn
, RXSTATS_RetrievePeerRPCStats
, &iter
, &st
)) {
698 ERR_ST_EXT("util_RPCStatsGetBegin", st
);
701 if (!util_RPCStatsGetBegin
702 (conn
, RXSTATS_RetrieveProcessRPCStats
, &iter
, &st
)) {
703 ERR_ST_EXT("util_RPCStatsGetBegin", st
);
707 printf("Listing rpc stats at server %s process %s:\n",
708 as
->parms
[SERVER
].items
->data
, as
->parms
[PROCESS
].items
->data
);
710 while (util_RPCStatsGetNext(iter
, &stats
, &st
)) {
713 * Print a new heading for each stat collection
716 if (stats
.s
.stats_v1
.func_index
== 0) {
721 * Look up the interface in our list
724 for (i
= 0; i
< ((sizeof(int_list
) - 1) / sizeof(interface_t
));
726 if (stats
.s
.stats_v1
.interfaceId
== int_list
[i
].interfaceId
) {
732 * Print out a meaningful header for each stat collection
735 if (which
== AFS_PEER_STATS
) {
737 ina
.s_addr
= htonl(stats
.s
.stats_v1
.remote_peer
);
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
,
744 remote_is_server
) ? "accessed by" : "accessing"),
745 as
->parms
[PROCESS
].items
->data
,
747 remote_is_server
) ? "client" : "server"),
748 int_list
[i
].interfaceName
);
750 printf("%s stats for the %s interface " "accessed as a %s\n",
751 as
->parms
[PROCESS
].items
->data
,
752 int_list
[i
].interfaceName
,
754 remote_is_server
) ? "client" : "server")
758 Print_afs_RPCStats_p(&stats
, int_list
[i
].functionList
, " ");
761 if (st
!= ADMITERATORDONE
) {
762 ERR_ST_EXT("util_RPCStatsGetNext", st
);
765 if (!util_RPCStatsGetDone(iter
, &st
)) {
766 ERR_ST_EXT("util_RPCStatsGetDone", st
);
769 afsclient_RPCStatClose(conn
, 0);
775 DoClientRPCStatsClear(struct cmd_syndesc
*as
, void *arock
)
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
785 struct rx_connection
*conn
;
786 afs_stat_source_t type
;
789 afs_stat_type_t which
;
790 afs_RPCStatsClearFlag_t flag
= 0;
794 typeIsValid
= GetStatSourceFromString(as
->parms
[PROCESS
].items
->data
,
797 which
= GetStatTypeFromString(as
->parms
[STAT_TYPE
].items
->data
);
800 if (!afsclient_RPCStatOpen(cellHandle
,
801 as
->parms
[SERVER
].items
->data
,
803 ERR_ST_EXT("afsclient_RPCStatOpen", st
);
806 if (!afsclient_RPCStatOpenPort(cellHandle
,
807 as
->parms
[SERVER
].items
->data
,
808 srvrPort
, &conn
, &st
)) {
809 ERR_ST_EXT("afsclient_RPCStatOpenPort", st
);
813 if (as
->parms
[CLEAR_ALL
].items
) {
816 flag
= AFS_RX_STATS_CLEAR_ALL
;
819 if (as
->parms
[CLEAR_INVOCATIONS
].items
) {
821 ERR_EXT("cannot specify additional flags when "
822 "specifying clear_all");
825 flag
|= AFS_RX_STATS_CLEAR_INVOCATIONS
;
828 if (as
->parms
[CLEAR_BYTES_SENT
].items
) {
830 ERR_EXT("cannot specify additional flags when "
831 "specifying clear_all");
834 flag
|= AFS_RX_STATS_CLEAR_BYTES_SENT
;
837 if (as
->parms
[CLEAR_BYTES_RCVD
].items
) {
839 ERR_EXT("cannot specify additional flags when "
840 "specifying clear_all");
843 flag
|= AFS_RX_STATS_CLEAR_BYTES_RCVD
;
846 if (as
->parms
[CLEAR_QUEUE_TIME_SUM
].items
) {
848 ERR_EXT("cannot specify additional flags when "
849 "specifying clear_all");
852 flag
|= AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM
;
855 if (as
->parms
[CLEAR_QUEUE_TIME_SQUARE
].items
) {
857 ERR_EXT("cannot specify additional flags when "
858 "specifying clear_all");
861 flag
|= AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE
;
864 if (as
->parms
[CLEAR_QUEUE_TIME_MIN
].items
) {
866 ERR_EXT("cannot specify additional flags when "
867 "specifying clear_all");
870 flag
|= AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN
;
873 if (as
->parms
[CLEAR_QUEUE_TIME_MAX
].items
) {
875 ERR_EXT("cannot specify additional flags when "
876 "specifying clear_all");
879 flag
|= AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX
;
882 if (as
->parms
[CLEAR_EXEC_TIME_SUM
].items
) {
884 ERR_EXT("cannot specify additional flags when "
885 "specifying clear_all");
888 flag
|= AFS_RX_STATS_CLEAR_EXEC_TIME_SUM
;
891 if (as
->parms
[CLEAR_EXEC_TIME_SQUARE
].items
) {
893 ERR_EXT("cannot specify additional flags when "
894 "specifying clear_all");
897 flag
|= AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE
;
900 if (as
->parms
[CLEAR_EXEC_TIME_MIN
].items
) {
902 ERR_EXT("cannot specify additional flags when "
903 "specifying clear_all");
906 flag
|= AFS_RX_STATS_CLEAR_EXEC_TIME_MIN
;
909 if (as
->parms
[CLEAR_EXEC_TIME_MAX
].items
) {
911 ERR_EXT("cannot specify additional flags when "
912 "specifying clear_all");
915 flag
|= AFS_RX_STATS_CLEAR_EXEC_TIME_MAX
;
919 ERR_EXT("you must specify something to clear");
922 if (which
== AFS_PEER_STATS
) {
923 if (!util_RPCStatsClear(conn
, RXSTATS_ClearPeerRPCStats
, flag
, &st
)) {
924 ERR_ST_EXT("util_RPCStatsClear", st
);
927 if (!util_RPCStatsClear
928 (conn
, RXSTATS_ClearProcessRPCStats
, flag
, &st
)) {
929 ERR_ST_EXT("util_RPCStatsClear", st
);
933 afsclient_RPCStatClose(conn
, 0);
939 DoClientRPCStatsVersionGet(struct cmd_syndesc
*as
, void *arock
)
941 enum { SERVER
, PROCESS
};
943 struct rx_connection
*conn
;
944 afs_stat_source_t type
;
947 afs_RPCStatsVersion_t version
;
949 typeIsValid
= GetStatSourceFromString(as
->parms
[PROCESS
].items
->data
,
953 if (!afsclient_RPCStatOpen(cellHandle
,
954 as
->parms
[SERVER
].items
->data
,
956 ERR_ST_EXT("afsclient_RPCStatOpen", st
);
959 if (!afsclient_RPCStatOpenPort(cellHandle
,
960 as
->parms
[SERVER
].items
->data
,
961 srvrPort
, &conn
, &st
)) {
962 ERR_ST_EXT("afsclient_RPCStatOpenPort", st
);
966 if (!util_RPCStatsVersionGet(conn
, &version
, &st
)) {
967 ERR_ST_EXT("util_RPCStatsVersionGet", st
);
970 printf("the rpc stat version number is %u\n", version
);
972 afsclient_RPCStatClose(conn
, 0);
978 Print_afs_CMServerPref_p(afs_CMServerPref_p pref
)
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,
989 DoClientCMGetServerPrefs(struct cmd_syndesc
*as
, void *arock
)
992 enum { SERVER
, PORT
};
993 struct rx_connection
*conn
;
994 int srvrPort
= AFSCONF_CALLBACKPORT
;
995 afs_CMServerPref_t prefs
;
999 (pthread_func_list_done
1000 || pthread_once(&pthread_func_list_once
, cr_list
));
1003 if (as
->parms
[PORT
].items
) {
1004 if (!GetStatPortFromString(as
->parms
[PORT
].items
->data
, &srvrPort
)) {
1005 ERR_EXT("Couldn't undertand port number");
1009 if (!afsclient_CMStatOpenPort(cellHandle
,
1010 as
->parms
[SERVER
].items
->data
,
1011 srvrPort
, &conn
, &st
)) {
1012 ERR_ST_EXT("afsclient_CMStatOpenPort", st
);
1015 if (!util_CMGetServerPrefsBegin(conn
, &iter
, &st
)) {
1016 ERR_ST_EXT("util_CMGetServerPrefsBegin", st
);
1019 printf("Listing CellServDB for %s at port %s:\n",
1020 as
->parms
[SERVER
].items
->data
, as
->parms
[PORT
].items
->data
);
1022 while (util_CMGetServerPrefsNext(iter
, &prefs
, &st
)) {
1024 Print_afs_CMServerPref_p(&prefs
);
1027 if (st
!= ADMITERATORDONE
) {
1028 ERR_ST_EXT("util_CMGetServerPrefsNext", st
);
1031 if (!util_CMGetServerPrefsDone(iter
, &st
)) {
1032 ERR_ST_EXT("util_CMGetServerPrefsDone", st
);
1035 afsclient_CMStatClose(conn
, 0);
1041 Print_afs_CMListCell_p(afs_CMListCell_p cellInfo
)
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);
1056 DoClientCMListCells(struct cmd_syndesc
*as
, void *arock
)
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
;
1066 (pthread_func_list_done
1067 || pthread_once(&pthread_func_list_once
, cr_list
));
1070 if (as
->parms
[PORT
].items
) {
1071 if (!GetStatPortFromString(as
->parms
[PORT
].items
->data
, &srvrPort
)) {
1072 ERR_EXT("Couldn't undertand port number");
1076 if (!afsclient_CMStatOpenPort(cellHandle
,
1077 as
->parms
[SERVER
].items
->data
,
1078 srvrPort
, &conn
, &st
)) {
1079 ERR_ST_EXT("afsclient_CMStatOpenPort", st
);
1082 if (!util_CMListCellsBegin(conn
, &iter
, &st
)) {
1083 ERR_ST_EXT("util_CMListCellsBegin", st
);
1086 printf("Listing CellServDB for %s at port %s:\n",
1087 as
->parms
[SERVER
].items
->data
, as
->parms
[PORT
].items
->data
);
1089 while (util_CMListCellsNext(iter
, &cellInfo
, &st
)) {
1091 Print_afs_CMListCell_p(&cellInfo
);
1094 if (st
!= ADMITERATORDONE
) {
1095 ERR_ST_EXT("util_CMListCellsNext", st
);
1098 if (!util_CMListCellsDone(iter
, &st
)) {
1099 ERR_ST_EXT("util_CMListCellsDone", st
);
1102 afsclient_CMStatClose(conn
, 0);
1108 DoClientCMLocalCell(struct cmd_syndesc
*as
, void *arock
)
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
;
1117 (pthread_func_list_done
1118 || pthread_once(&pthread_func_list_once
, cr_list
));
1121 if (as
->parms
[PORT
].items
) {
1122 if (!GetStatPortFromString(as
->parms
[PORT
].items
->data
, &srvrPort
)) {
1123 ERR_EXT("Couldn't undertand port number");
1127 if (!afsclient_CMStatOpenPort(cellHandle
,
1128 as
->parms
[SERVER
].items
->data
,
1129 srvrPort
, &conn
, &st
)) {
1130 ERR_ST_EXT("afsclient_CMStatOpenPort", st
);
1133 if (!util_CMLocalCell(conn
, cellname
, &st
)) {
1134 ERR_ST_EXT("util_CMLocalCell", st
);
1137 printf("Client %s (port %s) is in cell %s\n",
1138 as
->parms
[SERVER
].items
->data
, as
->parms
[PORT
].items
->data
,
1141 afsclient_CMStatClose(conn
, 0);
1147 Print_afs_ClientConfig_p(afs_ClientConfig_p config
)
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
);
1164 DoClientCMClientConfig(struct cmd_syndesc
*as
, void *arock
)
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
;
1173 (pthread_func_list_done
1174 || pthread_once(&pthread_func_list_once
, cr_list
));
1177 if (as
->parms
[PORT
].items
) {
1178 if (!GetStatPortFromString(as
->parms
[PORT
].items
->data
, &srvrPort
)) {
1179 ERR_EXT("Couldn't undertand port number");
1183 if (!afsclient_CMStatOpenPort(cellHandle
,
1184 as
->parms
[SERVER
].items
->data
,
1185 srvrPort
, &conn
, &st
)) {
1186 ERR_ST_EXT("afsclient_CMStatOpenPort", st
);
1189 if (!util_CMClientConfig(conn
, &config
, &st
)) {
1190 ERR_ST_EXT("util_CMClientConfig", st
);
1193 printf("Cache configuration for client %s (port %s):\n\n",
1194 as
->parms
[SERVER
].items
->data
, as
->parms
[PORT
].items
->data
);
1196 Print_afs_ClientConfig_p(&config
);
1200 afsclient_CMStatClose(conn
, 0);
1206 SetupClientAdminCmd(void)
1208 struct cmd_syndesc
*ts
;
1210 ts
= cmd_CreateSyntax("ClientLocalCellGet", DoClientLocalCellGet
, NULL
, 0,
1211 "get the name of this machine's cell");
1212 SetupCommonCmdArgs(ts
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);