src/rx/rx.c

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