#include <afs/param.h>
#endif
-RCSID
- ("$Header$");
#ifdef KERNEL
#include "afs/sysincludes.h"
#include "h/socket.h"
#endif
#include "netinet/in.h"
+#ifdef AFS_SUN57_ENV
+#include "inet/common.h"
+#include "inet/ip.h"
+#include "inet/ip_ire.h"
+#endif
#include "afs/afs_args.h"
#include "afs/afs_osi.h"
#ifdef RX_KERNEL_TRACE
# include "rxgen_consts.h"
#else /* KERNEL */
# include <sys/types.h>
+# include <string.h>
+# include <stdarg.h>
# include <errno.h>
#ifdef AFS_NT40_ENV
# include <stdlib.h>
# include <fcntl.h>
# include <afs/afsutil.h>
+# include <WINNT\afsreg.h>
#else
# include <sys/socket.h>
# include <sys/file.h>
# include <netinet/in.h>
# include <sys/time.h>
#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-#endif
# include "rx.h"
# include "rx_user.h"
# include "rx_clock.h"
# include <afs/rxgen_consts.h>
#endif /* KERNEL */
-int (*registerProgram) () = 0;
-int (*swapNameProgram) () = 0;
+#ifndef KERNEL
+#ifdef AFS_PTHREAD_ENV
+#ifndef AFS_NT40_ENV
+int (*registerProgram) (pid_t, char *) = 0;
+int (*swapNameProgram) (pid_t, const char *, char *) = 0;
+#endif
+#else
+int (*registerProgram) (PROCESS, char *) = 0;
+int (*swapNameProgram) (PROCESS, const char *, char *) = 0;
+#endif
+#endif
/* Local static routines */
-static void rxi_DestroyConnectionNoLock(register struct rx_connection *conn);
+static void rxi_DestroyConnectionNoLock(struct rx_connection *conn);
#ifdef RX_ENABLE_LOCKS
-static void rxi_SetAcksInTransmitQueue(register struct rx_call *call);
+static void rxi_SetAcksInTransmitQueue(struct rx_call *call);
#endif
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
* to ease NT porting
*/
-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;
-extern pthread_mutex_t rxi_connCacheMutex;
-extern pthread_mutex_t rx_event_mutex;
-extern pthread_mutex_t osi_malloc_mutex;
-extern pthread_mutex_t event_handler_mutex;
-extern pthread_mutex_t listener_mutex;
-extern pthread_mutex_t rx_if_init_mutex;
-extern pthread_mutex_t rx_if_mutex;
-extern pthread_mutex_t rxkad_client_uid_mutex;
-extern pthread_mutex_t rxkad_random_mutex;
-
-extern pthread_cond_t rx_event_handler_cond;
-extern pthread_cond_t rx_listener_cond;
-
-static pthread_mutex_t epoch_mutex;
-static pthread_mutex_t rx_init_mutex;
-static pthread_mutex_t rx_debug_mutex;
+extern afs_kmutex_t rx_stats_mutex;
+extern afs_kmutex_t rx_waiting_mutex;
+extern afs_kmutex_t rx_quota_mutex;
+extern afs_kmutex_t rx_pthread_mutex;
+extern afs_kmutex_t rx_packets_mutex;
+extern afs_kmutex_t des_init_mutex;
+extern afs_kmutex_t des_random_mutex;
+extern afs_kmutex_t rx_clock_mutex;
+extern afs_kmutex_t rxi_connCacheMutex;
+extern afs_kmutex_t rx_event_mutex;
+extern afs_kmutex_t osi_malloc_mutex;
+extern afs_kmutex_t event_handler_mutex;
+extern afs_kmutex_t listener_mutex;
+extern afs_kmutex_t rx_if_init_mutex;
+extern afs_kmutex_t rx_if_mutex;
+extern afs_kmutex_t rxkad_client_uid_mutex;
+extern afs_kmutex_t rxkad_random_mutex;
+
+extern afs_kcondvar_t rx_event_handler_cond;
+extern afs_kcondvar_t rx_listener_cond;
+
+static afs_kmutex_t epoch_mutex;
+static afs_kmutex_t rx_init_mutex;
+static afs_kmutex_t rx_debug_mutex;
+static afs_kmutex_t rx_rpc_stats;
static void
rxi_InitPthread(void)
{
- assert(pthread_mutex_init(&rx_clock_mutex, (const pthread_mutexattr_t *)0)
- == 0);
- assert(pthread_mutex_init(&rx_stats_mutex, (const pthread_mutexattr_t *)0)
- == 0);
- assert(pthread_mutex_init
- (&rxi_connCacheMutex, (const pthread_mutexattr_t *)0) == 0);
- assert(pthread_mutex_init(&rx_init_mutex, (const pthread_mutexattr_t *)0)
- == 0);
- assert(pthread_mutex_init(&epoch_mutex, (const pthread_mutexattr_t *)0) ==
- 0);
- assert(pthread_mutex_init(&rx_event_mutex, (const pthread_mutexattr_t *)0)
- == 0);
- assert(pthread_mutex_init(&des_init_mutex, (const pthread_mutexattr_t *)0)
- == 0);
- assert(pthread_mutex_init
- (&des_random_mutex, (const pthread_mutexattr_t *)0) == 0);
- assert(pthread_mutex_init
- (&osi_malloc_mutex, (const pthread_mutexattr_t *)0) == 0);
- assert(pthread_mutex_init
- (&event_handler_mutex, (const pthread_mutexattr_t *)0) == 0);
- assert(pthread_mutex_init(&listener_mutex, (const pthread_mutexattr_t *)0)
- == 0);
- assert(pthread_mutex_init
- (&rx_if_init_mutex, (const pthread_mutexattr_t *)0) == 0);
- assert(pthread_mutex_init(&rx_if_mutex, (const pthread_mutexattr_t *)0) ==
- 0);
- assert(pthread_mutex_init
- (&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);
+ MUTEX_INIT(&rx_clock_mutex, "clock", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_stats_mutex, "stats", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_waiting_mutex, "waiting", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_quota_mutex, "quota", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_pthread_mutex, "pthread", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_packets_mutex, "packets", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&epoch_mutex, "epoch", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_init_mutex, "init", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_event_mutex, "event", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&des_init_mutex, "des", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&des_random_mutex, "random", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&osi_malloc_mutex, "malloc", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&event_handler_mutex, "event handler", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rxi_connCacheMutex, "conn cache", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&listener_mutex, "listener", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_if_init_mutex, "if init", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_if_mutex, "if", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rxkad_client_uid_mutex, "uid", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rxkad_random_mutex, "rxkad random", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_debug_mutex, "debug", MUTEX_DEFAULT, 0);
assert(pthread_cond_init
(&rx_event_handler_cond, (const pthread_condattr_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();
+
+ MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
+#ifdef RX_ENABLE_LOCKS
+#ifdef RX_LOCKS_DB
+ rxdb_init();
+#endif /* RX_LOCKS_DB */
+ MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock", MUTEX_DEFAULT,
+ 0);
+ CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
+ 0);
+ MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
+ 0);
+ MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
+ 0);
+ MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rxi_keyCreate_lock, "rxi_keyCreate_lock", MUTEX_DEFAULT, 0);
+#endif /* RX_ENABLE_LOCKS */
}
pthread_once_t rx_once_init = PTHREAD_ONCE_INIT;
assert(pthread_once(&rx_once_init, rxi_InitPthread)==0)
/*
* The rx_stats_mutex mutex protects the following global variables:
- * rxi_dataQuota
- * rxi_minDeficit
- * rxi_availProcs
- * rxi_totalMin
* rxi_lowConnRefCount
* rxi_lowPeerRefCount
* rxi_nCalls
* rxi_Alloccnt
* rxi_Allocsize
- * rx_nFreePackets
* rx_tq_debug
* rx_stats
*/
+
+/*
+ * The rx_quota_mutex mutex protects the following global variables:
+ * rxi_dataQuota
+ * rxi_minDeficit
+ * rxi_availProcs
+ * rxi_totalMin
+ */
+
+/*
+ * The rx_freePktQ_lock protects the following global variables:
+ * rx_nFreePackets
+ */
+
+/*
+ * The rx_packets_mutex mutex protects the following global variables:
+ * rx_nPackets
+ * rx_TSFPQLocalMax
+ * rx_TSFPQGlobSize
+ * rx_TSFPQMaxProcs
+ */
+
+/*
+ * The rx_pthread_mutex mutex protects the following global variables:
+ * rxi_pthread_hinum
+ */
#else
#define INIT_PTHREAD_LOCKS
#endif
* to manipulate the queue.
*/
-#ifdef RX_ENABLE_LOCKS
+#if defined(RX_ENABLE_LOCKS) && defined(KERNEL)
static afs_kmutex_t rx_rpc_stats;
-void rxi_StartUnlocked();
+void rxi_StartUnlocked(struct rxevent *event, void *call,
+ void *arg1, int istack);
#endif
/* We keep a "last conn pointer" in rxi_FindConnection. The odds are
* rx_epoch
*/
-#define LOCK_EPOCH assert(pthread_mutex_lock(&epoch_mutex)==0)
-#define UNLOCK_EPOCH assert(pthread_mutex_unlock(&epoch_mutex)==0)
+#define LOCK_EPOCH MUTEX_ENTER(&epoch_mutex)
+#define UNLOCK_EPOCH MUTEX_EXIT(&epoch_mutex)
#else
#define LOCK_EPOCH
#define UNLOCK_EPOCH
* by the kernel. Whether this will ever overlap anything in
* /etc/services is anybody's guess... Returns 0 on success, -1 on
* error. */
-static int rxinit_status = 1;
+#ifndef AFS_NT40_ENV
+static
+#endif
+int rxinit_status = 1;
#ifdef AFS_PTHREAD_ENV
/*
* This mutex protects the following global variables:
* rxinit_status
*/
-#define LOCK_RX_INIT assert(pthread_mutex_lock(&rx_init_mutex)==0)
-#define UNLOCK_RX_INIT assert(pthread_mutex_unlock(&rx_init_mutex)==0)
+#define LOCK_RX_INIT MUTEX_ENTER(&rx_init_mutex)
+#define UNLOCK_RX_INIT MUTEX_EXIT(&rx_init_mutex)
#else
#define LOCK_RX_INIT
#define UNLOCK_RX_INIT
#endif /* KERNEL */
char *htable, *ptable;
int tmp_status;
-
-#if defined(AFS_DJGPP_ENV) && !defined(DEBUG)
- __djgpp_set_quiet_socket(1);
-#endif
-
+
SPLVAR;
-
+
INIT_PTHREAD_LOCKS;
LOCK_RX_INIT;
if (rxinit_status == 0) {
UNLOCK_RX_INIT;
return tmp_status; /* Already started; return previous error code. */
}
+#ifdef RXDEBUG
+ rxi_DebugInit();
+#endif
#ifdef AFS_NT40_ENV
if (afs_winsockInit() < 0)
return -1;
UNLOCK_RX_INIT;
return RX_ADDRINUSE;
}
-#ifdef RX_ENABLE_LOCKS
+#if defined(RX_ENABLE_LOCKS) && defined(KERNEL)
#ifdef RX_LOCKS_DB
rxdb_init();
#endif /* RX_LOCKS_DB */
MUTEX_INIT(&rx_stats_mutex, "rx_stats_mutex", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_waiting_mutex, "rx_waiting_mutex", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_quota_mutex, "rx_quota_mutex", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_pthread_mutex, "rx_pthread_mutex", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&rx_packets_mutex, "rx_packets_mutex", MUTEX_DEFAULT, 0);
MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
0);
MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
-#ifndef KERNEL
- MUTEX_INIT(&rxi_keyCreate_lock, "rxi_keyCreate_lock", MUTEX_DEFAULT, 0);
-#endif /* !KERNEL */
-#if defined(KERNEL) && defined(AFS_HPUX110_ENV)
+#if defined(AFS_HPUX110_ENV)
if (!uniprocessor)
rx_sleepLock = alloc_spinlock(LAST_HELD_ORDER - 10, "rx_sleepLock");
-#endif /* KERNEL && AFS_HPUX110_ENV */
-#else /* RX_ENABLE_LOCKS */
-#if defined(KERNEL) && defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_OBSD_ENV)
- mutex_init(&afs_rxglobal_lock, "afs_rxglobal_lock", MUTEX_DEFAULT, NULL);
-#endif /* AFS_GLOBAL_SUNLOCK */
-#endif /* RX_ENABLE_LOCKS */
+#endif /* AFS_HPUX110_ENV */
+#endif /* RX_ENABLE_LOCKS && KERNEL */
rxi_nCalls = 0;
rx_connDeadTime = 12;
rx_tranquil = 0; /* reset flag */
- memset((char *)&rx_stats, 0, sizeof(struct rx_stats));
+ memset((char *)&rx_stats, 0, sizeof(struct rx_statistics));
htable = (char *)
osi_Alloc(rx_hashTableSize * sizeof(struct rx_connection *));
PIN(htable, rx_hashTableSize * sizeof(struct rx_connection *)); /* XXXXX */
rx_port = 0;
#else
struct sockaddr_in addr;
- int addrlen = sizeof(addr);
+#ifdef AFS_NT40_ENV
+ int addrlen = sizeof(addr);
+#else
+ socklen_t addrlen = sizeof(addr);
+#endif
if (getsockname((int)rx_socket, (struct sockaddr *)&addr, &addrlen)) {
rx_Finalize();
return -1;
rx_SetEpoch(tv.tv_sec); /* Start time of this package, rxkad
* will provide a randomer value. */
#endif
- MUTEX_ENTER(&rx_stats_mutex);
- rxi_dataQuota += rx_extraQuota; /* + extra pkts caller asked to rsrv */
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_ENTER(&rx_quota_mutex);
+ rxi_dataQuota += rx_extraQuota; /* + extra pkts caller asked to rsrv */
+ MUTEX_EXIT(&rx_quota_mutex);
/* *Slightly* random start time for the cid. This is just to help
* out with the hashing function at the peer */
rx_nextCid = ((tv.tv_sec ^ tv.tv_usec) << RX_CIDSHIFT);
* rx_serverPool_lock is held. Return quota using ReturnToServerPool().
*/
static int
-QuotaOK(register struct rx_service *aservice)
+QuotaOK(struct rx_service *aservice)
{
/* check if over max quota */
if (aservice->nRequestsRunning >= aservice->maxProcs) {
/* otherwise, can use only if there are enough to allow everyone
* to go to their min quota after this guy starts.
*/
- MUTEX_ENTER(&rx_stats_mutex);
+
+ MUTEX_ENTER(&rx_quota_mutex);
if ((aservice->nRequestsRunning < aservice->minProcs)
|| (rxi_availProcs > rxi_minDeficit)) {
aservice->nRequestsRunning++;
if (aservice->nRequestsRunning <= aservice->minProcs)
rxi_minDeficit--;
rxi_availProcs--;
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_EXIT(&rx_quota_mutex);
return 1;
}
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_EXIT(&rx_quota_mutex);
return 0;
}
static void
-ReturnToServerPool(register struct rx_service *aservice)
+ReturnToServerPool(struct rx_service *aservice)
{
aservice->nRequestsRunning--;
- MUTEX_ENTER(&rx_stats_mutex);
+ MUTEX_ENTER(&rx_quota_mutex);
if (aservice->nRequestsRunning < aservice->minProcs)
rxi_minDeficit++;
rxi_availProcs++;
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_EXIT(&rx_quota_mutex);
}
#else /* RX_ENABLE_LOCKS */
static int
-QuotaOK(register struct rx_service *aservice)
+QuotaOK(struct rx_service *aservice)
{
int rc = 0;
/* under min quota, we're OK */
void
rxi_StartServerProcs(int nExistingProcs)
{
- register struct rx_service *service;
- register int i;
+ struct rx_service *service;
+ int i;
int maxdiff = 0;
int nProcs = 0;
}
nProcs += maxdiff; /* Extra processes needed to allow max number requested to run in any given service, under good conditions */
nProcs -= nExistingProcs; /* Subtract the number of procs that were previously created for use as server procs */
-#ifdef RX_ENABLE_TSFPQ
- rx_TSFPQMaxProcs += nProcs;
- RX_TS_FPQ_COMPUTE_LIMITS;
-#endif /* RX_ENABLE_TSFPQ */
for (i = 0; i < nProcs; i++) {
rxi_StartServerProc(rx_ServerProc, rx_stackSize);
}
rx_StartClientThread(void)
{
#ifdef AFS_PTHREAD_ENV
- int pid;
- pid = (int) pthread_self();
+ pthread_t pid;
+ pid = pthread_self();
#endif /* AFS_PTHREAD_ENV */
-#ifdef RX_ENABLE_TSFPQ
- rx_TSFPQMaxProcs++;
- RX_TS_FPQ_COMPUTE_LIMITS;
-#endif /* RX_ENABLE_TSFPQ */
}
#endif /* AFS_NT40_ENV */
void
rx_StartServer(int donateMe)
{
- register struct rx_service *service;
- register int i;
+ struct rx_service *service;
+ int i;
SPLVAR;
clock_NewTime();
service = rx_services[i];
if (service == (struct rx_service *)0)
break;
- MUTEX_ENTER(&rx_stats_mutex);
+ MUTEX_ENTER(&rx_quota_mutex);
rxi_totalMin += service->minProcs;
/* below works even if a thread is running, since minDeficit would
* still have been decremented and later re-incremented.
*/
rxi_minDeficit += service->minProcs;
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_EXIT(&rx_quota_mutex);
}
/* Turn on reaping of idle server connections */
- rxi_ReapConnections();
+ rxi_ReapConnections(NULL, NULL, NULL);
USERPRI;
(*registerProgram) (pid, name);
#endif /* KERNEL */
#endif /* AFS_NT40_ENV */
- rx_ServerProc(); /* Never returns */
+ rx_ServerProc(NULL); /* Never returns */
}
+#ifdef RX_ENABLE_TSFPQ
+ /* no use leaving packets around in this thread's local queue if
+ * it isn't getting donated to the server thread pool.
+ */
+ rxi_FlushLocalPacketsTSFPQ();
+#endif /* RX_ENABLE_TSFPQ */
return;
}
* specified security object to implement the security model for this
* connection. */
struct rx_connection *
-rx_NewConnection(register afs_uint32 shost, u_short sport, u_short sservice,
- register struct rx_securityClass *securityObject,
+rx_NewConnection(afs_uint32 shost, u_short sport, u_short sservice,
+ struct rx_securityClass *securityObject,
int serviceSecurityIndex)
{
- int hashindex;
+ int hashindex, i;
afs_int32 cid;
- register struct rx_connection *conn;
+ struct rx_connection *conn;
SPLVAR;
clock_NewTime();
- dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", shost, sport, sservice, securityObject, serviceSecurityIndex));
+ dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", ntohl(shost), ntohs(sport), sservice, securityObject, serviceSecurityIndex));
/* Vasilsi said: "NETPRI protects Cid and Alloc", but can this be true in
* the case of kmem_alloc? */
conn = rxi_AllocConnection();
#ifdef RX_ENABLE_LOCKS
MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
- MUTEX_INIT(&conn->conn_data_lock, "conn call lock", MUTEX_DEFAULT, 0);
+ MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
#endif
NETPRI;
conn->peer = rxi_FindPeer(shost, sport, 0, 1);
conn->serviceId = sservice;
conn->securityObject = securityObject;
- /* This doesn't work in all compilers with void (they're buggy), so fake it
- * with VOID */
- conn->securityData = (VOID *) 0;
+ conn->securityData = (void *) 0;
conn->securityIndex = serviceSecurityIndex;
rx_SetConnDeadTime(conn, rx_connDeadTime);
conn->ackRate = RX_FAST_ACK_RATE;
conn->delayedAbortEvent = NULL;
conn->abortCount = 0;
conn->error = 0;
+ for (i = 0; i < RX_MAXCALLS; i++) {
+ conn->twind[i] = rx_initSendWindow;
+ conn->rwind[i] = rx_initReceiveWindow;
+ }
RXS_NewConnection(securityObject, conn);
hashindex =
conn->refCount++; /* no lock required since only this thread knows... */
conn->next = rx_connHashTable[hashindex];
rx_connHashTable[hashindex] = conn;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nClientConns++;
- MUTEX_EXIT(&rx_stats_mutex);
-
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.nClientConns, rx_stats_mutex);
MUTEX_EXIT(&rx_connHashTable_lock);
USERPRI;
return conn;
}
void
-rx_SetConnDeadTime(register struct rx_connection *conn, register int seconds)
+rx_SetConnDeadTime(struct rx_connection *conn, int seconds)
{
/* The idea is to set the dead time to a value that allows several
* keepalives to be dropped without timing out the connection. */
conn->peer->idleWhen = clock_Sec();
if (conn->peer->refCount < 1) {
conn->peer->refCount = 1;
- MUTEX_ENTER(&rx_stats_mutex);
- rxi_lowPeerRefCount++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active) {
+ MUTEX_ENTER(&rx_stats_mutex);
+ rxi_lowPeerRefCount++;
+ MUTEX_EXIT(&rx_stats_mutex);
+ }
}
}
conn->peer->refCount--;
MUTEX_EXIT(&rx_peerHashTable_lock);
- MUTEX_ENTER(&rx_stats_mutex);
- if (conn->type == RX_SERVER_CONNECTION)
- rx_stats.nServerConns--;
- else
- rx_stats.nClientConns--;
- MUTEX_EXIT(&rx_stats_mutex);
-
+ if (rx_stats_active)
+ {
+ if (conn->type == RX_SERVER_CONNECTION)
+ rx_MutexDecrement(rx_stats.nServerConns, rx_stats_mutex);
+ else
+ rx_MutexDecrement(rx_stats.nClientConns, rx_stats_mutex);
+ }
#ifndef KERNEL
if (conn->specific) {
int i;
/* Destroy the specified connection */
void
-rxi_DestroyConnection(register struct rx_connection *conn)
+rxi_DestroyConnection(struct rx_connection *conn)
{
MUTEX_ENTER(&rx_connHashTable_lock);
rxi_DestroyConnectionNoLock(conn);
}
static void
-rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
+rxi_DestroyConnectionNoLock(struct rx_connection *conn)
{
- register struct rx_connection **conn_ptr;
- register int havecalls = 0;
+ struct rx_connection **conn_ptr;
+ int havecalls = 0;
struct rx_packet *packet;
int i;
SPLVAR;
if (conn->refCount > 0)
conn->refCount--;
else {
- MUTEX_ENTER(&rx_stats_mutex);
- rxi_lowConnRefCount++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active) {
+ MUTEX_ENTER(&rx_stats_mutex);
+ rxi_lowConnRefCount++;
+ MUTEX_EXIT(&rx_stats_mutex);
+ }
}
if ((conn->refCount > 0) || (conn->flags & RX_CONN_BUSY)) {
/* Check for extant references to this connection */
for (i = 0; i < RX_MAXCALLS; i++) {
- register struct rx_call *call = conn->call[i];
+ struct rx_call *call = conn->call[i];
if (call) {
havecalls = 1;
if (conn->type == RX_CLIENT_CONNECTION) {
/* Externally available version */
void
-rx_DestroyConnection(register struct rx_connection *conn)
+rx_DestroyConnection(struct rx_connection *conn)
{
SPLVAR;
}
void
-rx_GetConnection(register struct rx_connection *conn)
+rx_GetConnection(struct rx_connection *conn)
{
SPLVAR;
USERPRI;
}
+#ifdef AFS_GLOBAL_RXLOCK_KERNEL
+/* Wait for the transmit queue to no longer be busy.
+ * requires the call->lock to be held */
+static void rxi_WaitforTQBusy(struct rx_call *call) {
+ while (call->flags & RX_CALL_TQ_BUSY) {
+ call->flags |= RX_CALL_TQ_WAIT;
+ call->tqWaiters++;
+#ifdef RX_ENABLE_LOCKS
+ osirx_AssertMine(&call->lock, "rxi_WaitforTQ lock");
+ CV_WAIT(&call->cv_tq, &call->lock);
+#else /* RX_ENABLE_LOCKS */
+ osi_rxSleep(&call->tq);
+#endif /* RX_ENABLE_LOCKS */
+ call->tqWaiters--;
+ if (call->tqWaiters == 0) {
+ call->flags &= ~RX_CALL_TQ_WAIT;
+ }
+ }
+}
+#endif
+
/* Start a new rx remote procedure call, on the specified connection.
* If wait is set to 1, wait for a free call channel; otherwise return
* 0. Maxtime gives the maximum number of seconds this call may take,
- * after rx_MakeCall returns. After this time interval, a call to any
+ * after rx_NewCall returns. After this time interval, a call to any
* of rx_SendData, rx_ReadData, etc. will fail with RX_CALL_TIMEOUT.
* For fine grain locking, we hold the conn_call_lock in order to
* to ensure that we don't get signalle after we found a call in an active
* state and before we go to sleep.
*/
struct rx_call *
-rx_NewCall(register struct rx_connection *conn)
+rx_NewCall(struct rx_connection *conn)
{
- register int i;
- register struct rx_call *call;
+ int i;
+ struct rx_call *call;
struct clock queueTime;
SPLVAR;
clock_NewTime();
- dpf(("rx_MakeCall(conn %x)\n", conn));
+ dpf(("rx_NewCall(conn %x)\n", conn));
NETPRI;
clock_GetTime(&queueTime);
* If so, let them go first to avoid starving them.
* This is a fairly simple scheme, and might not be
* a complete solution for large numbers of waiters.
+ *
+ * makeCallWaiters keeps track of the number of
+ * threads waiting to make calls and the
+ * RX_CONN_MAKECALL_WAITING flag bit is used to
+ * indicate that there are indeed calls waiting.
+ * The flag is set when the waiter is incremented.
+ * It is only cleared in rx_EndCall when
+ * makeCallWaiters is 0. This prevents us from
+ * accidently destroying the connection while it
+ * is potentially about to be used.
*/
+ MUTEX_ENTER(&conn->conn_data_lock);
if (conn->makeCallWaiters) {
+ conn->flags |= RX_CONN_MAKECALL_WAITING;
+ conn->makeCallWaiters++;
+ MUTEX_EXIT(&conn->conn_data_lock);
+
#ifdef RX_ENABLE_LOCKS
- CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
+ CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
#else
- osi_rxSleep(conn);
+ osi_rxSleep(conn);
#endif
- }
+ MUTEX_ENTER(&conn->conn_data_lock);
+ conn->makeCallWaiters--;
+ }
+ MUTEX_EXIT(&conn->conn_data_lock);
for (;;) {
for (i = 0; i < RX_MAXCALLS; i++) {
}
MUTEX_ENTER(&conn->conn_data_lock);
conn->flags |= RX_CONN_MAKECALL_WAITING;
+ conn->makeCallWaiters++;
MUTEX_EXIT(&conn->conn_data_lock);
- conn->makeCallWaiters++;
#ifdef RX_ENABLE_LOCKS
CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
#else
osi_rxSleep(conn);
#endif
+ MUTEX_ENTER(&conn->conn_data_lock);
conn->makeCallWaiters--;
+ MUTEX_EXIT(&conn->conn_data_lock);
}
/*
* Wake up anyone else who might be giving us a chance to
/* Client is initially in send mode */
call->state = RX_STATE_ACTIVE;
- call->mode = RX_MODE_SENDING;
-
+ call->error = conn->error;
+ if (call->error)
+ call->mode = RX_MODE_ERROR;
+ else
+ call->mode = RX_MODE_SENDING;
+
/* remember start time for call in case we have hard dead time limit */
call->queueTime = queueTime;
clock_GetTime(&call->startTime);
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
/* Now, if TQ wasn't cleared earlier, do it now. */
MUTEX_ENTER(&call->lock);
- while (call->flags & RX_CALL_TQ_BUSY) {
- call->flags |= RX_CALL_TQ_WAIT;
-#ifdef RX_ENABLE_LOCKS
- CV_WAIT(&call->cv_tq, &call->lock);
-#else /* RX_ENABLE_LOCKS */
- osi_rxSleep(&call->tq);
-#endif /* RX_ENABLE_LOCKS */
- }
+ rxi_WaitforTQBusy(call);
if (call->flags & RX_CALL_TQ_CLEARME) {
- rxi_ClearTransmitQueue(call, 0);
- queue_Init(&call->tq);
+ rxi_ClearTransmitQueue(call, 1);
+ /*queue_Init(&call->tq);*/
}
MUTEX_EXIT(&call->lock);
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
+ dpf(("rx_NewCall(call %x)\n", call));
return call;
}
int
-rxi_HasActiveCalls(register struct rx_connection *aconn)
+rxi_HasActiveCalls(struct rx_connection *aconn)
{
- register int i;
- register struct rx_call *tcall;
+ int i;
+ struct rx_call *tcall;
SPLVAR;
NETPRI;
}
int
-rxi_GetCallNumberVector(register struct rx_connection *aconn,
- register afs_int32 * aint32s)
+rxi_GetCallNumberVector(struct rx_connection *aconn,
+ afs_int32 * aint32s)
{
- register int i;
- register struct rx_call *tcall;
+ int i;
+ struct rx_call *tcall;
SPLVAR;
NETPRI;
}
int
-rxi_SetCallNumberVector(register struct rx_connection *aconn,
- register afs_int32 * aint32s)
+rxi_SetCallNumberVector(struct rx_connection *aconn,
+ afs_int32 * aint32s)
{
- register int i;
- register struct rx_call *tcall;
+ int i;
+ struct rx_call *tcall;
SPLVAR;
NETPRI;
service name might be used for probing for
statistics) */
struct rx_service *
-rx_NewService(u_short port, u_short serviceId, char *serviceName,
- struct rx_securityClass **securityObjects, int nSecurityObjects,
- afs_int32(*serviceProc) (struct rx_call * acall))
+rx_NewServiceHost(afs_uint32 host, u_short port, u_short serviceId,
+ char *serviceName, struct rx_securityClass **securityObjects,
+ int nSecurityObjects,
+ afs_int32(*serviceProc) (struct rx_call * acall))
{
osi_socket socket = OSI_NULLSOCKET;
- register struct rx_service *tservice;
- register int i;
+ struct rx_service *tservice;
+ int i;
SPLVAR;
clock_NewTime();
tservice = rxi_AllocService();
NETPRI;
for (i = 0; i < RX_MAX_SERVICES; i++) {
- register struct rx_service *service = rx_services[i];
+ struct rx_service *service = rx_services[i];
if (service) {
- if (port == service->servicePort) {
+ if (port == service->servicePort && host == service->serviceHost) {
if (service->serviceId == serviceId) {
/* The identical service has already been
* installed; if the caller was intending to
if (socket == OSI_NULLSOCKET) {
/* If we don't already have a socket (from another
* service on same port) get a new one */
- socket = rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
+ socket = rxi_GetHostUDPSocket(host, port);
if (socket == OSI_NULLSOCKET) {
USERPRI;
rxi_FreeService(tservice);
}
service = tservice;
service->socket = socket;
+ service->serviceHost = host;
service->servicePort = port;
service->serviceId = serviceId;
service->serviceName = serviceName;
service->minProcs = 0;
service->maxProcs = 1;
service->idleDeadTime = 60;
+ service->idleDeadErr = 0;
service->connDeadTime = rx_connDeadTime;
service->executeRequestProc = serviceProc;
service->checkReach = 0;
return 0;
}
+/* Set configuration options for all of a service's security objects */
+
+afs_int32
+rx_SetSecurityConfiguration(struct rx_service *service,
+ rx_securityConfigVariables type,
+ void *value)
+{
+ int i;
+ for (i = 0; i<service->nSecurityObjects; i++) {
+ if (service->securityObjects[i]) {
+ RXS_SetConfiguration(service->securityObjects[i], NULL, type,
+ value, NULL);
+ }
+ }
+ return 0;
+}
+
+struct rx_service *
+rx_NewService(u_short port, u_short serviceId, char *serviceName,
+ struct rx_securityClass **securityObjects, int nSecurityObjects,
+ afs_int32(*serviceProc) (struct rx_call * acall))
+{
+ return rx_NewServiceHost(htonl(INADDR_ANY), port, serviceId, serviceName, securityObjects, nSecurityObjects, serviceProc);
+}
+
/* Generic request processing loop. This routine should be called
* by the implementation dependent rx_ServerProc. If socketp is
* non-null, it will be set to the file descriptor that this thread
void
rxi_ServerProc(int threadID, struct rx_call *newcall, osi_socket * socketp)
{
- register struct rx_call *call;
- register afs_int32 code;
- register struct rx_service *tservice = NULL;
+ struct rx_call *call;
+ afs_int32 code;
+ struct rx_service *tservice = NULL;
for (;;) {
if (newcall) {
(*tservice->afterProc) (call, code);
rx_EndCall(call, code);
- MUTEX_ENTER(&rx_stats_mutex);
- rxi_nCalls++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active) {
+ MUTEX_ENTER(&rx_stats_mutex);
+ rxi_nCalls++;
+ MUTEX_EXIT(&rx_stats_mutex);
+ }
}
}
rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
{
struct rx_serverQueueEntry *sq;
- register struct rx_call *call = (struct rx_call *)0;
+ struct rx_call *call = (struct rx_call *)0;
struct rx_service *service = NULL;
SPLVAR;
}
while (1) {
if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
- register struct rx_call *tcall, *ncall, *choice2 = NULL;
+ struct rx_call *tcall, *ncall, *choice2 = NULL;
/* Scan for eligible incoming calls. A call is not eligible
* if the maximum number of calls for its service type are
if (!QuotaOK(service)) {
continue;
}
+ MUTEX_ENTER(&rx_pthread_mutex);
if (tno == rxi_fcfs_thread_num
|| !tcall->queue_item_header.next) {
+ MUTEX_EXIT(&rx_pthread_mutex);
/* If we're the fcfs thread , then we'll just use
* this call. If we haven't been able to find an optimal
* choice, and we're at the end of the list, then use a
* 2d choice if one has been identified. Otherwise... */
call = (choice2 ? choice2 : tcall);
service = call->conn->service;
- } else if (!queue_IsEmpty(&tcall->rq)) {
- struct rx_packet *rp;
- rp = queue_First(&tcall->rq, rx_packet);
- if (rp->header.seq == 1) {
- if (!meltdown_1pkt
- || (rp->header.flags & RX_LAST_PACKET)) {
- call = tcall;
- } else if (rxi_2dchoice && !choice2
- && !(tcall->flags & RX_CALL_CLEARED)
- && (tcall->rprev > rxi_HardAckRate)) {
- choice2 = tcall;
- } else
- rxi_md2cnt++;
+ } else {
+ MUTEX_EXIT(&rx_pthread_mutex);
+ if (!queue_IsEmpty(&tcall->rq)) {
+ struct rx_packet *rp;
+ rp = queue_First(&tcall->rq, rx_packet);
+ if (rp->header.seq == 1) {
+ if (!meltdown_1pkt
+ || (rp->header.flags & RX_LAST_PACKET)) {
+ call = tcall;
+ } else if (rxi_2dchoice && !choice2
+ && !(tcall->flags & RX_CALL_CLEARED)
+ && (tcall->rprev > rxi_HardAckRate)) {
+ choice2 = tcall;
+ } else
+ rxi_md2cnt++;
+ }
}
}
if (call) {
if (call->flags & RX_CALL_WAIT_PROC) {
call->flags &= ~RX_CALL_WAIT_PROC;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_nWaiting--;
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_ENTER(&rx_waiting_mutex);
+ rx_nWaiting--;
+ MUTEX_EXIT(&rx_waiting_mutex);
}
if (call->state != RX_STATE_PRECALL || call->error) {
rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
{
struct rx_serverQueueEntry *sq;
- register struct rx_call *call = (struct rx_call *)0, *choice2;
+ struct rx_call *call = (struct rx_call *)0, *choice2;
struct rx_service *service = NULL;
SPLVAR;
rxi_availProcs++;
}
if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
- register struct rx_call *tcall, *ncall;
+ struct rx_call *tcall, *ncall;
/* Scan for eligible incoming calls. A call is not eligible
* if the maximum number of calls for its service type are
* already executing */
for (queue_Scan(&rx_incomingCallQueue, tcall, ncall, rx_call)) {
service = tcall->conn->service;
if (QuotaOK(service)) {
+ MUTEX_ENTER(&rx_pthread_mutex);
if (tno == rxi_fcfs_thread_num
|| !tcall->queue_item_header.next) {
+ MUTEX_EXIT(&rx_pthread_mutex);
/* If we're the fcfs thread, then we'll just use
* this call. If we haven't been able to find an optimal
* choice, and we're at the end of the list, then use a
* 2d choice if one has been identified. Otherwise... */
call = (choice2 ? choice2 : tcall);
service = call->conn->service;
- } else if (!queue_IsEmpty(&tcall->rq)) {
- struct rx_packet *rp;
- rp = queue_First(&tcall->rq, rx_packet);
- if (rp->header.seq == 1
- && (!meltdown_1pkt
- || (rp->header.flags & RX_LAST_PACKET))) {
- call = tcall;
- } else if (rxi_2dchoice && !choice2
- && !(tcall->flags & RX_CALL_CLEARED)
- && (tcall->rprev > rxi_HardAckRate)) {
- choice2 = tcall;
- } else
- rxi_md2cnt++;
+ } else {
+ MUTEX_EXIT(&rx_pthread_mutex);
+ if (!queue_IsEmpty(&tcall->rq)) {
+ struct rx_packet *rp;
+ rp = queue_First(&tcall->rq, rx_packet);
+ if (rp->header.seq == 1
+ && (!meltdown_1pkt
+ || (rp->header.flags & RX_LAST_PACKET))) {
+ call = tcall;
+ } else if (rxi_2dchoice && !choice2
+ && !(tcall->flags & RX_CALL_CLEARED)
+ && (tcall->rprev > rxi_HardAckRate)) {
+ choice2 = tcall;
+ } else
+ rxi_md2cnt++;
+ }
}
}
if (call)
* and (2) only use it once. Other uses currently void your warranty
*/
void
-rx_SetArrivalProc(register struct rx_call *call,
- register void (*proc) (register struct rx_call * call,
- register VOID * mh,
- register int index),
- register VOID * handle, register int arg)
+rx_SetArrivalProc(struct rx_call *call,
+ void (*proc) (struct rx_call * call,
+ void * mh,
+ int index),
+ void * handle, int arg)
{
call->arrivalProc = proc;
call->arrivalProcHandle = handle;
* to the caller */
afs_int32
-rx_EndCall(register struct rx_call *call, afs_int32 rc)
+rx_EndCall(struct rx_call *call, afs_int32 rc)
{
- register struct rx_connection *conn = call->conn;
- register struct rx_service *service;
- register struct rx_packet *tp; /* Temporary packet pointer */
- register struct rx_packet *nxp; /* Next packet pointer, for queue_Scan */
+ struct rx_connection *conn = call->conn;
+ struct rx_service *service;
afs_int32 error;
SPLVAR;
- dpf(("rx_EndCall(call %x)\n", call));
+
+
+ dpf(("rx_EndCall(call %x rc %d error %d abortCode %d)\n", call, rc, call->error, call->abortCode));
NETPRI;
MUTEX_ENTER(&call->lock);
* rx_NewCall is in a stable state. Otherwise, rx_NewCall may
* have checked this call, found it active and by the time it
* goes to sleep, will have missed the signal.
+ *
+ * Do not clear the RX_CONN_MAKECALL_WAITING flag as long as
+ * there are threads waiting to use the conn object.
*/
MUTEX_EXIT(&call->lock);
MUTEX_ENTER(&conn->conn_call_lock);
MUTEX_ENTER(&conn->conn_data_lock);
conn->flags |= RX_CONN_BUSY;
if (conn->flags & RX_CONN_MAKECALL_WAITING) {
- conn->flags &= (~RX_CONN_MAKECALL_WAITING);
+ if (conn->makeCallWaiters == 0)
+ conn->flags &= (~RX_CONN_MAKECALL_WAITING);
MUTEX_EXIT(&conn->conn_data_lock);
#ifdef RX_ENABLE_LOCKS
CV_BROADCAST(&conn->conn_call_cv);
* kernel version, and may interrupt the macros rx_Read or
* rx_Write, which run at normal priority for efficiency. */
if (call->currentPacket) {
+ call->currentPacket->flags &= ~RX_PKTFLAG_CP;
rxi_FreePacket(call->currentPacket);
call->currentPacket = (struct rx_packet *)0;
- call->nLeft = call->nFree = call->curlen = 0;
- } else
- call->nLeft = call->nFree = call->curlen = 0;
+ }
+
+ call->nLeft = call->nFree = call->curlen = 0;
/* Free any packets from the last call to ReadvProc/WritevProc */
- for (queue_Scan(&call->iovq, tp, nxp, rx_packet)) {
- queue_Remove(tp);
- rxi_FreePacket(tp);
- }
+#ifdef RXDEBUG_PACKET
+ call->iovqc -=
+#endif /* RXDEBUG_PACKET */
+ rxi_FreePackets(0, &call->iovq);
CALL_RELE(call, RX_CALL_REFCOUNT_BEGIN);
MUTEX_EXIT(&call->lock);
void
rx_Finalize(void)
{
- register struct rx_connection **conn_ptr, **conn_end;
+ struct rx_connection **conn_ptr, **conn_end;
INIT_PTHREAD_LOCKS;
LOCK_RX_INIT;
}
rxi_flushtrace();
+#ifdef AFS_NT40_ENV
+ afs_winsockCleanup();
+#endif
+
rxinit_status = 1;
UNLOCK_RX_INIT;
}
/* Return this process's service structure for the
* specified socket and service */
struct rx_service *
-rxi_FindService(register osi_socket socket, register u_short serviceId)
+rxi_FindService(osi_socket socket, u_short serviceId)
{
- register struct rx_service **sp;
+ struct rx_service **sp;
for (sp = &rx_services[0]; *sp; sp++) {
if ((*sp)->serviceId == serviceId && (*sp)->socket == socket)
return *sp;
return 0;
}
+#ifdef DEBUG
+#ifdef KDUMP_RX_LOCK
+static struct rx_call_rx_lock *rx_allCallsp = 0;
+#else
+static struct rx_call *rx_allCallsp = 0;
+#endif
+#endif /* DEBUG */
+
/* Allocate a call structure, for the indicated channel of the
* supplied connection. The mode and state of the call must be set by
* the caller. Returns the call with mutex locked. */
struct rx_call *
-rxi_NewCall(register struct rx_connection *conn, register int channel)
+rxi_NewCall(struct rx_connection *conn, int channel)
{
- register struct rx_call *call;
+ struct rx_call *call;
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
- register struct rx_call *cp; /* Call pointer temp */
- register struct rx_call *nxp; /* Next call pointer, for queue_Scan */
+ struct rx_call *cp; /* Call pointer temp */
+ struct rx_call *nxp; /* Next call pointer, for queue_Scan */
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
+ dpf(("rxi_NewCall(conn %x, channel %d)\n", conn, channel));
+
/* Grab an existing call structure, or allocate a new one.
* Existing call structures are assumed to have been left reset by
* rxi_FreeCall */
call = queue_First(&rx_freeCallQueue, rx_call);
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
queue_Remove(call);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nFreeCallStructs--;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexDecrement(rx_stats.nFreeCallStructs, rx_stats_mutex);
MUTEX_EXIT(&rx_freeCallQueue_lock);
MUTEX_ENTER(&call->lock);
CLEAR_CALL_QUEUE_LOCK(call);
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
/* Now, if TQ wasn't cleared earlier, do it now. */
if (call->flags & RX_CALL_TQ_CLEARME) {
- rxi_ClearTransmitQueue(call, 0);
- queue_Init(&call->tq);
+ rxi_ClearTransmitQueue(call, 1);
+ /*queue_Init(&call->tq);*/
}
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
/* Bind the call to its connection structure */
call->conn = conn;
rxi_ResetCall(call, 1);
} else {
- call = (struct rx_call *)rxi_Alloc(sizeof(struct rx_call));
- MUTEX_EXIT(&rx_freeCallQueue_lock);
+ call = (struct rx_call *)rxi_Alloc(sizeof(struct rx_call));
+#ifdef RXDEBUG_PACKET
+ call->allNextp = rx_allCallsp;
+ rx_allCallsp = call;
+ call->call_id =
+#endif /* RXDEBUG_PACKET */
+ rx_MutexIncrement(rx_stats.nCallStructs, rx_stats_mutex);
+
+ MUTEX_EXIT(&rx_freeCallQueue_lock);
MUTEX_INIT(&call->lock, "call lock", MUTEX_DEFAULT, NULL);
MUTEX_ENTER(&call->lock);
CV_INIT(&call->cv_twind, "call twind", CV_DEFAULT, 0);
CV_INIT(&call->cv_rq, "call rq", CV_DEFAULT, 0);
CV_INIT(&call->cv_tq, "call tq", CV_DEFAULT, 0);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nCallStructs++;
- MUTEX_EXIT(&rx_stats_mutex);
/* Initialize once-only items */
queue_Init(&call->tq);
queue_Init(&call->rq);
queue_Init(&call->iovq);
+#ifdef RXDEBUG_PACKET
+ call->rqc = call->tqc = call->iovqc = 0;
+#endif /* RXDEBUG_PACKET */
/* Bind the call to its connection structure (prereq for reset) */
call->conn = conn;
rxi_ResetCall(call, 1);
}
call->channel = channel;
call->callNumber = &conn->callNumber[channel];
+ call->rwind = conn->rwind[channel];
+ call->twind = conn->twind[channel];
/* Note that the next expected call number is retained (in
* conn->callNumber[i]), even if we reallocate the call structure
*/
*/
#ifdef RX_ENABLE_LOCKS
void
-rxi_FreeCall(register struct rx_call *call, int haveCTLock)
+rxi_FreeCall(struct rx_call *call, int haveCTLock)
#else /* RX_ENABLE_LOCKS */
void
-rxi_FreeCall(register struct rx_call *call)
+rxi_FreeCall(struct rx_call *call)
#endif /* RX_ENABLE_LOCKS */
{
- register int channel = call->channel;
- register struct rx_connection *conn = call->conn;
+ int channel = call->channel;
+ struct rx_connection *conn = call->conn;
if (call->state == RX_STATE_DALLY || call->state == RX_STATE_HOLD)
#else /* AFS_GLOBAL_RXLOCK_KERNEL */
queue_Append(&rx_freeCallQueue, call);
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nFreeCallStructs++;
- MUTEX_EXIT(&rx_stats_mutex);
-
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.nFreeCallStructs, rx_stats_mutex);
MUTEX_EXIT(&rx_freeCallQueue_lock);
/* Destroy the connection if it was previously slated for
* If someone else destroys a connection, they either have no
* call lock held or are going through this section of code.
*/
- if (conn->flags & RX_CONN_DESTROY_ME) {
+ if (conn->flags & RX_CONN_DESTROY_ME && !(conn->flags & RX_CONN_MAKECALL_WAITING)) {
MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount++;
MUTEX_EXIT(&conn->conn_data_lock);
afs_int32 rxi_Alloccnt = 0, rxi_Allocsize = 0;
char *
-rxi_Alloc(register size_t size)
+rxi_Alloc(size_t size)
{
- register char *p;
+ char *p;
- MUTEX_ENTER(&rx_stats_mutex);
- rxi_Alloccnt++;
- rxi_Allocsize += size;
- MUTEX_EXIT(&rx_stats_mutex);
-
- p = (char *)osi_Alloc(size);
+ if (rx_stats_active)
+ rx_MutexAdd1Increment2(rxi_Allocsize, (afs_int32)size, rxi_Alloccnt, rx_stats_mutex);
+p = (char *)
+#if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
+ afs_osi_Alloc_NoSleep(size);
+#else
+ osi_Alloc(size);
+#endif
if (!p)
osi_Panic("rxi_Alloc error");
memset(p, 0, size);
}
void
-rxi_Free(void *addr, register size_t size)
+rxi_Free(void *addr, size_t size)
{
- MUTEX_ENTER(&rx_stats_mutex);
- rxi_Alloccnt--;
- rxi_Allocsize -= size;
- MUTEX_EXIT(&rx_stats_mutex);
-
+ if (rx_stats_active)
+ rx_MutexAdd1Decrement2(rxi_Allocsize, -(afs_int32)size, rxi_Alloccnt, rx_stats_mutex);
osi_Free(addr, size);
}
+void
+rxi_SetPeerMtu(afs_uint32 host, afs_uint32 port, int mtu)
+{
+ struct rx_peer **peer_ptr, **peer_end;
+ int hashIndex;
+
+ MUTEX_ENTER(&rx_peerHashTable_lock);
+ if (port == 0) {
+ for (peer_ptr = &rx_peerHashTable[0], peer_end =
+ &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
+ peer_ptr++) {
+ struct rx_peer *peer, *next;
+ for (peer = *peer_ptr; peer; peer = next) {
+ next = peer->next;
+ if (host == peer->host) {
+ MUTEX_ENTER(&peer->peer_lock);
+ peer->ifMTU=MIN(mtu, peer->ifMTU);
+ peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
+ MUTEX_EXIT(&peer->peer_lock);
+ }
+ }
+ }
+ } else {
+ struct rx_peer *peer;
+ hashIndex = PEER_HASH(host, port);
+ for (peer = rx_peerHashTable[hashIndex]; peer; peer = peer->next) {
+ if ((peer->host == host) && (peer->port == port)) {
+ MUTEX_ENTER(&peer->peer_lock);
+ peer->ifMTU=MIN(mtu, peer->ifMTU);
+ peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
+ MUTEX_EXIT(&peer->peer_lock);
+ }
+ }
+ }
+ MUTEX_EXIT(&rx_peerHashTable_lock);
+}
+
/* Find the peer process represented by the supplied (host,port)
* combination. If there is no appropriate active peer structure, a
* new one will be allocated and initialized
* refcount will be be decremented. This is used to replace the peer
* structure hanging off a connection structure */
struct rx_peer *
-rxi_FindPeer(register afs_uint32 host, register u_short port,
+rxi_FindPeer(afs_uint32 host, u_short port,
struct rx_peer *origPeer, int create)
{
- register struct rx_peer *pp;
+ struct rx_peer *pp;
int hashIndex;
hashIndex = PEER_HASH(host, port);
MUTEX_ENTER(&rx_peerHashTable_lock);
pp->next = rx_peerHashTable[hashIndex];
rx_peerHashTable[hashIndex] = pp;
rxi_InitPeerParams(pp);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nPeerStructs++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.nPeerStructs, rx_stats_mutex);
}
}
if (pp && create) {
* server connection is created, it will be created using the supplied
* index, if the index is valid for this service */
struct rx_connection *
-rxi_FindConnection(osi_socket socket, register afs_int32 host,
- register u_short port, u_short serviceId, afs_uint32 cid,
+rxi_FindConnection(osi_socket socket, afs_int32 host,
+ u_short port, u_short serviceId, afs_uint32 cid,
afs_uint32 epoch, int type, u_int securityIndex)
{
- int hashindex, flag;
- register struct rx_connection *conn;
+ int hashindex, flag, i;
+ struct rx_connection *conn;
hashindex = CONN_HASH(host, port, cid, epoch, type);
MUTEX_ENTER(&rx_connHashTable_lock);
rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
for (; conn;) {
if ((conn->type == type) && ((cid & RX_CIDMASK) == conn->cid)
&& (epoch == conn->epoch)) {
- register struct rx_peer *pp = conn->peer;
+ struct rx_peer *pp = conn->peer;
if (securityIndex != conn->securityIndex) {
/* this isn't supposed to happen, but someone could forge a packet
* like this, and there seems to be some CM bug that makes this
conn->specific = NULL;
rx_SetConnDeadTime(conn, service->connDeadTime);
rx_SetConnIdleDeadTime(conn, service->idleDeadTime);
+ rx_SetServerConnIdleDeadErr(conn, service->idleDeadErr);
+ for (i = 0; i < RX_MAXCALLS; i++) {
+ conn->twind[i] = rx_initSendWindow;
+ conn->rwind[i] = rx_initReceiveWindow;
+ }
/* Notify security object of the new connection */
RXS_NewConnection(conn->securityObject, conn);
/* XXXX Connection timeout? */
if (service->newConnProc)
(*service->newConnProc) (conn);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nServerConns++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.nServerConns, rx_stats_mutex);
}
MUTEX_ENTER(&conn->conn_data_lock);
* containing the network address. Both can be modified. The return value, if
* non-zero, indicates that the packet should be dropped. */
-int (*rx_justReceived) () = 0;
-int (*rx_almostSent) () = 0;
+int (*rx_justReceived) (struct rx_packet *, struct sockaddr_in *) = 0;
+int (*rx_almostSent) (struct rx_packet *, struct sockaddr_in *) = 0;
/* A packet has been received off the interface. Np is the packet, socket is
* the socket number it was received from (useful in determining which service
* it, rather than de-allocating it, just as a small performance hack */
struct rx_packet *
-rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
+rxi_ReceivePacket(struct rx_packet *np, osi_socket socket,
afs_uint32 host, u_short port, int *tnop,
struct rx_call **newcallp)
{
- register struct rx_call *call;
- register struct rx_connection *conn;
+ struct rx_call *call;
+ struct rx_connection *conn;
int channel;
afs_uint32 currentCallNumber;
int type;
packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %x",
- np->header.serial, packetType, host, port, np->header.serviceId,
+ np->header.serial, packetType, ntohl(host), ntohs(port), np->header.serviceId,
np->header.epoch, np->header.cid, np->header.callNumber,
np->header.seq, np->header.flags, np));
#endif
/* Check for connection-only requests (i.e. not call specific). */
if (np->header.callNumber == 0) {
switch (np->header.type) {
- case RX_PACKET_TYPE_ABORT:
+ case RX_PACKET_TYPE_ABORT: {
/* What if the supplied error is zero? */
- rxi_ConnectionError(conn, ntohl(rx_GetInt32(np, 0)));
+ afs_int32 errcode = ntohl(rx_GetInt32(np, 0));
+ dpf(("rxi_ReceivePacket ABORT rx_GetInt32 = %d", errcode));
+ rxi_ConnectionError(conn, errcode);
MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount--;
MUTEX_EXIT(&conn->conn_data_lock);
return np;
+ }
case RX_PACKET_TYPE_CHALLENGE:
tnp = rxi_ReceiveChallengePacket(conn, np, 1);
MUTEX_ENTER(&conn->conn_data_lock);
* then, since this is a client connection we're getting data for
* it must be for the previous call.
*/
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.spuriousPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount--;
MUTEX_EXIT(&conn->conn_data_lock);
if (type == RX_SERVER_CONNECTION) { /* We're the server */
if (np->header.callNumber < currentCallNumber) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.spuriousPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
#ifdef RX_ENABLE_LOCKS
if (call)
MUTEX_EXIT(&call->lock);
call = rxi_NewCall(conn, channel);
MUTEX_EXIT(&conn->conn_call_lock);
*call->callNumber = np->header.callNumber;
+#ifdef RXDEBUG
+ if (np->header.callNumber == 0)
+ dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
+#endif
call->state = RX_STATE_PRECALL;
clock_GetTime(&call->queueTime);
hzero(call->bytesSent);
hzero(call->bytesRcvd);
+ /*
+ * If the number of queued calls exceeds the overload
+ * threshold then abort this call.
+ */
+ if ((rx_BusyThreshold > 0) && (rx_nWaiting > rx_BusyThreshold)) {
+ struct rx_packet *tp;
+
+ rxi_CallError(call, rx_BusyError);
+ tp = rxi_SendCallAbort(call, np, 1, 0);
+ MUTEX_EXIT(&call->lock);
+ MUTEX_ENTER(&conn->conn_data_lock);
+ conn->refCount--;
+ MUTEX_EXIT(&conn->conn_data_lock);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.nBusies, rx_stats_mutex);
+ return tp;
+ }
rxi_KeepAliveOn(call);
} else if (np->header.callNumber != currentCallNumber) {
/* Wait until the transmit queue is idle before deciding
while ((call->state == RX_STATE_ACTIVE)
&& (call->flags & RX_CALL_TQ_BUSY)) {
call->flags |= RX_CALL_TQ_WAIT;
+ call->tqWaiters++;
#ifdef RX_ENABLE_LOCKS
+ osirx_AssertMine(&call->lock, "rxi_Start lock3");
CV_WAIT(&call->cv_tq, &call->lock);
#else /* RX_ENABLE_LOCKS */
osi_rxSleep(&call->tq);
#endif /* RX_ENABLE_LOCKS */
+ call->tqWaiters--;
+ if (call->tqWaiters == 0)
+ call->flags &= ~RX_CALL_TQ_WAIT;
}
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
/* If the new call cannot be taken right now send a busy and set
}
rxi_ResetCall(call, 0);
*call->callNumber = np->header.callNumber;
+#ifdef RXDEBUG
+ if (np->header.callNumber == 0)
+ dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
+#endif
call->state = RX_STATE_PRECALL;
clock_GetTime(&call->queueTime);
hzero(call->bytesSent);
MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount--;
MUTEX_EXIT(&conn->conn_data_lock);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nBusies++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.nBusies, rx_stats_mutex);
return tp;
}
rxi_KeepAliveOn(call);
/* Ignore all incoming acknowledgements for calls in DALLY state */
if (call && (call->state == RX_STATE_DALLY)
&& (np->header.type == RX_PACKET_TYPE_ACK)) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.ignorePacketDally++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.ignorePacketDally, rx_stats_mutex);
#ifdef RX_ENABLE_LOCKS
if (call) {
MUTEX_EXIT(&call->lock);
/* Ignore anything that's not relevant to the current call. If there
* isn't a current call, then no packet is relevant. */
if (!call || (np->header.callNumber != currentCallNumber)) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.spuriousPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
#ifdef RX_ENABLE_LOCKS
if (call) {
MUTEX_EXIT(&call->lock);
* XXX interact badly with the server-restart detection
* XXX code in receiveackpacket. */
if (ntohl(rx_GetInt32(np, FIRSTACKOFFSET)) < call->tfirst) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.spuriousPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
MUTEX_EXIT(&call->lock);
MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount--;
conn->lastSerial = np->header.serial;
MUTEX_EXIT(&conn->conn_data_lock);
if (skew > 0) {
- register struct rx_peer *peer;
+ struct rx_peer *peer;
peer = conn->peer;
if (skew > peer->inPacketSkew) {
dpf(("*** In skew changed from %d to %d\n", peer->inPacketSkew,
}
np = rxi_ReceiveAckPacket(call, np, 1);
break;
- case RX_PACKET_TYPE_ABORT:
- /* An abort packet: reset the connection, passing the error up to
- * the user */
+ case RX_PACKET_TYPE_ABORT: {
+ /* An abort packet: reset the call, passing the error up to the user. */
/* What if error is zero? */
- rxi_CallError(call, ntohl(*(afs_int32 *) rx_DataOf(np)));
- break;
+ /* What if the error is -1? the application will treat it as a timeout. */
+ afs_int32 errdata = ntohl(*(afs_int32 *) rx_DataOf(np));
+ dpf(("rxi_ReceivePacket ABORT rx_DataOf = %d", errdata));
+ rxi_CallError(call, errdata);
+ MUTEX_EXIT(&call->lock);
+ MUTEX_ENTER(&conn->conn_data_lock);
+ conn->refCount--;
+ MUTEX_EXIT(&conn->conn_data_lock);
+ return np; /* xmitting; drop packet */
+ }
case RX_PACKET_TYPE_BUSY:
/* XXXX */
break;
rxi_SetAcksInTransmitQueue(call);
break;
#else /* RX_ENABLE_LOCKS */
+ MUTEX_EXIT(&call->lock);
+ MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount--;
+ MUTEX_EXIT(&conn->conn_data_lock);
return np; /* xmitting; drop packet */
#endif /* RX_ENABLE_LOCKS */
}
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
rxi_ClearTransmitQueue(call, 0);
+ rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
break;
default:
/* Should not reach here, unless the peer is broken: send an abort
int
rxi_IsConnInteresting(struct rx_connection *aconn)
{
- register int i;
- register struct rx_call *tcall;
+ int i;
+ struct rx_call *tcall;
if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
return 1;
TooLow(struct rx_packet *ap, struct rx_call *acall)
{
int rc = 0;
- MUTEX_ENTER(&rx_stats_mutex);
+
+ MUTEX_ENTER(&rx_quota_mutex);
if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
&& (acall->state == RX_STATE_PRECALL))
|| ((rx_nFreePackets < rxi_dataQuota + 2)
&& (acall->flags & RX_CALL_READER_WAIT)))) {
rc = 1;
}
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_EXIT(&rx_quota_mutex);
return rc;
}
#endif /* KERNEL */
static void
-rxi_CheckReachEvent(struct rxevent *event, struct rx_connection *conn,
- struct rx_call *acall)
+rxi_CheckReachEvent(struct rxevent *event, void *arg1, void *arg2)
{
+ struct rx_connection *conn = arg1;
+ struct rx_call *acall = arg2;
struct rx_call *call = acall;
- struct clock when;
+ struct clock when, now;
int i, waiting;
MUTEX_ENTER(&conn->conn_data_lock);
if (call != acall)
MUTEX_EXIT(&call->lock);
- clock_GetTime(&when);
+ clock_GetTime(&now);
+ when = now;
when.sec += RX_CHECKREACH_TIMEOUT;
MUTEX_ENTER(&conn->conn_data_lock);
if (!conn->checkReachEvent) {
conn->refCount++;
conn->checkReachEvent =
- rxevent_Post(&when, rxi_CheckReachEvent, conn, NULL);
+ rxevent_PostNow(&when, &now, rxi_CheckReachEvent, conn,
+ NULL);
}
MUTEX_EXIT(&conn->conn_data_lock);
}
/* try to attach call, if authentication is complete */
static void
-TryAttach(register struct rx_call *acall, register osi_socket socket,
- register int *tnop, register struct rx_call **newcallp,
+TryAttach(struct rx_call *acall, osi_socket socket,
+ int *tnop, struct rx_call **newcallp,
int reachOverride)
{
struct rx_connection *conn = acall->conn;
* routine can return a packet to the caller, for re-use */
struct rx_packet *
-rxi_ReceiveDataPacket(register struct rx_call *call,
- register struct rx_packet *np, int istack,
+rxi_ReceiveDataPacket(struct rx_call *call,
+ struct rx_packet *np, int istack,
osi_socket socket, afs_uint32 host, u_short port,
int *tnop, struct rx_call **newcallp)
{
int newPackets = 0;
int didHardAck = 0;
int haveLast = 0;
- afs_uint32 seq, serial, flags;
+ afs_uint32 seq;
+ afs_uint32 serial=0, flags=0;
int isFirst;
struct rx_packet *tnp;
- struct clock when;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dataPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ struct clock when, now;
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.dataPacketsRead, rx_stats_mutex);
#ifdef KERNEL
/* If there are no packet buffers, drop this new packet, unless we can find
MUTEX_ENTER(&rx_freePktQ_lock);
rxi_NeedMorePackets = TRUE;
MUTEX_EXIT(&rx_freePktQ_lock);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.noPacketBuffersOnRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.noPacketBuffersOnRead, rx_stats_mutex);
call->rprev = np->header.serial;
rxi_calltrace(RX_TRACE_DROP, call);
dpf(("packet %x dropped on receipt - quota problems", np));
if (rxi_doreclaim)
rxi_ClearReceiveQueue(call);
- clock_GetTime(&when);
+ clock_GetTime(&now);
+ when = now;
clock_Add(&when, &rx_softAckDelay);
if (!call->delayedAckEvent
|| clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
RX_CALL_REFCOUNT_DELAY);
CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
call->delayedAckEvent =
- rxevent_Post(&when, rxi_SendDelayedAck, call, 0);
+ rxevent_PostNow(&when, &now, rxi_SendDelayedAck, call, 0);
}
/* we've damaged this call already, might as well do it in. */
return np;
/* Check to make sure it is not a duplicate of one already queued */
if (queue_IsNotEmpty(&call->rq)
&& queue_First(&call->rq, rx_packet)->header.seq == seq) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dupPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.dupPacketsRead, rx_stats_mutex);
dpf(("packet %x dropped on receipt - duplicate", np));
rxevent_Cancel(call->delayedAckEvent, call,
RX_CALL_REFCOUNT_DELAY);
/* It's the next packet. Stick it on the receive queue
* for this call. Set newPackets to make sure we wake
* the reader once all packets have been processed */
+ np->flags |= RX_PKTFLAG_RQ;
queue_Prepend(&call->rq, np);
+#ifdef RXDEBUG_PACKET
+ call->rqc++;
+#endif /* RXDEBUG_PACKET */
call->nSoftAcks++;
np = NULL; /* We can't use this anymore */
newPackets = 1;
/* If the new packet's sequence number has been sent to the
* application already, then this is a duplicate */
if (seq < call->rnext) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dupPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.dupPacketsRead, rx_stats_mutex);
rxevent_Cancel(call->delayedAckEvent, call,
RX_CALL_REFCOUNT_DELAY);
np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
0, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
/*Check for duplicate packet */
if (seq == tp->header.seq) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dupPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.dupPacketsRead, rx_stats_mutex);
rxevent_Cancel(call->delayedAckEvent, call,
RX_CALL_REFCOUNT_DELAY);
np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE,
* packet before which to insert the new packet, or at the
* queue head if the queue is empty or the packet should be
* appended. */
+ np->flags |= RX_PKTFLAG_RQ;
+#ifdef RXDEBUG_PACKET
+ call->rqc++;
+#endif /* RXDEBUG_PACKET */
queue_InsertBefore(tp, np);
call->nSoftAcks++;
np = NULL;
/* We need to send an ack of the packet is out of sequence,
* or if an ack was requested by the peer. */
- if (seq != prev + 1 || missing || (flags & RX_REQUEST_ACK)) {
+ if (seq != prev + 1 || missing) {
ackNeeded = RX_ACK_OUT_OF_SEQUENCE;
- }
+ } else if (flags & RX_REQUEST_ACK) {
+ ackNeeded = RX_ACK_REQUESTED;
+ }
/* Acknowledge the last packet for each call */
if (flags & RX_LAST_PACKET) {
rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
np = rxi_SendAck(call, np, serial, RX_ACK_IDLE, istack);
} else if (call->nSoftAcks) {
- clock_GetTime(&when);
+ clock_GetTime(&now);
+ when = now;
if (haveLast && !(flags & RX_CLIENT_INITIATED)) {
clock_Add(&when, &rx_lastAckDelay);
} else {
RX_CALL_REFCOUNT_DELAY);
CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
call->delayedAckEvent =
- rxevent_Post(&when, rxi_SendDelayedAck, call, 0);
+ rxevent_PostNow(&when, &now, rxi_SendDelayedAck, call, 0);
}
} else if (call->flags & RX_CALL_RECEIVE_DONE) {
rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
MUTEX_EXIT(&conn->conn_data_lock);
}
+static const char *
+rx_ack_reason(int reason)
+{
+ switch (reason) {
+ case RX_ACK_REQUESTED:
+ return "requested";
+ case RX_ACK_DUPLICATE:
+ return "duplicate";
+ case RX_ACK_OUT_OF_SEQUENCE:
+ return "sequence";
+ case RX_ACK_EXCEEDS_WINDOW:
+ return "window";
+ case RX_ACK_NOSPACE:
+ return "nospace";
+ case RX_ACK_PING:
+ return "ping";
+ case RX_ACK_PING_RESPONSE:
+ return "response";
+ case RX_ACK_DELAY:
+ return "delay";
+ case RX_ACK_IDLE:
+ return "idle";
+ default:
+ return "unknown!!";
+ }
+}
+
+
/* rxi_ComputePeerNetStats
*
* Called exclusively by rxi_ReceiveAckPacket to compute network link
/* The real smarts of the whole thing. */
struct rx_packet *
-rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
+rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
int istack)
{
struct rx_ackPacket *ap;
int nAcks;
- register struct rx_packet *tp;
- register struct rx_packet *nxp; /* Next packet pointer for queue_Scan */
- register struct rx_connection *conn = call->conn;
+ struct rx_packet *tp;
+ struct rx_packet *nxp; /* Next packet pointer for queue_Scan */
+ struct rx_connection *conn = call->conn;
struct rx_peer *peer = conn->peer;
afs_uint32 first;
afs_uint32 serial;
u_short maxMTU = 0; /* Set if peer supports AFS 3.4a jumbo datagrams */
int maxDgramPackets = 0; /* Set if peer supports AFS 3.5 jumbo datagrams */
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.ackPacketsRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.ackPacketsRead, rx_stats_mutex);
ap = (struct rx_ackPacket *)rx_DataOf(np);
- nbytes = rx_Contiguous(np) - ((ap->acks) - (u_char *) ap);
+ nbytes = rx_Contiguous(np) - (int)((ap->acks) - (u_char *) ap);
if (nbytes < 0)
return np; /* truncated ack packet */
rxi_UpdatePeerReach(conn, call);
#ifdef RXDEBUG
+#ifdef AFS_NT40_ENV
+ if (rxdebug_active) {
+ char msg[512];
+ size_t len;
+
+ len = _snprintf(msg, sizeof(msg),
+ "tid[%d] RACK: reason %s serial %u previous %u seq %u skew %d first %u acks %u space %u ",
+ GetCurrentThreadId(), rx_ack_reason(ap->reason),
+ ntohl(ap->serial), ntohl(ap->previousPacket),
+ (unsigned int)np->header.seq, (unsigned int)skew,
+ ntohl(ap->firstPacket), ap->nAcks, ntohs(ap->bufferSpace) );
+ if (nAcks) {
+ int offset;
+
+ for (offset = 0; offset < nAcks && len < sizeof(msg); offset++)
+ msg[len++] = (ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*');
+ }
+ msg[len++]='\n';
+ msg[len] = '\0';
+ OutputDebugString(msg);
+ }
+#else /* AFS_NT40_ENV */
if (rx_Log) {
fprintf(rx_Log,
"RACK: reason %x previous %u seq %u serial %u skew %d first %u",
}
putc('\n', rx_Log);
}
+#endif /* AFS_NT40_ENV */
#endif
/* Update the outgoing packet skew value to the latest value of
if (serial
&& (tp->header.serial == serial || tp->firstSerial == serial))
rxi_ComputePeerNetStats(call, tp, ap, np);
+ if (!(tp->flags & RX_PKTFLAG_ACKED)) {
+ newAckCount++;
+ }
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
/* XXX Hack. Because we have to release the global rx lock when sending
* packets (osi_NetSend) we drop all acks while we're traversing the tq
* set the ack bits in the packets and have rxi_Start remove the packets
* when it's done transmitting.
*/
- if (!(tp->flags & RX_PKTFLAG_ACKED)) {
- newAckCount++;
- }
if (call->flags & RX_CALL_TQ_BUSY) {
#ifdef RX_ENABLE_LOCKS
tp->flags |= RX_PKTFLAG_ACKED;
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
{
queue_Remove(tp);
+ tp->flags &= ~RX_PKTFLAG_TQ;
+#ifdef RXDEBUG_PACKET
+ call->tqc--;
+#endif /* RXDEBUG_PACKET */
rxi_FreePacket(tp); /* rxi_FreePacket mustn't wake up anyone, preemptively. */
}
}
} else {
call->nSoftAcked++;
}
- } else {
+ } else /* RX_ACK_TYPE_NACK */ {
tp->flags &= ~RX_PKTFLAG_ACKED;
missing = 1;
}
/* If the ack packet has a "recommended" size that is less than
* what I am using now, reduce my size to match */
rx_packetread(np, rx_AckDataSize(ap->nAcks) + sizeof(afs_int32),
- sizeof(afs_int32), &tSize);
+ (int)sizeof(afs_int32), &tSize);
tSize = (afs_uint32) ntohl(tSize);
peer->natMTU = rxi_AdjustIfMTU(MIN(tSize, peer->ifMTU));
/* Get the maximum packet size to send to this peer */
- rx_packetread(np, rx_AckDataSize(ap->nAcks), sizeof(afs_int32),
+ rx_packetread(np, rx_AckDataSize(ap->nAcks), (int)sizeof(afs_int32),
&tSize);
tSize = (afs_uint32) ntohl(tSize);
tSize = (afs_uint32) MIN(tSize, rx_MyMaxSendSize);
* be unable to accept packets of the size that prior AFS versions would
* send without asking. */
if (peer->maxMTU != tSize) {
+ if (peer->maxMTU > tSize) /* possible cong., maxMTU decreased */
+ peer->congestSeq++;
peer->maxMTU = tSize;
peer->MTU = MIN(tSize, peer->MTU);
call->MTU = MIN(call->MTU, tSize);
- peer->congestSeq++;
}
if (np->length == rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32)) {
/* AFS 3.4a */
rx_packetread(np,
rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
- sizeof(afs_int32), &tSize);
+ (int)sizeof(afs_int32), &tSize);
tSize = (afs_uint32) ntohl(tSize); /* peer's receive window, if it's */
if (tSize < call->twind) { /* smaller than our send */
call->twind = tSize; /* window, we must send less... */
call->ssthresh = MIN(call->twind, call->ssthresh);
+ call->conn->twind[call->channel] = call->twind;
}
/* Only send jumbograms to 3.4a fileservers. 3.3a RX gets the
*/
if (tSize < call->twind) {
call->twind = tSize;
+ call->conn->twind[call->channel] = call->twind;
call->ssthresh = MIN(call->twind, call->ssthresh);
} else if (tSize > call->twind) {
call->twind = tSize;
+ call->conn->twind[call->channel] = call->twind;
}
/*
call->nNacks = nNacked;
}
} else {
- if (newAckCount) {
- call->nAcks++;
- }
+ call->nAcks += newAckCount;
call->nNacks = 0;
}
return np;
}
call->flags |= RX_CALL_FAST_RECOVER_WAIT;
- while (call->flags & RX_CALL_TQ_BUSY) {
- call->flags |= RX_CALL_TQ_WAIT;
-#ifdef RX_ENABLE_LOCKS
- CV_WAIT(&call->cv_tq, &call->lock);
-#else /* RX_ENABLE_LOCKS */
- osi_rxSleep(&call->tq);
-#endif /* RX_ENABLE_LOCKS */
- }
+ rxi_WaitforTQBusy(call);
MUTEX_ENTER(&peer->peer_lock);
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
&& call->tfirst + call->nSoftAcked >= call->tnext) {
call->state = RX_STATE_DALLY;
rxi_ClearTransmitQueue(call, 0);
+ rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
} else if (!queue_IsEmpty(&call->tq)) {
rxi_Start(0, call, 0, istack);
}
/* Received a response to a challenge packet */
struct rx_packet *
-rxi_ReceiveResponsePacket(register struct rx_connection *conn,
- register struct rx_packet *np, int istack)
+rxi_ReceiveResponsePacket(struct rx_connection *conn,
+ struct rx_packet *np, int istack)
{
int error;
* challenge if it fails to get a response. */
struct rx_packet *
-rxi_ReceiveChallengePacket(register struct rx_connection *conn,
- register struct rx_packet *np, int istack)
+rxi_ReceiveChallengePacket(struct rx_connection *conn,
+ struct rx_packet *np, int istack)
{
int error;
* the given call structure. If one isn't available, queue up this
* call so it eventually gets one */
void
-rxi_AttachServerProc(register struct rx_call *call,
- register osi_socket socket, register int *tnop,
- register struct rx_call **newcallp)
+rxi_AttachServerProc(struct rx_call *call,
+ osi_socket socket, int *tnop,
+ struct rx_call **newcallp)
{
- register struct rx_serverQueueEntry *sq;
- register struct rx_service *service = call->conn->service;
- register int haveQuota = 0;
+ struct rx_serverQueueEntry *sq;
+ struct rx_service *service = call->conn->service;
+ int haveQuota = 0;
/* May already be attached */
if (call->state == RX_STATE_ACTIVE)
if (!(call->flags & RX_CALL_WAIT_PROC)) {
call->flags |= RX_CALL_WAIT_PROC;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_nWaiting++;
- rx_nWaited++;
- MUTEX_EXIT(&rx_stats_mutex);
+ MUTEX_ENTER(&rx_waiting_mutex);
+ rx_nWaiting++;
+ rx_nWaited++;
+ MUTEX_EXIT(&rx_waiting_mutex);
rxi_calltrace(RX_CALL_ARRIVAL, call);
SET_CALL_QUEUE_LOCK(call, &rx_serverPool_lock);
queue_Append(&rx_incomingCallQueue, call);
call->flags &= ~RX_CALL_WAIT_PROC;
if (queue_IsOnQueue(call)) {
queue_Remove(call);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_nWaiting--;
- MUTEX_EXIT(&rx_stats_mutex);
+
+ MUTEX_ENTER(&rx_waiting_mutex);
+ rx_nWaiting--;
+ MUTEX_EXIT(&rx_waiting_mutex);
}
}
call->state = RX_STATE_ACTIVE;
* is being prepared (in the case of a server). Rather than sending
* an ack packet, an ACKALL packet is sent. */
void
-rxi_AckAll(struct rxevent *event, register struct rx_call *call, char *dummy)
+rxi_AckAll(struct rxevent *event, struct rx_call *call, char *dummy)
{
#ifdef RX_ENABLE_LOCKS
if (event) {
}
void
-rxi_SendDelayedAck(struct rxevent *event, register struct rx_call *call,
- char *dummy)
+rxi_SendDelayedAck(struct rxevent *event, void *arg1, void *unused)
{
+ struct rx_call *call = arg1;
#ifdef RX_ENABLE_LOCKS
if (event) {
MUTEX_ENTER(&call->lock);
* clearing them out.
*/
static void
-rxi_SetAcksInTransmitQueue(register struct rx_call *call)
+rxi_SetAcksInTransmitQueue(struct rx_call *call)
{
- register struct rx_packet *p, *tp;
+ struct rx_packet *p, *tp;
int someAcked = 0;
for (queue_Scan(&call->tq, p, tp, rx_packet)) {
- if (!p)
- break;
p->flags |= RX_PKTFLAG_ACKED;
someAcked = 1;
}
}
rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
- rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
call->tfirst = call->tnext;
call->nSoftAcked = 0;
/* Clear out the transmit queue for the current call (all packets have
* been received by peer) */
void
-rxi_ClearTransmitQueue(register struct rx_call *call, register int force)
+rxi_ClearTransmitQueue(struct rx_call *call, int force)
{
- register struct rx_packet *p, *tp;
-
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
+ struct rx_packet *p, *tp;
+
if (!force && (call->flags & RX_CALL_TQ_BUSY)) {
int someAcked = 0;
for (queue_Scan(&call->tq, p, tp, rx_packet)) {
- if (!p)
- break;
p->flags |= RX_PKTFLAG_ACKED;
someAcked = 1;
}
}
} else {
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
- for (queue_Scan(&call->tq, p, tp, rx_packet)) {
- if (!p)
- break;
- queue_Remove(p);
- rxi_FreePacket(p);
- }
+#ifdef RXDEBUG_PACKET
+ call->tqc -=
+#endif /* RXDEBUG_PACKET */
+ rxi_FreePackets(0, &call->tq);
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
call->flags &= ~RX_CALL_TQ_CLEARME;
}
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
- rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
call->tfirst = call->tnext; /* implicitly acknowledge all data already sent */
call->nSoftAcked = 0;
}
void
-rxi_ClearReceiveQueue(register struct rx_call *call)
+rxi_ClearReceiveQueue(struct rx_call *call)
{
- register struct rx_packet *p, *tp;
if (queue_IsNotEmpty(&call->rq)) {
- for (queue_Scan(&call->rq, p, tp, rx_packet)) {
- if (!p)
- break;
- queue_Remove(p);
- rxi_FreePacket(p);
- rx_packetReclaims++;
- }
+ u_short count;
+
+ count = rxi_FreePackets(0, &call->rq);
+ rx_packetReclaims += count;
+#ifdef RXDEBUG_PACKET
+ call->rqc -= count;
+ if ( call->rqc != 0 )
+ dpf(("rxi_ClearReceiveQueue call %x rqc %u != 0", call, call->rqc));
+#endif
call->flags &= ~(RX_CALL_RECEIVE_DONE | RX_CALL_HAVE_LAST);
}
if (call->state == RX_STATE_PRECALL) {
/* Send an abort packet for the specified call */
struct rx_packet *
-rxi_SendCallAbort(register struct rx_call *call, struct rx_packet *packet,
+rxi_SendCallAbort(struct rx_call *call, struct rx_packet *packet,
int istack, int force)
{
afs_int32 error;
- struct clock when;
+ struct clock when, now;
if (!call->error)
return packet;
rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
(char *)&error, sizeof(error), istack);
} else if (!call->delayedAbortEvent) {
- clock_GetTime(&when);
+ clock_GetTime(&now);
+ when = now;
clock_Addmsec(&when, rxi_callAbortDelay);
CALL_HOLD(call, RX_CALL_REFCOUNT_ABORT);
call->delayedAbortEvent =
- rxevent_Post(&when, rxi_SendDelayedCallAbort, call, 0);
+ rxevent_PostNow(&when, &now, rxi_SendDelayedCallAbort, call, 0);
}
return packet;
}
* to send the abort packet.
*/
struct rx_packet *
-rxi_SendConnectionAbort(register struct rx_connection *conn,
+rxi_SendConnectionAbort(struct rx_connection *conn,
struct rx_packet *packet, int istack, int force)
{
afs_int32 error;
- struct clock when;
+ struct clock when, now;
if (!conn->error)
return packet;
sizeof(error), istack);
MUTEX_ENTER(&conn->conn_data_lock);
} else if (!conn->delayedAbortEvent) {
- clock_GetTime(&when);
+ clock_GetTime(&now);
+ when = now;
clock_Addmsec(&when, rxi_connAbortDelay);
conn->delayedAbortEvent =
- rxevent_Post(&when, rxi_SendDelayedConnAbort, conn, 0);
+ rxevent_PostNow(&when, &now, rxi_SendDelayedConnAbort, conn, 0);
}
return packet;
}
* error at this point, so that future packets received will be
* rejected. */
void
-rxi_ConnectionError(register struct rx_connection *conn,
- register afs_int32 error)
+rxi_ConnectionError(struct rx_connection *conn,
+ afs_int32 error)
{
if (error) {
- register int i;
+ int i;
+
+ dpf(("rxi_ConnectionError conn %x error %d", conn, error));
+
MUTEX_ENTER(&conn->conn_data_lock);
if (conn->challengeEvent)
rxevent_Cancel(conn->challengeEvent, (struct rx_call *)0, 0);
}
}
conn->error = error;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.fatalErrors++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.fatalErrors, rx_stats_mutex);
}
}
void
-rxi_CallError(register struct rx_call *call, afs_int32 error)
+rxi_CallError(struct rx_call *call, afs_int32 error)
{
+#ifdef DEBUG
+ osirx_AssertMine(&call->lock, "rxi_CallError");
+#endif
+ dpf(("rxi_CallError call %x error %d call->error %d", call, error, call->error));
if (call->error)
error = call->error;
-#ifdef RX_GLOBAL_RXLOCK_KERNEL
- if (!(call->flags & RX_CALL_TQ_BUSY)) {
+
+#ifdef AFS_GLOBAL_RXLOCK_KERNEL
+ if (!((call->flags & RX_CALL_TQ_BUSY) || (call->tqWaiters > 0))) {
rxi_ResetCall(call, 0);
}
#else
#endif /* ADAPT_WINDOW */
void
-rxi_ResetCall(register struct rx_call *call, register int newcall)
+rxi_ResetCall(struct rx_call *call, int newcall)
{
- register int flags;
- register struct rx_peer *peer;
+ int flags;
+ struct rx_peer *peer;
struct rx_packet *packet;
+#ifdef DEBUG
+ osirx_AssertMine(&call->lock, "rxi_ResetCall");
+#endif
+ dpf(("rxi_ResetCall(call %x, newcall %d)\n", call, newcall));
/* Notify anyone who is waiting for asynchronous packet arrival */
if (call->arrivalProc) {
MUTEX_EXIT(&peer->peer_lock);
flags = call->flags;
- rxi_ClearReceiveQueue(call);
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
- if (call->flags & RX_CALL_TQ_BUSY) {
+ if (flags & RX_CALL_TQ_BUSY) {
call->flags = RX_CALL_TQ_CLEARME | RX_CALL_TQ_BUSY;
call->flags |= (flags & RX_CALL_TQ_WAIT);
} else
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
{
- rxi_ClearTransmitQueue(call, 0);
- queue_Init(&call->tq);
+ rxi_ClearTransmitQueue(call, 1);
+ /* why init the queue if you just emptied it? queue_Init(&call->tq); */
+ if (call->tqWaiters || (flags & RX_CALL_TQ_WAIT)) {
+ dpf(("rcall %x has %d waiters and flags %d\n", call, call->tqWaiters, call->flags));
+ }
call->flags = 0;
+ while (call->tqWaiters) {
+#ifdef RX_ENABLE_LOCKS
+ CV_BROADCAST(&call->cv_tq);
+#else /* RX_ENABLE_LOCKS */
+ osi_rxWakeup(&call->tq);
+#endif /* RX_ENABLE_LOCKS */
+ call->tqWaiters--;
+ }
}
- queue_Init(&call->rq);
+
+ rxi_ClearReceiveQueue(call);
+ /* why init the queue if you just emptied it? queue_Init(&call->rq); */
+
+ if (call->currentPacket) {
+ call->currentPacket->flags &= ~RX_PKTFLAG_CP;
+ call->currentPacket->flags |= RX_PKTFLAG_IOVQ;
+ queue_Prepend(&call->iovq, call->currentPacket);
+#ifdef RXDEBUG_PACKET
+ call->iovqc++;
+#endif /* RXDEBUG_PACKET */
+ call->currentPacket = (struct rx_packet *)0;
+ }
+ call->curlen = call->nLeft = call->nFree = 0;
+
+#ifdef RXDEBUG_PACKET
+ call->iovqc -=
+#endif
+ rxi_FreePackets(0, &call->iovq);
+
call->error = 0;
- call->rwind = rx_initReceiveWindow;
- call->twind = rx_initSendWindow;
+ call->twind = call->conn->twind[call->channel];
+ call->rwind = call->conn->rwind[call->channel];
call->nSoftAcked = 0;
call->nextCwind = 0;
call->nAcks = 0;
if (queue_IsOnQueue(call)) {
queue_Remove(call);
if (flags & RX_CALL_WAIT_PROC) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_nWaiting--;
- MUTEX_EXIT(&rx_stats_mutex);
+
+ MUTEX_ENTER(&rx_waiting_mutex);
+ rx_nWaiting--;
+ MUTEX_EXIT(&rx_waiting_mutex);
}
}
MUTEX_EXIT(call->call_queue_lock);
* ignored by mundanes, which indicates the maximum size packet this
* host can swallow. */
/*
- register struct rx_packet *optionalPacket; use to send ack (or null)
+ struct rx_packet *optionalPacket; use to send ack (or null)
int seq; Sequence number of the packet we are acking
int serial; Serial number of the packet
int pflags; Flags field from packet header
*/
struct rx_packet *
-rxi_SendAck(register struct rx_call *call,
- register struct rx_packet *optionalPacket, int serial, int reason,
+rxi_SendAck(struct rx_call *call,
+ struct rx_packet *optionalPacket, int serial, int reason,
int istack)
{
struct rx_ackPacket *ap;
- register struct rx_packet *rqp;
- register struct rx_packet *nxp; /* For queue_Scan */
- register struct rx_packet *p;
+ struct rx_packet *rqp;
+ struct rx_packet *nxp; /* For queue_Scan */
+ struct rx_packet *p;
u_char offset;
afs_int32 templ;
+#ifdef RX_ENABLE_TSFPQ
+ struct rx_ts_info_t * rx_ts_info;
+#endif
/*
* Open the receive window once a thread starts reading packets
*/
if (call->rnext > 1) {
- call->rwind = rx_maxReceiveWindow;
+ call->conn->rwind[call->channel] = call->rwind = rx_maxReceiveWindow;
}
call->nHardAcks = 0;
if (p) {
rx_computelen(p, p->length); /* reset length, you never know */
} /* where that's been... */
+#ifdef RX_ENABLE_TSFPQ
+ else {
+ RX_TS_INFO_GET(rx_ts_info);
+ if ((p = rx_ts_info->local_special_packet)) {
+ rx_computelen(p, p->length);
+ } else if ((p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL))) {
+ rx_ts_info->local_special_packet = p;
+ } else { /* We won't send the ack, but don't panic. */
+ return optionalPacket;
+ }
+ }
+#else
else if (!(p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL))) {
/* We won't send the ack, but don't panic. */
return optionalPacket;
}
+#endif
templ =
rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32) -
rx_GetDataSize(p);
if (templ > 0) {
- if (rxi_AllocDataBuf(p, templ, RX_PACKET_CLASS_SPECIAL)) {
+ if (rxi_AllocDataBuf(p, templ, RX_PACKET_CLASS_SPECIAL) > 0) {
+#ifndef RX_ENABLE_TSFPQ
if (!optionalPacket)
rxi_FreePacket(p);
+#endif
return optionalPacket;
}
templ = rx_AckDataSize(call->rwind) + 2 * sizeof(afs_int32);
if (rx_Contiguous(p) < templ) {
+#ifndef RX_ENABLE_TSFPQ
if (!optionalPacket)
rxi_FreePacket(p);
+#endif
return optionalPacket;
}
}
for (offset = 0, queue_Scan(&call->rq, rqp, nxp, rx_packet)) {
if (!rqp || !call->rq.next
|| (rqp->header.seq > (call->rnext + call->rwind))) {
+#ifndef RX_ENABLE_TSFPQ
if (!optionalPacket)
rxi_FreePacket(p);
+#endif
rxi_CallError(call, RX_CALL_DEAD);
return optionalPacket;
}
ap->acks[offset++] = RX_ACK_TYPE_ACK;
if ((offset > (u_char) rx_maxReceiveWindow) || (offset > call->rwind)) {
+#ifndef RX_ENABLE_TSFPQ
if (!optionalPacket)
rxi_FreePacket(p);
+#endif
rxi_CallError(call, RX_CALL_DEAD);
return optionalPacket;
}
p->header.flags |= RX_CLIENT_INITIATED;
#ifdef RXDEBUG
+#ifdef AFS_NT40_ENV
+ if (rxdebug_active) {
+ char msg[512];
+ size_t len;
+
+ len = _snprintf(msg, sizeof(msg),
+ "tid[%d] SACK: reason %s serial %u previous %u seq %u first %u acks %u space %u ",
+ GetCurrentThreadId(), rx_ack_reason(ap->reason),
+ ntohl(ap->serial), ntohl(ap->previousPacket),
+ (unsigned int)p->header.seq, ntohl(ap->firstPacket),
+ ap->nAcks, ntohs(ap->bufferSpace) );
+ if (ap->nAcks) {
+ int offset;
+
+ for (offset = 0; offset < ap->nAcks && len < sizeof(msg); offset++)
+ msg[len++] = (ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*');
+ }
+ msg[len++]='\n';
+ msg[len] = '\0';
+ OutputDebugString(msg);
+ }
+#else /* AFS_NT40_ENV */
if (rx_Log) {
- fprintf(rx_Log, "SACK: reason %x previous %u seq %u first %u",
+ fprintf(rx_Log, "SACK: reason %x previous %u seq %u first %u ",
ap->reason, ntohl(ap->previousPacket),
(unsigned int)p->header.seq, ntohl(ap->firstPacket));
if (ap->nAcks) {
}
putc('\n', rx_Log);
}
+#endif /* AFS_NT40_ENV */
#endif
-
{
- register int i, nbytes = p->length;
+ int i, nbytes = p->length;
for (i = 1; i < p->niovecs; i++) { /* vec 0 is ALWAYS header */
if (nbytes <= p->wirevec[i].iov_len) {
- register int savelen, saven;
+ int savelen, saven;
savelen = p->wirevec[i].iov_len;
saven = p->niovecs;
nbytes -= p->wirevec[i].iov_len;
}
}
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.ackPacketsSent++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.ackPacketsSent, rx_stats_mutex);
+#ifndef RX_ENABLE_TSFPQ
if (!optionalPacket)
rxi_FreePacket(p);
+#endif
return optionalPacket; /* Return packet for re-use by caller */
}
peer->nSent += len;
if (resending)
peer->reSends += len;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dataPacketsSent += len;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexAdd(rx_stats.dataPacketsSent, len, rx_stats_mutex);
MUTEX_EXIT(&peer->peer_lock);
if (list[len - 1]->header.flags & RX_LAST_PACKET) {
* packet until the congestion window reaches the ack rate. */
if (list[i]->header.serial) {
requestAck = 1;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dataPacketsReSent++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.dataPacketsReSent, rx_stats_mutex);
} else {
/* improved RTO calculation- not Karn */
list[i]->firstSent = *now;
}
}
- MUTEX_ENTER(&peer->peer_lock);
- peer->nSent++;
- if (resending)
- peer->reSends++;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.dataPacketsSent++;
- MUTEX_EXIT(&rx_stats_mutex);
- MUTEX_EXIT(&peer->peer_lock);
-
/* Tag this packet as not being the last in this group,
* for the receiver's benefit */
if (i < len - 1 || moreFlag) {
/* Update last send time for this call (for keep-alive
* processing), and for the connection (so that we can discover
* idle connections) */
- conn->lastSendTime = call->lastSendTime = clock_Sec();
+ call->lastSendData = conn->lastSendTime = call->lastSendTime = clock_Sec();
}
/* When sending packets we need to follow these rules:
#ifdef RX_ENABLE_LOCKS
/* Call rxi_Start, below, but with the call lock held. */
void
-rxi_StartUnlocked(struct rxevent *event, register struct rx_call *call,
- void *arg1, int istack)
+rxi_StartUnlocked(struct rxevent *event,
+ void *arg0, void *arg1, int istack)
{
+ struct rx_call *call = arg0;
+
MUTEX_ENTER(&call->lock);
rxi_Start(event, call, arg1, istack);
MUTEX_EXIT(&call->lock);
* better optimized for new packets, the usual case, now that we've
* got rid of queues of send packets. XXXXXXXXXXX */
void
-rxi_Start(struct rxevent *event, register struct rx_call *call,
- void *arg1, int istack)
+rxi_Start(struct rxevent *event,
+ void *arg0, void *arg1, int istack)
{
+ struct rx_call *call = arg0;
+
struct rx_packet *p;
- register struct rx_packet *nxp; /* Next pointer for queue_Scan */
+ struct rx_packet *nxp; /* Next pointer for queue_Scan */
struct rx_peer *peer = call->conn->peer;
- struct clock now, retryTime;
+ struct clock now, usenow, retryTime;
int haveEvent;
int nXmitPackets;
int maxXmitPackets;
return;
}
call->flags |= RX_CALL_FAST_RECOVER_WAIT;
- while (call->flags & RX_CALL_TQ_BUSY) {
- call->flags |= RX_CALL_TQ_WAIT;
-#ifdef RX_ENABLE_LOCKS
- CV_WAIT(&call->cv_tq, &call->lock);
-#else /* RX_ENABLE_LOCKS */
- osi_rxSleep(&call->tq);
-#endif /* RX_ENABLE_LOCKS */
- }
+ rxi_WaitforTQBusy(call);
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
call->flags |= RX_CALL_FAST_RECOVER;
}
if (call->error) {
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
- MUTEX_ENTER(&rx_stats_mutex);
- rx_tq_debug.rxi_start_in_error++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_tq_debug.rxi_start_in_error, rx_stats_mutex);
#endif
return;
}
* in this burst. Note, if we back off, it's reasonable to
* back off all of the packets in the same manner, even if
* some of them have been retransmitted more times than more
- * recent additions */
- clock_GetTime(&now);
- retryTime = now; /* initialize before use */
+ * recent additions.
+ * Do a dance to avoid blocking after setting now. */
+ clock_Zero(&retryTime);
MUTEX_ENTER(&peer->peer_lock);
clock_Add(&retryTime, &peer->timeout);
MUTEX_EXIT(&peer->peer_lock);
-
+ clock_GetTime(&now);
+ clock_Add(&retryTime, &now);
+ usenow = now;
/* Send (or resend) any packets that need it, subject to
* window restrictions and congestion burst control
* restrictions. Ask for an ack on the last packet sent in
nXmitPackets = 0;
maxXmitPackets = MIN(call->twind, call->cwind);
xmitList = (struct rx_packet **)
- osi_Alloc(maxXmitPackets * sizeof(struct rx_packet *));
+#if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
+ /* XXXX else we must drop any mtx we hold */
+ afs_osi_Alloc_NoSleep(maxXmitPackets * sizeof(struct rx_packet *));
+#else
+ osi_Alloc(maxXmitPackets * sizeof(struct rx_packet *));
+#endif
if (xmitList == NULL)
osi_Panic("rxi_Start, failed to allocate xmit list");
for (queue_Scan(&call->tq, p, nxp, rx_packet)) {
osi_Panic("rxi_Start: xmit queue clobbered");
}
if (p->flags & RX_PKTFLAG_ACKED) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.ignoreAckedPacket++;
- MUTEX_EXIT(&rx_stats_mutex);
+ /* Since we may block, don't trust this */
+ usenow.sec = usenow.usec = 0;
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_stats.ignoreAckedPacket, rx_stats_mutex);
continue; /* Ignore this packet if it has been acknowledged */
}
*/
if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
call->flags &= ~RX_CALL_TQ_BUSY;
- if (call->flags & RX_CALL_TQ_WAIT) {
- call->flags &= ~RX_CALL_TQ_WAIT;
+ if (call->tqWaiters || (call->flags & RX_CALL_TQ_WAIT)) {
+ dpf(("call %x has %d waiters and flags %d\n", call, call->tqWaiters, call->flags));
#ifdef RX_ENABLE_LOCKS
+ osirx_AssertMine(&call->lock, "rxi_Start start");
CV_BROADCAST(&call->cv_tq);
#else /* RX_ENABLE_LOCKS */
osi_rxWakeup(&call->tq);
* the time to reset the call. This will also inform the using
* process that the call is in an error state.
*/
- MUTEX_ENTER(&rx_stats_mutex);
- rx_tq_debug.rxi_start_aborted++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexIncrement(rx_tq_debug.rxi_start_aborted, rx_stats_mutex);
call->flags &= ~RX_CALL_TQ_BUSY;
- if (call->flags & RX_CALL_TQ_WAIT) {
- call->flags &= ~RX_CALL_TQ_WAIT;
+ if (call->tqWaiters || (call->flags & RX_CALL_TQ_WAIT)) {
+ dpf(("call %x has %d waiters and flags %d\n", call, call->tqWaiters, call->flags));
#ifdef RX_ENABLE_LOCKS
+ osirx_AssertMine(&call->lock, "rxi_Start middle");
CV_BROADCAST(&call->cv_tq);
#else /* RX_ENABLE_LOCKS */
osi_rxWakeup(&call->tq);
}
#ifdef RX_ENABLE_LOCKS
if (call->flags & RX_CALL_TQ_SOME_ACKED) {
- register int missing;
+ int missing;
call->flags &= ~RX_CALL_TQ_SOME_ACKED;
/* Some packets have received acks. If they all have, we can clear
* the transmit queue.
if (p->header.seq < call->tfirst
&& (p->flags & RX_PKTFLAG_ACKED)) {
queue_Remove(p);
+ p->flags &= ~RX_PKTFLAG_TQ;
+#ifdef RXDEBUG_PACKET
+ call->tqc--;
+#endif
rxi_FreePacket(p);
} else
missing = 1;
#ifdef RX_ENABLE_LOCKS
CALL_HOLD(call, RX_CALL_REFCOUNT_RESEND);
call->resendEvent =
- rxevent_Post2(&retryTime, rxi_StartUnlocked,
- (void *)call, 0, istack);
+ rxevent_PostNow2(&retryTime, &usenow,
+ rxi_StartUnlocked,
+ (void *)call, 0, istack);
#else /* RX_ENABLE_LOCKS */
call->resendEvent =
- rxevent_Post2(&retryTime, rxi_Start, (void *)call,
- 0, istack);
+ rxevent_PostNow2(&retryTime, &usenow, rxi_Start,
+ (void *)call, 0, istack);
#endif /* RX_ENABLE_LOCKS */
}
}
* protected by the global lock.
*/
call->flags &= ~RX_CALL_TQ_BUSY;
- if (call->flags & RX_CALL_TQ_WAIT) {
- call->flags &= ~RX_CALL_TQ_WAIT;
+ if (call->tqWaiters || (call->flags & RX_CALL_TQ_WAIT)) {
+ dpf(("call %x has %d waiters and flags %d\n", call, call->tqWaiters, call->flags));
#ifdef RX_ENABLE_LOCKS
+ osirx_AssertMine(&call->lock, "rxi_Start end");
CV_BROADCAST(&call->cv_tq);
#else /* RX_ENABLE_LOCKS */
osi_rxWakeup(&call->tq);
* that we have just sent a packet (so keep alives aren't sent
* immediately) */
void
-rxi_Send(register struct rx_call *call, register struct rx_packet *p,
+rxi_Send(struct rx_call *call, struct rx_packet *p,
int istack)
{
- register struct rx_connection *conn = call->conn;
+ struct rx_connection *conn = call->conn;
/* Stamp each packet with the user supplied status */
p->header.userStatus = call->localStatus;
* processing), and for the connection (so that we can discover
* idle connections) */
conn->lastSendTime = call->lastSendTime = clock_Sec();
+ /* Don't count keepalives here, so idleness can be tracked. */
+ if ((p->header.type != RX_PACKET_TYPE_ACK) || (((struct rx_ackPacket *)rx_DataOf(p))->reason != RX_ACK_PING))
+ call->lastSendData = call->lastSendTime;
}
*/
#ifdef RX_ENABLE_LOCKS
int
-rxi_CheckCall(register struct rx_call *call, int haveCTLock)
+rxi_CheckCall(struct rx_call *call, int haveCTLock)
#else /* RX_ENABLE_LOCKS */
int
-rxi_CheckCall(register struct rx_call *call)
+rxi_CheckCall(struct rx_call *call)
#endif /* RX_ENABLE_LOCKS */
{
- register struct rx_connection *conn = call->conn;
+ struct rx_connection *conn = call->conn;
afs_uint32 now;
afs_uint32 deadTime;
-#ifdef RX_GLOBAL_RXLOCK_KERNEL
+#ifdef AFS_GLOBAL_RXLOCK_KERNEL
if (call->flags & RX_CALL_TQ_BUSY) {
/* Call is active and will be reset by rxi_Start if it's
* in an error state.
* number of seconds. */
if (now > (call->lastReceiveTime + deadTime)) {
if (call->state == RX_STATE_ACTIVE) {
+#ifdef ADAPT_PMTU
+#if defined(KERNEL) && defined(AFS_SUN57_ENV)
+ ire_t *ire;
+#if defined(AFS_SUN510_ENV) && defined(GLOBAL_NETSTACKID)
+ netstack_t *ns = netstack_find_by_stackid(GLOBAL_NETSTACKID);
+ ip_stack_t *ipst = ns->netstack_ip;
+#endif
+ ire = ire_cache_lookup(call->conn->peer->host
+#if defined(AFS_SUN510_ENV) && defined(ALL_ZONES)
+ , ALL_ZONES
+#if defined(AFS_SUN510_ENV) && (defined(ICL_3_ARG) || defined(GLOBAL_NETSTACKID))
+ , NULL
+#if defined(AFS_SUN510_ENV) && defined(GLOBAL_NETSTACKID)
+ , ipst
+#endif
+#endif
+#endif
+ );
+
+ if (ire && ire->ire_max_frag > 0)
+ rxi_SetPeerMtu(call->conn->peer->host, 0, ire->ire_max_frag);
+#if defined(GLOBAL_NETSTACKID)
+ netstack_rele(ns);
+#endif
+#endif
+#endif /* ADAPT_PMTU */
rxi_CallError(call, RX_CALL_DEAD);
return -1;
} else {
return -1;
}
}
+ if (call->lastSendData && conn->idleDeadTime && (conn->idleDeadErr != 0)
+ && ((call->lastSendData + conn->idleDeadTime) < now)) {
+ if (call->state == RX_STATE_ACTIVE) {
+ rxi_CallError(call, conn->idleDeadErr);
+ return -1;
+ }
+ }
/* see if we have a hard timeout */
if (conn->hardDeadTime
&& (now > (conn->hardDeadTime + call->startTime.sec))) {
* keep-alive packet (if we're actually trying to keep the call alive)
*/
void
-rxi_KeepAliveEvent(struct rxevent *event, register struct rx_call *call,
- char *dummy)
+rxi_KeepAliveEvent(struct rxevent *event, void *arg1, void *dummy)
{
+ struct rx_call *call = arg1;
struct rx_connection *conn;
afs_uint32 now;
void
-rxi_ScheduleKeepAliveEvent(register struct rx_call *call)
+rxi_ScheduleKeepAliveEvent(struct rx_call *call)
{
if (!call->keepAliveEvent) {
- struct clock when;
- clock_GetTime(&when);
+ struct clock when, now;
+ clock_GetTime(&now);
+ when = now;
when.sec += call->conn->secondsUntilPing;
CALL_HOLD(call, RX_CALL_REFCOUNT_ALIVE);
call->keepAliveEvent =
- rxevent_Post(&when, rxi_KeepAliveEvent, call, 0);
+ rxevent_PostNow(&when, &now, rxi_KeepAliveEvent, call, 0);
}
}
/* N.B. rxi_KeepAliveOff: is defined earlier as a macro */
void
-rxi_KeepAliveOn(register struct rx_call *call)
+rxi_KeepAliveOn(struct rx_call *call)
{
/* Pretend last packet received was received now--i.e. if another
* packet isn't received within the keep alive time, then the call
* that have been delayed to throttle looping clients. */
void
rxi_SendDelayedConnAbort(struct rxevent *event,
- register struct rx_connection *conn, char *dummy)
+ void *arg1, void *unused)
{
+ struct rx_connection *conn = arg1;
+
afs_int32 error;
struct rx_packet *packet;
/* This routine is called to send call abort messages
* that have been delayed to throttle looping clients. */
void
-rxi_SendDelayedCallAbort(struct rxevent *event, register struct rx_call *call,
- char *dummy)
+rxi_SendDelayedCallAbort(struct rxevent *event,
+ void *arg1, void *dummy)
{
+ struct rx_call *call = arg1;
+
afs_int32 error;
struct rx_packet *packet;
(char *)&error, sizeof(error), 0);
rxi_FreePacket(packet);
}
+ CALL_RELE(call, RX_CALL_REFCOUNT_ABORT);
MUTEX_EXIT(&call->lock);
}
* issues a challenge to the client, which is obtained from the
* security object associated with the connection */
void
-rxi_ChallengeEvent(struct rxevent *event, register struct rx_connection *conn,
- void *arg1, int tries)
+rxi_ChallengeEvent(struct rxevent *event,
+ void *arg0, void *arg1, int tries)
{
+ struct rx_connection *conn = arg0;
+
conn->challengeEvent = NULL;
if (RXS_CheckAuthentication(conn->securityObject, conn) != 0) {
- register struct rx_packet *packet;
- struct clock when;
+ struct rx_packet *packet;
+ struct clock when, now;
if (tries <= 0) {
/* We've failed to authenticate for too long.
RX_PACKET_TYPE_CHALLENGE, NULL, -1, 0);
rxi_FreePacket(packet);
}
- clock_GetTime(&when);
+ clock_GetTime(&now);
+ when = now;
when.sec += RX_CHALLENGE_TIMEOUT;
conn->challengeEvent =
- rxevent_Post2(&when, rxi_ChallengeEvent, conn, 0,
+ rxevent_PostNow2(&when, &now, rxi_ChallengeEvent, conn, 0,
(tries - 1));
}
}
* the challenge at this time. N.B. rxi_ChallengeOff is a macro,
* defined earlier. */
void
-rxi_ChallengeOn(register struct rx_connection *conn)
+rxi_ChallengeOn(struct rx_connection *conn)
{
if (!conn->challengeEvent) {
RXS_CreateChallenge(conn->securityObject, conn);
/* rxi_ComputeRoundTripTime is called with peer locked. */
/* sentp and/or peer may be null */
void
-rxi_ComputeRoundTripTime(register struct rx_packet *p,
- register struct clock *sentp,
- register struct rx_peer *peer)
+rxi_ComputeRoundTripTime(struct rx_packet *p,
+ struct clock *sentp,
+ struct rx_peer *peer)
{
struct clock thisRtt, *rttp = &thisRtt;
- register int rtt_timeout;
+ int rtt_timeout;
clock_GetTime(rttp);
return; /* somebody set the clock back, don't count this time. */
}
clock_Sub(rttp, sentp);
- MUTEX_ENTER(&rx_stats_mutex);
- if (clock_Lt(rttp, &rx_stats.minRtt))
- rx_stats.minRtt = *rttp;
- if (clock_Gt(rttp, &rx_stats.maxRtt)) {
- if (rttp->sec > 60) {
- MUTEX_EXIT(&rx_stats_mutex);
- return; /* somebody set the clock ahead */
- }
- rx_stats.maxRtt = *rttp;
+ if (rx_stats_active) {
+ MUTEX_ENTER(&rx_stats_mutex);
+ if (clock_Lt(rttp, &rx_stats.minRtt))
+ rx_stats.minRtt = *rttp;
+ if (clock_Gt(rttp, &rx_stats.maxRtt)) {
+ if (rttp->sec > 60) {
+ MUTEX_EXIT(&rx_stats_mutex);
+ return; /* somebody set the clock ahead */
+ }
+ rx_stats.maxRtt = *rttp;
+ }
+ clock_Add(&rx_stats.totalRtt, rttp);
+ rx_stats.nRttSamples++;
+ MUTEX_EXIT(&rx_stats_mutex);
}
- clock_Add(&rx_stats.totalRtt, rttp);
- rx_stats.nRttSamples++;
- MUTEX_EXIT(&rx_stats_mutex);
/* better rtt calculation courtesy of UMich crew (dave,larry,peter,?) */
/* Apply VanJacobson round-trip estimations */
if (peer->rtt) {
- register int delta;
+ int delta;
/*
* srtt (peer->rtt) is in units of one-eighth-milliseconds.
/* Find all server connections that have not been active for a long time, and
* toss them */
void
-rxi_ReapConnections(void)
+rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2)
{
- struct clock now;
+ struct clock now, when;
clock_GetTime(&now);
/* Find server connection structures that haven't been used for
for (i = 0; i < RX_MAXCALLS; i++) {
call = conn->call[i];
if (call) {
+ int code;
havecalls = 1;
- MUTEX_ENTER(&call->lock);
+ code = MUTEX_TRYENTER(&call->lock);
+ if (!code)
+ continue;
#ifdef RX_ENABLE_LOCKS
result = rxi_CheckCall(call, 1);
#else /* RX_ENABLE_LOCKS */
rxi_rpc_peer_stat_cnt -= num_funcs;
}
rxi_FreePeer(peer);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nPeerStructs--;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexDecrement(rx_stats.nPeerStructs, rx_stats_mutex);
if (peer == *peer_ptr) {
*peer_ptr = next;
prev = next;
}
MUTEX_EXIT(&rx_freePktQ_lock);
- now.sec += RX_REAP_TIME; /* Check every RX_REAP_TIME seconds */
- rxevent_Post(&now, rxi_ReapConnections, 0, 0);
+ when = now;
+ when.sec += RX_REAP_TIME; /* Check every RX_REAP_TIME seconds */
+ rxevent_Post(&when, rxi_ReapConnections, 0, 0);
}
*/
static void
-rxi_ComputeRate(register struct rx_peer *peer, register struct rx_call *call,
+rxi_ComputeRate(struct rx_peer *peer, struct rx_call *call,
struct rx_packet *p, struct rx_packet *ackp, u_char ackReason)
{
afs_int32 xferSize, xferMs;
- register afs_int32 minTime;
+ afs_int32 minTime;
struct clock newTO;
/* Count down packets */
#endif /* ADAPT_WINDOW */
+void
+rxi_DebugInit(void)
+{
+#ifdef RXDEBUG
+#ifdef AFS_NT40_ENV
+#define TRACE_OPTION_RX_DEBUG 16
+ HKEY parmKey;
+ DWORD dummyLen;
+ DWORD TraceOption;
+ long code;
+
+ rxdebug_active = 0;
+ code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
+ 0, KEY_QUERY_VALUE, &parmKey);
+ if (code != ERROR_SUCCESS)
+ return;
+ dummyLen = sizeof(TraceOption);
+ code = RegQueryValueEx(parmKey, "TraceOption", NULL, NULL,
+ (BYTE *) &TraceOption, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ rxdebug_active = (TraceOption & TRACE_OPTION_RX_DEBUG) ? 1 : 0;
+ }
+ RegCloseKey (parmKey);
+#endif /* AFS_NT40_ENV */
+#endif
+}
+void
+rx_DebugOnOff(int on)
+{
+#ifdef RXDEBUG
+#ifdef AFS_NT40_ENV
+ rxdebug_active = on;
+#endif
+#endif
+}
+void
+rx_StatsOnOff(int on)
+{
#ifdef RXDEBUG
+ rx_stats_active = on;
+#endif
+}
+
+
/* Don't call this debugging routine directly; use dpf */
void
-rxi_DebugPrint(char *format, int a1, int a2, int a3, int a4, int a5, int a6,
- int a7, int a8, int a9, int a10, int a11, int a12, int a13,
- int a14, int a15)
+rxi_DebugPrint(char *format, ...)
{
+#ifdef RXDEBUG
+ va_list ap;
+#ifdef AFS_NT40_ENV
+ char msg[512];
+ char tformat[256];
+ size_t len;
+
+ va_start(ap, format);
+
+ len = _snprintf(tformat, sizeof(tformat), "tid[%d] %s", GetCurrentThreadId(), format);
+
+ if (len > 0) {
+ len = _vsnprintf(msg, sizeof(msg)-2, tformat, ap);
+ if (len > 0) {
+ if (msg[len-1] != '\n') {
+ msg[len] = '\n';
+ msg[len+1] = '\0';
+ }
+ OutputDebugString(msg);
+ }
+ }
+ va_end(ap);
+#else
struct clock now;
+
+ va_start(ap, format);
+
clock_GetTime(&now);
fprintf(rx_Log, " %u.%.3u:", (unsigned int)now.sec,
(unsigned int)now.usec / 1000);
- fprintf(rx_Log, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
- a13, a14, a15);
+ vfprintf(rx_Log, format, ap);
putc('\n', rx_Log);
-}
+ va_end(ap);
#endif
+#endif
+}
-#ifdef RXDEBUG
+#ifndef KERNEL
/*
* This function is used to process the rx_stats structure that is local
* to a process as well as an rx_stats structure received from a remote
* checking.
*/
void
-rx_PrintTheseStats(FILE * file, struct rx_stats *s, int size,
+rx_PrintTheseStats(FILE * file, struct rx_statistics *s, int size,
afs_int32 freePackets, char version)
{
+#ifdef RXDEBUG
int i;
- if (size != sizeof(struct rx_stats)) {
+ if (size != sizeof(struct rx_statistics)) {
fprintf(file,
- "Unexpected size of stats structure: was %d, expected %d\n",
- size, sizeof(struct rx_stats));
+ "Unexpected size of stats structure: was %d, expected %lud\n",
+ size, sizeof(struct rx_statistics));
}
fprintf(file, "rx stats: free packets %d, allocs %d, ", (int)freePackets,
s->packetRequests);
if (version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
- fprintf(file, "alloc-failures(rcv %d/%d,send %d/%d,ack %d)\n",
+ fprintf(file, "alloc-failures(rcv %u/%u,send %u/%u,ack %u)\n",
s->receivePktAllocFailures, s->receiveCbufPktAllocFailures,
s->sendPktAllocFailures, s->sendCbufPktAllocFailures,
s->specialPktAllocFailures);
} else {
- fprintf(file, "alloc-failures(rcv %d,send %d,ack %d)\n",
+ fprintf(file, "alloc-failures(rcv %u,send %u,ack %u)\n",
s->receivePktAllocFailures, s->sendPktAllocFailures,
s->specialPktAllocFailures);
}
fprintf(file,
- " greedy %d, " "bogusReads %d (last from host %x), "
- "noPackets %d, " "noBuffers %d, " "selects %d, "
- "sendSelects %d\n", s->socketGreedy, s->bogusPacketOnRead,
+ " greedy %u, " "bogusReads %u (last from host %x), "
+ "noPackets %u, " "noBuffers %u, " "selects %u, "
+ "sendSelects %u\n", s->socketGreedy, s->bogusPacketOnRead,
s->bogusHost, s->noPacketOnRead, s->noPacketBuffersOnRead,
s->selects, s->sendSelects);
fprintf(file, " packets read: ");
for (i = 0; i < RX_N_PACKET_TYPES; i++) {
- fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsRead[i]);
+ fprintf(file, "%s %u ", rx_packetTypes[i], s->packetsRead[i]);
}
fprintf(file, "\n");
fprintf(file,
- " other read counters: data %d, " "ack %d, " "dup %d "
- "spurious %d " "dally %d\n", s->dataPacketsRead,
+ " other read counters: data %u, " "ack %u, " "dup %u "
+ "spurious %u " "dally %u\n", s->dataPacketsRead,
s->ackPacketsRead, s->dupPacketsRead, s->spuriousPacketsRead,
s->ignorePacketDally);
fprintf(file, " packets sent: ");
for (i = 0; i < RX_N_PACKET_TYPES; i++) {
- fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsSent[i]);
+ fprintf(file, "%s %u ", rx_packetTypes[i], s->packetsSent[i]);
}
fprintf(file, "\n");
fprintf(file,
- " other send counters: ack %d, " "data %d (not resends), "
- "resends %d, " "pushed %d, " "acked&ignored %d\n",
+ " other send counters: ack %u, " "data %u (not resends), "
+ "resends %u, " "pushed %u, " "acked&ignored %u\n",
s->ackPacketsSent, s->dataPacketsSent, s->dataPacketsReSent,
s->dataPacketsPushed, s->ignoreAckedPacket);
fprintf(file,
- " \t(these should be small) sendFailed %d, " "fatalErrors %d\n",
+ " \t(these should be small) sendFailed %u, " "fatalErrors %u\n",
s->netSendFailures, (int)s->fatalErrors);
if (s->nRttSamples) {
#if !defined(AFS_PTHREAD_ENV) && !defined(AFS_USE_GETTIMEOFDAY)
fprintf(file, " %d clock updates\n", clock_nUpdates);
#endif
-
+#else
+ fprintf(file, "ERROR: compiled without RXDEBUG\n");
+#endif
}
/* for backward compatibility */
"max out packet skew %d\n", peer->ifMTU, (int)peer->inPacketSkew,
(int)peer->outPacketSkew);
}
+#endif
-#ifdef AFS_PTHREAD_ENV
+#if defined(AFS_PTHREAD_ENV) && defined(RXDEBUG)
/*
* This mutex protects the following static variables:
* counter
*/
-#define LOCK_RX_DEBUG assert(pthread_mutex_lock(&rx_debug_mutex)==0)
-#define UNLOCK_RX_DEBUG assert(pthread_mutex_unlock(&rx_debug_mutex)==0)
+#define LOCK_RX_DEBUG MUTEX_ENTER(&rx_debug_mutex)
+#define UNLOCK_RX_DEBUG MUTEX_EXIT(&rx_debug_mutex)
#else
#define LOCK_RX_DEBUG
#define UNLOCK_RX_DEBUG
#endif /* AFS_PTHREAD_ENV */
+#ifdef RXDEBUG
static int
MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
u_char type, void *inputData, size_t inputLength,
void *outputData, size_t outputLength)
{
static afs_int32 counter = 100;
- afs_int32 endTime;
+ time_t waitTime, waitCount, startTime;
struct rx_header theader;
char tbuffer[1500];
- register afs_int32 code;
- struct timeval tv;
+ afs_int32 code;
+ struct timeval tv_now, tv_wake, tv_delta;
struct sockaddr_in taddr, faddr;
+#ifdef AFS_NT40_ENV
int faddrLen;
+#else
+ socklen_t faddrLen;
+#endif
fd_set imask;
- register char *tp;
+ char *tp;
- endTime = time(0) + 20; /* try for 20 seconds */
+ startTime = time(0);
+ waitTime = 1;
+ waitCount = 5;
LOCK_RX_DEBUG;
counter++;
UNLOCK_RX_DEBUG;
(struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
/* see if there's a packet available */
- FD_ZERO(&imask);
- FD_SET(socket, &imask);
- tv.tv_sec = 1;
- tv.tv_usec = 0;
- code = select(socket + 1, &imask, 0, 0, &tv);
- if (code == 1 && FD_ISSET(socket, &imask)) {
- /* now receive a packet */
- faddrLen = sizeof(struct sockaddr_in);
- code =
- recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
- (struct sockaddr *)&faddr, &faddrLen);
-
- if (code > 0) {
- memcpy(&theader, tbuffer, sizeof(struct rx_header));
- if (counter == ntohl(theader.callNumber))
- break;
+ gettimeofday(&tv_wake,0);
+ tv_wake.tv_sec += waitTime;
+ for (;;) {
+ FD_ZERO(&imask);
+ FD_SET(socket, &imask);
+ tv_delta.tv_sec = tv_wake.tv_sec;
+ tv_delta.tv_usec = tv_wake.tv_usec;
+ gettimeofday(&tv_now, 0);
+
+ if (tv_delta.tv_usec < tv_now.tv_usec) {
+ /* borrow */
+ tv_delta.tv_usec += 1000000;
+ tv_delta.tv_sec--;
+ }
+ tv_delta.tv_usec -= tv_now.tv_usec;
+
+ if (tv_delta.tv_sec < tv_now.tv_sec) {
+ /* time expired */
+ break;
}
+ tv_delta.tv_sec -= tv_now.tv_sec;
+
+ code = select(socket + 1, &imask, 0, 0, &tv_delta);
+ if (code == 1 && FD_ISSET(socket, &imask)) {
+ /* now receive a packet */
+ faddrLen = sizeof(struct sockaddr_in);
+ code =
+ recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
+ (struct sockaddr *)&faddr, &faddrLen);
+
+ if (code > 0) {
+ memcpy(&theader, tbuffer, sizeof(struct rx_header));
+ if (counter == ntohl(theader.callNumber))
+ goto success;
+ continue;
+ }
+ }
+ break;
}
/* see if we've timed out */
- if (endTime < time(0))
- return -1;
+ if (!--waitCount) {
+ return -1;
+ }
+ waitTime <<= 1;
}
+
+ success:
code -= sizeof(struct rx_header);
if (code > outputLength)
code = outputLength;
memcpy(outputData, tp, code);
return code;
}
+#endif /* RXDEBUG */
afs_int32
rx_GetServerDebug(osi_socket socket, afs_uint32 remoteAddr,
afs_uint16 remotePort, struct rx_debugStats * stat,
afs_uint32 * supportedValues)
{
- struct rx_debugIn in;
+#ifndef RXDEBUG
+ afs_int32 rc = -1;
+#else
afs_int32 rc = 0;
+ struct rx_debugIn in;
+ afs_int32 *lp = (afs_int32 *) stat;
*supportedValues = 0;
in.type = htonl(RX_DEBUGI_GETSTATS);
if (stat->version >= RX_DEBUGI_VERSION_W_WAITED) {
*supportedValues |= RX_SERVER_DEBUG_WAITED_CNT;
}
-
+ if (stat->version >= RX_DEBUGI_VERSION_W_PACKETS) {
+ *supportedValues |= RX_SERVER_DEBUG_PACKETS_CNT;
+ }
stat->nFreePackets = ntohl(stat->nFreePackets);
stat->packetReclaims = ntohl(stat->packetReclaims);
stat->callsExecuted = ntohl(stat->callsExecuted);
stat->nWaiting = ntohl(stat->nWaiting);
stat->idleThreads = ntohl(stat->idleThreads);
+ stat->nWaited = ntohl(stat->nWaited);
+ stat->nPackets = ntohl(stat->nPackets);
}
-
+#endif
return rc;
}
afs_int32
rx_GetServerStats(osi_socket socket, afs_uint32 remoteAddr,
- afs_uint16 remotePort, struct rx_stats * stat,
+ afs_uint16 remotePort, struct rx_statistics * stat,
afs_uint32 * supportedValues)
{
+#ifndef RXDEBUG
+ afs_int32 rc = -1;
+#else
+ afs_int32 rc = 0;
struct rx_debugIn in;
afs_int32 *lp = (afs_int32 *) stat;
int i;
- afs_int32 rc = 0;
/*
* supportedValues is currently unused, but added to allow future
*lp = ntohl(*lp);
}
}
-
+#endif
return rc;
}
afs_uint16 remotePort, size_t version_length,
char *version)
{
+#ifdef RXDEBUG
char a[1] = { 0 };
return MakeDebugCall(socket, remoteAddr, remotePort,
RX_PACKET_TYPE_VERSION, a, 1, version,
version_length);
+#else
+ return -1;
+#endif
}
afs_int32
struct rx_debugConn * conn,
afs_uint32 * supportedValues)
{
- struct rx_debugIn in;
+#ifndef RXDEBUG
+ afs_int32 rc = -1;
+#else
afs_int32 rc = 0;
+ struct rx_debugIn in;
int i;
/*
conn->epoch = ntohl(conn->epoch);
conn->natMTU = ntohl(conn->natMTU);
}
-
+#endif
return rc;
}
afs_uint32 debugSupportedValues, struct rx_debugPeer * peer,
afs_uint32 * supportedValues)
{
- struct rx_debugIn in;
+#ifndef RXDEBUG
+ afs_int32 rc = -1;
+#else
afs_int32 rc = 0;
+ struct rx_debugIn in;
/*
* supportedValues is currently unused, but added to allow future
peer->bytesReceived.high = ntohl(peer->bytesReceived.high);
peer->bytesReceived.low = ntohl(peer->bytesReceived.low);
}
-
+#endif
return rc;
}
-#endif /* RXDEBUG */
void
shutdown_rx(void)
{
struct rx_serverQueueEntry *np;
- register int i, j;
+ int i, j;
#ifndef KERNEL
- register struct rx_call *call;
- register struct rx_serverQueueEntry *sq;
+ struct rx_call *call;
+ struct rx_serverQueueEntry *sq;
#endif /* KERNEL */
LOCK_RX_INIT;
}
next = peer->next;
rxi_FreePeer(peer);
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.nPeerStructs--;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active)
+ rx_MutexDecrement(rx_stats.nPeerStructs, rx_stats_mutex);
}
}
}
rxi_Free(rx_services[i], sizeof(*rx_services[i]));
}
for (i = 0; i < rx_hashTableSize; i++) {
- register struct rx_connection *tc, *ntc;
+ struct rx_connection *tc, *ntc;
MUTEX_ENTER(&rx_connHashTable_lock);
for (tc = rx_connHashTable[i]; tc; tc = ntc) {
ntc = tc->next;
rxi_FreeAllPackets();
- MUTEX_ENTER(&rx_stats_mutex);
+ MUTEX_ENTER(&rx_quota_mutex);
rxi_dataQuota = RX_MAX_QUOTA;
rxi_availProcs = rxi_totalMin = rxi_minDeficit = 0;
- MUTEX_EXIT(&rx_stats_mutex);
-
+ MUTEX_EXIT(&rx_quota_mutex);
rxinit_status = 1;
UNLOCK_RX_INIT;
}
int isServer)
{
+ if (!(rxi_monitor_peerStats || rxi_monitor_processStats))
+ return;
+
MUTEX_ENTER(&rx_rpc_stats);
MUTEX_ENTER(&peer->peer_lock);
return 0;
return rxi_rxstat_userok(call);
}
+
+#ifdef AFS_NT40_ENV
+/*
+ * DllMain() -- Entry-point function called by the DllMainCRTStartup()
+ * function in the MSVC runtime DLL (msvcrt.dll).
+ *
+ * Note: the system serializes calls to this function.
+ */
+BOOL WINAPI
+DllMain(HINSTANCE dllInstHandle, /* instance handle for this DLL module */
+ DWORD reason, /* reason function is being called */
+ LPVOID reserved) /* reserved for future use */
+{
+ switch (reason) {
+ case DLL_PROCESS_ATTACH:
+ /* library is being attached to a process */
+ INIT_PTHREAD_LOCKS;
+ return TRUE;
+
+ case DLL_PROCESS_DETACH:
+ return TRUE;
+
+ default:
+ return FALSE;
+ }
+}
+
+#ifdef AFS_NT40_ENV
+int rx_DumpCalls(FILE *outputFile, char *cookie)
+{
+#ifdef RXDEBUG_PACKET
+ int zilch;
+#ifdef KDUMP_RX_LOCK
+ struct rx_call_rx_lock *c;
+#else
+ struct rx_call *c;
+#endif
+ char output[2048];
+
+ sprintf(output, "%s - Start dumping all Rx Calls - count=%u\r\n", cookie, rx_stats.nCallStructs);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ for (c = rx_allCallsp; c; c = c->allNextp) {
+ u_short rqc, tqc, iovqc;
+ struct rx_packet *p, *np;
+
+ MUTEX_ENTER(&c->lock);
+ queue_Count(&c->rq, p, np, rx_packet, rqc);
+ queue_Count(&c->tq, p, np, rx_packet, tqc);
+ queue_Count(&c->iovq, p, np, rx_packet, iovqc);
+
+ sprintf(output, "%s - call=0x%p, id=%u, state=%u, mode=%u, conn=%p, epoch=%u, cid=%u, callNum=%u, connFlags=0x%x, flags=0x%x, "
+ "rqc=%u,%u, tqc=%u,%u, iovqc=%u,%u, "
+ "lstatus=%u, rstatus=%u, error=%d, timeout=%u, "
+ "resendEvent=%d, timeoutEvt=%d, keepAliveEvt=%d, delayedAckEvt=%d, delayedAbortEvt=%d, abortCode=%d, abortCount=%d, "
+ "lastSendTime=%u, lastRecvTime=%u, lastSendData=%u"
+#ifdef RX_ENABLE_LOCKS
+ ", refCount=%u"
+#endif
+#ifdef RX_REFCOUNT_CHECK
+ ", refCountBegin=%u, refCountResend=%u, refCountDelay=%u, "
+ "refCountAlive=%u, refCountPacket=%u, refCountSend=%u, refCountAckAll=%u, refCountAbort=%u"
+#endif
+ "\r\n",
+ cookie, c, c->call_id, (afs_uint32)c->state, (afs_uint32)c->mode, c->conn, c->conn?c->conn->epoch:0, c->conn?c->conn->cid:0,
+ c->callNumber?*c->callNumber:0, c->conn?c->conn->flags:0, c->flags,
+ (afs_uint32)c->rqc, (afs_uint32)rqc, (afs_uint32)c->tqc, (afs_uint32)tqc, (afs_uint32)c->iovqc, (afs_uint32)iovqc,
+ (afs_uint32)c->localStatus, (afs_uint32)c->remoteStatus, c->error, c->timeout,
+ c->resendEvent?1:0, c->timeoutEvent?1:0, c->keepAliveEvent?1:0, c->delayedAckEvent?1:0, c->delayedAbortEvent?1:0,
+ c->abortCode, c->abortCount, c->lastSendTime, c->lastReceiveTime, c->lastSendData
+#ifdef RX_ENABLE_LOCKS
+ , (afs_uint32)c->refCount
+#endif
+#ifdef RX_REFCOUNT_CHECK
+ , c->refCDebug[0],c->refCDebug[1],c->refCDebug[2],c->refCDebug[3],c->refCDebug[4],c->refCDebug[5],c->refCDebug[6],c->refCDebug[7]
+#endif
+ );
+ MUTEX_EXIT(&c->lock);
+
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+ sprintf(output, "%s - End dumping all Rx Calls\r\n", cookie);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+#endif /* RXDEBUG_PACKET */
+ return 0;
+}
+#endif /* AFS_NT40_ENV */
+#endif
+
git://git.openafs.org / openafs.git / blobdiff