src/rxstat/rxstat.c

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