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, ...)
6319 {
6320 #ifdef AFS_NT40_ENV
6321     char msg[512];
6322     char tformat[256];
6323     size_t len;
6324
6325     len = _snprintf(tformat, sizeof(tformat), "tid[%d] %s", GetCurrentThreadId(), format);
6326
6327     if (len > 0) {
6328         len = _vsnprintf(msg, sizeof(msg)-2, tformat, ap);
6329         if (len > 0) {
6330             if (msg[len-1] != '\n') {
6331                 msg[len] = '\n';
6332                 msg[len+1] = '\0';
6333             }
6334             OutputDebugString(msg);
6335         }
6336     }
6337     va_end(ap);
6338 #else
6339     struct clock now;
6340     va_list ap;
6341
6342     va_start(ap, format);
6343
6344     clock_GetTime(&now);
6345     fprintf(rx_Log, " %u.%.3u:", (unsigned int)now.sec,
6346             (unsigned int)now.usec / 1000);
6347     vfprintf(rx_Log, format, ap);
6348     putc('\n', rx_Log);
6349     va_end(ap);
6350 #endif
6351 }
6352
6353 /*
6354  * This function is used to process the rx_stats structure that is local
6355  * to a process as well as an rx_stats structure received from a remote
6356  * process (via rxdebug).  Therefore, it needs to do minimal version
6357  * checking.
6358  */
6359 void
6360 rx_PrintTheseStats(FILE * file, struct rx_stats *s, int size,
6361                    afs_int32 freePackets, char version)
6362 {
6363     int i;
6364
6365     if (size != sizeof(struct rx_stats)) {
6366         fprintf(file,
6367                 "Unexpected size of stats structure: was %d, expected %lud\n",
6368                 size, sizeof(struct rx_stats));
6369     }
6370
6371     fprintf(file, "rx stats: free packets %d, allocs %d, ", (int)freePackets,
6372             s->packetRequests);
6373
6374     if (version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
6375         fprintf(file, "alloc-failures(rcv %d/%d,send %d/%d,ack %d)\n",
6376                 s->receivePktAllocFailures, s->receiveCbufPktAllocFailures,
6377                 s->sendPktAllocFailures, s->sendCbufPktAllocFailures,
6378                 s->specialPktAllocFailures);
6379     } else {
6380         fprintf(file, "alloc-failures(rcv %d,send %d,ack %d)\n",
6381                 s->receivePktAllocFailures, s->sendPktAllocFailures,
6382                 s->specialPktAllocFailures);
6383     }
6384
6385     fprintf(file,
6386             "   greedy %d, " "bogusReads %d (last from host %x), "
6387             "noPackets %d, " "noBuffers %d, " "selects %d, "
6388             "sendSelects %d\n", s->socketGreedy, s->bogusPacketOnRead,
6389             s->bogusHost, s->noPacketOnRead, s->noPacketBuffersOnRead,
6390             s->selects, s->sendSelects);
6391
6392     fprintf(file, "   packets read: ");
6393     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
6394         fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsRead[i]);
6395     }
6396     fprintf(file, "\n");
6397
6398     fprintf(file,
6399             "   other read counters: data %d, " "ack %d, " "dup %d "
6400             "spurious %d " "dally %d\n", s->dataPacketsRead,
6401             s->ackPacketsRead, s->dupPacketsRead, s->spuriousPacketsRead,
6402             s->ignorePacketDally);
6403
6404     fprintf(file, "   packets sent: ");
6405     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
6406         fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsSent[i]);
6407     }
6408     fprintf(file, "\n");
6409
6410     fprintf(file,
6411             "   other send counters: ack %d, " "data %d (not resends), "
6412             "resends %d, " "pushed %d, " "acked&ignored %d\n",
6413             s->ackPacketsSent, s->dataPacketsSent, s->dataPacketsReSent,
6414             s->dataPacketsPushed, s->ignoreAckedPacket);
6415
6416     fprintf(file,
6417             "   \t(these should be small) sendFailed %d, " "fatalErrors %d\n",
6418             s->netSendFailures, (int)s->fatalErrors);
6419
6420     if (s->nRttSamples) {
6421         fprintf(file, "   Average rtt is %0.3f, with %d samples\n",
6422                 clock_Float(&s->totalRtt) / s->nRttSamples, s->nRttSamples);
6423
6424         fprintf(file, "   Minimum rtt is %0.3f, maximum is %0.3f\n",
6425                 clock_Float(&s->minRtt), clock_Float(&s->maxRtt));
6426     }
6427
6428     fprintf(file,
6429             "   %d server connections, " "%d client connections, "
6430             "%d peer structs, " "%d call structs, " "%d free call structs\n",
6431             s->nServerConns, s->nClientConns, s->nPeerStructs,
6432             s->nCallStructs, s->nFreeCallStructs);
6433
6434 #if     !defined(AFS_PTHREAD_ENV) && !defined(AFS_USE_GETTIMEOFDAY)
6435     fprintf(file, "   %d clock updates\n", clock_nUpdates);
6436 #endif
6437
6438 }
6439
6440 /* for backward compatibility */
6441 void
6442 rx_PrintStats(FILE * file)
6443 {
6444     MUTEX_ENTER(&rx_stats_mutex);
6445     rx_PrintTheseStats(file, &rx_stats, sizeof(rx_stats), rx_nFreePackets,
6446                        RX_DEBUGI_VERSION);
6447     MUTEX_EXIT(&rx_stats_mutex);
6448 }
6449
6450 void
6451 rx_PrintPeerStats(FILE * file, struct rx_peer *peer)
6452 {
6453     fprintf(file, "Peer %x.%d.  " "Burst size %d, " "burst wait %u.%d.\n",
6454             ntohl(peer->host), (int)peer->port, (int)peer->burstSize,
6455             (int)peer->burstWait.sec, (int)peer->burstWait.usec);
6456
6457     fprintf(file,
6458             "   Rtt %d, " "retry time %u.%06d, " "total sent %d, "
6459             "resent %d\n", peer->rtt, (int)peer->timeout.sec,
6460             (int)peer->timeout.usec, peer->nSent, peer->reSends);
6461
6462     fprintf(file,
6463             "   Packet size %d, " "max in packet skew %d, "
6464             "max out packet skew %d\n", peer->ifMTU, (int)peer->inPacketSkew,
6465             (int)peer->outPacketSkew);
6466 }
6467
6468 #ifdef AFS_PTHREAD_ENV
6469 /*
6470  * This mutex protects the following static variables:
6471  * counter
6472  */
6473
6474 #define LOCK_RX_DEBUG assert(pthread_mutex_lock(&rx_debug_mutex)==0)
6475 #define UNLOCK_RX_DEBUG assert(pthread_mutex_unlock(&rx_debug_mutex)==0)
6476 #else
6477 #define LOCK_RX_DEBUG
6478 #define UNLOCK_RX_DEBUG
6479 #endif /* AFS_PTHREAD_ENV */
6480
6481 static int
6482 MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
6483               u_char type, void *inputData, size_t inputLength,
6484               void *outputData, size_t outputLength)
6485 {
6486     static afs_int32 counter = 100;
6487     time_t waitTime, waitCount, startTime;
6488     struct rx_header theader;
6489     char tbuffer[1500];
6490     register afs_int32 code;
6491     struct timeval tv_now, tv_wake, tv_delta;
6492     struct sockaddr_in taddr, faddr;
6493     socklen_t faddrLen;
6494     fd_set imask;
6495     register char *tp;
6496
6497     startTime = time(0);
6498     waitTime = 1;
6499     waitCount = 5;
6500     LOCK_RX_DEBUG;
6501     counter++;
6502     UNLOCK_RX_DEBUG;
6503     tp = &tbuffer[sizeof(struct rx_header)];
6504     taddr.sin_family = AF_INET;
6505     taddr.sin_port = remotePort;
6506     taddr.sin_addr.s_addr = remoteAddr;
6507 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
6508     taddr.sin_len = sizeof(struct sockaddr_in);
6509 #endif
6510     while (1) {
6511         memset(&theader, 0, sizeof(theader));
6512         theader.epoch = htonl(999);
6513         theader.cid = 0;
6514         theader.callNumber = htonl(counter);
6515         theader.seq = 0;
6516         theader.serial = 0;
6517         theader.type = type;
6518         theader.flags = RX_CLIENT_INITIATED | RX_LAST_PACKET;
6519         theader.serviceId = 0;
6520
6521         memcpy(tbuffer, &theader, sizeof(theader));
6522         memcpy(tp, inputData, inputLength);
6523         code =
6524             sendto(socket, tbuffer, inputLength + sizeof(struct rx_header), 0,
6525                    (struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
6526
6527         /* see if there's a packet available */
6528         gettimeofday(&tv_wake,0);
6529         tv_wake.tv_sec += waitTime;
6530         for (;;) {
6531             FD_ZERO(&imask);
6532             FD_SET(socket, &imask);
6533             tv_delta.tv_sec = tv_wake.tv_sec;
6534             tv_delta.tv_usec = tv_wake.tv_usec;
6535             gettimeofday(&tv_now, 0);
6536
6537             if (tv_delta.tv_usec < tv_now.tv_usec) {
6538                 /* borrow */
6539                 tv_delta.tv_usec += 1000000;
6540                 tv_delta.tv_sec--;
6541             }
6542             tv_delta.tv_usec -= tv_now.tv_usec;
6543
6544             if (tv_delta.tv_sec < tv_now.tv_sec) {
6545                 /* time expired */
6546                 break;
6547             }
6548             tv_delta.tv_sec -= tv_now.tv_sec;
6549
6550             code = select(socket + 1, &imask, 0, 0, &tv_delta);
6551             if (code == 1 && FD_ISSET(socket, &imask)) {
6552                 /* now receive a packet */
6553                 faddrLen = sizeof(struct sockaddr_in);
6554                 code =
6555                     recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
6556                              (struct sockaddr *)&faddr, &faddrLen);
6557
6558                 if (code > 0) {
6559                     memcpy(&theader, tbuffer, sizeof(struct rx_header));
6560                     if (counter == ntohl(theader.callNumber))
6561                         goto success;
6562                     continue;
6563                 }
6564             }
6565             break;
6566         }
6567
6568         /* see if we've timed out */
6569         if (!--waitCount) {
6570             return -1;
6571         }
6572         waitTime <<= 1;
6573     }
6574
6575  success:
6576     code -= sizeof(struct rx_header);
6577     if (code > outputLength)
6578         code = outputLength;
6579     memcpy(outputData, tp, code);
6580     return code;
6581 }
6582
6583 afs_int32
6584 rx_GetServerDebug(osi_socket socket, afs_uint32 remoteAddr,
6585                   afs_uint16 remotePort, struct rx_debugStats * stat,
6586                   afs_uint32 * supportedValues)
6587 {
6588     struct rx_debugIn in;
6589     afs_int32 rc = 0;
6590
6591     *supportedValues = 0;
6592     in.type = htonl(RX_DEBUGI_GETSTATS);
6593     in.index = 0;
6594
6595     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6596                        &in, sizeof(in), stat, sizeof(*stat));
6597
6598     /*
6599      * If the call was successful, fixup the version and indicate
6600      * what contents of the stat structure are valid.
6601      * Also do net to host conversion of fields here.
6602      */
6603
6604     if (rc >= 0) {
6605         if (stat->version >= RX_DEBUGI_VERSION_W_SECSTATS) {
6606             *supportedValues |= RX_SERVER_DEBUG_SEC_STATS;
6607         }
6608         if (stat->version >= RX_DEBUGI_VERSION_W_GETALLCONN) {
6609             *supportedValues |= RX_SERVER_DEBUG_ALL_CONN;
6610         }
6611         if (stat->version >= RX_DEBUGI_VERSION_W_RXSTATS) {
6612             *supportedValues |= RX_SERVER_DEBUG_RX_STATS;
6613         }
6614         if (stat->version >= RX_DEBUGI_VERSION_W_WAITERS) {
6615             *supportedValues |= RX_SERVER_DEBUG_WAITER_CNT;
6616         }
6617         if (stat->version >= RX_DEBUGI_VERSION_W_IDLETHREADS) {
6618             *supportedValues |= RX_SERVER_DEBUG_IDLE_THREADS;
6619         }
6620         if (stat->version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
6621             *supportedValues |= RX_SERVER_DEBUG_NEW_PACKETS;
6622         }
6623         if (stat->version >= RX_DEBUGI_VERSION_W_GETPEER) {
6624             *supportedValues |= RX_SERVER_DEBUG_ALL_PEER;
6625         }
6626         if (stat->version >= RX_DEBUGI_VERSION_W_WAITED) {
6627             *supportedValues |= RX_SERVER_DEBUG_WAITED_CNT;
6628         }
6629
6630         stat->nFreePackets = ntohl(stat->nFreePackets);
6631         stat->packetReclaims = ntohl(stat->packetReclaims);
6632         stat->callsExecuted = ntohl(stat->callsExecuted);
6633         stat->nWaiting = ntohl(stat->nWaiting);
6634         stat->idleThreads = ntohl(stat->idleThreads);
6635     }
6636
6637     return rc;
6638 }
6639
6640 afs_int32
6641 rx_GetServerStats(osi_socket socket, afs_uint32 remoteAddr,
6642                   afs_uint16 remotePort, struct rx_stats * stat,
6643                   afs_uint32 * supportedValues)
6644 {
6645     struct rx_debugIn in;
6646     afs_int32 *lp = (afs_int32 *) stat;
6647     int i;
6648     afs_int32 rc = 0;
6649
6650     /*
6651      * supportedValues is currently unused, but added to allow future
6652      * versioning of this function.
6653      */
6654
6655     *supportedValues = 0;
6656     in.type = htonl(RX_DEBUGI_RXSTATS);
6657     in.index = 0;
6658     memset(stat, 0, sizeof(*stat));
6659
6660     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6661                        &in, sizeof(in), stat, sizeof(*stat));
6662
6663     if (rc >= 0) {
6664
6665         /*
6666          * Do net to host conversion here
6667          */
6668
6669         for (i = 0; i < sizeof(*stat) / sizeof(afs_int32); i++, lp++) {
6670             *lp = ntohl(*lp);
6671         }
6672     }
6673
6674     return rc;
6675 }
6676
6677 afs_int32
6678 rx_GetServerVersion(osi_socket socket, afs_uint32 remoteAddr,
6679                     afs_uint16 remotePort, size_t version_length,
6680                     char *version)
6681 {
6682     char a[1] = { 0 };
6683     return MakeDebugCall(socket, remoteAddr, remotePort,
6684                          RX_PACKET_TYPE_VERSION, a, 1, version,
6685                          version_length);
6686 }
6687
6688 afs_int32
6689 rx_GetServerConnections(osi_socket socket, afs_uint32 remoteAddr,
6690                         afs_uint16 remotePort, afs_int32 * nextConnection,
6691                         int allConnections, afs_uint32 debugSupportedValues,
6692                         struct rx_debugConn * conn,
6693                         afs_uint32 * supportedValues)
6694 {
6695     struct rx_debugIn in;
6696     afs_int32 rc = 0;
6697     int i;
6698
6699     /*
6700      * supportedValues is currently unused, but added to allow future
6701      * versioning of this function.
6702      */
6703
6704     *supportedValues = 0;
6705     if (allConnections) {
6706         in.type = htonl(RX_DEBUGI_GETALLCONN);
6707     } else {
6708         in.type = htonl(RX_DEBUGI_GETCONN);
6709     }
6710     in.index = htonl(*nextConnection);
6711     memset(conn, 0, sizeof(*conn));
6712
6713     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6714                        &in, sizeof(in), conn, sizeof(*conn));
6715
6716     if (rc >= 0) {
6717         *nextConnection += 1;
6718
6719         /*
6720          * Convert old connection format to new structure.
6721          */
6722
6723         if (debugSupportedValues & RX_SERVER_DEBUG_OLD_CONN) {
6724             struct rx_debugConn_vL *vL = (struct rx_debugConn_vL *)conn;
6725 #define MOVEvL(a) (conn->a = vL->a)
6726
6727             /* any old or unrecognized version... */
6728             for (i = 0; i < RX_MAXCALLS; i++) {
6729                 MOVEvL(callState[i]);
6730                 MOVEvL(callMode[i]);
6731                 MOVEvL(callFlags[i]);
6732                 MOVEvL(callOther[i]);
6733             }
6734             if (debugSupportedValues & RX_SERVER_DEBUG_SEC_STATS) {
6735                 MOVEvL(secStats.type);
6736                 MOVEvL(secStats.level);
6737                 MOVEvL(secStats.flags);
6738                 MOVEvL(secStats.expires);
6739                 MOVEvL(secStats.packetsReceived);
6740                 MOVEvL(secStats.packetsSent);
6741                 MOVEvL(secStats.bytesReceived);
6742                 MOVEvL(secStats.bytesSent);
6743             }
6744         }
6745
6746         /*
6747          * Do net to host conversion here
6748          * NOTE:
6749          *    I don't convert host or port since we are most likely
6750          *    going to want these in NBO.
6751          */
6752         conn->cid = ntohl(conn->cid);
6753         conn->serial = ntohl(conn->serial);
6754         for (i = 0; i < RX_MAXCALLS; i++) {
6755             conn->callNumber[i] = ntohl(conn->callNumber[i]);
6756         }
6757         conn->error = ntohl(conn->error);
6758         conn->secStats.flags = ntohl(conn->secStats.flags);
6759         conn->secStats.expires = ntohl(conn->secStats.expires);
6760         conn->secStats.packetsReceived =
6761             ntohl(conn->secStats.packetsReceived);
6762         conn->secStats.packetsSent = ntohl(conn->secStats.packetsSent);
6763         conn->secStats.bytesReceived = ntohl(conn->secStats.bytesReceived);
6764         conn->secStats.bytesSent = ntohl(conn->secStats.bytesSent);
6765         conn->epoch = ntohl(conn->epoch);
6766         conn->natMTU = ntohl(conn->natMTU);
6767     }
6768
6769     return rc;
6770 }
6771
6772 afs_int32
6773 rx_GetServerPeers(osi_socket socket, afs_uint32 remoteAddr,
6774                   afs_uint16 remotePort, afs_int32 * nextPeer,
6775                   afs_uint32 debugSupportedValues, struct rx_debugPeer * peer,
6776                   afs_uint32 * supportedValues)
6777 {
6778     struct rx_debugIn in;
6779     afs_int32 rc = 0;
6780
6781     /*
6782      * supportedValues is currently unused, but added to allow future
6783      * versioning of this function.
6784      */
6785
6786     *supportedValues = 0;
6787     in.type = htonl(RX_DEBUGI_GETPEER);
6788     in.index = htonl(*nextPeer);
6789     memset(peer, 0, sizeof(*peer));
6790
6791     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6792                        &in, sizeof(in), peer, sizeof(*peer));
6793
6794     if (rc >= 0) {
6795         *nextPeer += 1;
6796
6797         /*
6798          * Do net to host conversion here
6799          * NOTE:
6800          *    I don't convert host or port since we are most likely
6801          *    going to want these in NBO.
6802          */
6803         peer->ifMTU = ntohs(peer->ifMTU);
6804         peer->idleWhen = ntohl(peer->idleWhen);
6805         peer->refCount = ntohs(peer->refCount);
6806         peer->burstWait.sec = ntohl(peer->burstWait.sec);
6807         peer->burstWait.usec = ntohl(peer->burstWait.usec);
6808         peer->rtt = ntohl(peer->rtt);
6809         peer->rtt_dev = ntohl(peer->rtt_dev);
6810         peer->timeout.sec = ntohl(peer->timeout.sec);
6811         peer->timeout.usec = ntohl(peer->timeout.usec);
6812         peer->nSent = ntohl(peer->nSent);
6813         peer->reSends = ntohl(peer->reSends);
6814         peer->inPacketSkew = ntohl(peer->inPacketSkew);
6815         peer->outPacketSkew = ntohl(peer->outPacketSkew);
6816         peer->rateFlag = ntohl(peer->rateFlag);
6817         peer->natMTU = ntohs(peer->natMTU);
6818         peer->maxMTU = ntohs(peer->maxMTU);
6819         peer->maxDgramPackets = ntohs(peer->maxDgramPackets);
6820         peer->ifDgramPackets = ntohs(peer->ifDgramPackets);
6821         peer->MTU = ntohs(peer->MTU);
6822         peer->cwind = ntohs(peer->cwind);
6823         peer->nDgramPackets = ntohs(peer->nDgramPackets);
6824         peer->congestSeq = ntohs(peer->congestSeq);
6825         peer->bytesSent.high = ntohl(peer->bytesSent.high);
6826         peer->bytesSent.low = ntohl(peer->bytesSent.low);
6827         peer->bytesReceived.high = ntohl(peer->bytesReceived.high);
6828         peer->bytesReceived.low = ntohl(peer->bytesReceived.low);
6829     }
6830
6831     return rc;
6832 }
6833 #endif /* RXDEBUG */
6834
6835 void
6836 shutdown_rx(void)
6837 {
6838     struct rx_serverQueueEntry *np;
6839     register int i, j;
6840 #ifndef KERNEL
6841     register struct rx_call *call;
6842     register struct rx_serverQueueEntry *sq;
6843 #endif /* KERNEL */
6844
6845     LOCK_RX_INIT;
6846     if (rxinit_status == 1) {
6847         UNLOCK_RX_INIT;
6848         return;                 /* Already shutdown. */
6849     }
6850 #ifndef KERNEL
6851     rx_port = 0;
6852 #ifndef AFS_PTHREAD_ENV
6853     FD_ZERO(&rx_selectMask);
6854 #endif /* AFS_PTHREAD_ENV */
6855     rxi_dataQuota = RX_MAX_QUOTA;
6856 #ifndef AFS_PTHREAD_ENV
6857     rxi_StopListener();
6858 #endif /* AFS_PTHREAD_ENV */
6859     shutdown_rxevent();
6860     rx_SetEpoch(0);
6861 #ifndef AFS_PTHREAD_ENV
6862 #ifndef AFS_USE_GETTIMEOFDAY
6863     clock_UnInit();
6864 #endif /* AFS_USE_GETTIMEOFDAY */
6865 #endif /* AFS_PTHREAD_ENV */
6866
6867     while (!queue_IsEmpty(&rx_freeCallQueue)) {
6868         call = queue_First(&rx_freeCallQueue, rx_call);
6869         queue_Remove(call);
6870         rxi_Free(call, sizeof(struct rx_call));
6871     }
6872
6873     while (!queue_IsEmpty(&rx_idleServerQueue)) {
6874         sq = queue_First(&rx_idleServerQueue, rx_serverQueueEntry);
6875         queue_Remove(sq);
6876     }
6877 #endif /* KERNEL */
6878
6879     {
6880         struct rx_peer **peer_ptr, **peer_end;
6881         for (peer_ptr = &rx_peerHashTable[0], peer_end =
6882              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
6883              peer_ptr++) {
6884             struct rx_peer *peer, *next;
6885             for (peer = *peer_ptr; peer; peer = next) {
6886                 rx_interface_stat_p rpc_stat, nrpc_stat;
6887                 size_t space;
6888                 for (queue_Scan
6889                      (&peer->rpcStats, rpc_stat, nrpc_stat,
6890                       rx_interface_stat)) {
6891                     unsigned int num_funcs;
6892                     if (!rpc_stat)
6893                         break;
6894                     queue_Remove(&rpc_stat->queue_header);
6895                     queue_Remove(&rpc_stat->all_peers);
6896                     num_funcs = rpc_stat->stats[0].func_total;
6897                     space =
6898                         sizeof(rx_interface_stat_t) +
6899                         rpc_stat->stats[0].func_total *
6900                         sizeof(rx_function_entry_v1_t);
6901
6902                     rxi_Free(rpc_stat, space);
6903                     MUTEX_ENTER(&rx_rpc_stats);
6904                     rxi_rpc_peer_stat_cnt -= num_funcs;
6905                     MUTEX_EXIT(&rx_rpc_stats);
6906                 }
6907                 next = peer->next;
6908                 rxi_FreePeer(peer);
6909                 rx_MutexDecrement(rx_stats.nPeerStructs, rx_stats_mutex);
6910             }
6911         }
6912     }
6913     for (i = 0; i < RX_MAX_SERVICES; i++) {
6914         if (rx_services[i])
6915             rxi_Free(rx_services[i], sizeof(*rx_services[i]));
6916     }
6917     for (i = 0; i < rx_hashTableSize; i++) {
6918         register struct rx_connection *tc, *ntc;
6919         MUTEX_ENTER(&rx_connHashTable_lock);
6920         for (tc = rx_connHashTable[i]; tc; tc = ntc) {
6921             ntc = tc->next;
6922             for (j = 0; j < RX_MAXCALLS; j++) {
6923                 if (tc->call[j]) {
6924                     rxi_Free(tc->call[j], sizeof(*tc->call[j]));
6925                 }
6926             }
6927             rxi_Free(tc, sizeof(*tc));
6928         }
6929         MUTEX_EXIT(&rx_connHashTable_lock);
6930     }
6931
6932     MUTEX_ENTER(&freeSQEList_lock);
6933
6934     while ((np = rx_FreeSQEList)) {
6935         rx_FreeSQEList = *(struct rx_serverQueueEntry **)np;
6936         MUTEX_DESTROY(&np->lock);
6937         rxi_Free(np, sizeof(*np));
6938     }
6939
6940     MUTEX_EXIT(&freeSQEList_lock);
6941     MUTEX_DESTROY(&freeSQEList_lock);
6942     MUTEX_DESTROY(&rx_freeCallQueue_lock);
6943     MUTEX_DESTROY(&rx_connHashTable_lock);
6944     MUTEX_DESTROY(&rx_peerHashTable_lock);
6945     MUTEX_DESTROY(&rx_serverPool_lock);
6946
6947     osi_Free(rx_connHashTable,
6948              rx_hashTableSize * sizeof(struct rx_connection *));
6949     osi_Free(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
6950
6951     UNPIN(rx_connHashTable,
6952           rx_hashTableSize * sizeof(struct rx_connection *));
6953     UNPIN(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
6954
6955     rxi_FreeAllPackets();
6956
6957     MUTEX_ENTER(&rx_stats_mutex);
6958     rxi_dataQuota = RX_MAX_QUOTA;
6959     rxi_availProcs = rxi_totalMin = rxi_minDeficit = 0;
6960     MUTEX_EXIT(&rx_stats_mutex);
6961
6962     rxinit_status = 1;
6963     UNLOCK_RX_INIT;
6964 }
6965
6966 #ifdef RX_ENABLE_LOCKS
6967 void
6968 osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg)
6969 {
6970     if (!MUTEX_ISMINE(lockaddr))
6971         osi_Panic("Lock not held: %s", msg);
6972 }
6973 #endif /* RX_ENABLE_LOCKS */
6974
6975 #ifndef KERNEL
6976
6977 /*
6978  * Routines to implement connection specific data.
6979  */
6980
6981 int
6982 rx_KeyCreate(rx_destructor_t rtn)
6983 {
6984     int key;
6985     MUTEX_ENTER(&rxi_keyCreate_lock);
6986     key = rxi_keyCreate_counter++;
6987     rxi_keyCreate_destructor = (rx_destructor_t *)
6988         realloc((void *)rxi_keyCreate_destructor,
6989                 (key + 1) * sizeof(rx_destructor_t));
6990     rxi_keyCreate_destructor[key] = rtn;
6991     MUTEX_EXIT(&rxi_keyCreate_lock);
6992     return key;
6993 }
6994
6995 void
6996 rx_SetSpecific(struct rx_connection *conn, int key, void *ptr)
6997 {
6998     int i;
6999     MUTEX_ENTER(&conn->conn_data_lock);
7000     if (!conn->specific) {
7001         conn->specific = (void **)malloc((key + 1) * sizeof(void *));
7002         for (i = 0; i < key; i++)
7003             conn->specific[i] = NULL;
7004         conn->nSpecific = key + 1;
7005         conn->specific[key] = ptr;
7006     } else if (key >= conn->nSpecific) {
7007         conn->specific = (void **)
7008             realloc(conn->specific, (key + 1) * sizeof(void *));
7009         for (i = conn->nSpecific; i < key; i++)
7010             conn->specific[i] = NULL;
7011         conn->nSpecific = key + 1;
7012         conn->specific[key] = ptr;
7013     } else {
7014         if (conn->specific[key] && rxi_keyCreate_destructor[key])
7015             (*rxi_keyCreate_destructor[key]) (conn->specific[key]);
7016         conn->specific[key] = ptr;
7017     }
7018     MUTEX_EXIT(&conn->conn_data_lock);
7019 }
7020
7021 void *
7022 rx_GetSpecific(struct rx_connection *conn, int key)
7023 {
7024     void *ptr;
7025     MUTEX_ENTER(&conn->conn_data_lock);
7026     if (key >= conn->nSpecific)
7027         ptr = NULL;
7028     else
7029         ptr = conn->specific[key];
7030     MUTEX_EXIT(&conn->conn_data_lock);
7031     return ptr;
7032 }
7033
7034 #endif /* !KERNEL */
7035
7036 /*
7037  * processStats is a queue used to store the statistics for the local
7038  * process.  Its contents are similar to the contents of the rpcStats
7039  * queue on a rx_peer structure, but the actual data stored within
7040  * this queue contains totals across the lifetime of the process (assuming
7041  * the stats have not been reset) - unlike the per peer structures
7042  * which can come and go based upon the peer lifetime.
7043  */
7044
7045 static struct rx_queue processStats = { &processStats, &processStats };
7046
7047 /*
7048  * peerStats is a queue used to store the statistics for all peer structs.
7049  * Its contents are the union of all the peer rpcStats queues.
7050  */
7051
7052 static struct rx_queue peerStats = { &peerStats, &peerStats };
7053
7054 /*
7055  * rxi_monitor_processStats is used to turn process wide stat collection
7056  * on and off
7057  */
7058
7059 static int rxi_monitor_processStats = 0;
7060
7061 /*
7062  * rxi_monitor_peerStats is used to turn per peer stat collection on and off
7063  */
7064
7065 static int rxi_monitor_peerStats = 0;
7066
7067 /*
7068  * rxi_AddRpcStat - given all of the information for a particular rpc
7069  * call, create (if needed) and update the stat totals for the rpc.
7070  *
7071  * PARAMETERS
7072  *
7073  * IN stats - the queue of stats that will be updated with the new value
7074  *
7075  * IN rxInterface - a unique number that identifies the rpc interface
7076  *
7077  * IN currentFunc - the index of the function being invoked
7078  *
7079  * IN totalFunc - the total number of functions in this interface
7080  *
7081  * IN queueTime - the amount of time this function waited for a thread
7082  *
7083  * IN execTime - the amount of time this function invocation took to execute
7084  *
7085  * IN bytesSent - the number bytes sent by this invocation
7086  *
7087  * IN bytesRcvd - the number bytes received by this invocation
7088  *
7089  * IN isServer - if true, this invocation was made to a server
7090  *
7091  * IN remoteHost - the ip address of the remote host
7092  *
7093  * IN remotePort - the port of the remote host
7094  *
7095  * IN addToPeerList - if != 0, add newly created stat to the global peer list
7096  *
7097  * INOUT counter - if a new stats structure is allocated, the counter will
7098  * be updated with the new number of allocated stat structures
7099  *
7100  * RETURN CODES
7101  *
7102  * Returns void.
7103  */
7104
7105 static int
7106 rxi_AddRpcStat(struct rx_queue *stats, afs_uint32 rxInterface,
7107                afs_uint32 currentFunc, afs_uint32 totalFunc,
7108                struct clock *queueTime, struct clock *execTime,
7109                afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd, int isServer,
7110                afs_uint32 remoteHost, afs_uint32 remotePort,
7111                int addToPeerList, unsigned int *counter)
7112 {
7113     int rc = 0;
7114     rx_interface_stat_p rpc_stat, nrpc_stat;
7115
7116     /*
7117      * See if there's already a structure for this interface
7118      */
7119
7120     for (queue_Scan(stats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7121         if ((rpc_stat->stats[0].interfaceId == rxInterface)
7122             && (rpc_stat->stats[0].remote_is_server == isServer))
7123             break;
7124     }
7125
7126     /*
7127      * Didn't find a match so allocate a new structure and add it to the
7128      * queue.
7129      */
7130
7131     if (queue_IsEnd(stats, rpc_stat) || (rpc_stat == NULL)
7132         || (rpc_stat->stats[0].interfaceId != rxInterface)
7133         || (rpc_stat->stats[0].remote_is_server != isServer)) {
7134         int i;
7135         size_t space;
7136
7137         space =
7138             sizeof(rx_interface_stat_t) +
7139             totalFunc * sizeof(rx_function_entry_v1_t);
7140
7141         rpc_stat = (rx_interface_stat_p) rxi_Alloc(space);
7142         if (rpc_stat == NULL) {
7143             rc = 1;
7144             goto fail;
7145         }
7146         *counter += totalFunc;
7147         for (i = 0; i < totalFunc; i++) {
7148             rpc_stat->stats[i].remote_peer = remoteHost;
7149             rpc_stat->stats[i].remote_port = remotePort;
7150             rpc_stat->stats[i].remote_is_server = isServer;
7151             rpc_stat->stats[i].interfaceId = rxInterface;
7152             rpc_stat->stats[i].func_total = totalFunc;
7153             rpc_stat->stats[i].func_index = i;
7154             hzero(rpc_stat->stats[i].invocations);
7155             hzero(rpc_stat->stats[i].bytes_sent);
7156             hzero(rpc_stat->stats[i].bytes_rcvd);
7157             rpc_stat->stats[i].queue_time_sum.sec = 0;
7158             rpc_stat->stats[i].queue_time_sum.usec = 0;
7159             rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7160             rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7161             rpc_stat->stats[i].queue_time_min.sec = 9999999;
7162             rpc_stat->stats[i].queue_time_min.usec = 9999999;
7163             rpc_stat->stats[i].queue_time_max.sec = 0;
7164             rpc_stat->stats[i].queue_time_max.usec = 0;
7165             rpc_stat->stats[i].execution_time_sum.sec = 0;
7166             rpc_stat->stats[i].execution_time_sum.usec = 0;
7167             rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7168             rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7169             rpc_stat->stats[i].execution_time_min.sec = 9999999;
7170             rpc_stat->stats[i].execution_time_min.usec = 9999999;
7171             rpc_stat->stats[i].execution_time_max.sec = 0;
7172             rpc_stat->stats[i].execution_time_max.usec = 0;
7173         }
7174         queue_Prepend(stats, rpc_stat);
7175         if (addToPeerList) {
7176             queue_Prepend(&peerStats, &rpc_stat->all_peers);
7177         }
7178     }
7179
7180     /*
7181      * Increment the stats for this function
7182      */
7183
7184     hadd32(rpc_stat->stats[currentFunc].invocations, 1);
7185     hadd(rpc_stat->stats[currentFunc].bytes_sent, *bytesSent);
7186     hadd(rpc_stat->stats[currentFunc].bytes_rcvd, *bytesRcvd);
7187     clock_Add(&rpc_stat->stats[currentFunc].queue_time_sum, queueTime);
7188     clock_AddSq(&rpc_stat->stats[currentFunc].queue_time_sum_sqr, queueTime);
7189     if (clock_Lt(queueTime, &rpc_stat->stats[currentFunc].queue_time_min)) {
7190         rpc_stat->stats[currentFunc].queue_time_min = *queueTime;
7191     }
7192     if (clock_Gt(queueTime, &rpc_stat->stats[currentFunc].queue_time_max)) {
7193         rpc_stat->stats[currentFunc].queue_time_max = *queueTime;
7194     }
7195     clock_Add(&rpc_stat->stats[currentFunc].execution_time_sum, execTime);
7196     clock_AddSq(&rpc_stat->stats[currentFunc].execution_time_sum_sqr,
7197                 execTime);
7198     if (clock_Lt(execTime, &rpc_stat->stats[currentFunc].execution_time_min)) {
7199         rpc_stat->stats[currentFunc].execution_time_min = *execTime;
7200     }
7201     if (clock_Gt(execTime, &rpc_stat->stats[currentFunc].execution_time_max)) {
7202         rpc_stat->stats[currentFunc].execution_time_max = *execTime;
7203     }
7204
7205   fail:
7206     return rc;
7207 }
7208
7209 /*
7210  * rx_IncrementTimeAndCount - increment the times and count for a particular
7211  * rpc function.
7212  *
7213  * PARAMETERS
7214  *
7215  * IN peer - the peer who invoked the rpc
7216  *
7217  * IN rxInterface - a unique number that identifies the rpc interface
7218  *
7219  * IN currentFunc - the index of the function being invoked
7220  *
7221  * IN totalFunc - the total number of functions in this interface
7222  *
7223  * IN queueTime - the amount of time this function waited for a thread
7224  *
7225  * IN execTime - the amount of time this function invocation took to execute
7226  *
7227  * IN bytesSent - the number bytes sent by this invocation
7228  *
7229  * IN bytesRcvd - the number bytes received by this invocation
7230  *
7231  * IN isServer - if true, this invocation was made to a server
7232  *
7233  * RETURN CODES
7234  *
7235  * Returns void.
7236  */
7237
7238 void
7239 rx_IncrementTimeAndCount(struct rx_peer *peer, afs_uint32 rxInterface,
7240                          afs_uint32 currentFunc, afs_uint32 totalFunc,
7241                          struct clock *queueTime, struct clock *execTime,
7242                          afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd,
7243                          int isServer)
7244 {
7245
7246     if (!(rxi_monitor_peerStats || rxi_monitor_processStats))
7247         return;
7248
7249     MUTEX_ENTER(&rx_rpc_stats);
7250     MUTEX_ENTER(&peer->peer_lock);
7251
7252     if (rxi_monitor_peerStats) {
7253         rxi_AddRpcStat(&peer->rpcStats, rxInterface, currentFunc, totalFunc,
7254                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
7255                        peer->host, peer->port, 1, &rxi_rpc_peer_stat_cnt);
7256     }
7257
7258     if (rxi_monitor_processStats) {
7259         rxi_AddRpcStat(&processStats, rxInterface, currentFunc, totalFunc,
7260                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
7261                        0xffffffff, 0xffffffff, 0, &rxi_rpc_process_stat_cnt);
7262     }
7263
7264     MUTEX_EXIT(&peer->peer_lock);
7265     MUTEX_EXIT(&rx_rpc_stats);
7266
7267 }
7268
7269 /*
7270  * rx_MarshallProcessRPCStats - marshall an array of rpc statistics
7271  *
7272  * PARAMETERS
7273  *
7274  * IN callerVersion - the rpc stat version of the caller.
7275  *
7276  * IN count - the number of entries to marshall.
7277  *
7278  * IN stats - pointer to stats to be marshalled.
7279  *
7280  * OUT ptr - Where to store the marshalled data.
7281  *
7282  * RETURN CODES
7283  *
7284  * Returns void.
7285  */
7286 void
7287 rx_MarshallProcessRPCStats(afs_uint32 callerVersion, int count,
7288                            rx_function_entry_v1_t * stats, afs_uint32 ** ptrP)
7289 {
7290     int i;
7291     afs_uint32 *ptr;
7292
7293     /*
7294      * We only support the first version
7295      */
7296     for (ptr = *ptrP, i = 0; i < count; i++, stats++) {
7297         *(ptr++) = stats->remote_peer;
7298         *(ptr++) = stats->remote_port;
7299         *(ptr++) = stats->remote_is_server;
7300         *(ptr++) = stats->interfaceId;
7301         *(ptr++) = stats->func_total;
7302         *(ptr++) = stats->func_index;
7303         *(ptr++) = hgethi(stats->invocations);
7304         *(ptr++) = hgetlo(stats->invocations);
7305         *(ptr++) = hgethi(stats->bytes_sent);
7306         *(ptr++) = hgetlo(stats->bytes_sent);
7307         *(ptr++) = hgethi(stats->bytes_rcvd);
7308         *(ptr++) = hgetlo(stats->bytes_rcvd);
7309         *(ptr++) = stats->queue_time_sum.sec;
7310         *(ptr++) = stats->queue_time_sum.usec;
7311         *(ptr++) = stats->queue_time_sum_sqr.sec;
7312         *(ptr++) = stats->queue_time_sum_sqr.usec;
7313         *(ptr++) = stats->queue_time_min.sec;
7314         *(ptr++) = stats->queue_time_min.usec;
7315         *(ptr++) = stats->queue_time_max.sec;
7316         *(ptr++) = stats->queue_time_max.usec;
7317         *(ptr++) = stats->execution_time_sum.sec;
7318         *(ptr++) = stats->execution_time_sum.usec;
7319         *(ptr++) = stats->execution_time_sum_sqr.sec;
7320         *(ptr++) = stats->execution_time_sum_sqr.usec;
7321         *(ptr++) = stats->execution_time_min.sec;
7322         *(ptr++) = stats->execution_time_min.usec;
7323         *(ptr++) = stats->execution_time_max.sec;
7324         *(ptr++) = stats->execution_time_max.usec;
7325     }
7326     *ptrP = ptr;
7327 }
7328
7329 /*
7330  * rx_RetrieveProcessRPCStats - retrieve all of the rpc statistics for
7331  * this process
7332  *
7333  * PARAMETERS
7334  *
7335  * IN callerVersion - the rpc stat version of the caller
7336  *
7337  * OUT myVersion - the rpc stat version of this function
7338  *
7339  * OUT clock_sec - local time seconds
7340  *
7341  * OUT clock_usec - local time microseconds
7342  *
7343  * OUT allocSize - the number of bytes allocated to contain stats
7344  *
7345  * OUT statCount - the number stats retrieved from this process.
7346  *
7347  * OUT stats - the actual stats retrieved from this process.
7348  *
7349  * RETURN CODES
7350  *
7351  * Returns void.  If successful, stats will != NULL.
7352  */
7353
7354 int
7355 rx_RetrieveProcessRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
7356                            afs_uint32 * clock_sec, afs_uint32 * clock_usec,
7357                            size_t * allocSize, afs_uint32 * statCount,
7358                            afs_uint32 ** stats)
7359 {
7360     size_t space = 0;
7361     afs_uint32 *ptr;
7362     struct clock now;
7363     int rc = 0;
7364
7365     *stats = 0;
7366     *allocSize = 0;
7367     *statCount = 0;
7368     *myVersion = RX_STATS_RETRIEVAL_VERSION;
7369
7370     /*
7371      * Check to see if stats are enabled
7372      */
7373
7374     MUTEX_ENTER(&rx_rpc_stats);
7375     if (!rxi_monitor_processStats) {
7376         MUTEX_EXIT(&rx_rpc_stats);
7377         return rc;
7378     }
7379
7380     clock_GetTime(&now);
7381     *clock_sec = now.sec;
7382     *clock_usec = now.usec;
7383
7384     /*
7385      * Allocate the space based upon the caller version
7386      *
7387      * If the client is at an older version than we are,
7388      * we return the statistic data in the older data format, but
7389      * we still return our version number so the client knows we
7390      * are maintaining more data than it can retrieve.
7391      */
7392
7393     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
7394         space = rxi_rpc_process_stat_cnt * sizeof(rx_function_entry_v1_t);
7395         *statCount = rxi_rpc_process_stat_cnt;
7396     } else {
7397         /*
7398          * This can't happen yet, but in the future version changes
7399          * can be handled by adding additional code here
7400          */
7401     }
7402
7403     if (space > (size_t) 0) {
7404         *allocSize = space;
7405         ptr = *stats = (afs_uint32 *) rxi_Alloc(space);
7406
7407         if (ptr != NULL) {
7408             rx_interface_stat_p rpc_stat, nrpc_stat;
7409
7410
7411             for (queue_Scan
7412                  (&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7413                 /*
7414                  * Copy the data based upon the caller version
7415                  */
7416                 rx_MarshallProcessRPCStats(callerVersion,
7417                                            rpc_stat->stats[0].func_total,
7418                                            rpc_stat->stats, &ptr);
7419             }
7420         } else {
7421             rc = ENOMEM;
7422         }
7423     }
7424     MUTEX_EXIT(&rx_rpc_stats);
7425     return rc;
7426 }
7427
7428 /*
7429  * rx_RetrievePeerRPCStats - retrieve all of the rpc statistics for the peers
7430  *
7431  * PARAMETERS
7432  *
7433  * IN callerVersion - the rpc stat version of the caller
7434  *
7435  * OUT myVersion - the rpc stat version of this function
7436  *
7437  * OUT clock_sec - local time seconds
7438  *
7439  * OUT clock_usec - local time microseconds
7440  *
7441  * OUT allocSize - the number of bytes allocated to contain stats
7442  *
7443  * OUT statCount - the number of stats retrieved from the individual
7444  * peer structures.
7445  *
7446  * OUT stats - the actual stats retrieved from the individual peer structures.
7447  *
7448  * RETURN CODES
7449  *
7450  * Returns void.  If successful, stats will != NULL.
7451  */
7452
7453 int
7454 rx_RetrievePeerRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
7455                         afs_uint32 * clock_sec, afs_uint32 * clock_usec,
7456                         size_t * allocSize, afs_uint32 * statCount,
7457                         afs_uint32 ** stats)
7458 {
7459     size_t space = 0;
7460     afs_uint32 *ptr;
7461     struct clock now;
7462     int rc = 0;
7463
7464     *stats = 0;
7465     *statCount = 0;
7466     *allocSize = 0;
7467     *myVersion = RX_STATS_RETRIEVAL_VERSION;
7468
7469     /*
7470      * Check to see if stats are enabled
7471      */
7472
7473     MUTEX_ENTER(&rx_rpc_stats);
7474     if (!rxi_monitor_peerStats) {
7475         MUTEX_EXIT(&rx_rpc_stats);
7476         return rc;
7477     }
7478
7479     clock_GetTime(&now);
7480     *clock_sec = now.sec;
7481     *clock_usec = now.usec;
7482
7483     /*
7484      * Allocate the space based upon the caller version
7485      *
7486      * If the client is at an older version than we are,
7487      * we return the statistic data in the older data format, but
7488      * we still return our version number so the client knows we
7489      * are maintaining more data than it can retrieve.
7490      */
7491
7492     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
7493         space = rxi_rpc_peer_stat_cnt * sizeof(rx_function_entry_v1_t);
7494         *statCount = rxi_rpc_peer_stat_cnt;
7495     } else {
7496         /*
7497          * This can't happen yet, but in the future version changes
7498          * can be handled by adding additional code here
7499          */
7500     }
7501
7502     if (space > (size_t) 0) {
7503         *allocSize = space;
7504         ptr = *stats = (afs_uint32 *) rxi_Alloc(space);
7505
7506         if (ptr != NULL) {
7507             rx_interface_stat_p rpc_stat, nrpc_stat;
7508             char *fix_offset;
7509
7510             for (queue_Scan
7511                  (&peerStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7512                 /*
7513                  * We have to fix the offset of rpc_stat since we are
7514                  * keeping this structure on two rx_queues.  The rx_queue
7515                  * package assumes that the rx_queue member is the first
7516                  * member of the structure.  That is, rx_queue assumes that
7517                  * any one item is only on one queue at a time.  We are
7518                  * breaking that assumption and so we have to do a little
7519                  * math to fix our pointers.
7520                  */
7521
7522                 fix_offset = (char *)rpc_stat;
7523                 fix_offset -= offsetof(rx_interface_stat_t, all_peers);
7524                 rpc_stat = (rx_interface_stat_p) fix_offset;
7525
7526                 /*
7527                  * Copy the data based upon the caller version
7528                  */
7529                 rx_MarshallProcessRPCStats(callerVersion,
7530                                            rpc_stat->stats[0].func_total,
7531                                            rpc_stat->stats, &ptr);
7532             }
7533         } else {
7534             rc = ENOMEM;
7535         }
7536     }
7537     MUTEX_EXIT(&rx_rpc_stats);
7538     return rc;
7539 }
7540
7541 /*
7542  * rx_FreeRPCStats - free memory allocated by
7543  *                   rx_RetrieveProcessRPCStats and rx_RetrievePeerRPCStats
7544  *
7545  * PARAMETERS
7546  *
7547  * IN stats - stats previously returned by rx_RetrieveProcessRPCStats or
7548  * rx_RetrievePeerRPCStats
7549  *
7550  * IN allocSize - the number of bytes in stats.
7551  *
7552  * RETURN CODES
7553  *
7554  * Returns void.
7555  */
7556
7557 void
7558 rx_FreeRPCStats(afs_uint32 * stats, size_t allocSize)
7559 {
7560     rxi_Free(stats, allocSize);
7561 }
7562
7563 /*
7564  * rx_queryProcessRPCStats - see if process rpc stat collection is
7565  * currently enabled.
7566  *
7567  * PARAMETERS
7568  *
7569  * RETURN CODES
7570  *
7571  * Returns 0 if stats are not enabled != 0 otherwise
7572  */
7573
7574 int
7575 rx_queryProcessRPCStats(void)
7576 {
7577     int rc;
7578     MUTEX_ENTER(&rx_rpc_stats);
7579     rc = rxi_monitor_processStats;
7580     MUTEX_EXIT(&rx_rpc_stats);
7581     return rc;
7582 }
7583
7584 /*
7585  * rx_queryPeerRPCStats - see if peer stat collection is currently enabled.
7586  *
7587  * PARAMETERS
7588  *
7589  * RETURN CODES
7590  *
7591  * Returns 0 if stats are not enabled != 0 otherwise
7592  */
7593
7594 int
7595 rx_queryPeerRPCStats(void)
7596 {
7597     int rc;
7598     MUTEX_ENTER(&rx_rpc_stats);
7599     rc = rxi_monitor_peerStats;
7600     MUTEX_EXIT(&rx_rpc_stats);
7601     return rc;
7602 }
7603
7604 /*
7605  * rx_enableProcessRPCStats - begin rpc stat collection for entire process
7606  *
7607  * PARAMETERS
7608  *
7609  * RETURN CODES
7610  *
7611  * Returns void.
7612  */
7613
7614 void
7615 rx_enableProcessRPCStats(void)
7616 {
7617     MUTEX_ENTER(&rx_rpc_stats);
7618     rx_enable_stats = 1;
7619     rxi_monitor_processStats = 1;
7620     MUTEX_EXIT(&rx_rpc_stats);
7621 }
7622
7623 /*
7624  * rx_enablePeerRPCStats - begin rpc stat collection per peer structure
7625  *
7626  * PARAMETERS
7627  *
7628  * RETURN CODES
7629  *
7630  * Returns void.
7631  */
7632
7633 void
7634 rx_enablePeerRPCStats(void)
7635 {
7636     MUTEX_ENTER(&rx_rpc_stats);
7637     rx_enable_stats = 1;
7638     rxi_monitor_peerStats = 1;
7639     MUTEX_EXIT(&rx_rpc_stats);
7640 }
7641
7642 /*
7643  * rx_disableProcessRPCStats - stop rpc stat collection for entire process
7644  *
7645  * PARAMETERS
7646  *
7647  * RETURN CODES
7648  *
7649  * Returns void.
7650  */
7651
7652 void
7653 rx_disableProcessRPCStats(void)
7654 {
7655     rx_interface_stat_p rpc_stat, nrpc_stat;
7656     size_t space;
7657
7658     MUTEX_ENTER(&rx_rpc_stats);
7659
7660     /*
7661      * Turn off process statistics and if peer stats is also off, turn
7662      * off everything
7663      */
7664
7665     rxi_monitor_processStats = 0;
7666     if (rxi_monitor_peerStats == 0) {
7667         rx_enable_stats = 0;
7668     }
7669
7670     for (queue_Scan(&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7671         unsigned int num_funcs = 0;
7672         if (!rpc_stat)
7673             break;
7674         queue_Remove(rpc_stat);
7675         num_funcs = rpc_stat->stats[0].func_total;
7676         space =
7677             sizeof(rx_interface_stat_t) +
7678             rpc_stat->stats[0].func_total * sizeof(rx_function_entry_v1_t);
7679
7680         rxi_Free(rpc_stat, space);
7681         rxi_rpc_process_stat_cnt -= num_funcs;
7682     }
7683     MUTEX_EXIT(&rx_rpc_stats);
7684 }
7685
7686 /*
7687  * rx_disablePeerRPCStats - stop rpc stat collection for peers
7688  *
7689  * PARAMETERS
7690  *
7691  * RETURN CODES
7692  *
7693  * Returns void.
7694  */
7695
7696 void
7697 rx_disablePeerRPCStats(void)
7698 {
7699     struct rx_peer **peer_ptr, **peer_end;
7700     int code;
7701
7702     MUTEX_ENTER(&rx_rpc_stats);
7703
7704     /*
7705      * Turn off peer statistics and if process stats is also off, turn
7706      * off everything
7707      */
7708
7709     rxi_monitor_peerStats = 0;
7710     if (rxi_monitor_processStats == 0) {
7711         rx_enable_stats = 0;
7712     }
7713
7714     MUTEX_ENTER(&rx_peerHashTable_lock);
7715     for (peer_ptr = &rx_peerHashTable[0], peer_end =
7716          &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
7717          peer_ptr++) {
7718         struct rx_peer *peer, *next, *prev;
7719         for (prev = peer = *peer_ptr; peer; peer = next) {
7720             next = peer->next;
7721             code = MUTEX_TRYENTER(&peer->peer_lock);
7722             if (code) {
7723                 rx_interface_stat_p rpc_stat, nrpc_stat;
7724                 size_t space;
7725                 for (queue_Scan
7726                      (&peer->rpcStats, rpc_stat, nrpc_stat,
7727                       rx_interface_stat)) {
7728                     unsigned int num_funcs = 0;
7729                     if (!rpc_stat)
7730                         break;
7731                     queue_Remove(&rpc_stat->queue_header);
7732                     queue_Remove(&rpc_stat->all_peers);
7733                     num_funcs = rpc_stat->stats[0].func_total;
7734                     space =
7735                         sizeof(rx_interface_stat_t) +
7736                         rpc_stat->stats[0].func_total *
7737                         sizeof(rx_function_entry_v1_t);
7738
7739                     rxi_Free(rpc_stat, space);
7740                     rxi_rpc_peer_stat_cnt -= num_funcs;
7741                 }
7742                 MUTEX_EXIT(&peer->peer_lock);
7743                 if (prev == *peer_ptr) {
7744                     *peer_ptr = next;
7745                     prev = next;
7746                 } else
7747                     prev->next = next;
7748             } else {
7749                 prev = peer;
7750             }
7751         }
7752     }
7753     MUTEX_EXIT(&rx_peerHashTable_lock);
7754     MUTEX_EXIT(&rx_rpc_stats);
7755 }
7756
7757 /*
7758  * rx_clearProcessRPCStats - clear the contents of the rpc stats according
7759  * to clearFlag
7760  *
7761  * PARAMETERS
7762  *
7763  * IN clearFlag - flag indicating which stats to clear
7764  *
7765  * RETURN CODES
7766  *
7767  * Returns void.
7768  */
7769
7770 void
7771 rx_clearProcessRPCStats(afs_uint32 clearFlag)
7772 {
7773     rx_interface_stat_p rpc_stat, nrpc_stat;
7774
7775     MUTEX_ENTER(&rx_rpc_stats);
7776
7777     for (queue_Scan(&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7778         unsigned int num_funcs = 0, i;
7779         num_funcs = rpc_stat->stats[0].func_total;
7780         for (i = 0; i < num_funcs; i++) {
7781             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
7782                 hzero(rpc_stat->stats[i].invocations);
7783             }
7784             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
7785                 hzero(rpc_stat->stats[i].bytes_sent);
7786             }
7787             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
7788                 hzero(rpc_stat->stats[i].bytes_rcvd);
7789             }
7790             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
7791                 rpc_stat->stats[i].queue_time_sum.sec = 0;
7792                 rpc_stat->stats[i].queue_time_sum.usec = 0;
7793             }
7794             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
7795                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7796                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7797             }
7798             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
7799                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
7800                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
7801             }
7802             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
7803                 rpc_stat->stats[i].queue_time_max.sec = 0;
7804                 rpc_stat->stats[i].queue_time_max.usec = 0;
7805             }
7806             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
7807                 rpc_stat->stats[i].execution_time_sum.sec = 0;
7808                 rpc_stat->stats[i].execution_time_sum.usec = 0;
7809             }
7810             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
7811                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7812                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7813             }
7814             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
7815                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
7816                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
7817             }
7818             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
7819                 rpc_stat->stats[i].execution_time_max.sec = 0;
7820                 rpc_stat->stats[i].execution_time_max.usec = 0;
7821             }
7822         }
7823     }
7824
7825     MUTEX_EXIT(&rx_rpc_stats);
7826 }
7827
7828 /*
7829  * rx_clearPeerRPCStats - clear the contents of the rpc stats according
7830  * to clearFlag
7831  *
7832  * PARAMETERS
7833  *
7834  * IN clearFlag - flag indicating which stats to clear
7835  *
7836  * RETURN CODES
7837  *
7838  * Returns void.
7839  */
7840
7841 void
7842 rx_clearPeerRPCStats(afs_uint32 clearFlag)
7843 {
7844     rx_interface_stat_p rpc_stat, nrpc_stat;
7845
7846     MUTEX_ENTER(&rx_rpc_stats);
7847
7848     for (queue_Scan(&peerStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7849         unsigned int num_funcs = 0, i;
7850         char *fix_offset;
7851         /*
7852          * We have to fix the offset of rpc_stat since we are
7853          * keeping this structure on two rx_queues.  The rx_queue
7854          * package assumes that the rx_queue member is the first
7855          * member of the structure.  That is, rx_queue assumes that
7856          * any one item is only on one queue at a time.  We are
7857          * breaking that assumption and so we have to do a little
7858          * math to fix our pointers.
7859          */
7860
7861         fix_offset = (char *)rpc_stat;
7862         fix_offset -= offsetof(rx_interface_stat_t, all_peers);
7863         rpc_stat = (rx_interface_stat_p) fix_offset;
7864
7865         num_funcs = rpc_stat->stats[0].func_total;
7866         for (i = 0; i < num_funcs; i++) {
7867             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
7868                 hzero(rpc_stat->stats[i].invocations);
7869             }
7870             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
7871                 hzero(rpc_stat->stats[i].bytes_sent);
7872             }
7873             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
7874                 hzero(rpc_stat->stats[i].bytes_rcvd);
7875             }
7876             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
7877                 rpc_stat->stats[i].queue_time_sum.sec = 0;
7878                 rpc_stat->stats[i].queue_time_sum.usec = 0;
7879             }
7880             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
7881                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7882                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7883             }
7884             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
7885                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
7886                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
7887             }
7888             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
7889                 rpc_stat->stats[i].queue_time_max.sec = 0;
7890                 rpc_stat->stats[i].queue_time_max.usec = 0;
7891             }
7892             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
7893                 rpc_stat->stats[i].execution_time_sum.sec = 0;
7894                 rpc_stat->stats[i].execution_time_sum.usec = 0;
7895             }
7896             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
7897                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7898                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7899             }
7900             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
7901                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
7902                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
7903             }
7904             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
7905                 rpc_stat->stats[i].execution_time_max.sec = 0;
7906                 rpc_stat->stats[i].execution_time_max.usec = 0;
7907             }
7908         }
7909     }
7910
7911     MUTEX_EXIT(&rx_rpc_stats);
7912 }
7913
7914 /*
7915  * rxi_rxstat_userok points to a routine that returns 1 if the caller
7916  * is authorized to enable/disable/clear RX statistics.
7917  */
7918 static int (*rxi_rxstat_userok) (struct rx_call * call) = NULL;
7919
7920 void
7921 rx_SetRxStatUserOk(int (*proc) (struct rx_call * call))
7922 {
7923     rxi_rxstat_userok = proc;
7924 }
7925
7926 int
7927 rx_RxStatUserOk(struct rx_call *call)
7928 {
7929     if (!rxi_rxstat_userok)
7930         return 0;
7931     return rxi_rxstat_userok(call);
7932 }
7933
7934 #ifdef AFS_NT40_ENV
7935 /*
7936  * DllMain() -- Entry-point function called by the DllMainCRTStartup()
7937  *     function in the MSVC runtime DLL (msvcrt.dll).
7938  *
7939  *     Note: the system serializes calls to this function.
7940  */
7941 BOOL WINAPI
7942 DllMain(HINSTANCE dllInstHandle,        /* instance handle for this DLL module */
7943         DWORD reason,                   /* reason function is being called */
7944         LPVOID reserved)                /* reserved for future use */
7945 {
7946     switch (reason) {
7947     case DLL_PROCESS_ATTACH:
7948         /* library is being attached to a process */
7949         INIT_PTHREAD_LOCKS;
7950         return TRUE;
7951
7952     case DLL_PROCESS_DETACH:
7953         return TRUE;
7954
7955     default:
7956         return FALSE;
7957     }
7958 }
7959 #endif
7960