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