src/rx/rx.c

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