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