#define DBG_PRINT(s)
#endif
-#ifdef AFS_PTHREAD_ENV
-pthread_mutex_t rxkad_stats_mutex;
-#endif /* AFS_PTHREAD_ENV */
-
/* encrypt == 0 ==> decrypt, else encrypt */
afs_int32
#ifdef DEBUG
afs_uint32 dbg_tmp[2];
#endif
- LOCK_RXKAD_STATS;
if (encrypt)
- rxkad_stats.des_encrypts[DES_ENCRYPT]++;
+ INC_RXKAD_STATS(des_encrypts[DES_ENCRYPT]);
else
- rxkad_stats.des_encrypts[DES_DECRYPT]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(des_encrypts[DES_DECRYPT]);
/*
* Use L1,R1 and L2,R2 as two sets of "64-bit" registers always
* work from L1,R1 input to L2,R2 output; initialize the cleartext
n = 0;
p_char = k_char;
- LOCK_RXKAD_STATS;
- rxkad_stats.des_key_scheds++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(des_key_scheds);
#ifdef lint
n = n; /* fool it in case of VAXASM */
#endif
{
int i;
- LOCK_RXKAD_STATS;
- rxkad_stats.des_randoms++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(des_randoms);
/*
* Encrypt the sequence number to get the new random block:
*/
/* Some Cheap statistics which should be shared with the rxkad definitions, but
* aren't. The layout should match the layout in rxkad/rxkad.p.h. */
+#ifndef OPENAFS_DES_STATS_H
+#define OPENAFS_DES_STATS_H
+
+
+/* this is an optimization for pthreads environments. Instead of having global
+ rxkad statistics, make them thread-specific, and only perform aggregation on
+ the stats structures when necessary. Furthermore, don't do any locking, and
+ live with the nearly accurate aggregation (e.g. you might miss a few increments,
+ but the resulting aggregation should be almost correct). */
+
+#ifdef AFS_PTHREAD_ENV
+typedef struct rxkad_stats_t {
+#else
struct rxkad_stats {
+#endif
afs_uint32 connections[3]; /* client side only */
afs_uint32 destroyObject; /* client security objects */
afs_uint32 destroyClient; /* client connections */
afs_uint32 des_encrypts[2]; /* DECRYPT==0, ENCRYPT==1 */
afs_uint32 des_key_scheds; /* key schedule creations */
afs_uint32 des_randoms; /* random blocks generated */
- long spares[10];
+ afs_uint32 clientObjects;
+ afs_uint32 serverObjects;
+ long spares[8];
+#ifdef AFS_PTHREAD_ENV
+ struct rxkad_stats_t * next;
+ struct rxkad_stats_t * prev;
+} rxkad_stats_t; /* put these here for convenience */
+#else /* AFS_PTHREAD_ENV */
} rxkad_stats; /* put these here for convenience */
+#endif /* AFS_PTHREAD_ENV */
+
#ifdef AFS_PTHREAD_ENV
+struct rxkad_global_stats {
+ rxkad_stats_t * first;
+ rxkad_stats_t * last;
+} rxkad_global_stats;
+
#include <pthread.h>
#include <assert.h>
-extern pthread_mutex_t rxkad_stats_mutex;
-#define LOCK_RXKAD_STATS assert(pthread_mutex_lock(&rxkad_stats_mutex)==0)
-#define UNLOCK_RXKAD_STATS assert(pthread_mutex_unlock(&rxkad_stats_mutex)==0)
+extern pthread_mutex_t rxkad_global_stats_lock;
+extern pthread_key_t rxkad_stats_key;
+
+extern void rxkad_global_stats_init();
+extern rxkad_stats_t * rxkad_thr_stats_init();
+extern int rxkad_stats_agg(rxkad_stats_t *);
+
+#ifndef BEGIN
+#define BEGIN do {
+#define END } while(0)
+#endif
+#define RXKAD_GLOBAL_STATS_LOCK assert(pthread_mutex_lock(&rxkad_global_stats_lock)==0)
+#define RXKAD_GLOBAL_STATS_UNLOCK assert(pthread_mutex_unlock(&rxkad_global_stats_lock)==0)
+#define GET_RXKAD_STATS(stats) rxkad_stats_agg(stats)
+#define GET_RXKAD_THR_STATS(rxkad_stats) \
+ BEGIN \
+ (rxkad_stats) = ((rxkad_stats_t*)pthread_getspecific(rxkad_stats_key)); \
+ if ((rxkad_stats) == NULL) { \
+ assert(((rxkad_stats) = rxkad_thr_stats_init()) != NULL); \
+ } \
+ END
+#define INC_RXKAD_STATS(stats_elem) \
+ BEGIN \
+ rxkad_stats_t * rxkad_stats; \
+ rxkad_stats = ((rxkad_stats_t*)pthread_getspecific(rxkad_stats_key)); \
+ if (rxkad_stats == NULL) { \
+ assert(((rxkad_stats) = rxkad_thr_stats_init()) != NULL); \
+ } \
+ rxkad_stats->stats_elem++; \
+ END
+#define DEC_RXKAD_STATS(stats_elem) \
+ BEGIN \
+ rxkad_stats_t * rxkad_stats; \
+ rxkad_stats = ((rxkad_stats_t*)pthread_getspecific(rxkad_stats_key)); \
+ if (rxkad_stats == NULL) { \
+ assert(((rxkad_stats) = rxkad_thr_stats_init()) != NULL); \
+ } \
+ rxkad_stats->stats_elem--; \
+ END
+#define ADD_RXKAD_STATS(stats_elem, inc_value) \
+ BEGIN \
+ rxkad_stats_t * rxkad_stats; \
+ rxkad_stats = ((rxkad_stats_t*)pthread_getspecific(rxkad_stats_key)); \
+ if (rxkad_stats == NULL) { \
+ assert(((rxkad_stats) = rxkad_thr_stats_init()) != NULL); \
+ } \
+ rxkad_stats->stats_elem += inc_value; \
+ END
+#define SUB_RXKAD_STATS(stats_elem, dec_value) \
+ BEGIN \
+ rxkad_stats_t * rxkad_stats; \
+ rxkad_stats = ((rxkad_stats_t*)pthread_getspecific(rxkad_stats_key)); \
+ if (rxkad_stats == NULL) { \
+ assert(((rxkad_stats) = rxkad_thr_stats_init()) != NULL); \
+ } \
+ rxkad_stats->stats_elem -= dec_value; \
+ END
+#else /* AFS_PTHREAD_ENV */
+#define INC_RXKAD_STATS(stats_elem) rxkad_stats.stats_elem++
+#define DEC_RXKAD_STATS(stats_elem) rxkad_stats.stats_elem--
+#define ADD_RXKAD_STATS(stats_elem, inc_value) rxkad_stats.stats_elem += (inc_value)
+#define SUB_RXKAD_STATS(stats_elem, dec_value) rxkad_stats.stats_elem -= (dec_value)
+#define GET_RXKAD_STATS(stats) memcpy((stats), &rxkad_stats, sizeof(rxkad_stats))
+#endif /* AFS_PTHREAD_ENV */
+
+
+#if defined(AFS_NT40_ENV) && defined(AFS_PTHREAD_ENV)
+#ifndef RXKAD_STATS_DECLSPEC
+#define RXKAD_STATS_DECLSPEC __declspec(dllimport) extern
+#endif
#else
-#define LOCK_RXKAD_STATS
-#define UNLOCK_RXKAD_STATS
+#define RXKAD_STATS_DECLSPEC extern
#endif
+
+#ifdef AFS_PTHREAD_ENV
+RXKAD_STATS_DECLSPEC struct rxkad_global_stats rxkad_global_stats;
+#else /* AFS_PTHREAD_ENV */
+RXKAD_STATS_DECLSPEC struct rxkad_stats rxkad_stats;
+#endif
+
+
+#endif /* OPENAFS_DES_STATS_H */
PrintRxkadStats()
{
printf("New Objects client %d, server %d. Destroyed objects %d.\n",
- rxkad_stats_clientObjects, rxkad_stats_serverObjects,
+ rxkad_stats.clientObjects, rxkad_stats.serverObjects,
rxkad_stats.destroyObject);
printf("client conns: %d %d %d, destroyed client %d.\n",
rxkad_stats.connections[0], rxkad_stats.connections[1],
PrintRxkadStats()
{
printf("New Objects client %d, server %d. Destroyed objects %d.\n",
- rxkad_stats_clientObjects, rxkad_stats_serverObjects,
+ rxkad_stats.clientObjects, rxkad_stats.serverObjects,
rxkad_stats.destroyObject);
printf("client conns: %d %d %d, destroyed client %d.\n",
rxkad_stats.connections[0], rxkad_stats.connections[1],
xdrrec_skiprecord @71
xdrrx_create @72
hton_syserr_conv @73
- rxkad_stats @74 DATA
+ rxkad_global_stats @74 DATA
com_err @75
error_message @76
rx_socket @77 DATA
StartRXAFS_FetchData64 @218
StartRXAFS_StoreData64 @219
rx_StartClientThread @220
+ rxkad_global_stats_lock @221 DATA
+ rxkad_stats_key @222 DATA
xdr_afsuuid
xdr_int64
hton_syserr_conv
-rxkad_stats
+rxkad_global_stats
+rxkad_global_stats_lock
+rxkad_stats_key
_et_list
et_list_mutex
com_err
*/
extern pthread_mutex_t rx_stats_mutex;
-extern pthread_mutex_t rxkad_stats_mutex;
extern pthread_mutex_t des_init_mutex;
extern pthread_mutex_t des_random_mutex;
extern pthread_mutex_t rx_clock_mutex;
(&rxkad_client_uid_mutex, (const pthread_mutexattr_t *)0) == 0);
assert(pthread_mutex_init
(&rxkad_random_mutex, (const pthread_mutexattr_t *)0) == 0);
- assert(pthread_mutex_init
- (&rxkad_stats_mutex, (const pthread_mutexattr_t *)0) == 0);
assert(pthread_mutex_init(&rx_debug_mutex, (const pthread_mutexattr_t *)0)
== 0);
== 0);
assert(pthread_key_create(&rx_thread_id_key, NULL) == 0);
assert(pthread_key_create(&rx_ts_info_key, NULL) == 0);
+
+ rxkad_global_stats_init();
}
pthread_once_t rx_once_init = PTHREAD_ONCE_INIT;
#include "rxkad.h"
#include "fcrypt.h"
#include "private_data.h"
+#include <des/stats.h>
#undef WORDS_BIGENDIAN
#ifdef AFSBIG_ENDIAN
fc_ecb_encrypt(afs_uint32 * in, afs_uint32 * out, fc_KeySchedule sched,
int encrypt)
{
- LOCK_RXKAD_STATS;
- rxkad_stats.fc_encrypts[encrypt]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(fc_encrypts[encrypt]);
if (encrypt)
fc_ecb_enc(in[0], in[1], out, sched);
else
ROT56R(hi, lo, 11);
*sched++ = EFF_NTOHL(lo);
#endif
- LOCK_RXKAD_STATS;
- rxkad_stats.fc_key_scheds++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(fc_key_scheds);
return 0;
}
obj = rx_SecurityObjectOf(rx_connection_not_used);
tp = (struct rxkad_cprivate *)obj->privateData;
- LOCK_RXKAD_STATS;
- rxkad_stats.bytesEncrypted[rxkad_TypeIndex(tp->type)] += len;
- UNLOCK_RXKAD_STATS;
+ ADD_RXKAD_STATS(bytesEncrypted[rxkad_TypeIndex(tp->type)],len);
{
/* What is this good for?
* It turns out that the security header for auth_enc is of
obj = rx_SecurityObjectOf(rx_connection_not_used);
tp = (struct rxkad_cprivate *)obj->privateData;
- LOCK_RXKAD_STATS;
- rxkad_stats.bytesDecrypted[rxkad_TypeIndex(tp->type)] += len;
- UNLOCK_RXKAD_STATS;
+ ADD_RXKAD_STATS(bytesDecrypted[rxkad_TypeIndex(tp->type)],len);
memcpy(ivec, iv, sizeof(ivec)); /* Must use copy of iv */
for (frag = &packet->wirevec[1]; len > 0; frag++) {
int iov_len = frag->iov_len;
#endif
#endif /* KERNEL */
+#include <des/stats.h>
#include "private_data.h"
#define XPRT_RXKAD_CRYPT
obj = rx_SecurityObjectOf(conn);
tp = (struct rxkad_cprivate *)obj->privateData;
- LOCK_RXKAD_STATS;
- rxkad_stats.bytesDecrypted[rxkad_TypeIndex(tp->type)] += len;
- UNLOCK_RXKAD_STATS;
+ ADD_RXKAD_STATS(bytesDecrypted[rxkad_TypeIndex(tp->type)],len);
memcpy((void *)xor, (void *)ivec, sizeof(xor));
for (i = 0; len; i++) {
data = rx_data(packet, i, tlen);
obj = rx_SecurityObjectOf(conn);
tp = (struct rxkad_cprivate *)obj->privateData;
- LOCK_RXKAD_STATS;
- rxkad_stats.bytesEncrypted[rxkad_TypeIndex(tp->type)] += len;
- UNLOCK_RXKAD_STATS;
+ ADD_RXKAD_STATS(bytesEncrypted[rxkad_TypeIndex(tp->type)],len);
/*
* afs_int32 cksum;
* cksum = htonl(0);
#include "sboxes.h"
#include "fcrypt.h"
#include "rxkad.h"
-
+#include <des/stats.h>
#ifdef TCRYPT
int ROUNDS = 16;
kword[1] = (kword[1] >> 11) | (temp << (56 - 32 - 11));
schedule[i] = kword[0];
}
- LOCK_RXKAD_STATS;
- rxkad_stats.fc_key_scheds++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(fc_key_scheds);
return 0;
}
#endif
if (encrypt) {
- LOCK_RXKAD_STATS;
- rxkad_stats.fc_encrypts[ENCRYPT]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(fc_encrypts[ENCRYPT]);
for (i = 0; i < (ROUNDS / 2); i++) {
S = *schedule++ ^ R; /* xor R with key bits from schedule */
Pchar[Byte2] = sbox0[Schar[Byte0]]; /* do 8-bit S Box subst. */
R ^= P;
}
} else {
- LOCK_RXKAD_STATS;
- rxkad_stats.fc_encrypts[DECRYPT]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(fc_encrypts[DECRYPT]);
schedule = &schedule[ROUNDS - 1]; /* start at end of key schedule */
for (i = 0; i < (ROUNDS / 2); i++) {
S = *schedule-- ^ L; /* xor R with key bits from schedule */
#define rxkad_TypeIndex(type) \
((((type) == 1) || ((type) == 2)) ? (type) : 0)
-struct rxkad_stats {
- afs_uint32 connections[3]; /* client side only */
- afs_uint32 destroyObject; /* client security objects */
- afs_uint32 destroyClient; /* client connections */
- afs_uint32 destroyUnused; /* unused server conn */
- afs_uint32 destroyUnauth; /* unauthenticated server conn */
- afs_uint32 destroyConn[3]; /* server conn per level */
- afs_uint32 expired; /* server packets rejected */
- afs_uint32 challengesSent; /* server challenges sent */
- afs_uint32 challenges[3]; /* challenges seen by client */
- afs_uint32 responses[3]; /* responses seen by server */
- afs_uint32 preparePackets[6];
- afs_uint32 checkPackets[6];
- afs_uint32 bytesEncrypted[2]; /* index just by type */
- afs_uint32 bytesDecrypted[2];
- afs_uint32 fc_encrypts[2]; /* DECRYPT==0, ENCRYPT==1 */
- afs_uint32 fc_key_scheds; /* key schedule creations */
- afs_uint32 des_encrypts[2]; /* DECRYPT==0, ENCRYPT==1 */
- afs_uint32 des_key_scheds; /* key schedule creations */
- afs_uint32 des_randoms; /* random blocks generated */
- long spares[10];
-};
-
-#if defined(AFS_NT40_ENV) && defined(AFS_PTHREAD_ENV)
-#ifndef RXKAD_STATS_DECLSPEC
-#define RXKAD_STATS_DECLSPEC __declspec(dllimport) extern
-#endif
-#else
-#define RXKAD_STATS_DECLSPEC extern
-#endif
-RXKAD_STATS_DECLSPEC struct rxkad_stats rxkad_stats;
-#ifdef AFS_PTHREAD_ENV
-#include <pthread.h>
-#include <assert.h>
-extern pthread_mutex_t rxkad_stats_mutex;
-#define LOCK_RXKAD_STATS assert(pthread_mutex_lock(&rxkad_stats_mutex)==0)
-#define UNLOCK_RXKAD_STATS assert(pthread_mutex_unlock(&rxkad_stats_mutex)==0)
-#else
-#define LOCK_RXKAD_STATS
-#define UNLOCK_RXKAD_STATS
-#endif
-
-
-/* gak! using up spares already! */
-#define rxkad_stats_clientObjects (rxkad_stats.spares[0])
-#define rxkad_stats_serverObjects (rxkad_stats.spares[1])
extern int rxkad_EpochWasSet; /* TRUE => we called rx_SetEpoch */
#endif /* AFS_PTHREAD_ENV */
#endif /* KERNEL */
+#include <des/stats.h>
#include "private_data.h"
#define XPRT_RXKAD_CLIENT
}
memcpy(tcp->ticket, ticket, ticketLen);
- LOCK_RXKAD_STATS;
- rxkad_stats_clientObjects++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(clientObjects);
return tsc;
}
if (level > tcp->level)
return RXKADLEVELFAIL;
- LOCK_RXKAD_STATS;
- rxkad_stats.challenges[rxkad_LevelIndex(tcp->level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(challenges[rxkad_LevelIndex(tcp->level)]);
if (v2) {
int i;
afs_uint32 xor[2];
#endif /* KERNEL */
+#include <des/stats.h>
#include "private_data.h"
#define XPRT_RXKAD_COMMON
#endif
/* variable initialization for the benefit of darwin compiler; if it causes
problems elsewhere, conditionalize for darwin or fc_test compile breaks */
+#ifdef AFS_PTHREAD_ENV
+struct rxkad_global_stats rxkad_global_stats = { 0 };
+pthread_mutex_t rxkad_global_stats_lock;
+pthread_key_t rxkad_stats_key;
+#else /* AFS_PTHREAD_ENV */
struct rxkad_stats rxkad_stats = { { 0 } };
+#endif /* AFS_PTHREAD_ENV */
+
+#ifdef AFS_PTHREAD_ENV
+/* rxkad_stats related stuff */
+
+/*
+ * Macro to insert an element at the tail of a doubly linked list
+ */
+#define DLL_INSERT_TAIL(ptr,head,tail,next,prev) \
+ do { \
+ (ptr)->next = NULL; \
+ (ptr)->prev = (tail); \
+ (tail) = (ptr); \
+ if ((ptr)->prev) \
+ (ptr)->prev->next = (ptr); \
+ else \
+ (head) = (ptr); \
+ assert((head) && ((head)->prev == NULL)); \
+ } while(0)
+
+void rxkad_global_stats_init() {
+ assert(pthread_mutex_init(&rxkad_global_stats_lock, (const pthread_mutexattr_t *)0) == 0);
+ assert(pthread_key_create(&rxkad_stats_key, NULL) == 0);
+ memset(&rxkad_global_stats, 0, sizeof(rxkad_global_stats));
+}
+
+rxkad_stats_t *
+rxkad_thr_stats_init() {
+ rxkad_stats_t * rxkad_stats;
+ rxkad_stats = (rxkad_stats_t *)malloc(sizeof(rxkad_stats_t));
+ assert(rxkad_stats != NULL && pthread_setspecific(rxkad_stats_key,rxkad_stats) == 0);
+ memset(rxkad_stats,0,sizeof(rxkad_stats_t));
+ RXKAD_GLOBAL_STATS_LOCK;
+ DLL_INSERT_TAIL(rxkad_stats, rxkad_global_stats.first, rxkad_global_stats.last, next, prev);
+ RXKAD_GLOBAL_STATS_UNLOCK;
+ return rxkad_stats;
+}
+
+int rxkad_stats_agg(rxkad_stats_t * rxkad_stats) {
+ rxkad_stats_t * thr_stats;
+ assert(rxkad_stats != NULL);
+ memset(rxkad_stats, 0, sizeof(rxkad_stats_t));
+ RXKAD_GLOBAL_STATS_LOCK;
+ for (thr_stats = rxkad_global_stats.first; thr_stats != NULL; thr_stats = thr_stats->next) {
+ rxkad_stats->connections[0] += thr_stats->connections[0];
+ rxkad_stats->connections[1] += thr_stats->connections[1];
+ rxkad_stats->connections[2] += thr_stats->connections[2];
+ rxkad_stats->destroyObject += thr_stats->destroyObject;
+ rxkad_stats->destroyClient += thr_stats->destroyClient;
+ rxkad_stats->destroyUnused += thr_stats->destroyUnused;
+ rxkad_stats->destroyUnauth += thr_stats->destroyUnauth;
+ rxkad_stats->destroyConn[0] += thr_stats->destroyConn[0];
+ rxkad_stats->destroyConn[1] += thr_stats->destroyConn[1];
+ rxkad_stats->destroyConn[2] += thr_stats->destroyConn[2];
+ rxkad_stats->expired += thr_stats->expired;
+ rxkad_stats->challengesSent += thr_stats->challengesSent;
+ rxkad_stats->challenges[0] += thr_stats->challenges[0];
+ rxkad_stats->challenges[1] += thr_stats->challenges[1];
+ rxkad_stats->challenges[2] += thr_stats->challenges[2];
+ rxkad_stats->responses[0] += thr_stats->responses[0];
+ rxkad_stats->responses[1] += thr_stats->responses[1];
+ rxkad_stats->responses[2] += thr_stats->responses[2];
+ rxkad_stats->preparePackets[0] += thr_stats->preparePackets[0];
+ rxkad_stats->preparePackets[1] += thr_stats->preparePackets[1];
+ rxkad_stats->preparePackets[2] += thr_stats->preparePackets[2];
+ rxkad_stats->preparePackets[3] += thr_stats->preparePackets[3];
+ rxkad_stats->preparePackets[4] += thr_stats->preparePackets[4];
+ rxkad_stats->preparePackets[5] += thr_stats->preparePackets[5];
+ rxkad_stats->checkPackets[0] += thr_stats->checkPackets[0];
+ rxkad_stats->checkPackets[1] += thr_stats->checkPackets[1];
+ rxkad_stats->checkPackets[2] += thr_stats->checkPackets[2];
+ rxkad_stats->checkPackets[3] += thr_stats->checkPackets[3];
+ rxkad_stats->checkPackets[4] += thr_stats->checkPackets[4];
+ rxkad_stats->checkPackets[5] += thr_stats->checkPackets[5];
+ rxkad_stats->bytesEncrypted[0] += thr_stats->bytesEncrypted[0];
+ rxkad_stats->bytesEncrypted[1] += thr_stats->bytesEncrypted[1];
+ rxkad_stats->bytesDecrypted[0] += thr_stats->bytesDecrypted[0];
+ rxkad_stats->bytesDecrypted[1] += thr_stats->bytesDecrypted[1];
+ rxkad_stats->fc_encrypts[0] += thr_stats->fc_encrypts[0];
+ rxkad_stats->fc_encrypts[1] += thr_stats->fc_encrypts[1];
+ rxkad_stats->fc_key_scheds += thr_stats->fc_key_scheds;
+ rxkad_stats->des_encrypts[0] += thr_stats->des_encrypts[0];
+ rxkad_stats->des_encrypts[1] += thr_stats->des_encrypts[1];
+ rxkad_stats->des_key_scheds += thr_stats->des_key_scheds;
+ rxkad_stats->des_randoms += thr_stats->des_randoms;
+ rxkad_stats->spares[0] += thr_stats->spares[0];
+ rxkad_stats->spares[1] += thr_stats->spares[1];
+ rxkad_stats->spares[2] += thr_stats->spares[2];
+ rxkad_stats->spares[3] += thr_stats->spares[3];
+ rxkad_stats->spares[4] += thr_stats->spares[4];
+ rxkad_stats->spares[5] += thr_stats->spares[5];
+ rxkad_stats->spares[6] += thr_stats->spares[6];
+ rxkad_stats->spares[7] += thr_stats->spares[7];
+ rxkad_stats->spares[8] += thr_stats->spares[8];
+ rxkad_stats->spares[9] += thr_stats->spares[9];
+ }
+ RXKAD_GLOBAL_STATS_UNLOCK;
+ return 0;
+}
+#endif /* AFS_PTHREAD_ENV */
/* static prototypes */
static afs_int32 ComputeSum(struct rx_packet *apacket,
} else {
return RXKADINCONSISTENCY;
} /* unknown type */
- LOCK_RXKAD_STATS;
- rxkad_stats.destroyObject++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(destroyObject);
return 0;
}
rxkad_SetLevel(aconn, tcp->level); /* set header and trailer sizes */
rxkad_AllocCID(aobj, aconn); /* CHANGES cid AND epoch!!!! */
rxkad_DeriveXORInfo(aconn, tcp->keysched, tcp->ivec, tccp->preSeq);
- LOCK_RXKAD_STATS;
- rxkad_stats.connections[rxkad_LevelIndex(tcp->level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(connections[rxkad_LevelIndex(tcp->level)]);
}
aobj->refCount++; /* attached connection */
sconn = (struct rxkad_sconn *)aconn->securityData;
if (sconn) {
aconn->securityData = 0;
- LOCK_RXKAD_STATS;
if (sconn->authenticated)
- rxkad_stats.destroyConn[rxkad_LevelIndex(sconn->level)]++;
+ INC_RXKAD_STATS(destroyConn[rxkad_LevelIndex(sconn->level)]);
else
- rxkad_stats.destroyUnauth++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(destroyUnauth);
rock = sconn->rock;
if (rock)
rxi_Free(rock, sizeof(struct rxkad_serverinfo));
rxi_Free(sconn, sizeof(struct rxkad_sconn));
} else {
- LOCK_RXKAD_STATS;
- rxkad_stats.destroyUnused++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(destroyUnused);
}
} else { /* client */
struct rxkad_cconn *cconn;
aconn->securityData = 0;
rxi_Free(cconn, sizeof(struct rxkad_cconn));
}
- LOCK_RXKAD_STATS;
- rxkad_stats.destroyClient++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(destroyClient);
}
aobj->refCount--; /* decrement connection counter */
if (aobj->refCount <= 0) {
if (sconn && sconn->authenticated
&& (osi_Time() < sconn->expirationTime)) {
level = sconn->level;
- LOCK_RXKAD_STATS;
- rxkad_stats.checkPackets[rxkad_StatIndex(rxkad_server, level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(checkPackets[rxkad_StatIndex(rxkad_server, level)]);
sconn->stats.packetsReceived++;
sconn->stats.bytesReceived += len;
schedule = (fc_KeySchedule *) sconn->keysched;
ivec = (fc_InitializationVector *) sconn->ivec;
} else {
- LOCK_RXKAD_STATS;
- rxkad_stats.expired++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(expired);
return RXKADEXPIRED;
}
preSeq = sconn->preSeq;
if (!(tcp->type & rxkad_client))
return RXKADINCONSISTENCY;
level = tcp->level;
- LOCK_RXKAD_STATS;
- rxkad_stats.checkPackets[rxkad_StatIndex(rxkad_client, level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(checkPackets[rxkad_StatIndex(rxkad_client, level)]);
cconn->stats.packetsReceived++;
cconn->stats.bytesReceived += len;
preSeq = cconn->preSeq;
if (sconn && sconn->authenticated
&& (osi_Time() < sconn->expirationTime)) {
level = sconn->level;
- LOCK_RXKAD_STATS;
- rxkad_stats.
- preparePackets[rxkad_StatIndex(rxkad_server, level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(preparePackets[rxkad_StatIndex(rxkad_server, level)]);
sconn->stats.packetsSent++;
sconn->stats.bytesSent += len;
schedule = (fc_KeySchedule *) sconn->keysched;
ivec = (fc_InitializationVector *) sconn->ivec;
} else {
- LOCK_RXKAD_STATS;
- rxkad_stats.expired++; /* this is a pretty unlikely path... */
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(expired); /* this is a pretty unlikely path... */
return RXKADEXPIRED;
}
preSeq = sconn->preSeq;
if (!(tcp->type & rxkad_client))
return RXKADINCONSISTENCY;
level = tcp->level;
- LOCK_RXKAD_STATS;
- rxkad_stats.preparePackets[rxkad_StatIndex(rxkad_client, level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(preparePackets[rxkad_StatIndex(rxkad_client, level)]);
cconn->stats.packetsSent++;
cconn->stats.bytesSent += len;
preSeq = cconn->preSeq;
#include <rx/xdr.h>
#include <des.h>
#include <afs/afsutil.h>
+#include <des/stats.h>
#include "private_data.h"
#define XPRT_RXKAD_SERVER
tsp->user_ok = user_ok; /* to inform server of client id. */
init_random_int32();
- LOCK_RXKAD_STATS;
- rxkad_stats_serverObjects++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(serverObjects);
return tsc;
}
rx_packetwrite(apacket, 0, challengeSize, challenge);
rx_SetDataSize(apacket, challengeSize);
sconn->tried = 1;
- LOCK_RXKAD_STATS;
- rxkad_stats.challengesSent++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(challengesSent);
return 0;
}
return RXKADLEVELFAIL;
sconn->level = level;
rxkad_SetLevel(aconn, sconn->level);
- LOCK_RXKAD_STATS;
- rxkad_stats.responses[rxkad_LevelIndex(sconn->level)]++;
- UNLOCK_RXKAD_STATS;
+ INC_RXKAD_STATS(responses[rxkad_LevelIndex(sconn->level)]);
/* now compute endpoint-specific info used for computing 16 bit checksum */
rxkad_DeriveXORInfo(aconn, sconn->keysched, sconn->ivec, sconn->preSeq);
xdr_afsuuid
xdr_int64
hton_syserr_conv
-rxkad_stats
+rxkad_global_stats
+rxkad_global_stats_lock
+rxkad_stats_key
_et_list
et_list_mutex
com_err
tkt_MakeTicket;
xdrrx_create;
hton_syserr_conv;
- rxkad_stats;
+ rxkad_global_stats;
+ rxkad_global_stats_lock;
+ rxkad_stats_key;
com_err;
error_message;
rx_socket;
git://git.openafs.org / openafs.git / commitdiff