src/rx/rx.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /* RX:  Extended Remote Procedure Call */
  11
  12 #include <afsconfig.h>
  13 #ifdef  KERNEL
  14 #include "afs/param.h"
  15 #else
  16 #include <afs/param.h>
  17 #endif
  18
  19 RCSID
  20     ("$Header$");
  21
  22 #ifdef KERNEL
  23 #include "afs/sysincludes.h"
  24 #include "afsincludes.h"
  25 #ifndef UKERNEL
  26 #include "h/types.h"
  27 #include "h/time.h"
  28 #include "h/stat.h"
  29 #ifdef  AFS_OSF_ENV
  30 #include <net/net_globals.h>
  31 #endif /* AFS_OSF_ENV */
  32 #ifdef AFS_LINUX20_ENV
  33 #include "h/socket.h"
  34 #endif
  35 #include "netinet/in.h"
  36 #include "afs/afs_args.h"
  37 #include "afs/afs_osi.h"
  38 #ifdef RX_KERNEL_TRACE
  39 #include "rx_kcommon.h"
  40 #endif
  41 #if     (defined(AFS_AUX_ENV) || defined(AFS_AIX_ENV))
  42 #include "h/systm.h"
  43 #endif
  44 #ifdef RXDEBUG
  45 #undef RXDEBUG                  /* turn off debugging */
  46 #endif /* RXDEBUG */
  47 #if defined(AFS_SGI_ENV)
  48 #include "sys/debug.h"
  49 #endif
  50 #include "afsint.h"
  51 #ifdef  AFS_ALPHA_ENV
  52 #undef kmem_alloc
  53 #undef kmem_free
  54 #undef mem_alloc
  55 #undef mem_free
  56 #undef register
  57 #endif /* AFS_ALPHA_ENV */
  58 #else /* !UKERNEL */
  59 #include "afs/sysincludes.h"
  60 #include "afsincludes.h"
  61 #endif /* !UKERNEL */
  62 #include "afs/lock.h"
  63 #include "rx_kmutex.h"
  64 #include "rx_kernel.h"
  65 #include "rx_clock.h"
  66 #include "rx_queue.h"
  67 #include "rx.h"
  68 #include "rx_globals.h"
  69 #include "rx_trace.h"
  70 #define AFSOP_STOP_RXCALLBACK   210     /* Stop CALLBACK process */
  71 #define AFSOP_STOP_AFS          211     /* Stop AFS process */
  72 #define AFSOP_STOP_BKG          212     /* Stop BKG process */
  73 #include "afsint.h"
  74 extern afs_int32 afs_termState;
  75 #ifdef AFS_AIX41_ENV
  76 #include "sys/lockl.h"
  77 #include "sys/lock_def.h"
  78 #endif /* AFS_AIX41_ENV */
  79 # include "rxgen_consts.h"
  80 #else /* KERNEL */
  81 # include <sys/types.h>
  82 # include <errno.h>
  83 #ifdef AFS_NT40_ENV
  84 # include <stdlib.h>
  85 # include <fcntl.h>
  86 # include <afs/afsutil.h>
  87 #else
  88 # include <sys/socket.h>
  89 # include <sys/file.h>
  90 # include <netdb.h>
  91 # include <sys/stat.h>
  92 # include <netinet/in.h>
  93 # include <sys/time.h>
  94 #endif
  95 #ifdef HAVE_STRING_H
  96 #include <string.h>
  97 #else
  98 #ifdef HAVE_STRINGS_H
  99 #include <strings.h>
 100 #endif
 101 #endif
 102 # include "rx.h"
 103 # include "rx_user.h"
 104 # include "rx_clock.h"
 105 # include "rx_queue.h"
 106 # include "rx_globals.h"
 107 # include "rx_trace.h"
 108 # include <afs/rxgen_consts.h>
 109 #endif /* KERNEL */
 110
 111 int (*registerProgram) () = 0;
 112 int (*swapNameProgram) () = 0;
 113
 114 /* Local static routines */
 115 static void rxi_DestroyConnectionNoLock(register struct rx_connection *conn);
 116 #ifdef RX_ENABLE_LOCKS
 117 static void rxi_SetAcksInTransmitQueue(register struct rx_call *call);
 118 #endif
 119
 120 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
 121 struct rx_tq_debug {
 122     afs_int32 rxi_start_aborted;        /* rxi_start awoke after rxi_Send in error. */
 123     afs_int32 rxi_start_in_error;
 124 } rx_tq_debug;
 125 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
 126
 127 /*
 128  * rxi_rpc_peer_stat_cnt counts the total number of peer stat structures
 129  * currently allocated within rx.  This number is used to allocate the
 130  * memory required to return the statistics when queried.
 131  */
 132
 133 static unsigned int rxi_rpc_peer_stat_cnt;
 134
 135 /*
 136  * rxi_rpc_process_stat_cnt counts the total number of local process stat
 137  * structures currently allocated within rx.  The number is used to allocate
 138  * the memory required to return the statistics when queried.
 139  */
 140
 141 static unsigned int rxi_rpc_process_stat_cnt;
 142
 143 #if !defined(offsetof)
 144 #include <stddef.h>             /* for definition of offsetof() */
 145 #endif
 146
 147 #ifdef AFS_PTHREAD_ENV
 148 #include <assert.h>
 149
 150 /*
 151  * Use procedural initialization of mutexes/condition variables
 152  * to ease NT porting
 153  */
 154
 155 extern pthread_mutex_t rx_stats_mutex;
 156 extern pthread_mutex_t rxkad_stats_mutex;
 157 extern pthread_mutex_t des_init_mutex;
 158 extern pthread_mutex_t des_random_mutex;
 159 extern pthread_mutex_t rx_clock_mutex;
 160 extern pthread_mutex_t rxi_connCacheMutex;
 161 extern pthread_mutex_t rx_event_mutex;
 162 extern pthread_mutex_t osi_malloc_mutex;
 163 extern pthread_mutex_t event_handler_mutex;
 164 extern pthread_mutex_t listener_mutex;
 165 extern pthread_mutex_t rx_if_init_mutex;
 166 extern pthread_mutex_t rx_if_mutex;
 167 extern pthread_mutex_t rxkad_client_uid_mutex;
 168 extern pthread_mutex_t rxkad_random_mutex;
 169
 170 extern pthread_cond_t rx_event_handler_cond;
 171 extern pthread_cond_t rx_listener_cond;
 172
 173 static pthread_mutex_t epoch_mutex;
 174 static pthread_mutex_t rx_init_mutex;
 175 static pthread_mutex_t rx_debug_mutex;
 176
 177 static void
 178 rxi_InitPthread(void)
 179 {
 180     assert(pthread_mutex_init(&rx_clock_mutex, (const pthread_mutexattr_t *)0)
 181            == 0);
 182     assert(pthread_mutex_init(&rx_stats_mutex, (const pthread_mutexattr_t *)0)
 183            == 0);
 184     assert(pthread_mutex_init
 185            (&rxi_connCacheMutex, (const pthread_mutexattr_t *)0) == 0);
 186     assert(pthread_mutex_init(&rx_init_mutex, (const pthread_mutexattr_t *)0)
 187            == 0);
 188     assert(pthread_mutex_init(&epoch_mutex, (const pthread_mutexattr_t *)0) ==
 189            0);
 190     assert(pthread_mutex_init(&rx_event_mutex, (const pthread_mutexattr_t *)0)
 191            == 0);
 192     assert(pthread_mutex_init(&des_init_mutex, (const pthread_mutexattr_t *)0)
 193            == 0);
 194     assert(pthread_mutex_init
 195            (&des_random_mutex, (const pthread_mutexattr_t *)0) == 0);
 196     assert(pthread_mutex_init
 197            (&osi_malloc_mutex, (const pthread_mutexattr_t *)0) == 0);
 198     assert(pthread_mutex_init
 199            (&event_handler_mutex, (const pthread_mutexattr_t *)0) == 0);
 200     assert(pthread_mutex_init(&listener_mutex, (const pthread_mutexattr_t *)0)
 201            == 0);
 202     assert(pthread_mutex_init
 203            (&rx_if_init_mutex, (const pthread_mutexattr_t *)0) == 0);
 204     assert(pthread_mutex_init(&rx_if_mutex, (const pthread_mutexattr_t *)0) ==
 205            0);
 206     assert(pthread_mutex_init
 207            (&rxkad_client_uid_mutex, (const pthread_mutexattr_t *)0) == 0);
 208     assert(pthread_mutex_init
 209            (&rxkad_random_mutex, (const pthread_mutexattr_t *)0) == 0);
 210     assert(pthread_mutex_init
 211            (&rxkad_stats_mutex, (const pthread_mutexattr_t *)0) == 0);
 212     assert(pthread_mutex_init(&rx_debug_mutex, (const pthread_mutexattr_t *)0)
 213            == 0);
 214
 215     assert(pthread_cond_init
 216            (&rx_event_handler_cond, (const pthread_condattr_t *)0) == 0);
 217     assert(pthread_cond_init(&rx_listener_cond, (const pthread_condattr_t *)0)
 218            == 0);
 219     assert(pthread_key_create(&rx_thread_id_key, NULL) == 0);
 220 }
 221
 222 pthread_once_t rx_once_init = PTHREAD_ONCE_INIT;
 223 #define INIT_PTHREAD_LOCKS \
 224 assert(pthread_once(&rx_once_init, rxi_InitPthread)==0)
 225 /*
 226  * The rx_stats_mutex mutex protects the following global variables:
 227  * rxi_dataQuota
 228  * rxi_minDeficit
 229  * rxi_availProcs
 230  * rxi_totalMin
 231  * rxi_lowConnRefCount
 232  * rxi_lowPeerRefCount
 233  * rxi_nCalls
 234  * rxi_Alloccnt
 235  * rxi_Allocsize
 236  * rx_nFreePackets
 237  * rx_tq_debug
 238  * rx_stats
 239  */
 240 #else
 241 #define INIT_PTHREAD_LOCKS
 242 #endif
 243
 244
 245 /* Variables for handling the minProcs implementation.  availProcs gives the
 246  * number of threads available in the pool at this moment (not counting dudes
 247  * executing right now).  totalMin gives the total number of procs required
 248  * for handling all minProcs requests.  minDeficit is a dynamic variable
 249  * tracking the # of procs required to satisfy all of the remaining minProcs
 250  * demands.
 251  * For fine grain locking to work, the quota check and the reservation of
 252  * a server thread has to come while rxi_availProcs and rxi_minDeficit
 253  * are locked. To this end, the code has been modified under #ifdef
 254  * RX_ENABLE_LOCKS so that quota checks and reservation occur at the
 255  * same time. A new function, ReturnToServerPool() returns the allocation.
 256  *
 257  * A call can be on several queue's (but only one at a time). When
 258  * rxi_ResetCall wants to remove the call from a queue, it has to ensure
 259  * that no one else is touching the queue. To this end, we store the address
 260  * of the queue lock in the call structure (under the call lock) when we
 261  * put the call on a queue, and we clear the call_queue_lock when the
 262  * call is removed from a queue (once the call lock has been obtained).
 263  * This allows rxi_ResetCall to safely synchronize with others wishing
 264  * to manipulate the queue.
 265  */
 266
 267 #ifdef RX_ENABLE_LOCKS
 268 static afs_kmutex_t rx_rpc_stats;
 269 void rxi_StartUnlocked();
 270 #endif
 271
 272 /* We keep a "last conn pointer" in rxi_FindConnection. The odds are
 273 ** pretty good that the next packet coming in is from the same connection
 274 ** as the last packet, since we're send multiple packets in a transmit window.
 275 */
 276 struct rx_connection *rxLastConn = 0;
 277
 278 #ifdef RX_ENABLE_LOCKS
 279 /* The locking hierarchy for rx fine grain locking is composed of these
 280  * tiers:
 281  *
 282  * rx_connHashTable_lock - synchronizes conn creation, rx_connHashTable access
 283  * conn_call_lock - used to synchonize rx_EndCall and rx_NewCall
 284  * call->lock - locks call data fields.
 285  * These are independent of each other:
 286  *      rx_freeCallQueue_lock
 287  *      rxi_keyCreate_lock
 288  * rx_serverPool_lock
 289  * freeSQEList_lock
 290  *
 291  * serverQueueEntry->lock
 292  * rx_rpc_stats
 293  * rx_peerHashTable_lock - locked under rx_connHashTable_lock
 294  * peer->lock - locks peer data fields.
 295  * conn_data_lock - that more than one thread is not updating a conn data
 296  *                  field at the same time.
 297  * rx_freePktQ_lock
 298  *
 299  * lowest level:
 300  *      multi_handle->lock
 301  *      rxevent_lock
 302  *      rx_stats_mutex
 303  *
 304  * Do we need a lock to protect the peer field in the conn structure?
 305  *      conn->peer was previously a constant for all intents and so has no
 306  *      lock protecting this field. The multihomed client delta introduced
 307  *      a RX code change : change the peer field in the connection structure
 308  *      to that remote inetrface from which the last packet for this
 309  *      connection was sent out. This may become an issue if further changes
 310  *      are made.
 311  */
 312 #define SET_CALL_QUEUE_LOCK(C, L) (C)->call_queue_lock = (L)
 313 #define CLEAR_CALL_QUEUE_LOCK(C) (C)->call_queue_lock = NULL
 314 #ifdef RX_LOCKS_DB
 315 /* rxdb_fileID is used to identify the lock location, along with line#. */
 316 static int rxdb_fileID = RXDB_FILE_RX;
 317 #endif /* RX_LOCKS_DB */
 318 #else /* RX_ENABLE_LOCKS */
 319 #define SET_CALL_QUEUE_LOCK(C, L)
 320 #define CLEAR_CALL_QUEUE_LOCK(C)
 321 #endif /* RX_ENABLE_LOCKS */
 322 struct rx_serverQueueEntry *rx_waitForPacket = 0;
 323 struct rx_serverQueueEntry *rx_waitingForPacket = 0;
 324
 325 /* ------------Exported Interfaces------------- */
 326
 327 /* This function allows rxkad to set the epoch to a suitably random number
 328  * which rx_NewConnection will use in the future.  The principle purpose is to
 329  * get rxnull connections to use the same epoch as the rxkad connections do, at
 330  * least once the first rxkad connection is established.  This is important now
 331  * that the host/port addresses aren't used in FindConnection: the uniqueness
 332  * of epoch/cid matters and the start time won't do. */
 333
 334 #ifdef AFS_PTHREAD_ENV
 335 /*
 336  * This mutex protects the following global variables:
 337  * rx_epoch
 338  */
 339
 340 #define LOCK_EPOCH assert(pthread_mutex_lock(&epoch_mutex)==0)
 341 #define UNLOCK_EPOCH assert(pthread_mutex_unlock(&epoch_mutex)==0)
 342 #else
 343 #define LOCK_EPOCH
 344 #define UNLOCK_EPOCH
 345 #endif /* AFS_PTHREAD_ENV */
 346
 347 void
 348 rx_SetEpoch(afs_uint32 epoch)
 349 {
 350     LOCK_EPOCH;
 351     rx_epoch = epoch;
 352     UNLOCK_EPOCH;
 353 }
 354
 355 /* Initialize rx.  A port number may be mentioned, in which case this
 356  * becomes the default port number for any service installed later.
 357  * If 0 is provided for the port number, a random port will be chosen
 358  * by the kernel.  Whether this will ever overlap anything in
 359  * /etc/services is anybody's guess...  Returns 0 on success, -1 on
 360  * error. */
 361 static int rxinit_status = 1;
 362 #ifdef AFS_PTHREAD_ENV
 363 /*
 364  * This mutex protects the following global variables:
 365  * rxinit_status
 366  */
 367
 368 #define LOCK_RX_INIT assert(pthread_mutex_lock(&rx_init_mutex)==0)
 369 #define UNLOCK_RX_INIT assert(pthread_mutex_unlock(&rx_init_mutex)==0)
 370 #else
 371 #define LOCK_RX_INIT
 372 #define UNLOCK_RX_INIT
 373 #endif
 374
 375 int
 376 rx_InitHost(u_int host, u_int port)
 377 {
 378 #ifdef KERNEL
 379     osi_timeval_t tv;
 380 #else /* KERNEL */
 381     struct timeval tv;
 382 #endif /* KERNEL */
 383     char *htable, *ptable;
 384     int tmp_status;
 385
 386 #if defined(AFS_DJGPP_ENV) && !defined(DEBUG)
 387     __djgpp_set_quiet_socket(1);
 388 #endif
 389
 390     SPLVAR;
 391
 392     INIT_PTHREAD_LOCKS;
 393     LOCK_RX_INIT;
 394     if (rxinit_status == 0) {
 395         tmp_status = rxinit_status;
 396         UNLOCK_RX_INIT;
 397         return tmp_status;      /* Already started; return previous error code. */
 398     }
 399 #ifdef AFS_NT40_ENV
 400     if (afs_winsockInit() < 0)
 401         return -1;
 402 #endif
 403
 404 #ifndef KERNEL
 405     /*
 406      * Initialize anything necessary to provide a non-premptive threading
 407      * environment.
 408      */
 409     rxi_InitializeThreadSupport();
 410 #endif
 411
 412     /* Allocate and initialize a socket for client and perhaps server
 413      * connections. */
 414
 415     rx_socket = rxi_GetHostUDPSocket(host, (u_short) port);
 416     if (rx_socket == OSI_NULLSOCKET) {
 417         UNLOCK_RX_INIT;
 418         return RX_ADDRINUSE;
 419     }
 420 #ifdef  RX_ENABLE_LOCKS
 421 #ifdef RX_LOCKS_DB
 422     rxdb_init();
 423 #endif /* RX_LOCKS_DB */
 424     MUTEX_INIT(&rx_stats_mutex, "rx_stats_mutex", MUTEX_DEFAULT, 0);
 425     MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
 426     MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
 427     MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
 428     MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock", MUTEX_DEFAULT,
 429                0);
 430     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
 431             0);
 432     MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
 433                0);
 434     MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
 435                0);
 436     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
 437 #ifndef KERNEL
 438     MUTEX_INIT(&rxi_keyCreate_lock, "rxi_keyCreate_lock", MUTEX_DEFAULT, 0);
 439 #endif /* !KERNEL */
 440 #if defined(KERNEL) && defined(AFS_HPUX110_ENV)
 441     if (!uniprocessor)
 442         rx_sleepLock = alloc_spinlock(LAST_HELD_ORDER - 10, "rx_sleepLock");
 443 #endif /* KERNEL && AFS_HPUX110_ENV */
 444 #else /* RX_ENABLE_LOCKS */
 445 #if defined(KERNEL) && defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_OBSD_ENV)
 446     mutex_init(&afs_rxglobal_lock, "afs_rxglobal_lock", MUTEX_DEFAULT, NULL);
 447 #endif /* AFS_GLOBAL_SUNLOCK */
 448 #endif /* RX_ENABLE_LOCKS */
 449
 450     rxi_nCalls = 0;
 451     rx_connDeadTime = 12;
 452     rx_tranquil = 0;            /* reset flag */
 453     memset((char *)&rx_stats, 0, sizeof(struct rx_stats));
 454     htable = (char *)
 455         osi_Alloc(rx_hashTableSize * sizeof(struct rx_connection *));
 456     PIN(htable, rx_hashTableSize * sizeof(struct rx_connection *));     /* XXXXX */
 457     memset(htable, 0, rx_hashTableSize * sizeof(struct rx_connection *));
 458     ptable = (char *)osi_Alloc(rx_hashTableSize * sizeof(struct rx_peer *));
 459     PIN(ptable, rx_hashTableSize * sizeof(struct rx_peer *));   /* XXXXX */
 460     memset(ptable, 0, rx_hashTableSize * sizeof(struct rx_peer *));
 461
 462     /* Malloc up a bunch of packets & buffers */
 463     rx_nFreePackets = 0;
 464     rx_nPackets = rx_extraPackets + RX_MAX_QUOTA + 2;   /* fudge */
 465     queue_Init(&rx_freePacketQueue);
 466     rxi_NeedMorePackets = FALSE;
 467     rxi_MorePackets(rx_nPackets);
 468     rx_CheckPackets();
 469
 470     NETPRI;
 471     AFS_RXGLOCK();
 472
 473     clock_Init();
 474
 475 #if defined(AFS_NT40_ENV) && !defined(AFS_PTHREAD_ENV)
 476     tv.tv_sec = clock_now.sec;
 477     tv.tv_usec = clock_now.usec;
 478     srand((unsigned int)tv.tv_usec);
 479 #else
 480     osi_GetTime(&tv);
 481 #endif
 482     if (port) {
 483         rx_port = port;
 484     } else {
 485 #if defined(KERNEL) && !defined(UKERNEL)
 486         /* Really, this should never happen in a real kernel */
 487         rx_port = 0;
 488 #else
 489         struct sockaddr_in addr;
 490         int addrlen = sizeof(addr);
 491         if (getsockname((int)rx_socket, (struct sockaddr *)&addr, &addrlen)) {
 492             rx_Finalize();
 493             return -1;
 494         }
 495         rx_port = addr.sin_port;
 496 #endif
 497     }
 498     rx_stats.minRtt.sec = 9999999;
 499 #ifdef  KERNEL
 500     rx_SetEpoch(tv.tv_sec | 0x80000000);
 501 #else
 502     rx_SetEpoch(tv.tv_sec);     /* Start time of this package, rxkad
 503                                  * will provide a randomer value. */
 504 #endif
 505     MUTEX_ENTER(&rx_stats_mutex);
 506     rxi_dataQuota += rx_extraQuota;     /* + extra pkts caller asked to rsrv */
 507     MUTEX_EXIT(&rx_stats_mutex);
 508     /* *Slightly* random start time for the cid.  This is just to help
 509      * out with the hashing function at the peer */
 510     rx_nextCid = ((tv.tv_sec ^ tv.tv_usec) << RX_CIDSHIFT);
 511     rx_connHashTable = (struct rx_connection **)htable;
 512     rx_peerHashTable = (struct rx_peer **)ptable;
 513
 514     rx_lastAckDelay.sec = 0;
 515     rx_lastAckDelay.usec = 400000;      /* 400 milliseconds */
 516     rx_hardAckDelay.sec = 0;
 517     rx_hardAckDelay.usec = 100000;      /* 100 milliseconds */
 518     rx_softAckDelay.sec = 0;
 519     rx_softAckDelay.usec = 100000;      /* 100 milliseconds */
 520
 521     rxevent_Init(20, rxi_ReScheduleEvents);
 522
 523     /* Initialize various global queues */
 524     queue_Init(&rx_idleServerQueue);
 525     queue_Init(&rx_incomingCallQueue);
 526     queue_Init(&rx_freeCallQueue);
 527
 528 #if defined(AFS_NT40_ENV) && !defined(KERNEL)
 529     /* Initialize our list of usable IP addresses. */
 530     rx_GetIFInfo();
 531 #endif
 532
 533     /* Start listener process (exact function is dependent on the
 534      * implementation environment--kernel or user space) */
 535     rxi_StartListener();
 536
 537     AFS_RXGUNLOCK();
 538     USERPRI;
 539     tmp_status = rxinit_status = 0;
 540     UNLOCK_RX_INIT;
 541     return tmp_status;
 542 }
 543
 544 int
 545 rx_Init(u_int port)
 546 {
 547     return rx_InitHost(htonl(INADDR_ANY), port);
 548 }
 549
 550 /* called with unincremented nRequestsRunning to see if it is OK to start
 551  * a new thread in this service.  Could be "no" for two reasons: over the
 552  * max quota, or would prevent others from reaching their min quota.
 553  */
 554 #ifdef RX_ENABLE_LOCKS
 555 /* This verion of QuotaOK reserves quota if it's ok while the
 556  * rx_serverPool_lock is held.  Return quota using ReturnToServerPool().
 557  */
 558 static int
 559 QuotaOK(register struct rx_service *aservice)
 560 {
 561     /* check if over max quota */
 562     if (aservice->nRequestsRunning >= aservice->maxProcs) {
 563         return 0;
 564     }
 565
 566     /* under min quota, we're OK */
 567     /* otherwise, can use only if there are enough to allow everyone
 568      * to go to their min quota after this guy starts.
 569      */
 570     MUTEX_ENTER(&rx_stats_mutex);
 571     if ((aservice->nRequestsRunning < aservice->minProcs)
 572         || (rxi_availProcs > rxi_minDeficit)) {
 573         aservice->nRequestsRunning++;
 574         /* just started call in minProcs pool, need fewer to maintain
 575          * guarantee */
 576         if (aservice->nRequestsRunning <= aservice->minProcs)
 577             rxi_minDeficit--;
 578         rxi_availProcs--;
 579         MUTEX_EXIT(&rx_stats_mutex);
 580         return 1;
 581     }
 582     MUTEX_EXIT(&rx_stats_mutex);
 583
 584     return 0;
 585 }
 586
 587 static void
 588 ReturnToServerPool(register struct rx_service *aservice)
 589 {
 590     aservice->nRequestsRunning--;
 591     MUTEX_ENTER(&rx_stats_mutex);
 592     if (aservice->nRequestsRunning < aservice->minProcs)
 593         rxi_minDeficit++;
 594     rxi_availProcs++;
 595     MUTEX_EXIT(&rx_stats_mutex);
 596 }
 597
 598 #else /* RX_ENABLE_LOCKS */
 599 static int
 600 QuotaOK(register struct rx_service *aservice)
 601 {
 602     int rc = 0;
 603     /* under min quota, we're OK */
 604     if (aservice->nRequestsRunning < aservice->minProcs)
 605         return 1;
 606
 607     /* check if over max quota */
 608     if (aservice->nRequestsRunning >= aservice->maxProcs)
 609         return 0;
 610
 611     /* otherwise, can use only if there are enough to allow everyone
 612      * to go to their min quota after this guy starts.
 613      */
 614     if (rxi_availProcs > rxi_minDeficit)
 615         rc = 1;
 616     return rc;
 617 }
 618 #endif /* RX_ENABLE_LOCKS */
 619
 620 #ifndef KERNEL
 621 /* Called by rx_StartServer to start up lwp's to service calls.
 622    NExistingProcs gives the number of procs already existing, and which
 623    therefore needn't be created. */
 624 void
 625 rxi_StartServerProcs(int nExistingProcs)
 626 {
 627     register struct rx_service *service;
 628     register int i;
 629     int maxdiff = 0;
 630     int nProcs = 0;
 631
 632     /* For each service, reserve N processes, where N is the "minimum"
 633      * number of processes that MUST be able to execute a request in parallel,
 634      * at any time, for that process.  Also compute the maximum difference
 635      * between any service's maximum number of processes that can run
 636      * (i.e. the maximum number that ever will be run, and a guarantee
 637      * that this number will run if other services aren't running), and its
 638      * minimum number.  The result is the extra number of processes that
 639      * we need in order to provide the latter guarantee */
 640     for (i = 0; i < RX_MAX_SERVICES; i++) {
 641         int diff;
 642         service = rx_services[i];
 643         if (service == (struct rx_service *)0)
 644             break;
 645         nProcs += service->minProcs;
 646         diff = service->maxProcs - service->minProcs;
 647         if (diff > maxdiff)
 648             maxdiff = diff;
 649     }
 650     nProcs += maxdiff;          /* Extra processes needed to allow max number requested to run in any given service, under good conditions */
 651     nProcs -= nExistingProcs;   /* Subtract the number of procs that were previously created for use as server procs */
 652     for (i = 0; i < nProcs; i++) {
 653         rxi_StartServerProc(rx_ServerProc, rx_stackSize);
 654     }
 655 }
 656 #endif /* KERNEL */
 657
 658 /* This routine must be called if any services are exported.  If the
 659  * donateMe flag is set, the calling process is donated to the server
 660  * process pool */
 661 void
 662 rx_StartServer(int donateMe)
 663 {
 664     register struct rx_service *service;
 665     register int i;
 666     SPLVAR;
 667     clock_NewTime();
 668
 669     NETPRI;
 670     AFS_RXGLOCK();
 671     /* Start server processes, if necessary (exact function is dependent
 672      * on the implementation environment--kernel or user space).  DonateMe
 673      * will be 1 if there is 1 pre-existing proc, i.e. this one.  In this
 674      * case, one less new proc will be created rx_StartServerProcs.
 675      */
 676     rxi_StartServerProcs(donateMe);
 677
 678     /* count up the # of threads in minProcs, and add set the min deficit to
 679      * be that value, too.
 680      */
 681     for (i = 0; i < RX_MAX_SERVICES; i++) {
 682         service = rx_services[i];
 683         if (service == (struct rx_service *)0)
 684             break;
 685         MUTEX_ENTER(&rx_stats_mutex);
 686         rxi_totalMin += service->minProcs;
 687         /* below works even if a thread is running, since minDeficit would
 688          * still have been decremented and later re-incremented.
 689          */
 690         rxi_minDeficit += service->minProcs;
 691         MUTEX_EXIT(&rx_stats_mutex);
 692     }
 693
 694     /* Turn on reaping of idle server connections */
 695     rxi_ReapConnections();
 696
 697     AFS_RXGUNLOCK();
 698     USERPRI;
 699
 700     if (donateMe) {
 701 #ifndef AFS_NT40_ENV
 702 #ifndef KERNEL
 703         char name[32];
 704         static int nProcs;
 705 #ifdef AFS_PTHREAD_ENV
 706         pid_t pid;
 707         pid = (pid_t) pthread_self();
 708 #else /* AFS_PTHREAD_ENV */
 709         PROCESS pid;
 710         LWP_CurrentProcess(&pid);
 711 #endif /* AFS_PTHREAD_ENV */
 712
 713         sprintf(name, "srv_%d", ++nProcs);
 714         if (registerProgram)
 715             (*registerProgram) (pid, name);
 716 #endif /* KERNEL */
 717 #endif /* AFS_NT40_ENV */
 718         rx_ServerProc();        /* Never returns */
 719     }
 720     return;
 721 }
 722
 723 /* Create a new client connection to the specified service, using the
 724  * specified security object to implement the security model for this
 725  * connection. */
 726 struct rx_connection *
 727 rx_NewConnection(register afs_uint32 shost, u_short sport, u_short sservice,
 728                  register struct rx_securityClass *securityObject,
 729                  int serviceSecurityIndex)
 730 {
 731     int hashindex;
 732     afs_int32 cid;
 733     register struct rx_connection *conn;
 734
 735     SPLVAR;
 736
 737     clock_NewTime();
 738     dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", shost, sport, sservice, securityObject, serviceSecurityIndex));
 739
 740     /* Vasilsi said: "NETPRI protects Cid and Alloc", but can this be true in
 741      * the case of kmem_alloc? */
 742     conn = rxi_AllocConnection();
 743 #ifdef  RX_ENABLE_LOCKS
 744     MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
 745     MUTEX_INIT(&conn->conn_data_lock, "conn call lock", MUTEX_DEFAULT, 0);
 746     CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
 747 #endif
 748     NETPRI;
 749     AFS_RXGLOCK();
 750     MUTEX_ENTER(&rx_connHashTable_lock);
 751     cid = (rx_nextCid += RX_MAXCALLS);
 752     conn->type = RX_CLIENT_CONNECTION;
 753     conn->cid = cid;
 754     conn->epoch = rx_epoch;
 755     conn->peer = rxi_FindPeer(shost, sport, 0, 1);
 756     conn->serviceId = sservice;
 757     conn->securityObject = securityObject;
 758     /* This doesn't work in all compilers with void (they're buggy), so fake it
 759      * with VOID */
 760     conn->securityData = (VOID *) 0;
 761     conn->securityIndex = serviceSecurityIndex;
 762     rx_SetConnDeadTime(conn, rx_connDeadTime);
 763     conn->ackRate = RX_FAST_ACK_RATE;
 764     conn->nSpecific = 0;
 765     conn->specific = NULL;
 766     conn->challengeEvent = NULL;
 767     conn->delayedAbortEvent = NULL;
 768     conn->abortCount = 0;
 769     conn->error = 0;
 770
 771     RXS_NewConnection(securityObject, conn);
 772     hashindex =
 773         CONN_HASH(shost, sport, conn->cid, conn->epoch, RX_CLIENT_CONNECTION);
 774
 775     conn->refCount++;           /* no lock required since only this thread knows... */
 776     conn->next = rx_connHashTable[hashindex];
 777     rx_connHashTable[hashindex] = conn;
 778     MUTEX_ENTER(&rx_stats_mutex);
 779     rx_stats.nClientConns++;
 780     MUTEX_EXIT(&rx_stats_mutex);
 781
 782     MUTEX_EXIT(&rx_connHashTable_lock);
 783     AFS_RXGUNLOCK();
 784     USERPRI;
 785     return conn;
 786 }
 787
 788 void
 789 rx_SetConnDeadTime(register struct rx_connection *conn, register int seconds)
 790 {
 791     /* The idea is to set the dead time to a value that allows several
 792      * keepalives to be dropped without timing out the connection. */
 793     conn->secondsUntilDead = MAX(seconds, 6);
 794     conn->secondsUntilPing = conn->secondsUntilDead / 6;
 795 }
 796
 797 int rxi_lowPeerRefCount = 0;
 798 int rxi_lowConnRefCount = 0;
 799
 800 /*
 801  * Cleanup a connection that was destroyed in rxi_DestroyConnectioNoLock.
 802  * NOTE: must not be called with rx_connHashTable_lock held.
 803  */
 804 void
 805 rxi_CleanupConnection(struct rx_connection *conn)
 806 {
 807     /* Notify the service exporter, if requested, that this connection
 808      * is being destroyed */
 809     if (conn->type == RX_SERVER_CONNECTION && conn->service->destroyConnProc)
 810         (*conn->service->destroyConnProc) (conn);
 811
 812     /* Notify the security module that this connection is being destroyed */
 813     RXS_DestroyConnection(conn->securityObject, conn);
 814
 815     /* If this is the last connection using the rx_peer struct, set its
 816      * idle time to now. rxi_ReapConnections will reap it if it's still
 817      * idle (refCount == 0) after rx_idlePeerTime (60 seconds) have passed.
 818      */
 819     MUTEX_ENTER(&rx_peerHashTable_lock);
 820     if (conn->peer->refCount < 2) {
 821         conn->peer->idleWhen = clock_Sec();
 822         if (conn->peer->refCount < 1) {
 823             conn->peer->refCount = 1;
 824             MUTEX_ENTER(&rx_stats_mutex);
 825             rxi_lowPeerRefCount++;
 826             MUTEX_EXIT(&rx_stats_mutex);
 827         }
 828     }
 829     conn->peer->refCount--;
 830     MUTEX_EXIT(&rx_peerHashTable_lock);
 831
 832     MUTEX_ENTER(&rx_stats_mutex);
 833     if (conn->type == RX_SERVER_CONNECTION)
 834         rx_stats.nServerConns--;
 835     else
 836         rx_stats.nClientConns--;
 837     MUTEX_EXIT(&rx_stats_mutex);
 838
 839 #ifndef KERNEL
 840     if (conn->specific) {
 841         int i;
 842         for (i = 0; i < conn->nSpecific; i++) {
 843             if (conn->specific[i] && rxi_keyCreate_destructor[i])
 844                 (*rxi_keyCreate_destructor[i]) (conn->specific[i]);
 845             conn->specific[i] = NULL;
 846         }
 847         free(conn->specific);
 848     }
 849     conn->specific = NULL;
 850     conn->nSpecific = 0;
 851 #endif /* !KERNEL */
 852
 853     MUTEX_DESTROY(&conn->conn_call_lock);
 854     MUTEX_DESTROY(&conn->conn_data_lock);
 855     CV_DESTROY(&conn->conn_call_cv);
 856
 857     rxi_FreeConnection(conn);
 858 }
 859
 860 /* Destroy the specified connection */
 861 void
 862 rxi_DestroyConnection(register struct rx_connection *conn)
 863 {
 864     MUTEX_ENTER(&rx_connHashTable_lock);
 865     rxi_DestroyConnectionNoLock(conn);
 866     /* conn should be at the head of the cleanup list */
 867     if (conn == rx_connCleanup_list) {
 868         rx_connCleanup_list = rx_connCleanup_list->next;
 869         MUTEX_EXIT(&rx_connHashTable_lock);
 870         rxi_CleanupConnection(conn);
 871     }
 872 #ifdef RX_ENABLE_LOCKS
 873     else {
 874         MUTEX_EXIT(&rx_connHashTable_lock);
 875     }
 876 #endif /* RX_ENABLE_LOCKS */
 877 }
 878
 879 static void
 880 rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
 881 {
 882     register struct rx_connection **conn_ptr;
 883     register int havecalls = 0;
 884     struct rx_packet *packet;
 885     int i;
 886     SPLVAR;
 887
 888     clock_NewTime();
 889
 890     NETPRI;
 891     MUTEX_ENTER(&conn->conn_data_lock);
 892     if (conn->refCount > 0)
 893         conn->refCount--;
 894     else {
 895         MUTEX_ENTER(&rx_stats_mutex);
 896         rxi_lowConnRefCount++;
 897         MUTEX_EXIT(&rx_stats_mutex);
 898     }
 899
 900     if ((conn->refCount > 0) || (conn->flags & RX_CONN_BUSY)) {
 901         /* Busy; wait till the last guy before proceeding */
 902         MUTEX_EXIT(&conn->conn_data_lock);
 903         USERPRI;
 904         return;
 905     }
 906
 907     /* If the client previously called rx_NewCall, but it is still
 908      * waiting, treat this as a running call, and wait to destroy the
 909      * connection later when the call completes. */
 910     if ((conn->type == RX_CLIENT_CONNECTION)
 911         && (conn->flags & RX_CONN_MAKECALL_WAITING)) {
 912         conn->flags |= RX_CONN_DESTROY_ME;
 913         MUTEX_EXIT(&conn->conn_data_lock);
 914         USERPRI;
 915         return;
 916     }
 917     MUTEX_EXIT(&conn->conn_data_lock);
 918
 919     /* Check for extant references to this connection */
 920     for (i = 0; i < RX_MAXCALLS; i++) {
 921         register struct rx_call *call = conn->call[i];
 922         if (call) {
 923             havecalls = 1;
 924             if (conn->type == RX_CLIENT_CONNECTION) {
 925                 MUTEX_ENTER(&call->lock);
 926                 if (call->delayedAckEvent) {
 927                     /* Push the final acknowledgment out now--there
 928                      * won't be a subsequent call to acknowledge the
 929                      * last reply packets */
 930                     rxevent_Cancel(call->delayedAckEvent, call,
 931                                    RX_CALL_REFCOUNT_DELAY);
 932                     if (call->state == RX_STATE_PRECALL
 933                         || call->state == RX_STATE_ACTIVE) {
 934                         rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
 935                     } else {
 936                         rxi_AckAll(NULL, call, 0);
 937                     }
 938                 }
 939                 MUTEX_EXIT(&call->lock);
 940             }
 941         }
 942     }
 943 #ifdef RX_ENABLE_LOCKS
 944     if (!havecalls) {
 945         if (MUTEX_TRYENTER(&conn->conn_data_lock)) {
 946             MUTEX_EXIT(&conn->conn_data_lock);
 947         } else {
 948             /* Someone is accessing a packet right now. */
 949             havecalls = 1;
 950         }
 951     }
 952 #endif /* RX_ENABLE_LOCKS */
 953
 954     if (havecalls) {
 955         /* Don't destroy the connection if there are any call
 956          * structures still in use */
 957         MUTEX_ENTER(&conn->conn_data_lock);
 958         conn->flags |= RX_CONN_DESTROY_ME;
 959         MUTEX_EXIT(&conn->conn_data_lock);
 960         USERPRI;
 961         return;
 962     }
 963
 964     if (conn->delayedAbortEvent) {
 965         rxevent_Cancel(conn->delayedAbortEvent, (struct rx_call *)0, 0);
 966         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
 967         if (packet) {
 968             MUTEX_ENTER(&conn->conn_data_lock);
 969             rxi_SendConnectionAbort(conn, packet, 0, 1);
 970             MUTEX_EXIT(&conn->conn_data_lock);
 971             rxi_FreePacket(packet);
 972         }
 973     }
 974
 975     /* Remove from connection hash table before proceeding */
 976     conn_ptr =
 977         &rx_connHashTable[CONN_HASH
 978                           (peer->host, peer->port, conn->cid, conn->epoch,
 979                            conn->type)];
 980     for (; *conn_ptr; conn_ptr = &(*conn_ptr)->next) {
 981         if (*conn_ptr == conn) {
 982             *conn_ptr = conn->next;
 983             break;
 984         }
 985     }
 986     /* if the conn that we are destroying was the last connection, then we
 987      * clear rxLastConn as well */
 988     if (rxLastConn == conn)
 989         rxLastConn = 0;
 990
 991     /* Make sure the connection is completely reset before deleting it. */
 992     /* get rid of pending events that could zap us later */
 993     if (conn->challengeEvent)
 994         rxevent_Cancel(conn->challengeEvent, (struct rx_call *)0, 0);
 995     if (conn->checkReachEvent)
 996         rxevent_Cancel(conn->checkReachEvent, (struct rx_call *)0, 0);
 997
 998     /* Add the connection to the list of destroyed connections that
 999      * need to be cleaned up. This is necessary to avoid deadlocks
1000      * in the routines we call to inform others that this connection is
1001      * being destroyed. */
1002     conn->next = rx_connCleanup_list;
1003     rx_connCleanup_list = conn;
1004 }
1005
1006 /* Externally available version */
1007 void
1008 rx_DestroyConnection(register struct rx_connection *conn)
1009 {
1010     SPLVAR;
1011
1012     NETPRI;
1013     AFS_RXGLOCK();
1014     rxi_DestroyConnection(conn);
1015     AFS_RXGUNLOCK();
1016     USERPRI;
1017 }
1018
1019 void
1020 rx_GetConnection(register struct rx_connection *conn)
1021 {
1022     SPLVAR;
1023
1024     NETPRI;
1025     AFS_RXGLOCK();
1026     MUTEX_ENTER(&conn->conn_data_lock);
1027     conn->refCount++;
1028     MUTEX_EXIT(&conn->conn_data_lock);
1029     AFS_RXGUNLOCK();
1030     USERPRI;
1031 }
1032
1033 /* Start a new rx remote procedure call, on the specified connection.
1034  * If wait is set to 1, wait for a free call channel; otherwise return
1035  * 0.  Maxtime gives the maximum number of seconds this call may take,
1036  * after rx_MakeCall returns.  After this time interval, a call to any
1037  * of rx_SendData, rx_ReadData, etc. will fail with RX_CALL_TIMEOUT.
1038  * For fine grain locking, we hold the conn_call_lock in order to
1039  * to ensure that we don't get signalle after we found a call in an active
1040  * state and before we go to sleep.
1041  */
1042 struct rx_call *
1043 rx_NewCall(register struct rx_connection *conn)
1044 {
1045     register int i;
1046     register struct rx_call *call;
1047     struct clock queueTime;
1048     SPLVAR;
1049
1050     clock_NewTime();
1051     dpf(("rx_MakeCall(conn %x)\n", conn));
1052
1053     NETPRI;
1054     clock_GetTime(&queueTime);
1055     AFS_RXGLOCK();
1056     MUTEX_ENTER(&conn->conn_call_lock);
1057
1058     /*
1059      * Check if there are others waiting for a new call.
1060      * If so, let them go first to avoid starving them.
1061      * This is a fairly simple scheme, and might not be
1062      * a complete solution for large numbers of waiters.
1063      */
1064     if (conn->makeCallWaiters) {
1065 #ifdef  RX_ENABLE_LOCKS
1066         CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
1067 #else
1068         osi_rxSleep(conn);
1069 #endif
1070     }
1071
1072     for (;;) {
1073         for (i = 0; i < RX_MAXCALLS; i++) {
1074             call = conn->call[i];
1075             if (call) {
1076                 MUTEX_ENTER(&call->lock);
1077                 if (call->state == RX_STATE_DALLY) {
1078                     rxi_ResetCall(call, 0);
1079                     (*call->callNumber)++;
1080                     break;
1081                 }
1082                 MUTEX_EXIT(&call->lock);
1083             } else {
1084                 call = rxi_NewCall(conn, i);
1085                 break;
1086             }
1087         }
1088         if (i < RX_MAXCALLS) {
1089             break;
1090         }
1091         MUTEX_ENTER(&conn->conn_data_lock);
1092         conn->flags |= RX_CONN_MAKECALL_WAITING;
1093         MUTEX_EXIT(&conn->conn_data_lock);
1094
1095         conn->makeCallWaiters++;
1096 #ifdef  RX_ENABLE_LOCKS
1097         CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
1098 #else
1099         osi_rxSleep(conn);
1100 #endif
1101         conn->makeCallWaiters--;
1102     }
1103     /*
1104      * Wake up anyone else who might be giving us a chance to
1105      * run (see code above that avoids resource starvation).
1106      */
1107 #ifdef  RX_ENABLE_LOCKS
1108     CV_BROADCAST(&conn->conn_call_cv);
1109 #else
1110     osi_rxWakeup(conn);
1111 #endif
1112
1113     CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
1114
1115     /* Client is initially in send mode */
1116     call->state = RX_STATE_ACTIVE;
1117     call->mode = RX_MODE_SENDING;
1118
1119     /* remember start time for call in case we have hard dead time limit */
1120     call->queueTime = queueTime;
1121     clock_GetTime(&call->startTime);
1122     hzero(call->bytesSent);
1123     hzero(call->bytesRcvd);
1124
1125     /* Turn on busy protocol. */
1126     rxi_KeepAliveOn(call);
1127
1128     MUTEX_EXIT(&call->lock);
1129     MUTEX_EXIT(&conn->conn_call_lock);
1130     AFS_RXGUNLOCK();
1131     USERPRI;
1132
1133 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1134     /* Now, if TQ wasn't cleared earlier, do it now. */
1135     AFS_RXGLOCK();
1136     MUTEX_ENTER(&call->lock);
1137     while (call->flags & RX_CALL_TQ_BUSY) {
1138         call->flags |= RX_CALL_TQ_WAIT;
1139 #ifdef RX_ENABLE_LOCKS
1140         CV_WAIT(&call->cv_tq, &call->lock);
1141 #else /* RX_ENABLE_LOCKS */
1142         osi_rxSleep(&call->tq);
1143 #endif /* RX_ENABLE_LOCKS */
1144     }
1145     if (call->flags & RX_CALL_TQ_CLEARME) {
1146         rxi_ClearTransmitQueue(call, 0);
1147         queue_Init(&call->tq);
1148     }
1149     MUTEX_EXIT(&call->lock);
1150     AFS_RXGUNLOCK();
1151 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1152
1153     return call;
1154 }
1155
1156 int
1157 rxi_HasActiveCalls(register struct rx_connection *aconn)
1158 {
1159     register int i;
1160     register struct rx_call *tcall;
1161     SPLVAR;
1162
1163     NETPRI;
1164     for (i = 0; i < RX_MAXCALLS; i++) {
1165         if ((tcall = aconn->call[i])) {
1166             if ((tcall->state == RX_STATE_ACTIVE)
1167                 || (tcall->state == RX_STATE_PRECALL)) {
1168                 USERPRI;
1169                 return 1;
1170             }
1171         }
1172     }
1173     USERPRI;
1174     return 0;
1175 }
1176
1177 int
1178 rxi_GetCallNumberVector(register struct rx_connection *aconn,
1179                         register afs_int32 * aint32s)
1180 {
1181     register int i;
1182     register struct rx_call *tcall;
1183     SPLVAR;
1184
1185     NETPRI;
1186     for (i = 0; i < RX_MAXCALLS; i++) {
1187         if ((tcall = aconn->call[i]) && (tcall->state == RX_STATE_DALLY))
1188             aint32s[i] = aconn->callNumber[i] + 1;
1189         else
1190             aint32s[i] = aconn->callNumber[i];
1191     }
1192     USERPRI;
1193     return 0;
1194 }
1195
1196 int
1197 rxi_SetCallNumberVector(register struct rx_connection *aconn,
1198                         register afs_int32 * aint32s)
1199 {
1200     register int i;
1201     register struct rx_call *tcall;
1202     SPLVAR;
1203
1204     NETPRI;
1205     for (i = 0; i < RX_MAXCALLS; i++) {
1206         if ((tcall = aconn->call[i]) && (tcall->state == RX_STATE_DALLY))
1207             aconn->callNumber[i] = aint32s[i] - 1;
1208         else
1209             aconn->callNumber[i] = aint32s[i];
1210     }
1211     USERPRI;
1212     return 0;
1213 }
1214
1215 /* Advertise a new service.  A service is named locally by a UDP port
1216  * number plus a 16-bit service id.  Returns (struct rx_service *) 0
1217  * on a failure.
1218  *
1219      char *serviceName;  Name for identification purposes (e.g. the
1220                          service name might be used for probing for
1221                          statistics) */
1222 struct rx_service *
1223 rx_NewService(u_short port, u_short serviceId, char *serviceName,
1224               struct rx_securityClass **securityObjects, int nSecurityObjects,
1225               afs_int32(*serviceProc) (struct rx_call * acall))
1226 {
1227     osi_socket socket = OSI_NULLSOCKET;
1228     register struct rx_service *tservice;
1229     register int i;
1230     SPLVAR;
1231
1232     clock_NewTime();
1233
1234     if (serviceId == 0) {
1235         (osi_Msg
1236          "rx_NewService:  service id for service %s is not non-zero.\n",
1237          serviceName);
1238         return 0;
1239     }
1240     if (port == 0) {
1241         if (rx_port == 0) {
1242             (osi_Msg
1243              "rx_NewService: A non-zero port must be specified on this call if a non-zero port was not provided at Rx initialization (service %s).\n",
1244              serviceName);
1245             return 0;
1246         }
1247         port = rx_port;
1248         socket = rx_socket;
1249     }
1250
1251     tservice = rxi_AllocService();
1252     NETPRI;
1253     AFS_RXGLOCK();
1254     for (i = 0; i < RX_MAX_SERVICES; i++) {
1255         register struct rx_service *service = rx_services[i];
1256         if (service) {
1257             if (port == service->servicePort) {
1258                 if (service->serviceId == serviceId) {
1259                     /* The identical service has already been
1260                      * installed; if the caller was intending to
1261                      * change the security classes used by this
1262                      * service, he/she loses. */
1263                     (osi_Msg
1264                      "rx_NewService: tried to install service %s with service id %d, which is already in use for service %s\n",
1265                      serviceName, serviceId, service->serviceName);
1266                     AFS_RXGUNLOCK();
1267                     USERPRI;
1268                     rxi_FreeService(tservice);
1269                     return service;
1270                 }
1271                 /* Different service, same port: re-use the socket
1272                  * which is bound to the same port */
1273                 socket = service->socket;
1274             }
1275         } else {
1276             if (socket == OSI_NULLSOCKET) {
1277                 /* If we don't already have a socket (from another
1278                  * service on same port) get a new one */
1279                 socket = rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
1280                 if (socket == OSI_NULLSOCKET) {
1281                     AFS_RXGUNLOCK();
1282                     USERPRI;
1283                     rxi_FreeService(tservice);
1284                     return 0;
1285                 }
1286             }
1287             service = tservice;
1288             service->socket = socket;
1289             service->servicePort = port;
1290             service->serviceId = serviceId;
1291             service->serviceName = serviceName;
1292             service->nSecurityObjects = nSecurityObjects;
1293             service->securityObjects = securityObjects;
1294             service->minProcs = 0;
1295             service->maxProcs = 1;
1296             service->idleDeadTime = 60;
1297             service->connDeadTime = rx_connDeadTime;
1298             service->executeRequestProc = serviceProc;
1299             service->checkReach = 0;
1300             rx_services[i] = service;   /* not visible until now */
1301             AFS_RXGUNLOCK();
1302             USERPRI;
1303             return service;
1304         }
1305     }
1306     AFS_RXGUNLOCK();
1307     USERPRI;
1308     rxi_FreeService(tservice);
1309     (osi_Msg "rx_NewService: cannot support > %d services\n",
1310      RX_MAX_SERVICES);
1311     return 0;
1312 }
1313
1314 /* Generic request processing loop. This routine should be called
1315  * by the implementation dependent rx_ServerProc. If socketp is
1316  * non-null, it will be set to the file descriptor that this thread
1317  * is now listening on. If socketp is null, this routine will never
1318  * returns. */
1319 void
1320 rxi_ServerProc(int threadID, struct rx_call *newcall, osi_socket * socketp)
1321 {
1322     register struct rx_call *call;
1323     register afs_int32 code;
1324     register struct rx_service *tservice = NULL;
1325
1326     for (;;) {
1327         if (newcall) {
1328             call = newcall;
1329             newcall = NULL;
1330         } else {
1331             call = rx_GetCall(threadID, tservice, socketp);
1332             if (socketp && *socketp != OSI_NULLSOCKET) {
1333                 /* We are now a listener thread */
1334                 return;
1335             }
1336         }
1337
1338         /* if server is restarting( typically smooth shutdown) then do not
1339          * allow any new calls.
1340          */
1341
1342         if (rx_tranquil && (call != NULL)) {
1343             SPLVAR;
1344
1345             NETPRI;
1346             AFS_RXGLOCK();
1347             MUTEX_ENTER(&call->lock);
1348
1349             rxi_CallError(call, RX_RESTARTING);
1350             rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
1351
1352             MUTEX_EXIT(&call->lock);
1353             AFS_RXGUNLOCK();
1354             USERPRI;
1355         }
1356 #ifdef  KERNEL
1357         if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1358 #ifdef RX_ENABLE_LOCKS
1359             AFS_GLOCK();
1360 #endif /* RX_ENABLE_LOCKS */
1361             afs_termState = AFSOP_STOP_AFS;
1362             afs_osi_Wakeup(&afs_termState);
1363 #ifdef RX_ENABLE_LOCKS
1364             AFS_GUNLOCK();
1365 #endif /* RX_ENABLE_LOCKS */
1366             return;
1367         }
1368 #endif
1369
1370         tservice = call->conn->service;
1371
1372         if (tservice->beforeProc)
1373             (*tservice->beforeProc) (call);
1374
1375         code = call->conn->service->executeRequestProc(call);
1376
1377         if (tservice->afterProc)
1378             (*tservice->afterProc) (call, code);
1379
1380         rx_EndCall(call, code);
1381         MUTEX_ENTER(&rx_stats_mutex);
1382         rxi_nCalls++;
1383         MUTEX_EXIT(&rx_stats_mutex);
1384     }
1385 }
1386
1387
1388 void
1389 rx_WakeupServerProcs(void)
1390 {
1391     struct rx_serverQueueEntry *np, *tqp;
1392     SPLVAR;
1393
1394     NETPRI;
1395     AFS_RXGLOCK();
1396     MUTEX_ENTER(&rx_serverPool_lock);
1397
1398 #ifdef RX_ENABLE_LOCKS
1399     if (rx_waitForPacket)
1400         CV_BROADCAST(&rx_waitForPacket->cv);
1401 #else /* RX_ENABLE_LOCKS */
1402     if (rx_waitForPacket)
1403         osi_rxWakeup(rx_waitForPacket);
1404 #endif /* RX_ENABLE_LOCKS */
1405     MUTEX_ENTER(&freeSQEList_lock);
1406     for (np = rx_FreeSQEList; np; np = tqp) {
1407         tqp = *(struct rx_serverQueueEntry **)np;
1408 #ifdef RX_ENABLE_LOCKS
1409         CV_BROADCAST(&np->cv);
1410 #else /* RX_ENABLE_LOCKS */
1411         osi_rxWakeup(np);
1412 #endif /* RX_ENABLE_LOCKS */
1413     }
1414     MUTEX_EXIT(&freeSQEList_lock);
1415     for (queue_Scan(&rx_idleServerQueue, np, tqp, rx_serverQueueEntry)) {
1416 #ifdef RX_ENABLE_LOCKS
1417         CV_BROADCAST(&np->cv);
1418 #else /* RX_ENABLE_LOCKS */
1419         osi_rxWakeup(np);
1420 #endif /* RX_ENABLE_LOCKS */
1421     }
1422     MUTEX_EXIT(&rx_serverPool_lock);
1423     AFS_RXGUNLOCK();
1424     USERPRI;
1425 }
1426
1427 /* meltdown:
1428  * One thing that seems to happen is that all the server threads get
1429  * tied up on some empty or slow call, and then a whole bunch of calls
1430  * arrive at once, using up the packet pool, so now there are more
1431  * empty calls.  The most critical resources here are server threads
1432  * and the free packet pool.  The "doreclaim" code seems to help in
1433  * general.  I think that eventually we arrive in this state: there
1434  * are lots of pending calls which do have all their packets present,
1435  * so they won't be reclaimed, are multi-packet calls, so they won't
1436  * be scheduled until later, and thus are tying up most of the free
1437  * packet pool for a very long time.
1438  * future options:
1439  * 1.  schedule multi-packet calls if all the packets are present.
1440  * Probably CPU-bound operation, useful to return packets to pool.
1441  * Do what if there is a full window, but the last packet isn't here?
1442  * 3.  preserve one thread which *only* runs "best" calls, otherwise
1443  * it sleeps and waits for that type of call.
1444  * 4.  Don't necessarily reserve a whole window for each thread.  In fact,
1445  * the current dataquota business is badly broken.  The quota isn't adjusted
1446  * to reflect how many packets are presently queued for a running call.
1447  * So, when we schedule a queued call with a full window of packets queued
1448  * up for it, that *should* free up a window full of packets for other 2d-class
1449  * calls to be able to use from the packet pool.  But it doesn't.
1450  *
1451  * NB.  Most of the time, this code doesn't run -- since idle server threads
1452  * sit on the idle server queue and are assigned by "...ReceivePacket" as soon
1453  * as a new call arrives.
1454  */
1455 /* Sleep until a call arrives.  Returns a pointer to the call, ready
1456  * for an rx_Read. */
1457 #ifdef RX_ENABLE_LOCKS
1458 struct rx_call *
1459 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
1460 {
1461     struct rx_serverQueueEntry *sq;
1462     register struct rx_call *call = (struct rx_call *)0;
1463     struct rx_service *service = NULL;
1464     SPLVAR;
1465
1466     MUTEX_ENTER(&freeSQEList_lock);
1467
1468     if ((sq = rx_FreeSQEList)) {
1469         rx_FreeSQEList = *(struct rx_serverQueueEntry **)sq;
1470         MUTEX_EXIT(&freeSQEList_lock);
1471     } else {                    /* otherwise allocate a new one and return that */
1472         MUTEX_EXIT(&freeSQEList_lock);
1473         sq = (struct rx_serverQueueEntry *)
1474             rxi_Alloc(sizeof(struct rx_serverQueueEntry));
1475         MUTEX_INIT(&sq->lock, "server Queue lock", MUTEX_DEFAULT, 0);
1476         CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
1477     }
1478
1479     MUTEX_ENTER(&rx_serverPool_lock);
1480     if (cur_service != NULL) {
1481         ReturnToServerPool(cur_service);
1482     }
1483     while (1) {
1484         if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
1485             register struct rx_call *tcall, *ncall, *choice2 = NULL;
1486
1487             /* Scan for eligible incoming calls.  A call is not eligible
1488              * if the maximum number of calls for its service type are
1489              * already executing */
1490             /* One thread will process calls FCFS (to prevent starvation),
1491              * while the other threads may run ahead looking for calls which
1492              * have all their input data available immediately.  This helps
1493              * keep threads from blocking, waiting for data from the client. */
1494             for (queue_Scan(&rx_incomingCallQueue, tcall, ncall, rx_call)) {
1495                 service = tcall->conn->service;
1496                 if (!QuotaOK(service)) {
1497                     continue;
1498                 }
1499                 if (tno == rxi_fcfs_thread_num
1500                     || !tcall->queue_item_header.next) {
1501                     /* If we're the fcfs thread , then  we'll just use
1502                      * this call. If we haven't been able to find an optimal
1503                      * choice, and we're at the end of the list, then use a
1504                      * 2d choice if one has been identified.  Otherwise... */
1505                     call = (choice2 ? choice2 : tcall);
1506                     service = call->conn->service;
1507                 } else if (!queue_IsEmpty(&tcall->rq)) {
1508                     struct rx_packet *rp;
1509                     rp = queue_First(&tcall->rq, rx_packet);
1510                     if (rp->header.seq == 1) {
1511                         if (!meltdown_1pkt
1512                             || (rp->header.flags & RX_LAST_PACKET)) {
1513                             call = tcall;
1514                         } else if (rxi_2dchoice && !choice2
1515                                    && !(tcall->flags & RX_CALL_CLEARED)
1516                                    && (tcall->rprev > rxi_HardAckRate)) {
1517                             choice2 = tcall;
1518                         } else
1519                             rxi_md2cnt++;
1520                     }
1521                 }
1522                 if (call) {
1523                     break;
1524                 } else {
1525                     ReturnToServerPool(service);
1526                 }
1527             }
1528         }
1529
1530         if (call) {
1531             queue_Remove(call);
1532             MUTEX_EXIT(&rx_serverPool_lock);
1533             MUTEX_ENTER(&call->lock);
1534
1535             if (call->flags & RX_CALL_WAIT_PROC) {
1536                 call->flags &= ~RX_CALL_WAIT_PROC;
1537                 MUTEX_ENTER(&rx_stats_mutex);
1538                 rx_nWaiting--;
1539                 MUTEX_EXIT(&rx_stats_mutex);
1540             }
1541
1542             if (call->state != RX_STATE_PRECALL || call->error) {
1543                 MUTEX_EXIT(&call->lock);
1544                 MUTEX_ENTER(&rx_serverPool_lock);
1545                 ReturnToServerPool(service);
1546                 call = NULL;
1547                 continue;
1548             }
1549
1550             if (queue_IsEmpty(&call->rq)
1551                 || queue_First(&call->rq, rx_packet)->header.seq != 1)
1552                 rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
1553
1554             CLEAR_CALL_QUEUE_LOCK(call);
1555             break;
1556         } else {
1557             /* If there are no eligible incoming calls, add this process
1558              * to the idle server queue, to wait for one */
1559             sq->newcall = 0;
1560             sq->tno = tno;
1561             if (socketp) {
1562                 *socketp = OSI_NULLSOCKET;
1563             }
1564             sq->socketp = socketp;
1565             queue_Append(&rx_idleServerQueue, sq);
1566 #ifndef AFS_AIX41_ENV
1567             rx_waitForPacket = sq;
1568 #else
1569             rx_waitingForPacket = sq;
1570 #endif /* AFS_AIX41_ENV */
1571             do {
1572                 CV_WAIT(&sq->cv, &rx_serverPool_lock);
1573 #ifdef  KERNEL
1574                 if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1575                     MUTEX_EXIT(&rx_serverPool_lock);
1576                     return (struct rx_call *)0;
1577                 }
1578 #endif
1579             } while (!(call = sq->newcall)
1580                      && !(socketp && *socketp != OSI_NULLSOCKET));
1581             MUTEX_EXIT(&rx_serverPool_lock);
1582             if (call) {
1583                 MUTEX_ENTER(&call->lock);
1584             }
1585             break;
1586         }
1587     }
1588
1589     MUTEX_ENTER(&freeSQEList_lock);
1590     *(struct rx_serverQueueEntry **)sq = rx_FreeSQEList;
1591     rx_FreeSQEList = sq;
1592     MUTEX_EXIT(&freeSQEList_lock);
1593
1594     if (call) {
1595         clock_GetTime(&call->startTime);
1596         call->state = RX_STATE_ACTIVE;
1597         call->mode = RX_MODE_RECEIVING;
1598 #ifdef RX_KERNEL_TRACE
1599         if (ICL_SETACTIVE(afs_iclSetp)) {
1600             int glockOwner = ISAFS_GLOCK();
1601             if (!glockOwner)
1602                 AFS_GLOCK();
1603             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
1604                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
1605                        call);
1606             if (!glockOwner)
1607                 AFS_GUNLOCK();
1608         }
1609 #endif
1610
1611         rxi_calltrace(RX_CALL_START, call);
1612         dpf(("rx_GetCall(port=%d, service=%d) ==> call %x\n",
1613              call->conn->service->servicePort, call->conn->service->serviceId,
1614              call));
1615
1616         CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
1617         MUTEX_EXIT(&call->lock);
1618     } else {
1619         dpf(("rx_GetCall(socketp=0x%x, *socketp=0x%x)\n", socketp, *socketp));
1620     }
1621
1622     return call;
1623 }
1624 #else /* RX_ENABLE_LOCKS */
1625 struct rx_call *
1626 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
1627 {
1628     struct rx_serverQueueEntry *sq;
1629     register struct rx_call *call = (struct rx_call *)0, *choice2;
1630     struct rx_service *service = NULL;
1631     SPLVAR;
1632
1633     NETPRI;
1634     AFS_RXGLOCK();
1635     MUTEX_ENTER(&freeSQEList_lock);
1636
1637     if ((sq = rx_FreeSQEList)) {
1638         rx_FreeSQEList = *(struct rx_serverQueueEntry **)sq;
1639         MUTEX_EXIT(&freeSQEList_lock);
1640     } else {                    /* otherwise allocate a new one and return that */
1641         MUTEX_EXIT(&freeSQEList_lock);
1642         sq = (struct rx_serverQueueEntry *)
1643             rxi_Alloc(sizeof(struct rx_serverQueueEntry));
1644         MUTEX_INIT(&sq->lock, "server Queue lock", MUTEX_DEFAULT, 0);
1645         CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
1646     }
1647     MUTEX_ENTER(&sq->lock);
1648
1649     if (cur_service != NULL) {
1650         cur_service->nRequestsRunning--;
1651         if (cur_service->nRequestsRunning < cur_service->minProcs)
1652             rxi_minDeficit++;
1653         rxi_availProcs++;
1654     }
1655     if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
1656         register struct rx_call *tcall, *ncall;
1657         /* Scan for eligible incoming calls.  A call is not eligible
1658          * if the maximum number of calls for its service type are
1659          * already executing */
1660         /* One thread will process calls FCFS (to prevent starvation),
1661          * while the other threads may run ahead looking for calls which
1662          * have all their input data available immediately.  This helps
1663          * keep threads from blocking, waiting for data from the client. */
1664         choice2 = (struct rx_call *)0;
1665         for (queue_Scan(&rx_incomingCallQueue, tcall, ncall, rx_call)) {
1666             service = tcall->conn->service;
1667             if (QuotaOK(service)) {
1668                 if (tno == rxi_fcfs_thread_num
1669                     || !tcall->queue_item_header.next) {
1670                     /* If we're the fcfs thread, then  we'll just use
1671                      * this call. If we haven't been able to find an optimal
1672                      * choice, and we're at the end of the list, then use a
1673                      * 2d choice if one has been identified.  Otherwise... */
1674                     call = (choice2 ? choice2 : tcall);
1675                     service = call->conn->service;
1676                 } else if (!queue_IsEmpty(&tcall->rq)) {
1677                     struct rx_packet *rp;
1678                     rp = queue_First(&tcall->rq, rx_packet);
1679                     if (rp->header.seq == 1
1680                         && (!meltdown_1pkt
1681                             || (rp->header.flags & RX_LAST_PACKET))) {
1682                         call = tcall;
1683                     } else if (rxi_2dchoice && !choice2
1684                                && !(tcall->flags & RX_CALL_CLEARED)
1685                                && (tcall->rprev > rxi_HardAckRate)) {
1686                         choice2 = tcall;
1687                     } else
1688                         rxi_md2cnt++;
1689                 }
1690             }
1691             if (call)
1692                 break;
1693         }
1694     }
1695
1696     if (call) {
1697         queue_Remove(call);
1698         /* we can't schedule a call if there's no data!!! */
1699         /* send an ack if there's no data, if we're missing the
1700          * first packet, or we're missing something between first
1701          * and last -- there's a "hole" in the incoming data. */
1702         if (queue_IsEmpty(&call->rq)
1703             || queue_First(&call->rq, rx_packet)->header.seq != 1
1704             || call->rprev != queue_Last(&call->rq, rx_packet)->header.seq)
1705             rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
1706
1707         call->flags &= (~RX_CALL_WAIT_PROC);
1708         service->nRequestsRunning++;
1709         /* just started call in minProcs pool, need fewer to maintain
1710          * guarantee */
1711         if (service->nRequestsRunning <= service->minProcs)
1712             rxi_minDeficit--;
1713         rxi_availProcs--;
1714         rx_nWaiting--;
1715         /* MUTEX_EXIT(&call->lock); */
1716     } else {
1717         /* If there are no eligible incoming calls, add this process
1718          * to the idle server queue, to wait for one */
1719         sq->newcall = 0;
1720         if (socketp) {
1721             *socketp = OSI_NULLSOCKET;
1722         }
1723         sq->socketp = socketp;
1724         queue_Append(&rx_idleServerQueue, sq);
1725         do {
1726             osi_rxSleep(sq);
1727 #ifdef  KERNEL
1728             if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1729                 AFS_RXGUNLOCK();
1730                 USERPRI;
1731                 rxi_Free(sq, sizeof(struct rx_serverQueueEntry));
1732                 return (struct rx_call *)0;
1733             }
1734 #endif
1735         } while (!(call = sq->newcall)
1736                  && !(socketp && *socketp != OSI_NULLSOCKET));
1737     }
1738     MUTEX_EXIT(&sq->lock);
1739
1740     MUTEX_ENTER(&freeSQEList_lock);
1741     *(struct rx_serverQueueEntry **)sq = rx_FreeSQEList;
1742     rx_FreeSQEList = sq;
1743     MUTEX_EXIT(&freeSQEList_lock);
1744
1745     if (call) {
1746         clock_GetTime(&call->startTime);
1747         call->state = RX_STATE_ACTIVE;
1748         call->mode = RX_MODE_RECEIVING;
1749 #ifdef RX_KERNEL_TRACE
1750         if (ICL_SETACTIVE(afs_iclSetp)) {
1751             int glockOwner = ISAFS_GLOCK();
1752             if (!glockOwner)
1753                 AFS_GLOCK();
1754             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
1755                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
1756                        call);
1757             if (!glockOwner)
1758                 AFS_GUNLOCK();
1759         }
1760 #endif
1761
1762         rxi_calltrace(RX_CALL_START, call);
1763         dpf(("rx_GetCall(port=%d, service=%d) ==> call %x\n",
1764              call->conn->service->servicePort, call->conn->service->serviceId,
1765              call));
1766     } else {
1767         dpf(("rx_GetCall(socketp=0x%x, *socketp=0x%x)\n", socketp, *socketp));
1768     }
1769
1770     AFS_RXGUNLOCK();
1771     USERPRI;
1772
1773     return call;
1774 }
1775 #endif /* RX_ENABLE_LOCKS */
1776
1777
1778
1779 /* Establish a procedure to be called when a packet arrives for a
1780  * call.  This routine will be called at most once after each call,
1781  * and will also be called if there is an error condition on the or
1782  * the call is complete.  Used by multi rx to build a selection
1783  * function which determines which of several calls is likely to be a
1784  * good one to read from.
1785  * NOTE: the way this is currently implemented it is probably only a
1786  * good idea to (1) use it immediately after a newcall (clients only)
1787  * and (2) only use it once.  Other uses currently void your warranty
1788  */
1789 void
1790 rx_SetArrivalProc(register struct rx_call *call,
1791                   register void (*proc) (register struct rx_call * call,
1792                                         register VOID * mh,
1793                                         register int index),
1794                   register VOID * handle, register int arg)
1795 {
1796     call->arrivalProc = proc;
1797     call->arrivalProcHandle = handle;
1798     call->arrivalProcArg = arg;
1799 }
1800
1801 /* Call is finished (possibly prematurely).  Return rc to the peer, if
1802  * appropriate, and return the final error code from the conversation
1803  * to the caller */
1804
1805 afs_int32
1806 rx_EndCall(register struct rx_call *call, afs_int32 rc)
1807 {
1808     register struct rx_connection *conn = call->conn;
1809     register struct rx_service *service;
1810     register struct rx_packet *tp;      /* Temporary packet pointer */
1811     register struct rx_packet *nxp;     /* Next packet pointer, for queue_Scan */
1812     afs_int32 error;
1813     SPLVAR;
1814
1815     dpf(("rx_EndCall(call %x)\n", call));
1816
1817     NETPRI;
1818     AFS_RXGLOCK();
1819     MUTEX_ENTER(&call->lock);
1820
1821     if (rc == 0 && call->error == 0) {
1822         call->abortCode = 0;
1823         call->abortCount = 0;
1824     }
1825
1826     call->arrivalProc = (void (*)())0;
1827     if (rc && call->error == 0) {
1828         rxi_CallError(call, rc);
1829         /* Send an abort message to the peer if this error code has
1830          * only just been set.  If it was set previously, assume the
1831          * peer has already been sent the error code or will request it
1832          */
1833         rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
1834     }
1835     if (conn->type == RX_SERVER_CONNECTION) {
1836         /* Make sure reply or at least dummy reply is sent */
1837         if (call->mode == RX_MODE_RECEIVING) {
1838             rxi_WriteProc(call, 0, 0);
1839         }
1840         if (call->mode == RX_MODE_SENDING) {
1841             rxi_FlushWrite(call);
1842         }
1843         service = conn->service;
1844         rxi_calltrace(RX_CALL_END, call);
1845         /* Call goes to hold state until reply packets are acknowledged */
1846         if (call->tfirst + call->nSoftAcked < call->tnext) {
1847             call->state = RX_STATE_HOLD;
1848         } else {
1849             call->state = RX_STATE_DALLY;
1850             rxi_ClearTransmitQueue(call, 0);
1851             rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
1852             rxevent_Cancel(call->keepAliveEvent, call,
1853                            RX_CALL_REFCOUNT_ALIVE);
1854         }
1855     } else {                    /* Client connection */
1856         char dummy;
1857         /* Make sure server receives input packets, in the case where
1858          * no reply arguments are expected */
1859         if ((call->mode == RX_MODE_SENDING)
1860             || (call->mode == RX_MODE_RECEIVING && call->rnext == 1)) {
1861             (void)rxi_ReadProc(call, &dummy, 1);
1862         }
1863
1864         /* If we had an outstanding delayed ack, be nice to the server
1865          * and force-send it now.
1866          */
1867         if (call->delayedAckEvent) {
1868             rxevent_Cancel(call->delayedAckEvent, call,
1869                            RX_CALL_REFCOUNT_DELAY);
1870             call->delayedAckEvent = NULL;
1871             rxi_SendDelayedAck(NULL, call, NULL);
1872         }
1873
1874         /* We need to release the call lock since it's lower than the
1875          * conn_call_lock and we don't want to hold the conn_call_lock
1876          * over the rx_ReadProc call. The conn_call_lock needs to be held
1877          * here for the case where rx_NewCall is perusing the calls on
1878          * the connection structure. We don't want to signal until
1879          * rx_NewCall is in a stable state. Otherwise, rx_NewCall may
1880          * have checked this call, found it active and by the time it
1881          * goes to sleep, will have missed the signal.
1882          */
1883         MUTEX_EXIT(&call->lock);
1884         MUTEX_ENTER(&conn->conn_call_lock);
1885         MUTEX_ENTER(&call->lock);
1886         MUTEX_ENTER(&conn->conn_data_lock);
1887         conn->flags |= RX_CONN_BUSY;
1888         if (conn->flags & RX_CONN_MAKECALL_WAITING) {
1889             conn->flags &= (~RX_CONN_MAKECALL_WAITING);
1890             MUTEX_EXIT(&conn->conn_data_lock);
1891 #ifdef  RX_ENABLE_LOCKS
1892             CV_BROADCAST(&conn->conn_call_cv);
1893 #else
1894             osi_rxWakeup(conn);
1895 #endif
1896         }
1897 #ifdef RX_ENABLE_LOCKS
1898         else {
1899             MUTEX_EXIT(&conn->conn_data_lock);
1900         }
1901 #endif /* RX_ENABLE_LOCKS */
1902         call->state = RX_STATE_DALLY;
1903     }
1904     error = call->error;
1905
1906     /* currentPacket, nLeft, and NFree must be zeroed here, because
1907      * ResetCall cannot: ResetCall may be called at splnet(), in the
1908      * kernel version, and may interrupt the macros rx_Read or
1909      * rx_Write, which run at normal priority for efficiency. */
1910     if (call->currentPacket) {
1911         rxi_FreePacket(call->currentPacket);
1912         call->currentPacket = (struct rx_packet *)0;
1913         call->nLeft = call->nFree = call->curlen = 0;
1914     } else
1915         call->nLeft = call->nFree = call->curlen = 0;
1916
1917     /* Free any packets from the last call to ReadvProc/WritevProc */
1918     for (queue_Scan(&call->iovq, tp, nxp, rx_packet)) {
1919         queue_Remove(tp);
1920         rxi_FreePacket(tp);
1921     }
1922
1923     CALL_RELE(call, RX_CALL_REFCOUNT_BEGIN);
1924     MUTEX_EXIT(&call->lock);
1925     if (conn->type == RX_CLIENT_CONNECTION) {
1926         MUTEX_EXIT(&conn->conn_call_lock);
1927         conn->flags &= ~RX_CONN_BUSY;
1928     }
1929     AFS_RXGUNLOCK();
1930     USERPRI;
1931     /*
1932      * Map errors to the local host's errno.h format.
1933      */
1934     error = ntoh_syserr_conv(error);
1935     return error;
1936 }
1937
1938 #if !defined(KERNEL)
1939
1940 /* Call this routine when shutting down a server or client (especially
1941  * clients).  This will allow Rx to gracefully garbage collect server
1942  * connections, and reduce the number of retries that a server might
1943  * make to a dead client.
1944  * This is not quite right, since some calls may still be ongoing and
1945  * we can't lock them to destroy them. */
1946 void
1947 rx_Finalize(void)
1948 {
1949     register struct rx_connection **conn_ptr, **conn_end;
1950
1951     INIT_PTHREAD_LOCKS;
1952     LOCK_RX_INIT;
1953     if (rxinit_status == 1) {
1954         UNLOCK_RX_INIT;
1955         return;                 /* Already shutdown. */
1956     }
1957     rxi_DeleteCachedConnections();
1958     if (rx_connHashTable) {
1959         MUTEX_ENTER(&rx_connHashTable_lock);
1960         for (conn_ptr = &rx_connHashTable[0], conn_end =
1961              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
1962              conn_ptr++) {
1963             struct rx_connection *conn, *next;
1964             for (conn = *conn_ptr; conn; conn = next) {
1965                 next = conn->next;
1966                 if (conn->type == RX_CLIENT_CONNECTION) {
1967                     /* MUTEX_ENTER(&conn->conn_data_lock); when used in kernel */
1968                     conn->refCount++;
1969                     /* MUTEX_EXIT(&conn->conn_data_lock); when used in kernel */
1970 #ifdef RX_ENABLE_LOCKS
1971                     rxi_DestroyConnectionNoLock(conn);
1972 #else /* RX_ENABLE_LOCKS */
1973                     rxi_DestroyConnection(conn);
1974 #endif /* RX_ENABLE_LOCKS */
1975                 }
1976             }
1977         }
1978 #ifdef RX_ENABLE_LOCKS
1979         while (rx_connCleanup_list) {
1980             struct rx_connection *conn;
1981             conn = rx_connCleanup_list;
1982             rx_connCleanup_list = rx_connCleanup_list->next;
1983             MUTEX_EXIT(&rx_connHashTable_lock);
1984             rxi_CleanupConnection(conn);
1985             MUTEX_ENTER(&rx_connHashTable_lock);
1986         }
1987         MUTEX_EXIT(&rx_connHashTable_lock);
1988 #endif /* RX_ENABLE_LOCKS */
1989     }
1990     rxi_flushtrace();
1991
1992     rxinit_status = 1;
1993     UNLOCK_RX_INIT;
1994 }
1995 #endif
1996
1997 /* if we wakeup packet waiter too often, can get in loop with two
1998     AllocSendPackets each waking each other up (from ReclaimPacket calls) */
1999 void
2000 rxi_PacketsUnWait(void)
2001 {
2002     if (!rx_waitingForPackets) {
2003         return;
2004     }
2005 #ifdef KERNEL
2006     if (rxi_OverQuota(RX_PACKET_CLASS_SEND)) {
2007         return;                 /* still over quota */
2008     }
2009 #endif /* KERNEL */
2010     rx_waitingForPackets = 0;
2011 #ifdef  RX_ENABLE_LOCKS
2012     CV_BROADCAST(&rx_waitingForPackets_cv);
2013 #else
2014     osi_rxWakeup(&rx_waitingForPackets);
2015 #endif
2016     return;
2017 }
2018
2019
2020 /* ------------------Internal interfaces------------------------- */
2021
2022 /* Return this process's service structure for the
2023  * specified socket and service */
2024 struct rx_service *
2025 rxi_FindService(register osi_socket socket, register u_short serviceId)
2026 {
2027     register struct rx_service **sp;
2028     for (sp = &rx_services[0]; *sp; sp++) {
2029         if ((*sp)->serviceId == serviceId && (*sp)->socket == socket)
2030             return *sp;
2031     }
2032     return 0;
2033 }
2034
2035 /* Allocate a call structure, for the indicated channel of the
2036  * supplied connection.  The mode and state of the call must be set by
2037  * the caller. Returns the call with mutex locked. */
2038 struct rx_call *
2039 rxi_NewCall(register struct rx_connection *conn, register int channel)
2040 {
2041     register struct rx_call *call;
2042 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2043     register struct rx_call *cp;        /* Call pointer temp */
2044     register struct rx_call *nxp;       /* Next call pointer, for queue_Scan */
2045 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2046
2047     /* Grab an existing call structure, or allocate a new one.
2048      * Existing call structures are assumed to have been left reset by
2049      * rxi_FreeCall */
2050     MUTEX_ENTER(&rx_freeCallQueue_lock);
2051
2052 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2053     /*
2054      * EXCEPT that the TQ might not yet be cleared out.
2055      * Skip over those with in-use TQs.
2056      */
2057     call = NULL;
2058     for (queue_Scan(&rx_freeCallQueue, cp, nxp, rx_call)) {
2059         if (!(cp->flags & RX_CALL_TQ_BUSY)) {
2060             call = cp;
2061             break;
2062         }
2063     }
2064     if (call) {
2065 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2066     if (queue_IsNotEmpty(&rx_freeCallQueue)) {
2067         call = queue_First(&rx_freeCallQueue, rx_call);
2068 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2069         queue_Remove(call);
2070         MUTEX_ENTER(&rx_stats_mutex);
2071         rx_stats.nFreeCallStructs--;
2072         MUTEX_EXIT(&rx_stats_mutex);
2073         MUTEX_EXIT(&rx_freeCallQueue_lock);
2074         MUTEX_ENTER(&call->lock);
2075         CLEAR_CALL_QUEUE_LOCK(call);
2076 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2077         /* Now, if TQ wasn't cleared earlier, do it now. */
2078         if (call->flags & RX_CALL_TQ_CLEARME) {
2079             rxi_ClearTransmitQueue(call, 0);
2080             queue_Init(&call->tq);
2081         }
2082 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2083         /* Bind the call to its connection structure */
2084         call->conn = conn;
2085         rxi_ResetCall(call, 1);
2086     } else {
2087         call = (struct rx_call *)rxi_Alloc(sizeof(struct rx_call));
2088
2089         MUTEX_EXIT(&rx_freeCallQueue_lock);
2090         MUTEX_INIT(&call->lock, "call lock", MUTEX_DEFAULT, NULL);
2091         MUTEX_ENTER(&call->lock);
2092         CV_INIT(&call->cv_twind, "call twind", CV_DEFAULT, 0);
2093         CV_INIT(&call->cv_rq, "call rq", CV_DEFAULT, 0);
2094         CV_INIT(&call->cv_tq, "call tq", CV_DEFAULT, 0);
2095
2096         MUTEX_ENTER(&rx_stats_mutex);
2097         rx_stats.nCallStructs++;
2098         MUTEX_EXIT(&rx_stats_mutex);
2099         /* Initialize once-only items */
2100         queue_Init(&call->tq);
2101         queue_Init(&call->rq);
2102         queue_Init(&call->iovq);
2103         /* Bind the call to its connection structure (prereq for reset) */
2104         call->conn = conn;
2105         rxi_ResetCall(call, 1);
2106     }
2107     call->channel = channel;
2108     call->callNumber = &conn->callNumber[channel];
2109     /* Note that the next expected call number is retained (in
2110      * conn->callNumber[i]), even if we reallocate the call structure
2111      */
2112     conn->call[channel] = call;
2113     /* if the channel's never been used (== 0), we should start at 1, otherwise
2114      * the call number is valid from the last time this channel was used */
2115     if (*call->callNumber == 0)
2116         *call->callNumber = 1;
2117
2118     return call;
2119 }
2120
2121 /* A call has been inactive long enough that so we can throw away
2122  * state, including the call structure, which is placed on the call
2123  * free list.
2124  * Call is locked upon entry.
2125  * haveCTLock set if called from rxi_ReapConnections
2126  */
2127 #ifdef RX_ENABLE_LOCKS
2128 void
2129 rxi_FreeCall(register struct rx_call *call, int haveCTLock)
2130 #else /* RX_ENABLE_LOCKS */
2131 void
2132 rxi_FreeCall(register struct rx_call *call)
2133 #endif                          /* RX_ENABLE_LOCKS */
2134 {
2135     register int channel = call->channel;
2136     register struct rx_connection *conn = call->conn;
2137
2138
2139     if (call->state == RX_STATE_DALLY || call->state == RX_STATE_HOLD)
2140         (*call->callNumber)++;
2141     rxi_ResetCall(call, 0);
2142     call->conn->call[channel] = (struct rx_call *)0;
2143
2144     MUTEX_ENTER(&rx_freeCallQueue_lock);
2145     SET_CALL_QUEUE_LOCK(call, &rx_freeCallQueue_lock);
2146 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
2147     /* A call may be free even though its transmit queue is still in use.
2148      * Since we search the call list from head to tail, put busy calls at
2149      * the head of the list, and idle calls at the tail.
2150      */
2151     if (call->flags & RX_CALL_TQ_BUSY)
2152         queue_Prepend(&rx_freeCallQueue, call);
2153     else
2154         queue_Append(&rx_freeCallQueue, call);
2155 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2156     queue_Append(&rx_freeCallQueue, call);
2157 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2158     MUTEX_ENTER(&rx_stats_mutex);
2159     rx_stats.nFreeCallStructs++;
2160     MUTEX_EXIT(&rx_stats_mutex);
2161
2162     MUTEX_EXIT(&rx_freeCallQueue_lock);
2163
2164     /* Destroy the connection if it was previously slated for
2165      * destruction, i.e. the Rx client code previously called
2166      * rx_DestroyConnection (client connections), or
2167      * rxi_ReapConnections called the same routine (server
2168      * connections).  Only do this, however, if there are no
2169      * outstanding calls. Note that for fine grain locking, there appears
2170      * to be a deadlock in that rxi_FreeCall has a call locked and
2171      * DestroyConnectionNoLock locks each call in the conn. But note a
2172      * few lines up where we have removed this call from the conn.
2173      * If someone else destroys a connection, they either have no
2174      * call lock held or are going through this section of code.
2175      */
2176     if (conn->flags & RX_CONN_DESTROY_ME) {
2177         MUTEX_ENTER(&conn->conn_data_lock);
2178         conn->refCount++;
2179         MUTEX_EXIT(&conn->conn_data_lock);
2180 #ifdef RX_ENABLE_LOCKS
2181         if (haveCTLock)
2182             rxi_DestroyConnectionNoLock(conn);
2183         else
2184             rxi_DestroyConnection(conn);
2185 #else /* RX_ENABLE_LOCKS */
2186         rxi_DestroyConnection(conn);
2187 #endif /* RX_ENABLE_LOCKS */
2188     }
2189 }
2190
2191 afs_int32 rxi_Alloccnt = 0, rxi_Allocsize = 0;
2192 char *
2193 rxi_Alloc(register size_t size)
2194 {
2195     register char *p;
2196
2197 #if defined(AFS_AIX41_ENV) && defined(KERNEL)
2198     /* Grab the AFS filesystem lock. See afs/osi.h for the lock
2199      * implementation.
2200      */
2201     int glockOwner = ISAFS_GLOCK();
2202     if (!glockOwner)
2203         AFS_GLOCK();
2204 #endif
2205     MUTEX_ENTER(&rx_stats_mutex);
2206     rxi_Alloccnt++;
2207     rxi_Allocsize += size;
2208     MUTEX_EXIT(&rx_stats_mutex);
2209 #if     (defined(AFS_AIX32_ENV) || defined(AFS_HPUX_ENV)) && !defined(AFS_HPUX100_ENV) && defined(KERNEL)
2210     if (size > AFS_SMALLOCSIZ) {
2211         p = (char *)osi_AllocMediumSpace(size);
2212     } else
2213         p = (char *)osi_AllocSmall(size, 1);
2214 #if defined(AFS_AIX41_ENV) && defined(KERNEL)
2215     if (!glockOwner)
2216         AFS_GUNLOCK();
2217 #endif
2218 #else
2219     p = (char *)osi_Alloc(size);
2220 #endif
2221     if (!p)
2222         osi_Panic("rxi_Alloc error");
2223     memset(p, 0, size);
2224     return p;
2225 }
2226
2227 void
2228 rxi_Free(void *addr, register size_t size)
2229 {
2230 #if defined(AFS_AIX41_ENV) && defined(KERNEL)
2231     /* Grab the AFS filesystem lock. See afs/osi.h for the lock
2232      * implementation.
2233      */
2234     int glockOwner = ISAFS_GLOCK();
2235     if (!glockOwner)
2236         AFS_GLOCK();
2237 #endif
2238     MUTEX_ENTER(&rx_stats_mutex);
2239     rxi_Alloccnt--;
2240     rxi_Allocsize -= size;
2241     MUTEX_EXIT(&rx_stats_mutex);
2242 #if     (defined(AFS_AIX32_ENV) || defined(AFS_HPUX_ENV)) && !defined(AFS_HPUX100_ENV) && defined(KERNEL)
2243     if (size > AFS_SMALLOCSIZ)
2244         osi_FreeMediumSpace(addr);
2245     else
2246         osi_FreeSmall(addr);
2247 #if defined(AFS_AIX41_ENV) && defined(KERNEL)
2248     if (!glockOwner)
2249         AFS_GUNLOCK();
2250 #endif
2251 #else
2252     osi_Free(addr, size);
2253 #endif
2254 }
2255
2256 /* Find the peer process represented by the supplied (host,port)
2257  * combination.  If there is no appropriate active peer structure, a
2258  * new one will be allocated and initialized
2259  * The origPeer, if set, is a pointer to a peer structure on which the
2260  * refcount will be be decremented. This is used to replace the peer
2261  * structure hanging off a connection structure */
2262 struct rx_peer *
2263 rxi_FindPeer(register afs_uint32 host, register u_short port,
2264              struct rx_peer *origPeer, int create)
2265 {
2266     register struct rx_peer *pp;
2267     int hashIndex;
2268     hashIndex = PEER_HASH(host, port);
2269     MUTEX_ENTER(&rx_peerHashTable_lock);
2270     for (pp = rx_peerHashTable[hashIndex]; pp; pp = pp->next) {
2271         if ((pp->host == host) && (pp->port == port))
2272             break;
2273     }
2274     if (!pp) {
2275         if (create) {
2276             pp = rxi_AllocPeer();       /* This bzero's *pp */
2277             pp->host = host;    /* set here or in InitPeerParams is zero */
2278             pp->port = port;
2279             MUTEX_INIT(&pp->peer_lock, "peer_lock", MUTEX_DEFAULT, 0);
2280             queue_Init(&pp->congestionQueue);
2281             queue_Init(&pp->rpcStats);
2282             pp->next = rx_peerHashTable[hashIndex];
2283             rx_peerHashTable[hashIndex] = pp;
2284             rxi_InitPeerParams(pp);
2285             MUTEX_ENTER(&rx_stats_mutex);
2286             rx_stats.nPeerStructs++;
2287             MUTEX_EXIT(&rx_stats_mutex);
2288         }
2289     }
2290     if (pp && create) {
2291         pp->refCount++;
2292     }
2293     if (origPeer)
2294         origPeer->refCount--;
2295     MUTEX_EXIT(&rx_peerHashTable_lock);
2296     return pp;
2297 }
2298
2299
2300 /* Find the connection at (host, port) started at epoch, and with the
2301  * given connection id.  Creates the server connection if necessary.
2302  * The type specifies whether a client connection or a server
2303  * connection is desired.  In both cases, (host, port) specify the
2304  * peer's (host, pair) pair.  Client connections are not made
2305  * automatically by this routine.  The parameter socket gives the
2306  * socket descriptor on which the packet was received.  This is used,
2307  * in the case of server connections, to check that *new* connections
2308  * come via a valid (port, serviceId).  Finally, the securityIndex
2309  * parameter must match the existing index for the connection.  If a
2310  * server connection is created, it will be created using the supplied
2311  * index, if the index is valid for this service */
2312 struct rx_connection *
2313 rxi_FindConnection(osi_socket socket, register afs_int32 host,
2314                    register u_short port, u_short serviceId, afs_uint32 cid,
2315                    afs_uint32 epoch, int type, u_int securityIndex)
2316 {
2317     int hashindex, flag;
2318     register struct rx_connection *conn;
2319     hashindex = CONN_HASH(host, port, cid, epoch, type);
2320     MUTEX_ENTER(&rx_connHashTable_lock);
2321     rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
2322                                                   rx_connHashTable[hashindex],
2323                                                   flag = 1);
2324     for (; conn;) {
2325         if ((conn->type == type) && ((cid & RX_CIDMASK) == conn->cid)
2326             && (epoch == conn->epoch)) {
2327             register struct rx_peer *pp = conn->peer;
2328             if (securityIndex != conn->securityIndex) {
2329                 /* this isn't supposed to happen, but someone could forge a packet
2330                  * like this, and there seems to be some CM bug that makes this
2331                  * happen from time to time -- in which case, the fileserver
2332                  * asserts. */
2333                 MUTEX_EXIT(&rx_connHashTable_lock);
2334                 return (struct rx_connection *)0;
2335             }
2336             if (pp->host == host && pp->port == port)
2337                 break;
2338             if (type == RX_CLIENT_CONNECTION && pp->port == port)
2339                 break;
2340             /* So what happens when it's a callback connection? */
2341             if (                /*type == RX_CLIENT_CONNECTION && */
2342                    (conn->epoch & 0x80000000))
2343                 break;
2344         }
2345         if (!flag) {
2346             /* the connection rxLastConn that was used the last time is not the
2347              ** one we are looking for now. Hence, start searching in the hash */
2348             flag = 1;
2349             conn = rx_connHashTable[hashindex];
2350         } else
2351             conn = conn->next;
2352     }
2353     if (!conn) {
2354         struct rx_service *service;
2355         if (type == RX_CLIENT_CONNECTION) {
2356             MUTEX_EXIT(&rx_connHashTable_lock);
2357             return (struct rx_connection *)0;
2358         }
2359         service = rxi_FindService(socket, serviceId);
2360         if (!service || (securityIndex >= service->nSecurityObjects)
2361             || (service->securityObjects[securityIndex] == 0)) {
2362             MUTEX_EXIT(&rx_connHashTable_lock);
2363             return (struct rx_connection *)0;
2364         }
2365         conn = rxi_AllocConnection();   /* This bzero's the connection */
2366         MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
2367         MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
2368         CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
2369         conn->next = rx_connHashTable[hashindex];
2370         rx_connHashTable[hashindex] = conn;
2371         conn->peer = rxi_FindPeer(host, port, 0, 1);
2372         conn->type = RX_SERVER_CONNECTION;
2373         conn->lastSendTime = clock_Sec();       /* don't GC immediately */
2374         conn->epoch = epoch;
2375         conn->cid = cid & RX_CIDMASK;
2376         /* conn->serial = conn->lastSerial = 0; */
2377         /* conn->timeout = 0; */
2378         conn->ackRate = RX_FAST_ACK_RATE;
2379         conn->service = service;
2380         conn->serviceId = serviceId;
2381         conn->securityIndex = securityIndex;
2382         conn->securityObject = service->securityObjects[securityIndex];
2383         conn->nSpecific = 0;
2384         conn->specific = NULL;
2385         rx_SetConnDeadTime(conn, service->connDeadTime);
2386         rx_SetConnIdleDeadTime(conn, service->idleDeadTime);
2387         /* Notify security object of the new connection */
2388         RXS_NewConnection(conn->securityObject, conn);
2389         /* XXXX Connection timeout? */
2390         if (service->newConnProc)
2391             (*service->newConnProc) (conn);
2392         MUTEX_ENTER(&rx_stats_mutex);
2393         rx_stats.nServerConns++;
2394         MUTEX_EXIT(&rx_stats_mutex);
2395     }
2396
2397     MUTEX_ENTER(&conn->conn_data_lock);
2398     conn->refCount++;
2399     MUTEX_EXIT(&conn->conn_data_lock);
2400
2401     rxLastConn = conn;          /* store this connection as the last conn used */
2402     MUTEX_EXIT(&rx_connHashTable_lock);
2403     return conn;
2404 }
2405
2406 /* There are two packet tracing routines available for testing and monitoring
2407  * Rx.  One is called just after every packet is received and the other is
2408  * called just before every packet is sent.  Received packets, have had their
2409  * headers decoded, and packets to be sent have not yet had their headers
2410  * encoded.  Both take two parameters: a pointer to the packet and a sockaddr
2411  * containing the network address.  Both can be modified.  The return value, if
2412  * non-zero, indicates that the packet should be dropped.  */
2413
2414 int (*rx_justReceived) () = 0;
2415 int (*rx_almostSent) () = 0;
2416
2417 /* A packet has been received off the interface.  Np is the packet, socket is
2418  * the socket number it was received from (useful in determining which service
2419  * this packet corresponds to), and (host, port) reflect the host,port of the
2420  * sender.  This call returns the packet to the caller if it is finished with
2421  * it, rather than de-allocating it, just as a small performance hack */
2422
2423 struct rx_packet *
2424 rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
2425                   afs_uint32 host, u_short port, int *tnop,
2426                   struct rx_call **newcallp)
2427 {
2428     register struct rx_call *call;
2429     register struct rx_connection *conn;
2430     int channel;
2431     afs_uint32 currentCallNumber;
2432     int type;
2433     int skew;
2434 #ifdef RXDEBUG
2435     char *packetType;
2436 #endif
2437     struct rx_packet *tnp;
2438
2439 #ifdef RXDEBUG
2440 /* We don't print out the packet until now because (1) the time may not be
2441  * accurate enough until now in the lwp implementation (rx_Listener only gets
2442  * the time after the packet is read) and (2) from a protocol point of view,
2443  * this is the first time the packet has been seen */
2444     packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
2445         ? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
2446     dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %x",
2447          np->header.serial, packetType, host, port, np->header.serviceId,
2448          np->header.epoch, np->header.cid, np->header.callNumber,
2449          np->header.seq, np->header.flags, np));
2450 #endif
2451
2452     if (np->header.type == RX_PACKET_TYPE_VERSION) {
2453         return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
2454     }
2455
2456     if (np->header.type == RX_PACKET_TYPE_DEBUG) {
2457         return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
2458     }
2459 #ifdef RXDEBUG
2460     /* If an input tracer function is defined, call it with the packet and
2461      * network address.  Note this function may modify its arguments. */
2462     if (rx_justReceived) {
2463         struct sockaddr_in addr;
2464         int drop;
2465         addr.sin_family = AF_INET;
2466         addr.sin_port = port;
2467         addr.sin_addr.s_addr = host;
2468 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
2469         addr.sin_len = sizeof(addr);
2470 #endif /* AFS_OSF_ENV */
2471         drop = (*rx_justReceived) (np, &addr);
2472         /* drop packet if return value is non-zero */
2473         if (drop)
2474             return np;
2475         port = addr.sin_port;   /* in case fcn changed addr */
2476         host = addr.sin_addr.s_addr;
2477     }
2478 #endif
2479
2480     /* If packet was not sent by the client, then *we* must be the client */
2481     type = ((np->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED)
2482         ? RX_CLIENT_CONNECTION : RX_SERVER_CONNECTION;
2483
2484     /* Find the connection (or fabricate one, if we're the server & if
2485      * necessary) associated with this packet */
2486     conn =
2487         rxi_FindConnection(socket, host, port, np->header.serviceId,
2488                            np->header.cid, np->header.epoch, type,
2489                            np->header.securityIndex);
2490
2491     if (!conn) {
2492         /* If no connection found or fabricated, just ignore the packet.
2493          * (An argument could be made for sending an abort packet for
2494          * the conn) */
2495         return np;
2496     }
2497
2498     MUTEX_ENTER(&conn->conn_data_lock);
2499     if (conn->maxSerial < np->header.serial)
2500         conn->maxSerial = np->header.serial;
2501     MUTEX_EXIT(&conn->conn_data_lock);
2502
2503     /* If the connection is in an error state, send an abort packet and ignore
2504      * the incoming packet */
2505     if (conn->error) {
2506         /* Don't respond to an abort packet--we don't want loops! */
2507         MUTEX_ENTER(&conn->conn_data_lock);
2508         if (np->header.type != RX_PACKET_TYPE_ABORT)
2509             np = rxi_SendConnectionAbort(conn, np, 1, 0);
2510         conn->refCount--;
2511         MUTEX_EXIT(&conn->conn_data_lock);
2512         return np;
2513     }
2514
2515     /* Check for connection-only requests (i.e. not call specific). */
2516     if (np->header.callNumber == 0) {
2517         switch (np->header.type) {
2518         case RX_PACKET_TYPE_ABORT:
2519             /* What if the supplied error is zero? */
2520             rxi_ConnectionError(conn, ntohl(rx_GetInt32(np, 0)));
2521             MUTEX_ENTER(&conn->conn_data_lock);
2522             conn->refCount--;
2523             MUTEX_EXIT(&conn->conn_data_lock);
2524             return np;
2525         case RX_PACKET_TYPE_CHALLENGE:
2526             tnp = rxi_ReceiveChallengePacket(conn, np, 1);
2527             MUTEX_ENTER(&conn->conn_data_lock);
2528             conn->refCount--;
2529             MUTEX_EXIT(&conn->conn_data_lock);
2530             return tnp;
2531         case RX_PACKET_TYPE_RESPONSE:
2532             tnp = rxi_ReceiveResponsePacket(conn, np, 1);
2533             MUTEX_ENTER(&conn->conn_data_lock);
2534             conn->refCount--;
2535             MUTEX_EXIT(&conn->conn_data_lock);
2536             return tnp;
2537         case RX_PACKET_TYPE_PARAMS:
2538         case RX_PACKET_TYPE_PARAMS + 1:
2539         case RX_PACKET_TYPE_PARAMS + 2:
2540             /* ignore these packet types for now */
2541             MUTEX_ENTER(&conn->conn_data_lock);
2542             conn->refCount--;
2543             MUTEX_EXIT(&conn->conn_data_lock);
2544             return np;
2545
2546
2547         default:
2548             /* Should not reach here, unless the peer is broken: send an
2549              * abort packet */
2550             rxi_ConnectionError(conn, RX_PROTOCOL_ERROR);
2551             MUTEX_ENTER(&conn->conn_data_lock);
2552             tnp = rxi_SendConnectionAbort(conn, np, 1, 0);
2553             conn->refCount--;
2554             MUTEX_EXIT(&conn->conn_data_lock);
2555             return tnp;
2556         }
2557     }
2558
2559     channel = np->header.cid & RX_CHANNELMASK;
2560     call = conn->call[channel];
2561 #ifdef  RX_ENABLE_LOCKS
2562     if (call)
2563         MUTEX_ENTER(&call->lock);
2564     /* Test to see if call struct is still attached to conn. */
2565     if (call != conn->call[channel]) {
2566         if (call)
2567             MUTEX_EXIT(&call->lock);
2568         if (type == RX_SERVER_CONNECTION) {
2569             call = conn->call[channel];
2570             /* If we started with no call attached and there is one now,
2571              * another thread is also running this routine and has gotten
2572              * the connection channel. We should drop this packet in the tests
2573              * below. If there was a call on this connection and it's now
2574              * gone, then we'll be making a new call below.
2575              * If there was previously a call and it's now different then
2576              * the old call was freed and another thread running this routine
2577              * has created a call on this channel. One of these two threads
2578              * has a packet for the old call and the code below handles those
2579              * cases.
2580              */
2581             if (call)
2582                 MUTEX_ENTER(&call->lock);
2583         } else {
2584             /* This packet can't be for this call. If the new call address is
2585              * 0 then no call is running on this channel. If there is a call
2586              * then, since this is a client connection we're getting data for
2587              * it must be for the previous call.
2588              */
2589             MUTEX_ENTER(&rx_stats_mutex);
2590             rx_stats.spuriousPacketsRead++;
2591             MUTEX_EXIT(&rx_stats_mutex);
2592             MUTEX_ENTER(&conn->conn_data_lock);
2593             conn->refCount--;
2594             MUTEX_EXIT(&conn->conn_data_lock);
2595             return np;
2596         }
2597     }
2598 #endif
2599     currentCallNumber = conn->callNumber[channel];
2600
2601     if (type == RX_SERVER_CONNECTION) { /* We're the server */
2602         if (np->header.callNumber < currentCallNumber) {
2603             MUTEX_ENTER(&rx_stats_mutex);
2604             rx_stats.spuriousPacketsRead++;
2605             MUTEX_EXIT(&rx_stats_mutex);
2606 #ifdef  RX_ENABLE_LOCKS
2607             if (call)
2608                 MUTEX_EXIT(&call->lock);
2609 #endif
2610             MUTEX_ENTER(&conn->conn_data_lock);
2611             conn->refCount--;
2612             MUTEX_EXIT(&conn->conn_data_lock);
2613             return np;
2614         }
2615         if (!call) {
2616             MUTEX_ENTER(&conn->conn_call_lock);
2617             call = rxi_NewCall(conn, channel);
2618             MUTEX_EXIT(&conn->conn_call_lock);
2619             *call->callNumber = np->header.callNumber;
2620             call->state = RX_STATE_PRECALL;
2621             clock_GetTime(&call->queueTime);
2622             hzero(call->bytesSent);
2623             hzero(call->bytesRcvd);
2624             rxi_KeepAliveOn(call);
2625         } else if (np->header.callNumber != currentCallNumber) {
2626             /* Wait until the transmit queue is idle before deciding
2627              * whether to reset the current call. Chances are that the
2628              * call will be in ether DALLY or HOLD state once the TQ_BUSY
2629              * flag is cleared.
2630              */
2631 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
2632             while ((call->state == RX_STATE_ACTIVE)
2633                    && (call->flags & RX_CALL_TQ_BUSY)) {
2634                 call->flags |= RX_CALL_TQ_WAIT;
2635 #ifdef RX_ENABLE_LOCKS
2636                 CV_WAIT(&call->cv_tq, &call->lock);
2637 #else /* RX_ENABLE_LOCKS */
2638                 osi_rxSleep(&call->tq);
2639 #endif /* RX_ENABLE_LOCKS */
2640             }
2641 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2642             /* If the new call cannot be taken right now send a busy and set
2643              * the error condition in this call, so that it terminates as
2644              * quickly as possible */
2645             if (call->state == RX_STATE_ACTIVE) {
2646                 struct rx_packet *tp;
2647
2648                 rxi_CallError(call, RX_CALL_DEAD);
2649                 tp = rxi_SendSpecial(call, conn, np, RX_PACKET_TYPE_BUSY,
2650                                      NULL, 0, 1);
2651                 MUTEX_EXIT(&call->lock);
2652                 MUTEX_ENTER(&conn->conn_data_lock);
2653                 conn->refCount--;
2654                 MUTEX_EXIT(&conn->conn_data_lock);
2655                 return tp;
2656             }
2657             rxi_ResetCall(call, 0);
2658             *call->callNumber = np->header.callNumber;
2659             call->state = RX_STATE_PRECALL;
2660             clock_GetTime(&call->queueTime);
2661             hzero(call->bytesSent);
2662             hzero(call->bytesRcvd);
2663             /*
2664              * If the number of queued calls exceeds the overload
2665              * threshold then abort this call.
2666              */
2667             if ((rx_BusyThreshold > 0) && (rx_nWaiting > rx_BusyThreshold)) {
2668                 struct rx_packet *tp;
2669
2670                 rxi_CallError(call, rx_BusyError);
2671                 tp = rxi_SendCallAbort(call, np, 1, 0);
2672                 MUTEX_EXIT(&call->lock);
2673                 MUTEX_ENTER(&conn->conn_data_lock);
2674                 conn->refCount--;
2675                 MUTEX_EXIT(&conn->conn_data_lock);
2676                 return tp;
2677             }
2678             rxi_KeepAliveOn(call);
2679         } else {
2680             /* Continuing call; do nothing here. */
2681         }
2682     } else {                    /* we're the client */
2683         /* Ignore all incoming acknowledgements for calls in DALLY state */
2684         if (call && (call->state == RX_STATE_DALLY)
2685             && (np->header.type == RX_PACKET_TYPE_ACK)) {
2686             MUTEX_ENTER(&rx_stats_mutex);
2687             rx_stats.ignorePacketDally++;
2688             MUTEX_EXIT(&rx_stats_mutex);
2689 #ifdef  RX_ENABLE_LOCKS
2690             if (call) {
2691                 MUTEX_EXIT(&call->lock);
2692             }
2693 #endif
2694             MUTEX_ENTER(&conn->conn_data_lock);
2695             conn->refCount--;
2696             MUTEX_EXIT(&conn->conn_data_lock);
2697             return np;
2698         }
2699
2700         /* Ignore anything that's not relevant to the current call.  If there
2701          * isn't a current call, then no packet is relevant. */
2702         if (!call || (np->header.callNumber != currentCallNumber)) {
2703             MUTEX_ENTER(&rx_stats_mutex);
2704             rx_stats.spuriousPacketsRead++;
2705             MUTEX_EXIT(&rx_stats_mutex);
2706 #ifdef  RX_ENABLE_LOCKS
2707             if (call) {
2708                 MUTEX_EXIT(&call->lock);
2709             }
2710 #endif
2711             MUTEX_ENTER(&conn->conn_data_lock);
2712             conn->refCount--;
2713             MUTEX_EXIT(&conn->conn_data_lock);
2714             return np;
2715         }
2716         /* If the service security object index stamped in the packet does not
2717          * match the connection's security index, ignore the packet */
2718         if (np->header.securityIndex != conn->securityIndex) {
2719 #ifdef  RX_ENABLE_LOCKS
2720             MUTEX_EXIT(&call->lock);
2721 #endif
2722             MUTEX_ENTER(&conn->conn_data_lock);
2723             conn->refCount--;
2724             MUTEX_EXIT(&conn->conn_data_lock);
2725             return np;
2726         }
2727
2728         /* If we're receiving the response, then all transmit packets are
2729          * implicitly acknowledged.  Get rid of them. */
2730         if (np->header.type == RX_PACKET_TYPE_DATA) {
2731 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2732             /* XXX Hack. Because we must release the global rx lock when
2733              * sending packets (osi_NetSend) we drop all acks while we're
2734              * traversing the tq in rxi_Start sending packets out because
2735              * packets may move to the freePacketQueue as result of being here!
2736              * So we drop these packets until we're safely out of the
2737              * traversing. Really ugly!
2738              * For fine grain RX locking, we set the acked field in the
2739              * packets and let rxi_Start remove them from the transmit queue.
2740              */
2741             if (call->flags & RX_CALL_TQ_BUSY) {
2742 #ifdef  RX_ENABLE_LOCKS
2743                 rxi_SetAcksInTransmitQueue(call);
2744 #else
2745                 conn->refCount--;
2746                 return np;      /* xmitting; drop packet */
2747 #endif
2748             } else {
2749                 rxi_ClearTransmitQueue(call, 0);
2750             }
2751 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2752             rxi_ClearTransmitQueue(call, 0);
2753 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2754         } else {
2755             if (np->header.type == RX_PACKET_TYPE_ACK) {
2756                 /* now check to see if this is an ack packet acknowledging that the
2757                  * server actually *lost* some hard-acked data.  If this happens we
2758                  * ignore this packet, as it may indicate that the server restarted in
2759                  * the middle of a call.  It is also possible that this is an old ack
2760                  * packet.  We don't abort the connection in this case, because this
2761                  * *might* just be an old ack packet.  The right way to detect a server
2762                  * restart in the midst of a call is to notice that the server epoch
2763                  * changed, btw.  */
2764                 /* XXX I'm not sure this is exactly right, since tfirst **IS**
2765                  * XXX unacknowledged.  I think that this is off-by-one, but
2766                  * XXX I don't dare change it just yet, since it will
2767                  * XXX interact badly with the server-restart detection
2768                  * XXX code in receiveackpacket.  */
2769                 if (ntohl(rx_GetInt32(np, FIRSTACKOFFSET)) < call->tfirst) {
2770                     MUTEX_ENTER(&rx_stats_mutex);
2771                     rx_stats.spuriousPacketsRead++;
2772                     MUTEX_EXIT(&rx_stats_mutex);
2773                     MUTEX_EXIT(&call->lock);
2774                     MUTEX_ENTER(&conn->conn_data_lock);
2775                     conn->refCount--;
2776                     MUTEX_EXIT(&conn->conn_data_lock);
2777                     return np;
2778                 }
2779             }
2780         }                       /* else not a data packet */
2781     }
2782
2783     osirx_AssertMine(&call->lock, "rxi_ReceivePacket middle");
2784     /* Set remote user defined status from packet */
2785     call->remoteStatus = np->header.userStatus;
2786
2787     /* Note the gap between the expected next packet and the actual
2788      * packet that arrived, when the new packet has a smaller serial number
2789      * than expected.  Rioses frequently reorder packets all by themselves,
2790      * so this will be quite important with very large window sizes.
2791      * Skew is checked against 0 here to avoid any dependence on the type of
2792      * inPacketSkew (which may be unsigned).  In C, -1 > (unsigned) 0 is always
2793      * true!
2794      * The inPacketSkew should be a smoothed running value, not just a maximum.  MTUXXX
2795      * see CalculateRoundTripTime for an example of how to keep smoothed values.
2796      * I think using a beta of 1/8 is probably appropriate.  93.04.21
2797      */
2798     MUTEX_ENTER(&conn->conn_data_lock);
2799     skew = conn->lastSerial - np->header.serial;
2800     conn->lastSerial = np->header.serial;
2801     MUTEX_EXIT(&conn->conn_data_lock);
2802     if (skew > 0) {
2803         register struct rx_peer *peer;
2804         peer = conn->peer;
2805         if (skew > peer->inPacketSkew) {
2806             dpf(("*** In skew changed from %d to %d\n", peer->inPacketSkew,
2807                  skew));
2808             peer->inPacketSkew = skew;
2809         }
2810     }
2811
2812     /* Now do packet type-specific processing */
2813     switch (np->header.type) {
2814     case RX_PACKET_TYPE_DATA:
2815         np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
2816                                    newcallp);
2817         break;
2818     case RX_PACKET_TYPE_ACK:
2819         /* Respond immediately to ack packets requesting acknowledgement
2820          * (ping packets) */
2821         if (np->header.flags & RX_REQUEST_ACK) {
2822             if (call->error)
2823                 (void)rxi_SendCallAbort(call, 0, 1, 0);
2824             else
2825                 (void)rxi_SendAck(call, 0, np->header.serial,
2826                                   RX_ACK_PING_RESPONSE, 1);
2827         }
2828         np = rxi_ReceiveAckPacket(call, np, 1);
2829         break;
2830     case RX_PACKET_TYPE_ABORT:
2831         /* An abort packet: reset the connection, passing the error up to
2832          * the user */
2833         /* What if error is zero? */
2834         rxi_CallError(call, ntohl(*(afs_int32 *) rx_DataOf(np)));
2835         break;
2836     case RX_PACKET_TYPE_BUSY:
2837         /* XXXX */
2838         break;
2839     case RX_PACKET_TYPE_ACKALL:
2840         /* All packets acknowledged, so we can drop all packets previously
2841          * readied for sending */
2842 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2843         /* XXX Hack. We because we can't release the global rx lock when
2844          * sending packets (osi_NetSend) we drop all ack pkts while we're
2845          * traversing the tq in rxi_Start sending packets out because
2846          * packets may move to the freePacketQueue as result of being
2847          * here! So we drop these packets until we're safely out of the
2848          * traversing. Really ugly!
2849          * For fine grain RX locking, we set the acked field in the packets
2850          * and let rxi_Start remove the packets from the transmit queue.
2851          */
2852         if (call->flags & RX_CALL_TQ_BUSY) {
2853 #ifdef  RX_ENABLE_LOCKS
2854             rxi_SetAcksInTransmitQueue(call);
2855             break;
2856 #else /* RX_ENABLE_LOCKS */
2857             conn->refCount--;
2858             return np;          /* xmitting; drop packet */
2859 #endif /* RX_ENABLE_LOCKS */
2860         }
2861 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2862         rxi_ClearTransmitQueue(call, 0);
2863         break;
2864     default:
2865         /* Should not reach here, unless the peer is broken: send an abort
2866          * packet */
2867         rxi_CallError(call, RX_PROTOCOL_ERROR);
2868         np = rxi_SendCallAbort(call, np, 1, 0);
2869         break;
2870     };
2871     /* Note when this last legitimate packet was received, for keep-alive
2872      * processing.  Note, we delay getting the time until now in the hope that
2873      * the packet will be delivered to the user before any get time is required
2874      * (if not, then the time won't actually be re-evaluated here). */
2875     call->lastReceiveTime = clock_Sec();
2876     MUTEX_EXIT(&call->lock);
2877     MUTEX_ENTER(&conn->conn_data_lock);
2878     conn->refCount--;
2879     MUTEX_EXIT(&conn->conn_data_lock);
2880     return np;
2881 }
2882
2883 /* return true if this is an "interesting" connection from the point of view
2884     of someone trying to debug the system */
2885 int
2886 rxi_IsConnInteresting(struct rx_connection *aconn)
2887 {
2888     register int i;
2889     register struct rx_call *tcall;
2890
2891     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
2892         return 1;
2893     for (i = 0; i < RX_MAXCALLS; i++) {
2894         tcall = aconn->call[i];
2895         if (tcall) {
2896             if ((tcall->state == RX_STATE_PRECALL)
2897                 || (tcall->state == RX_STATE_ACTIVE))
2898                 return 1;
2899             if ((tcall->mode == RX_MODE_SENDING)
2900                 || (tcall->mode == RX_MODE_RECEIVING))
2901                 return 1;
2902         }
2903     }
2904     return 0;
2905 }
2906
2907 #ifdef KERNEL
2908 /* if this is one of the last few packets AND it wouldn't be used by the
2909    receiving call to immediately satisfy a read request, then drop it on
2910    the floor, since accepting it might prevent a lock-holding thread from
2911    making progress in its reading. If a call has been cleared while in
2912    the precall state then ignore all subsequent packets until the call
2913    is assigned to a thread. */
2914
2915 static int
2916 TooLow(struct rx_packet *ap, struct rx_call *acall)
2917 {
2918     int rc = 0;
2919     MUTEX_ENTER(&rx_stats_mutex);
2920     if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
2921          && (acall->state == RX_STATE_PRECALL))
2922         || ((rx_nFreePackets < rxi_dataQuota + 2)
2923             && !((ap->header.seq < acall->rnext + rx_initSendWindow)
2924                  && (acall->flags & RX_CALL_READER_WAIT)))) {
2925         rc = 1;
2926     }
2927     MUTEX_EXIT(&rx_stats_mutex);
2928     return rc;
2929 }
2930 #endif /* KERNEL */
2931
2932 static void
2933 rxi_CheckReachEvent(struct rxevent *event, struct rx_connection *conn,
2934                     struct rx_call *acall)
2935 {
2936     struct rx_call *call = acall;
2937     struct clock when;
2938     int i, waiting;
2939
2940     MUTEX_ENTER(&conn->conn_data_lock);
2941     conn->checkReachEvent = NULL;
2942     waiting = conn->flags & RX_CONN_ATTACHWAIT;
2943     if (event)
2944         conn->refCount--;
2945     MUTEX_EXIT(&conn->conn_data_lock);
2946
2947     if (waiting) {
2948         if (!call) {
2949             MUTEX_ENTER(&conn->conn_call_lock);
2950             MUTEX_ENTER(&conn->conn_data_lock);
2951             for (i = 0; i < RX_MAXCALLS; i++) {
2952                 struct rx_call *tc = conn->call[i];
2953                 if (tc && tc->state == RX_STATE_PRECALL) {
2954                     call = tc;
2955                     break;
2956                 }
2957             }
2958             if (!call)
2959                 /* Indicate that rxi_CheckReachEvent is no longer running by
2960                  * clearing the flag.  Must be atomic under conn_data_lock to
2961                  * avoid a new call slipping by: rxi_CheckConnReach holds
2962                  * conn_data_lock while checking RX_CONN_ATTACHWAIT.
2963                  */
2964                 conn->flags &= ~RX_CONN_ATTACHWAIT;
2965             MUTEX_EXIT(&conn->conn_data_lock);
2966             MUTEX_EXIT(&conn->conn_call_lock);
2967         }
2968
2969         if (call) {
2970             if (call != acall)
2971                 MUTEX_ENTER(&call->lock);
2972             rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
2973             if (call != acall)
2974                 MUTEX_EXIT(&call->lock);
2975
2976             clock_GetTime(&when);
2977             when.sec += RX_CHECKREACH_TIMEOUT;
2978             MUTEX_ENTER(&conn->conn_data_lock);
2979             if (!conn->checkReachEvent) {
2980                 conn->refCount++;
2981                 conn->checkReachEvent =
2982                     rxevent_Post(&when, rxi_CheckReachEvent, conn, NULL);
2983             }
2984             MUTEX_EXIT(&conn->conn_data_lock);
2985         }
2986     }
2987 }
2988
2989 static int
2990 rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
2991 {
2992     struct rx_service *service = conn->service;
2993     struct rx_peer *peer = conn->peer;
2994     afs_uint32 now, lastReach;
2995
2996     if (service->checkReach == 0)
2997         return 0;
2998
2999     now = clock_Sec();
3000     MUTEX_ENTER(&peer->peer_lock);
3001     lastReach = peer->lastReachTime;
3002     MUTEX_EXIT(&peer->peer_lock);
3003     if (now - lastReach < RX_CHECKREACH_TTL)
3004         return 0;
3005
3006     MUTEX_ENTER(&conn->conn_data_lock);
3007     if (conn->flags & RX_CONN_ATTACHWAIT) {
3008         MUTEX_EXIT(&conn->conn_data_lock);
3009         return 1;
3010     }
3011     conn->flags |= RX_CONN_ATTACHWAIT;
3012     MUTEX_EXIT(&conn->conn_data_lock);
3013     if (!conn->checkReachEvent)
3014         rxi_CheckReachEvent(NULL, conn, call);
3015
3016     return 1;
3017 }
3018
3019 /* try to attach call, if authentication is complete */
3020 static void
3021 TryAttach(register struct rx_call *acall, register osi_socket socket,
3022           register int *tnop, register struct rx_call **newcallp,
3023           int reachOverride)
3024 {
3025     struct rx_connection *conn = acall->conn;
3026
3027     if (conn->type == RX_SERVER_CONNECTION
3028         && acall->state == RX_STATE_PRECALL) {
3029         /* Don't attach until we have any req'd. authentication. */
3030         if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
3031             if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
3032                 rxi_AttachServerProc(acall, socket, tnop, newcallp);
3033             /* Note:  this does not necessarily succeed; there
3034              * may not any proc available
3035              */
3036         } else {
3037             rxi_ChallengeOn(acall->conn);
3038         }
3039     }
3040 }
3041
3042 /* A data packet has been received off the interface.  This packet is
3043  * appropriate to the call (the call is in the right state, etc.).  This
3044  * routine can return a packet to the caller, for re-use */
3045
3046 struct rx_packet *
3047 rxi_ReceiveDataPacket(register struct rx_call *call,
3048                       register struct rx_packet *np, int istack,
3049                       osi_socket socket, afs_uint32 host, u_short port,
3050                       int *tnop, struct rx_call **newcallp)
3051 {
3052     int ackNeeded = 0;          /* 0 means no, otherwise ack_reason */
3053     int newPackets = 0;
3054     int didHardAck = 0;
3055     int haveLast = 0;
3056     afs_uint32 seq, serial, flags;
3057     int isFirst;
3058     struct rx_packet *tnp;
3059     struct clock when;
3060     MUTEX_ENTER(&rx_stats_mutex);
3061     rx_stats.dataPacketsRead++;
3062     MUTEX_EXIT(&rx_stats_mutex);
3063
3064 #ifdef KERNEL
3065     /* If there are no packet buffers, drop this new packet, unless we can find
3066      * packet buffers from inactive calls */
3067     if (!call->error
3068         && (rxi_OverQuota(RX_PACKET_CLASS_RECEIVE) || TooLow(np, call))) {
3069         MUTEX_ENTER(&rx_freePktQ_lock);
3070         rxi_NeedMorePackets = TRUE;
3071         MUTEX_EXIT(&rx_freePktQ_lock);
3072         MUTEX_ENTER(&rx_stats_mutex);
3073         rx_stats.noPacketBuffersOnRead++;
3074         MUTEX_EXIT(&rx_stats_mutex);
3075         call->rprev = np->header.serial;
3076         rxi_calltrace(RX_TRACE_DROP, call);
3077         dpf(("packet %x dropped on receipt - quota problems", np));
3078         if (rxi_doreclaim)
3079             rxi_ClearReceiveQueue(call);
3080         clock_GetTime(&when);
3081         clock_Add(&when, &rx_softAckDelay);
3082         if (!call->delayedAckEvent
3083             || clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
3084             rxevent_Cancel(call->delayedAckEvent, call,
3085                            RX_CALL_REFCOUNT_DELAY);
3086             CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
3087             call->delayedAckEvent =
3088                 rxevent_Post(&when, rxi_SendDelayedAck, call, 0);
3089         }
3090         /* we've damaged this call already, might as well do it in. */
3091         return np;
3092     }
3093 #endif /* KERNEL */
3094
3095     /*
3096      * New in AFS 3.5, if the RX_JUMBO_PACKET flag is set then this
3097      * packet is one of several packets transmitted as a single
3098      * datagram. Do not send any soft or hard acks until all packets
3099      * in a jumbogram have been processed. Send negative acks right away.
3100      */
3101     for (isFirst = 1, tnp = NULL; isFirst || tnp; isFirst = 0) {
3102         /* tnp is non-null when there are more packets in the
3103          * current jumbo gram */
3104         if (tnp) {
3105             if (np)
3106                 rxi_FreePacket(np);
3107             np = tnp;
3108         }
3109
3110         seq = np->header.seq;
3111         serial = np->header.serial;
3112         flags = np->header.flags;
3113
3114         /* If the call is in an error state, send an abort message */
3115         if (call->error)
3116             return rxi_SendCallAbort(call, np, istack, 0);
3117
3118         /* The RX_JUMBO_PACKET is set in all but the last packet in each
3119          * AFS 3.5 jumbogram. */
3120         if (flags & RX_JUMBO_PACKET) {
3121             tnp = rxi_SplitJumboPacket(np, host, port, isFirst);
3122         } else {
3123             tnp = NULL;
3124         }
3125
3126         if (np->header.spare != 0) {
3127             MUTEX_ENTER(&call->conn->conn_data_lock);
3128             call->conn->flags |= RX_CONN_USING_PACKET_CKSUM;
3129             MUTEX_EXIT(&call->conn->conn_data_lock);
3130         }
3131
3132         /* The usual case is that this is the expected next packet */
3133         if (seq == call->rnext) {
3134
3135             /* Check to make sure it is not a duplicate of one already queued */
3136             if (queue_IsNotEmpty(&call->rq)
3137                 && queue_First(&call->rq, rx_packet)->header.seq == seq) {
3138                 MUTEX_ENTER(&rx_stats_mutex);
3139                 rx_stats.dupPacketsRead++;
3140                 MUTEX_EXIT(&rx_stats_mutex);
3141                 dpf(("packet %x dropped on receipt - duplicate", np));
3142                 rxevent_Cancel(call->delayedAckEvent, call,
3143                                RX_CALL_REFCOUNT_DELAY);
3144                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3145                 ackNeeded = 0;
3146                 call->rprev = seq;
3147                 continue;
3148             }
3149
3150             /* It's the next packet. Stick it on the receive queue
3151              * for this call. Set newPackets to make sure we wake
3152              * the reader once all packets have been processed */
3153             queue_Prepend(&call->rq, np);
3154             call->nSoftAcks++;
3155             np = NULL;          /* We can't use this anymore */
3156             newPackets = 1;
3157
3158             /* If an ack is requested then set a flag to make sure we
3159              * send an acknowledgement for this packet */
3160             if (flags & RX_REQUEST_ACK) {
3161                 ackNeeded = RX_ACK_REQUESTED;
3162             }
3163
3164             /* Keep track of whether we have received the last packet */
3165             if (flags & RX_LAST_PACKET) {
3166                 call->flags |= RX_CALL_HAVE_LAST;
3167                 haveLast = 1;
3168             }
3169
3170             /* Check whether we have all of the packets for this call */
3171             if (call->flags & RX_CALL_HAVE_LAST) {
3172                 afs_uint32 tseq;        /* temporary sequence number */
3173                 struct rx_packet *tp;   /* Temporary packet pointer */
3174                 struct rx_packet *nxp;  /* Next pointer, for queue_Scan */
3175
3176                 for (tseq = seq, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3177                     if (tseq != tp->header.seq)
3178                         break;
3179                     if (tp->header.flags & RX_LAST_PACKET) {
3180                         call->flags |= RX_CALL_RECEIVE_DONE;
3181                         break;
3182                     }
3183                     tseq++;
3184                 }
3185             }
3186
3187             /* Provide asynchronous notification for those who want it
3188              * (e.g. multi rx) */
3189             if (call->arrivalProc) {
3190                 (*call->arrivalProc) (call, call->arrivalProcHandle,
3191                                       call->arrivalProcArg);
3192                 call->arrivalProc = (void (*)())0;
3193             }
3194
3195             /* Update last packet received */
3196             call->rprev = seq;
3197
3198             /* If there is no server process serving this call, grab
3199              * one, if available. We only need to do this once. If a
3200              * server thread is available, this thread becomes a server
3201              * thread and the server thread becomes a listener thread. */
3202             if (isFirst) {
3203                 TryAttach(call, socket, tnop, newcallp, 0);
3204             }
3205         }
3206         /* This is not the expected next packet. */
3207         else {
3208             /* Determine whether this is a new or old packet, and if it's
3209              * a new one, whether it fits into the current receive window.
3210              * Also figure out whether the packet was delivered in sequence.
3211              * We use the prev variable to determine whether the new packet
3212              * is the successor of its immediate predecessor in the
3213              * receive queue, and the missing flag to determine whether
3214              * any of this packets predecessors are missing.  */
3215
3216             afs_uint32 prev;    /* "Previous packet" sequence number */
3217             struct rx_packet *tp;       /* Temporary packet pointer */
3218             struct rx_packet *nxp;      /* Next pointer, for queue_Scan */
3219             int missing;        /* Are any predecessors missing? */
3220
3221             /* If the new packet's sequence number has been sent to the
3222              * application already, then this is a duplicate */
3223             if (seq < call->rnext) {
3224                 MUTEX_ENTER(&rx_stats_mutex);
3225                 rx_stats.dupPacketsRead++;
3226                 MUTEX_EXIT(&rx_stats_mutex);
3227                 rxevent_Cancel(call->delayedAckEvent, call,
3228                                RX_CALL_REFCOUNT_DELAY);
3229                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3230                 ackNeeded = 0;
3231                 call->rprev = seq;
3232                 continue;
3233             }
3234
3235             /* If the sequence number is greater than what can be
3236              * accomodated by the current window, then send a negative
3237              * acknowledge and drop the packet */
3238             if ((call->rnext + call->rwind) <= seq) {
3239                 rxevent_Cancel(call->delayedAckEvent, call,
3240                                RX_CALL_REFCOUNT_DELAY);
3241                 np = rxi_SendAck(call, np, serial, RX_ACK_EXCEEDS_WINDOW,
3242                                  istack);
3243                 ackNeeded = 0;
3244                 call->rprev = seq;
3245                 continue;
3246             }
3247
3248             /* Look for the packet in the queue of old received packets */
3249             for (prev = call->rnext - 1, missing =
3250                  0, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3251                 /*Check for duplicate packet */
3252                 if (seq == tp->header.seq) {
3253                     MUTEX_ENTER(&rx_stats_mutex);
3254                     rx_stats.dupPacketsRead++;
3255                     MUTEX_EXIT(&rx_stats_mutex);
3256                     rxevent_Cancel(call->delayedAckEvent, call,
3257                                    RX_CALL_REFCOUNT_DELAY);
3258                     np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE,
3259                                      istack);
3260                     ackNeeded = 0;
3261                     call->rprev = seq;
3262                     goto nextloop;
3263                 }
3264                 /* If we find a higher sequence packet, break out and
3265                  * insert the new packet here. */
3266                 if (seq < tp->header.seq)
3267                     break;
3268                 /* Check for missing packet */
3269                 if (tp->header.seq != prev + 1) {
3270                     missing = 1;
3271                 }
3272
3273                 prev = tp->header.seq;
3274             }
3275
3276             /* Keep track of whether we have received the last packet. */
3277             if (flags & RX_LAST_PACKET) {
3278                 call->flags |= RX_CALL_HAVE_LAST;
3279             }
3280
3281             /* It's within the window: add it to the the receive queue.
3282              * tp is left by the previous loop either pointing at the
3283              * packet before which to insert the new packet, or at the
3284              * queue head if the queue is empty or the packet should be
3285              * appended. */
3286             queue_InsertBefore(tp, np);
3287             call->nSoftAcks++;
3288             np = NULL;
3289
3290             /* Check whether we have all of the packets for this call */
3291             if ((call->flags & RX_CALL_HAVE_LAST)
3292                 && !(call->flags & RX_CALL_RECEIVE_DONE)) {
3293                 afs_uint32 tseq;        /* temporary sequence number */
3294
3295                 for (tseq =
3296                      call->rnext, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3297                     if (tseq != tp->header.seq)
3298                         break;
3299                     if (tp->header.flags & RX_LAST_PACKET) {
3300                         call->flags |= RX_CALL_RECEIVE_DONE;
3301                         break;
3302                     }
3303                     tseq++;
3304                 }
3305             }
3306
3307             /* We need to send an ack of the packet is out of sequence,
3308              * or if an ack was requested by the peer. */
3309             if (seq != prev + 1 || missing || (flags & RX_REQUEST_ACK)) {
3310                 ackNeeded = RX_ACK_OUT_OF_SEQUENCE;
3311             }
3312
3313             /* Acknowledge the last packet for each call */
3314             if (flags & RX_LAST_PACKET) {
3315                 haveLast = 1;
3316             }
3317
3318             call->rprev = seq;
3319         }
3320       nextloop:;
3321     }
3322
3323     if (newPackets) {
3324         /*
3325          * If the receiver is waiting for an iovec, fill the iovec
3326          * using the data from the receive queue */
3327         if (call->flags & RX_CALL_IOVEC_WAIT) {
3328             didHardAck = rxi_FillReadVec(call, serial);
3329             /* the call may have been aborted */
3330             if (call->error) {
3331                 return NULL;
3332             }
3333             if (didHardAck) {
3334                 ackNeeded = 0;
3335             }
3336         }
3337
3338         /* Wakeup the reader if any */
3339         if ((call->flags & RX_CALL_READER_WAIT)
3340             && (!(call->flags & RX_CALL_IOVEC_WAIT) || !(call->iovNBytes)
3341                 || (call->iovNext >= call->iovMax)
3342                 || (call->flags & RX_CALL_RECEIVE_DONE))) {
3343             call->flags &= ~RX_CALL_READER_WAIT;
3344 #ifdef  RX_ENABLE_LOCKS
3345             CV_BROADCAST(&call->cv_rq);
3346 #else
3347             osi_rxWakeup(&call->rq);
3348 #endif
3349         }
3350     }
3351
3352     /*
3353      * Send an ack when requested by the peer, or once every
3354      * rxi_SoftAckRate packets until the last packet has been
3355      * received. Always send a soft ack for the last packet in
3356      * the server's reply. */
3357     if (ackNeeded) {
3358         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3359         np = rxi_SendAck(call, np, serial, ackNeeded, istack);
3360     } else if (call->nSoftAcks > (u_short) rxi_SoftAckRate) {
3361         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3362         np = rxi_SendAck(call, np, serial, RX_ACK_IDLE, istack);
3363     } else if (call->nSoftAcks) {
3364         clock_GetTime(&when);
3365         if (haveLast && !(flags & RX_CLIENT_INITIATED)) {
3366             clock_Add(&when, &rx_lastAckDelay);
3367         } else {
3368             clock_Add(&when, &rx_softAckDelay);
3369         }
3370         if (!call->delayedAckEvent
3371             || clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
3372             rxevent_Cancel(call->delayedAckEvent, call,
3373                            RX_CALL_REFCOUNT_DELAY);
3374             CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
3375             call->delayedAckEvent =
3376                 rxevent_Post(&when, rxi_SendDelayedAck, call, 0);
3377         }
3378     } else if (call->flags & RX_CALL_RECEIVE_DONE) {
3379         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3380     }
3381
3382     return np;
3383 }
3384
3385 #ifdef  ADAPT_WINDOW
3386 static void rxi_ComputeRate();
3387 #endif
3388
3389 static void
3390 rxi_UpdatePeerReach(struct rx_connection *conn, struct rx_call *acall)
3391 {
3392     struct rx_peer *peer = conn->peer;
3393
3394     MUTEX_ENTER(&peer->peer_lock);
3395     peer->lastReachTime = clock_Sec();
3396     MUTEX_EXIT(&peer->peer_lock);
3397
3398     MUTEX_ENTER(&conn->conn_data_lock);
3399     if (conn->flags & RX_CONN_ATTACHWAIT) {
3400         int i;
3401
3402         conn->flags &= ~RX_CONN_ATTACHWAIT;
3403         MUTEX_EXIT(&conn->conn_data_lock);
3404
3405         for (i = 0; i < RX_MAXCALLS; i++) {
3406             struct rx_call *call = conn->call[i];
3407             if (call) {
3408                 if (call != acall)
3409                     MUTEX_ENTER(&call->lock);
3410                 /* tnop can be null if newcallp is null */
3411                 TryAttach(call, (osi_socket) - 1, NULL, NULL, 1);
3412                 if (call != acall)
3413                     MUTEX_EXIT(&call->lock);
3414             }
3415         }
3416     } else
3417         MUTEX_EXIT(&conn->conn_data_lock);
3418 }
3419
3420 /* rxi_ComputePeerNetStats
3421  *
3422  * Called exclusively by rxi_ReceiveAckPacket to compute network link
3423  * estimates (like RTT and throughput) based on ack packets.  Caller
3424  * must ensure that the packet in question is the right one (i.e.
3425  * serial number matches).
3426  */
3427 static void
3428 rxi_ComputePeerNetStats(struct rx_call *call, struct rx_packet *p,
3429                         struct rx_ackPacket *ap, struct rx_packet *np)
3430 {
3431     struct rx_peer *peer = call->conn->peer;
3432
3433     /* Use RTT if not delayed by client. */
3434     if (ap->reason != RX_ACK_DELAY)
3435         rxi_ComputeRoundTripTime(p, &p->timeSent, peer);
3436 #ifdef ADAPT_WINDOW
3437     rxi_ComputeRate(peer, call, p, np, ap->reason);
3438 #endif
3439 }
3440
3441 /* The real smarts of the whole thing.  */
3442 struct rx_packet *
3443 rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
3444                      int istack)
3445 {
3446     struct rx_ackPacket *ap;
3447     int nAcks;
3448     register struct rx_packet *tp;
3449     register struct rx_packet *nxp;     /* Next packet pointer for queue_Scan */
3450     register struct rx_connection *conn = call->conn;
3451     struct rx_peer *peer = conn->peer;
3452     afs_uint32 first;
3453     afs_uint32 serial;
3454     /* because there are CM's that are bogus, sending weird values for this. */
3455     afs_uint32 skew = 0;
3456     int nbytes;
3457     int missing;
3458     int acked;
3459     int nNacked = 0;
3460     int newAckCount = 0;
3461     u_short maxMTU = 0;         /* Set if peer supports AFS 3.4a jumbo datagrams */
3462     int maxDgramPackets = 0;    /* Set if peer supports AFS 3.5 jumbo datagrams */
3463
3464     MUTEX_ENTER(&rx_stats_mutex);
3465     rx_stats.ackPacketsRead++;
3466     MUTEX_EXIT(&rx_stats_mutex);
3467     ap = (struct rx_ackPacket *)rx_DataOf(np);
3468     nbytes = rx_Contiguous(np) - ((ap->acks) - (u_char *) ap);
3469     if (nbytes < 0)
3470         return np;              /* truncated ack packet */
3471
3472     /* depends on ack packet struct */
3473     nAcks = MIN((unsigned)nbytes, (unsigned)ap->nAcks);
3474     first = ntohl(ap->firstPacket);
3475     serial = ntohl(ap->serial);
3476     /* temporarily disabled -- needs to degrade over time
3477      * skew = ntohs(ap->maxSkew); */
3478
3479     /* Ignore ack packets received out of order */
3480     if (first < call->tfirst) {
3481         return np;
3482     }
3483
3484     if (np->header.flags & RX_SLOW_START_OK) {
3485         call->flags |= RX_CALL_SLOW_START_OK;
3486     }
3487
3488     if (ap->reason == RX_ACK_PING_RESPONSE)
3489         rxi_UpdatePeerReach(conn, call);
3490
3491 #ifdef RXDEBUG
3492     if (rx_Log) {
3493         fprintf(rx_Log,
3494                 "RACK: reason %x previous %u seq %u serial %u skew %d first %u",
3495                 ap->reason, ntohl(ap->previousPacket),
3496                 (unsigned int)np->header.seq, (unsigned int)serial,
3497                 (unsigned int)skew, ntohl(ap->firstPacket));
3498         if (nAcks) {
3499             int offset;
3500             for (offset = 0; offset < nAcks; offset++)
3501                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
3502                      rx_Log);
3503         }
3504         putc('\n', rx_Log);
3505     }
3506 #endif
3507
3508     /* Update the outgoing packet skew value to the latest value of
3509      * the peer's incoming packet skew value.  The ack packet, of
3510      * course, could arrive out of order, but that won't affect things
3511      * much */
3512     MUTEX_ENTER(&peer->peer_lock);
3513     peer->outPacketSkew = skew;
3514
3515     /* Check for packets that no longer need to be transmitted, and
3516      * discard them.  This only applies to packets positively
3517      * acknowledged as having been sent to the peer's upper level.
3518      * All other packets must be retained.  So only packets with
3519      * sequence numbers < ap->firstPacket are candidates. */
3520     for (queue_Scan(&call->tq, tp, nxp, rx_packet)) {
3521         if (tp->header.seq >= first)
3522             break;
3523         call->tfirst = tp->header.seq + 1;
3524         if (serial
3525             && (tp->header.serial == serial || tp->firstSerial == serial))
3526             rxi_ComputePeerNetStats(call, tp, ap, np);
3527 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3528         /* XXX Hack. Because we have to release the global rx lock when sending
3529          * packets (osi_NetSend) we drop all acks while we're traversing the tq
3530          * in rxi_Start sending packets out because packets may move to the
3531          * freePacketQueue as result of being here! So we drop these packets until
3532          * we're safely out of the traversing. Really ugly!
3533          * To make it even uglier, if we're using fine grain locking, we can
3534          * set the ack bits in the packets and have rxi_Start remove the packets
3535          * when it's done transmitting.
3536          */
3537         if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3538             newAckCount++;
3539         }
3540         if (call->flags & RX_CALL_TQ_BUSY) {
3541 #ifdef RX_ENABLE_LOCKS
3542             tp->flags |= RX_PKTFLAG_ACKED;
3543             call->flags |= RX_CALL_TQ_SOME_ACKED;
3544 #else /* RX_ENABLE_LOCKS */
3545             break;
3546 #endif /* RX_ENABLE_LOCKS */
3547         } else
3548 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3549         {
3550             queue_Remove(tp);
3551             rxi_FreePacket(tp); /* rxi_FreePacket mustn't wake up anyone, preemptively. */
3552         }
3553     }
3554
3555 #ifdef ADAPT_WINDOW
3556     /* Give rate detector a chance to respond to ping requests */
3557     if (ap->reason == RX_ACK_PING_RESPONSE) {
3558         rxi_ComputeRate(peer, call, 0, np, ap->reason);
3559     }
3560 #endif
3561
3562     /* N.B. we don't turn off any timers here.  They'll go away by themselves, anyway */
3563
3564     /* Now go through explicit acks/nacks and record the results in
3565      * the waiting packets.  These are packets that can't be released
3566      * yet, even with a positive acknowledge.  This positive
3567      * acknowledge only means the packet has been received by the
3568      * peer, not that it will be retained long enough to be sent to
3569      * the peer's upper level.  In addition, reset the transmit timers
3570      * of any missing packets (those packets that must be missing
3571      * because this packet was out of sequence) */
3572
3573     call->nSoftAcked = 0;
3574     for (missing = 0, queue_Scan(&call->tq, tp, nxp, rx_packet)) {
3575         /* Update round trip time if the ack was stimulated on receipt
3576          * of this packet */
3577 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
3578 #ifdef RX_ENABLE_LOCKS
3579         if (tp->header.seq >= first)
3580 #endif /* RX_ENABLE_LOCKS */
3581 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3582             if (serial
3583                 && (tp->header.serial == serial || tp->firstSerial == serial))
3584                 rxi_ComputePeerNetStats(call, tp, ap, np);
3585
3586         /* Set the acknowledge flag per packet based on the
3587          * information in the ack packet. An acknowlegded packet can
3588          * be downgraded when the server has discarded a packet it
3589          * soacked previously, or when an ack packet is received
3590          * out of sequence. */
3591         if (tp->header.seq < first) {
3592             /* Implicit ack information */
3593             if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3594                 newAckCount++;
3595             }
3596             tp->flags |= RX_PKTFLAG_ACKED;
3597         } else if (tp->header.seq < first + nAcks) {
3598             /* Explicit ack information:  set it in the packet appropriately */
3599             if (ap->acks[tp->header.seq - first] == RX_ACK_TYPE_ACK) {
3600                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3601                     newAckCount++;
3602                     tp->flags |= RX_PKTFLAG_ACKED;
3603                 }
3604                 if (missing) {
3605                     nNacked++;
3606                 } else {
3607                     call->nSoftAcked++;
3608                 }
3609             } else {
3610                 tp->flags &= ~RX_PKTFLAG_ACKED;
3611                 missing = 1;
3612             }
3613         } else {
3614             tp->flags &= ~RX_PKTFLAG_ACKED;
3615             missing = 1;
3616         }
3617
3618         /* If packet isn't yet acked, and it has been transmitted at least
3619          * once, reset retransmit time using latest timeout
3620          * ie, this should readjust the retransmit timer for all outstanding
3621          * packets...  So we don't just retransmit when we should know better*/
3622
3623         if (!(tp->flags & RX_PKTFLAG_ACKED) && !clock_IsZero(&tp->retryTime)) {
3624             tp->retryTime = tp->timeSent;
3625             clock_Add(&tp->retryTime, &peer->timeout);
3626             /* shift by eight because one quarter-sec ~ 256 milliseconds */
3627             clock_Addmsec(&(tp->retryTime), ((afs_uint32) tp->backoff) << 8);
3628         }
3629     }
3630
3631     /* If the window has been extended by this acknowledge packet,
3632      * then wakeup a sender waiting in alloc for window space, or try
3633      * sending packets now, if he's been sitting on packets due to
3634      * lack of window space */
3635     if (call->tnext < (call->tfirst + call->twind)) {
3636 #ifdef  RX_ENABLE_LOCKS
3637         CV_SIGNAL(&call->cv_twind);
3638 #else
3639         if (call->flags & RX_CALL_WAIT_WINDOW_ALLOC) {
3640             call->flags &= ~RX_CALL_WAIT_WINDOW_ALLOC;
3641             osi_rxWakeup(&call->twind);
3642         }
3643 #endif
3644         if (call->flags & RX_CALL_WAIT_WINDOW_SEND) {
3645             call->flags &= ~RX_CALL_WAIT_WINDOW_SEND;
3646         }
3647     }
3648
3649     /* if the ack packet has a receivelen field hanging off it,
3650      * update our state */
3651     if (np->length >= rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32)) {
3652         afs_uint32 tSize;
3653
3654         /* If the ack packet has a "recommended" size that is less than
3655          * what I am using now, reduce my size to match */
3656         rx_packetread(np, rx_AckDataSize(ap->nAcks) + sizeof(afs_int32),
3657                       sizeof(afs_int32), &tSize);
3658         tSize = (afs_uint32) ntohl(tSize);
3659         peer->natMTU = rxi_AdjustIfMTU(MIN(tSize, peer->ifMTU));
3660
3661         /* Get the maximum packet size to send to this peer */
3662         rx_packetread(np, rx_AckDataSize(ap->nAcks), sizeof(afs_int32),
3663                       &tSize);
3664         tSize = (afs_uint32) ntohl(tSize);
3665         tSize = (afs_uint32) MIN(tSize, rx_MyMaxSendSize);
3666         tSize = rxi_AdjustMaxMTU(peer->natMTU, tSize);
3667
3668         /* sanity check - peer might have restarted with different params.
3669          * If peer says "send less", dammit, send less...  Peer should never
3670          * be unable to accept packets of the size that prior AFS versions would
3671          * send without asking.  */
3672         if (peer->maxMTU != tSize) {
3673             peer->maxMTU = tSize;
3674             peer->MTU = MIN(tSize, peer->MTU);
3675             call->MTU = MIN(call->MTU, tSize);
3676             peer->congestSeq++;
3677         }
3678
3679         if (np->length == rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32)) {
3680             /* AFS 3.4a */
3681             rx_packetread(np,
3682                           rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
3683                           sizeof(afs_int32), &tSize);
3684             tSize = (afs_uint32) ntohl(tSize);  /* peer's receive window, if it's */
3685             if (tSize < call->twind) {  /* smaller than our send */
3686                 call->twind = tSize;    /* window, we must send less... */
3687                 call->ssthresh = MIN(call->twind, call->ssthresh);
3688             }
3689
3690             /* Only send jumbograms to 3.4a fileservers. 3.3a RX gets the
3691              * network MTU confused with the loopback MTU. Calculate the
3692              * maximum MTU here for use in the slow start code below.
3693              */
3694             maxMTU = peer->maxMTU;
3695             /* Did peer restart with older RX version? */
3696             if (peer->maxDgramPackets > 1) {
3697                 peer->maxDgramPackets = 1;
3698             }
3699         } else if (np->length >=
3700                    rx_AckDataSize(ap->nAcks) + 4 * sizeof(afs_int32)) {
3701             /* AFS 3.5 */
3702             rx_packetread(np,
3703                           rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
3704                           sizeof(afs_int32), &tSize);
3705             tSize = (afs_uint32) ntohl(tSize);
3706             /*
3707              * As of AFS 3.5 we set the send window to match the receive window.
3708              */
3709             if (tSize < call->twind) {
3710                 call->twind = tSize;
3711                 call->ssthresh = MIN(call->twind, call->ssthresh);
3712             } else if (tSize > call->twind) {
3713                 call->twind = tSize;
3714             }
3715
3716             /*
3717              * As of AFS 3.5, a jumbogram is more than one fixed size
3718              * packet transmitted in a single UDP datagram. If the remote
3719              * MTU is smaller than our local MTU then never send a datagram
3720              * larger than the natural MTU.
3721              */
3722             rx_packetread(np,
3723                           rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32),
3724                           sizeof(afs_int32), &tSize);
3725             maxDgramPackets = (afs_uint32) ntohl(tSize);
3726             maxDgramPackets = MIN(maxDgramPackets, rxi_nDgramPackets);
3727             maxDgramPackets =
3728                 MIN(maxDgramPackets, (int)(peer->ifDgramPackets));
3729             maxDgramPackets = MIN(maxDgramPackets, tSize);
3730             if (maxDgramPackets > 1) {
3731                 peer->maxDgramPackets = maxDgramPackets;
3732                 call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
3733             } else {
3734                 peer->maxDgramPackets = 1;
3735                 call->MTU = peer->natMTU;
3736             }
3737         } else if (peer->maxDgramPackets > 1) {
3738             /* Restarted with lower version of RX */
3739             peer->maxDgramPackets = 1;
3740         }
3741     } else if (peer->maxDgramPackets > 1
3742                || peer->maxMTU != OLD_MAX_PACKET_SIZE) {
3743         /* Restarted with lower version of RX */
3744         peer->maxMTU = OLD_MAX_PACKET_SIZE;
3745         peer->natMTU = OLD_MAX_PACKET_SIZE;
3746         peer->MTU = OLD_MAX_PACKET_SIZE;
3747         peer->maxDgramPackets = 1;
3748         peer->nDgramPackets = 1;
3749         peer->congestSeq++;
3750         call->MTU = OLD_MAX_PACKET_SIZE;
3751     }
3752
3753     if (nNacked) {
3754         /*
3755          * Calculate how many datagrams were successfully received after
3756          * the first missing packet and adjust the negative ack counter
3757          * accordingly.
3758          */
3759         call->nAcks = 0;
3760         call->nNacks++;
3761         nNacked = (nNacked + call->nDgramPackets - 1) / call->nDgramPackets;
3762         if (call->nNacks < nNacked) {
3763             call->nNacks = nNacked;
3764         }
3765     } else {
3766         if (newAckCount) {
3767             call->nAcks++;
3768         }
3769         call->nNacks = 0;
3770     }
3771
3772     if (call->flags & RX_CALL_FAST_RECOVER) {
3773         if (nNacked) {
3774             call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
3775         } else {
3776             call->flags &= ~RX_CALL_FAST_RECOVER;
3777             call->cwind = call->nextCwind;
3778             call->nextCwind = 0;
3779             call->nAcks = 0;
3780         }
3781         call->nCwindAcks = 0;
3782     } else if (nNacked && call->nNacks >= (u_short) rx_nackThreshold) {
3783         /* Three negative acks in a row trigger congestion recovery */
3784 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3785         MUTEX_EXIT(&peer->peer_lock);
3786         if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
3787             /* someone else is waiting to start recovery */
3788             return np;
3789         }
3790         call->flags |= RX_CALL_FAST_RECOVER_WAIT;
3791         while (call->flags & RX_CALL_TQ_BUSY) {
3792             call->flags |= RX_CALL_TQ_WAIT;
3793 #ifdef RX_ENABLE_LOCKS
3794             CV_WAIT(&call->cv_tq, &call->lock);
3795 #else /* RX_ENABLE_LOCKS */
3796             osi_rxSleep(&call->tq);
3797 #endif /* RX_ENABLE_LOCKS */
3798         }
3799         MUTEX_ENTER(&peer->peer_lock);
3800 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3801         call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
3802         call->flags |= RX_CALL_FAST_RECOVER;
3803         call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
3804         call->cwind =
3805             MIN((int)(call->ssthresh + rx_nackThreshold), rx_maxSendWindow);
3806         call->nDgramPackets = MAX(2, (int)call->nDgramPackets) >> 1;
3807         call->nextCwind = call->ssthresh;
3808         call->nAcks = 0;
3809         call->nNacks = 0;
3810         peer->MTU = call->MTU;
3811         peer->cwind = call->nextCwind;
3812         peer->nDgramPackets = call->nDgramPackets;
3813         peer->congestSeq++;
3814         call->congestSeq = peer->congestSeq;
3815         /* Reset the resend times on the packets that were nacked
3816          * so we will retransmit as soon as the window permits*/
3817         for (acked = 0, queue_ScanBackwards(&call->tq, tp, nxp, rx_packet)) {
3818             if (acked) {
3819                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3820                     clock_Zero(&tp->retryTime);
3821                 }
3822             } else if (tp->flags & RX_PKTFLAG_ACKED) {
3823                 acked = 1;
3824             }
3825         }
3826     } else {
3827         /* If cwind is smaller than ssthresh, then increase
3828          * the window one packet for each ack we receive (exponential
3829          * growth).
3830          * If cwind is greater than or equal to ssthresh then increase
3831          * the congestion window by one packet for each cwind acks we
3832          * receive (linear growth).  */
3833         if (call->cwind < call->ssthresh) {
3834             call->cwind =
3835                 MIN((int)call->ssthresh, (int)(call->cwind + newAckCount));
3836             call->nCwindAcks = 0;
3837         } else {
3838             call->nCwindAcks += newAckCount;
3839             if (call->nCwindAcks >= call->cwind) {
3840                 call->nCwindAcks = 0;
3841                 call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
3842             }
3843         }
3844         /*
3845          * If we have received several acknowledgements in a row then
3846          * it is time to increase the size of our datagrams
3847          */
3848         if ((int)call->nAcks > rx_nDgramThreshold) {
3849             if (peer->maxDgramPackets > 1) {
3850                 if (call->nDgramPackets < peer->maxDgramPackets) {
3851                     call->nDgramPackets++;
3852                 }
3853                 call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
3854             } else if (call->MTU < peer->maxMTU) {
3855                 call->MTU += peer->natMTU;
3856                 call->MTU = MIN(call->MTU, peer->maxMTU);
3857             }
3858             call->nAcks = 0;
3859         }
3860     }
3861
3862     MUTEX_EXIT(&peer->peer_lock);       /* rxi_Start will lock peer. */
3863
3864     /* Servers need to hold the call until all response packets have
3865      * been acknowledged. Soft acks are good enough since clients
3866      * are not allowed to clear their receive queues. */
3867     if (call->state == RX_STATE_HOLD
3868         && call->tfirst + call->nSoftAcked >= call->tnext) {
3869         call->state = RX_STATE_DALLY;
3870         rxi_ClearTransmitQueue(call, 0);
3871     } else if (!queue_IsEmpty(&call->tq)) {
3872         rxi_Start(0, call, 0, istack);
3873     }
3874     return np;
3875 }
3876
3877 /* Received a response to a challenge packet */
3878 struct rx_packet *
3879 rxi_ReceiveResponsePacket(register struct rx_connection *conn,
3880                           register struct rx_packet *np, int istack)
3881 {
3882     int error;
3883
3884     /* Ignore the packet if we're the client */
3885     if (conn->type == RX_CLIENT_CONNECTION)
3886         return np;
3887
3888     /* If already authenticated, ignore the packet (it's probably a retry) */
3889     if (RXS_CheckAuthentication(conn->securityObject, conn) == 0)
3890         return np;
3891
3892     /* Otherwise, have the security object evaluate the response packet */
3893     error = RXS_CheckResponse(conn->securityObject, conn, np);
3894     if (error) {
3895         /* If the response is invalid, reset the connection, sending
3896          * an abort to the peer */
3897 #ifndef KERNEL
3898         rxi_Delay(1);
3899 #endif
3900         rxi_ConnectionError(conn, error);
3901         MUTEX_ENTER(&conn->conn_data_lock);
3902         np = rxi_SendConnectionAbort(conn, np, istack, 0);
3903         MUTEX_EXIT(&conn->conn_data_lock);
3904         return np;
3905     } else {
3906         /* If the response is valid, any calls waiting to attach
3907          * servers can now do so */
3908         int i;
3909
3910         for (i = 0; i < RX_MAXCALLS; i++) {
3911             struct rx_call *call = conn->call[i];
3912             if (call) {
3913                 MUTEX_ENTER(&call->lock);
3914                 if (call->state == RX_STATE_PRECALL)
3915                     rxi_AttachServerProc(call, (osi_socket) - 1, NULL, NULL);
3916                 /* tnop can be null if newcallp is null */
3917                 MUTEX_EXIT(&call->lock);
3918             }
3919         }
3920
3921         /* Update the peer reachability information, just in case
3922          * some calls went into attach-wait while we were waiting
3923          * for authentication..
3924          */
3925         rxi_UpdatePeerReach(conn, NULL);
3926     }
3927     return np;
3928 }
3929
3930 /* A client has received an authentication challenge: the security
3931  * object is asked to cough up a respectable response packet to send
3932  * back to the server.  The server is responsible for retrying the
3933  * challenge if it fails to get a response. */
3934
3935 struct rx_packet *
3936 rxi_ReceiveChallengePacket(register struct rx_connection *conn,
3937                            register struct rx_packet *np, int istack)
3938 {
3939     int error;
3940
3941     /* Ignore the challenge if we're the server */
3942     if (conn->type == RX_SERVER_CONNECTION)
3943         return np;
3944
3945     /* Ignore the challenge if the connection is otherwise idle; someone's
3946      * trying to use us as an oracle. */
3947     if (!rxi_HasActiveCalls(conn))
3948         return np;
3949
3950     /* Send the security object the challenge packet.  It is expected to fill
3951      * in the response. */
3952     error = RXS_GetResponse(conn->securityObject, conn, np);
3953
3954     /* If the security object is unable to return a valid response, reset the
3955      * connection and send an abort to the peer.  Otherwise send the response
3956      * packet to the peer connection. */
3957     if (error) {
3958         rxi_ConnectionError(conn, error);
3959         MUTEX_ENTER(&conn->conn_data_lock);
3960         np = rxi_SendConnectionAbort(conn, np, istack, 0);
3961         MUTEX_EXIT(&conn->conn_data_lock);
3962     } else {
3963         np = rxi_SendSpecial((struct rx_call *)0, conn, np,
3964                              RX_PACKET_TYPE_RESPONSE, NULL, -1, istack);
3965     }
3966     return np;
3967 }
3968
3969
3970 /* Find an available server process to service the current request in
3971  * the given call structure.  If one isn't available, queue up this
3972  * call so it eventually gets one */
3973 void
3974 rxi_AttachServerProc(register struct rx_call *call,
3975                      register osi_socket socket, register int *tnop,
3976                      register struct rx_call **newcallp)
3977 {
3978     register struct rx_serverQueueEntry *sq;
3979     register struct rx_service *service = call->conn->service;
3980     register int haveQuota = 0;
3981
3982     /* May already be attached */
3983     if (call->state == RX_STATE_ACTIVE)
3984         return;
3985
3986     MUTEX_ENTER(&rx_serverPool_lock);
3987
3988     haveQuota = QuotaOK(service);
3989     if ((!haveQuota) || queue_IsEmpty(&rx_idleServerQueue)) {
3990         /* If there are no processes available to service this call,
3991          * put the call on the incoming call queue (unless it's
3992          * already on the queue).
3993          */
3994 #ifdef RX_ENABLE_LOCKS
3995         if (haveQuota)
3996             ReturnToServerPool(service);
3997 #endif /* RX_ENABLE_LOCKS */
3998
3999         if (!(call->flags & RX_CALL_WAIT_PROC)) {
4000             call->flags |= RX_CALL_WAIT_PROC;
4001             MUTEX_ENTER(&rx_stats_mutex);
4002             rx_nWaiting++;
4003             rx_nWaited++;
4004             MUTEX_EXIT(&rx_stats_mutex);
4005             rxi_calltrace(RX_CALL_ARRIVAL, call);
4006             SET_CALL_QUEUE_LOCK(call, &rx_serverPool_lock);
4007             queue_Append(&rx_incomingCallQueue, call);
4008         }
4009     } else {
4010         sq = queue_First(&rx_idleServerQueue, rx_serverQueueEntry);
4011
4012         /* If hot threads are enabled, and both newcallp and sq->socketp
4013          * are non-null, then this thread will process the call, and the
4014          * idle server thread will start listening on this threads socket.
4015          */
4016         queue_Remove(sq);
4017         if (rx_enable_hot_thread && newcallp && sq->socketp) {
4018             *newcallp = call;
4019             *tnop = sq->tno;
4020             *sq->socketp = socket;
4021             clock_GetTime(&call->startTime);
4022             CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
4023         } else {
4024             sq->newcall = call;
4025         }
4026         if (call->flags & RX_CALL_WAIT_PROC) {
4027             /* Conservative:  I don't think this should happen */
4028             call->flags &= ~RX_CALL_WAIT_PROC;
4029             if (queue_IsOnQueue(call)) {
4030                 queue_Remove(call);
4031                 MUTEX_ENTER(&rx_stats_mutex);
4032                 rx_nWaiting--;
4033                 MUTEX_EXIT(&rx_stats_mutex);
4034             }
4035         }
4036         call->state = RX_STATE_ACTIVE;
4037         call->mode = RX_MODE_RECEIVING;
4038 #ifdef RX_KERNEL_TRACE
4039         {
4040             int glockOwner = ISAFS_GLOCK();
4041             if (!glockOwner)
4042                 AFS_GLOCK();
4043             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
4044                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
4045                        call);
4046             if (!glockOwner)
4047                 AFS_GUNLOCK();
4048         }
4049 #endif
4050         if (call->flags & RX_CALL_CLEARED) {
4051             /* send an ack now to start the packet flow up again */
4052             call->flags &= ~RX_CALL_CLEARED;
4053             rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4054         }
4055 #ifdef  RX_ENABLE_LOCKS
4056         CV_SIGNAL(&sq->cv);
4057 #else
4058         service->nRequestsRunning++;
4059         if (service->nRequestsRunning <= service->minProcs)
4060             rxi_minDeficit--;
4061         rxi_availProcs--;
4062         osi_rxWakeup(sq);
4063 #endif
4064     }
4065     MUTEX_EXIT(&rx_serverPool_lock);
4066 }
4067
4068 /* Delay the sending of an acknowledge event for a short while, while
4069  * a new call is being prepared (in the case of a client) or a reply
4070  * is being prepared (in the case of a server).  Rather than sending
4071  * an ack packet, an ACKALL packet is sent. */
4072 void
4073 rxi_AckAll(struct rxevent *event, register struct rx_call *call, char *dummy)
4074 {
4075 #ifdef RX_ENABLE_LOCKS
4076     if (event) {
4077         MUTEX_ENTER(&call->lock);
4078         call->delayedAckEvent = NULL;
4079         CALL_RELE(call, RX_CALL_REFCOUNT_ACKALL);
4080     }
4081     rxi_SendSpecial(call, call->conn, (struct rx_packet *)0,
4082                     RX_PACKET_TYPE_ACKALL, NULL, 0, 0);
4083     if (event)
4084         MUTEX_EXIT(&call->lock);
4085 #else /* RX_ENABLE_LOCKS */
4086     if (event)
4087         call->delayedAckEvent = NULL;
4088     rxi_SendSpecial(call, call->conn, (struct rx_packet *)0,
4089                     RX_PACKET_TYPE_ACKALL, NULL, 0, 0);
4090 #endif /* RX_ENABLE_LOCKS */
4091 }
4092
4093 void
4094 rxi_SendDelayedAck(struct rxevent *event, register struct rx_call *call,
4095                    char *dummy)
4096 {
4097 #ifdef RX_ENABLE_LOCKS
4098     if (event) {
4099         MUTEX_ENTER(&call->lock);
4100         if (event == call->delayedAckEvent)
4101             call->delayedAckEvent = NULL;
4102         CALL_RELE(call, RX_CALL_REFCOUNT_DELAY);
4103     }
4104     (void)rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4105     if (event)
4106         MUTEX_EXIT(&call->lock);
4107 #else /* RX_ENABLE_LOCKS */
4108     if (event)
4109         call->delayedAckEvent = NULL;
4110     (void)rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4111 #endif /* RX_ENABLE_LOCKS */
4112 }
4113
4114
4115 #ifdef RX_ENABLE_LOCKS
4116 /* Set ack in all packets in transmit queue. rxi_Start will deal with
4117  * clearing them out.
4118  */
4119 static void
4120 rxi_SetAcksInTransmitQueue(register struct rx_call *call)
4121 {
4122     register struct rx_packet *p, *tp;
4123     int someAcked = 0;
4124
4125     for (queue_Scan(&call->tq, p, tp, rx_packet)) {
4126         if (!p)
4127             break;
4128         p->flags |= RX_PKTFLAG_ACKED;
4129         someAcked = 1;
4130     }
4131     if (someAcked) {
4132         call->flags |= RX_CALL_TQ_CLEARME;
4133         call->flags |= RX_CALL_TQ_SOME_ACKED;
4134     }
4135
4136     rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
4137     rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
4138     call->tfirst = call->tnext;
4139     call->nSoftAcked = 0;
4140
4141     if (call->flags & RX_CALL_FAST_RECOVER) {
4142         call->flags &= ~RX_CALL_FAST_RECOVER;
4143         call->cwind = call->nextCwind;
4144         call->nextCwind = 0;
4145     }
4146
4147     CV_SIGNAL(&call->cv_twind);
4148 }
4149 #endif /* RX_ENABLE_LOCKS */
4150
4151 /* Clear out the transmit queue for the current call (all packets have
4152  * been received by peer) */
4153 void
4154 rxi_ClearTransmitQueue(register struct rx_call *call, register int force)
4155 {
4156     register struct rx_packet *p, *tp;
4157
4158 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4159     if (!force && (call->flags & RX_CALL_TQ_BUSY)) {
4160         int someAcked = 0;
4161         for (queue_Scan(&call->tq, p, tp, rx_packet)) {
4162             if (!p)
4163                 break;
4164             p->flags |= RX_PKTFLAG_ACKED;
4165             someAcked = 1;
4166         }
4167         if (someAcked) {
4168             call->flags |= RX_CALL_TQ_CLEARME;
4169             call->flags |= RX_CALL_TQ_SOME_ACKED;
4170         }
4171     } else {
4172 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4173         for (queue_Scan(&call->tq, p, tp, rx_packet)) {
4174             if (!p)
4175                 break;
4176             queue_Remove(p);
4177             rxi_FreePacket(p);
4178         }
4179 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4180         call->flags &= ~RX_CALL_TQ_CLEARME;
4181     }
4182 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4183
4184     rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
4185     rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
4186     call->tfirst = call->tnext; /* implicitly acknowledge all data already sent */
4187     call->nSoftAcked = 0;
4188
4189     if (call->flags & RX_CALL_FAST_RECOVER) {
4190         call->flags &= ~RX_CALL_FAST_RECOVER;
4191         call->cwind = call->nextCwind;
4192     }
4193 #ifdef  RX_ENABLE_LOCKS
4194     CV_SIGNAL(&call->cv_twind);
4195 #else
4196     osi_rxWakeup(&call->twind);
4197 #endif
4198 }
4199
4200 void
4201 rxi_ClearReceiveQueue(register struct rx_call *call)
4202 {
4203     register struct rx_packet *p, *tp;
4204     if (queue_IsNotEmpty(&call->rq)) {
4205         for (queue_Scan(&call->rq, p, tp, rx_packet)) {
4206             if (!p)
4207                 break;
4208             queue_Remove(p);
4209             rxi_FreePacket(p);
4210             rx_packetReclaims++;
4211         }
4212         call->flags &= ~(RX_CALL_RECEIVE_DONE | RX_CALL_HAVE_LAST);
4213     }
4214     if (call->state == RX_STATE_PRECALL) {
4215         call->flags |= RX_CALL_CLEARED;
4216     }
4217 }
4218
4219 /* Send an abort packet for the specified call */
4220 struct rx_packet *
4221 rxi_SendCallAbort(register struct rx_call *call, struct rx_packet *packet,
4222                   int istack, int force)
4223 {
4224     afs_int32 error;
4225     struct clock when;
4226
4227     if (!call->error)
4228         return packet;
4229
4230     /* Clients should never delay abort messages */
4231     if (rx_IsClientConn(call->conn))
4232         force = 1;
4233
4234     if (call->abortCode != call->error) {
4235         call->abortCode = call->error;
4236         call->abortCount = 0;
4237     }
4238
4239     if (force || rxi_callAbortThreshhold == 0
4240         || call->abortCount < rxi_callAbortThreshhold) {
4241         if (call->delayedAbortEvent) {
4242             rxevent_Cancel(call->delayedAbortEvent, call,
4243                            RX_CALL_REFCOUNT_ABORT);
4244         }
4245         error = htonl(call->error);
4246         call->abortCount++;
4247         packet =
4248             rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
4249                             (char *)&error, sizeof(error), istack);
4250     } else if (!call->delayedAbortEvent) {
4251         clock_GetTime(&when);
4252         clock_Addmsec(&when, rxi_callAbortDelay);
4253         CALL_HOLD(call, RX_CALL_REFCOUNT_ABORT);
4254         call->delayedAbortEvent =
4255             rxevent_Post(&when, rxi_SendDelayedCallAbort, call, 0);
4256     }
4257     return packet;
4258 }
4259
4260 /* Send an abort packet for the specified connection.  Packet is an
4261  * optional pointer to a packet that can be used to send the abort.
4262  * Once the number of abort messages reaches the threshhold, an
4263  * event is scheduled to send the abort. Setting the force flag
4264  * overrides sending delayed abort messages.
4265  *
4266  * NOTE: Called with conn_data_lock held. conn_data_lock is dropped
4267  *       to send the abort packet.
4268  */
4269 struct rx_packet *
4270 rxi_SendConnectionAbort(register struct rx_connection *conn,
4271                         struct rx_packet *packet, int istack, int force)
4272 {
4273     afs_int32 error;
4274     struct clock when;
4275
4276     if (!conn->error)
4277         return packet;
4278
4279     /* Clients should never delay abort messages */
4280     if (rx_IsClientConn(conn))
4281         force = 1;
4282
4283     if (force || rxi_connAbortThreshhold == 0
4284         || conn->abortCount < rxi_connAbortThreshhold) {
4285         if (conn->delayedAbortEvent) {
4286             rxevent_Cancel(conn->delayedAbortEvent, (struct rx_call *)0, 0);
4287         }
4288         error = htonl(conn->error);
4289         conn->abortCount++;
4290         MUTEX_EXIT(&conn->conn_data_lock);
4291         packet =
4292             rxi_SendSpecial((struct rx_call *)0, conn, packet,
4293                             RX_PACKET_TYPE_ABORT, (char *)&error,
4294                             sizeof(error), istack);
4295         MUTEX_ENTER(&conn->conn_data_lock);
4296     } else if (!conn->delayedAbortEvent) {
4297         clock_GetTime(&when);
4298         clock_Addmsec(&when, rxi_connAbortDelay);
4299         conn->delayedAbortEvent =
4300             rxevent_Post(&when, rxi_SendDelayedConnAbort, conn, 0);
4301     }
4302     return packet;
4303 }
4304
4305 /* Associate an error all of the calls owned by a connection.  Called
4306  * with error non-zero.  This is only for really fatal things, like
4307  * bad authentication responses.  The connection itself is set in
4308  * error at this point, so that future packets received will be
4309  * rejected. */
4310 void
4311 rxi_ConnectionError(register struct rx_connection *conn,
4312                     register afs_int32 error)
4313 {
4314     if (error) {
4315         register int i;
4316         MUTEX_ENTER(&conn->conn_data_lock);
4317         if (conn->challengeEvent)
4318             rxevent_Cancel(conn->challengeEvent, (struct rx_call *)0, 0);
4319         if (conn->checkReachEvent) {
4320             rxevent_Cancel(conn->checkReachEvent, (struct rx_call *)0, 0);
4321             conn->checkReachEvent = 0;
4322             conn->flags &= ~RX_CONN_ATTACHWAIT;
4323             conn->refCount--;
4324         }
4325         MUTEX_EXIT(&conn->conn_data_lock);
4326         for (i = 0; i < RX_MAXCALLS; i++) {
4327             struct rx_call *call = conn->call[i];
4328             if (call) {
4329                 MUTEX_ENTER(&call->lock);
4330                 rxi_CallError(call, error);
4331                 MUTEX_EXIT(&call->lock);
4332             }
4333         }
4334         conn->error = error;
4335         MUTEX_ENTER(&rx_stats_mutex);
4336         rx_stats.fatalErrors++;
4337         MUTEX_EXIT(&rx_stats_mutex);
4338     }
4339 }
4340
4341 void
4342 rxi_CallError(register struct rx_call *call, afs_int32 error)
4343 {
4344     if (call->error)
4345         error = call->error;
4346 #ifdef RX_GLOBAL_RXLOCK_KERNEL
4347     if (!(call->flags & RX_CALL_TQ_BUSY)) {
4348         rxi_ResetCall(call, 0);
4349     }
4350 #else
4351     rxi_ResetCall(call, 0);
4352 #endif
4353     call->error = error;
4354     call->mode = RX_MODE_ERROR;
4355 }
4356
4357 /* Reset various fields in a call structure, and wakeup waiting
4358  * processes.  Some fields aren't changed: state & mode are not
4359  * touched (these must be set by the caller), and bufptr, nLeft, and
4360  * nFree are not reset, since these fields are manipulated by
4361  * unprotected macros, and may only be reset by non-interrupting code.
4362  */
4363 #ifdef ADAPT_WINDOW
4364 /* this code requires that call->conn be set properly as a pre-condition. */
4365 #endif /* ADAPT_WINDOW */
4366
4367 void
4368 rxi_ResetCall(register struct rx_call *call, register int newcall)
4369 {
4370     register int flags;
4371     register struct rx_peer *peer;
4372     struct rx_packet *packet;
4373
4374     /* Notify anyone who is waiting for asynchronous packet arrival */
4375     if (call->arrivalProc) {
4376         (*call->arrivalProc) (call, call->arrivalProcHandle,
4377                               call->arrivalProcArg);
4378         call->arrivalProc = (void (*)())0;
4379     }
4380
4381     if (call->delayedAbortEvent) {
4382         rxevent_Cancel(call->delayedAbortEvent, call, RX_CALL_REFCOUNT_ABORT);
4383         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
4384         if (packet) {
4385             rxi_SendCallAbort(call, packet, 0, 1);
4386             rxi_FreePacket(packet);
4387         }
4388     }
4389
4390     /*
4391      * Update the peer with the congestion information in this call
4392      * so other calls on this connection can pick up where this call
4393      * left off. If the congestion sequence numbers don't match then
4394      * another call experienced a retransmission.
4395      */
4396     peer = call->conn->peer;
4397     MUTEX_ENTER(&peer->peer_lock);
4398     if (!newcall) {
4399         if (call->congestSeq == peer->congestSeq) {
4400             peer->cwind = MAX(peer->cwind, call->cwind);
4401             peer->MTU = MAX(peer->MTU, call->MTU);
4402             peer->nDgramPackets =
4403                 MAX(peer->nDgramPackets, call->nDgramPackets);
4404         }
4405     } else {
4406         call->abortCode = 0;
4407         call->abortCount = 0;
4408     }
4409     if (peer->maxDgramPackets > 1) {
4410         call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
4411     } else {
4412         call->MTU = peer->MTU;
4413     }
4414     call->cwind = MIN((int)peer->cwind, (int)peer->nDgramPackets);
4415     call->ssthresh = rx_maxSendWindow;
4416     call->nDgramPackets = peer->nDgramPackets;
4417     call->congestSeq = peer->congestSeq;
4418     MUTEX_EXIT(&peer->peer_lock);
4419
4420     flags = call->flags;
4421     rxi_ClearReceiveQueue(call);
4422 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4423     if (call->flags & RX_CALL_TQ_BUSY) {
4424         call->flags = RX_CALL_TQ_CLEARME | RX_CALL_TQ_BUSY;
4425         call->flags |= (flags & RX_CALL_TQ_WAIT);
4426     } else
4427 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4428     {
4429         rxi_ClearTransmitQueue(call, 0);
4430         queue_Init(&call->tq);
4431         call->flags = 0;
4432     }
4433     queue_Init(&call->rq);
4434     call->error = 0;
4435     call->rwind = rx_initReceiveWindow;
4436     call->twind = rx_initSendWindow;
4437     call->nSoftAcked = 0;
4438     call->nextCwind = 0;
4439     call->nAcks = 0;
4440     call->nNacks = 0;
4441     call->nCwindAcks = 0;
4442     call->nSoftAcks = 0;
4443     call->nHardAcks = 0;
4444
4445     call->tfirst = call->rnext = call->tnext = 1;
4446     call->rprev = 0;
4447     call->lastAcked = 0;
4448     call->localStatus = call->remoteStatus = 0;
4449
4450     if (flags & RX_CALL_READER_WAIT) {
4451 #ifdef  RX_ENABLE_LOCKS
4452         CV_BROADCAST(&call->cv_rq);
4453 #else
4454         osi_rxWakeup(&call->rq);
4455 #endif
4456     }
4457     if (flags & RX_CALL_WAIT_PACKETS) {
4458         MUTEX_ENTER(&rx_freePktQ_lock);
4459         rxi_PacketsUnWait();    /* XXX */
4460         MUTEX_EXIT(&rx_freePktQ_lock);
4461     }
4462 #ifdef  RX_ENABLE_LOCKS
4463     CV_SIGNAL(&call->cv_twind);
4464 #else
4465     if (flags & RX_CALL_WAIT_WINDOW_ALLOC)
4466         osi_rxWakeup(&call->twind);
4467 #endif
4468
4469 #ifdef RX_ENABLE_LOCKS
4470     /* The following ensures that we don't mess with any queue while some
4471      * other thread might also be doing so. The call_queue_lock field is
4472      * is only modified under the call lock. If the call is in the process
4473      * of being removed from a queue, the call is not locked until the
4474      * the queue lock is dropped and only then is the call_queue_lock field
4475      * zero'd out. So it's safe to lock the queue if call_queue_lock is set.
4476      * Note that any other routine which removes a call from a queue has to
4477      * obtain the queue lock before examing the queue and removing the call.
4478      */
4479     if (call->call_queue_lock) {
4480         MUTEX_ENTER(call->call_queue_lock);
4481         if (queue_IsOnQueue(call)) {
4482             queue_Remove(call);
4483             if (flags & RX_CALL_WAIT_PROC) {
4484                 MUTEX_ENTER(&rx_stats_mutex);
4485                 rx_nWaiting--;
4486                 MUTEX_EXIT(&rx_stats_mutex);
4487             }
4488         }
4489         MUTEX_EXIT(call->call_queue_lock);
4490         CLEAR_CALL_QUEUE_LOCK(call);
4491     }
4492 #else /* RX_ENABLE_LOCKS */
4493     if (queue_IsOnQueue(call)) {
4494         queue_Remove(call);
4495         if (flags & RX_CALL_WAIT_PROC)
4496             rx_nWaiting--;
4497     }
4498 #endif /* RX_ENABLE_LOCKS */
4499
4500     rxi_KeepAliveOff(call);
4501     rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4502 }
4503
4504 /* Send an acknowledge for the indicated packet (seq,serial) of the
4505  * indicated call, for the indicated reason (reason).  This
4506  * acknowledge will specifically acknowledge receiving the packet, and
4507  * will also specify which other packets for this call have been
4508  * received.  This routine returns the packet that was used to the
4509  * caller.  The caller is responsible for freeing it or re-using it.
4510  * This acknowledgement also returns the highest sequence number
4511  * actually read out by the higher level to the sender; the sender
4512  * promises to keep around packets that have not been read by the
4513  * higher level yet (unless, of course, the sender decides to abort
4514  * the call altogether).  Any of p, seq, serial, pflags, or reason may
4515  * be set to zero without ill effect.  That is, if they are zero, they
4516  * will not convey any information.
4517  * NOW there is a trailer field, after the ack where it will safely be
4518  * ignored by mundanes, which indicates the maximum size packet this
4519  * host can swallow.  */
4520 /*
4521     register struct rx_packet *optionalPacket;  use to send ack (or null)
4522     int seq;                     Sequence number of the packet we are acking
4523     int serial;                  Serial number of the packet
4524     int pflags;                  Flags field from packet header
4525     int reason;                  Reason an acknowledge was prompted
4526 */
4527
4528 struct rx_packet *
4529 rxi_SendAck(register struct rx_call *call,
4530             register struct rx_packet *optionalPacket, int serial, int reason,
4531             int istack)
4532 {
4533     struct rx_ackPacket *ap;
4534     register struct rx_packet *rqp;
4535     register struct rx_packet *nxp;     /* For queue_Scan */
4536     register struct rx_packet *p;
4537     u_char offset;
4538     afs_int32 templ;
4539
4540     /*
4541      * Open the receive window once a thread starts reading packets
4542      */
4543     if (call->rnext > 1) {
4544         call->rwind = rx_maxReceiveWindow;
4545     }
4546
4547     call->nHardAcks = 0;
4548     call->nSoftAcks = 0;
4549     if (call->rnext > call->lastAcked)
4550         call->lastAcked = call->rnext;
4551     p = optionalPacket;
4552
4553     if (p) {
4554         rx_computelen(p, p->length);    /* reset length, you never know */
4555     } /* where that's been...         */
4556     else if (!(p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL))) {
4557         /* We won't send the ack, but don't panic. */
4558         return optionalPacket;
4559     }
4560
4561     templ =
4562         rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32) -
4563         rx_GetDataSize(p);
4564     if (templ > 0) {
4565         if (rxi_AllocDataBuf(p, templ, RX_PACKET_CLASS_SPECIAL)) {
4566             if (!optionalPacket)
4567                 rxi_FreePacket(p);
4568             return optionalPacket;
4569         }
4570         templ = rx_AckDataSize(call->rwind) + 2 * sizeof(afs_int32);
4571         if (rx_Contiguous(p) < templ) {
4572             if (!optionalPacket)
4573                 rxi_FreePacket(p);
4574             return optionalPacket;
4575         }
4576     }
4577
4578
4579     /* MTUXXX failing to send an ack is very serious.  We should */
4580     /* try as hard as possible to send even a partial ack; it's */
4581     /* better than nothing. */
4582     ap = (struct rx_ackPacket *)rx_DataOf(p);
4583     ap->bufferSpace = htonl(0); /* Something should go here, sometime */
4584     ap->reason = reason;
4585
4586     /* The skew computation used to be bogus, I think it's better now. */
4587     /* We should start paying attention to skew.    XXX  */
4588     ap->serial = htonl(serial);
4589     ap->maxSkew = 0;            /* used to be peer->inPacketSkew */
4590
4591     ap->firstPacket = htonl(call->rnext);       /* First packet not yet forwarded to reader */
4592     ap->previousPacket = htonl(call->rprev);    /* Previous packet received */
4593
4594     /* No fear of running out of ack packet here because there can only be at most
4595      * one window full of unacknowledged packets.  The window size must be constrained
4596      * to be less than the maximum ack size, of course.  Also, an ack should always
4597      * fit into a single packet -- it should not ever be fragmented.  */
4598     for (offset = 0, queue_Scan(&call->rq, rqp, nxp, rx_packet)) {
4599         if (!rqp || !call->rq.next
4600             || (rqp->header.seq > (call->rnext + call->rwind))) {
4601             if (!optionalPacket)
4602                 rxi_FreePacket(p);
4603             rxi_CallError(call, RX_CALL_DEAD);
4604             return optionalPacket;
4605         }
4606
4607         while (rqp->header.seq > call->rnext + offset)
4608             ap->acks[offset++] = RX_ACK_TYPE_NACK;
4609         ap->acks[offset++] = RX_ACK_TYPE_ACK;
4610
4611         if ((offset > (u_char) rx_maxReceiveWindow) || (offset > call->rwind)) {
4612             if (!optionalPacket)
4613                 rxi_FreePacket(p);
4614             rxi_CallError(call, RX_CALL_DEAD);
4615             return optionalPacket;
4616         }
4617     }
4618
4619     ap->nAcks = offset;
4620     p->length = rx_AckDataSize(offset) + 4 * sizeof(afs_int32);
4621
4622     /* these are new for AFS 3.3 */
4623     templ = rxi_AdjustMaxMTU(call->conn->peer->ifMTU, rx_maxReceiveSize);
4624     templ = htonl(templ);
4625     rx_packetwrite(p, rx_AckDataSize(offset), sizeof(afs_int32), &templ);
4626     templ = htonl(call->conn->peer->ifMTU);
4627     rx_packetwrite(p, rx_AckDataSize(offset) + sizeof(afs_int32),
4628                    sizeof(afs_int32), &templ);
4629
4630     /* new for AFS 3.4 */
4631     templ = htonl(call->rwind);
4632     rx_packetwrite(p, rx_AckDataSize(offset) + 2 * sizeof(afs_int32),
4633                    sizeof(afs_int32), &templ);
4634
4635     /* new for AFS 3.5 */
4636     templ = htonl(call->conn->peer->ifDgramPackets);
4637     rx_packetwrite(p, rx_AckDataSize(offset) + 3 * sizeof(afs_int32),
4638                    sizeof(afs_int32), &templ);
4639
4640     p->header.serviceId = call->conn->serviceId;
4641     p->header.cid = (call->conn->cid | call->channel);
4642     p->header.callNumber = *call->callNumber;
4643     p->header.seq = 0;
4644     p->header.securityIndex = call->conn->securityIndex;
4645     p->header.epoch = call->conn->epoch;
4646     p->header.type = RX_PACKET_TYPE_ACK;
4647     p->header.flags = RX_SLOW_START_OK;
4648     if (reason == RX_ACK_PING) {
4649         p->header.flags |= RX_REQUEST_ACK;
4650 #ifdef ADAPT_WINDOW
4651         clock_GetTime(&call->pingRequestTime);
4652 #endif
4653     }
4654     if (call->conn->type == RX_CLIENT_CONNECTION)
4655         p->header.flags |= RX_CLIENT_INITIATED;
4656
4657 #ifdef RXDEBUG
4658     if (rx_Log) {
4659         fprintf(rx_Log, "SACK: reason %x previous %u seq %u first %u",
4660                 ap->reason, ntohl(ap->previousPacket),
4661                 (unsigned int)p->header.seq, ntohl(ap->firstPacket));
4662         if (ap->nAcks) {
4663             for (offset = 0; offset < ap->nAcks; offset++)
4664                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
4665                      rx_Log);
4666         }
4667         putc('\n', rx_Log);
4668     }
4669 #endif
4670
4671     {
4672         register int i, nbytes = p->length;
4673
4674         for (i = 1; i < p->niovecs; i++) {      /* vec 0 is ALWAYS header */
4675             if (nbytes <= p->wirevec[i].iov_len) {
4676                 register int savelen, saven;
4677
4678                 savelen = p->wirevec[i].iov_len;
4679                 saven = p->niovecs;
4680                 p->wirevec[i].iov_len = nbytes;
4681                 p->niovecs = i + 1;
4682                 rxi_Send(call, p, istack);
4683                 p->wirevec[i].iov_len = savelen;
4684                 p->niovecs = saven;
4685                 break;
4686             } else
4687                 nbytes -= p->wirevec[i].iov_len;
4688         }
4689     }
4690     MUTEX_ENTER(&rx_stats_mutex);
4691     rx_stats.ackPacketsSent++;
4692     MUTEX_EXIT(&rx_stats_mutex);
4693     if (!optionalPacket)
4694         rxi_FreePacket(p);
4695     return optionalPacket;      /* Return packet for re-use by caller */
4696 }
4697
4698 /* Send all of the packets in the list in single datagram */
4699 static void
4700 rxi_SendList(struct rx_call *call, struct rx_packet **list, int len,
4701              int istack, int moreFlag, struct clock *now,
4702              struct clock *retryTime, int resending)
4703 {
4704     int i;
4705     int requestAck = 0;
4706     int lastPacket = 0;
4707     struct rx_connection *conn = call->conn;
4708     struct rx_peer *peer = conn->peer;
4709
4710     MUTEX_ENTER(&peer->peer_lock);
4711     peer->nSent += len;
4712     if (resending)
4713         peer->reSends += len;
4714     MUTEX_ENTER(&rx_stats_mutex);
4715     rx_stats.dataPacketsSent += len;
4716     MUTEX_EXIT(&rx_stats_mutex);
4717     MUTEX_EXIT(&peer->peer_lock);
4718
4719     if (list[len - 1]->header.flags & RX_LAST_PACKET) {
4720         lastPacket = 1;
4721     }
4722
4723     /* Set the packet flags and schedule the resend events */
4724     /* Only request an ack for the last packet in the list */
4725     for (i = 0; i < len; i++) {
4726         list[i]->retryTime = *retryTime;
4727         if (list[i]->header.serial) {
4728             /* Exponentially backoff retry times */
4729             if (list[i]->backoff < MAXBACKOFF) {
4730                 /* so it can't stay == 0 */
4731                 list[i]->backoff = (list[i]->backoff << 1) + 1;
4732             } else
4733                 list[i]->backoff++;
4734             clock_Addmsec(&(list[i]->retryTime),
4735                           ((afs_uint32) list[i]->backoff) << 8);
4736         }
4737
4738         /* Wait a little extra for the ack on the last packet */
4739         if (lastPacket && !(list[i]->header.flags & RX_CLIENT_INITIATED)) {
4740             clock_Addmsec(&(list[i]->retryTime), 400);
4741         }
4742
4743         /* Record the time sent */
4744         list[i]->timeSent = *now;
4745
4746         /* Ask for an ack on retransmitted packets,  on every other packet
4747          * if the peer doesn't support slow start. Ask for an ack on every
4748          * packet until the congestion window reaches the ack rate. */
4749         if (list[i]->header.serial) {
4750             requestAck = 1;
4751             MUTEX_ENTER(&rx_stats_mutex);
4752             rx_stats.dataPacketsReSent++;
4753             MUTEX_EXIT(&rx_stats_mutex);
4754         } else {
4755             /* improved RTO calculation- not Karn */
4756             list[i]->firstSent = *now;
4757             if (!lastPacket && (call->cwind <= (u_short) (conn->ackRate + 1)
4758                                 || (!(call->flags & RX_CALL_SLOW_START_OK)
4759                                     && (list[i]->header.seq & 1)))) {
4760                 requestAck = 1;
4761             }
4762         }
4763
4764         MUTEX_ENTER(&peer->peer_lock);
4765         peer->nSent++;
4766         if (resending)
4767             peer->reSends++;
4768         MUTEX_ENTER(&rx_stats_mutex);
4769         rx_stats.dataPacketsSent++;
4770         MUTEX_EXIT(&rx_stats_mutex);
4771         MUTEX_EXIT(&peer->peer_lock);
4772
4773         /* Tag this packet as not being the last in this group,
4774          * for the receiver's benefit */
4775         if (i < len - 1 || moreFlag) {
4776             list[i]->header.flags |= RX_MORE_PACKETS;
4777         }
4778
4779         /* Install the new retransmit time for the packet, and
4780          * record the time sent */
4781         list[i]->timeSent = *now;
4782     }
4783
4784     if (requestAck) {
4785         list[len - 1]->header.flags |= RX_REQUEST_ACK;
4786     }
4787
4788     /* Since we're about to send a data packet to the peer, it's
4789      * safe to nuke any scheduled end-of-packets ack */
4790     rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4791
4792     CALL_HOLD(call, RX_CALL_REFCOUNT_SEND);
4793     MUTEX_EXIT(&call->lock);
4794     if (len > 1) {
4795         rxi_SendPacketList(call, conn, list, len, istack);
4796     } else {
4797         rxi_SendPacket(call, conn, list[0], istack);
4798     }
4799     MUTEX_ENTER(&call->lock);
4800     CALL_RELE(call, RX_CALL_REFCOUNT_SEND);
4801
4802     /* Update last send time for this call (for keep-alive
4803      * processing), and for the connection (so that we can discover
4804      * idle connections) */
4805     conn->lastSendTime = call->lastSendTime = clock_Sec();
4806 }
4807
4808 /* When sending packets we need to follow these rules:
4809  * 1. Never send more than maxDgramPackets in a jumbogram.
4810  * 2. Never send a packet with more than two iovecs in a jumbogram.
4811  * 3. Never send a retransmitted packet in a jumbogram.
4812  * 4. Never send more than cwind/4 packets in a jumbogram
4813  * We always keep the last list we should have sent so we
4814  * can set the RX_MORE_PACKETS flags correctly.
4815  */
4816 static void
4817 rxi_SendXmitList(struct rx_call *call, struct rx_packet **list, int len,
4818                  int istack, struct clock *now, struct clock *retryTime,
4819                  int resending)
4820 {
4821     int i, cnt, lastCnt = 0;
4822     struct rx_packet **listP, **lastP = 0;
4823     struct rx_peer *peer = call->conn->peer;
4824     int morePackets = 0;
4825
4826     for (cnt = 0, listP = &list[0], i = 0; i < len; i++) {
4827         /* Does the current packet force us to flush the current list? */
4828         if (cnt > 0
4829             && (list[i]->header.serial || (list[i]->flags & RX_PKTFLAG_ACKED)
4830                 || list[i]->length > RX_JUMBOBUFFERSIZE)) {
4831             if (lastCnt > 0) {
4832                 rxi_SendList(call, lastP, lastCnt, istack, 1, now, retryTime,
4833                              resending);
4834                 /* If the call enters an error state stop sending, or if
4835                  * we entered congestion recovery mode, stop sending */
4836                 if (call->error || (call->flags & RX_CALL_FAST_RECOVER_WAIT))
4837                     return;
4838             }
4839             lastP = listP;
4840             lastCnt = cnt;
4841             listP = &list[i];
4842             cnt = 0;
4843         }
4844         /* Add the current packet to the list if it hasn't been acked.
4845          * Otherwise adjust the list pointer to skip the current packet.  */
4846         if (!(list[i]->flags & RX_PKTFLAG_ACKED)) {
4847             cnt++;
4848             /* Do we need to flush the list? */
4849             if (cnt >= (int)peer->maxDgramPackets
4850                 || cnt >= (int)call->nDgramPackets || cnt >= (int)call->cwind
4851                 || list[i]->header.serial
4852                 || list[i]->length != RX_JUMBOBUFFERSIZE) {
4853                 if (lastCnt > 0) {
4854                     rxi_SendList(call, lastP, lastCnt, istack, 1, now,
4855                                  retryTime, resending);
4856                     /* If the call enters an error state stop sending, or if
4857                      * we entered congestion recovery mode, stop sending */
4858                     if (call->error
4859                         || (call->flags & RX_CALL_FAST_RECOVER_WAIT))
4860                         return;
4861                 }
4862                 lastP = listP;
4863                 lastCnt = cnt;
4864                 listP = &list[i + 1];
4865                 cnt = 0;
4866             }
4867         } else {
4868             if (cnt != 0) {
4869                 osi_Panic("rxi_SendList error");
4870             }
4871             listP = &list[i + 1];
4872         }
4873     }
4874
4875     /* Send the whole list when the call is in receive mode, when
4876      * the call is in eof mode, when we are in fast recovery mode,
4877      * and when we have the last packet */
4878     if ((list[len - 1]->header.flags & RX_LAST_PACKET)
4879         || call->mode == RX_MODE_RECEIVING || call->mode == RX_MODE_EOF
4880         || (call->flags & RX_CALL_FAST_RECOVER)) {
4881         /* Check for the case where the current list contains
4882          * an acked packet. Since we always send retransmissions
4883          * in a separate packet, we only need to check the first
4884          * packet in the list */
4885         if (cnt > 0 && !(listP[0]->flags & RX_PKTFLAG_ACKED)) {
4886             morePackets = 1;
4887         }
4888         if (lastCnt > 0) {
4889             rxi_SendList(call, lastP, lastCnt, istack, morePackets, now,
4890                          retryTime, resending);
4891             /* If the call enters an error state stop sending, or if
4892              * we entered congestion recovery mode, stop sending */
4893             if (call->error || (call->flags & RX_CALL_FAST_RECOVER_WAIT))
4894                 return;
4895         }
4896         if (morePackets) {
4897             rxi_SendList(call, listP, cnt, istack, 0, now, retryTime,
4898                          resending);
4899         }
4900     } else if (lastCnt > 0) {
4901         rxi_SendList(call, lastP, lastCnt, istack, 0, now, retryTime,
4902                      resending);
4903     }
4904 }
4905
4906 #ifdef  RX_ENABLE_LOCKS
4907 /* Call rxi_Start, below, but with the call lock held. */
4908 void
4909 rxi_StartUnlocked(struct rxevent *event, register struct rx_call *call,
4910                   void *arg1, int istack)
4911 {
4912     MUTEX_ENTER(&call->lock);
4913     rxi_Start(event, call, arg1, istack);
4914     MUTEX_EXIT(&call->lock);
4915 }
4916 #endif /* RX_ENABLE_LOCKS */
4917
4918 /* This routine is called when new packets are readied for
4919  * transmission and when retransmission may be necessary, or when the
4920  * transmission window or burst count are favourable.  This should be
4921  * better optimized for new packets, the usual case, now that we've
4922  * got rid of queues of send packets. XXXXXXXXXXX */
4923 void
4924 rxi_Start(struct rxevent *event, register struct rx_call *call,
4925           void *arg1, int istack)
4926 {
4927     struct rx_packet *p;
4928     register struct rx_packet *nxp;     /* Next pointer for queue_Scan */
4929     struct rx_peer *peer = call->conn->peer;
4930     struct clock now, retryTime;
4931     int haveEvent;
4932     int nXmitPackets;
4933     int maxXmitPackets;
4934     struct rx_packet **xmitList;
4935     int resending = 0;
4936
4937     /* If rxi_Start is being called as a result of a resend event,
4938      * then make sure that the event pointer is removed from the call
4939      * structure, since there is no longer a per-call retransmission
4940      * event pending. */
4941     if (event && event == call->resendEvent) {
4942         CALL_RELE(call, RX_CALL_REFCOUNT_RESEND);
4943         call->resendEvent = NULL;
4944         resending = 1;
4945         if (queue_IsEmpty(&call->tq)) {
4946             /* Nothing to do */
4947             return;
4948         }
4949         /* Timeouts trigger congestion recovery */
4950 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4951         if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
4952             /* someone else is waiting to start recovery */
4953             return;
4954         }
4955         call->flags |= RX_CALL_FAST_RECOVER_WAIT;
4956         while (call->flags & RX_CALL_TQ_BUSY) {
4957             call->flags |= RX_CALL_TQ_WAIT;
4958 #ifdef RX_ENABLE_LOCKS
4959             CV_WAIT(&call->cv_tq, &call->lock);
4960 #else /* RX_ENABLE_LOCKS */
4961             osi_rxSleep(&call->tq);
4962 #endif /* RX_ENABLE_LOCKS */
4963         }
4964 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4965         call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
4966         call->flags |= RX_CALL_FAST_RECOVER;
4967         if (peer->maxDgramPackets > 1) {
4968             call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
4969         } else {
4970             call->MTU = MIN(peer->natMTU, peer->maxMTU);
4971         }
4972         call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
4973         call->nDgramPackets = 1;
4974         call->cwind = 1;
4975         call->nextCwind = 1;
4976         call->nAcks = 0;
4977         call->nNacks = 0;
4978         MUTEX_ENTER(&peer->peer_lock);
4979         peer->MTU = call->MTU;
4980         peer->cwind = call->cwind;
4981         peer->nDgramPackets = 1;
4982         peer->congestSeq++;
4983         call->congestSeq = peer->congestSeq;
4984         MUTEX_EXIT(&peer->peer_lock);
4985         /* Clear retry times on packets. Otherwise, it's possible for
4986          * some packets in the queue to force resends at rates faster
4987          * than recovery rates.
4988          */
4989         for (queue_Scan(&call->tq, p, nxp, rx_packet)) {
4990             if (!(p->flags & RX_PKTFLAG_ACKED)) {
4991                 clock_Zero(&p->retryTime);
4992             }
4993         }
4994     }
4995     if (call->error) {
4996 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4997         MUTEX_ENTER(&rx_stats_mutex);
4998         rx_tq_debug.rxi_start_in_error++;
4999         MUTEX_EXIT(&rx_stats_mutex);
5000 #endif
5001         return;
5002     }
5003
5004     if (queue_IsNotEmpty(&call->tq)) {  /* If we have anything to send */
5005         /* Get clock to compute the re-transmit time for any packets
5006          * in this burst.  Note, if we back off, it's reasonable to
5007          * back off all of the packets in the same manner, even if
5008          * some of them have been retransmitted more times than more
5009          * recent additions */
5010         clock_GetTime(&now);
5011         retryTime = now;        /* initialize before use */
5012         MUTEX_ENTER(&peer->peer_lock);
5013         clock_Add(&retryTime, &peer->timeout);
5014         MUTEX_EXIT(&peer->peer_lock);
5015
5016         /* Send (or resend) any packets that need it, subject to
5017          * window restrictions and congestion burst control
5018          * restrictions.  Ask for an ack on the last packet sent in
5019          * this burst.  For now, we're relying upon the window being
5020          * considerably bigger than the largest number of packets that
5021          * are typically sent at once by one initial call to
5022          * rxi_Start.  This is probably bogus (perhaps we should ask
5023          * for an ack when we're half way through the current
5024          * window?).  Also, for non file transfer applications, this
5025          * may end up asking for an ack for every packet.  Bogus. XXXX
5026          */
5027         /*
5028          * But check whether we're here recursively, and let the other guy
5029          * do the work.
5030          */
5031 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5032         if (!(call->flags & RX_CALL_TQ_BUSY)) {
5033             call->flags |= RX_CALL_TQ_BUSY;
5034             do {
5035 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5036             restart:
5037 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5038                 call->flags &= ~RX_CALL_NEED_START;
5039 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5040                 nXmitPackets = 0;
5041                 maxXmitPackets = MIN(call->twind, call->cwind);
5042                 xmitList = (struct rx_packet **)
5043                     osi_Alloc(maxXmitPackets * sizeof(struct rx_packet *));
5044                 if (xmitList == NULL)
5045                     osi_Panic("rxi_Start, failed to allocate xmit list");
5046                 for (queue_Scan(&call->tq, p, nxp, rx_packet)) {
5047                     if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
5048                         /* We shouldn't be sending packets if a thread is waiting
5049                          * to initiate congestion recovery */
5050                         break;
5051                     }
5052                     if ((nXmitPackets)
5053                         && (call->flags & RX_CALL_FAST_RECOVER)) {
5054                         /* Only send one packet during fast recovery */
5055                         break;
5056                     }
5057                     if ((p->flags & RX_PKTFLAG_FREE)
5058                         || (!queue_IsEnd(&call->tq, nxp)
5059                             && (nxp->flags & RX_PKTFLAG_FREE))
5060                         || (p == (struct rx_packet *)&rx_freePacketQueue)
5061                         || (nxp == (struct rx_packet *)&rx_freePacketQueue)) {
5062                         osi_Panic("rxi_Start: xmit queue clobbered");
5063                     }
5064                     if (p->flags & RX_PKTFLAG_ACKED) {
5065                         MUTEX_ENTER(&rx_stats_mutex);
5066                         rx_stats.ignoreAckedPacket++;
5067                         MUTEX_EXIT(&rx_stats_mutex);
5068                         continue;       /* Ignore this packet if it has been acknowledged */
5069                     }
5070
5071                     /* Turn off all flags except these ones, which are the same
5072                      * on each transmission */
5073                     p->header.flags &= RX_PRESET_FLAGS;
5074
5075                     if (p->header.seq >=
5076                         call->tfirst + MIN((int)call->twind,
5077                                            (int)(call->nSoftAcked +
5078                                                  call->cwind))) {
5079                         call->flags |= RX_CALL_WAIT_WINDOW_SEND;        /* Wait for transmit window */
5080                         /* Note: if we're waiting for more window space, we can
5081                          * still send retransmits; hence we don't return here, but
5082                          * break out to schedule a retransmit event */
5083                         dpf(("call %d waiting for window",
5084                              *(call->callNumber)));
5085                         break;
5086                     }
5087
5088                     /* Transmit the packet if it needs to be sent. */
5089                     if (!clock_Lt(&now, &p->retryTime)) {
5090                         if (nXmitPackets == maxXmitPackets) {
5091                             rxi_SendXmitList(call, xmitList, nXmitPackets,
5092                                              istack, &now, &retryTime,
5093                                              resending);
5094                             osi_Free(xmitList, maxXmitPackets *
5095                                      sizeof(struct rx_packet *));
5096                             goto restart;
5097                         }
5098                         xmitList[nXmitPackets++] = p;
5099                     }
5100                 }
5101
5102                 /* xmitList now hold pointers to all of the packets that are
5103                  * ready to send. Now we loop to send the packets */
5104                 if (nXmitPackets > 0) {
5105                     rxi_SendXmitList(call, xmitList, nXmitPackets, istack,
5106                                      &now, &retryTime, resending);
5107                 }
5108                 osi_Free(xmitList,
5109                          maxXmitPackets * sizeof(struct rx_packet *));
5110
5111 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5112                 /*
5113                  * TQ references no longer protected by this flag; they must remain
5114                  * protected by the global lock.
5115                  */
5116                 if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
5117                     call->flags &= ~RX_CALL_TQ_BUSY;
5118                     if (call->flags & RX_CALL_TQ_WAIT) {
5119                         call->flags &= ~RX_CALL_TQ_WAIT;
5120 #ifdef RX_ENABLE_LOCKS
5121                         CV_BROADCAST(&call->cv_tq);
5122 #else /* RX_ENABLE_LOCKS */
5123                         osi_rxWakeup(&call->tq);
5124 #endif /* RX_ENABLE_LOCKS */
5125                     }
5126                     return;
5127                 }
5128                 if (call->error) {
5129                     /* We went into the error state while sending packets. Now is
5130                      * the time to reset the call. This will also inform the using
5131                      * process that the call is in an error state.
5132                      */
5133                     MUTEX_ENTER(&rx_stats_mutex);
5134                     rx_tq_debug.rxi_start_aborted++;
5135                     MUTEX_EXIT(&rx_stats_mutex);
5136                     call->flags &= ~RX_CALL_TQ_BUSY;
5137                     if (call->flags & RX_CALL_TQ_WAIT) {
5138                         call->flags &= ~RX_CALL_TQ_WAIT;
5139 #ifdef RX_ENABLE_LOCKS
5140                         CV_BROADCAST(&call->cv_tq);
5141 #else /* RX_ENABLE_LOCKS */
5142                         osi_rxWakeup(&call->tq);
5143 #endif /* RX_ENABLE_LOCKS */
5144                     }
5145                     rxi_CallError(call, call->error);
5146                     return;
5147                 }
5148 #ifdef RX_ENABLE_LOCKS
5149                 if (call->flags & RX_CALL_TQ_SOME_ACKED) {
5150                     register int missing;
5151                     call->flags &= ~RX_CALL_TQ_SOME_ACKED;
5152                     /* Some packets have received acks. If they all have, we can clear
5153                      * the transmit queue.
5154                      */
5155                     for (missing =
5156                          0, queue_Scan(&call->tq, p, nxp, rx_packet)) {
5157                         if (p->header.seq < call->tfirst
5158                             && (p->flags & RX_PKTFLAG_ACKED)) {
5159                             queue_Remove(p);
5160                             rxi_FreePacket(p);
5161                         } else
5162                             missing = 1;
5163                     }
5164                     if (!missing)
5165                         call->flags |= RX_CALL_TQ_CLEARME;
5166                 }
5167 #endif /* RX_ENABLE_LOCKS */
5168                 /* Don't bother doing retransmits if the TQ is cleared. */
5169                 if (call->flags & RX_CALL_TQ_CLEARME) {
5170                     rxi_ClearTransmitQueue(call, 1);
5171                 } else
5172 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5173                 {
5174
5175                     /* Always post a resend event, if there is anything in the
5176                      * queue, and resend is possible.  There should be at least
5177                      * one unacknowledged packet in the queue ... otherwise none
5178                      * of these packets should be on the queue in the first place.
5179                      */
5180                     if (call->resendEvent) {
5181                         /* Cancel the existing event and post a new one */
5182                         rxevent_Cancel(call->resendEvent, call,
5183                                        RX_CALL_REFCOUNT_RESEND);
5184                     }
5185
5186                     /* The retry time is the retry time on the first unacknowledged
5187                      * packet inside the current window */
5188                     for (haveEvent =
5189                          0, queue_Scan(&call->tq, p, nxp, rx_packet)) {
5190                         /* Don't set timers for packets outside the window */
5191                         if (p->header.seq >= call->tfirst + call->twind) {
5192                             break;
5193                         }
5194
5195                         if (!(p->flags & RX_PKTFLAG_ACKED)
5196                             && !clock_IsZero(&p->retryTime)) {
5197                             haveEvent = 1;
5198                             retryTime = p->retryTime;
5199                             break;
5200                         }
5201                     }
5202
5203                     /* Post a new event to re-run rxi_Start when retries may be needed */
5204                     if (haveEvent && !(call->flags & RX_CALL_NEED_START)) {
5205 #ifdef RX_ENABLE_LOCKS
5206                         CALL_HOLD(call, RX_CALL_REFCOUNT_RESEND);
5207                         call->resendEvent =
5208                             rxevent_Post2(&retryTime, rxi_StartUnlocked,
5209                                          (void *)call, 0, istack);
5210 #else /* RX_ENABLE_LOCKS */
5211                         call->resendEvent =
5212                             rxevent_Post2(&retryTime, rxi_Start, (void *)call,
5213                                          0, istack);
5214 #endif /* RX_ENABLE_LOCKS */
5215                     }
5216                 }
5217 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5218             } while (call->flags & RX_CALL_NEED_START);
5219             /*
5220              * TQ references no longer protected by this flag; they must remain
5221              * protected by the global lock.
5222              */
5223             call->flags &= ~RX_CALL_TQ_BUSY;
5224             if (call->flags & RX_CALL_TQ_WAIT) {
5225                 call->flags &= ~RX_CALL_TQ_WAIT;
5226 #ifdef RX_ENABLE_LOCKS
5227                 CV_BROADCAST(&call->cv_tq);
5228 #else /* RX_ENABLE_LOCKS */
5229                 osi_rxWakeup(&call->tq);
5230 #endif /* RX_ENABLE_LOCKS */
5231             }
5232         } else {
5233             call->flags |= RX_CALL_NEED_START;
5234         }
5235 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5236     } else {
5237         if (call->resendEvent) {
5238             rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
5239         }
5240     }
5241 }
5242
5243 /* Also adjusts the keep alive parameters for the call, to reflect
5244  * that we have just sent a packet (so keep alives aren't sent
5245  * immediately) */
5246 void
5247 rxi_Send(register struct rx_call *call, register struct rx_packet *p,
5248          int istack)
5249 {
5250     register struct rx_connection *conn = call->conn;
5251
5252     /* Stamp each packet with the user supplied status */
5253     p->header.userStatus = call->localStatus;
5254
5255     /* Allow the security object controlling this call's security to
5256      * make any last-minute changes to the packet */
5257     RXS_SendPacket(conn->securityObject, call, p);
5258
5259     /* Since we're about to send SOME sort of packet to the peer, it's
5260      * safe to nuke any scheduled end-of-packets ack */
5261     rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
5262
5263     /* Actually send the packet, filling in more connection-specific fields */
5264     CALL_HOLD(call, RX_CALL_REFCOUNT_SEND);
5265     MUTEX_EXIT(&call->lock);
5266     rxi_SendPacket(call, conn, p, istack);
5267     MUTEX_ENTER(&call->lock);
5268     CALL_RELE(call, RX_CALL_REFCOUNT_SEND);
5269
5270     /* Update last send time for this call (for keep-alive
5271      * processing), and for the connection (so that we can discover
5272      * idle connections) */
5273     conn->lastSendTime = call->lastSendTime = clock_Sec();
5274 }
5275
5276
5277 /* Check if a call needs to be destroyed.  Called by keep-alive code to ensure
5278  * that things are fine.  Also called periodically to guarantee that nothing
5279  * falls through the cracks (e.g. (error + dally) connections have keepalive
5280  * turned off.  Returns 0 if conn is well, -1 otherwise.  If otherwise, call
5281  *  may be freed!
5282  * haveCTLock Set if calling from rxi_ReapConnections
5283  */
5284 #ifdef RX_ENABLE_LOCKS
5285 int
5286 rxi_CheckCall(register struct rx_call *call, int haveCTLock)
5287 #else /* RX_ENABLE_LOCKS */
5288 int
5289 rxi_CheckCall(register struct rx_call *call)
5290 #endif                          /* RX_ENABLE_LOCKS */
5291 {
5292     register struct rx_connection *conn = call->conn;
5293     afs_uint32 now;
5294     afs_uint32 deadTime;
5295
5296 #ifdef RX_GLOBAL_RXLOCK_KERNEL
5297     if (call->flags & RX_CALL_TQ_BUSY) {
5298         /* Call is active and will be reset by rxi_Start if it's
5299          * in an error state.
5300          */
5301         return 0;
5302     }
5303 #endif
5304     /* dead time + RTT + 8*MDEV, rounded up to next second. */
5305     deadTime =
5306         (((afs_uint32) conn->secondsUntilDead << 10) +
5307          ((afs_uint32) conn->peer->rtt >> 3) +
5308          ((afs_uint32) conn->peer->rtt_dev << 1) + 1023) >> 10;
5309     now = clock_Sec();
5310     /* These are computed to the second (+- 1 second).  But that's
5311      * good enough for these values, which should be a significant
5312      * number of seconds. */
5313     if (now > (call->lastReceiveTime + deadTime)) {
5314         if (call->state == RX_STATE_ACTIVE) {
5315             rxi_CallError(call, RX_CALL_DEAD);
5316             return -1;
5317         } else {
5318 #ifdef RX_ENABLE_LOCKS
5319             /* Cancel pending events */
5320             rxevent_Cancel(call->delayedAckEvent, call,
5321                            RX_CALL_REFCOUNT_DELAY);
5322             rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
5323             rxevent_Cancel(call->keepAliveEvent, call,
5324                            RX_CALL_REFCOUNT_ALIVE);
5325             if (call->refCount == 0) {
5326                 rxi_FreeCall(call, haveCTLock);
5327                 return -2;
5328             }
5329             return -1;
5330 #else /* RX_ENABLE_LOCKS */
5331             rxi_FreeCall(call);
5332             return -2;
5333 #endif /* RX_ENABLE_LOCKS */
5334         }
5335         /* Non-active calls are destroyed if they are not responding
5336          * to pings; active calls are simply flagged in error, so the
5337          * attached process can die reasonably gracefully. */
5338     }
5339     /* see if we have a non-activity timeout */
5340     if (call->startWait && conn->idleDeadTime
5341         && ((call->startWait + conn->idleDeadTime) < now)) {
5342         if (call->state == RX_STATE_ACTIVE) {
5343             rxi_CallError(call, RX_CALL_TIMEOUT);
5344             return -1;
5345         }
5346     }
5347     /* see if we have a hard timeout */
5348     if (conn->hardDeadTime
5349         && (now > (conn->hardDeadTime + call->startTime.sec))) {
5350         if (call->state == RX_STATE_ACTIVE)
5351             rxi_CallError(call, RX_CALL_TIMEOUT);
5352         return -1;
5353     }
5354     return 0;
5355 }
5356
5357
5358 /* When a call is in progress, this routine is called occasionally to
5359  * make sure that some traffic has arrived (or been sent to) the peer.
5360  * If nothing has arrived in a reasonable amount of time, the call is
5361  * declared dead; if nothing has been sent for a while, we send a
5362  * keep-alive packet (if we're actually trying to keep the call alive)
5363  */
5364 void
5365 rxi_KeepAliveEvent(struct rxevent *event, register struct rx_call *call,
5366                    char *dummy)
5367 {
5368     struct rx_connection *conn;
5369     afs_uint32 now;
5370
5371     MUTEX_ENTER(&call->lock);
5372     CALL_RELE(call, RX_CALL_REFCOUNT_ALIVE);
5373     if (event == call->keepAliveEvent)
5374         call->keepAliveEvent = NULL;
5375     now = clock_Sec();
5376
5377 #ifdef RX_ENABLE_LOCKS
5378     if (rxi_CheckCall(call, 0)) {
5379         MUTEX_EXIT(&call->lock);
5380         return;
5381     }
5382 #else /* RX_ENABLE_LOCKS */
5383     if (rxi_CheckCall(call))
5384         return;
5385 #endif /* RX_ENABLE_LOCKS */
5386
5387     /* Don't try to keep alive dallying calls */
5388     if (call->state == RX_STATE_DALLY) {
5389         MUTEX_EXIT(&call->lock);
5390         return;
5391     }
5392
5393     conn = call->conn;
5394     if ((now - call->lastSendTime) > conn->secondsUntilPing) {
5395         /* Don't try to send keepalives if there is unacknowledged data */
5396         /* the rexmit code should be good enough, this little hack
5397          * doesn't quite work XXX */
5398         (void)rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
5399     }
5400     rxi_ScheduleKeepAliveEvent(call);
5401     MUTEX_EXIT(&call->lock);
5402 }
5403
5404
5405 void
5406 rxi_ScheduleKeepAliveEvent(register struct rx_call *call)
5407 {
5408     if (!call->keepAliveEvent) {
5409         struct clock when;
5410         clock_GetTime(&when);
5411         when.sec += call->conn->secondsUntilPing;
5412         CALL_HOLD(call, RX_CALL_REFCOUNT_ALIVE);
5413         call->keepAliveEvent =
5414             rxevent_Post(&when, rxi_KeepAliveEvent, call, 0);
5415     }
5416 }
5417
5418 /* N.B. rxi_KeepAliveOff:  is defined earlier as a macro */
5419 void
5420 rxi_KeepAliveOn(register struct rx_call *call)
5421 {
5422     /* Pretend last packet received was received now--i.e. if another
5423      * packet isn't received within the keep alive time, then the call
5424      * will die; Initialize last send time to the current time--even
5425      * if a packet hasn't been sent yet.  This will guarantee that a
5426      * keep-alive is sent within the ping time */
5427     call->lastReceiveTime = call->lastSendTime = clock_Sec();
5428     rxi_ScheduleKeepAliveEvent(call);
5429 }
5430
5431 /* This routine is called to send connection abort messages
5432  * that have been delayed to throttle looping clients. */
5433 void
5434 rxi_SendDelayedConnAbort(struct rxevent *event,
5435                          register struct rx_connection *conn, char *dummy)
5436 {
5437     afs_int32 error;
5438     struct rx_packet *packet;
5439
5440     MUTEX_ENTER(&conn->conn_data_lock);
5441     conn->delayedAbortEvent = NULL;
5442     error = htonl(conn->error);
5443     conn->abortCount++;
5444     MUTEX_EXIT(&conn->conn_data_lock);
5445     packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5446     if (packet) {
5447         packet =
5448             rxi_SendSpecial((struct rx_call *)0, conn, packet,
5449                             RX_PACKET_TYPE_ABORT, (char *)&error,
5450                             sizeof(error), 0);
5451         rxi_FreePacket(packet);
5452     }
5453 }
5454
5455 /* This routine is called to send call abort messages
5456  * that have been delayed to throttle looping clients. */
5457 void
5458 rxi_SendDelayedCallAbort(struct rxevent *event, register struct rx_call *call,
5459                          char *dummy)
5460 {
5461     afs_int32 error;
5462     struct rx_packet *packet;
5463
5464     MUTEX_ENTER(&call->lock);
5465     call->delayedAbortEvent = NULL;
5466     error = htonl(call->error);
5467     call->abortCount++;
5468     packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5469     if (packet) {
5470         packet =
5471             rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
5472                             (char *)&error, sizeof(error), 0);
5473         rxi_FreePacket(packet);
5474     }
5475     MUTEX_EXIT(&call->lock);
5476 }
5477
5478 /* This routine is called periodically (every RX_AUTH_REQUEST_TIMEOUT
5479  * seconds) to ask the client to authenticate itself.  The routine
5480  * issues a challenge to the client, which is obtained from the
5481  * security object associated with the connection */
5482 void
5483 rxi_ChallengeEvent(struct rxevent *event, register struct rx_connection *conn,
5484                    void *arg1, int tries)
5485 {
5486     conn->challengeEvent = NULL;
5487     if (RXS_CheckAuthentication(conn->securityObject, conn) != 0) {
5488         register struct rx_packet *packet;
5489         struct clock when;
5490
5491         if (tries <= 0) {
5492             /* We've failed to authenticate for too long.
5493              * Reset any calls waiting for authentication;
5494              * they are all in RX_STATE_PRECALL.
5495              */
5496             int i;
5497
5498             MUTEX_ENTER(&conn->conn_call_lock);
5499             for (i = 0; i < RX_MAXCALLS; i++) {
5500                 struct rx_call *call = conn->call[i];
5501                 if (call) {
5502                     MUTEX_ENTER(&call->lock);
5503                     if (call->state == RX_STATE_PRECALL) {
5504                         rxi_CallError(call, RX_CALL_DEAD);
5505                         rxi_SendCallAbort(call, NULL, 0, 0);
5506                     }
5507                     MUTEX_EXIT(&call->lock);
5508                 }
5509             }
5510             MUTEX_EXIT(&conn->conn_call_lock);
5511             return;
5512         }
5513
5514         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5515         if (packet) {
5516             /* If there's no packet available, do this later. */
5517             RXS_GetChallenge(conn->securityObject, conn, packet);
5518             rxi_SendSpecial((struct rx_call *)0, conn, packet,
5519                             RX_PACKET_TYPE_CHALLENGE, NULL, -1, 0);
5520             rxi_FreePacket(packet);
5521         }
5522         clock_GetTime(&when);
5523         when.sec += RX_CHALLENGE_TIMEOUT;
5524         conn->challengeEvent =
5525             rxevent_Post2(&when, rxi_ChallengeEvent, conn, 0,
5526                          (tries - 1));
5527     }
5528 }
5529
5530 /* Call this routine to start requesting the client to authenticate
5531  * itself.  This will continue until authentication is established,
5532  * the call times out, or an invalid response is returned.  The
5533  * security object associated with the connection is asked to create
5534  * the challenge at this time.  N.B.  rxi_ChallengeOff is a macro,
5535  * defined earlier. */
5536 void
5537 rxi_ChallengeOn(register struct rx_connection *conn)
5538 {
5539     if (!conn->challengeEvent) {
5540         RXS_CreateChallenge(conn->securityObject, conn);
5541         rxi_ChallengeEvent(NULL, conn, 0, RX_CHALLENGE_MAXTRIES);
5542     };
5543 }
5544
5545
5546 /* Compute round trip time of the packet provided, in *rttp.
5547  */
5548
5549 /* rxi_ComputeRoundTripTime is called with peer locked. */
5550 /* sentp and/or peer may be null */
5551 void
5552 rxi_ComputeRoundTripTime(register struct rx_packet *p,
5553                          register struct clock *sentp,
5554                          register struct rx_peer *peer)
5555 {
5556     struct clock thisRtt, *rttp = &thisRtt;
5557
5558 #if defined(AFS_ALPHA_LINUX22_ENV) && defined(AFS_PTHREAD_ENV) && !defined(KERNEL)
5559     /* making year 2038 bugs to get this running now - stroucki */
5560     struct timeval temptime;
5561 #endif
5562     register int rtt_timeout;
5563
5564 #if defined(AFS_ALPHA_LINUX20_ENV) && defined(AFS_PTHREAD_ENV) && !defined(KERNEL)
5565     /* yet again. This was the worst Heisenbug of the port - stroucki */
5566     clock_GetTime(&temptime);
5567     rttp->sec = (afs_int32) temptime.tv_sec;
5568     rttp->usec = (afs_int32) temptime.tv_usec;
5569 #else
5570     clock_GetTime(rttp);
5571 #endif
5572     if (clock_Lt(rttp, sentp)) {
5573         clock_Zero(rttp);
5574         return;                 /* somebody set the clock back, don't count this time. */
5575     }
5576     clock_Sub(rttp, sentp);
5577     MUTEX_ENTER(&rx_stats_mutex);
5578     if (clock_Lt(rttp, &rx_stats.minRtt))
5579         rx_stats.minRtt = *rttp;
5580     if (clock_Gt(rttp, &rx_stats.maxRtt)) {
5581         if (rttp->sec > 60) {
5582             MUTEX_EXIT(&rx_stats_mutex);
5583             return;             /* somebody set the clock ahead */
5584         }
5585         rx_stats.maxRtt = *rttp;
5586     }
5587     clock_Add(&rx_stats.totalRtt, rttp);
5588     rx_stats.nRttSamples++;
5589     MUTEX_EXIT(&rx_stats_mutex);
5590
5591     /* better rtt calculation courtesy of UMich crew (dave,larry,peter,?) */
5592
5593     /* Apply VanJacobson round-trip estimations */
5594     if (peer->rtt) {
5595         register int delta;
5596
5597         /*
5598          * srtt (peer->rtt) is in units of one-eighth-milliseconds.
5599          * srtt is stored as fixed point with 3 bits after the binary
5600          * point (i.e., scaled by 8). The following magic is
5601          * equivalent to the smoothing algorithm in rfc793 with an
5602          * alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed point).
5603          * srtt*8 = srtt*8 + rtt - srtt
5604          * srtt = srtt + rtt/8 - srtt/8
5605          */
5606
5607         delta = MSEC(rttp) - (peer->rtt >> 3);
5608         peer->rtt += delta;
5609
5610         /*
5611          * We accumulate a smoothed rtt variance (actually, a smoothed
5612          * mean difference), then set the retransmit timer to smoothed
5613          * rtt + 4 times the smoothed variance (was 2x in van's original
5614          * paper, but 4x works better for me, and apparently for him as
5615          * well).
5616          * rttvar is stored as
5617          * fixed point with 2 bits after the binary point (scaled by
5618          * 4).  The following is equivalent to rfc793 smoothing with
5619          * an alpha of .75 (rttvar = rttvar*3/4 + |delta| / 4).  This
5620          * replaces rfc793's wired-in beta.
5621          * dev*4 = dev*4 + (|actual - expected| - dev)
5622          */
5623
5624         if (delta < 0)
5625             delta = -delta;
5626
5627         delta -= (peer->rtt_dev >> 2);
5628         peer->rtt_dev += delta;
5629     } else {
5630         /* I don't have a stored RTT so I start with this value.  Since I'm
5631          * probably just starting a call, and will be pushing more data down
5632          * this, I expect congestion to increase rapidly.  So I fudge a
5633          * little, and I set deviance to half the rtt.  In practice,
5634          * deviance tends to approach something a little less than
5635          * half the smoothed rtt. */
5636         peer->rtt = (MSEC(rttp) << 3) + 8;
5637         peer->rtt_dev = peer->rtt >> 2; /* rtt/2: they're scaled differently */
5638     }
5639     /* the timeout is RTT + 4*MDEV + 0.35 sec   This is because one end or
5640      * the other of these connections is usually in a user process, and can
5641      * be switched and/or swapped out.  So on fast, reliable networks, the
5642      * timeout would otherwise be too short.
5643      */
5644     rtt_timeout = (peer->rtt >> 3) + peer->rtt_dev + 350;
5645     clock_Zero(&(peer->timeout));
5646     clock_Addmsec(&(peer->timeout), rtt_timeout);
5647
5648     dpf(("rxi_ComputeRoundTripTime(rtt=%d ms, srtt=%d ms, rtt_dev=%d ms, timeout=%d.%0.3d sec)\n", MSEC(rttp), peer->rtt >> 3, peer->rtt_dev >> 2, (peer->timeout.sec), (peer->timeout.usec)));
5649 }
5650
5651
5652 /* Find all server connections that have not been active for a long time, and
5653  * toss them */
5654 void
5655 rxi_ReapConnections(void)
5656 {
5657     struct clock now;
5658     clock_GetTime(&now);
5659
5660     /* Find server connection structures that haven't been used for
5661      * greater than rx_idleConnectionTime */
5662     {
5663         struct rx_connection **conn_ptr, **conn_end;
5664         int i, havecalls = 0;
5665         MUTEX_ENTER(&rx_connHashTable_lock);
5666         for (conn_ptr = &rx_connHashTable[0], conn_end =
5667              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
5668              conn_ptr++) {
5669             struct rx_connection *conn, *next;
5670             struct rx_call *call;
5671             int result;
5672
5673           rereap:
5674             for (conn = *conn_ptr; conn; conn = next) {
5675                 /* XXX -- Shouldn't the connection be locked? */
5676                 next = conn->next;
5677                 havecalls = 0;
5678                 for (i = 0; i < RX_MAXCALLS; i++) {
5679                     call = conn->call[i];
5680                     if (call) {
5681                         havecalls = 1;
5682                         MUTEX_ENTER(&call->lock);
5683 #ifdef RX_ENABLE_LOCKS
5684                         result = rxi_CheckCall(call, 1);
5685 #else /* RX_ENABLE_LOCKS */
5686                         result = rxi_CheckCall(call);
5687 #endif /* RX_ENABLE_LOCKS */
5688                         MUTEX_EXIT(&call->lock);
5689                         if (result == -2) {
5690                             /* If CheckCall freed the call, it might
5691                              * have destroyed  the connection as well,
5692                              * which screws up the linked lists.
5693                              */
5694                             goto rereap;
5695                         }
5696                     }
5697                 }
5698                 if (conn->type == RX_SERVER_CONNECTION) {
5699                     /* This only actually destroys the connection if
5700                      * there are no outstanding calls */
5701                     MUTEX_ENTER(&conn->conn_data_lock);
5702                     if (!havecalls && !conn->refCount
5703                         && ((conn->lastSendTime + rx_idleConnectionTime) <
5704                             now.sec)) {
5705                         conn->refCount++;       /* it will be decr in rx_DestroyConn */
5706                         MUTEX_EXIT(&conn->conn_data_lock);
5707 #ifdef RX_ENABLE_LOCKS
5708                         rxi_DestroyConnectionNoLock(conn);
5709 #else /* RX_ENABLE_LOCKS */
5710                         rxi_DestroyConnection(conn);
5711 #endif /* RX_ENABLE_LOCKS */
5712                     }
5713 #ifdef RX_ENABLE_LOCKS
5714                     else {
5715                         MUTEX_EXIT(&conn->conn_data_lock);
5716                     }
5717 #endif /* RX_ENABLE_LOCKS */
5718                 }
5719             }
5720         }
5721 #ifdef RX_ENABLE_LOCKS
5722         while (rx_connCleanup_list) {
5723             struct rx_connection *conn;
5724             conn = rx_connCleanup_list;
5725             rx_connCleanup_list = rx_connCleanup_list->next;
5726             MUTEX_EXIT(&rx_connHashTable_lock);
5727             rxi_CleanupConnection(conn);
5728             MUTEX_ENTER(&rx_connHashTable_lock);
5729         }
5730         MUTEX_EXIT(&rx_connHashTable_lock);
5731 #endif /* RX_ENABLE_LOCKS */
5732     }
5733
5734     /* Find any peer structures that haven't been used (haven't had an
5735      * associated connection) for greater than rx_idlePeerTime */
5736     {
5737         struct rx_peer **peer_ptr, **peer_end;
5738         int code;
5739         MUTEX_ENTER(&rx_rpc_stats);
5740         MUTEX_ENTER(&rx_peerHashTable_lock);
5741         for (peer_ptr = &rx_peerHashTable[0], peer_end =
5742              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
5743              peer_ptr++) {
5744             struct rx_peer *peer, *next, *prev;
5745             for (prev = peer = *peer_ptr; peer; peer = next) {
5746                 next = peer->next;
5747                 code = MUTEX_TRYENTER(&peer->peer_lock);
5748                 if ((code) && (peer->refCount == 0)
5749                     && ((peer->idleWhen + rx_idlePeerTime) < now.sec)) {
5750                     rx_interface_stat_p rpc_stat, nrpc_stat;
5751                     size_t space;
5752                     MUTEX_EXIT(&peer->peer_lock);
5753                     MUTEX_DESTROY(&peer->peer_lock);
5754                     for (queue_Scan
5755                          (&peer->rpcStats, rpc_stat, nrpc_stat,
5756                           rx_interface_stat)) {
5757                         unsigned int num_funcs;
5758                         if (!rpc_stat)
5759                             break;
5760                         queue_Remove(&rpc_stat->queue_header);
5761                         queue_Remove(&rpc_stat->all_peers);
5762                         num_funcs = rpc_stat->stats[0].func_total;
5763                         space =
5764                             sizeof(rx_interface_stat_t) +
5765                             rpc_stat->stats[0].func_total *
5766                             sizeof(rx_function_entry_v1_t);
5767
5768                         rxi_Free(rpc_stat, space);
5769                         rxi_rpc_peer_stat_cnt -= num_funcs;
5770                     }
5771                     rxi_FreePeer(peer);
5772                     MUTEX_ENTER(&rx_stats_mutex);
5773                     rx_stats.nPeerStructs--;
5774                     MUTEX_EXIT(&rx_stats_mutex);
5775                     if (peer == *peer_ptr) {
5776                         *peer_ptr = next;
5777                         prev = next;
5778                     } else
5779                         prev->next = next;
5780                 } else {
5781                     if (code) {
5782                         MUTEX_EXIT(&peer->peer_lock);
5783                     }
5784                     prev = peer;
5785                 }
5786             }
5787         }
5788         MUTEX_EXIT(&rx_peerHashTable_lock);
5789         MUTEX_EXIT(&rx_rpc_stats);
5790     }
5791
5792     /* THIS HACK IS A TEMPORARY HACK.  The idea is that the race condition in
5793      * rxi_AllocSendPacket, if it hits, will be handled at the next conn
5794      * GC, just below.  Really, we shouldn't have to keep moving packets from
5795      * one place to another, but instead ought to always know if we can
5796      * afford to hold onto a packet in its particular use.  */
5797     MUTEX_ENTER(&rx_freePktQ_lock);
5798     if (rx_waitingForPackets) {
5799         rx_waitingForPackets = 0;
5800 #ifdef  RX_ENABLE_LOCKS
5801         CV_BROADCAST(&rx_waitingForPackets_cv);
5802 #else
5803         osi_rxWakeup(&rx_waitingForPackets);
5804 #endif
5805     }
5806     MUTEX_EXIT(&rx_freePktQ_lock);
5807
5808     now.sec += RX_REAP_TIME;    /* Check every RX_REAP_TIME seconds */
5809     rxevent_Post(&now, rxi_ReapConnections, 0, 0);
5810 }
5811
5812
5813 /* rxs_Release - This isn't strictly necessary but, since the macro name from
5814  * rx.h is sort of strange this is better.  This is called with a security
5815  * object before it is discarded.  Each connection using a security object has
5816  * its own refcount to the object so it won't actually be freed until the last
5817  * connection is destroyed.
5818  *
5819  * This is the only rxs module call.  A hold could also be written but no one
5820  * needs it. */
5821
5822 int
5823 rxs_Release(struct rx_securityClass *aobj)
5824 {
5825     return RXS_Close(aobj);
5826 }
5827
5828 #ifdef ADAPT_WINDOW
5829 #define RXRATE_PKT_OH   (RX_HEADER_SIZE + RX_IPUDP_SIZE)
5830 #define RXRATE_SMALL_PKT    (RXRATE_PKT_OH + sizeof(struct rx_ackPacket))
5831 #define RXRATE_AVG_SMALL_PKT    (RXRATE_PKT_OH + (sizeof(struct rx_ackPacket)/2))
5832 #define RXRATE_LARGE_PKT    (RXRATE_SMALL_PKT + 256)
5833
5834 /* Adjust our estimate of the transmission rate to this peer, given
5835  * that the packet p was just acked. We can adjust peer->timeout and
5836  * call->twind. Pragmatically, this is called
5837  * only with packets of maximal length.
5838  * Called with peer and call locked.
5839  */
5840
5841 static void
5842 rxi_ComputeRate(register struct rx_peer *peer, register struct rx_call *call,
5843                 struct rx_packet *p, struct rx_packet *ackp, u_char ackReason)
5844 {
5845     afs_int32 xferSize, xferMs;
5846     register afs_int32 minTime;
5847     struct clock newTO;
5848
5849     /* Count down packets */
5850     if (peer->rateFlag > 0)
5851         peer->rateFlag--;
5852     /* Do nothing until we're enabled */
5853     if (peer->rateFlag != 0)
5854         return;
5855     if (!call->conn)
5856         return;
5857
5858     /* Count only when the ack seems legitimate */
5859     switch (ackReason) {
5860     case RX_ACK_REQUESTED:
5861         xferSize =
5862             p->length + RX_HEADER_SIZE + call->conn->securityMaxTrailerSize;
5863         xferMs = peer->rtt;
5864         break;
5865
5866     case RX_ACK_PING_RESPONSE:
5867         if (p)                  /* want the response to ping-request, not data send */
5868             return;
5869         clock_GetTime(&newTO);
5870         if (clock_Gt(&newTO, &call->pingRequestTime)) {
5871             clock_Sub(&newTO, &call->pingRequestTime);
5872             xferMs = (newTO.sec * 1000) + (newTO.usec / 1000);
5873         } else {
5874             return;
5875         }
5876         xferSize = rx_AckDataSize(rx_Window) + RX_HEADER_SIZE;
5877         break;
5878
5879     default:
5880         return;
5881     }
5882
5883     dpf(("CONG peer %lx/%u: sample (%s) size %ld, %ld ms (to %lu.%06lu, rtt %u, ps %u)", ntohl(peer->host), ntohs(peer->port), (ackReason == RX_ACK_REQUESTED ? "dataack" : "pingack"), xferSize, xferMs, peer->timeout.sec, peer->timeout.usec, peer->smRtt, peer->ifMTU));
5884
5885     /* Track only packets that are big enough. */
5886     if ((p->length + RX_HEADER_SIZE + call->conn->securityMaxTrailerSize) <
5887         peer->ifMTU)
5888         return;
5889
5890     /* absorb RTT data (in milliseconds) for these big packets */
5891     if (peer->smRtt == 0) {
5892         peer->smRtt = xferMs;
5893     } else {
5894         peer->smRtt = ((peer->smRtt * 15) + xferMs + 4) >> 4;
5895         if (!peer->smRtt)
5896             peer->smRtt = 1;
5897     }
5898
5899     if (peer->countDown) {
5900         peer->countDown--;
5901         return;
5902     }
5903     peer->countDown = 10;       /* recalculate only every so often */
5904
5905     /* In practice, we can measure only the RTT for full packets,
5906      * because of the way Rx acks the data that it receives.  (If it's
5907      * smaller than a full packet, it often gets implicitly acked
5908      * either by the call response (from a server) or by the next call
5909      * (from a client), and either case confuses transmission times
5910      * with processing times.)  Therefore, replace the above
5911      * more-sophisticated processing with a simpler version, where the
5912      * smoothed RTT is kept for full-size packets, and the time to
5913      * transmit a windowful of full-size packets is simply RTT *
5914      * windowSize. Again, we take two steps:
5915      - ensure the timeout is large enough for a single packet's RTT;
5916      - ensure that the window is small enough to fit in the desired timeout.*/
5917
5918     /* First, the timeout check. */
5919     minTime = peer->smRtt;
5920     /* Get a reasonable estimate for a timeout period */
5921     minTime += minTime;
5922     newTO.sec = minTime / 1000;
5923     newTO.usec = (minTime - (newTO.sec * 1000)) * 1000;
5924
5925     /* Increase the timeout period so that we can always do at least
5926      * one packet exchange */
5927     if (clock_Gt(&newTO, &peer->timeout)) {
5928
5929         dpf(("CONG peer %lx/%u: timeout %lu.%06lu ==> %lu.%06lu (rtt %u, ps %u)", ntohl(peer->host), ntohs(peer->port), peer->timeout.sec, peer->timeout.usec, newTO.sec, newTO.usec, peer->smRtt, peer->packetSize));
5930
5931         peer->timeout = newTO;
5932     }
5933
5934     /* Now, get an estimate for the transmit window size. */
5935     minTime = peer->timeout.sec * 1000 + (peer->timeout.usec / 1000);
5936     /* Now, convert to the number of full packets that could fit in a
5937      * reasonable fraction of that interval */
5938     minTime /= (peer->smRtt << 1);
5939     xferSize = minTime;         /* (make a copy) */
5940
5941     /* Now clamp the size to reasonable bounds. */
5942     if (minTime <= 1)
5943         minTime = 1;
5944     else if (minTime > rx_Window)
5945         minTime = rx_Window;
5946 /*    if (minTime != peer->maxWindow) {
5947       dpf(("CONG peer %lx/%u: windowsize %lu ==> %lu (to %lu.%06lu, rtt %u, ps %u)",
5948              ntohl(peer->host), ntohs(peer->port), peer->maxWindow, minTime,
5949              peer->timeout.sec, peer->timeout.usec, peer->smRtt,
5950              peer->packetSize));
5951       peer->maxWindow = minTime;
5952         elide... call->twind = minTime;
5953     }
5954 */
5955
5956     /* Cut back on the peer timeout if it had earlier grown unreasonably.
5957      * Discern this by calculating the timeout necessary for rx_Window
5958      * packets. */
5959     if ((xferSize > rx_Window) && (peer->timeout.sec >= 3)) {
5960         /* calculate estimate for transmission interval in milliseconds */
5961         minTime = rx_Window * peer->smRtt;
5962         if (minTime < 1000) {
5963             dpf(("CONG peer %lx/%u: cut TO %lu.%06lu by 0.5 (rtt %u, ps %u)",
5964                  ntohl(peer->host), ntohs(peer->port), peer->timeout.sec,
5965                  peer->timeout.usec, peer->smRtt, peer->packetSize));
5966
5967             newTO.sec = 0;      /* cut back on timeout by half a second */
5968             newTO.usec = 500000;
5969             clock_Sub(&peer->timeout, &newTO);
5970         }
5971     }
5972
5973     return;
5974 }                               /* end of rxi_ComputeRate */
5975 #endif /* ADAPT_WINDOW */
5976
5977
5978
5979
5980
5981
5982 #ifdef RXDEBUG
5983 /* Don't call this debugging routine directly; use dpf */
5984 void
5985 rxi_DebugPrint(char *format, int a1, int a2, int a3, int a4, int a5, int a6,
5986                int a7, int a8, int a9, int a10, int a11, int a12, int a13,
5987                int a14, int a15)
5988 {
5989     struct clock now;
5990     clock_GetTime(&now);
5991     fprintf(rx_Log, " %u.%.3u:", (unsigned int)now.sec,
5992             (unsigned int)now.usec / 1000);
5993     fprintf(rx_Log, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
5994             a13, a14, a15);
5995     putc('\n', rx_Log);
5996 }
5997 #endif
5998
5999 #ifdef RXDEBUG
6000 /*
6001  * This function is used to process the rx_stats structure that is local
6002  * to a process as well as an rx_stats structure received from a remote
6003  * process (via rxdebug).  Therefore, it needs to do minimal version
6004  * checking.
6005  */
6006 void
6007 rx_PrintTheseStats(FILE * file, struct rx_stats *s, int size,
6008                    afs_int32 freePackets, char version)
6009 {
6010     int i;
6011
6012     if (size != sizeof(struct rx_stats)) {
6013         fprintf(file,
6014                 "Unexpected size of stats structure: was %d, expected %d\n",
6015                 size, sizeof(struct rx_stats));
6016     }
6017
6018     fprintf(file, "rx stats: free packets %d, allocs %d, ", (int)freePackets,
6019             s->packetRequests);
6020
6021     if (version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
6022         fprintf(file, "alloc-failures(rcv %d/%d,send %d/%d,ack %d)\n",
6023                 s->receivePktAllocFailures, s->receiveCbufPktAllocFailures,
6024                 s->sendPktAllocFailures, s->sendCbufPktAllocFailures,
6025                 s->specialPktAllocFailures);
6026     } else {
6027         fprintf(file, "alloc-failures(rcv %d,send %d,ack %d)\n",
6028                 s->receivePktAllocFailures, s->sendPktAllocFailures,
6029                 s->specialPktAllocFailures);
6030     }
6031
6032     fprintf(file,
6033             "   greedy %d, " "bogusReads %d (last from host %x), "
6034             "noPackets %d, " "noBuffers %d, " "selects %d, "
6035             "sendSelects %d\n", s->socketGreedy, s->bogusPacketOnRead,
6036             s->bogusHost, s->noPacketOnRead, s->noPacketBuffersOnRead,
6037             s->selects, s->sendSelects);
6038
6039     fprintf(file, "   packets read: ");
6040     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
6041         fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsRead[i]);
6042     }
6043     fprintf(file, "\n");
6044
6045     fprintf(file,
6046             "   other read counters: data %d, " "ack %d, " "dup %d "
6047             "spurious %d " "dally %d\n", s->dataPacketsRead,
6048             s->ackPacketsRead, s->dupPacketsRead, s->spuriousPacketsRead,
6049             s->ignorePacketDally);
6050
6051     fprintf(file, "   packets sent: ");
6052     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
6053         fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsSent[i]);
6054     }
6055     fprintf(file, "\n");
6056
6057     fprintf(file,
6058             "   other send counters: ack %d, " "data %d (not resends), "
6059             "resends %d, " "pushed %d, " "acked&ignored %d\n",
6060             s->ackPacketsSent, s->dataPacketsSent, s->dataPacketsReSent,
6061             s->dataPacketsPushed, s->ignoreAckedPacket);
6062
6063     fprintf(file,
6064             "   \t(these should be small) sendFailed %d, " "fatalErrors %d\n",
6065             s->netSendFailures, (int)s->fatalErrors);
6066
6067     if (s->nRttSamples) {
6068         fprintf(file, "   Average rtt is %0.3f, with %d samples\n",
6069                 clock_Float(&s->totalRtt) / s->nRttSamples, s->nRttSamples);
6070
6071         fprintf(file, "   Minimum rtt is %0.3f, maximum is %0.3f\n",
6072                 clock_Float(&s->minRtt), clock_Float(&s->maxRtt));
6073     }
6074
6075     fprintf(file,
6076             "   %d server connections, " "%d client connections, "
6077             "%d peer structs, " "%d call structs, " "%d free call structs\n",
6078             s->nServerConns, s->nClientConns, s->nPeerStructs,
6079             s->nCallStructs, s->nFreeCallStructs);
6080
6081 #if     !defined(AFS_PTHREAD_ENV) && !defined(AFS_USE_GETTIMEOFDAY)
6082     fprintf(file, "   %d clock updates\n", clock_nUpdates);
6083 #endif
6084
6085 }
6086
6087 /* for backward compatibility */
6088 void
6089 rx_PrintStats(FILE * file)
6090 {
6091     MUTEX_ENTER(&rx_stats_mutex);
6092     rx_PrintTheseStats(file, &rx_stats, sizeof(rx_stats), rx_nFreePackets,
6093                        RX_DEBUGI_VERSION);
6094     MUTEX_EXIT(&rx_stats_mutex);
6095 }
6096
6097 void
6098 rx_PrintPeerStats(FILE * file, struct rx_peer *peer)
6099 {
6100     fprintf(file, "Peer %x.%d.  " "Burst size %d, " "burst wait %u.%d.\n",
6101             ntohl(peer->host), (int)peer->port, (int)peer->burstSize,
6102             (int)peer->burstWait.sec, (int)peer->burstWait.usec);
6103
6104     fprintf(file,
6105             "   Rtt %d, " "retry time %u.%06d, " "total sent %d, "
6106             "resent %d\n", peer->rtt, (int)peer->timeout.sec,
6107             (int)peer->timeout.usec, peer->nSent, peer->reSends);
6108
6109     fprintf(file,
6110             "   Packet size %d, " "max in packet skew %d, "
6111             "max out packet skew %d\n", peer->ifMTU, (int)peer->inPacketSkew,
6112             (int)peer->outPacketSkew);
6113 }
6114
6115 #ifdef AFS_PTHREAD_ENV
6116 /*
6117  * This mutex protects the following static variables:
6118  * counter
6119  */
6120
6121 #define LOCK_RX_DEBUG assert(pthread_mutex_lock(&rx_debug_mutex)==0)
6122 #define UNLOCK_RX_DEBUG assert(pthread_mutex_unlock(&rx_debug_mutex)==0)
6123 #else
6124 #define LOCK_RX_DEBUG
6125 #define UNLOCK_RX_DEBUG
6126 #endif /* AFS_PTHREAD_ENV */
6127
6128 static int
6129 MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
6130               u_char type, void *inputData, size_t inputLength,
6131               void *outputData, size_t outputLength)
6132 {
6133     static afs_int32 counter = 100;
6134     afs_int32 endTime;
6135     struct rx_header theader;
6136     char tbuffer[1500];
6137     register afs_int32 code;
6138     struct timeval tv;
6139     struct sockaddr_in taddr, faddr;
6140     int faddrLen;
6141     fd_set imask;
6142     register char *tp;
6143
6144     endTime = time(0) + 20;     /* try for 20 seconds */
6145     LOCK_RX_DEBUG;
6146     counter++;
6147     UNLOCK_RX_DEBUG;
6148     tp = &tbuffer[sizeof(struct rx_header)];
6149     taddr.sin_family = AF_INET;
6150     taddr.sin_port = remotePort;
6151     taddr.sin_addr.s_addr = remoteAddr;
6152 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
6153     taddr.sin_len = sizeof(struct sockaddr_in);
6154 #endif
6155     while (1) {
6156         memset(&theader, 0, sizeof(theader));
6157         theader.epoch = htonl(999);
6158         theader.cid = 0;
6159         theader.callNumber = htonl(counter);
6160         theader.seq = 0;
6161         theader.serial = 0;
6162         theader.type = type;
6163         theader.flags = RX_CLIENT_INITIATED | RX_LAST_PACKET;
6164         theader.serviceId = 0;
6165
6166         memcpy(tbuffer, &theader, sizeof(theader));
6167         memcpy(tp, inputData, inputLength);
6168         code =
6169             sendto(socket, tbuffer, inputLength + sizeof(struct rx_header), 0,
6170                    (struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
6171
6172         /* see if there's a packet available */
6173         FD_ZERO(&imask);
6174         FD_SET(socket, &imask);
6175         tv.tv_sec = 1;
6176         tv.tv_usec = 0;
6177         code = select(socket + 1, &imask, 0, 0, &tv);
6178         if (code == 1 && FD_ISSET(socket, &imask)) {
6179             /* now receive a packet */
6180             faddrLen = sizeof(struct sockaddr_in);
6181             code =
6182                 recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
6183                          (struct sockaddr *)&faddr, &faddrLen);
6184
6185             if (code > 0) {
6186                 memcpy(&theader, tbuffer, sizeof(struct rx_header));
6187                 if (counter == ntohl(theader.callNumber))
6188                     break;
6189             }
6190         }
6191
6192         /* see if we've timed out */
6193         if (endTime < time(0))
6194             return -1;
6195     }
6196     code -= sizeof(struct rx_header);
6197     if (code > outputLength)
6198         code = outputLength;
6199     memcpy(outputData, tp, code);
6200     return code;
6201 }
6202
6203 afs_int32
6204 rx_GetServerDebug(osi_socket socket, afs_uint32 remoteAddr,
6205                   afs_uint16 remotePort, struct rx_debugStats * stat,
6206                   afs_uint32 * supportedValues)
6207 {
6208     struct rx_debugIn in;
6209     afs_int32 rc = 0;
6210
6211     *supportedValues = 0;
6212     in.type = htonl(RX_DEBUGI_GETSTATS);
6213     in.index = 0;
6214
6215     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6216                        &in, sizeof(in), stat, sizeof(*stat));
6217
6218     /*
6219      * If the call was successful, fixup the version and indicate
6220      * what contents of the stat structure are valid.
6221      * Also do net to host conversion of fields here.
6222      */
6223
6224     if (rc >= 0) {
6225         if (stat->version >= RX_DEBUGI_VERSION_W_SECSTATS) {
6226             *supportedValues |= RX_SERVER_DEBUG_SEC_STATS;
6227         }
6228         if (stat->version >= RX_DEBUGI_VERSION_W_GETALLCONN) {
6229             *supportedValues |= RX_SERVER_DEBUG_ALL_CONN;
6230         }
6231         if (stat->version >= RX_DEBUGI_VERSION_W_RXSTATS) {
6232             *supportedValues |= RX_SERVER_DEBUG_RX_STATS;
6233         }
6234         if (stat->version >= RX_DEBUGI_VERSION_W_WAITERS) {
6235             *supportedValues |= RX_SERVER_DEBUG_WAITER_CNT;
6236         }
6237         if (stat->version >= RX_DEBUGI_VERSION_W_IDLETHREADS) {
6238             *supportedValues |= RX_SERVER_DEBUG_IDLE_THREADS;
6239         }
6240         if (stat->version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
6241             *supportedValues |= RX_SERVER_DEBUG_NEW_PACKETS;
6242         }
6243         if (stat->version >= RX_DEBUGI_VERSION_W_GETPEER) {
6244             *supportedValues |= RX_SERVER_DEBUG_ALL_PEER;
6245         }
6246         if (stat->version >= RX_DEBUGI_VERSION_W_WAITED) {
6247             *supportedValues |= RX_SERVER_DEBUG_WAITED_CNT;
6248         }
6249
6250         stat->nFreePackets = ntohl(stat->nFreePackets);
6251         stat->packetReclaims = ntohl(stat->packetReclaims);
6252         stat->callsExecuted = ntohl(stat->callsExecuted);
6253         stat->nWaiting = ntohl(stat->nWaiting);
6254         stat->idleThreads = ntohl(stat->idleThreads);
6255     }
6256
6257     return rc;
6258 }
6259
6260 afs_int32
6261 rx_GetServerStats(osi_socket socket, afs_uint32 remoteAddr,
6262                   afs_uint16 remotePort, struct rx_stats * stat,
6263                   afs_uint32 * supportedValues)
6264 {
6265     struct rx_debugIn in;
6266     afs_int32 *lp = (afs_int32 *) stat;
6267     int i;
6268     afs_int32 rc = 0;
6269
6270     /*
6271      * supportedValues is currently unused, but added to allow future
6272      * versioning of this function.
6273      */
6274
6275     *supportedValues = 0;
6276     in.type = htonl(RX_DEBUGI_RXSTATS);
6277     in.index = 0;
6278     memset(stat, 0, sizeof(*stat));
6279
6280     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6281                        &in, sizeof(in), stat, sizeof(*stat));
6282
6283     if (rc >= 0) {
6284
6285         /*
6286          * Do net to host conversion here
6287          */
6288
6289         for (i = 0; i < sizeof(*stat) / sizeof(afs_int32); i++, lp++) {
6290             *lp = ntohl(*lp);
6291         }
6292     }
6293
6294     return rc;
6295 }
6296
6297 afs_int32
6298 rx_GetServerVersion(osi_socket socket, afs_uint32 remoteAddr,
6299                     afs_uint16 remotePort, size_t version_length,
6300                     char *version)
6301 {
6302     char a[1] = { 0 };
6303     return MakeDebugCall(socket, remoteAddr, remotePort,
6304                          RX_PACKET_TYPE_VERSION, a, 1, version,
6305                          version_length);
6306 }
6307
6308 afs_int32
6309 rx_GetServerConnections(osi_socket socket, afs_uint32 remoteAddr,
6310                         afs_uint16 remotePort, afs_int32 * nextConnection,
6311                         int allConnections, afs_uint32 debugSupportedValues,
6312                         struct rx_debugConn * conn,
6313                         afs_uint32 * supportedValues)
6314 {
6315     struct rx_debugIn in;
6316     afs_int32 rc = 0;
6317     int i;
6318
6319     /*
6320      * supportedValues is currently unused, but added to allow future
6321      * versioning of this function.
6322      */
6323
6324     *supportedValues = 0;
6325     if (allConnections) {
6326         in.type = htonl(RX_DEBUGI_GETALLCONN);
6327     } else {
6328         in.type = htonl(RX_DEBUGI_GETCONN);
6329     }
6330     in.index = htonl(*nextConnection);
6331     memset(conn, 0, sizeof(*conn));
6332
6333     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6334                        &in, sizeof(in), conn, sizeof(*conn));
6335
6336     if (rc >= 0) {
6337         *nextConnection += 1;
6338
6339         /*
6340          * Convert old connection format to new structure.
6341          */
6342
6343         if (debugSupportedValues & RX_SERVER_DEBUG_OLD_CONN) {
6344             struct rx_debugConn_vL *vL = (struct rx_debugConn_vL *)conn;
6345 #define MOVEvL(a) (conn->a = vL->a)
6346
6347             /* any old or unrecognized version... */
6348             for (i = 0; i < RX_MAXCALLS; i++) {
6349                 MOVEvL(callState[i]);
6350                 MOVEvL(callMode[i]);
6351                 MOVEvL(callFlags[i]);
6352                 MOVEvL(callOther[i]);
6353             }
6354             if (debugSupportedValues & RX_SERVER_DEBUG_SEC_STATS) {
6355                 MOVEvL(secStats.type);
6356                 MOVEvL(secStats.level);
6357                 MOVEvL(secStats.flags);
6358                 MOVEvL(secStats.expires);
6359                 MOVEvL(secStats.packetsReceived);
6360                 MOVEvL(secStats.packetsSent);
6361                 MOVEvL(secStats.bytesReceived);
6362                 MOVEvL(secStats.bytesSent);
6363             }
6364         }
6365
6366         /*
6367          * Do net to host conversion here
6368          * NOTE:
6369          *    I don't convert host or port since we are most likely
6370          *    going to want these in NBO.
6371          */
6372         conn->cid = ntohl(conn->cid);
6373         conn->serial = ntohl(conn->serial);
6374         for (i = 0; i < RX_MAXCALLS; i++) {
6375             conn->callNumber[i] = ntohl(conn->callNumber[i]);
6376         }
6377         conn->error = ntohl(conn->error);
6378         conn->secStats.flags = ntohl(conn->secStats.flags);
6379         conn->secStats.expires = ntohl(conn->secStats.expires);
6380         conn->secStats.packetsReceived =
6381             ntohl(conn->secStats.packetsReceived);
6382         conn->secStats.packetsSent = ntohl(conn->secStats.packetsSent);
6383         conn->secStats.bytesReceived = ntohl(conn->secStats.bytesReceived);
6384         conn->secStats.bytesSent = ntohl(conn->secStats.bytesSent);
6385         conn->epoch = ntohl(conn->epoch);
6386         conn->natMTU = ntohl(conn->natMTU);
6387     }
6388
6389     return rc;
6390 }
6391
6392 afs_int32
6393 rx_GetServerPeers(osi_socket socket, afs_uint32 remoteAddr,
6394                   afs_uint16 remotePort, afs_int32 * nextPeer,
6395                   afs_uint32 debugSupportedValues, struct rx_debugPeer * peer,
6396                   afs_uint32 * supportedValues)
6397 {
6398     struct rx_debugIn in;
6399     afs_int32 rc = 0;
6400
6401     /*
6402      * supportedValues is currently unused, but added to allow future
6403      * versioning of this function.
6404      */
6405
6406     *supportedValues = 0;
6407     in.type = htonl(RX_DEBUGI_GETPEER);
6408     in.index = htonl(*nextPeer);
6409     memset(peer, 0, sizeof(*peer));
6410
6411     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6412                        &in, sizeof(in), peer, sizeof(*peer));
6413
6414     if (rc >= 0) {
6415         *nextPeer += 1;
6416
6417         /*
6418          * Do net to host conversion here
6419          * NOTE:
6420          *    I don't convert host or port since we are most likely
6421          *    going to want these in NBO.
6422          */
6423         peer->ifMTU = ntohs(peer->ifMTU);
6424         peer->idleWhen = ntohl(peer->idleWhen);
6425         peer->refCount = ntohs(peer->refCount);
6426         peer->burstWait.sec = ntohl(peer->burstWait.sec);
6427         peer->burstWait.usec = ntohl(peer->burstWait.usec);
6428         peer->rtt = ntohl(peer->rtt);
6429         peer->rtt_dev = ntohl(peer->rtt_dev);
6430         peer->timeout.sec = ntohl(peer->timeout.sec);
6431         peer->timeout.usec = ntohl(peer->timeout.usec);
6432         peer->nSent = ntohl(peer->nSent);
6433         peer->reSends = ntohl(peer->reSends);
6434         peer->inPacketSkew = ntohl(peer->inPacketSkew);
6435         peer->outPacketSkew = ntohl(peer->outPacketSkew);
6436         peer->rateFlag = ntohl(peer->rateFlag);
6437         peer->natMTU = ntohs(peer->natMTU);
6438         peer->maxMTU = ntohs(peer->maxMTU);
6439         peer->maxDgramPackets = ntohs(peer->maxDgramPackets);
6440         peer->ifDgramPackets = ntohs(peer->ifDgramPackets);
6441         peer->MTU = ntohs(peer->MTU);
6442         peer->cwind = ntohs(peer->cwind);
6443         peer->nDgramPackets = ntohs(peer->nDgramPackets);
6444         peer->congestSeq = ntohs(peer->congestSeq);
6445         peer->bytesSent.high = ntohl(peer->bytesSent.high);
6446         peer->bytesSent.low = ntohl(peer->bytesSent.low);
6447         peer->bytesReceived.high = ntohl(peer->bytesReceived.high);
6448         peer->bytesReceived.low = ntohl(peer->bytesReceived.low);
6449     }
6450
6451     return rc;
6452 }
6453 #endif /* RXDEBUG */
6454
6455 void
6456 shutdown_rx(void)
6457 {
6458     struct rx_serverQueueEntry *np;
6459     register int i, j;
6460 #ifndef KERNEL
6461     register struct rx_call *call;
6462     register struct rx_serverQueueEntry *sq;
6463 #endif /* KERNEL */
6464
6465     LOCK_RX_INIT;
6466     if (rxinit_status == 1) {
6467         UNLOCK_RX_INIT;
6468         return;                 /* Already shutdown. */
6469     }
6470 #ifndef KERNEL
6471     rx_port = 0;
6472 #ifndef AFS_PTHREAD_ENV
6473     FD_ZERO(&rx_selectMask);
6474 #endif /* AFS_PTHREAD_ENV */
6475     rxi_dataQuota = RX_MAX_QUOTA;
6476 #ifndef AFS_PTHREAD_ENV
6477     rxi_StopListener();
6478 #endif /* AFS_PTHREAD_ENV */
6479     shutdown_rxevent();
6480     rx_SetEpoch(0);
6481 #ifndef AFS_PTHREAD_ENV
6482 #ifndef AFS_USE_GETTIMEOFDAY
6483     clock_UnInit();
6484 #endif /* AFS_USE_GETTIMEOFDAY */
6485 #endif /* AFS_PTHREAD_ENV */
6486
6487     while (!queue_IsEmpty(&rx_freeCallQueue)) {
6488         call = queue_First(&rx_freeCallQueue, rx_call);
6489         queue_Remove(call);
6490         rxi_Free(call, sizeof(struct rx_call));
6491     }
6492
6493     while (!queue_IsEmpty(&rx_idleServerQueue)) {
6494         sq = queue_First(&rx_idleServerQueue, rx_serverQueueEntry);
6495         queue_Remove(sq);
6496     }
6497 #endif /* KERNEL */
6498
6499     {
6500         struct rx_peer **peer_ptr, **peer_end;
6501         for (peer_ptr = &rx_peerHashTable[0], peer_end =
6502              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
6503              peer_ptr++) {
6504             struct rx_peer *peer, *next;
6505             for (peer = *peer_ptr; peer; peer = next) {
6506                 rx_interface_stat_p rpc_stat, nrpc_stat;
6507                 size_t space;
6508                 for (queue_Scan
6509                      (&peer->rpcStats, rpc_stat, nrpc_stat,
6510                       rx_interface_stat)) {
6511                     unsigned int num_funcs;
6512                     if (!rpc_stat)
6513                         break;
6514                     queue_Remove(&rpc_stat->queue_header);
6515                     queue_Remove(&rpc_stat->all_peers);
6516                     num_funcs = rpc_stat->stats[0].func_total;
6517                     space =
6518                         sizeof(rx_interface_stat_t) +
6519                         rpc_stat->stats[0].func_total *
6520                         sizeof(rx_function_entry_v1_t);
6521
6522                     rxi_Free(rpc_stat, space);
6523                     MUTEX_ENTER(&rx_rpc_stats);
6524                     rxi_rpc_peer_stat_cnt -= num_funcs;
6525                     MUTEX_EXIT(&rx_rpc_stats);
6526                 }
6527                 next = peer->next;
6528                 rxi_FreePeer(peer);
6529                 MUTEX_ENTER(&rx_stats_mutex);
6530                 rx_stats.nPeerStructs--;
6531                 MUTEX_EXIT(&rx_stats_mutex);
6532             }
6533         }
6534     }
6535     for (i = 0; i < RX_MAX_SERVICES; i++) {
6536         if (rx_services[i])
6537             rxi_Free(rx_services[i], sizeof(*rx_services[i]));
6538     }
6539     for (i = 0; i < rx_hashTableSize; i++) {
6540         register struct rx_connection *tc, *ntc;
6541         MUTEX_ENTER(&rx_connHashTable_lock);
6542         for (tc = rx_connHashTable[i]; tc; tc = ntc) {
6543             ntc = tc->next;
6544             for (j = 0; j < RX_MAXCALLS; j++) {
6545                 if (tc->call[j]) {
6546                     rxi_Free(tc->call[j], sizeof(*tc->call[j]));
6547                 }
6548             }
6549             rxi_Free(tc, sizeof(*tc));
6550         }
6551         MUTEX_EXIT(&rx_connHashTable_lock);
6552     }
6553
6554     MUTEX_ENTER(&freeSQEList_lock);
6555
6556     while ((np = rx_FreeSQEList)) {
6557         rx_FreeSQEList = *(struct rx_serverQueueEntry **)np;
6558         MUTEX_DESTROY(&np->lock);
6559         rxi_Free(np, sizeof(*np));
6560     }
6561
6562     MUTEX_EXIT(&freeSQEList_lock);
6563     MUTEX_DESTROY(&freeSQEList_lock);
6564     MUTEX_DESTROY(&rx_freeCallQueue_lock);
6565     MUTEX_DESTROY(&rx_connHashTable_lock);
6566     MUTEX_DESTROY(&rx_peerHashTable_lock);
6567     MUTEX_DESTROY(&rx_serverPool_lock);
6568
6569     osi_Free(rx_connHashTable,
6570              rx_hashTableSize * sizeof(struct rx_connection *));
6571     osi_Free(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
6572
6573     UNPIN(rx_connHashTable,
6574           rx_hashTableSize * sizeof(struct rx_connection *));
6575     UNPIN(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
6576
6577     rxi_FreeAllPackets();
6578
6579     MUTEX_ENTER(&rx_stats_mutex);
6580     rxi_dataQuota = RX_MAX_QUOTA;
6581     rxi_availProcs = rxi_totalMin = rxi_minDeficit = 0;
6582     MUTEX_EXIT(&rx_stats_mutex);
6583
6584     rxinit_status = 1;
6585     UNLOCK_RX_INIT;
6586 }
6587
6588 #ifdef RX_ENABLE_LOCKS
6589 void
6590 osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg)
6591 {
6592     if (!MUTEX_ISMINE(lockaddr))
6593         osi_Panic("Lock not held: %s", msg);
6594 }
6595 #endif /* RX_ENABLE_LOCKS */
6596
6597 #ifndef KERNEL
6598
6599 /*
6600  * Routines to implement connection specific data.
6601  */
6602
6603 int
6604 rx_KeyCreate(rx_destructor_t rtn)
6605 {
6606     int key;
6607     MUTEX_ENTER(&rxi_keyCreate_lock);
6608     key = rxi_keyCreate_counter++;
6609     rxi_keyCreate_destructor = (rx_destructor_t *)
6610         realloc((void *)rxi_keyCreate_destructor,
6611                 (key + 1) * sizeof(rx_destructor_t));
6612     rxi_keyCreate_destructor[key] = rtn;
6613     MUTEX_EXIT(&rxi_keyCreate_lock);
6614     return key;
6615 }
6616
6617 void
6618 rx_SetSpecific(struct rx_connection *conn, int key, void *ptr)
6619 {
6620     int i;
6621     MUTEX_ENTER(&conn->conn_data_lock);
6622     if (!conn->specific) {
6623         conn->specific = (void **)malloc((key + 1) * sizeof(void *));
6624         for (i = 0; i < key; i++)
6625             conn->specific[i] = NULL;
6626         conn->nSpecific = key + 1;
6627         conn->specific[key] = ptr;
6628     } else if (key >= conn->nSpecific) {
6629         conn->specific = (void **)
6630             realloc(conn->specific, (key + 1) * sizeof(void *));
6631         for (i = conn->nSpecific; i < key; i++)
6632             conn->specific[i] = NULL;
6633         conn->nSpecific = key + 1;
6634         conn->specific[key] = ptr;
6635     } else {
6636         if (conn->specific[key] && rxi_keyCreate_destructor[key])
6637             (*rxi_keyCreate_destructor[key]) (conn->specific[key]);
6638         conn->specific[key] = ptr;
6639     }
6640     MUTEX_EXIT(&conn->conn_data_lock);
6641 }
6642
6643 void *
6644 rx_GetSpecific(struct rx_connection *conn, int key)
6645 {
6646     void *ptr;
6647     MUTEX_ENTER(&conn->conn_data_lock);
6648     if (key >= conn->nSpecific)
6649         ptr = NULL;
6650     else
6651         ptr = conn->specific[key];
6652     MUTEX_EXIT(&conn->conn_data_lock);
6653     return ptr;
6654 }
6655
6656 #endif /* !KERNEL */
6657
6658 /*
6659  * processStats is a queue used to store the statistics for the local
6660  * process.  Its contents are similar to the contents of the rpcStats
6661  * queue on a rx_peer structure, but the actual data stored within
6662  * this queue contains totals across the lifetime of the process (assuming
6663  * the stats have not been reset) - unlike the per peer structures
6664  * which can come and go based upon the peer lifetime.
6665  */
6666
6667 static struct rx_queue processStats = { &processStats, &processStats };
6668
6669 /*
6670  * peerStats is a queue used to store the statistics for all peer structs.
6671  * Its contents are the union of all the peer rpcStats queues.
6672  */
6673
6674 static struct rx_queue peerStats = { &peerStats, &peerStats };
6675
6676 /*
6677  * rxi_monitor_processStats is used to turn process wide stat collection
6678  * on and off
6679  */
6680
6681 static int rxi_monitor_processStats = 0;
6682
6683 /*
6684  * rxi_monitor_peerStats is used to turn per peer stat collection on and off
6685  */
6686
6687 static int rxi_monitor_peerStats = 0;
6688
6689 /*
6690  * rxi_AddRpcStat - given all of the information for a particular rpc
6691  * call, create (if needed) and update the stat totals for the rpc.
6692  *
6693  * PARAMETERS
6694  *
6695  * IN stats - the queue of stats that will be updated with the new value
6696  *
6697  * IN rxInterface - a unique number that identifies the rpc interface
6698  *
6699  * IN currentFunc - the index of the function being invoked
6700  *
6701  * IN totalFunc - the total number of functions in this interface
6702  *
6703  * IN queueTime - the amount of time this function waited for a thread
6704  *
6705  * IN execTime - the amount of time this function invocation took to execute
6706  *
6707  * IN bytesSent - the number bytes sent by this invocation
6708  *
6709  * IN bytesRcvd - the number bytes received by this invocation
6710  *
6711  * IN isServer - if true, this invocation was made to a server
6712  *
6713  * IN remoteHost - the ip address of the remote host
6714  *
6715  * IN remotePort - the port of the remote host
6716  *
6717  * IN addToPeerList - if != 0, add newly created stat to the global peer list
6718  *
6719  * INOUT counter - if a new stats structure is allocated, the counter will
6720  * be updated with the new number of allocated stat structures
6721  *
6722  * RETURN CODES
6723  *
6724  * Returns void.
6725  */
6726
6727 static int
6728 rxi_AddRpcStat(struct rx_queue *stats, afs_uint32 rxInterface,
6729                afs_uint32 currentFunc, afs_uint32 totalFunc,
6730                struct clock *queueTime, struct clock *execTime,
6731                afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd, int isServer,
6732                afs_uint32 remoteHost, afs_uint32 remotePort,
6733                int addToPeerList, unsigned int *counter)
6734 {
6735     int rc = 0;
6736     rx_interface_stat_p rpc_stat, nrpc_stat;
6737
6738     /*
6739      * See if there's already a structure for this interface
6740      */
6741
6742     for (queue_Scan(stats, rpc_stat, nrpc_stat, rx_interface_stat)) {
6743         if ((rpc_stat->stats[0].interfaceId == rxInterface)
6744             && (rpc_stat->stats[0].remote_is_server == isServer))
6745             break;
6746     }
6747
6748     /*
6749      * Didn't find a match so allocate a new structure and add it to the
6750      * queue.
6751      */
6752
6753     if (queue_IsEnd(stats, rpc_stat) || (rpc_stat == NULL)
6754         || (rpc_stat->stats[0].interfaceId != rxInterface)
6755         || (rpc_stat->stats[0].remote_is_server != isServer)) {
6756         int i;
6757         size_t space;
6758
6759         space =
6760             sizeof(rx_interface_stat_t) +
6761             totalFunc * sizeof(rx_function_entry_v1_t);
6762
6763         rpc_stat = (rx_interface_stat_p) rxi_Alloc(space);
6764         if (rpc_stat == NULL) {
6765             rc = 1;
6766             goto fail;
6767         }
6768         *counter += totalFunc;
6769         for (i = 0; i < totalFunc; i++) {
6770             rpc_stat->stats[i].remote_peer = remoteHost;
6771             rpc_stat->stats[i].remote_port = remotePort;
6772             rpc_stat->stats[i].remote_is_server = isServer;
6773             rpc_stat->stats[i].interfaceId = rxInterface;
6774             rpc_stat->stats[i].func_total = totalFunc;
6775             rpc_stat->stats[i].func_index = i;
6776             hzero(rpc_stat->stats[i].invocations);
6777             hzero(rpc_stat->stats[i].bytes_sent);
6778             hzero(rpc_stat->stats[i].bytes_rcvd);
6779             rpc_stat->stats[i].queue_time_sum.sec = 0;
6780             rpc_stat->stats[i].queue_time_sum.usec = 0;
6781             rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
6782             rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
6783             rpc_stat->stats[i].queue_time_min.sec = 9999999;
6784             rpc_stat->stats[i].queue_time_min.usec = 9999999;
6785             rpc_stat->stats[i].queue_time_max.sec = 0;
6786             rpc_stat->stats[i].queue_time_max.usec = 0;
6787             rpc_stat->stats[i].execution_time_sum.sec = 0;
6788             rpc_stat->stats[i].execution_time_sum.usec = 0;
6789             rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
6790             rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
6791             rpc_stat->stats[i].execution_time_min.sec = 9999999;
6792             rpc_stat->stats[i].execution_time_min.usec = 9999999;
6793             rpc_stat->stats[i].execution_time_max.sec = 0;
6794             rpc_stat->stats[i].execution_time_max.usec = 0;
6795         }
6796         queue_Prepend(stats, rpc_stat);
6797         if (addToPeerList) {
6798             queue_Prepend(&peerStats, &rpc_stat->all_peers);
6799         }
6800     }
6801
6802     /*
6803      * Increment the stats for this function
6804      */
6805
6806     hadd32(rpc_stat->stats[currentFunc].invocations, 1);
6807     hadd(rpc_stat->stats[currentFunc].bytes_sent, *bytesSent);
6808     hadd(rpc_stat->stats[currentFunc].bytes_rcvd, *bytesRcvd);
6809     clock_Add(&rpc_stat->stats[currentFunc].queue_time_sum, queueTime);
6810     clock_AddSq(&rpc_stat->stats[currentFunc].queue_time_sum_sqr, queueTime);
6811     if (clock_Lt(queueTime, &rpc_stat->stats[currentFunc].queue_time_min)) {
6812         rpc_stat->stats[currentFunc].queue_time_min = *queueTime;
6813     }
6814     if (clock_Gt(queueTime, &rpc_stat->stats[currentFunc].queue_time_max)) {
6815         rpc_stat->stats[currentFunc].queue_time_max = *queueTime;
6816     }
6817     clock_Add(&rpc_stat->stats[currentFunc].execution_time_sum, execTime);
6818     clock_AddSq(&rpc_stat->stats[currentFunc].execution_time_sum_sqr,
6819                 execTime);
6820     if (clock_Lt(execTime, &rpc_stat->stats[currentFunc].execution_time_min)) {
6821         rpc_stat->stats[currentFunc].execution_time_min = *execTime;
6822     }
6823     if (clock_Gt(execTime, &rpc_stat->stats[currentFunc].execution_time_max)) {
6824         rpc_stat->stats[currentFunc].execution_time_max = *execTime;
6825     }
6826
6827   fail:
6828     return rc;
6829 }
6830
6831 /*
6832  * rx_IncrementTimeAndCount - increment the times and count for a particular
6833  * rpc function.
6834  *
6835  * PARAMETERS
6836  *
6837  * IN peer - the peer who invoked the rpc
6838  *
6839  * IN rxInterface - a unique number that identifies the rpc interface
6840  *
6841  * IN currentFunc - the index of the function being invoked
6842  *
6843  * IN totalFunc - the total number of functions in this interface
6844  *
6845  * IN queueTime - the amount of time this function waited for a thread
6846  *
6847  * IN execTime - the amount of time this function invocation took to execute
6848  *
6849  * IN bytesSent - the number bytes sent by this invocation
6850  *
6851  * IN bytesRcvd - the number bytes received by this invocation
6852  *
6853  * IN isServer - if true, this invocation was made to a server
6854  *
6855  * RETURN CODES
6856  *
6857  * Returns void.
6858  */
6859
6860 void
6861 rx_IncrementTimeAndCount(struct rx_peer *peer, afs_uint32 rxInterface,
6862                          afs_uint32 currentFunc, afs_uint32 totalFunc,
6863                          struct clock *queueTime, struct clock *execTime,
6864                          afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd,
6865                          int isServer)
6866 {
6867
6868     MUTEX_ENTER(&rx_rpc_stats);
6869     MUTEX_ENTER(&peer->peer_lock);
6870
6871     if (rxi_monitor_peerStats) {
6872         rxi_AddRpcStat(&peer->rpcStats, rxInterface, currentFunc, totalFunc,
6873                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
6874                        peer->host, peer->port, 1, &rxi_rpc_peer_stat_cnt);
6875     }
6876
6877     if (rxi_monitor_processStats) {
6878         rxi_AddRpcStat(&processStats, rxInterface, currentFunc, totalFunc,
6879                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
6880                        0xffffffff, 0xffffffff, 0, &rxi_rpc_process_stat_cnt);
6881     }
6882
6883     MUTEX_EXIT(&peer->peer_lock);
6884     MUTEX_EXIT(&rx_rpc_stats);
6885
6886 }
6887
6888 /*
6889  * rx_MarshallProcessRPCStats - marshall an array of rpc statistics
6890  *
6891  * PARAMETERS
6892  *
6893  * IN callerVersion - the rpc stat version of the caller.
6894  *
6895  * IN count - the number of entries to marshall.
6896  *
6897  * IN stats - pointer to stats to be marshalled.
6898  *
6899  * OUT ptr - Where to store the marshalled data.
6900  *
6901  * RETURN CODES
6902  *
6903  * Returns void.
6904  */
6905 void
6906 rx_MarshallProcessRPCStats(afs_uint32 callerVersion, int count,
6907                            rx_function_entry_v1_t * stats, afs_uint32 ** ptrP)
6908 {
6909     int i;
6910     afs_uint32 *ptr;
6911
6912     /*
6913      * We only support the first version
6914      */
6915     for (ptr = *ptrP, i = 0; i < count; i++, stats++) {
6916         *(ptr++) = stats->remote_peer;
6917         *(ptr++) = stats->remote_port;
6918         *(ptr++) = stats->remote_is_server;
6919         *(ptr++) = stats->interfaceId;
6920         *(ptr++) = stats->func_total;
6921         *(ptr++) = stats->func_index;
6922         *(ptr++) = hgethi(stats->invocations);
6923         *(ptr++) = hgetlo(stats->invocations);
6924         *(ptr++) = hgethi(stats->bytes_sent);
6925         *(ptr++) = hgetlo(stats->bytes_sent);
6926         *(ptr++) = hgethi(stats->bytes_rcvd);
6927         *(ptr++) = hgetlo(stats->bytes_rcvd);
6928         *(ptr++) = stats->queue_time_sum.sec;
6929         *(ptr++) = stats->queue_time_sum.usec;
6930         *(ptr++) = stats->queue_time_sum_sqr.sec;
6931         *(ptr++) = stats->queue_time_sum_sqr.usec;
6932         *(ptr++) = stats->queue_time_min.sec;
6933         *(ptr++) = stats->queue_time_min.usec;
6934         *(ptr++) = stats->queue_time_max.sec;
6935         *(ptr++) = stats->queue_time_max.usec;
6936         *(ptr++) = stats->execution_time_sum.sec;
6937         *(ptr++) = stats->execution_time_sum.usec;
6938         *(ptr++) = stats->execution_time_sum_sqr.sec;
6939         *(ptr++) = stats->execution_time_sum_sqr.usec;
6940         *(ptr++) = stats->execution_time_min.sec;
6941         *(ptr++) = stats->execution_time_min.usec;
6942         *(ptr++) = stats->execution_time_max.sec;
6943         *(ptr++) = stats->execution_time_max.usec;
6944     }
6945     *ptrP = ptr;
6946 }
6947
6948 /*
6949  * rx_RetrieveProcessRPCStats - retrieve all of the rpc statistics for
6950  * this process
6951  *
6952  * PARAMETERS
6953  *
6954  * IN callerVersion - the rpc stat version of the caller
6955  *
6956  * OUT myVersion - the rpc stat version of this function
6957  *
6958  * OUT clock_sec - local time seconds
6959  *
6960  * OUT clock_usec - local time microseconds
6961  *
6962  * OUT allocSize - the number of bytes allocated to contain stats
6963  *
6964  * OUT statCount - the number stats retrieved from this process.
6965  *
6966  * OUT stats - the actual stats retrieved from this process.
6967  *
6968  * RETURN CODES
6969  *
6970  * Returns void.  If successful, stats will != NULL.
6971  */
6972
6973 int
6974 rx_RetrieveProcessRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
6975                            afs_uint32 * clock_sec, afs_uint32 * clock_usec,
6976                            size_t * allocSize, afs_uint32 * statCount,
6977                            afs_uint32 ** stats)
6978 {
6979     size_t space = 0;
6980     afs_uint32 *ptr;
6981     struct clock now;
6982     int rc = 0;
6983
6984     *stats = 0;
6985     *allocSize = 0;
6986     *statCount = 0;
6987     *myVersion = RX_STATS_RETRIEVAL_VERSION;
6988
6989     /*
6990      * Check to see if stats are enabled
6991      */
6992
6993     MUTEX_ENTER(&rx_rpc_stats);
6994     if (!rxi_monitor_processStats) {
6995         MUTEX_EXIT(&rx_rpc_stats);
6996         return rc;
6997     }
6998
6999     clock_GetTime(&now);
7000     *clock_sec = now.sec;
7001     *clock_usec = now.usec;
7002
7003     /*
7004      * Allocate the space based upon the caller version
7005      *
7006      * If the client is at an older version than we are,
7007      * we return the statistic data in the older data format, but
7008      * we still return our version number so the client knows we
7009      * are maintaining more data than it can retrieve.
7010      */
7011
7012     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
7013         space = rxi_rpc_process_stat_cnt * sizeof(rx_function_entry_v1_t);
7014         *statCount = rxi_rpc_process_stat_cnt;
7015     } else {
7016         /*
7017          * This can't happen yet, but in the future version changes
7018          * can be handled by adding additional code here
7019          */
7020     }
7021
7022     if (space > (size_t) 0) {
7023         *allocSize = space;
7024         ptr = *stats = (afs_uint32 *) rxi_Alloc(space);
7025
7026         if (ptr != NULL) {
7027             rx_interface_stat_p rpc_stat, nrpc_stat;
7028
7029
7030             for (queue_Scan
7031                  (&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7032                 /*
7033                  * Copy the data based upon the caller version
7034                  */
7035                 rx_MarshallProcessRPCStats(callerVersion,
7036                                            rpc_stat->stats[0].func_total,
7037                                            rpc_stat->stats, &ptr);
7038             }
7039         } else {
7040             rc = ENOMEM;
7041         }
7042     }
7043     MUTEX_EXIT(&rx_rpc_stats);
7044     return rc;
7045 }
7046
7047 /*
7048  * rx_RetrievePeerRPCStats - retrieve all of the rpc statistics for the peers
7049  *
7050  * PARAMETERS
7051  *
7052  * IN callerVersion - the rpc stat version of the caller
7053  *
7054  * OUT myVersion - the rpc stat version of this function
7055  *
7056  * OUT clock_sec - local time seconds
7057  *
7058  * OUT clock_usec - local time microseconds
7059  *
7060  * OUT allocSize - the number of bytes allocated to contain stats
7061  *
7062  * OUT statCount - the number of stats retrieved from the individual
7063  * peer structures.
7064  *
7065  * OUT stats - the actual stats retrieved from the individual peer structures.
7066  *
7067  * RETURN CODES
7068  *
7069  * Returns void.  If successful, stats will != NULL.
7070  */
7071
7072 int
7073 rx_RetrievePeerRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
7074                         afs_uint32 * clock_sec, afs_uint32 * clock_usec,
7075                         size_t * allocSize, afs_uint32 * statCount,
7076                         afs_uint32 ** stats)
7077 {
7078     size_t space = 0;
7079     afs_uint32 *ptr;
7080     struct clock now;
7081     int rc = 0;
7082
7083     *stats = 0;
7084     *statCount = 0;
7085     *allocSize = 0;
7086     *myVersion = RX_STATS_RETRIEVAL_VERSION;
7087
7088     /*
7089      * Check to see if stats are enabled
7090      */
7091
7092     MUTEX_ENTER(&rx_rpc_stats);
7093     if (!rxi_monitor_peerStats) {
7094         MUTEX_EXIT(&rx_rpc_stats);
7095         return rc;
7096     }
7097
7098     clock_GetTime(&now);
7099     *clock_sec = now.sec;
7100     *clock_usec = now.usec;
7101
7102     /*
7103      * Allocate the space based upon the caller version
7104      *
7105      * If the client is at an older version than we are,
7106      * we return the statistic data in the older data format, but
7107      * we still return our version number so the client knows we
7108      * are maintaining more data than it can retrieve.
7109      */
7110
7111     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
7112         space = rxi_rpc_peer_stat_cnt * sizeof(rx_function_entry_v1_t);
7113         *statCount = rxi_rpc_peer_stat_cnt;
7114     } else {
7115         /*
7116          * This can't happen yet, but in the future version changes
7117          * can be handled by adding additional code here
7118          */
7119     }
7120
7121     if (space > (size_t) 0) {
7122         *allocSize = space;
7123         ptr = *stats = (afs_uint32 *) rxi_Alloc(space);
7124
7125         if (ptr != NULL) {
7126             rx_interface_stat_p rpc_stat, nrpc_stat;
7127             char *fix_offset;
7128
7129             for (queue_Scan
7130                  (&peerStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7131                 /*
7132                  * We have to fix the offset of rpc_stat since we are
7133                  * keeping this structure on two rx_queues.  The rx_queue
7134                  * package assumes that the rx_queue member is the first
7135                  * member of the structure.  That is, rx_queue assumes that
7136                  * any one item is only on one queue at a time.  We are
7137                  * breaking that assumption and so we have to do a little
7138                  * math to fix our pointers.
7139                  */
7140
7141                 fix_offset = (char *)rpc_stat;
7142                 fix_offset -= offsetof(rx_interface_stat_t, all_peers);
7143                 rpc_stat = (rx_interface_stat_p) fix_offset;
7144
7145                 /*
7146                  * Copy the data based upon the caller version
7147                  */
7148                 rx_MarshallProcessRPCStats(callerVersion,
7149                                            rpc_stat->stats[0].func_total,
7150                                            rpc_stat->stats, &ptr);
7151             }
7152         } else {
7153             rc = ENOMEM;
7154         }
7155     }
7156     MUTEX_EXIT(&rx_rpc_stats);
7157     return rc;
7158 }
7159
7160 /*
7161  * rx_FreeRPCStats - free memory allocated by
7162  *                   rx_RetrieveProcessRPCStats and rx_RetrievePeerRPCStats
7163  *
7164  * PARAMETERS
7165  *
7166  * IN stats - stats previously returned by rx_RetrieveProcessRPCStats or
7167  * rx_RetrievePeerRPCStats
7168  *
7169  * IN allocSize - the number of bytes in stats.
7170  *
7171  * RETURN CODES
7172  *
7173  * Returns void.
7174  */
7175
7176 void
7177 rx_FreeRPCStats(afs_uint32 * stats, size_t allocSize)
7178 {
7179     rxi_Free(stats, allocSize);
7180 }
7181
7182 /*
7183  * rx_queryProcessRPCStats - see if process rpc stat collection is
7184  * currently enabled.
7185  *
7186  * PARAMETERS
7187  *
7188  * RETURN CODES
7189  *
7190  * Returns 0 if stats are not enabled != 0 otherwise
7191  */
7192
7193 int
7194 rx_queryProcessRPCStats(void)
7195 {
7196     int rc;
7197     MUTEX_ENTER(&rx_rpc_stats);
7198     rc = rxi_monitor_processStats;
7199     MUTEX_EXIT(&rx_rpc_stats);
7200     return rc;
7201 }
7202
7203 /*
7204  * rx_queryPeerRPCStats - see if peer stat collection is currently enabled.
7205  *
7206  * PARAMETERS
7207  *
7208  * RETURN CODES
7209  *
7210  * Returns 0 if stats are not enabled != 0 otherwise
7211  */
7212
7213 int
7214 rx_queryPeerRPCStats(void)
7215 {
7216     int rc;
7217     MUTEX_ENTER(&rx_rpc_stats);
7218     rc = rxi_monitor_peerStats;
7219     MUTEX_EXIT(&rx_rpc_stats);
7220     return rc;
7221 }
7222
7223 /*
7224  * rx_enableProcessRPCStats - begin rpc stat collection for entire process
7225  *
7226  * PARAMETERS
7227  *
7228  * RETURN CODES
7229  *
7230  * Returns void.
7231  */
7232
7233 void
7234 rx_enableProcessRPCStats(void)
7235 {
7236     MUTEX_ENTER(&rx_rpc_stats);
7237     rx_enable_stats = 1;
7238     rxi_monitor_processStats = 1;
7239     MUTEX_EXIT(&rx_rpc_stats);
7240 }
7241
7242 /*
7243  * rx_enablePeerRPCStats - begin rpc stat collection per peer structure
7244  *
7245  * PARAMETERS
7246  *
7247  * RETURN CODES
7248  *
7249  * Returns void.
7250  */
7251
7252 void
7253 rx_enablePeerRPCStats(void)
7254 {
7255     MUTEX_ENTER(&rx_rpc_stats);
7256     rx_enable_stats = 1;
7257     rxi_monitor_peerStats = 1;
7258     MUTEX_EXIT(&rx_rpc_stats);
7259 }
7260
7261 /*
7262  * rx_disableProcessRPCStats - stop rpc stat collection for entire process
7263  *
7264  * PARAMETERS
7265  *
7266  * RETURN CODES
7267  *
7268  * Returns void.
7269  */
7270
7271 void
7272 rx_disableProcessRPCStats(void)
7273 {
7274     rx_interface_stat_p rpc_stat, nrpc_stat;
7275     size_t space;
7276
7277     MUTEX_ENTER(&rx_rpc_stats);
7278
7279     /*
7280      * Turn off process statistics and if peer stats is also off, turn
7281      * off everything
7282      */
7283
7284     rxi_monitor_processStats = 0;
7285     if (rxi_monitor_peerStats == 0) {
7286         rx_enable_stats = 0;
7287     }
7288
7289     for (queue_Scan(&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7290         unsigned int num_funcs = 0;
7291         if (!rpc_stat)
7292             break;
7293         queue_Remove(rpc_stat);
7294         num_funcs = rpc_stat->stats[0].func_total;
7295         space =
7296             sizeof(rx_interface_stat_t) +
7297             rpc_stat->stats[0].func_total * sizeof(rx_function_entry_v1_t);
7298
7299         rxi_Free(rpc_stat, space);
7300         rxi_rpc_process_stat_cnt -= num_funcs;
7301     }
7302     MUTEX_EXIT(&rx_rpc_stats);
7303 }
7304
7305 /*
7306  * rx_disablePeerRPCStats - stop rpc stat collection for peers
7307  *
7308  * PARAMETERS
7309  *
7310  * RETURN CODES
7311  *
7312  * Returns void.
7313  */
7314
7315 void
7316 rx_disablePeerRPCStats(void)
7317 {
7318     struct rx_peer **peer_ptr, **peer_end;
7319     int code;
7320
7321     MUTEX_ENTER(&rx_rpc_stats);
7322
7323     /*
7324      * Turn off peer statistics and if process stats is also off, turn
7325      * off everything
7326      */
7327
7328     rxi_monitor_peerStats = 0;
7329     if (rxi_monitor_processStats == 0) {
7330         rx_enable_stats = 0;
7331     }
7332
7333     MUTEX_ENTER(&rx_peerHashTable_lock);
7334     for (peer_ptr = &rx_peerHashTable[0], peer_end =
7335          &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
7336          peer_ptr++) {
7337         struct rx_peer *peer, *next, *prev;
7338         for (prev = peer = *peer_ptr; peer; peer = next) {
7339             next = peer->next;
7340             code = MUTEX_TRYENTER(&peer->peer_lock);
7341             if (code) {
7342                 rx_interface_stat_p rpc_stat, nrpc_stat;
7343                 size_t space;
7344                 for (queue_Scan
7345                      (&peer->rpcStats, rpc_stat, nrpc_stat,
7346                       rx_interface_stat)) {
7347                     unsigned int num_funcs = 0;
7348                     if (!rpc_stat)
7349                         break;
7350                     queue_Remove(&rpc_stat->queue_header);
7351                     queue_Remove(&rpc_stat->all_peers);
7352                     num_funcs = rpc_stat->stats[0].func_total;
7353                     space =
7354                         sizeof(rx_interface_stat_t) +
7355                         rpc_stat->stats[0].func_total *
7356                         sizeof(rx_function_entry_v1_t);
7357
7358                     rxi_Free(rpc_stat, space);
7359                     rxi_rpc_peer_stat_cnt -= num_funcs;
7360                 }
7361                 MUTEX_EXIT(&peer->peer_lock);
7362                 if (prev == *peer_ptr) {
7363                     *peer_ptr = next;
7364                     prev = next;
7365                 } else
7366                     prev->next = next;
7367             } else {
7368                 prev = peer;
7369             }
7370         }
7371     }
7372     MUTEX_EXIT(&rx_peerHashTable_lock);
7373     MUTEX_EXIT(&rx_rpc_stats);
7374 }
7375
7376 /*
7377  * rx_clearProcessRPCStats - clear the contents of the rpc stats according
7378  * to clearFlag
7379  *
7380  * PARAMETERS
7381  *
7382  * IN clearFlag - flag indicating which stats to clear
7383  *
7384  * RETURN CODES
7385  *
7386  * Returns void.
7387  */
7388
7389 void
7390 rx_clearProcessRPCStats(afs_uint32 clearFlag)
7391 {
7392     rx_interface_stat_p rpc_stat, nrpc_stat;
7393
7394     MUTEX_ENTER(&rx_rpc_stats);
7395
7396     for (queue_Scan(&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7397         unsigned int num_funcs = 0, i;
7398         num_funcs = rpc_stat->stats[0].func_total;
7399         for (i = 0; i < num_funcs; i++) {
7400             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
7401                 hzero(rpc_stat->stats[i].invocations);
7402             }
7403             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
7404                 hzero(rpc_stat->stats[i].bytes_sent);
7405             }
7406             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
7407                 hzero(rpc_stat->stats[i].bytes_rcvd);
7408             }
7409             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
7410                 rpc_stat->stats[i].queue_time_sum.sec = 0;
7411                 rpc_stat->stats[i].queue_time_sum.usec = 0;
7412             }
7413             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
7414                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7415                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7416             }
7417             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
7418                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
7419                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
7420             }
7421             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
7422                 rpc_stat->stats[i].queue_time_max.sec = 0;
7423                 rpc_stat->stats[i].queue_time_max.usec = 0;
7424             }
7425             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
7426                 rpc_stat->stats[i].execution_time_sum.sec = 0;
7427                 rpc_stat->stats[i].execution_time_sum.usec = 0;
7428             }
7429             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
7430                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7431                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7432             }
7433             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
7434                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
7435                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
7436             }
7437             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
7438                 rpc_stat->stats[i].execution_time_max.sec = 0;
7439                 rpc_stat->stats[i].execution_time_max.usec = 0;
7440             }
7441         }
7442     }
7443
7444     MUTEX_EXIT(&rx_rpc_stats);
7445 }
7446
7447 /*
7448  * rx_clearPeerRPCStats - clear the contents of the rpc stats according
7449  * to clearFlag
7450  *
7451  * PARAMETERS
7452  *
7453  * IN clearFlag - flag indicating which stats to clear
7454  *
7455  * RETURN CODES
7456  *
7457  * Returns void.
7458  */
7459
7460 void
7461 rx_clearPeerRPCStats(afs_uint32 clearFlag)
7462 {
7463     rx_interface_stat_p rpc_stat, nrpc_stat;
7464
7465     MUTEX_ENTER(&rx_rpc_stats);
7466
7467     for (queue_Scan(&peerStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7468         unsigned int num_funcs = 0, i;
7469         char *fix_offset;
7470         /*
7471          * We have to fix the offset of rpc_stat since we are
7472          * keeping this structure on two rx_queues.  The rx_queue
7473          * package assumes that the rx_queue member is the first
7474          * member of the structure.  That is, rx_queue assumes that
7475          * any one item is only on one queue at a time.  We are
7476          * breaking that assumption and so we have to do a little
7477          * math to fix our pointers.
7478          */
7479
7480         fix_offset = (char *)rpc_stat;
7481         fix_offset -= offsetof(rx_interface_stat_t, all_peers);
7482         rpc_stat = (rx_interface_stat_p) fix_offset;
7483
7484         num_funcs = rpc_stat->stats[0].func_total;
7485         for (i = 0; i < num_funcs; i++) {
7486             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
7487                 hzero(rpc_stat->stats[i].invocations);
7488             }
7489             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
7490                 hzero(rpc_stat->stats[i].bytes_sent);
7491             }
7492             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
7493                 hzero(rpc_stat->stats[i].bytes_rcvd);
7494             }
7495             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
7496                 rpc_stat->stats[i].queue_time_sum.sec = 0;
7497                 rpc_stat->stats[i].queue_time_sum.usec = 0;
7498             }
7499             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
7500                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7501                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7502             }
7503             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
7504                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
7505                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
7506             }
7507             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
7508                 rpc_stat->stats[i].queue_time_max.sec = 0;
7509                 rpc_stat->stats[i].queue_time_max.usec = 0;
7510             }
7511             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
7512                 rpc_stat->stats[i].execution_time_sum.sec = 0;
7513                 rpc_stat->stats[i].execution_time_sum.usec = 0;
7514             }
7515             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
7516                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7517                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7518             }
7519             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
7520                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
7521                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
7522             }
7523             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
7524                 rpc_stat->stats[i].execution_time_max.sec = 0;
7525                 rpc_stat->stats[i].execution_time_max.usec = 0;
7526             }
7527         }
7528     }
7529
7530     MUTEX_EXIT(&rx_rpc_stats);
7531 }
7532
7533 /*
7534  * rxi_rxstat_userok points to a routine that returns 1 if the caller
7535  * is authorized to enable/disable/clear RX statistics.
7536  */
7537 static int (*rxi_rxstat_userok) (struct rx_call * call) = NULL;
7538
7539 void
7540 rx_SetRxStatUserOk(int (*proc) (struct rx_call * call))
7541 {
7542     rxi_rxstat_userok = proc;
7543 }
7544
7545 int
7546 rx_RxStatUserOk(struct rx_call *call)
7547 {
7548     if (!rxi_rxstat_userok)
7549         return 0;
7550     return rxi_rxstat_userok(call);
7551 }