rxstat-fix-objdir-builds-20030328
[openafs.git] / src / rxstat / rxstat.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 #ifdef UKERNEL
11 #include "afs/param.h"
12 #else
13 #include <afs/param.h>
14 #endif
15 #include <afsconfig.h>
16
17 RCSID("$Header$");
18
19 #ifdef UKERNEL
20 #include "afs/sysincludes.h"
21 #include "afsincludes.h"
22 #include <rx/rxstat.h>
23 #else /* UKERNEL */
24 #include <afs/stds.h>
25 #include <rx/rx.h>
26 #include <rx/rxstat.h>
27 #ifdef KERNEL
28 #include "sys/errno.h"
29 #else /* KERNEL */
30 #include <errno.h>
31 #endif /* KERNEL */
32 #endif /* UKERNEL */
33
34 /*
35  * This file creates a centralized mechanism for implementing the rpc
36  * stat code - which is generic across all servers.
37  */
38
39 afs_int32 MRXSTATS_RetrieveProcessRPCStats(
40   struct rx_call *call,
41   IN afs_uint32 clientVersion,
42   OUT afs_uint32 *serverVersion,
43   OUT afs_uint32 *clock_sec,
44   OUT afs_uint32 *clock_usec,
45   OUT afs_uint32 *stat_count,
46   OUT rpcStats *stats)
47
48     afs_int32 rc;
49     size_t allocSize;
50
51     rc = rx_RetrieveProcessRPCStats(clientVersion,
52                                     serverVersion,
53                                     clock_sec,
54                                     clock_usec,
55                                     &allocSize,
56                                     stat_count,
57                                     &stats->rpcStats_val);
58     stats->rpcStats_len = allocSize/sizeof(afs_uint32);
59     return rc;
60 }   
61
62
63 afs_int32 MRXSTATS_RetrievePeerRPCStats(
64   struct rx_call *call,
65   IN afs_uint32 clientVersion,
66   OUT afs_uint32 *serverVersion,
67   OUT afs_uint32 *clock_sec,
68   OUT afs_uint32 *clock_usec,
69   OUT afs_uint32 *stat_count,
70   OUT rpcStats *stats)
71
72     afs_int32 rc;
73     size_t allocSize;
74
75     rc = rx_RetrievePeerRPCStats(clientVersion,
76                                     serverVersion,
77                                     clock_sec,
78                                     clock_usec,
79                                     &allocSize,
80                                     stat_count,
81                                     &stats->rpcStats_val);
82     stats->rpcStats_len = allocSize/sizeof(afs_uint32);
83     return rc;
84 }   
85
86
87 afs_int32 MRXSTATS_QueryProcessRPCStats(
88   struct rx_call *call,
89   OUT afs_int32 *on)
90
91     afs_int32 rc = 0;
92     *on = rx_queryProcessRPCStats();
93     return rc;
94 }   
95
96
97 afs_int32 MRXSTATS_QueryPeerRPCStats(
98   struct rx_call *call,
99   OUT afs_int32 *on)
100
101     afs_int32 rc = 0;
102     *on = rx_queryPeerRPCStats();
103     return rc;
104 }   
105
106
107 afs_int32 MRXSTATS_EnableProcessRPCStats(
108   struct rx_call *call)
109
110     afs_int32 rc = 0;
111     if (!rx_RxStatUserOk(call)) {
112         rc = EPERM;
113     } else {
114         rx_enableProcessRPCStats();
115     }
116     return rc;
117 }   
118
119 afs_int32 MRXSTATS_EnablePeerRPCStats(
120   struct rx_call *call)
121
122     afs_int32 rc = 0;
123     if (!rx_RxStatUserOk(call)) {
124         rc = EPERM;
125     } else {
126         rx_enablePeerRPCStats();
127     }
128     return rc;
129 }   
130
131
132 afs_int32 MRXSTATS_DisableProcessRPCStats(
133   struct rx_call *call)
134
135     afs_int32 rc = 0;
136     if (!rx_RxStatUserOk(call)) {
137         rc = EPERM;
138     } else {
139         rx_disableProcessRPCStats();
140     }
141     return rc;
142 }   
143
144 afs_int32 MRXSTATS_DisablePeerRPCStats(
145   struct rx_call *call)
146
147     afs_int32 rc = 0;
148     if (!rx_RxStatUserOk(call)) {
149         rc = EPERM;
150     } else {
151     rx_disablePeerRPCStats();
152     }
153     return rc;
154 }   
155
156 afs_int32 MRXSTATS_QueryRPCStatsVersion(
157   struct rx_call *call,
158   OUT afs_uint32 *ver)
159 {
160     afs_int32 rc = 0;
161     *ver = RX_STATS_RETRIEVAL_VERSION;
162     return rc;
163 }
164
165 afs_int32 MRXSTATS_ClearProcessRPCStats(
166   struct rx_call *call,
167   IN afs_uint32 clearFlag)
168 {
169     afs_int32 rc = 0;
170     if (!rx_RxStatUserOk(call)) {
171         rc = EPERM;
172     } else {
173         rx_clearProcessRPCStats(clearFlag);
174     }
175     return rc;
176 }
177
178 afs_int32 MRXSTATS_ClearPeerRPCStats(
179   struct rx_call *call,
180   IN afs_uint32 clearFlag)
181 {
182     afs_int32 rc = 0;
183     if (!rx_RxStatUserOk(call)) {
184         rc = EPERM;
185     } else {
186         rx_clearPeerRPCStats(clearFlag);
187     }
188     return rc;
189 }