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             if (type == RX_CLIENT_CONNECTION && (conn->epoch & 0x80000000))
2313                 break;
2314         }
2315         if (!flag) {
2316             /* the connection rxLastConn that was used the last time is not the
2317              ** one we are looking for now. Hence, start searching in the hash */
2318             flag = 1;
2319             conn = rx_connHashTable[hashindex];
2320         } else
2321             conn = conn->next;
2322     }
2323     if (!conn) {
2324         struct rx_service *service;
2325         if (type == RX_CLIENT_CONNECTION) {
2326             MUTEX_EXIT(&rx_connHashTable_lock);
2327             return (struct rx_connection *)0;
2328         }
2329         service = rxi_FindService(socket, serviceId);
2330         if (!service || (securityIndex >= service->nSecurityObjects)
2331             || (service->securityObjects[securityIndex] == 0)) {
2332             MUTEX_EXIT(&rx_connHashTable_lock);
2333             return (struct rx_connection *)0;
2334         }
2335         conn = rxi_AllocConnection();   /* This bzero's the connection */
2336         MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
2337         MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
2338         CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
2339         conn->next = rx_connHashTable[hashindex];
2340         rx_connHashTable[hashindex] = conn;
2341         conn->peer = rxi_FindPeer(host, port, 0, 1);
2342         conn->type = RX_SERVER_CONNECTION;
2343         conn->lastSendTime = clock_Sec();       /* don't GC immediately */
2344         conn->epoch = epoch;
2345         conn->cid = cid & RX_CIDMASK;
2346         /* conn->serial = conn->lastSerial = 0; */
2347         /* conn->timeout = 0; */
2348         conn->ackRate = RX_FAST_ACK_RATE;
2349         conn->service = service;
2350         conn->serviceId = serviceId;
2351         conn->securityIndex = securityIndex;
2352         conn->securityObject = service->securityObjects[securityIndex];
2353         conn->nSpecific = 0;
2354         conn->specific = NULL;
2355         rx_SetConnDeadTime(conn, service->connDeadTime);
2356         rx_SetConnIdleDeadTime(conn, service->idleDeadTime);
2357         /* Notify security object of the new connection */
2358         RXS_NewConnection(conn->securityObject, conn);
2359         /* XXXX Connection timeout? */
2360         if (service->newConnProc)
2361             (*service->newConnProc) (conn);
2362         MUTEX_ENTER(&rx_stats_mutex);
2363         rx_stats.nServerConns++;
2364         MUTEX_EXIT(&rx_stats_mutex);
2365     }
2366
2367     MUTEX_ENTER(&conn->conn_data_lock);
2368     conn->refCount++;
2369     MUTEX_EXIT(&conn->conn_data_lock);
2370
2371     rxLastConn = conn;          /* store this connection as the last conn used */
2372     MUTEX_EXIT(&rx_connHashTable_lock);
2373     return conn;
2374 }
2375
2376 /* There are two packet tracing routines available for testing and monitoring
2377  * Rx.  One is called just after every packet is received and the other is
2378  * called just before every packet is sent.  Received packets, have had their
2379  * headers decoded, and packets to be sent have not yet had their headers
2380  * encoded.  Both take two parameters: a pointer to the packet and a sockaddr
2381  * containing the network address.  Both can be modified.  The return value, if
2382  * non-zero, indicates that the packet should be dropped.  */
2383
2384 int (*rx_justReceived) () = 0;
2385 int (*rx_almostSent) () = 0;
2386
2387 /* A packet has been received off the interface.  Np is the packet, socket is
2388  * the socket number it was received from (useful in determining which service
2389  * this packet corresponds to), and (host, port) reflect the host,port of the
2390  * sender.  This call returns the packet to the caller if it is finished with
2391  * it, rather than de-allocating it, just as a small performance hack */
2392
2393 struct rx_packet *
2394 rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
2395                   afs_uint32 host, u_short port, int *tnop,
2396                   struct rx_call **newcallp)
2397 {
2398     register struct rx_call *call;
2399     register struct rx_connection *conn;
2400     int channel;
2401     afs_uint32 currentCallNumber;
2402     int type;
2403     int skew;
2404 #ifdef RXDEBUG
2405     char *packetType;
2406 #endif
2407     struct rx_packet *tnp;
2408
2409 #ifdef RXDEBUG
2410 /* We don't print out the packet until now because (1) the time may not be
2411  * accurate enough until now in the lwp implementation (rx_Listener only gets
2412  * the time after the packet is read) and (2) from a protocol point of view,
2413  * this is the first time the packet has been seen */
2414     packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
2415         ? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
2416     dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %x",
2417          np->header.serial, packetType, host, port, np->header.serviceId,
2418          np->header.epoch, np->header.cid, np->header.callNumber,
2419          np->header.seq, np->header.flags, np));
2420 #endif
2421
2422     if (np->header.type == RX_PACKET_TYPE_VERSION) {
2423         return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
2424     }
2425
2426     if (np->header.type == RX_PACKET_TYPE_DEBUG) {
2427         return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
2428     }
2429 #ifdef RXDEBUG
2430     /* If an input tracer function is defined, call it with the packet and
2431      * network address.  Note this function may modify its arguments. */
2432     if (rx_justReceived) {
2433         struct sockaddr_in addr;
2434         int drop;
2435         addr.sin_family = AF_INET;
2436         addr.sin_port = port;
2437         addr.sin_addr.s_addr = host;
2438 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
2439         addr.sin_len = sizeof(addr);
2440 #endif /* AFS_OSF_ENV */
2441         drop = (*rx_justReceived) (np, &addr);
2442         /* drop packet if return value is non-zero */
2443         if (drop)
2444             return np;
2445         port = addr.sin_port;   /* in case fcn changed addr */
2446         host = addr.sin_addr.s_addr;
2447     }
2448 #endif
2449
2450     /* If packet was not sent by the client, then *we* must be the client */
2451     type = ((np->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED)
2452         ? RX_CLIENT_CONNECTION : RX_SERVER_CONNECTION;
2453
2454     /* Find the connection (or fabricate one, if we're the server & if
2455      * necessary) associated with this packet */
2456     conn =
2457         rxi_FindConnection(socket, host, port, np->header.serviceId,
2458                            np->header.cid, np->header.epoch, type,
2459                            np->header.securityIndex);
2460
2461     if (!conn) {
2462         /* If no connection found or fabricated, just ignore the packet.
2463          * (An argument could be made for sending an abort packet for
2464          * the conn) */
2465         return np;
2466     }
2467
2468     MUTEX_ENTER(&conn->conn_data_lock);
2469     if (conn->maxSerial < np->header.serial)
2470         conn->maxSerial = np->header.serial;
2471     MUTEX_EXIT(&conn->conn_data_lock);
2472
2473     /* If the connection is in an error state, send an abort packet and ignore
2474      * the incoming packet */
2475     if (conn->error) {
2476         /* Don't respond to an abort packet--we don't want loops! */
2477         MUTEX_ENTER(&conn->conn_data_lock);
2478         if (np->header.type != RX_PACKET_TYPE_ABORT)
2479             np = rxi_SendConnectionAbort(conn, np, 1, 0);
2480         conn->refCount--;
2481         MUTEX_EXIT(&conn->conn_data_lock);
2482         return np;
2483     }
2484
2485     /* Check for connection-only requests (i.e. not call specific). */
2486     if (np->header.callNumber == 0) {
2487         switch (np->header.type) {
2488         case RX_PACKET_TYPE_ABORT:
2489             /* What if the supplied error is zero? */
2490             rxi_ConnectionError(conn, ntohl(rx_GetInt32(np, 0)));
2491             MUTEX_ENTER(&conn->conn_data_lock);
2492             conn->refCount--;
2493             MUTEX_EXIT(&conn->conn_data_lock);
2494             return np;
2495         case RX_PACKET_TYPE_CHALLENGE:
2496             tnp = rxi_ReceiveChallengePacket(conn, np, 1);
2497             MUTEX_ENTER(&conn->conn_data_lock);
2498             conn->refCount--;
2499             MUTEX_EXIT(&conn->conn_data_lock);
2500             return tnp;
2501         case RX_PACKET_TYPE_RESPONSE:
2502             tnp = rxi_ReceiveResponsePacket(conn, np, 1);
2503             MUTEX_ENTER(&conn->conn_data_lock);
2504             conn->refCount--;
2505             MUTEX_EXIT(&conn->conn_data_lock);
2506             return tnp;
2507         case RX_PACKET_TYPE_PARAMS:
2508         case RX_PACKET_TYPE_PARAMS + 1:
2509         case RX_PACKET_TYPE_PARAMS + 2:
2510             /* ignore these packet types for now */
2511             MUTEX_ENTER(&conn->conn_data_lock);
2512             conn->refCount--;
2513             MUTEX_EXIT(&conn->conn_data_lock);
2514             return np;
2515
2516
2517         default:
2518             /* Should not reach here, unless the peer is broken: send an
2519              * abort packet */
2520             rxi_ConnectionError(conn, RX_PROTOCOL_ERROR);
2521             MUTEX_ENTER(&conn->conn_data_lock);
2522             tnp = rxi_SendConnectionAbort(conn, np, 1, 0);
2523             conn->refCount--;
2524             MUTEX_EXIT(&conn->conn_data_lock);
2525             return tnp;
2526         }
2527     }
2528
2529     channel = np->header.cid & RX_CHANNELMASK;
2530     call = conn->call[channel];
2531 #ifdef  RX_ENABLE_LOCKS
2532     if (call)
2533         MUTEX_ENTER(&call->lock);
2534     /* Test to see if call struct is still attached to conn. */
2535     if (call != conn->call[channel]) {
2536         if (call)
2537             MUTEX_EXIT(&call->lock);
2538         if (type == RX_SERVER_CONNECTION) {
2539             call = conn->call[channel];
2540             /* If we started with no call attached and there is one now,
2541              * another thread is also running this routine and has gotten
2542              * the connection channel. We should drop this packet in the tests
2543              * below. If there was a call on this connection and it's now
2544              * gone, then we'll be making a new call below.
2545              * If there was previously a call and it's now different then
2546              * the old call was freed and another thread running this routine
2547              * has created a call on this channel. One of these two threads
2548              * has a packet for the old call and the code below handles those
2549              * cases.
2550              */
2551             if (call)
2552                 MUTEX_ENTER(&call->lock);
2553         } else {
2554             /* This packet can't be for this call. If the new call address is
2555              * 0 then no call is running on this channel. If there is a call
2556              * then, since this is a client connection we're getting data for
2557              * it must be for the previous call.
2558              */
2559             MUTEX_ENTER(&rx_stats_mutex);
2560             rx_stats.spuriousPacketsRead++;
2561             MUTEX_EXIT(&rx_stats_mutex);
2562             MUTEX_ENTER(&conn->conn_data_lock);
2563             conn->refCount--;
2564             MUTEX_EXIT(&conn->conn_data_lock);
2565             return np;
2566         }
2567     }
2568 #endif
2569     currentCallNumber = conn->callNumber[channel];
2570
2571     if (type == RX_SERVER_CONNECTION) { /* We're the server */
2572         if (np->header.callNumber < currentCallNumber) {
2573             MUTEX_ENTER(&rx_stats_mutex);
2574             rx_stats.spuriousPacketsRead++;
2575             MUTEX_EXIT(&rx_stats_mutex);
2576 #ifdef  RX_ENABLE_LOCKS
2577             if (call)
2578                 MUTEX_EXIT(&call->lock);
2579 #endif
2580             MUTEX_ENTER(&conn->conn_data_lock);
2581             conn->refCount--;
2582             MUTEX_EXIT(&conn->conn_data_lock);
2583             return np;
2584         }
2585         if (!call) {
2586             MUTEX_ENTER(&conn->conn_call_lock);
2587             call = rxi_NewCall(conn, channel);
2588             MUTEX_EXIT(&conn->conn_call_lock);
2589             *call->callNumber = np->header.callNumber;
2590             call->state = RX_STATE_PRECALL;
2591             clock_GetTime(&call->queueTime);
2592             hzero(call->bytesSent);
2593             hzero(call->bytesRcvd);
2594             rxi_KeepAliveOn(call);
2595         } else if (np->header.callNumber != currentCallNumber) {
2596             /* Wait until the transmit queue is idle before deciding
2597              * whether to reset the current call. Chances are that the
2598              * call will be in ether DALLY or HOLD state once the TQ_BUSY
2599              * flag is cleared.
2600              */
2601 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
2602             while ((call->state == RX_STATE_ACTIVE)
2603                    && (call->flags & RX_CALL_TQ_BUSY)) {
2604                 call->flags |= RX_CALL_TQ_WAIT;
2605 #ifdef RX_ENABLE_LOCKS
2606                 CV_WAIT(&call->cv_tq, &call->lock);
2607 #else /* RX_ENABLE_LOCKS */
2608                 osi_rxSleep(&call->tq);
2609 #endif /* RX_ENABLE_LOCKS */
2610             }
2611 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2612             /* If the new call cannot be taken right now send a busy and set
2613              * the error condition in this call, so that it terminates as
2614              * quickly as possible */
2615             if (call->state == RX_STATE_ACTIVE) {
2616                 struct rx_packet *tp;
2617
2618                 rxi_CallError(call, RX_CALL_DEAD);
2619                 tp = rxi_SendSpecial(call, conn, np, RX_PACKET_TYPE_BUSY,
2620                                      NULL, 0, 1);
2621                 MUTEX_EXIT(&call->lock);
2622                 MUTEX_ENTER(&conn->conn_data_lock);
2623                 conn->refCount--;
2624                 MUTEX_EXIT(&conn->conn_data_lock);
2625                 return tp;
2626             }
2627             rxi_ResetCall(call, 0);
2628             *call->callNumber = np->header.callNumber;
2629             call->state = RX_STATE_PRECALL;
2630             clock_GetTime(&call->queueTime);
2631             hzero(call->bytesSent);
2632             hzero(call->bytesRcvd);
2633             /*
2634              * If the number of queued calls exceeds the overload
2635              * threshold then abort this call.
2636              */
2637             if ((rx_BusyThreshold > 0) && (rx_nWaiting > rx_BusyThreshold)) {
2638                 struct rx_packet *tp;
2639
2640                 rxi_CallError(call, rx_BusyError);
2641                 tp = rxi_SendCallAbort(call, np, 1, 0);
2642                 MUTEX_EXIT(&call->lock);
2643                 MUTEX_ENTER(&conn->conn_data_lock);
2644                 conn->refCount--;
2645                 MUTEX_EXIT(&conn->conn_data_lock);
2646                 return tp;
2647             }
2648             rxi_KeepAliveOn(call);
2649         } else {
2650             /* Continuing call; do nothing here. */
2651         }
2652     } else {                    /* we're the client */
2653         /* Ignore all incoming acknowledgements for calls in DALLY state */
2654         if (call && (call->state == RX_STATE_DALLY)
2655             && (np->header.type == RX_PACKET_TYPE_ACK)) {
2656             MUTEX_ENTER(&rx_stats_mutex);
2657             rx_stats.ignorePacketDally++;
2658             MUTEX_EXIT(&rx_stats_mutex);
2659 #ifdef  RX_ENABLE_LOCKS
2660             if (call) {
2661                 MUTEX_EXIT(&call->lock);
2662             }
2663 #endif
2664             MUTEX_ENTER(&conn->conn_data_lock);
2665             conn->refCount--;
2666             MUTEX_EXIT(&conn->conn_data_lock);
2667             return np;
2668         }
2669
2670         /* Ignore anything that's not relevant to the current call.  If there
2671          * isn't a current call, then no packet is relevant. */
2672         if (!call || (np->header.callNumber != currentCallNumber)) {
2673             MUTEX_ENTER(&rx_stats_mutex);
2674             rx_stats.spuriousPacketsRead++;
2675             MUTEX_EXIT(&rx_stats_mutex);
2676 #ifdef  RX_ENABLE_LOCKS
2677             if (call) {
2678                 MUTEX_EXIT(&call->lock);
2679             }
2680 #endif
2681             MUTEX_ENTER(&conn->conn_data_lock);
2682             conn->refCount--;
2683             MUTEX_EXIT(&conn->conn_data_lock);
2684             return np;
2685         }
2686         /* If the service security object index stamped in the packet does not
2687          * match the connection's security index, ignore the packet */
2688         if (np->header.securityIndex != conn->securityIndex) {
2689 #ifdef  RX_ENABLE_LOCKS
2690             MUTEX_EXIT(&call->lock);
2691 #endif
2692             MUTEX_ENTER(&conn->conn_data_lock);
2693             conn->refCount--;
2694             MUTEX_EXIT(&conn->conn_data_lock);
2695             return np;
2696         }
2697
2698         /* If we're receiving the response, then all transmit packets are
2699          * implicitly acknowledged.  Get rid of them. */
2700         if (np->header.type == RX_PACKET_TYPE_DATA) {
2701 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2702             /* XXX Hack. Because we must release the global rx lock when
2703              * sending packets (osi_NetSend) we drop all acks while we're
2704              * traversing the tq in rxi_Start sending packets out because
2705              * packets may move to the freePacketQueue as result of being here!
2706              * So we drop these packets until we're safely out of the
2707              * traversing. Really ugly!
2708              * For fine grain RX locking, we set the acked field in the
2709              * packets and let rxi_Start remove them from the transmit queue.
2710              */
2711             if (call->flags & RX_CALL_TQ_BUSY) {
2712 #ifdef  RX_ENABLE_LOCKS
2713                 rxi_SetAcksInTransmitQueue(call);
2714 #else
2715                 conn->refCount--;
2716                 return np;      /* xmitting; drop packet */
2717 #endif
2718             } else {
2719                 rxi_ClearTransmitQueue(call, 0);
2720             }
2721 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2722             rxi_ClearTransmitQueue(call, 0);
2723 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2724         } else {
2725             if (np->header.type == RX_PACKET_TYPE_ACK) {
2726                 /* now check to see if this is an ack packet acknowledging that the
2727                  * server actually *lost* some hard-acked data.  If this happens we
2728                  * ignore this packet, as it may indicate that the server restarted in
2729                  * the middle of a call.  It is also possible that this is an old ack
2730                  * packet.  We don't abort the connection in this case, because this
2731                  * *might* just be an old ack packet.  The right way to detect a server
2732                  * restart in the midst of a call is to notice that the server epoch
2733                  * changed, btw.  */
2734                 /* XXX I'm not sure this is exactly right, since tfirst **IS**
2735                  * XXX unacknowledged.  I think that this is off-by-one, but
2736                  * XXX I don't dare change it just yet, since it will
2737                  * XXX interact badly with the server-restart detection
2738                  * XXX code in receiveackpacket.  */
2739                 if (ntohl(rx_GetInt32(np, FIRSTACKOFFSET)) < call->tfirst) {
2740                     MUTEX_ENTER(&rx_stats_mutex);
2741                     rx_stats.spuriousPacketsRead++;
2742                     MUTEX_EXIT(&rx_stats_mutex);
2743                     MUTEX_EXIT(&call->lock);
2744                     MUTEX_ENTER(&conn->conn_data_lock);
2745                     conn->refCount--;
2746                     MUTEX_EXIT(&conn->conn_data_lock);
2747                     return np;
2748                 }
2749             }
2750         }                       /* else not a data packet */
2751     }
2752
2753     osirx_AssertMine(&call->lock, "rxi_ReceivePacket middle");
2754     /* Set remote user defined status from packet */
2755     call->remoteStatus = np->header.userStatus;
2756
2757     /* Note the gap between the expected next packet and the actual
2758      * packet that arrived, when the new packet has a smaller serial number
2759      * than expected.  Rioses frequently reorder packets all by themselves,
2760      * so this will be quite important with very large window sizes.
2761      * Skew is checked against 0 here to avoid any dependence on the type of
2762      * inPacketSkew (which may be unsigned).  In C, -1 > (unsigned) 0 is always
2763      * true!
2764      * The inPacketSkew should be a smoothed running value, not just a maximum.  MTUXXX
2765      * see CalculateRoundTripTime for an example of how to keep smoothed values.
2766      * I think using a beta of 1/8 is probably appropriate.  93.04.21
2767      */
2768     MUTEX_ENTER(&conn->conn_data_lock);
2769     skew = conn->lastSerial - np->header.serial;
2770     conn->lastSerial = np->header.serial;
2771     MUTEX_EXIT(&conn->conn_data_lock);
2772     if (skew > 0) {
2773         register struct rx_peer *peer;
2774         peer = conn->peer;
2775         if (skew > peer->inPacketSkew) {
2776             dpf(("*** In skew changed from %d to %d\n", peer->inPacketSkew,
2777                  skew));
2778             peer->inPacketSkew = skew;
2779         }
2780     }
2781
2782     /* Now do packet type-specific processing */
2783     switch (np->header.type) {
2784     case RX_PACKET_TYPE_DATA:
2785         np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
2786                                    newcallp);
2787         break;
2788     case RX_PACKET_TYPE_ACK:
2789         /* Respond immediately to ack packets requesting acknowledgement
2790          * (ping packets) */
2791         if (np->header.flags & RX_REQUEST_ACK) {
2792             if (call->error)
2793                 (void)rxi_SendCallAbort(call, 0, 1, 0);
2794             else
2795                 (void)rxi_SendAck(call, 0, np->header.serial,
2796                                   RX_ACK_PING_RESPONSE, 1);
2797         }
2798         np = rxi_ReceiveAckPacket(call, np, 1);
2799         break;
2800     case RX_PACKET_TYPE_ABORT:
2801         /* An abort packet: reset the connection, passing the error up to
2802          * the user */
2803         /* What if error is zero? */
2804         rxi_CallError(call, ntohl(*(afs_int32 *) rx_DataOf(np)));
2805         break;
2806     case RX_PACKET_TYPE_BUSY:
2807         /* XXXX */
2808         break;
2809     case RX_PACKET_TYPE_ACKALL:
2810         /* All packets acknowledged, so we can drop all packets previously
2811          * readied for sending */
2812 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2813         /* XXX Hack. We because we can't release the global rx lock when
2814          * sending packets (osi_NetSend) we drop all ack pkts while we're
2815          * traversing the tq in rxi_Start sending packets out because
2816          * packets may move to the freePacketQueue as result of being
2817          * here! So we drop these packets until we're safely out of the
2818          * traversing. Really ugly!
2819          * For fine grain RX locking, we set the acked field in the packets
2820          * and let rxi_Start remove the packets from the transmit queue.
2821          */
2822         if (call->flags & RX_CALL_TQ_BUSY) {
2823 #ifdef  RX_ENABLE_LOCKS
2824             rxi_SetAcksInTransmitQueue(call);
2825             break;
2826 #else /* RX_ENABLE_LOCKS */
2827             conn->refCount--;
2828             return np;          /* xmitting; drop packet */
2829 #endif /* RX_ENABLE_LOCKS */
2830         }
2831 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2832         rxi_ClearTransmitQueue(call, 0);
2833         break;
2834     default:
2835         /* Should not reach here, unless the peer is broken: send an abort
2836          * packet */
2837         rxi_CallError(call, RX_PROTOCOL_ERROR);
2838         np = rxi_SendCallAbort(call, np, 1, 0);
2839         break;
2840     };
2841     /* Note when this last legitimate packet was received, for keep-alive
2842      * processing.  Note, we delay getting the time until now in the hope that
2843      * the packet will be delivered to the user before any get time is required
2844      * (if not, then the time won't actually be re-evaluated here). */
2845     call->lastReceiveTime = clock_Sec();
2846     MUTEX_EXIT(&call->lock);
2847     MUTEX_ENTER(&conn->conn_data_lock);
2848     conn->refCount--;
2849     MUTEX_EXIT(&conn->conn_data_lock);
2850     return np;
2851 }
2852
2853 /* return true if this is an "interesting" connection from the point of view
2854     of someone trying to debug the system */
2855 int
2856 rxi_IsConnInteresting(struct rx_connection *aconn)
2857 {
2858     register int i;
2859     register struct rx_call *tcall;
2860
2861     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
2862         return 1;
2863     for (i = 0; i < RX_MAXCALLS; i++) {
2864         tcall = aconn->call[i];
2865         if (tcall) {
2866             if ((tcall->state == RX_STATE_PRECALL)
2867                 || (tcall->state == RX_STATE_ACTIVE))
2868                 return 1;
2869             if ((tcall->mode == RX_MODE_SENDING)
2870                 || (tcall->mode == RX_MODE_RECEIVING))
2871                 return 1;
2872         }
2873     }
2874     return 0;
2875 }
2876
2877 #ifdef KERNEL
2878 /* if this is one of the last few packets AND it wouldn't be used by the
2879    receiving call to immediately satisfy a read request, then drop it on
2880    the floor, since accepting it might prevent a lock-holding thread from
2881    making progress in its reading. If a call has been cleared while in
2882    the precall state then ignore all subsequent packets until the call
2883    is assigned to a thread. */
2884
2885 static int
2886 TooLow(struct rx_packet *ap, struct rx_call *acall)
2887 {
2888     int rc = 0;
2889     MUTEX_ENTER(&rx_stats_mutex);
2890     if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
2891          && (acall->state == RX_STATE_PRECALL))
2892         || ((rx_nFreePackets < rxi_dataQuota + 2)
2893             && !((ap->header.seq < acall->rnext + rx_initSendWindow)
2894                  && (acall->flags & RX_CALL_READER_WAIT)))) {
2895         rc = 1;
2896     }
2897     MUTEX_EXIT(&rx_stats_mutex);
2898     return rc;
2899 }
2900 #endif /* KERNEL */
2901
2902 static void
2903 rxi_CheckReachEvent(struct rxevent *event, struct rx_connection *conn,
2904                     struct rx_call *acall)
2905 {
2906     struct rx_call *call = acall;
2907     struct clock when;
2908     int i, waiting;
2909
2910     MUTEX_ENTER(&conn->conn_data_lock);
2911     conn->checkReachEvent = NULL;
2912     waiting = conn->flags & RX_CONN_ATTACHWAIT;
2913     if (event)
2914         conn->refCount--;
2915     MUTEX_EXIT(&conn->conn_data_lock);
2916
2917     if (waiting) {
2918         if (!call) {
2919             MUTEX_ENTER(&conn->conn_call_lock);
2920             MUTEX_ENTER(&conn->conn_data_lock);
2921             for (i = 0; i < RX_MAXCALLS; i++) {
2922                 struct rx_call *tc = conn->call[i];
2923                 if (tc && tc->state == RX_STATE_PRECALL) {
2924                     call = tc;
2925                     break;
2926                 }
2927             }
2928             if (!call)
2929                 /* Indicate that rxi_CheckReachEvent is no longer running by
2930                  * clearing the flag.  Must be atomic under conn_data_lock to
2931                  * avoid a new call slipping by: rxi_CheckConnReach holds
2932                  * conn_data_lock while checking RX_CONN_ATTACHWAIT.
2933                  */
2934                 conn->flags &= ~RX_CONN_ATTACHWAIT;
2935             MUTEX_EXIT(&conn->conn_data_lock);
2936             MUTEX_EXIT(&conn->conn_call_lock);
2937         }
2938
2939         if (call) {
2940             if (call != acall)
2941                 MUTEX_ENTER(&call->lock);
2942             rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
2943             if (call != acall)
2944                 MUTEX_EXIT(&call->lock);
2945
2946             clock_GetTime(&when);
2947             when.sec += RX_CHECKREACH_TIMEOUT;
2948             MUTEX_ENTER(&conn->conn_data_lock);
2949             if (!conn->checkReachEvent) {
2950                 conn->refCount++;
2951                 conn->checkReachEvent =
2952                     rxevent_Post(&when, rxi_CheckReachEvent, conn, NULL);
2953             }
2954             MUTEX_EXIT(&conn->conn_data_lock);
2955         }
2956     }
2957 }
2958
2959 static int
2960 rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
2961 {
2962     struct rx_service *service = conn->service;
2963     struct rx_peer *peer = conn->peer;
2964     afs_uint32 now, lastReach;
2965
2966     if (service->checkReach == 0)
2967         return 0;
2968
2969     now = clock_Sec();
2970     MUTEX_ENTER(&peer->peer_lock);
2971     lastReach = peer->lastReachTime;
2972     MUTEX_EXIT(&peer->peer_lock);
2973     if (now - lastReach < RX_CHECKREACH_TTL)
2974         return 0;
2975
2976     MUTEX_ENTER(&conn->conn_data_lock);
2977     if (conn->flags & RX_CONN_ATTACHWAIT) {
2978         MUTEX_EXIT(&conn->conn_data_lock);
2979         return 1;
2980     }
2981     conn->flags |= RX_CONN_ATTACHWAIT;
2982     MUTEX_EXIT(&conn->conn_data_lock);
2983     if (!conn->checkReachEvent)
2984         rxi_CheckReachEvent(NULL, conn, call);
2985
2986     return 1;
2987 }
2988
2989 /* try to attach call, if authentication is complete */
2990 static void
2991 TryAttach(register struct rx_call *acall, register osi_socket socket,
2992           register int *tnop, register struct rx_call **newcallp,
2993           int reachOverride)
2994 {
2995     struct rx_connection *conn = acall->conn;
2996
2997     if (conn->type == RX_SERVER_CONNECTION
2998         && acall->state == RX_STATE_PRECALL) {
2999         /* Don't attach until we have any req'd. authentication. */
3000         if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
3001             if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
3002                 rxi_AttachServerProc(acall, socket, tnop, newcallp);
3003             /* Note:  this does not necessarily succeed; there
3004              * may not any proc available
3005              */
3006         } else {
3007             rxi_ChallengeOn(acall->conn);
3008         }
3009     }
3010 }
3011
3012 /* A data packet has been received off the interface.  This packet is
3013  * appropriate to the call (the call is in the right state, etc.).  This
3014  * routine can return a packet to the caller, for re-use */
3015
3016 struct rx_packet *
3017 rxi_ReceiveDataPacket(register struct rx_call *call,
3018                       register struct rx_packet *np, int istack,
3019                       osi_socket socket, afs_uint32 host, u_short port,
3020                       int *tnop, struct rx_call **newcallp)
3021 {
3022     int ackNeeded = 0;          /* 0 means no, otherwise ack_reason */
3023     int newPackets = 0;
3024     int didHardAck = 0;
3025     int haveLast = 0;
3026     afs_uint32 seq, serial, flags;
3027     int isFirst;
3028     struct rx_packet *tnp;
3029     struct clock when;
3030     MUTEX_ENTER(&rx_stats_mutex);
3031     rx_stats.dataPacketsRead++;
3032     MUTEX_EXIT(&rx_stats_mutex);
3033
3034 #ifdef KERNEL
3035     /* If there are no packet buffers, drop this new packet, unless we can find
3036      * packet buffers from inactive calls */
3037     if (!call->error
3038         && (rxi_OverQuota(RX_PACKET_CLASS_RECEIVE) || TooLow(np, call))) {
3039         MUTEX_ENTER(&rx_freePktQ_lock);
3040         rxi_NeedMorePackets = TRUE;
3041         MUTEX_EXIT(&rx_freePktQ_lock);
3042         MUTEX_ENTER(&rx_stats_mutex);
3043         rx_stats.noPacketBuffersOnRead++;
3044         MUTEX_EXIT(&rx_stats_mutex);
3045         call->rprev = np->header.serial;
3046         rxi_calltrace(RX_TRACE_DROP, call);
3047         dpf(("packet %x dropped on receipt - quota problems", np));
3048         if (rxi_doreclaim)
3049             rxi_ClearReceiveQueue(call);
3050         clock_GetTime(&when);
3051         clock_Add(&when, &rx_softAckDelay);
3052         if (!call->delayedAckEvent
3053             || clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
3054             rxevent_Cancel(call->delayedAckEvent, call,
3055                            RX_CALL_REFCOUNT_DELAY);
3056             CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
3057             call->delayedAckEvent =
3058                 rxevent_Post(&when, rxi_SendDelayedAck, call, 0);
3059         }
3060         /* we've damaged this call already, might as well do it in. */
3061         return np;
3062     }
3063 #endif /* KERNEL */
3064
3065     /*
3066      * New in AFS 3.5, if the RX_JUMBO_PACKET flag is set then this
3067      * packet is one of several packets transmitted as a single
3068      * datagram. Do not send any soft or hard acks until all packets
3069      * in a jumbogram have been processed. Send negative acks right away.
3070      */
3071     for (isFirst = 1, tnp = NULL; isFirst || tnp; isFirst = 0) {
3072         /* tnp is non-null when there are more packets in the
3073          * current jumbo gram */
3074         if (tnp) {
3075             if (np)
3076                 rxi_FreePacket(np);
3077             np = tnp;
3078         }
3079
3080         seq = np->header.seq;
3081         serial = np->header.serial;
3082         flags = np->header.flags;
3083
3084         /* If the call is in an error state, send an abort message */
3085         if (call->error)
3086             return rxi_SendCallAbort(call, np, istack, 0);
3087
3088         /* The RX_JUMBO_PACKET is set in all but the last packet in each
3089          * AFS 3.5 jumbogram. */
3090         if (flags & RX_JUMBO_PACKET) {
3091             tnp = rxi_SplitJumboPacket(np, host, port, isFirst);
3092         } else {
3093             tnp = NULL;
3094         }
3095
3096         if (np->header.spare != 0) {
3097             MUTEX_ENTER(&call->conn->conn_data_lock);
3098             call->conn->flags |= RX_CONN_USING_PACKET_CKSUM;
3099             MUTEX_EXIT(&call->conn->conn_data_lock);
3100         }
3101
3102         /* The usual case is that this is the expected next packet */
3103         if (seq == call->rnext) {
3104
3105             /* Check to make sure it is not a duplicate of one already queued */
3106             if (queue_IsNotEmpty(&call->rq)
3107                 && queue_First(&call->rq, rx_packet)->header.seq == seq) {
3108                 MUTEX_ENTER(&rx_stats_mutex);
3109                 rx_stats.dupPacketsRead++;
3110                 MUTEX_EXIT(&rx_stats_mutex);
3111                 dpf(("packet %x dropped on receipt - duplicate", np));
3112                 rxevent_Cancel(call->delayedAckEvent, call,
3113                                RX_CALL_REFCOUNT_DELAY);
3114                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3115                 ackNeeded = 0;
3116                 call->rprev = seq;
3117                 continue;
3118             }
3119
3120             /* It's the next packet. Stick it on the receive queue
3121              * for this call. Set newPackets to make sure we wake
3122              * the reader once all packets have been processed */
3123             queue_Prepend(&call->rq, np);
3124             call->nSoftAcks++;
3125             np = NULL;          /* We can't use this anymore */
3126             newPackets = 1;
3127
3128             /* If an ack is requested then set a flag to make sure we
3129              * send an acknowledgement for this packet */
3130             if (flags & RX_REQUEST_ACK) {
3131                 ackNeeded = RX_ACK_REQUESTED;
3132             }
3133
3134             /* Keep track of whether we have received the last packet */
3135             if (flags & RX_LAST_PACKET) {
3136                 call->flags |= RX_CALL_HAVE_LAST;
3137                 haveLast = 1;
3138             }
3139
3140             /* Check whether we have all of the packets for this call */
3141             if (call->flags & RX_CALL_HAVE_LAST) {
3142                 afs_uint32 tseq;        /* temporary sequence number */
3143                 struct rx_packet *tp;   /* Temporary packet pointer */
3144                 struct rx_packet *nxp;  /* Next pointer, for queue_Scan */
3145
3146                 for (tseq = seq, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3147                     if (tseq != tp->header.seq)
3148                         break;
3149                     if (tp->header.flags & RX_LAST_PACKET) {
3150                         call->flags |= RX_CALL_RECEIVE_DONE;
3151                         break;
3152                     }
3153                     tseq++;
3154                 }
3155             }
3156
3157             /* Provide asynchronous notification for those who want it
3158              * (e.g. multi rx) */
3159             if (call->arrivalProc) {
3160                 (*call->arrivalProc) (call, call->arrivalProcHandle,
3161                                       (int)call->arrivalProcArg);
3162                 call->arrivalProc = (VOID(*)())0;
3163             }
3164
3165             /* Update last packet received */
3166             call->rprev = seq;
3167
3168             /* If there is no server process serving this call, grab
3169              * one, if available. We only need to do this once. If a
3170              * server thread is available, this thread becomes a server
3171              * thread and the server thread becomes a listener thread. */
3172             if (isFirst) {
3173                 TryAttach(call, socket, tnop, newcallp, 0);
3174             }
3175         }
3176         /* This is not the expected next packet. */
3177         else {
3178             /* Determine whether this is a new or old packet, and if it's
3179              * a new one, whether it fits into the current receive window.
3180              * Also figure out whether the packet was delivered in sequence.
3181              * We use the prev variable to determine whether the new packet
3182              * is the successor of its immediate predecessor in the
3183              * receive queue, and the missing flag to determine whether
3184              * any of this packets predecessors are missing.  */
3185
3186             afs_uint32 prev;    /* "Previous packet" sequence number */
3187             struct rx_packet *tp;       /* Temporary packet pointer */
3188             struct rx_packet *nxp;      /* Next pointer, for queue_Scan */
3189             int missing;        /* Are any predecessors missing? */
3190
3191             /* If the new packet's sequence number has been sent to the
3192              * application already, then this is a duplicate */
3193             if (seq < call->rnext) {
3194                 MUTEX_ENTER(&rx_stats_mutex);
3195                 rx_stats.dupPacketsRead++;
3196                 MUTEX_EXIT(&rx_stats_mutex);
3197                 rxevent_Cancel(call->delayedAckEvent, call,
3198                                RX_CALL_REFCOUNT_DELAY);
3199                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3200                 ackNeeded = 0;
3201                 call->rprev = seq;
3202                 continue;
3203             }
3204
3205             /* If the sequence number is greater than what can be
3206              * accomodated by the current window, then send a negative
3207              * acknowledge and drop the packet */
3208             if ((call->rnext + call->rwind) <= seq) {
3209                 rxevent_Cancel(call->delayedAckEvent, call,
3210                                RX_CALL_REFCOUNT_DELAY);
3211                 np = rxi_SendAck(call, np, serial, RX_ACK_EXCEEDS_WINDOW,
3212                                  istack);
3213                 ackNeeded = 0;
3214                 call->rprev = seq;
3215                 continue;
3216             }
3217
3218             /* Look for the packet in the queue of old received packets */
3219             for (prev = call->rnext - 1, missing =
3220                  0, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3221                 /*Check for duplicate packet */
3222                 if (seq == tp->header.seq) {
3223                     MUTEX_ENTER(&rx_stats_mutex);
3224                     rx_stats.dupPacketsRead++;
3225                     MUTEX_EXIT(&rx_stats_mutex);
3226                     rxevent_Cancel(call->delayedAckEvent, call,
3227                                    RX_CALL_REFCOUNT_DELAY);
3228                     np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE,
3229                                      istack);
3230                     ackNeeded = 0;
3231                     call->rprev = seq;
3232                     goto nextloop;
3233                 }
3234                 /* If we find a higher sequence packet, break out and
3235                  * insert the new packet here. */
3236                 if (seq < tp->header.seq)
3237                     break;
3238                 /* Check for missing packet */
3239                 if (tp->header.seq != prev + 1) {
3240                     missing = 1;
3241                 }
3242
3243                 prev = tp->header.seq;
3244             }
3245
3246             /* Keep track of whether we have received the last packet. */
3247             if (flags & RX_LAST_PACKET) {
3248                 call->flags |= RX_CALL_HAVE_LAST;
3249             }
3250
3251             /* It's within the window: add it to the the receive queue.
3252              * tp is left by the previous loop either pointing at the
3253              * packet before which to insert the new packet, or at the
3254              * queue head if the queue is empty or the packet should be
3255              * appended. */
3256             queue_InsertBefore(tp, np);
3257             call->nSoftAcks++;
3258             np = NULL;
3259
3260             /* Check whether we have all of the packets for this call */
3261             if ((call->flags & RX_CALL_HAVE_LAST)
3262                 && !(call->flags & RX_CALL_RECEIVE_DONE)) {
3263                 afs_uint32 tseq;        /* temporary sequence number */
3264
3265                 for (tseq =
3266                      call->rnext, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3267                     if (tseq != tp->header.seq)
3268                         break;
3269                     if (tp->header.flags & RX_LAST_PACKET) {
3270                         call->flags |= RX_CALL_RECEIVE_DONE;
3271                         break;
3272                     }
3273                     tseq++;
3274                 }
3275             }
3276
3277             /* We need to send an ack of the packet is out of sequence,
3278              * or if an ack was requested by the peer. */
3279             if (seq != prev + 1 || missing || (flags & RX_REQUEST_ACK)) {
3280                 ackNeeded = RX_ACK_OUT_OF_SEQUENCE;
3281             }
3282
3283             /* Acknowledge the last packet for each call */
3284             if (flags & RX_LAST_PACKET) {
3285                 haveLast = 1;
3286             }
3287
3288             call->rprev = seq;
3289         }
3290       nextloop:;
3291     }
3292
3293     if (newPackets) {
3294         /*
3295          * If the receiver is waiting for an iovec, fill the iovec
3296          * using the data from the receive queue */
3297         if (call->flags & RX_CALL_IOVEC_WAIT) {
3298             didHardAck = rxi_FillReadVec(call, serial);
3299             /* the call may have been aborted */
3300             if (call->error) {
3301                 return NULL;
3302             }
3303             if (didHardAck) {
3304                 ackNeeded = 0;
3305             }
3306         }
3307
3308         /* Wakeup the reader if any */
3309         if ((call->flags & RX_CALL_READER_WAIT)
3310             && (!(call->flags & RX_CALL_IOVEC_WAIT) || !(call->iovNBytes)
3311                 || (call->iovNext >= call->iovMax)
3312                 || (call->flags & RX_CALL_RECEIVE_DONE))) {
3313             call->flags &= ~RX_CALL_READER_WAIT;
3314 #ifdef  RX_ENABLE_LOCKS
3315             CV_BROADCAST(&call->cv_rq);
3316 #else
3317             osi_rxWakeup(&call->rq);
3318 #endif
3319         }
3320     }
3321
3322     /*
3323      * Send an ack when requested by the peer, or once every
3324      * rxi_SoftAckRate packets until the last packet has been
3325      * received. Always send a soft ack for the last packet in
3326      * the server's reply. */
3327     if (ackNeeded) {
3328         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3329         np = rxi_SendAck(call, np, serial, ackNeeded, istack);
3330     } else if (call->nSoftAcks > (u_short) rxi_SoftAckRate) {
3331         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3332         np = rxi_SendAck(call, np, serial, RX_ACK_IDLE, istack);
3333     } else if (call->nSoftAcks) {
3334         clock_GetTime(&when);
3335         if (haveLast && !(flags & RX_CLIENT_INITIATED)) {
3336             clock_Add(&when, &rx_lastAckDelay);
3337         } else {
3338             clock_Add(&when, &rx_softAckDelay);
3339         }
3340         if (!call->delayedAckEvent
3341             || clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
3342             rxevent_Cancel(call->delayedAckEvent, call,
3343                            RX_CALL_REFCOUNT_DELAY);
3344             CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
3345             call->delayedAckEvent =
3346                 rxevent_Post(&when, rxi_SendDelayedAck, call, 0);
3347         }
3348     } else if (call->flags & RX_CALL_RECEIVE_DONE) {
3349         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3350     }
3351
3352     return np;
3353 }
3354
3355 #ifdef  ADAPT_WINDOW
3356 static void rxi_ComputeRate();
3357 #endif
3358
3359 static void
3360 rxi_UpdatePeerReach(struct rx_connection *conn, struct rx_call *acall)
3361 {
3362     struct rx_peer *peer = conn->peer;
3363
3364     MUTEX_ENTER(&peer->peer_lock);
3365     peer->lastReachTime = clock_Sec();
3366     MUTEX_EXIT(&peer->peer_lock);
3367
3368     MUTEX_ENTER(&conn->conn_data_lock);
3369     if (conn->flags & RX_CONN_ATTACHWAIT) {
3370         int i;
3371
3372         conn->flags &= ~RX_CONN_ATTACHWAIT;
3373         MUTEX_EXIT(&conn->conn_data_lock);
3374
3375         for (i = 0; i < RX_MAXCALLS; i++) {
3376             struct rx_call *call = conn->call[i];
3377             if (call) {
3378                 if (call != acall)
3379                     MUTEX_ENTER(&call->lock);
3380                 /* tnop can be null if newcallp is null */
3381                 TryAttach(call, (osi_socket) - 1, NULL, NULL, 1);
3382                 if (call != acall)
3383                     MUTEX_EXIT(&call->lock);
3384             }
3385         }
3386     } else
3387         MUTEX_EXIT(&conn->conn_data_lock);
3388 }
3389
3390 /* rxi_ComputePeerNetStats
3391  *
3392  * Called exclusively by rxi_ReceiveAckPacket to compute network link
3393  * estimates (like RTT and throughput) based on ack packets.  Caller
3394  * must ensure that the packet in question is the right one (i.e.
3395  * serial number matches).
3396  */
3397 static void
3398 rxi_ComputePeerNetStats(struct rx_call *call, struct rx_packet *p,
3399                         struct rx_ackPacket *ap, struct rx_packet *np)
3400 {
3401     struct rx_peer *peer = call->conn->peer;
3402
3403     /* Use RTT if not delayed by client. */
3404     if (ap->reason != RX_ACK_DELAY)
3405         rxi_ComputeRoundTripTime(p, &p->timeSent, peer);
3406 #ifdef ADAPT_WINDOW
3407     rxi_ComputeRate(peer, call, p, np, ap->reason);
3408 #endif
3409 }
3410
3411 /* The real smarts of the whole thing.  */
3412 struct rx_packet *
3413 rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
3414                      int istack)
3415 {
3416     struct rx_ackPacket *ap;
3417     int nAcks;
3418     register struct rx_packet *tp;
3419     register struct rx_packet *nxp;     /* Next packet pointer for queue_Scan */
3420     register struct rx_connection *conn = call->conn;
3421     struct rx_peer *peer = conn->peer;
3422     afs_uint32 first;
3423     afs_uint32 serial;
3424     /* because there are CM's that are bogus, sending weird values for this. */
3425     afs_uint32 skew = 0;
3426     int nbytes;
3427     int missing;
3428     int acked;
3429     int nNacked = 0;
3430     int newAckCount = 0;
3431     u_short maxMTU = 0;         /* Set if peer supports AFS 3.4a jumbo datagrams */
3432     int maxDgramPackets = 0;    /* Set if peer supports AFS 3.5 jumbo datagrams */
3433
3434     MUTEX_ENTER(&rx_stats_mutex);
3435     rx_stats.ackPacketsRead++;
3436     MUTEX_EXIT(&rx_stats_mutex);
3437     ap = (struct rx_ackPacket *)rx_DataOf(np);
3438     nbytes = rx_Contiguous(np) - ((ap->acks) - (u_char *) ap);
3439     if (nbytes < 0)
3440         return np;              /* truncated ack packet */
3441
3442     /* depends on ack packet struct */
3443     nAcks = MIN((unsigned)nbytes, (unsigned)ap->nAcks);
3444     first = ntohl(ap->firstPacket);
3445     serial = ntohl(ap->serial);
3446     /* temporarily disabled -- needs to degrade over time
3447      * skew = ntohs(ap->maxSkew); */
3448
3449     /* Ignore ack packets received out of order */
3450     if (first < call->tfirst) {
3451         return np;
3452     }
3453
3454     if (np->header.flags & RX_SLOW_START_OK) {
3455         call->flags |= RX_CALL_SLOW_START_OK;
3456     }
3457
3458     if (ap->reason == RX_ACK_PING_RESPONSE)
3459         rxi_UpdatePeerReach(conn, call);
3460
3461 #ifdef RXDEBUG
3462     if (rx_Log) {
3463         fprintf(rx_Log,
3464                 "RACK: reason %x previous %u seq %u serial %u skew %d first %u",
3465                 ap->reason, ntohl(ap->previousPacket),
3466                 (unsigned int)np->header.seq, (unsigned int)serial,
3467                 (unsigned int)skew, ntohl(ap->firstPacket));
3468         if (nAcks) {
3469             int offset;
3470             for (offset = 0; offset < nAcks; offset++)
3471                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
3472                      rx_Log);
3473         }
3474         putc('\n', rx_Log);
3475     }
3476 #endif
3477
3478     /* Update the outgoing packet skew value to the latest value of
3479      * the peer's incoming packet skew value.  The ack packet, of
3480      * course, could arrive out of order, but that won't affect things
3481      * much */
3482     MUTEX_ENTER(&peer->peer_lock);
3483     peer->outPacketSkew = skew;
3484
3485     /* Check for packets that no longer need to be transmitted, and
3486      * discard them.  This only applies to packets positively
3487      * acknowledged as having been sent to the peer's upper level.
3488      * All other packets must be retained.  So only packets with
3489      * sequence numbers < ap->firstPacket are candidates. */
3490     for (queue_Scan(&call->tq, tp, nxp, rx_packet)) {
3491         if (tp->header.seq >= first)
3492             break;
3493         call->tfirst = tp->header.seq + 1;
3494         if (serial
3495             && (tp->header.serial == serial || tp->firstSerial == serial))
3496             rxi_ComputePeerNetStats(call, tp, ap, np);
3497 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3498         /* XXX Hack. Because we have to release the global rx lock when sending
3499          * packets (osi_NetSend) we drop all acks while we're traversing the tq
3500          * in rxi_Start sending packets out because packets may move to the
3501          * freePacketQueue as result of being here! So we drop these packets until
3502          * we're safely out of the traversing. Really ugly!
3503          * To make it even uglier, if we're using fine grain locking, we can
3504          * set the ack bits in the packets and have rxi_Start remove the packets
3505          * when it's done transmitting.
3506          */
3507         if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3508             newAckCount++;
3509         }
3510         if (call->flags & RX_CALL_TQ_BUSY) {
3511 #ifdef RX_ENABLE_LOCKS
3512             tp->flags |= RX_PKTFLAG_ACKED;
3513             call->flags |= RX_CALL_TQ_SOME_ACKED;
3514 #else /* RX_ENABLE_LOCKS */
3515             break;
3516 #endif /* RX_ENABLE_LOCKS */
3517         } else
3518 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3519         {
3520             queue_Remove(tp);
3521             rxi_FreePacket(tp); /* rxi_FreePacket mustn't wake up anyone, preemptively. */
3522         }
3523     }
3524
3525 #ifdef ADAPT_WINDOW
3526     /* Give rate detector a chance to respond to ping requests */
3527     if (ap->reason == RX_ACK_PING_RESPONSE) {
3528         rxi_ComputeRate(peer, call, 0, np, ap->reason);
3529     }
3530 #endif
3531
3532     /* N.B. we don't turn off any timers here.  They'll go away by themselves, anyway */
3533
3534     /* Now go through explicit acks/nacks and record the results in
3535      * the waiting packets.  These are packets that can't be released
3536      * yet, even with a positive acknowledge.  This positive
3537      * acknowledge only means the packet has been received by the
3538      * peer, not that it will be retained long enough to be sent to
3539      * the peer's upper level.  In addition, reset the transmit timers
3540      * of any missing packets (those packets that must be missing
3541      * because this packet was out of sequence) */
3542
3543     call->nSoftAcked = 0;
3544     for (missing = 0, queue_Scan(&call->tq, tp, nxp, rx_packet)) {
3545         /* Update round trip time if the ack was stimulated on receipt
3546          * of this packet */
3547 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
3548 #ifdef RX_ENABLE_LOCKS
3549         if (tp->header.seq >= first)
3550 #endif /* RX_ENABLE_LOCKS */
3551 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3552             if (serial
3553                 && (tp->header.serial == serial || tp->firstSerial == serial))
3554                 rxi_ComputePeerNetStats(call, tp, ap, np);
3555
3556         /* Set the acknowledge flag per packet based on the
3557          * information in the ack packet. An acknowlegded packet can
3558          * be downgraded when the server has discarded a packet it
3559          * soacked previously, or when an ack packet is received
3560          * out of sequence. */
3561         if (tp->header.seq < first) {
3562             /* Implicit ack information */
3563             if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3564                 newAckCount++;
3565             }
3566             tp->flags |= RX_PKTFLAG_ACKED;
3567         } else if (tp->header.seq < first + nAcks) {
3568             /* Explicit ack information:  set it in the packet appropriately */
3569             if (ap->acks[tp->header.seq - first] == RX_ACK_TYPE_ACK) {
3570                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3571                     newAckCount++;
3572                     tp->flags |= RX_PKTFLAG_ACKED;
3573                 }
3574                 if (missing) {
3575                     nNacked++;
3576                 } else {
3577                     call->nSoftAcked++;
3578                 }
3579             } else {
3580                 tp->flags &= ~RX_PKTFLAG_ACKED;
3581                 missing = 1;
3582             }
3583         } else {
3584             tp->flags &= ~RX_PKTFLAG_ACKED;
3585             missing = 1;
3586         }
3587
3588         /* If packet isn't yet acked, and it has been transmitted at least
3589          * once, reset retransmit time using latest timeout
3590          * ie, this should readjust the retransmit timer for all outstanding
3591          * packets...  So we don't just retransmit when we should know better*/
3592
3593         if (!(tp->flags & RX_PKTFLAG_ACKED) && !clock_IsZero(&tp->retryTime)) {
3594             tp->retryTime = tp->timeSent;
3595             clock_Add(&tp->retryTime, &peer->timeout);
3596             /* shift by eight because one quarter-sec ~ 256 milliseconds */
3597             clock_Addmsec(&(tp->retryTime), ((afs_uint32) tp->backoff) << 8);
3598         }
3599     }
3600
3601     /* If the window has been extended by this acknowledge packet,
3602      * then wakeup a sender waiting in alloc for window space, or try
3603      * sending packets now, if he's been sitting on packets due to
3604      * lack of window space */
3605     if (call->tnext < (call->tfirst + call->twind)) {
3606 #ifdef  RX_ENABLE_LOCKS
3607         CV_SIGNAL(&call->cv_twind);
3608 #else
3609         if (call->flags & RX_CALL_WAIT_WINDOW_ALLOC) {
3610             call->flags &= ~RX_CALL_WAIT_WINDOW_ALLOC;
3611             osi_rxWakeup(&call->twind);
3612         }
3613 #endif
3614         if (call->flags & RX_CALL_WAIT_WINDOW_SEND) {
3615             call->flags &= ~RX_CALL_WAIT_WINDOW_SEND;
3616         }
3617     }
3618
3619     /* if the ack packet has a receivelen field hanging off it,
3620      * update our state */
3621     if (np->length >= rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32)) {
3622         afs_uint32 tSize;
3623
3624         /* If the ack packet has a "recommended" size that is less than
3625          * what I am using now, reduce my size to match */
3626         rx_packetread(np, rx_AckDataSize(ap->nAcks) + sizeof(afs_int32),
3627                       sizeof(afs_int32), &tSize);
3628         tSize = (afs_uint32) ntohl(tSize);
3629         peer->natMTU = rxi_AdjustIfMTU(MIN(tSize, peer->ifMTU));
3630
3631         /* Get the maximum packet size to send to this peer */
3632         rx_packetread(np, rx_AckDataSize(ap->nAcks), sizeof(afs_int32),
3633                       &tSize);
3634         tSize = (afs_uint32) ntohl(tSize);
3635         tSize = (afs_uint32) MIN(tSize, rx_MyMaxSendSize);
3636         tSize = rxi_AdjustMaxMTU(peer->natMTU, tSize);
3637
3638         /* sanity check - peer might have restarted with different params.
3639          * If peer says "send less", dammit, send less...  Peer should never
3640          * be unable to accept packets of the size that prior AFS versions would
3641          * send without asking.  */
3642         if (peer->maxMTU != tSize) {
3643             peer->maxMTU = tSize;
3644             peer->MTU = MIN(tSize, peer->MTU);
3645             call->MTU = MIN(call->MTU, tSize);
3646             peer->congestSeq++;
3647         }
3648
3649         if (np->length == rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32)) {
3650             /* AFS 3.4a */
3651             rx_packetread(np,
3652                           rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
3653                           sizeof(afs_int32), &tSize);
3654             tSize = (afs_uint32) ntohl(tSize);  /* peer's receive window, if it's */
3655             if (tSize < call->twind) {  /* smaller than our send */
3656                 call->twind = tSize;    /* window, we must send less... */
3657                 call->ssthresh = MIN(call->twind, call->ssthresh);
3658             }
3659
3660             /* Only send jumbograms to 3.4a fileservers. 3.3a RX gets the
3661              * network MTU confused with the loopback MTU. Calculate the
3662              * maximum MTU here for use in the slow start code below.
3663              */
3664             maxMTU = peer->maxMTU;
3665             /* Did peer restart with older RX version? */
3666             if (peer->maxDgramPackets > 1) {
3667                 peer->maxDgramPackets = 1;
3668             }
3669         } else if (np->length >=
3670                    rx_AckDataSize(ap->nAcks) + 4 * sizeof(afs_int32)) {
3671             /* AFS 3.5 */
3672             rx_packetread(np,
3673                           rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
3674                           sizeof(afs_int32), &tSize);
3675             tSize = (afs_uint32) ntohl(tSize);
3676             /*
3677              * As of AFS 3.5 we set the send window to match the receive window.
3678              */
3679             if (tSize < call->twind) {
3680                 call->twind = tSize;
3681                 call->ssthresh = MIN(call->twind, call->ssthresh);
3682             } else if (tSize > call->twind) {
3683                 call->twind = tSize;
3684             }
3685
3686             /*
3687              * As of AFS 3.5, a jumbogram is more than one fixed size
3688              * packet transmitted in a single UDP datagram. If the remote
3689              * MTU is smaller than our local MTU then never send a datagram
3690              * larger than the natural MTU.
3691              */
3692             rx_packetread(np,
3693                           rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32),
3694                           sizeof(afs_int32), &tSize);
3695             maxDgramPackets = (afs_uint32) ntohl(tSize);
3696             maxDgramPackets = MIN(maxDgramPackets, rxi_nDgramPackets);
3697             maxDgramPackets =
3698                 MIN(maxDgramPackets, (int)(peer->ifDgramPackets));
3699             maxDgramPackets = MIN(maxDgramPackets, tSize);
3700             if (maxDgramPackets > 1) {
3701                 peer->maxDgramPackets = maxDgramPackets;
3702                 call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
3703             } else {
3704                 peer->maxDgramPackets = 1;
3705                 call->MTU = peer->natMTU;
3706             }
3707         } else if (peer->maxDgramPackets > 1) {
3708             /* Restarted with lower version of RX */
3709             peer->maxDgramPackets = 1;
3710         }
3711     } else if (peer->maxDgramPackets > 1
3712                || peer->maxMTU != OLD_MAX_PACKET_SIZE) {
3713         /* Restarted with lower version of RX */
3714         peer->maxMTU = OLD_MAX_PACKET_SIZE;
3715         peer->natMTU = OLD_MAX_PACKET_SIZE;
3716         peer->MTU = OLD_MAX_PACKET_SIZE;
3717         peer->maxDgramPackets = 1;
3718         peer->nDgramPackets = 1;
3719         peer->congestSeq++;
3720         call->MTU = OLD_MAX_PACKET_SIZE;
3721     }
3722
3723     if (nNacked) {
3724         /*
3725          * Calculate how many datagrams were successfully received after
3726          * the first missing packet and adjust the negative ack counter
3727          * accordingly.
3728          */
3729         call->nAcks = 0;
3730         call->nNacks++;
3731         nNacked = (nNacked + call->nDgramPackets - 1) / call->nDgramPackets;
3732         if (call->nNacks < nNacked) {
3733             call->nNacks = nNacked;
3734         }
3735     } else {
3736         if (newAckCount) {
3737             call->nAcks++;
3738         }
3739         call->nNacks = 0;
3740     }
3741
3742     if (call->flags & RX_CALL_FAST_RECOVER) {
3743         if (nNacked) {
3744             call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
3745         } else {
3746             call->flags &= ~RX_CALL_FAST_RECOVER;
3747             call->cwind = call->nextCwind;
3748             call->nextCwind = 0;
3749             call->nAcks = 0;
3750         }
3751         call->nCwindAcks = 0;
3752     } else if (nNacked && call->nNacks >= (u_short) rx_nackThreshold) {
3753         /* Three negative acks in a row trigger congestion recovery */
3754 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3755         MUTEX_EXIT(&peer->peer_lock);
3756         if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
3757             /* someone else is waiting to start recovery */
3758             return np;
3759         }
3760         call->flags |= RX_CALL_FAST_RECOVER_WAIT;
3761         while (call->flags & RX_CALL_TQ_BUSY) {
3762             call->flags |= RX_CALL_TQ_WAIT;
3763 #ifdef RX_ENABLE_LOCKS
3764             CV_WAIT(&call->cv_tq, &call->lock);
3765 #else /* RX_ENABLE_LOCKS */
3766             osi_rxSleep(&call->tq);
3767 #endif /* RX_ENABLE_LOCKS */
3768         }
3769         MUTEX_ENTER(&peer->peer_lock);
3770 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3771         call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
3772         call->flags |= RX_CALL_FAST_RECOVER;
3773         call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
3774         call->cwind =
3775             MIN((int)(call->ssthresh + rx_nackThreshold), rx_maxSendWindow);
3776         call->nDgramPackets = MAX(2, (int)call->nDgramPackets) >> 1;
3777         call->nextCwind = call->ssthresh;
3778         call->nAcks = 0;
3779         call->nNacks = 0;
3780         peer->MTU = call->MTU;
3781         peer->cwind = call->nextCwind;
3782         peer->nDgramPackets = call->nDgramPackets;
3783         peer->congestSeq++;
3784         call->congestSeq = peer->congestSeq;
3785         /* Reset the resend times on the packets that were nacked
3786          * so we will retransmit as soon as the window permits*/
3787         for (acked = 0, queue_ScanBackwards(&call->tq, tp, nxp, rx_packet)) {
3788             if (acked) {
3789                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3790                     clock_Zero(&tp->retryTime);
3791                 }
3792             } else if (tp->flags & RX_PKTFLAG_ACKED) {
3793                 acked = 1;
3794             }
3795         }
3796     } else {
3797         /* If cwind is smaller than ssthresh, then increase
3798          * the window one packet for each ack we receive (exponential
3799          * growth).
3800          * If cwind is greater than or equal to ssthresh then increase
3801          * the congestion window by one packet for each cwind acks we
3802          * receive (linear growth).  */
3803         if (call->cwind < call->ssthresh) {
3804             call->cwind =
3805                 MIN((int)call->ssthresh, (int)(call->cwind + newAckCount));
3806             call->nCwindAcks = 0;
3807         } else {
3808             call->nCwindAcks += newAckCount;
3809             if (call->nCwindAcks >= call->cwind) {
3810                 call->nCwindAcks = 0;
3811                 call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
3812             }
3813         }
3814         /*
3815          * If we have received several acknowledgements in a row then
3816          * it is time to increase the size of our datagrams
3817          */
3818         if ((int)call->nAcks > rx_nDgramThreshold) {
3819             if (peer->maxDgramPackets > 1) {
3820                 if (call->nDgramPackets < peer->maxDgramPackets) {
3821                     call->nDgramPackets++;
3822                 }
3823                 call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
3824             } else if (call->MTU < peer->maxMTU) {
3825                 call->MTU += peer->natMTU;
3826                 call->MTU = MIN(call->MTU, peer->maxMTU);
3827             }
3828             call->nAcks = 0;
3829         }
3830     }
3831
3832     MUTEX_EXIT(&peer->peer_lock);       /* rxi_Start will lock peer. */
3833
3834     /* Servers need to hold the call until all response packets have
3835      * been acknowledged. Soft acks are good enough since clients
3836      * are not allowed to clear their receive queues. */
3837     if (call->state == RX_STATE_HOLD
3838         && call->tfirst + call->nSoftAcked >= call->tnext) {
3839         call->state = RX_STATE_DALLY;
3840         rxi_ClearTransmitQueue(call, 0);
3841     } else if (!queue_IsEmpty(&call->tq)) {
3842         rxi_Start(0, call, istack);
3843     }
3844     return np;
3845 }
3846
3847 /* Received a response to a challenge packet */
3848 struct rx_packet *
3849 rxi_ReceiveResponsePacket(register struct rx_connection *conn,
3850                           register struct rx_packet *np, int istack)
3851 {
3852     int error;
3853
3854     /* Ignore the packet if we're the client */
3855     if (conn->type == RX_CLIENT_CONNECTION)
3856         return np;
3857
3858     /* If already authenticated, ignore the packet (it's probably a retry) */
3859     if (RXS_CheckAuthentication(conn->securityObject, conn) == 0)
3860         return np;
3861
3862     /* Otherwise, have the security object evaluate the response packet */
3863     error = RXS_CheckResponse(conn->securityObject, conn, np);
3864     if (error) {
3865         /* If the response is invalid, reset the connection, sending
3866          * an abort to the peer */
3867 #ifndef KERNEL
3868         rxi_Delay(1);
3869 #endif
3870         rxi_ConnectionError(conn, error);
3871         MUTEX_ENTER(&conn->conn_data_lock);
3872         np = rxi_SendConnectionAbort(conn, np, istack, 0);
3873         MUTEX_EXIT(&conn->conn_data_lock);
3874         return np;
3875     } else {
3876         /* If the response is valid, any calls waiting to attach
3877          * servers can now do so */
3878         int i;
3879
3880         for (i = 0; i < RX_MAXCALLS; i++) {
3881             struct rx_call *call = conn->call[i];
3882             if (call) {
3883                 MUTEX_ENTER(&call->lock);
3884                 if (call->state == RX_STATE_PRECALL)
3885                     rxi_AttachServerProc(call, (osi_socket) - 1, NULL, NULL);
3886                 /* tnop can be null if newcallp is null */
3887                 MUTEX_EXIT(&call->lock);
3888             }
3889         }
3890
3891         /* Update the peer reachability information, just in case
3892          * some calls went into attach-wait while we were waiting
3893          * for authentication..
3894          */
3895         rxi_UpdatePeerReach(conn, NULL);
3896     }
3897     return np;
3898 }
3899
3900 /* A client has received an authentication challenge: the security
3901  * object is asked to cough up a respectable response packet to send
3902  * back to the server.  The server is responsible for retrying the
3903  * challenge if it fails to get a response. */
3904
3905 struct rx_packet *
3906 rxi_ReceiveChallengePacket(register struct rx_connection *conn,
3907                            register struct rx_packet *np, int istack)
3908 {
3909     int error;
3910
3911     /* Ignore the challenge if we're the server */
3912     if (conn->type == RX_SERVER_CONNECTION)
3913         return np;
3914
3915     /* Ignore the challenge if the connection is otherwise idle; someone's
3916      * trying to use us as an oracle. */
3917     if (!rxi_HasActiveCalls(conn))
3918         return np;
3919
3920     /* Send the security object the challenge packet.  It is expected to fill
3921      * in the response. */
3922     error = RXS_GetResponse(conn->securityObject, conn, np);
3923
3924     /* If the security object is unable to return a valid response, reset the
3925      * connection and send an abort to the peer.  Otherwise send the response
3926      * packet to the peer connection. */
3927     if (error) {
3928         rxi_ConnectionError(conn, error);
3929         MUTEX_ENTER(&conn->conn_data_lock);
3930         np = rxi_SendConnectionAbort(conn, np, istack, 0);
3931         MUTEX_EXIT(&conn->conn_data_lock);
3932     } else {
3933         np = rxi_SendSpecial((struct rx_call *)0, conn, np,
3934                              RX_PACKET_TYPE_RESPONSE, NULL, -1, istack);
3935     }
3936     return np;
3937 }
3938
3939
3940 /* Find an available server process to service the current request in
3941  * the given call structure.  If one isn't available, queue up this
3942  * call so it eventually gets one */
3943 void
3944 rxi_AttachServerProc(register struct rx_call *call,
3945                      register osi_socket socket, register int *tnop,
3946                      register struct rx_call **newcallp)
3947 {
3948     register struct rx_serverQueueEntry *sq;
3949     register struct rx_service *service = call->conn->service;
3950     register int haveQuota = 0;
3951
3952     /* May already be attached */
3953     if (call->state == RX_STATE_ACTIVE)
3954         return;
3955
3956     MUTEX_ENTER(&rx_serverPool_lock);
3957
3958     haveQuota = QuotaOK(service);
3959     if ((!haveQuota) || queue_IsEmpty(&rx_idleServerQueue)) {
3960         /* If there are no processes available to service this call,
3961          * put the call on the incoming call queue (unless it's
3962          * already on the queue).
3963          */
3964 #ifdef RX_ENABLE_LOCKS
3965         if (haveQuota)
3966             ReturnToServerPool(service);
3967 #endif /* RX_ENABLE_LOCKS */
3968
3969         if (!(call->flags & RX_CALL_WAIT_PROC)) {
3970             call->flags |= RX_CALL_WAIT_PROC;
3971             MUTEX_ENTER(&rx_stats_mutex);
3972             rx_nWaiting++;
3973             MUTEX_EXIT(&rx_stats_mutex);
3974             rxi_calltrace(RX_CALL_ARRIVAL, call);
3975             SET_CALL_QUEUE_LOCK(call, &rx_serverPool_lock);
3976             queue_Append(&rx_incomingCallQueue, call);
3977         }
3978     } else {
3979         sq = queue_First(&rx_idleServerQueue, rx_serverQueueEntry);
3980
3981         /* If hot threads are enabled, and both newcallp and sq->socketp
3982          * are non-null, then this thread will process the call, and the
3983          * idle server thread will start listening on this threads socket.
3984          */
3985         queue_Remove(sq);
3986         if (rx_enable_hot_thread && newcallp && sq->socketp) {
3987             *newcallp = call;
3988             *tnop = sq->tno;
3989             *sq->socketp = socket;
3990             clock_GetTime(&call->startTime);
3991             CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
3992         } else {
3993             sq->newcall = call;
3994         }
3995         if (call->flags & RX_CALL_WAIT_PROC) {
3996             /* Conservative:  I don't think this should happen */
3997             call->flags &= ~RX_CALL_WAIT_PROC;
3998             MUTEX_ENTER(&rx_stats_mutex);
3999             rx_nWaiting--;
4000             MUTEX_EXIT(&rx_stats_mutex);
4001             if (queue_IsOnQueue(call))
4002                 queue_Remove(call);
4003         }
4004         call->state = RX_STATE_ACTIVE;
4005         call->mode = RX_MODE_RECEIVING;
4006 #ifdef RX_KERNEL_TRACE
4007         {
4008             int glockOwner = ISAFS_GLOCK();
4009             if (!glockOwner)
4010                 AFS_GLOCK();
4011             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
4012                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
4013                        call);
4014             if (!glockOwner)
4015                 AFS_GUNLOCK();
4016         }
4017 #endif
4018         if (call->flags & RX_CALL_CLEARED) {
4019             /* send an ack now to start the packet flow up again */
4020             call->flags &= ~RX_CALL_CLEARED;
4021             rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4022         }
4023 #ifdef  RX_ENABLE_LOCKS
4024         CV_SIGNAL(&sq->cv);
4025 #else
4026         service->nRequestsRunning++;
4027         if (service->nRequestsRunning <= service->minProcs)
4028             rxi_minDeficit--;
4029         rxi_availProcs--;
4030         osi_rxWakeup(sq);
4031 #endif
4032     }
4033     MUTEX_EXIT(&rx_serverPool_lock);
4034 }
4035
4036 /* Delay the sending of an acknowledge event for a short while, while
4037  * a new call is being prepared (in the case of a client) or a reply
4038  * is being prepared (in the case of a server).  Rather than sending
4039  * an ack packet, an ACKALL packet is sent. */
4040 void
4041 rxi_AckAll(struct rxevent *event, register struct rx_call *call, char *dummy)
4042 {
4043 #ifdef RX_ENABLE_LOCKS
4044     if (event) {
4045         MUTEX_ENTER(&call->lock);
4046         call->delayedAckEvent = NULL;
4047         CALL_RELE(call, RX_CALL_REFCOUNT_ACKALL);
4048     }
4049     rxi_SendSpecial(call, call->conn, (struct rx_packet *)0,
4050                     RX_PACKET_TYPE_ACKALL, NULL, 0, 0);
4051     if (event)
4052         MUTEX_EXIT(&call->lock);
4053 #else /* RX_ENABLE_LOCKS */
4054     if (event)
4055         call->delayedAckEvent = NULL;
4056     rxi_SendSpecial(call, call->conn, (struct rx_packet *)0,
4057                     RX_PACKET_TYPE_ACKALL, NULL, 0, 0);
4058 #endif /* RX_ENABLE_LOCKS */
4059 }
4060
4061 void
4062 rxi_SendDelayedAck(struct rxevent *event, register struct rx_call *call,
4063                    char *dummy)
4064 {
4065 #ifdef RX_ENABLE_LOCKS
4066     if (event) {
4067         MUTEX_ENTER(&call->lock);
4068         if (event == call->delayedAckEvent)
4069             call->delayedAckEvent = NULL;
4070         CALL_RELE(call, RX_CALL_REFCOUNT_DELAY);
4071     }
4072     (void)rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4073     if (event)
4074         MUTEX_EXIT(&call->lock);
4075 #else /* RX_ENABLE_LOCKS */
4076     if (event)
4077         call->delayedAckEvent = NULL;
4078     (void)rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4079 #endif /* RX_ENABLE_LOCKS */
4080 }
4081
4082
4083 #ifdef RX_ENABLE_LOCKS
4084 /* Set ack in all packets in transmit queue. rxi_Start will deal with
4085  * clearing them out.
4086  */
4087 static void
4088 rxi_SetAcksInTransmitQueue(register struct rx_call *call)
4089 {
4090     register struct rx_packet *p, *tp;
4091     int someAcked = 0;
4092
4093     for (queue_Scan(&call->tq, p, tp, rx_packet)) {
4094         if (!p)
4095             break;
4096         p->flags |= RX_PKTFLAG_ACKED;
4097         someAcked = 1;
4098     }
4099     if (someAcked) {
4100         call->flags |= RX_CALL_TQ_CLEARME;
4101         call->flags |= RX_CALL_TQ_SOME_ACKED;
4102     }
4103
4104     rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
4105     rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
4106     call->tfirst = call->tnext;
4107     call->nSoftAcked = 0;
4108
4109     if (call->flags & RX_CALL_FAST_RECOVER) {
4110         call->flags &= ~RX_CALL_FAST_RECOVER;
4111         call->cwind = call->nextCwind;
4112         call->nextCwind = 0;
4113     }
4114
4115     CV_SIGNAL(&call->cv_twind);
4116 }
4117 #endif /* RX_ENABLE_LOCKS */
4118
4119 /* Clear out the transmit queue for the current call (all packets have
4120  * been received by peer) */
4121 void
4122 rxi_ClearTransmitQueue(register struct rx_call *call, register int force)
4123 {
4124     register struct rx_packet *p, *tp;
4125
4126 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4127     if (!force && (call->flags & RX_CALL_TQ_BUSY)) {
4128         int someAcked = 0;
4129         for (queue_Scan(&call->tq, p, tp, rx_packet)) {
4130             if (!p)
4131                 break;
4132             p->flags |= RX_PKTFLAG_ACKED;
4133             someAcked = 1;
4134         }
4135         if (someAcked) {
4136             call->flags |= RX_CALL_TQ_CLEARME;
4137             call->flags |= RX_CALL_TQ_SOME_ACKED;
4138         }
4139     } else {
4140 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4141         for (queue_Scan(&call->tq, p, tp, rx_packet)) {
4142             if (!p)
4143                 break;
4144             queue_Remove(p);
4145             rxi_FreePacket(p);
4146         }
4147 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4148         call->flags &= ~RX_CALL_TQ_CLEARME;
4149     }
4150 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4151
4152     rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
4153     rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
4154     call->tfirst = call->tnext; /* implicitly acknowledge all data already sent */
4155     call->nSoftAcked = 0;
4156
4157     if (call->flags & RX_CALL_FAST_RECOVER) {
4158         call->flags &= ~RX_CALL_FAST_RECOVER;
4159         call->cwind = call->nextCwind;
4160     }
4161 #ifdef  RX_ENABLE_LOCKS
4162     CV_SIGNAL(&call->cv_twind);
4163 #else
4164     osi_rxWakeup(&call->twind);
4165 #endif
4166 }
4167
4168 void
4169 rxi_ClearReceiveQueue(register struct rx_call *call)
4170 {
4171     register struct rx_packet *p, *tp;
4172     if (queue_IsNotEmpty(&call->rq)) {
4173         for (queue_Scan(&call->rq, p, tp, rx_packet)) {
4174             if (!p)
4175                 break;
4176             queue_Remove(p);
4177             rxi_FreePacket(p);
4178             rx_packetReclaims++;
4179         }
4180         call->flags &= ~(RX_CALL_RECEIVE_DONE | RX_CALL_HAVE_LAST);
4181     }
4182     if (call->state == RX_STATE_PRECALL) {
4183         call->flags |= RX_CALL_CLEARED;
4184     }
4185 }
4186
4187 /* Send an abort packet for the specified call */
4188 struct rx_packet *
4189 rxi_SendCallAbort(register struct rx_call *call, struct rx_packet *packet,
4190                   int istack, int force)
4191 {
4192     afs_int32 error;
4193     struct clock when;
4194
4195     if (!call->error)
4196         return packet;
4197
4198     /* Clients should never delay abort messages */
4199     if (rx_IsClientConn(call->conn))
4200         force = 1;
4201
4202     if (call->abortCode != call->error) {
4203         call->abortCode = call->error;
4204         call->abortCount = 0;
4205     }
4206
4207     if (force || rxi_callAbortThreshhold == 0
4208         || call->abortCount < rxi_callAbortThreshhold) {
4209         if (call->delayedAbortEvent) {
4210             rxevent_Cancel(call->delayedAbortEvent, call,
4211                            RX_CALL_REFCOUNT_ABORT);
4212         }
4213         error = htonl(call->error);
4214         call->abortCount++;
4215         packet =
4216             rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
4217                             (char *)&error, sizeof(error), istack);
4218     } else if (!call->delayedAbortEvent) {
4219         clock_GetTime(&when);
4220         clock_Addmsec(&when, rxi_callAbortDelay);
4221         CALL_HOLD(call, RX_CALL_REFCOUNT_ABORT);
4222         call->delayedAbortEvent =
4223             rxevent_Post(&when, rxi_SendDelayedCallAbort, call, 0);
4224     }
4225     return packet;
4226 }
4227
4228 /* Send an abort packet for the specified connection.  Packet is an
4229  * optional pointer to a packet that can be used to send the abort.
4230  * Once the number of abort messages reaches the threshhold, an
4231  * event is scheduled to send the abort. Setting the force flag
4232  * overrides sending delayed abort messages.
4233  *
4234  * NOTE: Called with conn_data_lock held. conn_data_lock is dropped
4235  *       to send the abort packet.
4236  */
4237 struct rx_packet *
4238 rxi_SendConnectionAbort(register struct rx_connection *conn,
4239                         struct rx_packet *packet, int istack, int force)
4240 {
4241     afs_int32 error;
4242     struct clock when;
4243
4244     if (!conn->error)
4245         return packet;
4246
4247     /* Clients should never delay abort messages */
4248     if (rx_IsClientConn(conn))
4249         force = 1;
4250
4251     if (force || rxi_connAbortThreshhold == 0
4252         || conn->abortCount < rxi_connAbortThreshhold) {
4253         if (conn->delayedAbortEvent) {
4254             rxevent_Cancel(conn->delayedAbortEvent, (struct rx_call *)0, 0);
4255         }
4256         error = htonl(conn->error);
4257         conn->abortCount++;
4258         MUTEX_EXIT(&conn->conn_data_lock);
4259         packet =
4260             rxi_SendSpecial((struct rx_call *)0, conn, packet,
4261                             RX_PACKET_TYPE_ABORT, (char *)&error,
4262                             sizeof(error), istack);
4263         MUTEX_ENTER(&conn->conn_data_lock);
4264     } else if (!conn->delayedAbortEvent) {
4265         clock_GetTime(&when);
4266         clock_Addmsec(&when, rxi_connAbortDelay);
4267         conn->delayedAbortEvent =
4268             rxevent_Post(&when, rxi_SendDelayedConnAbort, conn, 0);
4269     }
4270     return packet;
4271 }
4272
4273 /* Associate an error all of the calls owned by a connection.  Called
4274  * with error non-zero.  This is only for really fatal things, like
4275  * bad authentication responses.  The connection itself is set in
4276  * error at this point, so that future packets received will be
4277  * rejected. */
4278 void
4279 rxi_ConnectionError(register struct rx_connection *conn,
4280                     register afs_int32 error)
4281 {
4282     if (error) {
4283         register int i;
4284         MUTEX_ENTER(&conn->conn_data_lock);
4285         if (conn->challengeEvent)
4286             rxevent_Cancel(conn->challengeEvent, (struct rx_call *)0, 0);
4287         if (conn->checkReachEvent) {
4288             rxevent_Cancel(conn->checkReachEvent, (struct rx_call *)0, 0);
4289             conn->checkReachEvent = 0;
4290             conn->flags &= ~RX_CONN_ATTACHWAIT;
4291             conn->refCount--;
4292         }
4293         MUTEX_EXIT(&conn->conn_data_lock);
4294         for (i = 0; i < RX_MAXCALLS; i++) {
4295             struct rx_call *call = conn->call[i];
4296             if (call) {
4297                 MUTEX_ENTER(&call->lock);
4298                 rxi_CallError(call, error);
4299                 MUTEX_EXIT(&call->lock);
4300             }
4301         }
4302         conn->error = error;
4303         MUTEX_ENTER(&rx_stats_mutex);
4304         rx_stats.fatalErrors++;
4305         MUTEX_EXIT(&rx_stats_mutex);
4306     }
4307 }
4308
4309 void
4310 rxi_CallError(register struct rx_call *call, afs_int32 error)
4311 {
4312     if (call->error)
4313         error = call->error;
4314 #ifdef RX_GLOBAL_RXLOCK_KERNEL
4315     if (!(call->flags & RX_CALL_TQ_BUSY)) {
4316         rxi_ResetCall(call, 0);
4317     }
4318 #else
4319     rxi_ResetCall(call, 0);
4320 #endif
4321     call->error = error;
4322     call->mode = RX_MODE_ERROR;
4323 }
4324
4325 /* Reset various fields in a call structure, and wakeup waiting
4326  * processes.  Some fields aren't changed: state & mode are not
4327  * touched (these must be set by the caller), and bufptr, nLeft, and
4328  * nFree are not reset, since these fields are manipulated by
4329  * unprotected macros, and may only be reset by non-interrupting code.
4330  */
4331 #ifdef ADAPT_WINDOW
4332 /* this code requires that call->conn be set properly as a pre-condition. */
4333 #endif /* ADAPT_WINDOW */
4334
4335 void
4336 rxi_ResetCall(register struct rx_call *call, register int newcall)
4337 {
4338     register int flags;
4339     register struct rx_peer *peer;
4340     struct rx_packet *packet;
4341
4342     /* Notify anyone who is waiting for asynchronous packet arrival */
4343     if (call->arrivalProc) {
4344         (*call->arrivalProc) (call, call->arrivalProcHandle,
4345                               (int)call->arrivalProcArg);
4346         call->arrivalProc = (VOID(*)())0;
4347     }
4348
4349     if (call->delayedAbortEvent) {
4350         rxevent_Cancel(call->delayedAbortEvent, call, RX_CALL_REFCOUNT_ABORT);
4351         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
4352         if (packet) {
4353             rxi_SendCallAbort(call, packet, 0, 1);
4354             rxi_FreePacket(packet);
4355         }
4356     }
4357
4358     /*
4359      * Update the peer with the congestion information in this call
4360      * so other calls on this connection can pick up where this call
4361      * left off. If the congestion sequence numbers don't match then
4362      * another call experienced a retransmission.
4363      */
4364     peer = call->conn->peer;
4365     MUTEX_ENTER(&peer->peer_lock);
4366     if (!newcall) {
4367         if (call->congestSeq == peer->congestSeq) {
4368             peer->cwind = MAX(peer->cwind, call->cwind);
4369             peer->MTU = MAX(peer->MTU, call->MTU);
4370             peer->nDgramPackets =
4371                 MAX(peer->nDgramPackets, call->nDgramPackets);
4372         }
4373     } else {
4374         call->abortCode = 0;
4375         call->abortCount = 0;
4376     }
4377     if (peer->maxDgramPackets > 1) {
4378         call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
4379     } else {
4380         call->MTU = peer->MTU;
4381     }
4382     call->cwind = MIN((int)peer->cwind, (int)peer->nDgramPackets);
4383     call->ssthresh = rx_maxSendWindow;
4384     call->nDgramPackets = peer->nDgramPackets;
4385     call->congestSeq = peer->congestSeq;
4386     MUTEX_EXIT(&peer->peer_lock);
4387
4388     flags = call->flags;
4389     rxi_ClearReceiveQueue(call);
4390 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4391     if (call->flags & RX_CALL_TQ_BUSY) {
4392         call->flags = RX_CALL_TQ_CLEARME | RX_CALL_TQ_BUSY;
4393         call->flags |= (flags & RX_CALL_TQ_WAIT);
4394     } else
4395 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4396     {
4397         rxi_ClearTransmitQueue(call, 0);
4398         queue_Init(&call->tq);
4399         call->flags = 0;
4400     }
4401     queue_Init(&call->rq);
4402     call->error = 0;
4403     call->rwind = rx_initReceiveWindow;
4404     call->twind = rx_initSendWindow;
4405     call->nSoftAcked = 0;
4406     call->nextCwind = 0;
4407     call->nAcks = 0;
4408     call->nNacks = 0;
4409     call->nCwindAcks = 0;
4410     call->nSoftAcks = 0;
4411     call->nHardAcks = 0;
4412
4413     call->tfirst = call->rnext = call->tnext = 1;
4414     call->rprev = 0;
4415     call->lastAcked = 0;
4416     call->localStatus = call->remoteStatus = 0;
4417
4418     if (flags & RX_CALL_READER_WAIT) {
4419 #ifdef  RX_ENABLE_LOCKS
4420         CV_BROADCAST(&call->cv_rq);
4421 #else
4422         osi_rxWakeup(&call->rq);
4423 #endif
4424     }
4425     if (flags & RX_CALL_WAIT_PACKETS) {
4426         MUTEX_ENTER(&rx_freePktQ_lock);
4427         rxi_PacketsUnWait();    /* XXX */
4428         MUTEX_EXIT(&rx_freePktQ_lock);
4429     }
4430 #ifdef  RX_ENABLE_LOCKS
4431     CV_SIGNAL(&call->cv_twind);
4432 #else
4433     if (flags & RX_CALL_WAIT_WINDOW_ALLOC)
4434         osi_rxWakeup(&call->twind);
4435 #endif
4436
4437 #ifdef RX_ENABLE_LOCKS
4438     /* The following ensures that we don't mess with any queue while some
4439      * other thread might also be doing so. The call_queue_lock field is
4440      * is only modified under the call lock. If the call is in the process
4441      * of being removed from a queue, the call is not locked until the
4442      * the queue lock is dropped and only then is the call_queue_lock field
4443      * zero'd out. So it's safe to lock the queue if call_queue_lock is set.
4444      * Note that any other routine which removes a call from a queue has to
4445      * obtain the queue lock before examing the queue and removing the call.
4446      */
4447     if (call->call_queue_lock) {
4448         MUTEX_ENTER(call->call_queue_lock);
4449         if (queue_IsOnQueue(call)) {
4450             queue_Remove(call);
4451             if (flags & RX_CALL_WAIT_PROC) {
4452                 MUTEX_ENTER(&rx_stats_mutex);
4453                 rx_nWaiting--;
4454                 MUTEX_EXIT(&rx_stats_mutex);
4455             }
4456         }
4457         MUTEX_EXIT(call->call_queue_lock);
4458         CLEAR_CALL_QUEUE_LOCK(call);
4459     }
4460 #else /* RX_ENABLE_LOCKS */
4461     if (queue_IsOnQueue(call)) {
4462         queue_Remove(call);
4463         if (flags & RX_CALL_WAIT_PROC)
4464             rx_nWaiting--;
4465     }
4466 #endif /* RX_ENABLE_LOCKS */
4467
4468     rxi_KeepAliveOff(call);
4469     rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4470 }
4471
4472 /* Send an acknowledge for the indicated packet (seq,serial) of the
4473  * indicated call, for the indicated reason (reason).  This
4474  * acknowledge will specifically acknowledge receiving the packet, and
4475  * will also specify which other packets for this call have been
4476  * received.  This routine returns the packet that was used to the
4477  * caller.  The caller is responsible for freeing it or re-using it.
4478  * This acknowledgement also returns the highest sequence number
4479  * actually read out by the higher level to the sender; the sender
4480  * promises to keep around packets that have not been read by the
4481  * higher level yet (unless, of course, the sender decides to abort
4482  * the call altogether).  Any of p, seq, serial, pflags, or reason may
4483  * be set to zero without ill effect.  That is, if they are zero, they
4484  * will not convey any information.
4485  * NOW there is a trailer field, after the ack where it will safely be
4486  * ignored by mundanes, which indicates the maximum size packet this
4487  * host can swallow.  */
4488 /*
4489     register struct rx_packet *optionalPacket;  use to send ack (or null)
4490     int seq;                     Sequence number of the packet we are acking
4491     int serial;                  Serial number of the packet
4492     int pflags;                  Flags field from packet header
4493     int reason;                  Reason an acknowledge was prompted
4494 */
4495
4496 struct rx_packet *
4497 rxi_SendAck(register struct rx_call *call,
4498             register struct rx_packet *optionalPacket, int serial, int reason,
4499             int istack)
4500 {
4501     struct rx_ackPacket *ap;
4502     register struct rx_packet *rqp;
4503     register struct rx_packet *nxp;     /* For queue_Scan */
4504     register struct rx_packet *p;
4505     u_char offset;
4506     afs_int32 templ;
4507
4508     /*
4509      * Open the receive window once a thread starts reading packets
4510      */
4511     if (call->rnext > 1) {
4512         call->rwind = rx_maxReceiveWindow;
4513     }
4514
4515     call->nHardAcks = 0;
4516     call->nSoftAcks = 0;
4517     if (call->rnext > call->lastAcked)
4518         call->lastAcked = call->rnext;
4519     p = optionalPacket;
4520
4521     if (p) {
4522         rx_computelen(p, p->length);    /* reset length, you never know */
4523     } /* where that's been...         */
4524     else if (!(p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL))) {
4525         /* We won't send the ack, but don't panic. */
4526         return optionalPacket;
4527     }
4528
4529     templ =
4530         rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32) -
4531         rx_GetDataSize(p);
4532     if (templ > 0) {
4533         if (rxi_AllocDataBuf(p, templ, RX_PACKET_CLASS_SPECIAL)) {
4534             if (!optionalPacket)
4535                 rxi_FreePacket(p);
4536             return optionalPacket;
4537         }
4538         templ = rx_AckDataSize(call->rwind) + 2 * sizeof(afs_int32);
4539         if (rx_Contiguous(p) < templ) {
4540             if (!optionalPacket)
4541                 rxi_FreePacket(p);
4542             return optionalPacket;
4543         }
4544     }
4545
4546
4547     /* MTUXXX failing to send an ack is very serious.  We should */
4548     /* try as hard as possible to send even a partial ack; it's */
4549     /* better than nothing. */
4550     ap = (struct rx_ackPacket *)rx_DataOf(p);
4551     ap->bufferSpace = htonl(0); /* Something should go here, sometime */
4552     ap->reason = reason;
4553
4554     /* The skew computation used to be bogus, I think it's better now. */
4555     /* We should start paying attention to skew.    XXX  */
4556     ap->serial = htonl(serial);
4557     ap->maxSkew = 0;            /* used to be peer->inPacketSkew */
4558
4559     ap->firstPacket = htonl(call->rnext);       /* First packet not yet forwarded to reader */
4560     ap->previousPacket = htonl(call->rprev);    /* Previous packet received */
4561
4562     /* No fear of running out of ack packet here because there can only be at most
4563      * one window full of unacknowledged packets.  The window size must be constrained
4564      * to be less than the maximum ack size, of course.  Also, an ack should always
4565      * fit into a single packet -- it should not ever be fragmented.  */
4566     for (offset = 0, queue_Scan(&call->rq, rqp, nxp, rx_packet)) {
4567         if (!rqp || !call->rq.next
4568             || (rqp->header.seq > (call->rnext + call->rwind))) {
4569             if (!optionalPacket)
4570                 rxi_FreePacket(p);
4571             rxi_CallError(call, RX_CALL_DEAD);
4572             return optionalPacket;
4573         }
4574
4575         while (rqp->header.seq > call->rnext + offset)
4576             ap->acks[offset++] = RX_ACK_TYPE_NACK;
4577         ap->acks[offset++] = RX_ACK_TYPE_ACK;
4578
4579         if ((offset > (u_char) rx_maxReceiveWindow) || (offset > call->rwind)) {
4580             if (!optionalPacket)
4581                 rxi_FreePacket(p);
4582             rxi_CallError(call, RX_CALL_DEAD);
4583             return optionalPacket;
4584         }
4585     }
4586
4587     ap->nAcks = offset;
4588     p->length = rx_AckDataSize(offset) + 4 * sizeof(afs_int32);
4589
4590     /* these are new for AFS 3.3 */
4591     templ = rxi_AdjustMaxMTU(call->conn->peer->ifMTU, rx_maxReceiveSize);
4592     templ = htonl(templ);
4593     rx_packetwrite(p, rx_AckDataSize(offset), sizeof(afs_int32), &templ);
4594     templ = htonl(call->conn->peer->ifMTU);
4595     rx_packetwrite(p, rx_AckDataSize(offset) + sizeof(afs_int32),
4596                    sizeof(afs_int32), &templ);
4597
4598     /* new for AFS 3.4 */
4599     templ = htonl(call->rwind);
4600     rx_packetwrite(p, rx_AckDataSize(offset) + 2 * sizeof(afs_int32),
4601                    sizeof(afs_int32), &templ);
4602
4603     /* new for AFS 3.5 */
4604     templ = htonl(call->conn->peer->ifDgramPackets);
4605     rx_packetwrite(p, rx_AckDataSize(offset) + 3 * sizeof(afs_int32),
4606                    sizeof(afs_int32), &templ);
4607
4608     p->header.serviceId = call->conn->serviceId;
4609     p->header.cid = (call->conn->cid | call->channel);
4610     p->header.callNumber = *call->callNumber;
4611     p->header.seq = 0;
4612     p->header.securityIndex = call->conn->securityIndex;
4613     p->header.epoch = call->conn->epoch;
4614     p->header.type = RX_PACKET_TYPE_ACK;
4615     p->header.flags = RX_SLOW_START_OK;
4616     if (reason == RX_ACK_PING) {
4617         p->header.flags |= RX_REQUEST_ACK;
4618 #ifdef ADAPT_WINDOW
4619         clock_GetTime(&call->pingRequestTime);
4620 #endif
4621     }
4622     if (call->conn->type == RX_CLIENT_CONNECTION)
4623         p->header.flags |= RX_CLIENT_INITIATED;
4624
4625 #ifdef RXDEBUG
4626     if (rx_Log) {
4627         fprintf(rx_Log, "SACK: reason %x previous %u seq %u first %u",
4628                 ap->reason, ntohl(ap->previousPacket),
4629                 (unsigned int)p->header.seq, ntohl(ap->firstPacket));
4630         if (ap->nAcks) {
4631             for (offset = 0; offset < ap->nAcks; offset++)
4632                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
4633                      rx_Log);
4634         }
4635         putc('\n', rx_Log);
4636     }
4637 #endif
4638
4639     {
4640         register int i, nbytes = p->length;
4641
4642         for (i = 1; i < p->niovecs; i++) {      /* vec 0 is ALWAYS header */
4643             if (nbytes <= p->wirevec[i].iov_len) {
4644                 register int savelen, saven;
4645
4646                 savelen = p->wirevec[i].iov_len;
4647                 saven = p->niovecs;
4648                 p->wirevec[i].iov_len = nbytes;
4649                 p->niovecs = i + 1;
4650                 rxi_Send(call, p, istack);
4651                 p->wirevec[i].iov_len = savelen;
4652                 p->niovecs = saven;
4653                 break;
4654             } else
4655                 nbytes -= p->wirevec[i].iov_len;
4656         }
4657     }
4658     MUTEX_ENTER(&rx_stats_mutex);
4659     rx_stats.ackPacketsSent++;
4660     MUTEX_EXIT(&rx_stats_mutex);
4661     if (!optionalPacket)
4662         rxi_FreePacket(p);
4663     return optionalPacket;      /* Return packet for re-use by caller */
4664 }
4665
4666 /* Send all of the packets in the list in single datagram */
4667 static void
4668 rxi_SendList(struct rx_call *call, struct rx_packet **list, int len,
4669              int istack, int moreFlag, struct clock *now,
4670              struct clock *retryTime, int resending)
4671 {
4672     int i;
4673     int requestAck = 0;
4674     int lastPacket = 0;
4675     struct rx_connection *conn = call->conn;
4676     struct rx_peer *peer = conn->peer;
4677
4678     MUTEX_ENTER(&peer->peer_lock);
4679     peer->nSent += len;
4680     if (resending)
4681         peer->reSends += len;
4682     MUTEX_ENTER(&rx_stats_mutex);
4683     rx_stats.dataPacketsSent += len;
4684     MUTEX_EXIT(&rx_stats_mutex);
4685     MUTEX_EXIT(&peer->peer_lock);
4686
4687     if (list[len - 1]->header.flags & RX_LAST_PACKET) {
4688         lastPacket = 1;
4689     }
4690
4691     /* Set the packet flags and schedule the resend events */
4692     /* Only request an ack for the last packet in the list */
4693     for (i = 0; i < len; i++) {
4694         list[i]->retryTime = *retryTime;
4695         if (list[i]->header.serial) {
4696             /* Exponentially backoff retry times */
4697             if (list[i]->backoff < MAXBACKOFF) {
4698                 /* so it can't stay == 0 */
4699                 list[i]->backoff = (list[i]->backoff << 1) + 1;
4700             } else
4701                 list[i]->backoff++;
4702             clock_Addmsec(&(list[i]->retryTime),
4703                           ((afs_uint32) list[i]->backoff) << 8);
4704         }
4705
4706         /* Wait a little extra for the ack on the last packet */
4707         if (lastPacket && !(list[i]->header.flags & RX_CLIENT_INITIATED)) {
4708             clock_Addmsec(&(list[i]->retryTime), 400);
4709         }
4710
4711         /* Record the time sent */
4712         list[i]->timeSent = *now;
4713
4714         /* Ask for an ack on retransmitted packets,  on every other packet
4715          * if the peer doesn't support slow start. Ask for an ack on every
4716          * packet until the congestion window reaches the ack rate. */
4717         if (list[i]->header.serial) {
4718             requestAck = 1;
4719             MUTEX_ENTER(&rx_stats_mutex);
4720             rx_stats.dataPacketsReSent++;
4721             MUTEX_EXIT(&rx_stats_mutex);
4722         } else {
4723             /* improved RTO calculation- not Karn */
4724             list[i]->firstSent = *now;
4725             if (!lastPacket && (call->cwind <= (u_short) (conn->ackRate + 1)
4726                                 || (!(call->flags & RX_CALL_SLOW_START_OK)
4727                                     && (list[i]->header.seq & 1)))) {
4728                 requestAck = 1;
4729             }
4730         }
4731
4732         MUTEX_ENTER(&peer->peer_lock);
4733         peer->nSent++;
4734         if (resending)
4735             peer->reSends++;
4736         MUTEX_ENTER(&rx_stats_mutex);
4737         rx_stats.dataPacketsSent++;
4738         MUTEX_EXIT(&rx_stats_mutex);
4739         MUTEX_EXIT(&peer->peer_lock);
4740
4741         /* Tag this packet as not being the last in this group,
4742          * for the receiver's benefit */
4743         if (i < len - 1 || moreFlag) {
4744             list[i]->header.flags |= RX_MORE_PACKETS;
4745         }
4746
4747         /* Install the new retransmit time for the packet, and
4748          * record the time sent */
4749         list[i]->timeSent = *now;
4750     }
4751
4752     if (requestAck) {
4753         list[len - 1]->header.flags |= RX_REQUEST_ACK;
4754     }
4755
4756     /* Since we're about to send a data packet to the peer, it's
4757      * safe to nuke any scheduled end-of-packets ack */
4758     rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4759
4760     CALL_HOLD(call, RX_CALL_REFCOUNT_SEND);
4761     MUTEX_EXIT(&call->lock);
4762     if (len > 1) {
4763         rxi_SendPacketList(call, conn, list, len, istack);
4764     } else {
4765         rxi_SendPacket(call, conn, list[0], istack);
4766     }
4767     MUTEX_ENTER(&call->lock);
4768     CALL_RELE(call, RX_CALL_REFCOUNT_SEND);
4769
4770     /* Update last send time for this call (for keep-alive
4771      * processing), and for the connection (so that we can discover
4772      * idle connections) */
4773     conn->lastSendTime = call->lastSendTime = clock_Sec();
4774 }
4775
4776 /* When sending packets we need to follow these rules:
4777  * 1. Never send more than maxDgramPackets in a jumbogram.
4778  * 2. Never send a packet with more than two iovecs in a jumbogram.
4779  * 3. Never send a retransmitted packet in a jumbogram.
4780  * 4. Never send more than cwind/4 packets in a jumbogram
4781  * We always keep the last list we should have sent so we
4782  * can set the RX_MORE_PACKETS flags correctly.
4783  */
4784 static void
4785 rxi_SendXmitList(struct rx_call *call, struct rx_packet **list, int len,
4786                  int istack, struct clock *now, struct clock *retryTime,
4787                  int resending)
4788 {
4789     int i, cnt, lastCnt = 0;
4790     struct rx_packet **listP, **lastP = 0;
4791     struct rx_peer *peer = call->conn->peer;
4792     int morePackets = 0;
4793
4794     for (cnt = 0, listP = &list[0], i = 0; i < len; i++) {
4795         /* Does the current packet force us to flush the current list? */
4796         if (cnt > 0
4797             && (list[i]->header.serial || (list[i]->flags & RX_PKTFLAG_ACKED)
4798                 || list[i]->length > RX_JUMBOBUFFERSIZE)) {
4799             if (lastCnt > 0) {
4800                 rxi_SendList(call, lastP, lastCnt, istack, 1, now, retryTime,
4801                              resending);
4802                 /* If the call enters an error state stop sending, or if
4803                  * we entered congestion recovery mode, stop sending */
4804                 if (call->error || (call->flags & RX_CALL_FAST_RECOVER_WAIT))
4805                     return;
4806             }
4807             lastP = listP;
4808             lastCnt = cnt;
4809             listP = &list[i];
4810             cnt = 0;
4811         }
4812         /* Add the current packet to the list if it hasn't been acked.
4813          * Otherwise adjust the list pointer to skip the current packet.  */
4814         if (!(list[i]->flags & RX_PKTFLAG_ACKED)) {
4815             cnt++;
4816             /* Do we need to flush the list? */
4817             if (cnt >= (int)peer->maxDgramPackets
4818                 || cnt >= (int)call->nDgramPackets || cnt >= (int)call->cwind
4819                 || list[i]->header.serial
4820                 || list[i]->length != RX_JUMBOBUFFERSIZE) {
4821                 if (lastCnt > 0) {
4822                     rxi_SendList(call, lastP, lastCnt, istack, 1, now,
4823                                  retryTime, resending);
4824                     /* If the call enters an error state stop sending, or if
4825                      * we entered congestion recovery mode, stop sending */
4826                     if (call->error
4827                         || (call->flags & RX_CALL_FAST_RECOVER_WAIT))
4828                         return;
4829                 }
4830                 lastP = listP;
4831                 lastCnt = cnt;
4832                 listP = &list[i + 1];
4833                 cnt = 0;
4834             }
4835         } else {
4836             if (cnt != 0) {
4837                 osi_Panic("rxi_SendList error");
4838             }
4839             listP = &list[i + 1];
4840         }
4841     }
4842
4843     /* Send the whole list when the call is in receive mode, when
4844      * the call is in eof mode, when we are in fast recovery mode,
4845      * and when we have the last packet */
4846     if ((list[len - 1]->header.flags & RX_LAST_PACKET)
4847         || call->mode == RX_MODE_RECEIVING || call->mode == RX_MODE_EOF
4848         || (call->flags & RX_CALL_FAST_RECOVER)) {
4849         /* Check for the case where the current list contains
4850          * an acked packet. Since we always send retransmissions
4851          * in a separate packet, we only need to check the first
4852          * packet in the list */
4853         if (cnt > 0 && !(listP[0]->flags & RX_PKTFLAG_ACKED)) {
4854             morePackets = 1;
4855         }
4856         if (lastCnt > 0) {
4857             rxi_SendList(call, lastP, lastCnt, istack, morePackets, now,
4858                          retryTime, resending);
4859             /* If the call enters an error state stop sending, or if
4860              * we entered congestion recovery mode, stop sending */
4861             if (call->error || (call->flags & RX_CALL_FAST_RECOVER_WAIT))
4862                 return;
4863         }
4864         if (morePackets) {
4865             rxi_SendList(call, listP, cnt, istack, 0, now, retryTime,
4866                          resending);
4867         }
4868     } else if (lastCnt > 0) {
4869         rxi_SendList(call, lastP, lastCnt, istack, 0, now, retryTime,
4870                      resending);
4871     }
4872 }
4873
4874 #ifdef  RX_ENABLE_LOCKS
4875 /* Call rxi_Start, below, but with the call lock held. */
4876 void
4877 rxi_StartUnlocked(struct rxevent *event, register struct rx_call *call,
4878                   int istack)
4879 {
4880     MUTEX_ENTER(&call->lock);
4881     rxi_Start(event, call, istack);
4882     MUTEX_EXIT(&call->lock);
4883 }
4884 #endif /* RX_ENABLE_LOCKS */
4885
4886 /* This routine is called when new packets are readied for
4887  * transmission and when retransmission may be necessary, or when the
4888  * transmission window or burst count are favourable.  This should be
4889  * better optimized for new packets, the usual case, now that we've
4890  * got rid of queues of send packets. XXXXXXXXXXX */
4891 void
4892 rxi_Start(struct rxevent *event, register struct rx_call *call, int istack)
4893 {
4894     struct rx_packet *p;
4895     register struct rx_packet *nxp;     /* Next pointer for queue_Scan */
4896     struct rx_peer *peer = call->conn->peer;
4897     struct clock now, retryTime;
4898     int haveEvent;
4899     int nXmitPackets;
4900     int maxXmitPackets;
4901     struct rx_packet **xmitList;
4902     int resending = 0;
4903
4904     /* If rxi_Start is being called as a result of a resend event,
4905      * then make sure that the event pointer is removed from the call
4906      * structure, since there is no longer a per-call retransmission
4907      * event pending. */
4908     if (event && event == call->resendEvent) {
4909         CALL_RELE(call, RX_CALL_REFCOUNT_RESEND);
4910         call->resendEvent = NULL;
4911         resending = 1;
4912         if (queue_IsEmpty(&call->tq)) {
4913             /* Nothing to do */
4914             return;
4915         }
4916         /* Timeouts trigger congestion recovery */
4917 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4918         if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
4919             /* someone else is waiting to start recovery */
4920             return;
4921         }
4922         call->flags |= RX_CALL_FAST_RECOVER_WAIT;
4923         while (call->flags & RX_CALL_TQ_BUSY) {
4924             call->flags |= RX_CALL_TQ_WAIT;
4925 #ifdef RX_ENABLE_LOCKS
4926             CV_WAIT(&call->cv_tq, &call->lock);
4927 #else /* RX_ENABLE_LOCKS */
4928             osi_rxSleep(&call->tq);
4929 #endif /* RX_ENABLE_LOCKS */
4930         }
4931 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4932         call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
4933         call->flags |= RX_CALL_FAST_RECOVER;
4934         if (peer->maxDgramPackets > 1) {
4935             call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
4936         } else {
4937             call->MTU = MIN(peer->natMTU, peer->maxMTU);
4938         }
4939         call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
4940         call->nDgramPackets = 1;
4941         call->cwind = 1;
4942         call->nextCwind = 1;
4943         call->nAcks = 0;
4944         call->nNacks = 0;
4945         MUTEX_ENTER(&peer->peer_lock);
4946         peer->MTU = call->MTU;
4947         peer->cwind = call->cwind;
4948         peer->nDgramPackets = 1;
4949         peer->congestSeq++;
4950         call->congestSeq = peer->congestSeq;
4951         MUTEX_EXIT(&peer->peer_lock);
4952         /* Clear retry times on packets. Otherwise, it's possible for
4953          * some packets in the queue to force resends at rates faster
4954          * than recovery rates.
4955          */
4956         for (queue_Scan(&call->tq, p, nxp, rx_packet)) {
4957             if (!(p->flags & RX_PKTFLAG_ACKED)) {
4958                 clock_Zero(&p->retryTime);
4959             }
4960         }
4961     }
4962     if (call->error) {
4963 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4964         MUTEX_ENTER(&rx_stats_mutex);
4965         rx_tq_debug.rxi_start_in_error++;
4966         MUTEX_EXIT(&rx_stats_mutex);
4967 #endif
4968         return;
4969     }
4970
4971     if (queue_IsNotEmpty(&call->tq)) {  /* If we have anything to send */
4972         /* Get clock to compute the re-transmit time for any packets
4973          * in this burst.  Note, if we back off, it's reasonable to
4974          * back off all of the packets in the same manner, even if
4975          * some of them have been retransmitted more times than more
4976          * recent additions */
4977         clock_GetTime(&now);
4978         retryTime = now;        /* initialize before use */
4979         MUTEX_ENTER(&peer->peer_lock);
4980         clock_Add(&retryTime, &peer->timeout);
4981         MUTEX_EXIT(&peer->peer_lock);
4982
4983         /* Send (or resend) any packets that need it, subject to
4984          * window restrictions and congestion burst control
4985          * restrictions.  Ask for an ack on the last packet sent in
4986          * this burst.  For now, we're relying upon the window being
4987          * considerably bigger than the largest number of packets that
4988          * are typically sent at once by one initial call to
4989          * rxi_Start.  This is probably bogus (perhaps we should ask
4990          * for an ack when we're half way through the current
4991          * window?).  Also, for non file transfer applications, this
4992          * may end up asking for an ack for every packet.  Bogus. XXXX
4993          */
4994         /*
4995          * But check whether we're here recursively, and let the other guy
4996          * do the work.
4997          */
4998 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4999         if (!(call->flags & RX_CALL_TQ_BUSY)) {
5000             call->flags |= RX_CALL_TQ_BUSY;
5001             do {
5002                 call->flags &= ~RX_CALL_NEED_START;
5003 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5004                 nXmitPackets = 0;
5005                 maxXmitPackets = MIN(call->twind, call->cwind);
5006                 xmitList = (struct rx_packet **)
5007                     osi_Alloc(maxXmitPackets * sizeof(struct rx_packet *));
5008                 if (xmitList == NULL)
5009                     osi_Panic("rxi_Start, failed to allocate xmit list");
5010                 for (queue_Scan(&call->tq, p, nxp, rx_packet)) {
5011                     if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
5012                         /* We shouldn't be sending packets if a thread is waiting
5013                          * to initiate congestion recovery */
5014                         break;
5015                     }
5016                     if ((nXmitPackets)
5017                         && (call->flags & RX_CALL_FAST_RECOVER)) {
5018                         /* Only send one packet during fast recovery */
5019                         break;
5020                     }
5021                     if ((p->flags & RX_PKTFLAG_FREE)
5022                         || (!queue_IsEnd(&call->tq, nxp)
5023                             && (nxp->flags & RX_PKTFLAG_FREE))
5024                         || (p == (struct rx_packet *)&rx_freePacketQueue)
5025                         || (nxp == (struct rx_packet *)&rx_freePacketQueue)) {
5026                         osi_Panic("rxi_Start: xmit queue clobbered");
5027                     }
5028                     if (p->flags & RX_PKTFLAG_ACKED) {
5029                         MUTEX_ENTER(&rx_stats_mutex);
5030                         rx_stats.ignoreAckedPacket++;
5031                         MUTEX_EXIT(&rx_stats_mutex);
5032                         continue;       /* Ignore this packet if it has been acknowledged */
5033                     }
5034
5035                     /* Turn off all flags except these ones, which are the same
5036                      * on each transmission */
5037                     p->header.flags &= RX_PRESET_FLAGS;
5038
5039                     if (p->header.seq >=
5040                         call->tfirst + MIN((int)call->twind,
5041                                            (int)(call->nSoftAcked +
5042                                                  call->cwind))) {
5043                         call->flags |= RX_CALL_WAIT_WINDOW_SEND;        /* Wait for transmit window */
5044                         /* Note: if we're waiting for more window space, we can
5045                          * still send retransmits; hence we don't return here, but
5046                          * break out to schedule a retransmit event */
5047                         dpf(("call %d waiting for window",
5048                              *(call->callNumber)));
5049                         break;
5050                     }
5051
5052                     /* Transmit the packet if it needs to be sent. */
5053                     if (!clock_Lt(&now, &p->retryTime)) {
5054                         if (nXmitPackets == maxXmitPackets) {
5055                             osi_Panic("rxi_Start: xmit list overflowed");
5056                         }
5057                         xmitList[nXmitPackets++] = p;
5058                     }
5059                 }
5060
5061                 /* xmitList now hold pointers to all of the packets that are
5062                  * ready to send. Now we loop to send the packets */
5063                 if (nXmitPackets > 0) {
5064                     rxi_SendXmitList(call, xmitList, nXmitPackets, istack,
5065                                      &now, &retryTime, resending);
5066                 }
5067                 osi_Free(xmitList,
5068                          maxXmitPackets * sizeof(struct rx_packet *));
5069
5070 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5071                 /*
5072                  * TQ references no longer protected by this flag; they must remain
5073                  * protected by the global lock.
5074                  */
5075                 if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
5076                     call->flags &= ~RX_CALL_TQ_BUSY;
5077                     if (call->flags & RX_CALL_TQ_WAIT) {
5078                         call->flags &= ~RX_CALL_TQ_WAIT;
5079 #ifdef RX_ENABLE_LOCKS
5080                         CV_BROADCAST(&call->cv_tq);
5081 #else /* RX_ENABLE_LOCKS */
5082                         osi_rxWakeup(&call->tq);
5083 #endif /* RX_ENABLE_LOCKS */
5084                     }
5085                     return;
5086                 }
5087                 if (call->error) {
5088                     /* We went into the error state while sending packets. Now is
5089                      * the time to reset the call. This will also inform the using
5090                      * process that the call is in an error state.
5091                      */
5092                     MUTEX_ENTER(&rx_stats_mutex);
5093                     rx_tq_debug.rxi_start_aborted++;
5094                     MUTEX_EXIT(&rx_stats_mutex);
5095                     call->flags &= ~RX_CALL_TQ_BUSY;
5096                     if (call->flags & RX_CALL_TQ_WAIT) {
5097                         call->flags &= ~RX_CALL_TQ_WAIT;
5098 #ifdef RX_ENABLE_LOCKS
5099                         CV_BROADCAST(&call->cv_tq);
5100 #else /* RX_ENABLE_LOCKS */
5101                         osi_rxWakeup(&call->tq);
5102 #endif /* RX_ENABLE_LOCKS */
5103                     }
5104                     rxi_CallError(call, call->error);
5105                     return;
5106                 }
5107 #ifdef RX_ENABLE_LOCKS
5108                 if (call->flags & RX_CALL_TQ_SOME_ACKED) {
5109                     register int missing;
5110                     call->flags &= ~RX_CALL_TQ_SOME_ACKED;
5111                     /* Some packets have received acks. If they all have, we can clear
5112                      * the transmit queue.
5113                      */
5114                     for (missing =
5115                          0, queue_Scan(&call->tq, p, nxp, rx_packet)) {
5116                         if (p->header.seq < call->tfirst
5117                             && (p->flags & RX_PKTFLAG_ACKED)) {
5118                             queue_Remove(p);
5119                             rxi_FreePacket(p);
5120                         } else
5121                             missing = 1;
5122                     }
5123                     if (!missing)
5124                         call->flags |= RX_CALL_TQ_CLEARME;
5125                 }
5126 #endif /* RX_ENABLE_LOCKS */
5127                 /* Don't bother doing retransmits if the TQ is cleared. */
5128                 if (call->flags & RX_CALL_TQ_CLEARME) {
5129                     rxi_ClearTransmitQueue(call, 1);
5130                 } else
5131 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5132                 {
5133
5134                     /* Always post a resend event, if there is anything in the
5135                      * queue, and resend is possible.  There should be at least
5136                      * one unacknowledged packet in the queue ... otherwise none
5137                      * of these packets should be on the queue in the first place.
5138                      */
5139                     if (call->resendEvent) {
5140                         /* Cancel the existing event and post a new one */
5141                         rxevent_Cancel(call->resendEvent, call,
5142                                        RX_CALL_REFCOUNT_RESEND);
5143                     }
5144
5145                     /* The retry time is the retry time on the first unacknowledged
5146                      * packet inside the current window */
5147                     for (haveEvent =
5148                          0, queue_Scan(&call->tq, p, nxp, rx_packet)) {
5149                         /* Don't set timers for packets outside the window */
5150                         if (p->header.seq >= call->tfirst + call->twind) {
5151                             break;
5152                         }
5153
5154                         if (!(p->flags & RX_PKTFLAG_ACKED)
5155                             && !clock_IsZero(&p->retryTime)) {
5156                             haveEvent = 1;
5157                             retryTime = p->retryTime;
5158                             break;
5159                         }
5160                     }
5161
5162                     /* Post a new event to re-run rxi_Start when retries may be needed */
5163                     if (haveEvent && !(call->flags & RX_CALL_NEED_START)) {
5164 #ifdef RX_ENABLE_LOCKS
5165                         CALL_HOLD(call, RX_CALL_REFCOUNT_RESEND);
5166                         call->resendEvent =
5167                             rxevent_Post(&retryTime, rxi_StartUnlocked,
5168                                          (void *)call, (void *)istack);
5169 #else /* RX_ENABLE_LOCKS */
5170                         call->resendEvent =
5171                             rxevent_Post(&retryTime, rxi_Start, (void *)call,
5172                                          (void *)istack);
5173 #endif /* RX_ENABLE_LOCKS */
5174                     }
5175                 }
5176 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5177             } while (call->flags & RX_CALL_NEED_START);
5178             /*
5179              * TQ references no longer protected by this flag; they must remain
5180              * protected by the global lock.
5181              */
5182             call->flags &= ~RX_CALL_TQ_BUSY;
5183             if (call->flags & RX_CALL_TQ_WAIT) {
5184                 call->flags &= ~RX_CALL_TQ_WAIT;
5185 #ifdef RX_ENABLE_LOCKS
5186                 CV_BROADCAST(&call->cv_tq);
5187 #else /* RX_ENABLE_LOCKS */
5188                 osi_rxWakeup(&call->tq);
5189 #endif /* RX_ENABLE_LOCKS */
5190             }
5191         } else {
5192             call->flags |= RX_CALL_NEED_START;
5193         }
5194 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5195     } else {
5196         if (call->resendEvent) {
5197             rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
5198         }
5199     }
5200 }
5201
5202 /* Also adjusts the keep alive parameters for the call, to reflect
5203  * that we have just sent a packet (so keep alives aren't sent
5204  * immediately) */
5205 void
5206 rxi_Send(register struct rx_call *call, register struct rx_packet *p,
5207          int istack)
5208 {
5209     register struct rx_connection *conn = call->conn;
5210
5211     /* Stamp each packet with the user supplied status */
5212     p->header.userStatus = call->localStatus;
5213
5214     /* Allow the security object controlling this call's security to
5215      * make any last-minute changes to the packet */
5216     RXS_SendPacket(conn->securityObject, call, p);
5217
5218     /* Since we're about to send SOME sort of packet to the peer, it's
5219      * safe to nuke any scheduled end-of-packets ack */
5220     rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
5221
5222     /* Actually send the packet, filling in more connection-specific fields */
5223     CALL_HOLD(call, RX_CALL_REFCOUNT_SEND);
5224     MUTEX_EXIT(&call->lock);
5225     rxi_SendPacket(call, conn, p, istack);
5226     MUTEX_ENTER(&call->lock);
5227     CALL_RELE(call, RX_CALL_REFCOUNT_SEND);
5228
5229     /* Update last send time for this call (for keep-alive
5230      * processing), and for the connection (so that we can discover
5231      * idle connections) */
5232     conn->lastSendTime = call->lastSendTime = clock_Sec();
5233 }
5234
5235
5236 /* Check if a call needs to be destroyed.  Called by keep-alive code to ensure
5237  * that things are fine.  Also called periodically to guarantee that nothing
5238  * falls through the cracks (e.g. (error + dally) connections have keepalive
5239  * turned off.  Returns 0 if conn is well, -1 otherwise.  If otherwise, call
5240  *  may be freed!
5241  * haveCTLock Set if calling from rxi_ReapConnections
5242  */
5243 #ifdef RX_ENABLE_LOCKS
5244 int
5245 rxi_CheckCall(register struct rx_call *call, int haveCTLock)
5246 #else /* RX_ENABLE_LOCKS */
5247 int
5248 rxi_CheckCall(register struct rx_call *call)
5249 #endif                          /* RX_ENABLE_LOCKS */
5250 {
5251     register struct rx_connection *conn = call->conn;
5252     afs_uint32 now;
5253     afs_uint32 deadTime;
5254
5255 #ifdef RX_GLOBAL_RXLOCK_KERNEL
5256     if (call->flags & RX_CALL_TQ_BUSY) {
5257         /* Call is active and will be reset by rxi_Start if it's
5258          * in an error state.
5259          */
5260         return 0;
5261     }
5262 #endif
5263     /* dead time + RTT + 8*MDEV, rounded up to next second. */
5264     deadTime =
5265         (((afs_uint32) conn->secondsUntilDead << 10) +
5266          ((afs_uint32) conn->peer->rtt >> 3) +
5267          ((afs_uint32) conn->peer->rtt_dev << 1) + 1023) >> 10;
5268     now = clock_Sec();
5269     /* These are computed to the second (+- 1 second).  But that's
5270      * good enough for these values, which should be a significant
5271      * number of seconds. */
5272     if (now > (call->lastReceiveTime + deadTime)) {
5273         if (call->state == RX_STATE_ACTIVE) {
5274             rxi_CallError(call, RX_CALL_DEAD);
5275             return -1;
5276         } else {
5277 #ifdef RX_ENABLE_LOCKS
5278             /* Cancel pending events */
5279             rxevent_Cancel(call->delayedAckEvent, call,
5280                            RX_CALL_REFCOUNT_DELAY);
5281             rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
5282             rxevent_Cancel(call->keepAliveEvent, call,
5283                            RX_CALL_REFCOUNT_ALIVE);
5284             if (call->refCount == 0) {
5285                 rxi_FreeCall(call, haveCTLock);
5286                 return -2;
5287             }
5288             return -1;
5289 #else /* RX_ENABLE_LOCKS */
5290             rxi_FreeCall(call);
5291             return -2;
5292 #endif /* RX_ENABLE_LOCKS */
5293         }
5294         /* Non-active calls are destroyed if they are not responding
5295          * to pings; active calls are simply flagged in error, so the
5296          * attached process can die reasonably gracefully. */
5297     }
5298     /* see if we have a non-activity timeout */
5299     if (call->startWait && conn->idleDeadTime
5300         && ((call->startWait + conn->idleDeadTime) < now)) {
5301         if (call->state == RX_STATE_ACTIVE) {
5302             rxi_CallError(call, RX_CALL_TIMEOUT);
5303             return -1;
5304         }
5305     }
5306     /* see if we have a hard timeout */
5307     if (conn->hardDeadTime
5308         && (now > (conn->hardDeadTime + call->startTime.sec))) {
5309         if (call->state == RX_STATE_ACTIVE)
5310             rxi_CallError(call, RX_CALL_TIMEOUT);
5311         return -1;
5312     }
5313     return 0;
5314 }
5315
5316
5317 /* When a call is in progress, this routine is called occasionally to
5318  * make sure that some traffic has arrived (or been sent to) the peer.
5319  * If nothing has arrived in a reasonable amount of time, the call is
5320  * declared dead; if nothing has been sent for a while, we send a
5321  * keep-alive packet (if we're actually trying to keep the call alive)
5322  */
5323 void
5324 rxi_KeepAliveEvent(struct rxevent *event, register struct rx_call *call,
5325                    char *dummy)
5326 {
5327     struct rx_connection *conn;
5328     afs_uint32 now;
5329
5330     MUTEX_ENTER(&call->lock);
5331     CALL_RELE(call, RX_CALL_REFCOUNT_ALIVE);
5332     if (event == call->keepAliveEvent)
5333         call->keepAliveEvent = NULL;
5334     now = clock_Sec();
5335
5336 #ifdef RX_ENABLE_LOCKS
5337     if (rxi_CheckCall(call, 0)) {
5338         MUTEX_EXIT(&call->lock);
5339         return;
5340     }
5341 #else /* RX_ENABLE_LOCKS */
5342     if (rxi_CheckCall(call))
5343         return;
5344 #endif /* RX_ENABLE_LOCKS */
5345
5346     /* Don't try to keep alive dallying calls */
5347     if (call->state == RX_STATE_DALLY) {
5348         MUTEX_EXIT(&call->lock);
5349         return;
5350     }
5351
5352     conn = call->conn;
5353     if ((now - call->lastSendTime) > conn->secondsUntilPing) {
5354         /* Don't try to send keepalives if there is unacknowledged data */
5355         /* the rexmit code should be good enough, this little hack
5356          * doesn't quite work XXX */
5357         (void)rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
5358     }
5359     rxi_ScheduleKeepAliveEvent(call);
5360     MUTEX_EXIT(&call->lock);
5361 }
5362
5363
5364 void
5365 rxi_ScheduleKeepAliveEvent(register struct rx_call *call)
5366 {
5367     if (!call->keepAliveEvent) {
5368         struct clock when;
5369         clock_GetTime(&when);
5370         when.sec += call->conn->secondsUntilPing;
5371         CALL_HOLD(call, RX_CALL_REFCOUNT_ALIVE);
5372         call->keepAliveEvent =
5373             rxevent_Post(&when, rxi_KeepAliveEvent, call, 0);
5374     }
5375 }
5376
5377 /* N.B. rxi_KeepAliveOff:  is defined earlier as a macro */
5378 void
5379 rxi_KeepAliveOn(register struct rx_call *call)
5380 {
5381     /* Pretend last packet received was received now--i.e. if another
5382      * packet isn't received within the keep alive time, then the call
5383      * will die; Initialize last send time to the current time--even
5384      * if a packet hasn't been sent yet.  This will guarantee that a
5385      * keep-alive is sent within the ping time */
5386     call->lastReceiveTime = call->lastSendTime = clock_Sec();
5387     rxi_ScheduleKeepAliveEvent(call);
5388 }
5389
5390 /* This routine is called to send connection abort messages
5391  * that have been delayed to throttle looping clients. */
5392 void
5393 rxi_SendDelayedConnAbort(struct rxevent *event,
5394                          register struct rx_connection *conn, char *dummy)
5395 {
5396     afs_int32 error;
5397     struct rx_packet *packet;
5398
5399     MUTEX_ENTER(&conn->conn_data_lock);
5400     conn->delayedAbortEvent = NULL;
5401     error = htonl(conn->error);
5402     conn->abortCount++;
5403     MUTEX_EXIT(&conn->conn_data_lock);
5404     packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5405     if (packet) {
5406         packet =
5407             rxi_SendSpecial((struct rx_call *)0, conn, packet,
5408                             RX_PACKET_TYPE_ABORT, (char *)&error,
5409                             sizeof(error), 0);
5410         rxi_FreePacket(packet);
5411     }
5412 }
5413
5414 /* This routine is called to send call abort messages
5415  * that have been delayed to throttle looping clients. */
5416 void
5417 rxi_SendDelayedCallAbort(struct rxevent *event, register struct rx_call *call,
5418                          char *dummy)
5419 {
5420     afs_int32 error;
5421     struct rx_packet *packet;
5422
5423     MUTEX_ENTER(&call->lock);
5424     call->delayedAbortEvent = NULL;
5425     error = htonl(call->error);
5426     call->abortCount++;
5427     packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5428     if (packet) {
5429         packet =
5430             rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
5431                             (char *)&error, sizeof(error), 0);
5432         rxi_FreePacket(packet);
5433     }
5434     MUTEX_EXIT(&call->lock);
5435 }
5436
5437 /* This routine is called periodically (every RX_AUTH_REQUEST_TIMEOUT
5438  * seconds) to ask the client to authenticate itself.  The routine
5439  * issues a challenge to the client, which is obtained from the
5440  * security object associated with the connection */
5441 void
5442 rxi_ChallengeEvent(struct rxevent *event, register struct rx_connection *conn,
5443                    void *atries)
5444 {
5445     int tries = (int)atries;
5446     conn->challengeEvent = NULL;
5447     if (RXS_CheckAuthentication(conn->securityObject, conn) != 0) {
5448         register struct rx_packet *packet;
5449         struct clock when;
5450
5451         if (tries <= 0) {
5452             /* We've failed to authenticate for too long.
5453              * Reset any calls waiting for authentication;
5454              * they are all in RX_STATE_PRECALL.
5455              */
5456             int i;
5457
5458             MUTEX_ENTER(&conn->conn_call_lock);
5459             for (i = 0; i < RX_MAXCALLS; i++) {
5460                 struct rx_call *call = conn->call[i];
5461                 if (call) {
5462                     MUTEX_ENTER(&call->lock);
5463                     if (call->state == RX_STATE_PRECALL) {
5464                         rxi_CallError(call, RX_CALL_DEAD);
5465                         rxi_SendCallAbort(call, NULL, 0, 0);
5466                     }
5467                     MUTEX_EXIT(&call->lock);
5468                 }
5469             }
5470             MUTEX_EXIT(&conn->conn_call_lock);
5471             return;
5472         }
5473
5474         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5475         if (packet) {
5476             /* If there's no packet available, do this later. */
5477             RXS_GetChallenge(conn->securityObject, conn, packet);
5478             rxi_SendSpecial((struct rx_call *)0, conn, packet,
5479                             RX_PACKET_TYPE_CHALLENGE, NULL, -1, 0);
5480             rxi_FreePacket(packet);
5481         }
5482         clock_GetTime(&when);
5483         when.sec += RX_CHALLENGE_TIMEOUT;
5484         conn->challengeEvent =
5485             rxevent_Post(&when, rxi_ChallengeEvent, conn,
5486                          (void *)(tries - 1));
5487     }
5488 }
5489
5490 /* Call this routine to start requesting the client to authenticate
5491  * itself.  This will continue until authentication is established,
5492  * the call times out, or an invalid response is returned.  The
5493  * security object associated with the connection is asked to create
5494  * the challenge at this time.  N.B.  rxi_ChallengeOff is a macro,
5495  * defined earlier. */
5496 void
5497 rxi_ChallengeOn(register struct rx_connection *conn)
5498 {
5499     if (!conn->challengeEvent) {
5500         RXS_CreateChallenge(conn->securityObject, conn);
5501         rxi_ChallengeEvent(NULL, conn, (void *)RX_CHALLENGE_MAXTRIES);
5502     };
5503 }
5504
5505
5506 /* Compute round trip time of the packet provided, in *rttp.
5507  */
5508
5509 /* rxi_ComputeRoundTripTime is called with peer locked. */
5510 /* sentp and/or peer may be null */
5511 void
5512 rxi_ComputeRoundTripTime(register struct rx_packet *p,
5513                          register struct clock *sentp,
5514                          register struct rx_peer *peer)
5515 {
5516     struct clock thisRtt, *rttp = &thisRtt;
5517
5518 #if defined(AFS_ALPHA_LINUX22_ENV) && defined(AFS_PTHREAD_ENV) && !defined(KERNEL)
5519     /* making year 2038 bugs to get this running now - stroucki */
5520     struct timeval temptime;
5521 #endif
5522     register int rtt_timeout;
5523
5524 #if defined(AFS_ALPHA_LINUX20_ENV) && defined(AFS_PTHREAD_ENV) && !defined(KERNEL)
5525     /* yet again. This was the worst Heisenbug of the port - stroucki */
5526     clock_GetTime(&temptime);
5527     rttp->sec = (afs_int32) temptime.tv_sec;
5528     rttp->usec = (afs_int32) temptime.tv_usec;
5529 #else
5530     clock_GetTime(rttp);
5531 #endif
5532     if (clock_Lt(rttp, sentp)) {
5533         clock_Zero(rttp);
5534         return;                 /* somebody set the clock back, don't count this time. */
5535     }
5536     clock_Sub(rttp, sentp);
5537     MUTEX_ENTER(&rx_stats_mutex);
5538     if (clock_Lt(rttp, &rx_stats.minRtt))
5539         rx_stats.minRtt = *rttp;
5540     if (clock_Gt(rttp, &rx_stats.maxRtt)) {
5541         if (rttp->sec > 60) {
5542             MUTEX_EXIT(&rx_stats_mutex);
5543             return;             /* somebody set the clock ahead */
5544         }
5545         rx_stats.maxRtt = *rttp;
5546     }
5547     clock_Add(&rx_stats.totalRtt, rttp);
5548     rx_stats.nRttSamples++;
5549     MUTEX_EXIT(&rx_stats_mutex);
5550
5551     /* better rtt calculation courtesy of UMich crew (dave,larry,peter,?) */
5552
5553     /* Apply VanJacobson round-trip estimations */
5554     if (peer->rtt) {
5555         register int delta;
5556
5557         /*
5558          * srtt (peer->rtt) is in units of one-eighth-milliseconds.
5559          * srtt is stored as fixed point with 3 bits after the binary
5560          * point (i.e., scaled by 8). The following magic is
5561          * equivalent to the smoothing algorithm in rfc793 with an
5562          * alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed point).
5563          * srtt*8 = srtt*8 + rtt - srtt
5564          * srtt = srtt + rtt/8 - srtt/8
5565          */
5566
5567         delta = MSEC(rttp) - (peer->rtt >> 3);
5568         peer->rtt += delta;
5569
5570         /*
5571          * We accumulate a smoothed rtt variance (actually, a smoothed
5572          * mean difference), then set the retransmit timer to smoothed
5573          * rtt + 4 times the smoothed variance (was 2x in van's original
5574          * paper, but 4x works better for me, and apparently for him as
5575          * well).
5576          * rttvar is stored as
5577          * fixed point with 2 bits after the binary point (scaled by
5578          * 4).  The following is equivalent to rfc793 smoothing with
5579          * an alpha of .75 (rttvar = rttvar*3/4 + |delta| / 4).  This
5580          * replaces rfc793's wired-in beta.
5581          * dev*4 = dev*4 + (|actual - expected| - dev)
5582          */
5583
5584         if (delta < 0)
5585             delta = -delta;
5586
5587         delta -= (peer->rtt_dev >> 2);
5588         peer->rtt_dev += delta;
5589     } else {
5590         /* I don't have a stored RTT so I start with this value.  Since I'm
5591          * probably just starting a call, and will be pushing more data down
5592          * this, I expect congestion to increase rapidly.  So I fudge a
5593          * little, and I set deviance to half the rtt.  In practice,
5594          * deviance tends to approach something a little less than
5595          * half the smoothed rtt. */
5596         peer->rtt = (MSEC(rttp) << 3) + 8;
5597         peer->rtt_dev = peer->rtt >> 2; /* rtt/2: they're scaled differently */
5598     }
5599     /* the timeout is RTT + 4*MDEV + 0.35 sec   This is because one end or
5600      * the other of these connections is usually in a user process, and can
5601      * be switched and/or swapped out.  So on fast, reliable networks, the
5602      * timeout would otherwise be too short.
5603      */
5604     rtt_timeout = (peer->rtt >> 3) + peer->rtt_dev + 350;
5605     clock_Zero(&(peer->timeout));
5606     clock_Addmsec(&(peer->timeout), rtt_timeout);
5607
5608     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)));
5609 }
5610
5611
5612 /* Find all server connections that have not been active for a long time, and
5613  * toss them */
5614 void
5615 rxi_ReapConnections(void)
5616 {
5617     struct clock now;
5618     clock_GetTime(&now);
5619
5620     /* Find server connection structures that haven't been used for
5621      * greater than rx_idleConnectionTime */
5622     {
5623         struct rx_connection **conn_ptr, **conn_end;
5624         int i, havecalls = 0;
5625         MUTEX_ENTER(&rx_connHashTable_lock);
5626         for (conn_ptr = &rx_connHashTable[0], conn_end =
5627              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
5628              conn_ptr++) {
5629             struct rx_connection *conn, *next;
5630             struct rx_call *call;
5631             int result;
5632
5633           rereap:
5634             for (conn = *conn_ptr; conn; conn = next) {
5635                 /* XXX -- Shouldn't the connection be locked? */
5636                 next = conn->next;
5637                 havecalls = 0;
5638                 for (i = 0; i < RX_MAXCALLS; i++) {
5639                     call = conn->call[i];
5640                     if (call) {
5641                         havecalls = 1;
5642                         MUTEX_ENTER(&call->lock);
5643 #ifdef RX_ENABLE_LOCKS
5644                         result = rxi_CheckCall(call, 1);
5645 #else /* RX_ENABLE_LOCKS */
5646                         result = rxi_CheckCall(call);
5647 #endif /* RX_ENABLE_LOCKS */
5648                         MUTEX_EXIT(&call->lock);
5649                         if (result == -2) {
5650                             /* If CheckCall freed the call, it might
5651                              * have destroyed  the connection as well,
5652                              * which screws up the linked lists.
5653                              */
5654                             goto rereap;
5655                         }
5656                     }
5657                 }
5658                 if (conn->type == RX_SERVER_CONNECTION) {
5659                     /* This only actually destroys the connection if
5660                      * there are no outstanding calls */
5661                     MUTEX_ENTER(&conn->conn_data_lock);
5662                     if (!havecalls && !conn->refCount
5663                         && ((conn->lastSendTime + rx_idleConnectionTime) <
5664                             now.sec)) {
5665                         conn->refCount++;       /* it will be decr in rx_DestroyConn */
5666                         MUTEX_EXIT(&conn->conn_data_lock);
5667 #ifdef RX_ENABLE_LOCKS
5668                         rxi_DestroyConnectionNoLock(conn);
5669 #else /* RX_ENABLE_LOCKS */
5670                         rxi_DestroyConnection(conn);
5671 #endif /* RX_ENABLE_LOCKS */
5672                     }
5673 #ifdef RX_ENABLE_LOCKS
5674                     else {
5675                         MUTEX_EXIT(&conn->conn_data_lock);
5676                     }
5677 #endif /* RX_ENABLE_LOCKS */
5678                 }
5679             }
5680         }
5681 #ifdef RX_ENABLE_LOCKS
5682         while (rx_connCleanup_list) {
5683             struct rx_connection *conn;
5684             conn = rx_connCleanup_list;
5685             rx_connCleanup_list = rx_connCleanup_list->next;
5686             MUTEX_EXIT(&rx_connHashTable_lock);
5687             rxi_CleanupConnection(conn);
5688             MUTEX_ENTER(&rx_connHashTable_lock);
5689         }
5690         MUTEX_EXIT(&rx_connHashTable_lock);
5691 #endif /* RX_ENABLE_LOCKS */
5692     }
5693
5694     /* Find any peer structures that haven't been used (haven't had an
5695      * associated connection) for greater than rx_idlePeerTime */
5696     {
5697         struct rx_peer **peer_ptr, **peer_end;
5698         int code;
5699         MUTEX_ENTER(&rx_rpc_stats);
5700         MUTEX_ENTER(&rx_peerHashTable_lock);
5701         for (peer_ptr = &rx_peerHashTable[0], peer_end =
5702              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
5703              peer_ptr++) {
5704             struct rx_peer *peer, *next, *prev;
5705             for (prev = peer = *peer_ptr; peer; peer = next) {
5706                 next = peer->next;
5707                 code = MUTEX_TRYENTER(&peer->peer_lock);
5708                 if ((code) && (peer->refCount == 0)
5709                     && ((peer->idleWhen + rx_idlePeerTime) < now.sec)) {
5710                     rx_interface_stat_p rpc_stat, nrpc_stat;
5711                     size_t space;
5712                     MUTEX_EXIT(&peer->peer_lock);
5713                     MUTEX_DESTROY(&peer->peer_lock);
5714                     for (queue_Scan
5715                          (&peer->rpcStats, rpc_stat, nrpc_stat,
5716                           rx_interface_stat)) {
5717                         unsigned int num_funcs;
5718                         if (!rpc_stat)
5719                             break;
5720                         queue_Remove(&rpc_stat->queue_header);
5721                         queue_Remove(&rpc_stat->all_peers);
5722                         num_funcs = rpc_stat->stats[0].func_total;
5723                         space =
5724                             sizeof(rx_interface_stat_t) +
5725                             rpc_stat->stats[0].func_total *
5726                             sizeof(rx_function_entry_v1_t);
5727
5728                         rxi_Free(rpc_stat, space);
5729                         rxi_rpc_peer_stat_cnt -= num_funcs;
5730                     }
5731                     rxi_FreePeer(peer);
5732                     MUTEX_ENTER(&rx_stats_mutex);
5733                     rx_stats.nPeerStructs--;
5734                     MUTEX_EXIT(&rx_stats_mutex);
5735                     if (prev == *peer_ptr) {
5736                         *peer_ptr = next;
5737                         prev = next;
5738                     } else
5739                         prev->next = next;
5740                 } else {
5741                     if (code) {
5742                         MUTEX_EXIT(&peer->peer_lock);
5743                     }
5744                     prev = peer;
5745                 }
5746             }
5747         }
5748         MUTEX_EXIT(&rx_peerHashTable_lock);
5749         MUTEX_EXIT(&rx_rpc_stats);
5750     }
5751
5752     /* THIS HACK IS A TEMPORARY HACK.  The idea is that the race condition in
5753      * rxi_AllocSendPacket, if it hits, will be handled at the next conn
5754      * GC, just below.  Really, we shouldn't have to keep moving packets from
5755      * one place to another, but instead ought to always know if we can
5756      * afford to hold onto a packet in its particular use.  */
5757     MUTEX_ENTER(&rx_freePktQ_lock);
5758     if (rx_waitingForPackets) {
5759         rx_waitingForPackets = 0;
5760 #ifdef  RX_ENABLE_LOCKS
5761         CV_BROADCAST(&rx_waitingForPackets_cv);
5762 #else
5763         osi_rxWakeup(&rx_waitingForPackets);
5764 #endif
5765     }
5766     MUTEX_EXIT(&rx_freePktQ_lock);
5767
5768     now.sec += RX_REAP_TIME;    /* Check every RX_REAP_TIME seconds */
5769     rxevent_Post(&now, rxi_ReapConnections, 0, 0);
5770 }
5771
5772
5773 /* rxs_Release - This isn't strictly necessary but, since the macro name from
5774  * rx.h is sort of strange this is better.  This is called with a security
5775  * object before it is discarded.  Each connection using a security object has
5776  * its own refcount to the object so it won't actually be freed until the last
5777  * connection is destroyed.
5778  *
5779  * This is the only rxs module call.  A hold could also be written but no one
5780  * needs it. */
5781
5782 int
5783 rxs_Release(struct rx_securityClass *aobj)
5784 {
5785     return RXS_Close(aobj);
5786 }
5787
5788 #ifdef ADAPT_WINDOW
5789 #define RXRATE_PKT_OH   (RX_HEADER_SIZE + RX_IPUDP_SIZE)
5790 #define RXRATE_SMALL_PKT    (RXRATE_PKT_OH + sizeof(struct rx_ackPacket))
5791 #define RXRATE_AVG_SMALL_PKT    (RXRATE_PKT_OH + (sizeof(struct rx_ackPacket)/2))
5792 #define RXRATE_LARGE_PKT    (RXRATE_SMALL_PKT + 256)
5793
5794 /* Adjust our estimate of the transmission rate to this peer, given
5795  * that the packet p was just acked. We can adjust peer->timeout and
5796  * call->twind. Pragmatically, this is called
5797  * only with packets of maximal length.
5798  * Called with peer and call locked.
5799  */
5800
5801 static void
5802 rxi_ComputeRate(register struct rx_peer *peer, register struct rx_call *call,
5803                 struct rx_packet *p, struct rx_packet *ackp, u_char ackReason)
5804 {
5805     afs_int32 xferSize, xferMs;
5806     register afs_int32 minTime;
5807     struct clock newTO;
5808
5809     /* Count down packets */
5810     if (peer->rateFlag > 0)
5811         peer->rateFlag--;
5812     /* Do nothing until we're enabled */
5813     if (peer->rateFlag != 0)
5814         return;
5815     if (!call->conn)
5816         return;
5817
5818     /* Count only when the ack seems legitimate */
5819     switch (ackReason) {
5820     case RX_ACK_REQUESTED:
5821         xferSize =
5822             p->length + RX_HEADER_SIZE + call->conn->securityMaxTrailerSize;
5823         xferMs = peer->rtt;
5824         break;
5825
5826     case RX_ACK_PING_RESPONSE:
5827         if (p)                  /* want the response to ping-request, not data send */
5828             return;
5829         clock_GetTime(&newTO);
5830         if (clock_Gt(&newTO, &call->pingRequestTime)) {
5831             clock_Sub(&newTO, &call->pingRequestTime);
5832             xferMs = (newTO.sec * 1000) + (newTO.usec / 1000);
5833         } else {
5834             return;
5835         }
5836         xferSize = rx_AckDataSize(rx_Window) + RX_HEADER_SIZE;
5837         break;
5838
5839     default:
5840         return;
5841     }
5842
5843     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));
5844
5845     /* Track only packets that are big enough. */
5846     if ((p->length + RX_HEADER_SIZE + call->conn->securityMaxTrailerSize) <
5847         peer->ifMTU)
5848         return;
5849
5850     /* absorb RTT data (in milliseconds) for these big packets */
5851     if (peer->smRtt == 0) {
5852         peer->smRtt = xferMs;
5853     } else {
5854         peer->smRtt = ((peer->smRtt * 15) + xferMs + 4) >> 4;
5855         if (!peer->smRtt)
5856             peer->smRtt = 1;
5857     }
5858
5859     if (peer->countDown) {
5860         peer->countDown--;
5861         return;
5862     }
5863     peer->countDown = 10;       /* recalculate only every so often */
5864
5865     /* In practice, we can measure only the RTT for full packets,
5866      * because of the way Rx acks the data that it receives.  (If it's
5867      * smaller than a full packet, it often gets implicitly acked
5868      * either by the call response (from a server) or by the next call
5869      * (from a client), and either case confuses transmission times
5870      * with processing times.)  Therefore, replace the above
5871      * more-sophisticated processing with a simpler version, where the
5872      * smoothed RTT is kept for full-size packets, and the time to
5873      * transmit a windowful of full-size packets is simply RTT *
5874      * windowSize. Again, we take two steps:
5875      - ensure the timeout is large enough for a single packet's RTT;
5876      - ensure that the window is small enough to fit in the desired timeout.*/
5877
5878     /* First, the timeout check. */
5879     minTime = peer->smRtt;
5880     /* Get a reasonable estimate for a timeout period */
5881     minTime += minTime;
5882     newTO.sec = minTime / 1000;
5883     newTO.usec = (minTime - (newTO.sec * 1000)) * 1000;
5884
5885     /* Increase the timeout period so that we can always do at least
5886      * one packet exchange */
5887     if (clock_Gt(&newTO, &peer->timeout)) {
5888
5889         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));
5890
5891         peer->timeout = newTO;
5892     }
5893
5894     /* Now, get an estimate for the transmit window size. */
5895     minTime = peer->timeout.sec * 1000 + (peer->timeout.usec / 1000);
5896     /* Now, convert to the number of full packets that could fit in a
5897      * reasonable fraction of that interval */
5898     minTime /= (peer->smRtt << 1);
5899     xferSize = minTime;         /* (make a copy) */
5900
5901     /* Now clamp the size to reasonable bounds. */
5902     if (minTime <= 1)
5903         minTime = 1;
5904     else if (minTime > rx_Window)
5905         minTime = rx_Window;
5906 /*    if (minTime != peer->maxWindow) {
5907       dpf(("CONG peer %lx/%u: windowsize %lu ==> %lu (to %lu.%06lu, rtt %u, ps %u)",
5908              ntohl(peer->host), ntohs(peer->port), peer->maxWindow, minTime,
5909              peer->timeout.sec, peer->timeout.usec, peer->smRtt,
5910              peer->packetSize));
5911       peer->maxWindow = minTime;
5912         elide... call->twind = minTime;
5913     }
5914 */
5915
5916     /* Cut back on the peer timeout if it had earlier grown unreasonably.
5917      * Discern this by calculating the timeout necessary for rx_Window
5918      * packets. */
5919     if ((xferSize > rx_Window) && (peer->timeout.sec >= 3)) {
5920         /* calculate estimate for transmission interval in milliseconds */
5921         minTime = rx_Window * peer->smRtt;
5922         if (minTime < 1000) {
5923             dpf(("CONG peer %lx/%u: cut TO %lu.%06lu by 0.5 (rtt %u, ps %u)",
5924                  ntohl(peer->host), ntohs(peer->port), peer->timeout.sec,
5925                  peer->timeout.usec, peer->smRtt, peer->packetSize));
5926
5927             newTO.sec = 0;      /* cut back on timeout by half a second */
5928             newTO.usec = 500000;
5929             clock_Sub(&peer->timeout, &newTO);
5930         }
5931     }
5932
5933     return;
5934 }                               /* end of rxi_ComputeRate */
5935 #endif /* ADAPT_WINDOW */
5936
5937
5938
5939
5940
5941
5942 #ifdef RXDEBUG
5943 /* Don't call this debugging routine directly; use dpf */
5944 void
5945 rxi_DebugPrint(char *format, int a1, int a2, int a3, int a4, int a5, int a6,
5946                int a7, int a8, int a9, int a10, int a11, int a12, int a13,
5947                int a14, int a15)
5948 {
5949     struct clock now;
5950     clock_GetTime(&now);
5951     fprintf(rx_Log, " %u.%.3u:", (unsigned int)now.sec,
5952             (unsigned int)now.usec / 1000);
5953     fprintf(rx_Log, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
5954             a13, a14, a15);
5955     putc('\n', rx_Log);
5956 }
5957 #endif
5958
5959 #ifdef RXDEBUG
5960 /*
5961  * This function is used to process the rx_stats structure that is local
5962  * to a process as well as an rx_stats structure received from a remote
5963  * process (via rxdebug).  Therefore, it needs to do minimal version
5964  * checking.
5965  */
5966 void
5967 rx_PrintTheseStats(FILE * file, struct rx_stats *s, int size,
5968                    afs_int32 freePackets, char version)
5969 {
5970     int i;
5971
5972     if (size != sizeof(struct rx_stats)) {
5973         fprintf(file,
5974                 "Unexpected size of stats structure: was %d, expected %d\n",
5975                 size, sizeof(struct rx_stats));
5976     }
5977
5978     fprintf(file, "rx stats: free packets %d, allocs %d, ", (int)freePackets,
5979             s->packetRequests);
5980
5981     if (version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
5982         fprintf(file, "alloc-failures(rcv %d/%d,send %d/%d,ack %d)\n",
5983                 s->receivePktAllocFailures, s->receiveCbufPktAllocFailures,
5984                 s->sendPktAllocFailures, s->sendCbufPktAllocFailures,
5985                 s->specialPktAllocFailures);
5986     } else {
5987         fprintf(file, "alloc-failures(rcv %d,send %d,ack %d)\n",
5988                 s->receivePktAllocFailures, s->sendPktAllocFailures,
5989                 s->specialPktAllocFailures);
5990     }
5991
5992     fprintf(file,
5993             "   greedy %d, " "bogusReads %d (last from host %x), "
5994             "noPackets %d, " "noBuffers %d, " "selects %d, "
5995             "sendSelects %d\n", s->socketGreedy, s->bogusPacketOnRead,
5996             s->bogusHost, s->noPacketOnRead, s->noPacketBuffersOnRead,
5997             s->selects, s->sendSelects);
5998
5999     fprintf(file, "   packets read: ");
6000     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
6001         fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsRead[i]);
6002     }
6003     fprintf(file, "\n");
6004
6005     fprintf(file,
6006             "   other read counters: data %d, " "ack %d, " "dup %d "
6007             "spurious %d " "dally %d\n", s->dataPacketsRead,
6008             s->ackPacketsRead, s->dupPacketsRead, s->spuriousPacketsRead,
6009             s->ignorePacketDally);
6010
6011     fprintf(file, "   packets sent: ");
6012     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
6013         fprintf(file, "%s %d ", rx_packetTypes[i], s->packetsSent[i]);
6014     }
6015     fprintf(file, "\n");
6016
6017     fprintf(file,
6018             "   other send counters: ack %d, " "data %d (not resends), "
6019             "resends %d, " "pushed %d, " "acked&ignored %d\n",
6020             s->ackPacketsSent, s->dataPacketsSent, s->dataPacketsReSent,
6021             s->dataPacketsPushed, s->ignoreAckedPacket);
6022
6023     fprintf(file,
6024             "   \t(these should be small) sendFailed %d, " "fatalErrors %d\n",
6025             s->netSendFailures, (int)s->fatalErrors);
6026
6027     if (s->nRttSamples) {
6028         fprintf(file, "   Average rtt is %0.3f, with %d samples\n",
6029                 clock_Float(&s->totalRtt) / s->nRttSamples, s->nRttSamples);
6030
6031         fprintf(file, "   Minimum rtt is %0.3f, maximum is %0.3f\n",
6032                 clock_Float(&s->minRtt), clock_Float(&s->maxRtt));
6033     }
6034
6035     fprintf(file,
6036             "   %d server connections, " "%d client connections, "
6037             "%d peer structs, " "%d call structs, " "%d free call structs\n",
6038             s->nServerConns, s->nClientConns, s->nPeerStructs,
6039             s->nCallStructs, s->nFreeCallStructs);
6040
6041 #if     !defined(AFS_PTHREAD_ENV) && !defined(AFS_USE_GETTIMEOFDAY)
6042     fprintf(file, "   %d clock updates\n", clock_nUpdates);
6043 #endif
6044
6045 }
6046
6047 /* for backward compatibility */
6048 void
6049 rx_PrintStats(FILE * file)
6050 {
6051     MUTEX_ENTER(&rx_stats_mutex);
6052     rx_PrintTheseStats(file, &rx_stats, sizeof(rx_stats), rx_nFreePackets,
6053                        RX_DEBUGI_VERSION);
6054     MUTEX_EXIT(&rx_stats_mutex);
6055 }
6056
6057 void
6058 rx_PrintPeerStats(FILE * file, struct rx_peer *peer)
6059 {
6060     fprintf(file, "Peer %x.%d.  " "Burst size %d, " "burst wait %u.%d.\n",
6061             ntohl(peer->host), (int)peer->port, (int)peer->burstSize,
6062             (int)peer->burstWait.sec, (int)peer->burstWait.usec);
6063
6064     fprintf(file,
6065             "   Rtt %d, " "retry time %u.%06d, " "total sent %d, "
6066             "resent %d\n", peer->rtt, (int)peer->timeout.sec,
6067             (int)peer->timeout.usec, peer->nSent, peer->reSends);
6068
6069     fprintf(file,
6070             "   Packet size %d, " "max in packet skew %d, "
6071             "max out packet skew %d\n", peer->ifMTU, (int)peer->inPacketSkew,
6072             (int)peer->outPacketSkew);
6073 }
6074
6075 #ifdef AFS_PTHREAD_ENV
6076 /*
6077  * This mutex protects the following static variables:
6078  * counter
6079  */
6080
6081 #define LOCK_RX_DEBUG assert(pthread_mutex_lock(&rx_debug_mutex)==0);
6082 #define UNLOCK_RX_DEBUG assert(pthread_mutex_unlock(&rx_debug_mutex)==0);
6083 #else
6084 #define LOCK_RX_DEBUG
6085 #define UNLOCK_RX_DEBUG
6086 #endif /* AFS_PTHREAD_ENV */
6087
6088 static int
6089 MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
6090               u_char type, void *inputData, size_t inputLength,
6091               void *outputData, size_t outputLength)
6092 {
6093     static afs_int32 counter = 100;
6094     afs_int32 endTime;
6095     struct rx_header theader;
6096     char tbuffer[1500];
6097     register afs_int32 code;
6098     struct timeval tv;
6099     struct sockaddr_in taddr, faddr;
6100     int faddrLen;
6101     fd_set imask;
6102     register char *tp;
6103
6104     endTime = time(0) + 20;     /* try for 20 seconds */
6105     LOCK_RX_DEBUG counter++;
6106     UNLOCK_RX_DEBUG tp = &tbuffer[sizeof(struct rx_header)];
6107     taddr.sin_family = AF_INET;
6108     taddr.sin_port = remotePort;
6109     taddr.sin_addr.s_addr = remoteAddr;
6110 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
6111     taddr.sin_len = sizeof(struct sockaddr_in);
6112 #endif
6113     while (1) {
6114         memset(&theader, 0, sizeof(theader));
6115         theader.epoch = htonl(999);
6116         theader.cid = 0;
6117         theader.callNumber = htonl(counter);
6118         theader.seq = 0;
6119         theader.serial = 0;
6120         theader.type = type;
6121         theader.flags = RX_CLIENT_INITIATED | RX_LAST_PACKET;
6122         theader.serviceId = 0;
6123
6124         memcpy(tbuffer, &theader, sizeof(theader));
6125         memcpy(tp, inputData, inputLength);
6126         code =
6127             sendto(socket, tbuffer, inputLength + sizeof(struct rx_header), 0,
6128                    (struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
6129
6130         /* see if there's a packet available */
6131         FD_ZERO(&imask);
6132         FD_SET(socket, &imask);
6133         tv.tv_sec = 1;
6134         tv.tv_usec = 0;
6135         code = select(socket + 1, &imask, 0, 0, &tv);
6136         if (code == 1 && FD_ISSET(socket,&imask)) {
6137             /* now receive a packet */
6138             faddrLen = sizeof(struct sockaddr_in);
6139             code =
6140                 recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
6141                          (struct sockaddr *)&faddr, &faddrLen);
6142
6143         if (code > 0) {
6144             memcpy(&theader, tbuffer, sizeof(struct rx_header));
6145             if (counter == ntohl(theader.callNumber))
6146                 break;
6147         }
6148         }
6149
6150         /* see if we've timed out */
6151         if (endTime < time(0))
6152             return -1;
6153     }
6154     code -= sizeof(struct rx_header);
6155     if (code > outputLength)
6156         code = outputLength;
6157     memcpy(outputData, tp, code);
6158     return code;
6159 }
6160
6161 afs_int32
6162 rx_GetServerDebug(osi_socket socket, afs_uint32 remoteAddr,
6163                   afs_uint16 remotePort, struct rx_debugStats * stat,
6164                   afs_uint32 * supportedValues)
6165 {
6166     struct rx_debugIn in;
6167     afs_int32 rc = 0;
6168
6169     *supportedValues = 0;
6170     in.type = htonl(RX_DEBUGI_GETSTATS);
6171     in.index = 0;
6172
6173     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6174                        &in, sizeof(in), stat, sizeof(*stat));
6175
6176     /*
6177      * If the call was successful, fixup the version and indicate
6178      * what contents of the stat structure are valid.
6179      * Also do net to host conversion of fields here.
6180      */
6181
6182     if (rc >= 0) {
6183         if (stat->version >= RX_DEBUGI_VERSION_W_SECSTATS) {
6184             *supportedValues |= RX_SERVER_DEBUG_SEC_STATS;
6185         }
6186         if (stat->version >= RX_DEBUGI_VERSION_W_GETALLCONN) {
6187             *supportedValues |= RX_SERVER_DEBUG_ALL_CONN;
6188         }
6189         if (stat->version >= RX_DEBUGI_VERSION_W_RXSTATS) {
6190             *supportedValues |= RX_SERVER_DEBUG_RX_STATS;
6191         }
6192         if (stat->version >= RX_DEBUGI_VERSION_W_WAITERS) {
6193             *supportedValues |= RX_SERVER_DEBUG_WAITER_CNT;
6194         }
6195         if (stat->version >= RX_DEBUGI_VERSION_W_IDLETHREADS) {
6196             *supportedValues |= RX_SERVER_DEBUG_IDLE_THREADS;
6197         }
6198         if (stat->version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
6199             *supportedValues |= RX_SERVER_DEBUG_NEW_PACKETS;
6200         }
6201         if (stat->version >= RX_DEBUGI_VERSION_W_GETPEER) {
6202             *supportedValues |= RX_SERVER_DEBUG_ALL_PEER;
6203         }
6204
6205         stat->nFreePackets = ntohl(stat->nFreePackets);
6206         stat->packetReclaims = ntohl(stat->packetReclaims);
6207         stat->callsExecuted = ntohl(stat->callsExecuted);
6208         stat->nWaiting = ntohl(stat->nWaiting);
6209         stat->idleThreads = ntohl(stat->idleThreads);
6210     }
6211
6212     return rc;
6213 }
6214
6215 afs_int32
6216 rx_GetServerStats(osi_socket socket, afs_uint32 remoteAddr,
6217                   afs_uint16 remotePort, struct rx_stats * stat,
6218                   afs_uint32 * supportedValues)
6219 {
6220     struct rx_debugIn in;
6221     afs_int32 *lp = (afs_int32 *) stat;
6222     int i;
6223     afs_int32 rc = 0;
6224
6225     /*
6226      * supportedValues is currently unused, but added to allow future
6227      * versioning of this function.
6228      */
6229
6230     *supportedValues = 0;
6231     in.type = htonl(RX_DEBUGI_RXSTATS);
6232     in.index = 0;
6233     memset(stat, 0, sizeof(*stat));
6234
6235     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6236                        &in, sizeof(in), stat, sizeof(*stat));
6237
6238     if (rc >= 0) {
6239
6240         /*
6241          * Do net to host conversion here
6242          */
6243
6244         for (i = 0; i < sizeof(*stat) / sizeof(afs_int32); i++, lp++) {
6245             *lp = ntohl(*lp);
6246         }
6247     }
6248
6249     return rc;
6250 }
6251
6252 afs_int32
6253 rx_GetServerVersion(osi_socket socket, afs_uint32 remoteAddr,
6254                     afs_uint16 remotePort, size_t version_length,
6255                     char *version)
6256 {
6257     char a[1] = { 0 };
6258     return MakeDebugCall(socket, remoteAddr, remotePort,
6259                          RX_PACKET_TYPE_VERSION, a, 1, version,
6260                          version_length);
6261 }
6262
6263 afs_int32
6264 rx_GetServerConnections(osi_socket socket, afs_uint32 remoteAddr,
6265                         afs_uint16 remotePort, afs_int32 * nextConnection,
6266                         int allConnections, afs_uint32 debugSupportedValues,
6267                         struct rx_debugConn * conn,
6268                         afs_uint32 * supportedValues)
6269 {
6270     struct rx_debugIn in;
6271     afs_int32 rc = 0;
6272     int i;
6273
6274     /*
6275      * supportedValues is currently unused, but added to allow future
6276      * versioning of this function.
6277      */
6278
6279     *supportedValues = 0;
6280     if (allConnections) {
6281         in.type = htonl(RX_DEBUGI_GETALLCONN);
6282     } else {
6283         in.type = htonl(RX_DEBUGI_GETCONN);
6284     }
6285     in.index = htonl(*nextConnection);
6286     memset(conn, 0, sizeof(*conn));
6287
6288     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6289                        &in, sizeof(in), conn, sizeof(*conn));
6290
6291     if (rc >= 0) {
6292         *nextConnection += 1;
6293
6294         /*
6295          * Convert old connection format to new structure.
6296          */
6297
6298         if (debugSupportedValues & RX_SERVER_DEBUG_OLD_CONN) {
6299             struct rx_debugConn_vL *vL = (struct rx_debugConn_vL *)conn;
6300 #define MOVEvL(a) (conn->a = vL->a)
6301
6302             /* any old or unrecognized version... */
6303             for (i = 0; i < RX_MAXCALLS; i++) {
6304                 MOVEvL(callState[i]);
6305                 MOVEvL(callMode[i]);
6306                 MOVEvL(callFlags[i]);
6307                 MOVEvL(callOther[i]);
6308             }
6309             if (debugSupportedValues & RX_SERVER_DEBUG_SEC_STATS) {
6310                 MOVEvL(secStats.type);
6311                 MOVEvL(secStats.level);
6312                 MOVEvL(secStats.flags);
6313                 MOVEvL(secStats.expires);
6314                 MOVEvL(secStats.packetsReceived);
6315                 MOVEvL(secStats.packetsSent);
6316                 MOVEvL(secStats.bytesReceived);
6317                 MOVEvL(secStats.bytesSent);
6318             }
6319         }
6320
6321         /*
6322          * Do net to host conversion here
6323          * NOTE:
6324          *    I don't convert host or port since we are most likely
6325          *    going to want these in NBO.
6326          */
6327         conn->cid = ntohl(conn->cid);
6328         conn->serial = ntohl(conn->serial);
6329         for (i = 0; i < RX_MAXCALLS; i++) {
6330             conn->callNumber[i] = ntohl(conn->callNumber[i]);
6331         }
6332         conn->error = ntohl(conn->error);
6333         conn->secStats.flags = ntohl(conn->secStats.flags);
6334         conn->secStats.expires = ntohl(conn->secStats.expires);
6335         conn->secStats.packetsReceived =
6336             ntohl(conn->secStats.packetsReceived);
6337         conn->secStats.packetsSent = ntohl(conn->secStats.packetsSent);
6338         conn->secStats.bytesReceived = ntohl(conn->secStats.bytesReceived);
6339         conn->secStats.bytesSent = ntohl(conn->secStats.bytesSent);
6340         conn->epoch = ntohl(conn->epoch);
6341         conn->natMTU = ntohl(conn->natMTU);
6342     }
6343
6344     return rc;
6345 }
6346
6347 afs_int32
6348 rx_GetServerPeers(osi_socket socket, afs_uint32 remoteAddr,
6349                   afs_uint16 remotePort, afs_int32 * nextPeer,
6350                   afs_uint32 debugSupportedValues, struct rx_debugPeer * peer,
6351                   afs_uint32 * supportedValues)
6352 {
6353     struct rx_debugIn in;
6354     afs_int32 rc = 0;
6355
6356     /*
6357      * supportedValues is currently unused, but added to allow future
6358      * versioning of this function.
6359      */
6360
6361     *supportedValues = 0;
6362     in.type = htonl(RX_DEBUGI_GETPEER);
6363     in.index = htonl(*nextPeer);
6364     memset(peer, 0, sizeof(*peer));
6365
6366     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
6367                        &in, sizeof(in), peer, sizeof(*peer));
6368
6369     if (rc >= 0) {
6370         *nextPeer += 1;
6371
6372         /*
6373          * Do net to host conversion here
6374          * NOTE:
6375          *    I don't convert host or port since we are most likely
6376          *    going to want these in NBO.
6377          */
6378         peer->ifMTU = ntohs(peer->ifMTU);
6379         peer->idleWhen = ntohl(peer->idleWhen);
6380         peer->refCount = ntohs(peer->refCount);
6381         peer->burstWait.sec = ntohl(peer->burstWait.sec);
6382         peer->burstWait.usec = ntohl(peer->burstWait.usec);
6383         peer->rtt = ntohl(peer->rtt);
6384         peer->rtt_dev = ntohl(peer->rtt_dev);
6385         peer->timeout.sec = ntohl(peer->timeout.sec);
6386         peer->timeout.usec = ntohl(peer->timeout.usec);
6387         peer->nSent = ntohl(peer->nSent);
6388         peer->reSends = ntohl(peer->reSends);
6389         peer->inPacketSkew = ntohl(peer->inPacketSkew);
6390         peer->outPacketSkew = ntohl(peer->outPacketSkew);
6391         peer->rateFlag = ntohl(peer->rateFlag);
6392         peer->natMTU = ntohs(peer->natMTU);
6393         peer->maxMTU = ntohs(peer->maxMTU);
6394         peer->maxDgramPackets = ntohs(peer->maxDgramPackets);
6395         peer->ifDgramPackets = ntohs(peer->ifDgramPackets);
6396         peer->MTU = ntohs(peer->MTU);
6397         peer->cwind = ntohs(peer->cwind);
6398         peer->nDgramPackets = ntohs(peer->nDgramPackets);
6399         peer->congestSeq = ntohs(peer->congestSeq);
6400         peer->bytesSent.high = ntohl(peer->bytesSent.high);
6401         peer->bytesSent.low = ntohl(peer->bytesSent.low);
6402         peer->bytesReceived.high = ntohl(peer->bytesReceived.high);
6403         peer->bytesReceived.low = ntohl(peer->bytesReceived.low);
6404     }
6405
6406     return rc;
6407 }
6408 #endif /* RXDEBUG */
6409
6410 void
6411 shutdown_rx(void)
6412 {
6413     struct rx_serverQueueEntry *np;
6414     register int i, j;
6415 #ifndef KERNEL
6416     register struct rx_call *call;
6417     register struct rx_serverQueueEntry *sq;
6418 #endif /* KERNEL */
6419
6420     LOCK_RX_INIT if (rxinit_status == 1) {
6421         UNLOCK_RX_INIT return;  /* Already shutdown. */
6422     }
6423 #ifndef KERNEL
6424     rx_port = 0;
6425 #ifndef AFS_PTHREAD_ENV
6426     FD_ZERO(&rx_selectMask);
6427 #endif /* AFS_PTHREAD_ENV */
6428     rxi_dataQuota = RX_MAX_QUOTA;
6429 #ifndef AFS_PTHREAD_ENV
6430     rxi_StopListener();
6431 #endif /* AFS_PTHREAD_ENV */
6432     shutdown_rxevent();
6433     rx_SetEpoch(0);
6434 #ifndef AFS_PTHREAD_ENV
6435 #ifndef AFS_USE_GETTIMEOFDAY
6436     clock_UnInit();
6437 #endif /* AFS_USE_GETTIMEOFDAY */
6438 #endif /* AFS_PTHREAD_ENV */
6439
6440     while (!queue_IsEmpty(&rx_freeCallQueue)) {
6441         call = queue_First(&rx_freeCallQueue, rx_call);
6442         queue_Remove(call);
6443         rxi_Free(call, sizeof(struct rx_call));
6444     }
6445
6446     while (!queue_IsEmpty(&rx_idleServerQueue)) {
6447         sq = queue_First(&rx_idleServerQueue, rx_serverQueueEntry);
6448         queue_Remove(sq);
6449     }
6450 #endif /* KERNEL */
6451
6452     {
6453         struct rx_peer **peer_ptr, **peer_end;
6454         for (peer_ptr = &rx_peerHashTable[0], peer_end =
6455              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
6456              peer_ptr++) {
6457             struct rx_peer *peer, *next;
6458             for (peer = *peer_ptr; peer; peer = next) {
6459                 rx_interface_stat_p rpc_stat, nrpc_stat;
6460                 size_t space;
6461                 for (queue_Scan
6462                      (&peer->rpcStats, rpc_stat, nrpc_stat,
6463                       rx_interface_stat)) {
6464                     unsigned int num_funcs;
6465                     if (!rpc_stat)
6466                         break;
6467                     queue_Remove(&rpc_stat->queue_header);
6468                     queue_Remove(&rpc_stat->all_peers);
6469                     num_funcs = rpc_stat->stats[0].func_total;
6470                     space =
6471                         sizeof(rx_interface_stat_t) +
6472                         rpc_stat->stats[0].func_total *
6473                         sizeof(rx_function_entry_v1_t);
6474
6475                     rxi_Free(rpc_stat, space);
6476                     MUTEX_ENTER(&rx_rpc_stats);
6477                     rxi_rpc_peer_stat_cnt -= num_funcs;
6478                     MUTEX_EXIT(&rx_rpc_stats);
6479                 }
6480                 next = peer->next;
6481                 rxi_FreePeer(peer);
6482                 MUTEX_ENTER(&rx_stats_mutex);
6483                 rx_stats.nPeerStructs--;
6484                 MUTEX_EXIT(&rx_stats_mutex);
6485             }
6486         }
6487     }
6488     for (i = 0; i < RX_MAX_SERVICES; i++) {
6489         if (rx_services[i])
6490             rxi_Free(rx_services[i], sizeof(*rx_services[i]));
6491     }
6492     for (i = 0; i < rx_hashTableSize; i++) {
6493         register struct rx_connection *tc, *ntc;
6494         MUTEX_ENTER(&rx_connHashTable_lock);
6495         for (tc = rx_connHashTable[i]; tc; tc = ntc) {
6496             ntc = tc->next;
6497             for (j = 0; j < RX_MAXCALLS; j++) {
6498                 if (tc->call[j]) {
6499                     rxi_Free(tc->call[j], sizeof(*tc->call[j]));
6500                 }
6501             }
6502             rxi_Free(tc, sizeof(*tc));
6503         }
6504         MUTEX_EXIT(&rx_connHashTable_lock);
6505     }
6506
6507     MUTEX_ENTER(&freeSQEList_lock);
6508
6509     while ((np = rx_FreeSQEList)) {
6510         rx_FreeSQEList = *(struct rx_serverQueueEntry **)np;
6511         MUTEX_DESTROY(&np->lock);
6512         rxi_Free(np, sizeof(*np));
6513     }
6514
6515     MUTEX_EXIT(&freeSQEList_lock);
6516     MUTEX_DESTROY(&freeSQEList_lock);
6517     MUTEX_DESTROY(&rx_freeCallQueue_lock);
6518     MUTEX_DESTROY(&rx_connHashTable_lock);
6519     MUTEX_DESTROY(&rx_peerHashTable_lock);
6520     MUTEX_DESTROY(&rx_serverPool_lock);
6521
6522     osi_Free(rx_connHashTable,
6523              rx_hashTableSize * sizeof(struct rx_connection *));
6524     osi_Free(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
6525
6526     UNPIN(rx_connHashTable,
6527           rx_hashTableSize * sizeof(struct rx_connection *));
6528     UNPIN(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
6529
6530     rxi_FreeAllPackets();
6531
6532     MUTEX_ENTER(&rx_stats_mutex);
6533     rxi_dataQuota = RX_MAX_QUOTA;
6534     rxi_availProcs = rxi_totalMin = rxi_minDeficit = 0;
6535     MUTEX_EXIT(&rx_stats_mutex);
6536
6537     rxinit_status = 1;
6538 UNLOCK_RX_INIT}
6539
6540 #ifdef RX_ENABLE_LOCKS
6541 void
6542 osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg)
6543 {
6544     if (!MUTEX_ISMINE(lockaddr))
6545         osi_Panic("Lock not held: %s", msg);
6546 }
6547 #endif /* RX_ENABLE_LOCKS */
6548
6549 #ifndef KERNEL
6550
6551 /*
6552  * Routines to implement connection specific data.
6553  */
6554
6555 int
6556 rx_KeyCreate(rx_destructor_t rtn)
6557 {
6558     int key;
6559     MUTEX_ENTER(&rxi_keyCreate_lock);
6560     key = rxi_keyCreate_counter++;
6561     rxi_keyCreate_destructor = (rx_destructor_t *)
6562         realloc((void *)rxi_keyCreate_destructor,
6563                 (key + 1) * sizeof(rx_destructor_t));
6564     rxi_keyCreate_destructor[key] = rtn;
6565     MUTEX_EXIT(&rxi_keyCreate_lock);
6566     return key;
6567 }
6568
6569 void
6570 rx_SetSpecific(struct rx_connection *conn, int key, void *ptr)
6571 {
6572     int i;
6573     MUTEX_ENTER(&conn->conn_data_lock);
6574     if (!conn->specific) {
6575         conn->specific = (void **)malloc((key + 1) * sizeof(void *));
6576         for (i = 0; i < key; i++)
6577             conn->specific[i] = NULL;
6578         conn->nSpecific = key + 1;
6579         conn->specific[key] = ptr;
6580     } else if (key >= conn->nSpecific) {
6581         conn->specific = (void **)
6582             realloc(conn->specific, (key + 1) * sizeof(void *));
6583         for (i = conn->nSpecific; i < key; i++)
6584             conn->specific[i] = NULL;
6585         conn->nSpecific = key + 1;
6586         conn->specific[key] = ptr;
6587     } else {
6588         if (conn->specific[key] && rxi_keyCreate_destructor[key])
6589             (*rxi_keyCreate_destructor[key]) (conn->specific[key]);
6590         conn->specific[key] = ptr;
6591     }
6592     MUTEX_EXIT(&conn->conn_data_lock);
6593 }
6594
6595 void *
6596 rx_GetSpecific(struct rx_connection *conn, int key)
6597 {
6598     void *ptr;
6599     MUTEX_ENTER(&conn->conn_data_lock);
6600     if (key >= conn->nSpecific)
6601         ptr = NULL;
6602     else
6603         ptr = conn->specific[key];
6604     MUTEX_EXIT(&conn->conn_data_lock);
6605     return ptr;
6606 }
6607
6608 #endif /* !KERNEL */
6609
6610 /*
6611  * processStats is a queue used to store the statistics for the local
6612  * process.  Its contents are similar to the contents of the rpcStats
6613  * queue on a rx_peer structure, but the actual data stored within
6614  * this queue contains totals across the lifetime of the process (assuming
6615  * the stats have not been reset) - unlike the per peer structures
6616  * which can come and go based upon the peer lifetime.
6617  */
6618
6619 static struct rx_queue processStats = { &processStats, &processStats };
6620
6621 /*
6622  * peerStats is a queue used to store the statistics for all peer structs.
6623  * Its contents are the union of all the peer rpcStats queues.
6624  */
6625
6626 static struct rx_queue peerStats = { &peerStats, &peerStats };
6627
6628 /*
6629  * rxi_monitor_processStats is used to turn process wide stat collection
6630  * on and off
6631  */
6632
6633 static int rxi_monitor_processStats = 0;
6634
6635 /*
6636  * rxi_monitor_peerStats is used to turn per peer stat collection on and off
6637  */
6638
6639 static int rxi_monitor_peerStats = 0;
6640
6641 /*
6642  * rxi_AddRpcStat - given all of the information for a particular rpc
6643  * call, create (if needed) and update the stat totals for the rpc.
6644  *
6645  * PARAMETERS
6646  *
6647  * IN stats - the queue of stats that will be updated with the new value
6648  *
6649  * IN rxInterface - a unique number that identifies the rpc interface
6650  *
6651  * IN currentFunc - the index of the function being invoked
6652  *
6653  * IN totalFunc - the total number of functions in this interface
6654  *
6655  * IN queueTime - the amount of time this function waited for a thread
6656  *
6657  * IN execTime - the amount of time this function invocation took to execute
6658  *
6659  * IN bytesSent - the number bytes sent by this invocation
6660  *
6661  * IN bytesRcvd - the number bytes received by this invocation
6662  *
6663  * IN isServer - if true, this invocation was made to a server
6664  *
6665  * IN remoteHost - the ip address of the remote host
6666  *
6667  * IN remotePort - the port of the remote host
6668  *
6669  * IN addToPeerList - if != 0, add newly created stat to the global peer list
6670  *
6671  * INOUT counter - if a new stats structure is allocated, the counter will
6672  * be updated with the new number of allocated stat structures
6673  *
6674  * RETURN CODES
6675  *
6676  * Returns void.
6677  */
6678
6679 static int
6680 rxi_AddRpcStat(struct rx_queue *stats, afs_uint32 rxInterface,
6681                afs_uint32 currentFunc, afs_uint32 totalFunc,
6682                struct clock *queueTime, struct clock *execTime,
6683                afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd, int isServer,
6684                afs_uint32 remoteHost, afs_uint32 remotePort,
6685                int addToPeerList, unsigned int *counter)
6686 {
6687     int rc = 0;
6688     rx_interface_stat_p rpc_stat, nrpc_stat;
6689
6690     /*
6691      * See if there's already a structure for this interface
6692      */
6693
6694     for (queue_Scan(stats, rpc_stat, nrpc_stat, rx_interface_stat)) {
6695         if ((rpc_stat->stats[0].interfaceId == rxInterface)
6696             && (rpc_stat->stats[0].remote_is_server == isServer))
6697             break;
6698     }
6699
6700     /*
6701      * Didn't find a match so allocate a new structure and add it to the
6702      * queue.
6703      */
6704
6705     if (queue_IsEnd(stats, rpc_stat) || (rpc_stat == NULL)
6706         || (rpc_stat->stats[0].interfaceId != rxInterface)
6707         || (rpc_stat->stats[0].remote_is_server != isServer)) {
6708         int i;
6709         size_t space;
6710
6711         space =
6712             sizeof(rx_interface_stat_t) +
6713             totalFunc * sizeof(rx_function_entry_v1_t);
6714
6715         rpc_stat = (rx_interface_stat_p) rxi_Alloc(space);
6716         if (rpc_stat == NULL) {
6717             rc = 1;
6718             goto fail;
6719         }
6720         *counter += totalFunc;
6721         for (i = 0; i < totalFunc; i++) {
6722             rpc_stat->stats[i].remote_peer = remoteHost;
6723             rpc_stat->stats[i].remote_port = remotePort;
6724             rpc_stat->stats[i].remote_is_server = isServer;
6725             rpc_stat->stats[i].interfaceId = rxInterface;
6726             rpc_stat->stats[i].func_total = totalFunc;
6727             rpc_stat->stats[i].func_index = i;
6728             hzero(rpc_stat->stats[i].invocations);
6729             hzero(rpc_stat->stats[i].bytes_sent);
6730             hzero(rpc_stat->stats[i].bytes_rcvd);
6731             rpc_stat->stats[i].queue_time_sum.sec = 0;
6732             rpc_stat->stats[i].queue_time_sum.usec = 0;
6733             rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
6734             rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
6735             rpc_stat->stats[i].queue_time_min.sec = 9999999;
6736             rpc_stat->stats[i].queue_time_min.usec = 9999999;
6737             rpc_stat->stats[i].queue_time_max.sec = 0;
6738             rpc_stat->stats[i].queue_time_max.usec = 0;
6739             rpc_stat->stats[i].execution_time_sum.sec = 0;
6740             rpc_stat->stats[i].execution_time_sum.usec = 0;
6741             rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
6742             rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
6743             rpc_stat->stats[i].execution_time_min.sec = 9999999;
6744             rpc_stat->stats[i].execution_time_min.usec = 9999999;
6745             rpc_stat->stats[i].execution_time_max.sec = 0;
6746             rpc_stat->stats[i].execution_time_max.usec = 0;
6747         }
6748         queue_Prepend(stats, rpc_stat);
6749         if (addToPeerList) {
6750             queue_Prepend(&peerStats, &rpc_stat->all_peers);
6751         }
6752     }
6753
6754     /*
6755      * Increment the stats for this function
6756      */
6757
6758     hadd32(rpc_stat->stats[currentFunc].invocations, 1);
6759     hadd(rpc_stat->stats[currentFunc].bytes_sent, *bytesSent);
6760     hadd(rpc_stat->stats[currentFunc].bytes_rcvd, *bytesRcvd);
6761     clock_Add(&rpc_stat->stats[currentFunc].queue_time_sum, queueTime);
6762     clock_AddSq(&rpc_stat->stats[currentFunc].queue_time_sum_sqr, queueTime);
6763     if (clock_Lt(queueTime, &rpc_stat->stats[currentFunc].queue_time_min)) {
6764         rpc_stat->stats[currentFunc].queue_time_min = *queueTime;
6765     }
6766     if (clock_Gt(queueTime, &rpc_stat->stats[currentFunc].queue_time_max)) {
6767         rpc_stat->stats[currentFunc].queue_time_max = *queueTime;
6768     }
6769     clock_Add(&rpc_stat->stats[currentFunc].execution_time_sum, execTime);
6770     clock_AddSq(&rpc_stat->stats[currentFunc].execution_time_sum_sqr,
6771                 execTime);
6772     if (clock_Lt(execTime, &rpc_stat->stats[currentFunc].execution_time_min)) {
6773         rpc_stat->stats[currentFunc].execution_time_min = *execTime;
6774     }
6775     if (clock_Gt(execTime, &rpc_stat->stats[currentFunc].execution_time_max)) {
6776         rpc_stat->stats[currentFunc].execution_time_max = *execTime;
6777     }
6778
6779   fail:
6780     return rc;
6781 }
6782
6783 /*
6784  * rx_IncrementTimeAndCount - increment the times and count for a particular
6785  * rpc function.
6786  *
6787  * PARAMETERS
6788  *
6789  * IN peer - the peer who invoked the rpc
6790  *
6791  * IN rxInterface - a unique number that identifies the rpc interface
6792  *
6793  * IN currentFunc - the index of the function being invoked
6794  *
6795  * IN totalFunc - the total number of functions in this interface
6796  *
6797  * IN queueTime - the amount of time this function waited for a thread
6798  *
6799  * IN execTime - the amount of time this function invocation took to execute
6800  *
6801  * IN bytesSent - the number bytes sent by this invocation
6802  *
6803  * IN bytesRcvd - the number bytes received by this invocation
6804  *
6805  * IN isServer - if true, this invocation was made to a server
6806  *
6807  * RETURN CODES
6808  *
6809  * Returns void.
6810  */
6811
6812 void
6813 rx_IncrementTimeAndCount(struct rx_peer *peer, afs_uint32 rxInterface,
6814                          afs_uint32 currentFunc, afs_uint32 totalFunc,
6815                          struct clock *queueTime, struct clock *execTime,
6816                          afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd,
6817                          int isServer)
6818 {
6819
6820     MUTEX_ENTER(&rx_rpc_stats);
6821     MUTEX_ENTER(&peer->peer_lock);
6822
6823     if (rxi_monitor_peerStats) {
6824         rxi_AddRpcStat(&peer->rpcStats, rxInterface, currentFunc, totalFunc,
6825                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
6826                        peer->host, peer->port, 1, &rxi_rpc_peer_stat_cnt);
6827     }
6828
6829     if (rxi_monitor_processStats) {
6830         rxi_AddRpcStat(&processStats, rxInterface, currentFunc, totalFunc,
6831                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
6832                        0xffffffff, 0xffffffff, 0, &rxi_rpc_process_stat_cnt);
6833     }
6834
6835     MUTEX_EXIT(&peer->peer_lock);
6836     MUTEX_EXIT(&rx_rpc_stats);
6837
6838 }
6839
6840 /*
6841  * rx_MarshallProcessRPCStats - marshall an array of rpc statistics
6842  *
6843  * PARAMETERS
6844  *
6845  * IN callerVersion - the rpc stat version of the caller.
6846  *
6847  * IN count - the number of entries to marshall.
6848  *
6849  * IN stats - pointer to stats to be marshalled.
6850  *
6851  * OUT ptr - Where to store the marshalled data.
6852  *
6853  * RETURN CODES
6854  *
6855  * Returns void.
6856  */
6857 void
6858 rx_MarshallProcessRPCStats(afs_uint32 callerVersion, int count,
6859                            rx_function_entry_v1_t * stats, afs_uint32 ** ptrP)
6860 {
6861     int i;
6862     afs_uint32 *ptr;
6863
6864     /*
6865      * We only support the first version
6866      */
6867     for (ptr = *ptrP, i = 0; i < count; i++, stats++) {
6868         *(ptr++) = stats->remote_peer;
6869         *(ptr++) = stats->remote_port;
6870         *(ptr++) = stats->remote_is_server;
6871         *(ptr++) = stats->interfaceId;
6872         *(ptr++) = stats->func_total;
6873         *(ptr++) = stats->func_index;
6874         *(ptr++) = hgethi(stats->invocations);
6875         *(ptr++) = hgetlo(stats->invocations);
6876         *(ptr++) = hgethi(stats->bytes_sent);
6877         *(ptr++) = hgetlo(stats->bytes_sent);
6878         *(ptr++) = hgethi(stats->bytes_rcvd);
6879         *(ptr++) = hgetlo(stats->bytes_rcvd);
6880         *(ptr++) = stats->queue_time_sum.sec;
6881         *(ptr++) = stats->queue_time_sum.usec;
6882         *(ptr++) = stats->queue_time_sum_sqr.sec;
6883         *(ptr++) = stats->queue_time_sum_sqr.usec;
6884         *(ptr++) = stats->queue_time_min.sec;
6885         *(ptr++) = stats->queue_time_min.usec;
6886         *(ptr++) = stats->queue_time_max.sec;
6887         *(ptr++) = stats->queue_time_max.usec;
6888         *(ptr++) = stats->execution_time_sum.sec;
6889         *(ptr++) = stats->execution_time_sum.usec;
6890         *(ptr++) = stats->execution_time_sum_sqr.sec;
6891         *(ptr++) = stats->execution_time_sum_sqr.usec;
6892         *(ptr++) = stats->execution_time_min.sec;
6893         *(ptr++) = stats->execution_time_min.usec;
6894         *(ptr++) = stats->execution_time_max.sec;
6895         *(ptr++) = stats->execution_time_max.usec;
6896     }
6897     *ptrP = ptr;
6898 }
6899
6900 /*
6901  * rx_RetrieveProcessRPCStats - retrieve all of the rpc statistics for
6902  * this process
6903  *
6904  * PARAMETERS
6905  *
6906  * IN callerVersion - the rpc stat version of the caller
6907  *
6908  * OUT myVersion - the rpc stat version of this function
6909  *
6910  * OUT clock_sec - local time seconds
6911  *
6912  * OUT clock_usec - local time microseconds
6913  *
6914  * OUT allocSize - the number of bytes allocated to contain stats
6915  *
6916  * OUT statCount - the number stats retrieved from this process.
6917  *
6918  * OUT stats - the actual stats retrieved from this process.
6919  *
6920  * RETURN CODES
6921  *
6922  * Returns void.  If successful, stats will != NULL.
6923  */
6924
6925 int
6926 rx_RetrieveProcessRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
6927                            afs_uint32 * clock_sec, afs_uint32 * clock_usec,
6928                            size_t * allocSize, afs_uint32 * statCount,
6929                            afs_uint32 ** stats)
6930 {
6931     size_t space = 0;
6932     afs_uint32 *ptr;
6933     struct clock now;
6934     int rc = 0;
6935
6936     *stats = 0;
6937     *allocSize = 0;
6938     *statCount = 0;
6939     *myVersion = RX_STATS_RETRIEVAL_VERSION;
6940
6941     /*
6942      * Check to see if stats are enabled
6943      */
6944
6945     MUTEX_ENTER(&rx_rpc_stats);
6946     if (!rxi_monitor_processStats) {
6947         MUTEX_EXIT(&rx_rpc_stats);
6948         return rc;
6949     }
6950
6951     clock_GetTime(&now);
6952     *clock_sec = now.sec;
6953     *clock_usec = now.usec;
6954
6955     /*
6956      * Allocate the space based upon the caller version
6957      *
6958      * If the client is at an older version than we are,
6959      * we return the statistic data in the older data format, but
6960      * we still return our version number so the client knows we
6961      * are maintaining more data than it can retrieve.
6962      */
6963
6964     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
6965         space = rxi_rpc_process_stat_cnt * sizeof(rx_function_entry_v1_t);
6966         *statCount = rxi_rpc_process_stat_cnt;
6967     } else {
6968         /*
6969          * This can't happen yet, but in the future version changes
6970          * can be handled by adding additional code here
6971          */
6972     }
6973
6974     if (space > (size_t) 0) {
6975         *allocSize = space;
6976         ptr = *stats = (afs_uint32 *) rxi_Alloc(space);
6977
6978         if (ptr != NULL) {
6979             rx_interface_stat_p rpc_stat, nrpc_stat;
6980
6981
6982             for (queue_Scan
6983                  (&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
6984                 /*
6985                  * Copy the data based upon the caller version
6986                  */
6987                 rx_MarshallProcessRPCStats(callerVersion,
6988                                            rpc_stat->stats[0].func_total,
6989                                            rpc_stat->stats, &ptr);
6990             }
6991         } else {
6992             rc = ENOMEM;
6993         }
6994     }
6995     MUTEX_EXIT(&rx_rpc_stats);
6996     return rc;
6997 }
6998
6999 /*
7000  * rx_RetrievePeerRPCStats - retrieve all of the rpc statistics for the peers
7001  *
7002  * PARAMETERS
7003  *
7004  * IN callerVersion - the rpc stat version of the caller
7005  *
7006  * OUT myVersion - the rpc stat version of this function
7007  *
7008  * OUT clock_sec - local time seconds
7009  *
7010  * OUT clock_usec - local time microseconds
7011  *
7012  * OUT allocSize - the number of bytes allocated to contain stats
7013  *
7014  * OUT statCount - the number of stats retrieved from the individual
7015  * peer structures.
7016  *
7017  * OUT stats - the actual stats retrieved from the individual peer structures.
7018  *
7019  * RETURN CODES
7020  *
7021  * Returns void.  If successful, stats will != NULL.
7022  */
7023
7024 int
7025 rx_RetrievePeerRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
7026                         afs_uint32 * clock_sec, afs_uint32 * clock_usec,
7027                         size_t * allocSize, afs_uint32 * statCount,
7028                         afs_uint32 ** stats)
7029 {
7030     size_t space = 0;
7031     afs_uint32 *ptr;
7032     struct clock now;
7033     int rc = 0;
7034
7035     *stats = 0;
7036     *statCount = 0;
7037     *allocSize = 0;
7038     *myVersion = RX_STATS_RETRIEVAL_VERSION;
7039
7040     /*
7041      * Check to see if stats are enabled
7042      */
7043
7044     MUTEX_ENTER(&rx_rpc_stats);
7045     if (!rxi_monitor_peerStats) {
7046         MUTEX_EXIT(&rx_rpc_stats);
7047         return rc;
7048     }
7049
7050     clock_GetTime(&now);
7051     *clock_sec = now.sec;
7052     *clock_usec = now.usec;
7053
7054     /*
7055      * Allocate the space based upon the caller version
7056      *
7057      * If the client is at an older version than we are,
7058      * we return the statistic data in the older data format, but
7059      * we still return our version number so the client knows we
7060      * are maintaining more data than it can retrieve.
7061      */
7062
7063     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
7064         space = rxi_rpc_peer_stat_cnt * sizeof(rx_function_entry_v1_t);
7065         *statCount = rxi_rpc_peer_stat_cnt;
7066     } else {
7067         /*
7068          * This can't happen yet, but in the future version changes
7069          * can be handled by adding additional code here
7070          */
7071     }
7072
7073     if (space > (size_t) 0) {
7074         *allocSize = space;
7075         ptr = *stats = (afs_uint32 *) rxi_Alloc(space);
7076
7077         if (ptr != NULL) {
7078             rx_interface_stat_p rpc_stat, nrpc_stat;
7079             char *fix_offset;
7080
7081             for (queue_Scan
7082                  (&peerStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7083                 /*
7084                  * We have to fix the offset of rpc_stat since we are
7085                  * keeping this structure on two rx_queues.  The rx_queue
7086                  * package assumes that the rx_queue member is the first
7087                  * member of the structure.  That is, rx_queue assumes that
7088                  * any one item is only on one queue at a time.  We are
7089                  * breaking that assumption and so we have to do a little
7090                  * math to fix our pointers.
7091                  */
7092
7093                 fix_offset = (char *)rpc_stat;
7094                 fix_offset -= offsetof(rx_interface_stat_t, all_peers);
7095                 rpc_stat = (rx_interface_stat_p) fix_offset;
7096
7097                 /*
7098                  * Copy the data based upon the caller version
7099                  */
7100                 rx_MarshallProcessRPCStats(callerVersion,
7101                                            rpc_stat->stats[0].func_total,
7102                                            rpc_stat->stats, &ptr);
7103             }
7104         } else {
7105             rc = ENOMEM;
7106         }
7107     }
7108     MUTEX_EXIT(&rx_rpc_stats);
7109     return rc;
7110 }
7111
7112 /*
7113  * rx_FreeRPCStats - free memory allocated by
7114  *                   rx_RetrieveProcessRPCStats and rx_RetrievePeerRPCStats
7115  *
7116  * PARAMETERS
7117  *
7118  * IN stats - stats previously returned by rx_RetrieveProcessRPCStats or
7119  * rx_RetrievePeerRPCStats
7120  *
7121  * IN allocSize - the number of bytes in stats.
7122  *
7123  * RETURN CODES
7124  *
7125  * Returns void.
7126  */
7127
7128 void
7129 rx_FreeRPCStats(afs_uint32 * stats, size_t allocSize)
7130 {
7131     rxi_Free(stats, allocSize);
7132 }
7133
7134 /*
7135  * rx_queryProcessRPCStats - see if process rpc stat collection is
7136  * currently enabled.
7137  *
7138  * PARAMETERS
7139  *
7140  * RETURN CODES
7141  *
7142  * Returns 0 if stats are not enabled != 0 otherwise
7143  */
7144
7145 int
7146 rx_queryProcessRPCStats(void)
7147 {
7148     int rc;
7149     MUTEX_ENTER(&rx_rpc_stats);
7150     rc = rxi_monitor_processStats;
7151     MUTEX_EXIT(&rx_rpc_stats);
7152     return rc;
7153 }
7154
7155 /*
7156  * rx_queryPeerRPCStats - see if peer stat collection is currently enabled.
7157  *
7158  * PARAMETERS
7159  *
7160  * RETURN CODES
7161  *
7162  * Returns 0 if stats are not enabled != 0 otherwise
7163  */
7164
7165 int
7166 rx_queryPeerRPCStats(void)
7167 {
7168     int rc;
7169     MUTEX_ENTER(&rx_rpc_stats);
7170     rc = rxi_monitor_peerStats;
7171     MUTEX_EXIT(&rx_rpc_stats);
7172     return rc;
7173 }
7174
7175 /*
7176  * rx_enableProcessRPCStats - begin rpc stat collection for entire process
7177  *
7178  * PARAMETERS
7179  *
7180  * RETURN CODES
7181  *
7182  * Returns void.
7183  */
7184
7185 void
7186 rx_enableProcessRPCStats(void)
7187 {
7188     MUTEX_ENTER(&rx_rpc_stats);
7189     rx_enable_stats = 1;
7190     rxi_monitor_processStats = 1;
7191     MUTEX_EXIT(&rx_rpc_stats);
7192 }
7193
7194 /*
7195  * rx_enablePeerRPCStats - begin rpc stat collection per peer structure
7196  *
7197  * PARAMETERS
7198  *
7199  * RETURN CODES
7200  *
7201  * Returns void.
7202  */
7203
7204 void
7205 rx_enablePeerRPCStats(void)
7206 {
7207     MUTEX_ENTER(&rx_rpc_stats);
7208     rx_enable_stats = 1;
7209     rxi_monitor_peerStats = 1;
7210     MUTEX_EXIT(&rx_rpc_stats);
7211 }
7212
7213 /*
7214  * rx_disableProcessRPCStats - stop rpc stat collection for entire process
7215  *
7216  * PARAMETERS
7217  *
7218  * RETURN CODES
7219  *
7220  * Returns void.
7221  */
7222
7223 void
7224 rx_disableProcessRPCStats(void)
7225 {
7226     rx_interface_stat_p rpc_stat, nrpc_stat;
7227     size_t space;
7228
7229     MUTEX_ENTER(&rx_rpc_stats);
7230
7231     /*
7232      * Turn off process statistics and if peer stats is also off, turn
7233      * off everything
7234      */
7235
7236     rxi_monitor_processStats = 0;
7237     if (rxi_monitor_peerStats == 0) {
7238         rx_enable_stats = 0;
7239     }
7240
7241     for (queue_Scan(&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7242         unsigned int num_funcs = 0;
7243         if (!rpc_stat)
7244             break;
7245         queue_Remove(rpc_stat);
7246         num_funcs = rpc_stat->stats[0].func_total;
7247         space =
7248             sizeof(rx_interface_stat_t) +
7249             rpc_stat->stats[0].func_total * sizeof(rx_function_entry_v1_t);
7250
7251         rxi_Free(rpc_stat, space);
7252         rxi_rpc_process_stat_cnt -= num_funcs;
7253     }
7254     MUTEX_EXIT(&rx_rpc_stats);
7255 }
7256
7257 /*
7258  * rx_disablePeerRPCStats - stop rpc stat collection for peers
7259  *
7260  * PARAMETERS
7261  *
7262  * RETURN CODES
7263  *
7264  * Returns void.
7265  */
7266
7267 void
7268 rx_disablePeerRPCStats(void)
7269 {
7270     struct rx_peer **peer_ptr, **peer_end;
7271     int code;
7272
7273     MUTEX_ENTER(&rx_rpc_stats);
7274
7275     /*
7276      * Turn off peer statistics and if process stats is also off, turn
7277      * off everything
7278      */
7279
7280     rxi_monitor_peerStats = 0;
7281     if (rxi_monitor_processStats == 0) {
7282         rx_enable_stats = 0;
7283     }
7284
7285     MUTEX_ENTER(&rx_peerHashTable_lock);
7286     for (peer_ptr = &rx_peerHashTable[0], peer_end =
7287          &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
7288          peer_ptr++) {
7289         struct rx_peer *peer, *next, *prev;
7290         for (prev = peer = *peer_ptr; peer; peer = next) {
7291             next = peer->next;
7292             code = MUTEX_TRYENTER(&peer->peer_lock);
7293             if (code) {
7294                 rx_interface_stat_p rpc_stat, nrpc_stat;
7295                 size_t space;
7296                 for (queue_Scan
7297                      (&peer->rpcStats, rpc_stat, nrpc_stat,
7298                       rx_interface_stat)) {
7299                     unsigned int num_funcs = 0;
7300                     if (!rpc_stat)
7301                         break;
7302                     queue_Remove(&rpc_stat->queue_header);
7303                     queue_Remove(&rpc_stat->all_peers);
7304                     num_funcs = rpc_stat->stats[0].func_total;
7305                     space =
7306                         sizeof(rx_interface_stat_t) +
7307                         rpc_stat->stats[0].func_total *
7308                         sizeof(rx_function_entry_v1_t);
7309
7310                     rxi_Free(rpc_stat, space);
7311                     rxi_rpc_peer_stat_cnt -= num_funcs;
7312                 }
7313                 MUTEX_EXIT(&peer->peer_lock);
7314                 if (prev == *peer_ptr) {
7315                     *peer_ptr = next;
7316                     prev = next;
7317                 } else
7318                     prev->next = next;
7319             } else {
7320                 prev = peer;
7321             }
7322         }
7323     }
7324     MUTEX_EXIT(&rx_peerHashTable_lock);
7325     MUTEX_EXIT(&rx_rpc_stats);
7326 }
7327
7328 /*
7329  * rx_clearProcessRPCStats - clear the contents of the rpc stats according
7330  * to clearFlag
7331  *
7332  * PARAMETERS
7333  *
7334  * IN clearFlag - flag indicating which stats to clear
7335  *
7336  * RETURN CODES
7337  *
7338  * Returns void.
7339  */
7340
7341 void
7342 rx_clearProcessRPCStats(afs_uint32 clearFlag)
7343 {
7344     rx_interface_stat_p rpc_stat, nrpc_stat;
7345
7346     MUTEX_ENTER(&rx_rpc_stats);
7347
7348     for (queue_Scan(&processStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7349         unsigned int num_funcs = 0, i;
7350         num_funcs = rpc_stat->stats[0].func_total;
7351         for (i = 0; i < num_funcs; i++) {
7352             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
7353                 hzero(rpc_stat->stats[i].invocations);
7354             }
7355             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
7356                 hzero(rpc_stat->stats[i].bytes_sent);
7357             }
7358             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
7359                 hzero(rpc_stat->stats[i].bytes_rcvd);
7360             }
7361             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
7362                 rpc_stat->stats[i].queue_time_sum.sec = 0;
7363                 rpc_stat->stats[i].queue_time_sum.usec = 0;
7364             }
7365             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
7366                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7367                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7368             }
7369             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
7370                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
7371                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
7372             }
7373             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
7374                 rpc_stat->stats[i].queue_time_max.sec = 0;
7375                 rpc_stat->stats[i].queue_time_max.usec = 0;
7376             }
7377             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
7378                 rpc_stat->stats[i].execution_time_sum.sec = 0;
7379                 rpc_stat->stats[i].execution_time_sum.usec = 0;
7380             }
7381             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
7382                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7383                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7384             }
7385             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
7386                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
7387                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
7388             }
7389             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
7390                 rpc_stat->stats[i].execution_time_max.sec = 0;
7391                 rpc_stat->stats[i].execution_time_max.usec = 0;
7392             }
7393         }
7394     }
7395
7396     MUTEX_EXIT(&rx_rpc_stats);
7397 }
7398
7399 /*
7400  * rx_clearPeerRPCStats - clear the contents of the rpc stats according
7401  * to clearFlag
7402  *
7403  * PARAMETERS
7404  *
7405  * IN clearFlag - flag indicating which stats to clear
7406  *
7407  * RETURN CODES
7408  *
7409  * Returns void.
7410  */
7411
7412 void
7413 rx_clearPeerRPCStats(afs_uint32 clearFlag)
7414 {
7415     rx_interface_stat_p rpc_stat, nrpc_stat;
7416
7417     MUTEX_ENTER(&rx_rpc_stats);
7418
7419     for (queue_Scan(&peerStats, rpc_stat, nrpc_stat, rx_interface_stat)) {
7420         unsigned int num_funcs = 0, i;
7421         char *fix_offset;
7422         /*
7423          * We have to fix the offset of rpc_stat since we are
7424          * keeping this structure on two rx_queues.  The rx_queue
7425          * package assumes that the rx_queue member is the first
7426          * member of the structure.  That is, rx_queue assumes that
7427          * any one item is only on one queue at a time.  We are
7428          * breaking that assumption and so we have to do a little
7429          * math to fix our pointers.
7430          */
7431
7432         fix_offset = (char *)rpc_stat;
7433         fix_offset -= offsetof(rx_interface_stat_t, all_peers);
7434         rpc_stat = (rx_interface_stat_p) fix_offset;
7435
7436         num_funcs = rpc_stat->stats[0].func_total;
7437         for (i = 0; i < num_funcs; i++) {
7438             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
7439                 hzero(rpc_stat->stats[i].invocations);
7440             }
7441             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
7442                 hzero(rpc_stat->stats[i].bytes_sent);
7443             }
7444             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
7445                 hzero(rpc_stat->stats[i].bytes_rcvd);
7446             }
7447             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
7448                 rpc_stat->stats[i].queue_time_sum.sec = 0;
7449                 rpc_stat->stats[i].queue_time_sum.usec = 0;
7450             }
7451             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
7452                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
7453                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
7454             }
7455             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
7456                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
7457                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
7458             }
7459             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
7460                 rpc_stat->stats[i].queue_time_max.sec = 0;
7461                 rpc_stat->stats[i].queue_time_max.usec = 0;
7462             }
7463             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
7464                 rpc_stat->stats[i].execution_time_sum.sec = 0;
7465                 rpc_stat->stats[i].execution_time_sum.usec = 0;
7466             }
7467             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
7468                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
7469                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
7470             }
7471             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
7472                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
7473                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
7474             }
7475             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
7476                 rpc_stat->stats[i].execution_time_max.sec = 0;
7477                 rpc_stat->stats[i].execution_time_max.usec = 0;
7478             }
7479         }
7480     }
7481
7482     MUTEX_EXIT(&rx_rpc_stats);
7483 }
7484
7485 /*
7486  * rxi_rxstat_userok points to a routine that returns 1 if the caller
7487  * is authorized to enable/disable/clear RX statistics.
7488  */
7489 static int (*rxi_rxstat_userok) (struct rx_call * call) = NULL;
7490
7491 void
7492 rx_SetRxStatUserOk(int (*proc) (struct rx_call * call))
7493 {
7494     rxi_rxstat_userok = proc;
7495 }
7496
7497 int
7498 rx_RxStatUserOk(struct rx_call *call)
7499 {
7500     if (!rxi_rxstat_userok)
7501         return 0;
7502     return rxi_rxstat_userok(call);
7503 }