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