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