#ifdef AFS_AIX_ENV
#include "h/systm.h"
#endif
-#ifdef AFS_DARWIN60_ENV
+#if defined(AFS_DARWIN60_ENV) || defined(AFS_OBSD_ENV)
#include "h/kernel.h"
#endif
#include "h/types.h"
#endif /* KERNEL */
+#include <des/stats.h>
#include "private_data.h"
#define XPRT_RXKAD_COMMON
-char *rxi_Alloc();
-
#ifndef afs_max
#define afs_max(a,b) ((a) < (b)? (b) : (a))
#endif /* afs_max */
#ifndef KERNEL
#define osi_Time() time(0)
#endif
-struct rxkad_stats rxkad_stats;
+/* 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 */
+/* Move delaration of this to des/key_sched.c */
+/* 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 return 0;
+ INC_RXKAD_STATS(destroyObject);
+ return 0;
}
/* rxkad_Close - called by rx with the security class object as a parameter
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 */
return 0;
sconn = (struct rxkad_sconn *)aconn->securityData;
if (sconn) {
aconn->securityData = 0;
- LOCK_RXKAD_STATS if (sconn->authenticated)
- rxkad_stats.destroyConn[rxkad_LevelIndex(sconn->level)]++;
+ if (sconn->authenticated)
+ INC_RXKAD_STATS(destroyConn[rxkad_LevelIndex(sconn->level)]);
else
- rxkad_stats.destroyUnauth++;
- UNLOCK_RXKAD_STATS rock = sconn->rock;
+ 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;
struct rxkad_cprivate *tcp;
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) {
afs_int32 code;
fc_KeySchedule *schedule;
fc_InitializationVector *ivec;
int len;
- int nlen;
+ int nlen = 0;
u_int word; /* so we get unsigned right-shift */
int checkCksum;
afs_int32 *preSeq;
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 sconn->stats.packetsReceived++;
+ 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 return RXKADEXPIRED;
+ INC_RXKAD_STATS(expired);
+ return RXKADEXPIRED;
}
preSeq = sconn->preSeq;
} else { /* client connection */
if (!(tcp->type & rxkad_client))
return RXKADINCONSISTENCY;
level = tcp->level;
- LOCK_RXKAD_STATS rxkad_stats.
- checkPackets[rxkad_StatIndex(rxkad_client, level)]++;
- UNLOCK_RXKAD_STATS cconn->stats.packetsReceived++;
+ INC_RXKAD_STATS(checkPackets[rxkad_StatIndex(rxkad_client, level)]);
+ cconn->stats.packetsReceived++;
cconn->stats.bytesReceived += len;
preSeq = cconn->preSeq;
schedule = (fc_KeySchedule *) tcp->keysched;
fc_KeySchedule *schedule;
fc_InitializationVector *ivec;
int len;
- int nlen;
+ int nlen = 0;
int word;
afs_int32 code;
afs_int32 *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 sconn->stats.packetsSent++;
+ 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 return RXKADEXPIRED;
+ INC_RXKAD_STATS(expired); /* this is a pretty unlikely path... */
+ return RXKADEXPIRED;
}
preSeq = sconn->preSeq;
} else { /* client connection */
if (!(tcp->type & rxkad_client))
return RXKADINCONSISTENCY;
level = tcp->level;
- LOCK_RXKAD_STATS rxkad_stats.
- preparePackets[rxkad_StatIndex(rxkad_client, level)]++;
- UNLOCK_RXKAD_STATS cconn->stats.packetsSent++;
+ INC_RXKAD_STATS(preparePackets[rxkad_StatIndex(rxkad_client, level)]);
+ cconn->stats.packetsSent++;
cconn->stats.bytesSent += len;
preSeq = cconn->preSeq;
schedule = (fc_KeySchedule *) tcp->keysched;
}
return 0;
}
+
+rxkad_level
+rxkad_StringToLevel(char *name)
+{
+ if (strcmp(name, "clear") == 0)
+ return rxkad_clear;
+ if (strcmp(name, "auth") == 0)
+ return rxkad_auth;
+ if (strcmp(name, "crypt") == 0)
+ return rxkad_crypt;
+ return -1;
+}
+
+char *
+rxkad_LevelToString(rxkad_level level)
+{
+ if (level == rxkad_clear)
+ return "clear";
+ if (level == rxkad_auth)
+ return "auth";
+ if (level == rxkad_crypt)
+ return "crypt";
+ return "unknown";
+}
git://git.openafs.org / openafs.git / blobdiff