viced: Assert valid statistics indices
[openafs.git] / src / viced / fsstats.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 /* An abstracted interface for recording fs statistics data */
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14
15 #include <assert.h>
16 #include <roken.h>
17
18 #include <afs/afsint.h>
19 #include <afs/ihandle.h>
20 #include <afs/nfs.h>
21 #include "viced.h"
22 #include "fs_stats.h"
23
24 #if FS_STATS_DETAILED
25
26 void
27 fsstats_StartOp(struct fsstats *stats, int index)
28 {
29     assert(index >= 0 && index < FS_STATS_NUM_RPC_OPS);
30     stats->opP = &(afs_FullPerfStats.det.rpcOpTimes[index]);
31     FS_LOCK;
32     (stats->opP->numOps)++;
33     FS_UNLOCK;
34     FT_GetTimeOfDay(&stats->opStartTime, NULL);
35 }
36
37 void
38 fsstats_FinishOp(struct fsstats *stats, int code)
39 {
40     struct timeval opStopTime, elapsedTime;
41
42     FT_GetTimeOfDay(&opStopTime, NULL);
43     if (code == 0) {
44         FS_LOCK;
45         (stats->opP->numSuccesses)++;
46         fs_stats_GetDiff(elapsedTime, stats->opStartTime, opStopTime);
47         fs_stats_AddTo((stats->opP->sumTime), elapsedTime);
48         fs_stats_SquareAddTo((stats->opP->sqrTime), elapsedTime);
49         if (fs_stats_TimeLessThan(elapsedTime, (stats->opP->minTime))) {
50             fs_stats_TimeAssign((stats->opP->minTime), elapsedTime);
51         }
52         if (fs_stats_TimeGreaterThan(elapsedTime, (stats->opP->maxTime))) {
53             fs_stats_TimeAssign((stats->opP->maxTime), elapsedTime);
54         }
55         FS_UNLOCK;
56     }
57 }
58
59 void
60 fsstats_StartXfer(struct fsstats *stats, int index)
61 {
62     assert(index >= 0 && index < FS_STATS_NUM_XFER_OPS);
63     FT_GetTimeOfDay(&stats->xferStartTime, NULL);
64     stats->xferP = &(afs_FullPerfStats.det.xferOpTimes[index]);
65 }
66
67 void
68 fsstats_FinishXfer(struct fsstats *stats, int code,
69                    afs_sfsize_t bytesToXfer, afs_sfsize_t bytesXferred,
70                    int *remainder)
71 {
72     struct timeval xferStopTime;
73     struct timeval elapsedTime;
74
75     /*
76      * At this point, the data transfer is done, for good or ill.  Remember
77      * when the transfer ended, bump the number of successes/failures, and
78      * integrate the transfer size and elapsed time into the stats.  If the
79      * operation failed, we jump to the appropriate point.
80      */
81     FT_GetTimeOfDay(&xferStopTime, 0);
82     FS_LOCK;
83     (stats->xferP->numXfers)++;
84     if (code == 0) {
85         (stats->xferP->numSuccesses)++;
86
87         /*
88          * Bump the xfer sum by the number of bytes actually sent, NOT the
89          * target number.
90          */
91         *remainder += bytesXferred;
92         (stats->xferP->sumBytes) += (*remainder >> 10);
93         *remainder &= 0x3FF;
94         if (bytesXferred < stats->xferP->minBytes)
95             stats->xferP->minBytes = bytesXferred;
96         if (bytesXferred > stats->xferP->maxBytes)
97             stats->xferP->maxBytes = bytesXferred;
98
99         /*
100          * Tally the size of the object.  Note: we tally the actual size,
101          * NOT the number of bytes that made it out over the wire.
102          */
103         if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET0)
104             (stats->xferP->count[0])++;
105         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET1)
106             (stats->xferP->count[1])++;
107         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET2)
108             (stats->xferP->count[2])++;
109         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET3)
110             (stats->xferP->count[3])++;
111         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET4)
112             (stats->xferP->count[4])++;
113         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET5)
114             (stats->xferP->count[5])++;
115         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET6)
116             (stats->xferP->count[6])++;
117         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET7)
118             (stats->xferP->count[7])++;
119         else
120             (stats->xferP->count[8])++;
121
122         fs_stats_GetDiff(elapsedTime, stats->xferStartTime, xferStopTime);
123         fs_stats_AddTo((stats->xferP->sumTime), elapsedTime);
124         fs_stats_SquareAddTo((stats->xferP->sqrTime), elapsedTime);
125         if (fs_stats_TimeLessThan(elapsedTime, (stats->xferP->minTime))) {
126             fs_stats_TimeAssign((stats->xferP->minTime), elapsedTime);
127         }
128         if (fs_stats_TimeGreaterThan(elapsedTime, (stats->xferP->maxTime))) {
129             fs_stats_TimeAssign((stats->xferP->maxTime), elapsedTime);
130         }
131     }
132     FS_UNLOCK;
133 }
134
135 #else
136
137 void
138 fsstats_StartOp(struct fsstats *stats, int index)
139 {
140     return;
141 }
142
143 void
144 fsstats_FinishOp(struct fsstats *stats, int code)
145 {
146     return;
147 }
148
149 void
150 fsstats_StartXfer(struct fsstats *stats)
151 {
152     return;
153 }
154
155 void
156 fsstats_FinishXfer(struct fsstats *stats, int code,
157                    afs_sfsize_t bytesToXfer, afs_sfsize_t bytesXferred,
158                    int *remainder)
159 {
160     return;
161 }
162
163
164
165
166 #endif