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