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 #include <afs/param.h>
  14
  15 #ifdef KERNEL
  16 # include "afs/sysincludes.h"
  17 # include "afsincludes.h"
  18 # ifndef UKERNEL
  19 #  include "h/types.h"
  20 #  include "h/time.h"
  21 #  include "h/stat.h"
  22 #  ifdef AFS_LINUX20_ENV
  23 #   include "h/socket.h"
  24 #  endif
  25 #  include "netinet/in.h"
  26 #  ifdef AFS_SUN5_ENV
  27 #   include "netinet/ip6.h"
  28 #   include "inet/common.h"
  29 #   include "inet/ip.h"
  30 #   include "inet/ip_ire.h"
  31 #  endif
  32 #  include "afs/afs_args.h"
  33 #  include "afs/afs_osi.h"
  34 #  ifdef RX_KERNEL_TRACE
  35 #   include "rx_kcommon.h"
  36 #  endif
  37 #  if   defined(AFS_AIX_ENV)
  38 #   include "h/systm.h"
  39 #  endif
  40 #  ifdef RXDEBUG
  41 #   undef RXDEBUG                       /* turn off debugging */
  42 #  endif /* RXDEBUG */
  43 #  if defined(AFS_SGI_ENV)
  44 #   include "sys/debug.h"
  45 #  endif
  46 # else /* !UKERNEL */
  47 #  include "afs/sysincludes.h"
  48 #  include "afsincludes.h"
  49 # endif /* !UKERNEL */
  50 # include "afs/lock.h"
  51 # include "rx_kmutex.h"
  52 # include "rx_kernel.h"
  53 # define        AFSOP_STOP_RXCALLBACK   210     /* Stop CALLBACK process */
  54 # define        AFSOP_STOP_AFS          211     /* Stop AFS process */
  55 # define        AFSOP_STOP_BKG          212     /* Stop BKG process */
  56 extern afs_int32 afs_termState;
  57 # ifdef AFS_AIX41_ENV
  58 #  include "sys/lockl.h"
  59 #  include "sys/lock_def.h"
  60 # endif /* AFS_AIX41_ENV */
  61 # include "afs/rxgen_consts.h"
  62 #else /* KERNEL */
  63 # include <roken.h>
  64
  65 # ifdef AFS_NT40_ENV
  66 #  include <afs/afsutil.h>
  67 #  include <WINNT\afsreg.h>
  68 # endif
  69
  70 # include <afs/opr.h>
  71
  72 # include "rx_user.h"
  73 #endif /* KERNEL */
  74
  75 #include <opr/queue.h>
  76
  77 #include "rx.h"
  78 #include "rx_clock.h"
  79 #include "rx_atomic.h"
  80 #include "rx_globals.h"
  81 #include "rx_trace.h"
  82 #include "rx_internal.h"
  83 #include "rx_stats.h"
  84 #include "rx_event.h"
  85
  86 #include "rx_peer.h"
  87 #include "rx_conn.h"
  88 #include "rx_call.h"
  89 #include "rx_packet.h"
  90 #include "rx_server.h"
  91
  92 #include <afs/rxgen_consts.h>
  93
  94 #ifndef KERNEL
  95 #ifdef AFS_PTHREAD_ENV
  96 #ifndef AFS_NT40_ENV
  97 int (*registerProgram) (pid_t, char *) = 0;
  98 int (*swapNameProgram) (pid_t, const char *, char *) = 0;
  99 #endif
 100 #else
 101 int (*registerProgram) (PROCESS, char *) = 0;
 102 int (*swapNameProgram) (PROCESS, const char *, char *) = 0;
 103 #endif
 104 #endif
 105
 106 /* Local static routines */
 107 static void rxi_DestroyConnectionNoLock(struct rx_connection *conn);
 108 static void rxi_ComputeRoundTripTime(struct rx_packet *, struct rx_ackPacket *,
 109                                      struct rx_call *, struct rx_peer *,
 110                                      struct clock *);
 111 static void rxi_Resend(struct rxevent *event, void *arg0, void *arg1,
 112                        int istack);
 113 static void rxi_SendDelayedAck(struct rxevent *event, void *call,
 114                                void *dummy, int dummy2);
 115 static void rxi_SendDelayedCallAbort(struct rxevent *event, void *arg1,
 116                                      void *dummy, int dummy2);
 117 static void rxi_SendDelayedConnAbort(struct rxevent *event, void *arg1,
 118                                      void *unused, int unused2);
 119 static void rxi_ReapConnections(struct rxevent *unused, void *unused1,
 120                                 void *unused2, int unused3);
 121 static struct rx_packet *rxi_SendCallAbort(struct rx_call *call,
 122                                            struct rx_packet *packet,
 123                                            int istack, int force);
 124 static void rxi_AckAll(struct rx_call *call);
 125 static struct rx_connection
 126         *rxi_FindConnection(osi_socket socket, afs_uint32 host, u_short port,
 127                             u_short serviceId, afs_uint32 cid,
 128                             afs_uint32 epoch, int type, u_int securityIndex);
 129 static struct rx_packet
 130         *rxi_ReceiveDataPacket(struct rx_call *call, struct rx_packet *np,
 131                                int istack, osi_socket socket,
 132                                afs_uint32 host, u_short port, int *tnop,
 133                                struct rx_call **newcallp);
 134 static struct rx_packet
 135         *rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
 136                               int istack);
 137 static struct rx_packet
 138         *rxi_ReceiveResponsePacket(struct rx_connection *conn,
 139                                    struct rx_packet *np, int istack);
 140 static struct rx_packet
 141         *rxi_ReceiveChallengePacket(struct rx_connection *conn,
 142                                     struct rx_packet *np, int istack);
 143 static void rxi_AttachServerProc(struct rx_call *call, osi_socket socket,
 144                                  int *tnop, struct rx_call **newcallp);
 145 static void rxi_ClearTransmitQueue(struct rx_call *call, int force);
 146 static void rxi_ClearReceiveQueue(struct rx_call *call);
 147 static void rxi_ResetCall(struct rx_call *call, int newcall);
 148 static void rxi_ScheduleKeepAliveEvent(struct rx_call *call);
 149 static void rxi_ScheduleNatKeepAliveEvent(struct rx_connection *conn);
 150 static void rxi_ScheduleGrowMTUEvent(struct rx_call *call, int secs);
 151 static void rxi_KeepAliveOn(struct rx_call *call);
 152 static void rxi_GrowMTUOn(struct rx_call *call);
 153 static void rxi_ChallengeOn(struct rx_connection *conn);
 154
 155 #ifdef RX_ENABLE_LOCKS
 156 static int rxi_CheckCall(struct rx_call *call, int haveCTLock);
 157 static void rxi_SetAcksInTransmitQueue(struct rx_call *call);
 158 #else
 159 static int rxi_CheckCall(struct rx_call *call);
 160 #endif
 161
 162 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
 163 struct rx_tq_debug {
 164     rx_atomic_t rxi_start_aborted; /* rxi_start awoke after rxi_Send in error.*/
 165     rx_atomic_t rxi_start_in_error;
 166 } rx_tq_debug;
 167 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
 168
 169 /* Constant delay time before sending an acknowledge of the last packet
 170  * received.  This is to avoid sending an extra acknowledge when the
 171  * client is about to make another call, anyway, or the server is
 172  * about to respond.
 173  *
 174  * The lastAckDelay may not exceeed 400ms without causing peers to
 175  * unecessarily timeout.
 176  */
 177 struct clock rx_lastAckDelay = {0, 400000};
 178
 179 /* Constant delay time before sending a soft ack when none was requested.
 180  * This is to make sure we send soft acks before the sender times out,
 181  * Normally we wait and send a hard ack when the receiver consumes the packet
 182  *
 183  * This value has been 100ms in all shipping versions of OpenAFS. Changing it
 184  * will require changes to the peer's RTT calculations.
 185  */
 186 struct clock rx_softAckDelay = {0, 100000};
 187
 188 /*
 189  * rxi_rpc_peer_stat_cnt counts the total number of peer stat structures
 190  * currently allocated within rx.  This number is used to allocate the
 191  * memory required to return the statistics when queried.
 192  * Protected by the rx_rpc_stats mutex.
 193  */
 194
 195 static unsigned int rxi_rpc_peer_stat_cnt;
 196
 197 /*
 198  * rxi_rpc_process_stat_cnt counts the total number of local process stat
 199  * structures currently allocated within rx.  The number is used to allocate
 200  * the memory required to return the statistics when queried.
 201  * Protected by the rx_rpc_stats mutex.
 202  */
 203
 204 static unsigned int rxi_rpc_process_stat_cnt;
 205
 206 /*
 207  * rxi_busyChannelError is a boolean.  It indicates whether or not RX_CALL_BUSY
 208  * errors should be reported to the application when a call channel appears busy
 209  * (inferred from the receipt of RX_PACKET_TYPE_BUSY packets on the channel),
 210  * and there are other call channels in the connection that are not busy.
 211  * If 0, we do not return errors upon receiving busy packets; we just keep
 212  * trying on the same call channel until we hit a timeout.
 213  */
 214 static afs_int32 rxi_busyChannelError = 0;
 215
 216 rx_atomic_t rx_nWaiting = RX_ATOMIC_INIT(0);
 217 rx_atomic_t rx_nWaited = RX_ATOMIC_INIT(0);
 218
 219 /* Incoming calls wait on this queue when there are no available
 220  * server processes */
 221 struct opr_queue rx_incomingCallQueue;
 222
 223 /* Server processes wait on this queue when there are no appropriate
 224  * calls to process */
 225 struct opr_queue rx_idleServerQueue;
 226
 227 #if !defined(offsetof)
 228 #include <stddef.h>             /* for definition of offsetof() */
 229 #endif
 230
 231 #ifdef RX_ENABLE_LOCKS
 232 afs_kmutex_t rx_atomic_mutex;
 233 #endif
 234
 235 /* Forward prototypes */
 236 static struct rx_call * rxi_NewCall(struct rx_connection *, int);
 237
 238 static_inline void
 239 putConnection (struct rx_connection *conn) {
 240     MUTEX_ENTER(&rx_refcnt_mutex);
 241     conn->refCount--;
 242     MUTEX_EXIT(&rx_refcnt_mutex);
 243 }
 244
 245 #ifdef AFS_PTHREAD_ENV
 246
 247 /*
 248  * Use procedural initialization of mutexes/condition variables
 249  * to ease NT porting
 250  */
 251
 252 extern afs_kmutex_t rx_quota_mutex;
 253 extern afs_kmutex_t rx_pthread_mutex;
 254 extern afs_kmutex_t rx_packets_mutex;
 255 extern afs_kmutex_t rx_refcnt_mutex;
 256 extern afs_kmutex_t des_init_mutex;
 257 extern afs_kmutex_t des_random_mutex;
 258 extern afs_kmutex_t rx_clock_mutex;
 259 extern afs_kmutex_t rxi_connCacheMutex;
 260 extern afs_kmutex_t event_handler_mutex;
 261 extern afs_kmutex_t listener_mutex;
 262 extern afs_kmutex_t rx_if_init_mutex;
 263 extern afs_kmutex_t rx_if_mutex;
 264
 265 extern afs_kcondvar_t rx_event_handler_cond;
 266 extern afs_kcondvar_t rx_listener_cond;
 267
 268 static afs_kmutex_t epoch_mutex;
 269 static afs_kmutex_t rx_init_mutex;
 270 static afs_kmutex_t rx_debug_mutex;
 271 static afs_kmutex_t rx_rpc_stats;
 272
 273 static void
 274 rxi_InitPthread(void)
 275 {
 276     MUTEX_INIT(&rx_clock_mutex, "clock", MUTEX_DEFAULT, 0);
 277     MUTEX_INIT(&rx_stats_mutex, "stats", MUTEX_DEFAULT, 0);
 278     MUTEX_INIT(&rx_atomic_mutex, "atomic", MUTEX_DEFAULT, 0);
 279     MUTEX_INIT(&rx_quota_mutex, "quota", MUTEX_DEFAULT, 0);
 280     MUTEX_INIT(&rx_pthread_mutex, "pthread", MUTEX_DEFAULT, 0);
 281     MUTEX_INIT(&rx_packets_mutex, "packets", MUTEX_DEFAULT, 0);
 282     MUTEX_INIT(&rx_refcnt_mutex, "refcnts", MUTEX_DEFAULT, 0);
 283     MUTEX_INIT(&epoch_mutex, "epoch", MUTEX_DEFAULT, 0);
 284     MUTEX_INIT(&rx_init_mutex, "init", MUTEX_DEFAULT, 0);
 285     MUTEX_INIT(&event_handler_mutex, "event handler", MUTEX_DEFAULT, 0);
 286     MUTEX_INIT(&rxi_connCacheMutex, "conn cache", MUTEX_DEFAULT, 0);
 287     MUTEX_INIT(&listener_mutex, "listener", MUTEX_DEFAULT, 0);
 288     MUTEX_INIT(&rx_if_init_mutex, "if init", MUTEX_DEFAULT, 0);
 289     MUTEX_INIT(&rx_if_mutex, "if", MUTEX_DEFAULT, 0);
 290     MUTEX_INIT(&rx_debug_mutex, "debug", MUTEX_DEFAULT, 0);
 291
 292     CV_INIT(&rx_event_handler_cond, "evhand", CV_DEFAULT, 0);
 293     CV_INIT(&rx_listener_cond, "rxlisten", CV_DEFAULT, 0);
 294
 295     osi_Assert(pthread_key_create(&rx_thread_id_key, NULL) == 0);
 296     osi_Assert(pthread_key_create(&rx_ts_info_key, NULL) == 0);
 297
 298     MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
 299     MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
 300 #ifdef  RX_ENABLE_LOCKS
 301 #ifdef RX_LOCKS_DB
 302     rxdb_init();
 303 #endif /* RX_LOCKS_DB */
 304     MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
 305     MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock", MUTEX_DEFAULT,
 306                0);
 307     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
 308             0);
 309     MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
 310                0);
 311     MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
 312                0);
 313     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
 314     MUTEX_INIT(&rxi_keyCreate_lock, "rxi_keyCreate_lock", MUTEX_DEFAULT, 0);
 315 #endif /* RX_ENABLE_LOCKS */
 316 }
 317
 318 pthread_once_t rx_once_init = PTHREAD_ONCE_INIT;
 319 #define INIT_PTHREAD_LOCKS osi_Assert(pthread_once(&rx_once_init, rxi_InitPthread)==0)
 320 /*
 321  * The rx_stats_mutex mutex protects the following global variables:
 322  * rxi_lowConnRefCount
 323  * rxi_lowPeerRefCount
 324  * rxi_nCalls
 325  * rxi_Alloccnt
 326  * rxi_Allocsize
 327  * rx_tq_debug
 328  * rx_stats
 329  */
 330
 331 /*
 332  * The rx_quota_mutex mutex protects the following global variables:
 333  * rxi_dataQuota
 334  * rxi_minDeficit
 335  * rxi_availProcs
 336  * rxi_totalMin
 337  */
 338
 339 /*
 340  * The rx_freePktQ_lock protects the following global variables:
 341  * rx_nFreePackets
 342  */
 343
 344 /*
 345  * The rx_packets_mutex mutex protects the following global variables:
 346  * rx_nPackets
 347  * rx_TSFPQLocalMax
 348  * rx_TSFPQGlobSize
 349  * rx_TSFPQMaxProcs
 350  */
 351
 352 /*
 353  * The rx_pthread_mutex mutex protects the following global variables:
 354  * rxi_fcfs_thread_num
 355  */
 356 #else
 357 #define INIT_PTHREAD_LOCKS
 358 #endif
 359
 360
 361 /* Variables for handling the minProcs implementation.  availProcs gives the
 362  * number of threads available in the pool at this moment (not counting dudes
 363  * executing right now).  totalMin gives the total number of procs required
 364  * for handling all minProcs requests.  minDeficit is a dynamic variable
 365  * tracking the # of procs required to satisfy all of the remaining minProcs
 366  * demands.
 367  * For fine grain locking to work, the quota check and the reservation of
 368  * a server thread has to come while rxi_availProcs and rxi_minDeficit
 369  * are locked. To this end, the code has been modified under #ifdef
 370  * RX_ENABLE_LOCKS so that quota checks and reservation occur at the
 371  * same time. A new function, ReturnToServerPool() returns the allocation.
 372  *
 373  * A call can be on several queue's (but only one at a time). When
 374  * rxi_ResetCall wants to remove the call from a queue, it has to ensure
 375  * that no one else is touching the queue. To this end, we store the address
 376  * of the queue lock in the call structure (under the call lock) when we
 377  * put the call on a queue, and we clear the call_queue_lock when the
 378  * call is removed from a queue (once the call lock has been obtained).
 379  * This allows rxi_ResetCall to safely synchronize with others wishing
 380  * to manipulate the queue.
 381  */
 382
 383 #if defined(RX_ENABLE_LOCKS)
 384 static afs_kmutex_t rx_rpc_stats;
 385 #endif
 386
 387 /* We keep a "last conn pointer" in rxi_FindConnection. The odds are
 388 ** pretty good that the next packet coming in is from the same connection
 389 ** as the last packet, since we're send multiple packets in a transmit window.
 390 */
 391 struct rx_connection *rxLastConn = 0;
 392
 393 #ifdef RX_ENABLE_LOCKS
 394 /* The locking hierarchy for rx fine grain locking is composed of these
 395  * tiers:
 396  *
 397  * rx_connHashTable_lock - synchronizes conn creation, rx_connHashTable access
 398  * conn_call_lock - used to synchonize rx_EndCall and rx_NewCall
 399  * call->lock - locks call data fields.
 400  * These are independent of each other:
 401  *      rx_freeCallQueue_lock
 402  *      rxi_keyCreate_lock
 403  * rx_serverPool_lock
 404  * freeSQEList_lock
 405  *
 406  * serverQueueEntry->lock
 407  * rx_peerHashTable_lock - locked under rx_connHashTable_lock
 408  * rx_rpc_stats
 409  * peer->lock - locks peer data fields.
 410  * conn_data_lock - that more than one thread is not updating a conn data
 411  *                  field at the same time.
 412  * rx_freePktQ_lock
 413  *
 414  * lowest level:
 415  *      multi_handle->lock
 416  *      rxevent_lock
 417  *      rx_packets_mutex
 418  *      rx_stats_mutex
 419  *      rx_refcnt_mutex
 420  *      rx_atomic_mutex
 421  *
 422  * Do we need a lock to protect the peer field in the conn structure?
 423  *      conn->peer was previously a constant for all intents and so has no
 424  *      lock protecting this field. The multihomed client delta introduced
 425  *      a RX code change : change the peer field in the connection structure
 426  *      to that remote interface from which the last packet for this
 427  *      connection was sent out. This may become an issue if further changes
 428  *      are made.
 429  */
 430 #define SET_CALL_QUEUE_LOCK(C, L) (C)->call_queue_lock = (L)
 431 #define CLEAR_CALL_QUEUE_LOCK(C) (C)->call_queue_lock = NULL
 432 #ifdef RX_LOCKS_DB
 433 /* rxdb_fileID is used to identify the lock location, along with line#. */
 434 static int rxdb_fileID = RXDB_FILE_RX;
 435 #endif /* RX_LOCKS_DB */
 436 #else /* RX_ENABLE_LOCKS */
 437 #define SET_CALL_QUEUE_LOCK(C, L)
 438 #define CLEAR_CALL_QUEUE_LOCK(C)
 439 #endif /* RX_ENABLE_LOCKS */
 440 struct rx_serverQueueEntry *rx_waitForPacket = 0;
 441 struct rx_serverQueueEntry *rx_waitingForPacket = 0;
 442
 443 /* ------------Exported Interfaces------------- */
 444
 445 /* This function allows rxkad to set the epoch to a suitably random number
 446  * which rx_NewConnection will use in the future.  The principle purpose is to
 447  * get rxnull connections to use the same epoch as the rxkad connections do, at
 448  * least once the first rxkad connection is established.  This is important now
 449  * that the host/port addresses aren't used in FindConnection: the uniqueness
 450  * of epoch/cid matters and the start time won't do. */
 451
 452 #ifdef AFS_PTHREAD_ENV
 453 /*
 454  * This mutex protects the following global variables:
 455  * rx_epoch
 456  */
 457
 458 #define LOCK_EPOCH MUTEX_ENTER(&epoch_mutex)
 459 #define UNLOCK_EPOCH MUTEX_EXIT(&epoch_mutex)
 460 #else
 461 #define LOCK_EPOCH
 462 #define UNLOCK_EPOCH
 463 #endif /* AFS_PTHREAD_ENV */
 464
 465 void
 466 rx_SetEpoch(afs_uint32 epoch)
 467 {
 468     LOCK_EPOCH;
 469     rx_epoch = epoch;
 470     UNLOCK_EPOCH;
 471 }
 472
 473 /* Initialize rx.  A port number may be mentioned, in which case this
 474  * becomes the default port number for any service installed later.
 475  * If 0 is provided for the port number, a random port will be chosen
 476  * by the kernel.  Whether this will ever overlap anything in
 477  * /etc/services is anybody's guess...  Returns 0 on success, -1 on
 478  * error. */
 479 #ifndef AFS_NT40_ENV
 480 static
 481 #endif
 482 int rxinit_status = 1;
 483 #ifdef AFS_PTHREAD_ENV
 484 /*
 485  * This mutex protects the following global variables:
 486  * rxinit_status
 487  */
 488
 489 #define LOCK_RX_INIT MUTEX_ENTER(&rx_init_mutex)
 490 #define UNLOCK_RX_INIT MUTEX_EXIT(&rx_init_mutex)
 491 #else
 492 #define LOCK_RX_INIT
 493 #define UNLOCK_RX_INIT
 494 #endif
 495
 496 int
 497 rx_InitHost(u_int host, u_int port)
 498 {
 499 #ifdef KERNEL
 500     osi_timeval_t tv;
 501 #else /* KERNEL */
 502     struct timeval tv;
 503 #endif /* KERNEL */
 504     char *htable, *ptable;
 505     int tmp_status;
 506
 507     SPLVAR;
 508
 509     INIT_PTHREAD_LOCKS;
 510     LOCK_RX_INIT;
 511     if (rxinit_status == 0) {
 512         tmp_status = rxinit_status;
 513         UNLOCK_RX_INIT;
 514         return tmp_status;      /* Already started; return previous error code. */
 515     }
 516 #ifdef RXDEBUG
 517     rxi_DebugInit();
 518 #endif
 519 #ifdef AFS_NT40_ENV
 520     if (afs_winsockInit() < 0)
 521         return -1;
 522 #endif
 523
 524 #ifndef KERNEL
 525     /*
 526      * Initialize anything necessary to provide a non-premptive threading
 527      * environment.
 528      */
 529     rxi_InitializeThreadSupport();
 530 #endif
 531
 532     /* Allocate and initialize a socket for client and perhaps server
 533      * connections. */
 534
 535     rx_socket = rxi_GetHostUDPSocket(host, (u_short) port);
 536     if (rx_socket == OSI_NULLSOCKET) {
 537         UNLOCK_RX_INIT;
 538         return RX_ADDRINUSE;
 539     }
 540 #if defined(RX_ENABLE_LOCKS) && defined(KERNEL)
 541 #ifdef RX_LOCKS_DB
 542     rxdb_init();
 543 #endif /* RX_LOCKS_DB */
 544     MUTEX_INIT(&rx_stats_mutex, "rx_stats_mutex", MUTEX_DEFAULT, 0);
 545     MUTEX_INIT(&rx_quota_mutex, "rx_quota_mutex", MUTEX_DEFAULT, 0);
 546     MUTEX_INIT(&rx_atomic_mutex, "rx_atomic_mutex", MUTEX_DEFAULT, 0);
 547     MUTEX_INIT(&rx_pthread_mutex, "rx_pthread_mutex", MUTEX_DEFAULT, 0);
 548     MUTEX_INIT(&rx_packets_mutex, "rx_packets_mutex", MUTEX_DEFAULT, 0);
 549     MUTEX_INIT(&rx_refcnt_mutex, "rx_refcnt_mutex", MUTEX_DEFAULT, 0);
 550     MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
 551     MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
 552     MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
 553     MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock", MUTEX_DEFAULT,
 554                0);
 555     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
 556             0);
 557     MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
 558                0);
 559     MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
 560                0);
 561     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
 562 #if defined(AFS_HPUX110_ENV)
 563     if (!uniprocessor)
 564         rx_sleepLock = alloc_spinlock(LAST_HELD_ORDER - 10, "rx_sleepLock");
 565 #endif /* AFS_HPUX110_ENV */
 566 #endif /* RX_ENABLE_LOCKS && KERNEL */
 567
 568     rxi_nCalls = 0;
 569     rx_connDeadTime = 12;
 570     rx_tranquil = 0;            /* reset flag */
 571     rxi_ResetStatistics();
 572     htable = osi_Alloc(rx_hashTableSize * sizeof(struct rx_connection *));
 573     PIN(htable, rx_hashTableSize * sizeof(struct rx_connection *));     /* XXXXX */
 574     memset(htable, 0, rx_hashTableSize * sizeof(struct rx_connection *));
 575     ptable = osi_Alloc(rx_hashTableSize * sizeof(struct rx_peer *));
 576     PIN(ptable, rx_hashTableSize * sizeof(struct rx_peer *));   /* XXXXX */
 577     memset(ptable, 0, rx_hashTableSize * sizeof(struct rx_peer *));
 578
 579     /* Malloc up a bunch of packets & buffers */
 580     rx_nFreePackets = 0;
 581     opr_queue_Init(&rx_freePacketQueue);
 582     rxi_NeedMorePackets = FALSE;
 583     rx_nPackets = 0;    /* rx_nPackets is managed by rxi_MorePackets* */
 584
 585     /* enforce a minimum number of allocated packets */
 586     if (rx_extraPackets < rxi_nSendFrags * rx_maxSendWindow)
 587         rx_extraPackets = rxi_nSendFrags * rx_maxSendWindow;
 588
 589     /* allocate the initial free packet pool */
 590 #ifdef RX_ENABLE_TSFPQ
 591     rxi_MorePacketsTSFPQ(rx_extraPackets + RX_MAX_QUOTA + 2, RX_TS_FPQ_FLUSH_GLOBAL, 0);
 592 #else /* RX_ENABLE_TSFPQ */
 593     rxi_MorePackets(rx_extraPackets + RX_MAX_QUOTA + 2);        /* fudge */
 594 #endif /* RX_ENABLE_TSFPQ */
 595     rx_CheckPackets();
 596
 597     NETPRI;
 598
 599     clock_Init();
 600
 601 #if defined(AFS_NT40_ENV) && !defined(AFS_PTHREAD_ENV)
 602     tv.tv_sec = clock_now.sec;
 603     tv.tv_usec = clock_now.usec;
 604     srand((unsigned int)tv.tv_usec);
 605 #else
 606     osi_GetTime(&tv);
 607 #endif
 608     if (port) {
 609         rx_port = port;
 610     } else {
 611 #if defined(KERNEL) && !defined(UKERNEL)
 612         /* Really, this should never happen in a real kernel */
 613         rx_port = 0;
 614 #else
 615         struct sockaddr_in addr;
 616 #ifdef AFS_NT40_ENV
 617         int addrlen = sizeof(addr);
 618 #else
 619         socklen_t addrlen = sizeof(addr);
 620 #endif
 621         if (getsockname((intptr_t)rx_socket, (struct sockaddr *)&addr, &addrlen)) {
 622             rx_Finalize();
 623             osi_Free(htable, rx_hashTableSize * sizeof(struct rx_connection *));
 624             return -1;
 625         }
 626         rx_port = addr.sin_port;
 627 #endif
 628     }
 629     rx_stats.minRtt.sec = 9999999;
 630 #ifdef  KERNEL
 631     rx_SetEpoch(tv.tv_sec | 0x80000000);
 632 #else
 633     rx_SetEpoch(tv.tv_sec);     /* Start time of this package, rxkad
 634                                  * will provide a randomer value. */
 635 #endif
 636     MUTEX_ENTER(&rx_quota_mutex);
 637     rxi_dataQuota += rx_extraQuota; /* + extra pkts caller asked to rsrv */
 638     MUTEX_EXIT(&rx_quota_mutex);
 639     /* *Slightly* random start time for the cid.  This is just to help
 640      * out with the hashing function at the peer */
 641     rx_nextCid = ((tv.tv_sec ^ tv.tv_usec) << RX_CIDSHIFT);
 642     rx_connHashTable = (struct rx_connection **)htable;
 643     rx_peerHashTable = (struct rx_peer **)ptable;
 644
 645     rx_hardAckDelay.sec = 0;
 646     rx_hardAckDelay.usec = 100000;      /* 100 milliseconds */
 647
 648     rxevent_Init(20, rxi_ReScheduleEvents);
 649
 650     /* Initialize various global queues */
 651     opr_queue_Init(&rx_idleServerQueue);
 652     opr_queue_Init(&rx_incomingCallQueue);
 653     opr_queue_Init(&rx_freeCallQueue);
 654
 655 #if defined(AFS_NT40_ENV) && !defined(KERNEL)
 656     /* Initialize our list of usable IP addresses. */
 657     rx_GetIFInfo();
 658 #endif
 659
 660 #if defined(RXK_LISTENER_ENV) || !defined(KERNEL)
 661     /* Start listener process (exact function is dependent on the
 662      * implementation environment--kernel or user space) */
 663     rxi_StartListener();
 664 #endif
 665
 666     USERPRI;
 667     tmp_status = rxinit_status = 0;
 668     UNLOCK_RX_INIT;
 669     return tmp_status;
 670 }
 671
 672 int
 673 rx_Init(u_int port)
 674 {
 675     return rx_InitHost(htonl(INADDR_ANY), port);
 676 }
 677
 678 /* RTT Timer
 679  * ---------
 680  *
 681  * The rxi_rto functions implement a TCP (RFC2988) style algorithm for
 682  * maintaing the round trip timer.
 683  *
 684  */
 685
 686 /*!
 687  * Start a new RTT timer for a given call and packet.
 688  *
 689  * There must be no resendEvent already listed for this call, otherwise this
 690  * will leak events - intended for internal use within the RTO code only
 691  *
 692  * @param[in] call
 693  *      the RX call to start the timer for
 694  * @param[in] lastPacket
 695  *      a flag indicating whether the last packet has been sent or not
 696  *
 697  * @pre call must be locked before calling this function
 698  *
 699  */
 700 static_inline void
 701 rxi_rto_startTimer(struct rx_call *call, int lastPacket, int istack)
 702 {
 703     struct clock now, retryTime;
 704
 705     clock_GetTime(&now);
 706     retryTime = now;
 707
 708     clock_Add(&retryTime, &call->rto);
 709
 710     /* If we're sending the last packet, and we're the client, then the server
 711      * may wait for an additional 400ms before returning the ACK, wait for it
 712      * rather than hitting a timeout */
 713     if (lastPacket && call->conn->type == RX_CLIENT_CONNECTION)
 714         clock_Addmsec(&retryTime, 400);
 715
 716     CALL_HOLD(call, RX_CALL_REFCOUNT_RESEND);
 717     call->resendEvent = rxevent_Post(&retryTime, &now, rxi_Resend,
 718                                      call, NULL, istack);
 719 }
 720
 721 /*!
 722  * Cancel an RTT timer for a given call.
 723  *
 724  *
 725  * @param[in] call
 726  *      the RX call to cancel the timer for
 727  *
 728  * @pre call must be locked before calling this function
 729  *
 730  */
 731
 732 static_inline void
 733 rxi_rto_cancel(struct rx_call *call)
 734 {
 735     rxevent_Cancel(&call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
 736 }
 737
 738 /*!
 739  * Tell the RTO timer that we have sent a packet.
 740  *
 741  * If the timer isn't already running, then start it. If the timer is running,
 742  * then do nothing.
 743  *
 744  * @param[in] call
 745  *      the RX call that the packet has been sent on
 746  * @param[in] lastPacket
 747  *      A flag which is true if this is the last packet for the call
 748  *
 749  * @pre The call must be locked before calling this function
 750  *
 751  */
 752
 753 static_inline void
 754 rxi_rto_packet_sent(struct rx_call *call, int lastPacket, int istack)
 755 {
 756     if (call->resendEvent)
 757         return;
 758
 759     rxi_rto_startTimer(call, lastPacket, istack);
 760 }
 761
 762 /*!
 763  * Tell the RTO timer that we have received an new ACK message
 764  *
 765  * This function should be called whenever a call receives an ACK that
 766  * acknowledges new packets. Whatever happens, we stop the current timer.
 767  * If there are unacked packets in the queue which have been sent, then
 768  * we restart the timer from now. Otherwise, we leave it stopped.
 769  *
 770  * @param[in] call
 771  *      the RX call that the ACK has been received on
 772  */
 773
 774 static_inline void
 775 rxi_rto_packet_acked(struct rx_call *call, int istack)
 776 {
 777     struct opr_queue *cursor;
 778
 779     rxi_rto_cancel(call);
 780
 781     if (opr_queue_IsEmpty(&call->tq))
 782         return;
 783
 784     for (opr_queue_Scan(&call->tq, cursor)) {
 785         struct rx_packet *p = opr_queue_Entry(cursor, struct rx_packet, entry);
 786         if (p->header.seq > call->tfirst + call->twind)
 787             return;
 788
 789         if (!(p->flags & RX_PKTFLAG_ACKED) && p->flags & RX_PKTFLAG_SENT) {
 790             rxi_rto_startTimer(call, p->header.flags & RX_LAST_PACKET, istack);
 791             return;
 792         }
 793     }
 794 }
 795
 796
 797 /**
 798  * Set an initial round trip timeout for a peer connection
 799  *
 800  * @param[in] secs The timeout to set in seconds
 801  */
 802
 803 void
 804 rx_rto_setPeerTimeoutSecs(struct rx_peer *peer, int secs) {
 805     peer->rtt = secs * 8000;
 806 }
 807
 808 /**
 809  * Enables or disables the busy call channel error (RX_CALL_BUSY).
 810  *
 811  * @param[in] onoff Non-zero to enable busy call channel errors.
 812  *
 813  * @pre Neither rx_Init nor rx_InitHost have been called yet
 814  */
 815 void
 816 rx_SetBusyChannelError(afs_int32 onoff)
 817 {
 818     osi_Assert(rxinit_status != 0);
 819     rxi_busyChannelError = onoff ? 1 : 0;
 820 }
 821
 822 /**
 823  * Set a delayed ack event on the specified call for the given time
 824  *
 825  * @param[in] call - the call on which to set the event
 826  * @param[in] offset - the delay from now after which the event fires
 827  */
 828 void
 829 rxi_PostDelayedAckEvent(struct rx_call *call, struct clock *offset)
 830 {
 831     struct clock now, when;
 832
 833     clock_GetTime(&now);
 834     when = now;
 835     clock_Add(&when, offset);
 836
 837     if (!call->delayedAckEvent
 838         || clock_Gt(&call->delayedAckTime, &when)) {
 839
 840         rxevent_Cancel(&call->delayedAckEvent, call,
 841                        RX_CALL_REFCOUNT_DELAY);
 842         CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
 843
 844         call->delayedAckEvent = rxevent_Post(&when, &now,
 845                                              rxi_SendDelayedAck,
 846                                              call, NULL, 0);
 847         call->delayedAckTime = when;
 848     }
 849 }
 850
 851 /* called with unincremented nRequestsRunning to see if it is OK to start
 852  * a new thread in this service.  Could be "no" for two reasons: over the
 853  * max quota, or would prevent others from reaching their min quota.
 854  */
 855 #ifdef RX_ENABLE_LOCKS
 856 /* This verion of QuotaOK reserves quota if it's ok while the
 857  * rx_serverPool_lock is held.  Return quota using ReturnToServerPool().
 858  */
 859 static int
 860 QuotaOK(struct rx_service *aservice)
 861 {
 862     /* check if over max quota */
 863     if (aservice->nRequestsRunning >= aservice->maxProcs) {
 864         return 0;
 865     }
 866
 867     /* under min quota, we're OK */
 868     /* otherwise, can use only if there are enough to allow everyone
 869      * to go to their min quota after this guy starts.
 870      */
 871
 872     MUTEX_ENTER(&rx_quota_mutex);
 873     if ((aservice->nRequestsRunning < aservice->minProcs)
 874         || (rxi_availProcs > rxi_minDeficit)) {
 875         aservice->nRequestsRunning++;
 876         /* just started call in minProcs pool, need fewer to maintain
 877          * guarantee */
 878         if (aservice->nRequestsRunning <= aservice->minProcs)
 879             rxi_minDeficit--;
 880         rxi_availProcs--;
 881         MUTEX_EXIT(&rx_quota_mutex);
 882         return 1;
 883     }
 884     MUTEX_EXIT(&rx_quota_mutex);
 885
 886     return 0;
 887 }
 888
 889 static void
 890 ReturnToServerPool(struct rx_service *aservice)
 891 {
 892     aservice->nRequestsRunning--;
 893     MUTEX_ENTER(&rx_quota_mutex);
 894     if (aservice->nRequestsRunning < aservice->minProcs)
 895         rxi_minDeficit++;
 896     rxi_availProcs++;
 897     MUTEX_EXIT(&rx_quota_mutex);
 898 }
 899
 900 #else /* RX_ENABLE_LOCKS */
 901 static int
 902 QuotaOK(struct rx_service *aservice)
 903 {
 904     int rc = 0;
 905     /* under min quota, we're OK */
 906     if (aservice->nRequestsRunning < aservice->minProcs)
 907         return 1;
 908
 909     /* check if over max quota */
 910     if (aservice->nRequestsRunning >= aservice->maxProcs)
 911         return 0;
 912
 913     /* otherwise, can use only if there are enough to allow everyone
 914      * to go to their min quota after this guy starts.
 915      */
 916     MUTEX_ENTER(&rx_quota_mutex);
 917     if (rxi_availProcs > rxi_minDeficit)
 918         rc = 1;
 919     MUTEX_EXIT(&rx_quota_mutex);
 920     return rc;
 921 }
 922 #endif /* RX_ENABLE_LOCKS */
 923
 924 #ifndef KERNEL
 925 /* Called by rx_StartServer to start up lwp's to service calls.
 926    NExistingProcs gives the number of procs already existing, and which
 927    therefore needn't be created. */
 928 static void
 929 rxi_StartServerProcs(int nExistingProcs)
 930 {
 931     struct rx_service *service;
 932     int i;
 933     int maxdiff = 0;
 934     int nProcs = 0;
 935
 936     /* For each service, reserve N processes, where N is the "minimum"
 937      * number of processes that MUST be able to execute a request in parallel,
 938      * at any time, for that process.  Also compute the maximum difference
 939      * between any service's maximum number of processes that can run
 940      * (i.e. the maximum number that ever will be run, and a guarantee
 941      * that this number will run if other services aren't running), and its
 942      * minimum number.  The result is the extra number of processes that
 943      * we need in order to provide the latter guarantee */
 944     for (i = 0; i < RX_MAX_SERVICES; i++) {
 945         int diff;
 946         service = rx_services[i];
 947         if (service == (struct rx_service *)0)
 948             break;
 949         nProcs += service->minProcs;
 950         diff = service->maxProcs - service->minProcs;
 951         if (diff > maxdiff)
 952             maxdiff = diff;
 953     }
 954     nProcs += maxdiff;          /* Extra processes needed to allow max number requested to run in any given service, under good conditions */
 955     nProcs -= nExistingProcs;   /* Subtract the number of procs that were previously created for use as server procs */
 956     for (i = 0; i < nProcs; i++) {
 957         rxi_StartServerProc(rx_ServerProc, rx_stackSize);
 958     }
 959 }
 960 #endif /* KERNEL */
 961
 962 #ifdef AFS_NT40_ENV
 963 /* This routine is only required on Windows */
 964 void
 965 rx_StartClientThread(void)
 966 {
 967 #ifdef AFS_PTHREAD_ENV
 968     pthread_t pid;
 969     pid = pthread_self();
 970 #endif /* AFS_PTHREAD_ENV */
 971 }
 972 #endif /* AFS_NT40_ENV */
 973
 974 /* This routine must be called if any services are exported.  If the
 975  * donateMe flag is set, the calling process is donated to the server
 976  * process pool */
 977 void
 978 rx_StartServer(int donateMe)
 979 {
 980     struct rx_service *service;
 981     int i;
 982     SPLVAR;
 983     clock_NewTime();
 984
 985     NETPRI;
 986     /* Start server processes, if necessary (exact function is dependent
 987      * on the implementation environment--kernel or user space).  DonateMe
 988      * will be 1 if there is 1 pre-existing proc, i.e. this one.  In this
 989      * case, one less new proc will be created rx_StartServerProcs.
 990      */
 991     rxi_StartServerProcs(donateMe);
 992
 993     /* count up the # of threads in minProcs, and add set the min deficit to
 994      * be that value, too.
 995      */
 996     for (i = 0; i < RX_MAX_SERVICES; i++) {
 997         service = rx_services[i];
 998         if (service == (struct rx_service *)0)
 999             break;
1000         MUTEX_ENTER(&rx_quota_mutex);
1001         rxi_totalMin += service->minProcs;
1002         /* below works even if a thread is running, since minDeficit would
1003          * still have been decremented and later re-incremented.
1004          */
1005         rxi_minDeficit += service->minProcs;
1006         MUTEX_EXIT(&rx_quota_mutex);
1007     }
1008
1009     /* Turn on reaping of idle server connections */
1010     rxi_ReapConnections(NULL, NULL, NULL, 0);
1011
1012     USERPRI;
1013
1014     if (donateMe) {
1015 #ifndef AFS_NT40_ENV
1016 #ifndef KERNEL
1017         char name[32];
1018         static int nProcs;
1019 #ifdef AFS_PTHREAD_ENV
1020         pid_t pid;
1021         pid = afs_pointer_to_int(pthread_self());
1022 #else /* AFS_PTHREAD_ENV */
1023         PROCESS pid;
1024         LWP_CurrentProcess(&pid);
1025 #endif /* AFS_PTHREAD_ENV */
1026
1027         sprintf(name, "srv_%d", ++nProcs);
1028         if (registerProgram)
1029             (*registerProgram) (pid, name);
1030 #endif /* KERNEL */
1031 #endif /* AFS_NT40_ENV */
1032         rx_ServerProc(NULL);    /* Never returns */
1033     }
1034 #ifdef RX_ENABLE_TSFPQ
1035     /* no use leaving packets around in this thread's local queue if
1036      * it isn't getting donated to the server thread pool.
1037      */
1038     rxi_FlushLocalPacketsTSFPQ();
1039 #endif /* RX_ENABLE_TSFPQ */
1040     return;
1041 }
1042
1043 /* Create a new client connection to the specified service, using the
1044  * specified security object to implement the security model for this
1045  * connection. */
1046 struct rx_connection *
1047 rx_NewConnection(afs_uint32 shost, u_short sport, u_short sservice,
1048                  struct rx_securityClass *securityObject,
1049                  int serviceSecurityIndex)
1050 {
1051     int hashindex, i;
1052     afs_int32 cid;
1053     struct rx_connection *conn;
1054
1055     SPLVAR;
1056
1057     clock_NewTime();
1058     dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %p, "
1059          "serviceSecurityIndex %d)\n",
1060          ntohl(shost), ntohs(sport), sservice, securityObject,
1061          serviceSecurityIndex));
1062
1063     /* Vasilsi said: "NETPRI protects Cid and Alloc", but can this be true in
1064      * the case of kmem_alloc? */
1065     conn = rxi_AllocConnection();
1066 #ifdef  RX_ENABLE_LOCKS
1067     MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
1068     MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
1069     CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
1070 #endif
1071     NETPRI;
1072     MUTEX_ENTER(&rx_connHashTable_lock);
1073     cid = (rx_nextCid += RX_MAXCALLS);
1074     conn->type = RX_CLIENT_CONNECTION;
1075     conn->cid = cid;
1076     conn->epoch = rx_epoch;
1077     conn->peer = rxi_FindPeer(shost, sport, 0, 1);
1078     conn->serviceId = sservice;
1079     conn->securityObject = securityObject;
1080     conn->securityData = (void *) 0;
1081     conn->securityIndex = serviceSecurityIndex;
1082     rx_SetConnDeadTime(conn, rx_connDeadTime);
1083     rx_SetConnSecondsUntilNatPing(conn, 0);
1084     conn->ackRate = RX_FAST_ACK_RATE;
1085     conn->nSpecific = 0;
1086     conn->specific = NULL;
1087     conn->challengeEvent = NULL;
1088     conn->delayedAbortEvent = NULL;
1089     conn->abortCount = 0;
1090     conn->error = 0;
1091     for (i = 0; i < RX_MAXCALLS; i++) {
1092         conn->twind[i] = rx_initSendWindow;
1093         conn->rwind[i] = rx_initReceiveWindow;
1094         conn->lastBusy[i] = 0;
1095     }
1096
1097     RXS_NewConnection(securityObject, conn);
1098     hashindex =
1099         CONN_HASH(shost, sport, conn->cid, conn->epoch, RX_CLIENT_CONNECTION);
1100
1101     conn->refCount++;           /* no lock required since only this thread knows... */
1102     conn->next = rx_connHashTable[hashindex];
1103     rx_connHashTable[hashindex] = conn;
1104     if (rx_stats_active)
1105         rx_atomic_inc(&rx_stats.nClientConns);
1106     MUTEX_EXIT(&rx_connHashTable_lock);
1107     USERPRI;
1108     return conn;
1109 }
1110
1111 /**
1112  * Ensure a connection's timeout values are valid.
1113  *
1114  * @param[in] conn The connection to check
1115  *
1116  * @post conn->secondUntilDead <= conn->idleDeadTime <= conn->hardDeadTime,
1117  *       unless idleDeadTime and/or hardDeadTime are not set
1118  * @internal
1119  */
1120 static void
1121 rxi_CheckConnTimeouts(struct rx_connection *conn)
1122 {
1123     /* a connection's timeouts must have the relationship
1124      * deadTime <= idleDeadTime <= hardDeadTime. Otherwise, for example, a
1125      * total loss of network to a peer may cause an idle timeout instead of a
1126      * dead timeout, simply because the idle timeout gets hit first. Also set
1127      * a minimum deadTime of 6, just to ensure it doesn't get set too low. */
1128     /* this logic is slightly complicated by the fact that
1129      * idleDeadTime/hardDeadTime may not be set at all, but it's not too bad.
1130      */
1131     conn->secondsUntilDead = MAX(conn->secondsUntilDead, 6);
1132     if (conn->idleDeadTime) {
1133         conn->idleDeadTime = MAX(conn->idleDeadTime, conn->secondsUntilDead);
1134     }
1135     if (conn->hardDeadTime) {
1136         if (conn->idleDeadTime) {
1137             conn->hardDeadTime = MAX(conn->idleDeadTime, conn->hardDeadTime);
1138         } else {
1139             conn->hardDeadTime = MAX(conn->secondsUntilDead, conn->hardDeadTime);
1140         }
1141     }
1142 }
1143
1144 void
1145 rx_SetConnDeadTime(struct rx_connection *conn, int seconds)
1146 {
1147     /* The idea is to set the dead time to a value that allows several
1148      * keepalives to be dropped without timing out the connection. */
1149     conn->secondsUntilDead = seconds;
1150     rxi_CheckConnTimeouts(conn);
1151     conn->secondsUntilPing = conn->secondsUntilDead / 6;
1152 }
1153
1154 void
1155 rx_SetConnHardDeadTime(struct rx_connection *conn, int seconds)
1156 {
1157     conn->hardDeadTime = seconds;
1158     rxi_CheckConnTimeouts(conn);
1159 }
1160
1161 void
1162 rx_SetConnIdleDeadTime(struct rx_connection *conn, int seconds)
1163 {
1164     conn->idleDeadTime = seconds;
1165     conn->idleDeadDetection = (seconds ? 1 : 0);
1166     rxi_CheckConnTimeouts(conn);
1167 }
1168
1169 int rxi_lowPeerRefCount = 0;
1170 int rxi_lowConnRefCount = 0;
1171
1172 /*
1173  * Cleanup a connection that was destroyed in rxi_DestroyConnectioNoLock.
1174  * NOTE: must not be called with rx_connHashTable_lock held.
1175  */
1176 static void
1177 rxi_CleanupConnection(struct rx_connection *conn)
1178 {
1179     /* Notify the service exporter, if requested, that this connection
1180      * is being destroyed */
1181     if (conn->type == RX_SERVER_CONNECTION && conn->service->destroyConnProc)
1182         (*conn->service->destroyConnProc) (conn);
1183
1184     /* Notify the security module that this connection is being destroyed */
1185     RXS_DestroyConnection(conn->securityObject, conn);
1186
1187     /* If this is the last connection using the rx_peer struct, set its
1188      * idle time to now. rxi_ReapConnections will reap it if it's still
1189      * idle (refCount == 0) after rx_idlePeerTime (60 seconds) have passed.
1190      */
1191     MUTEX_ENTER(&rx_peerHashTable_lock);
1192     if (conn->peer->refCount < 2) {
1193         conn->peer->idleWhen = clock_Sec();
1194         if (conn->peer->refCount < 1) {
1195             conn->peer->refCount = 1;
1196             if (rx_stats_active) {
1197                 MUTEX_ENTER(&rx_stats_mutex);
1198                 rxi_lowPeerRefCount++;
1199                 MUTEX_EXIT(&rx_stats_mutex);
1200             }
1201         }
1202     }
1203     conn->peer->refCount--;
1204     MUTEX_EXIT(&rx_peerHashTable_lock);
1205
1206     if (rx_stats_active)
1207     {
1208         if (conn->type == RX_SERVER_CONNECTION)
1209             rx_atomic_dec(&rx_stats.nServerConns);
1210         else
1211             rx_atomic_dec(&rx_stats.nClientConns);
1212     }
1213 #ifndef KERNEL
1214     if (conn->specific) {
1215         int i;
1216         for (i = 0; i < conn->nSpecific; i++) {
1217             if (conn->specific[i] && rxi_keyCreate_destructor[i])
1218                 (*rxi_keyCreate_destructor[i]) (conn->specific[i]);
1219             conn->specific[i] = NULL;
1220         }
1221         free(conn->specific);
1222     }
1223     conn->specific = NULL;
1224     conn->nSpecific = 0;
1225 #endif /* !KERNEL */
1226
1227     MUTEX_DESTROY(&conn->conn_call_lock);
1228     MUTEX_DESTROY(&conn->conn_data_lock);
1229     CV_DESTROY(&conn->conn_call_cv);
1230
1231     rxi_FreeConnection(conn);
1232 }
1233
1234 /* Destroy the specified connection */
1235 void
1236 rxi_DestroyConnection(struct rx_connection *conn)
1237 {
1238     MUTEX_ENTER(&rx_connHashTable_lock);
1239     rxi_DestroyConnectionNoLock(conn);
1240     /* conn should be at the head of the cleanup list */
1241     if (conn == rx_connCleanup_list) {
1242         rx_connCleanup_list = rx_connCleanup_list->next;
1243         MUTEX_EXIT(&rx_connHashTable_lock);
1244         rxi_CleanupConnection(conn);
1245     }
1246 #ifdef RX_ENABLE_LOCKS
1247     else {
1248         MUTEX_EXIT(&rx_connHashTable_lock);
1249     }
1250 #endif /* RX_ENABLE_LOCKS */
1251 }
1252
1253 static void
1254 rxi_DestroyConnectionNoLock(struct rx_connection *conn)
1255 {
1256     struct rx_connection **conn_ptr;
1257     int havecalls = 0;
1258     struct rx_packet *packet;
1259     int i;
1260     SPLVAR;
1261
1262     clock_NewTime();
1263
1264     NETPRI;
1265     MUTEX_ENTER(&conn->conn_data_lock);
1266     MUTEX_ENTER(&rx_refcnt_mutex);
1267     if (conn->refCount > 0)
1268         conn->refCount--;
1269     else {
1270         if (rx_stats_active) {
1271             MUTEX_ENTER(&rx_stats_mutex);
1272             rxi_lowConnRefCount++;
1273             MUTEX_EXIT(&rx_stats_mutex);
1274         }
1275     }
1276
1277     if ((conn->refCount > 0) || (conn->flags & RX_CONN_BUSY)) {
1278         /* Busy; wait till the last guy before proceeding */
1279         MUTEX_EXIT(&rx_refcnt_mutex);
1280         MUTEX_EXIT(&conn->conn_data_lock);
1281         USERPRI;
1282         return;
1283     }
1284
1285     /* If the client previously called rx_NewCall, but it is still
1286      * waiting, treat this as a running call, and wait to destroy the
1287      * connection later when the call completes. */
1288     if ((conn->type == RX_CLIENT_CONNECTION)
1289         && (conn->flags & (RX_CONN_MAKECALL_WAITING|RX_CONN_MAKECALL_ACTIVE))) {
1290         conn->flags |= RX_CONN_DESTROY_ME;
1291         MUTEX_EXIT(&conn->conn_data_lock);
1292         USERPRI;
1293         return;
1294     }
1295     MUTEX_EXIT(&rx_refcnt_mutex);
1296     MUTEX_EXIT(&conn->conn_data_lock);
1297
1298     /* Check for extant references to this connection */
1299     MUTEX_ENTER(&conn->conn_call_lock);
1300     for (i = 0; i < RX_MAXCALLS; i++) {
1301         struct rx_call *call = conn->call[i];
1302         if (call) {
1303             havecalls = 1;
1304             if (conn->type == RX_CLIENT_CONNECTION) {
1305                 MUTEX_ENTER(&call->lock);
1306                 if (call->delayedAckEvent) {
1307                     /* Push the final acknowledgment out now--there
1308                      * won't be a subsequent call to acknowledge the
1309                      * last reply packets */
1310                     rxevent_Cancel(&call->delayedAckEvent, call,
1311                                    RX_CALL_REFCOUNT_DELAY);
1312                     if (call->state == RX_STATE_PRECALL
1313                         || call->state == RX_STATE_ACTIVE) {
1314                         rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
1315                     } else {
1316                         rxi_AckAll(call);
1317                     }
1318                 }
1319                 MUTEX_EXIT(&call->lock);
1320             }
1321         }
1322     }
1323     MUTEX_EXIT(&conn->conn_call_lock);
1324
1325 #ifdef RX_ENABLE_LOCKS
1326     if (!havecalls) {
1327         if (MUTEX_TRYENTER(&conn->conn_data_lock)) {
1328             MUTEX_EXIT(&conn->conn_data_lock);
1329         } else {
1330             /* Someone is accessing a packet right now. */
1331             havecalls = 1;
1332         }
1333     }
1334 #endif /* RX_ENABLE_LOCKS */
1335
1336     if (havecalls) {
1337         /* Don't destroy the connection if there are any call
1338          * structures still in use */
1339         MUTEX_ENTER(&conn->conn_data_lock);
1340         conn->flags |= RX_CONN_DESTROY_ME;
1341         MUTEX_EXIT(&conn->conn_data_lock);
1342         USERPRI;
1343         return;
1344     }
1345
1346     if (conn->natKeepAliveEvent) {
1347         rxi_NatKeepAliveOff(conn);
1348     }
1349
1350     if (conn->delayedAbortEvent) {
1351         rxevent_Cancel(&conn->delayedAbortEvent, NULL, 0);
1352         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
1353         if (packet) {
1354             MUTEX_ENTER(&conn->conn_data_lock);
1355             rxi_SendConnectionAbort(conn, packet, 0, 1);
1356             MUTEX_EXIT(&conn->conn_data_lock);
1357             rxi_FreePacket(packet);
1358         }
1359     }
1360
1361     /* Remove from connection hash table before proceeding */
1362     conn_ptr =
1363         &rx_connHashTable[CONN_HASH
1364                           (peer->host, peer->port, conn->cid, conn->epoch,
1365                            conn->type)];
1366     for (; *conn_ptr; conn_ptr = &(*conn_ptr)->next) {
1367         if (*conn_ptr == conn) {
1368             *conn_ptr = conn->next;
1369             break;
1370         }
1371     }
1372     /* if the conn that we are destroying was the last connection, then we
1373      * clear rxLastConn as well */
1374     if (rxLastConn == conn)
1375         rxLastConn = 0;
1376
1377     /* Make sure the connection is completely reset before deleting it. */
1378     /* get rid of pending events that could zap us later */
1379     rxevent_Cancel(&conn->challengeEvent, NULL, 0);
1380     rxevent_Cancel(&conn->checkReachEvent, NULL, 0);
1381     rxevent_Cancel(&conn->natKeepAliveEvent, NULL, 0);
1382
1383     /* Add the connection to the list of destroyed connections that
1384      * need to be cleaned up. This is necessary to avoid deadlocks
1385      * in the routines we call to inform others that this connection is
1386      * being destroyed. */
1387     conn->next = rx_connCleanup_list;
1388     rx_connCleanup_list = conn;
1389 }
1390
1391 /* Externally available version */
1392 void
1393 rx_DestroyConnection(struct rx_connection *conn)
1394 {
1395     SPLVAR;
1396
1397     NETPRI;
1398     rxi_DestroyConnection(conn);
1399     USERPRI;
1400 }
1401
1402 void
1403 rx_GetConnection(struct rx_connection *conn)
1404 {
1405     SPLVAR;
1406
1407     NETPRI;
1408     MUTEX_ENTER(&rx_refcnt_mutex);
1409     conn->refCount++;
1410     MUTEX_EXIT(&rx_refcnt_mutex);
1411     USERPRI;
1412 }
1413
1414 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1415 /* Wait for the transmit queue to no longer be busy.
1416  * requires the call->lock to be held */
1417 void
1418 rxi_WaitforTQBusy(struct rx_call *call) {
1419     while (!call->error && (call->flags & RX_CALL_TQ_BUSY)) {
1420         call->flags |= RX_CALL_TQ_WAIT;
1421         call->tqWaiters++;
1422 #ifdef RX_ENABLE_LOCKS
1423         osirx_AssertMine(&call->lock, "rxi_WaitforTQ lock");
1424         CV_WAIT(&call->cv_tq, &call->lock);
1425 #else /* RX_ENABLE_LOCKS */
1426         osi_rxSleep(&call->tq);
1427 #endif /* RX_ENABLE_LOCKS */
1428         call->tqWaiters--;
1429         if (call->tqWaiters == 0) {
1430             call->flags &= ~RX_CALL_TQ_WAIT;
1431         }
1432     }
1433 }
1434 #endif
1435
1436 static void
1437 rxi_WakeUpTransmitQueue(struct rx_call *call)
1438 {
1439     if (call->tqWaiters || (call->flags & RX_CALL_TQ_WAIT)) {
1440         dpf(("call %"AFS_PTR_FMT" has %d waiters and flags %d\n",
1441              call, call->tqWaiters, call->flags));
1442 #ifdef RX_ENABLE_LOCKS
1443         osirx_AssertMine(&call->lock, "rxi_Start start");
1444         CV_BROADCAST(&call->cv_tq);
1445 #else /* RX_ENABLE_LOCKS */
1446         osi_rxWakeup(&call->tq);
1447 #endif /* RX_ENABLE_LOCKS */
1448     }
1449 }
1450
1451 /* Start a new rx remote procedure call, on the specified connection.
1452  * If wait is set to 1, wait for a free call channel; otherwise return
1453  * 0.  Maxtime gives the maximum number of seconds this call may take,
1454  * after rx_NewCall returns.  After this time interval, a call to any
1455  * of rx_SendData, rx_ReadData, etc. will fail with RX_CALL_TIMEOUT.
1456  * For fine grain locking, we hold the conn_call_lock in order to
1457  * to ensure that we don't get signalle after we found a call in an active
1458  * state and before we go to sleep.
1459  */
1460 struct rx_call *
1461 rx_NewCall(struct rx_connection *conn)
1462 {
1463     int i, wait, ignoreBusy = 1;
1464     struct rx_call *call;
1465     struct clock queueTime;
1466     afs_uint32 leastBusy = 0;
1467     SPLVAR;
1468
1469     clock_NewTime();
1470     dpf(("rx_NewCall(conn %"AFS_PTR_FMT")\n", conn));
1471
1472     NETPRI;
1473     clock_GetTime(&queueTime);
1474     /*
1475      * Check if there are others waiting for a new call.
1476      * If so, let them go first to avoid starving them.
1477      * This is a fairly simple scheme, and might not be
1478      * a complete solution for large numbers of waiters.
1479      *
1480      * makeCallWaiters keeps track of the number of
1481      * threads waiting to make calls and the
1482      * RX_CONN_MAKECALL_WAITING flag bit is used to
1483      * indicate that there are indeed calls waiting.
1484      * The flag is set when the waiter is incremented.
1485      * It is only cleared when makeCallWaiters is 0.
1486      * This prevents us from accidently destroying the
1487      * connection while it is potentially about to be used.
1488      */
1489     MUTEX_ENTER(&conn->conn_call_lock);
1490     MUTEX_ENTER(&conn->conn_data_lock);
1491     while (conn->flags & RX_CONN_MAKECALL_ACTIVE) {
1492         conn->flags |= RX_CONN_MAKECALL_WAITING;
1493         conn->makeCallWaiters++;
1494         MUTEX_EXIT(&conn->conn_data_lock);
1495
1496 #ifdef  RX_ENABLE_LOCKS
1497         CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
1498 #else
1499         osi_rxSleep(conn);
1500 #endif
1501         MUTEX_ENTER(&conn->conn_data_lock);
1502         conn->makeCallWaiters--;
1503         if (conn->makeCallWaiters == 0)
1504             conn->flags &= ~RX_CONN_MAKECALL_WAITING;
1505     }
1506
1507     /* We are now the active thread in rx_NewCall */
1508     conn->flags |= RX_CONN_MAKECALL_ACTIVE;
1509     MUTEX_EXIT(&conn->conn_data_lock);
1510
1511     for (;;) {
1512         wait = 1;
1513
1514         for (i = 0; i < RX_MAXCALLS; i++) {
1515             call = conn->call[i];
1516             if (call) {
1517                 if (!ignoreBusy && conn->lastBusy[i] != leastBusy) {
1518                     /* we're not ignoring busy call slots; only look at the
1519                      * call slot that is the "least" busy */
1520                     continue;
1521                 }
1522
1523                 if (call->state == RX_STATE_DALLY) {
1524                     MUTEX_ENTER(&call->lock);
1525                     if (call->state == RX_STATE_DALLY) {
1526                         if (ignoreBusy && conn->lastBusy[i]) {
1527                             /* if we're ignoring busy call slots, skip any ones that
1528                              * have lastBusy set */
1529                             if (leastBusy == 0 || conn->lastBusy[i] < leastBusy) {
1530                                 leastBusy = conn->lastBusy[i];
1531                             }
1532                             MUTEX_EXIT(&call->lock);
1533                             continue;
1534                         }
1535
1536                         /*
1537                          * We are setting the state to RX_STATE_RESET to
1538                          * ensure that no one else will attempt to use this
1539                          * call once we drop the conn->conn_call_lock and
1540                          * call->lock.  We must drop the conn->conn_call_lock
1541                          * before calling rxi_ResetCall because the process
1542                          * of clearing the transmit queue can block for an
1543                          * extended period of time.  If we block while holding
1544                          * the conn->conn_call_lock, then all rx_EndCall
1545                          * processing will block as well.  This has a detrimental
1546                          * effect on overall system performance.
1547                          */
1548                         call->state = RX_STATE_RESET;
1549                         (*call->callNumber)++;
1550                         MUTEX_EXIT(&conn->conn_call_lock);
1551                         CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
1552                         rxi_ResetCall(call, 0);
1553                         if (MUTEX_TRYENTER(&conn->conn_call_lock))
1554                             break;
1555
1556                         /*
1557                          * If we failed to be able to safely obtain the
1558                          * conn->conn_call_lock we will have to drop the
1559                          * call->lock to avoid a deadlock.  When the call->lock
1560                          * is released the state of the call can change.  If it
1561                          * is no longer RX_STATE_RESET then some other thread is
1562                          * using the call.
1563                          */
1564                         MUTEX_EXIT(&call->lock);
1565                         MUTEX_ENTER(&conn->conn_call_lock);
1566                         MUTEX_ENTER(&call->lock);
1567
1568                         if (call->state == RX_STATE_RESET)
1569                             break;
1570
1571                         /*
1572                          * If we get here it means that after dropping
1573                          * the conn->conn_call_lock and call->lock that
1574                          * the call is no longer ours.  If we can't find
1575                          * a free call in the remaining slots we should
1576                          * not go immediately to RX_CONN_MAKECALL_WAITING
1577                          * because by dropping the conn->conn_call_lock
1578                          * we have given up synchronization with rx_EndCall.
1579                          * Instead, cycle through one more time to see if
1580                          * we can find a call that can call our own.
1581                          */
1582                         CALL_RELE(call, RX_CALL_REFCOUNT_BEGIN);
1583                         wait = 0;
1584                     }
1585                     MUTEX_EXIT(&call->lock);
1586                 }
1587             } else {
1588                 if (ignoreBusy && conn->lastBusy[i]) {
1589                     /* if we're ignoring busy call slots, skip any ones that
1590                      * have lastBusy set */
1591                     if (leastBusy == 0 || conn->lastBusy[i] < leastBusy) {
1592                         leastBusy = conn->lastBusy[i];
1593                     }
1594                     continue;
1595                 }
1596
1597                 /* rxi_NewCall returns with mutex locked */
1598                 call = rxi_NewCall(conn, i);
1599                 CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
1600                 break;
1601             }
1602         }
1603         if (i < RX_MAXCALLS) {
1604             conn->lastBusy[i] = 0;
1605             call->flags &= ~RX_CALL_PEER_BUSY;
1606             break;
1607         }
1608         if (!wait)
1609             continue;
1610         if (leastBusy && ignoreBusy) {
1611             /* we didn't find a useable call slot, but we did see at least one
1612              * 'busy' slot; look again and only use a slot with the 'least
1613              * busy time */
1614             ignoreBusy = 0;
1615             continue;
1616         }
1617
1618         MUTEX_ENTER(&conn->conn_data_lock);
1619         conn->flags |= RX_CONN_MAKECALL_WAITING;
1620         conn->makeCallWaiters++;
1621         MUTEX_EXIT(&conn->conn_data_lock);
1622
1623 #ifdef  RX_ENABLE_LOCKS
1624         CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
1625 #else
1626         osi_rxSleep(conn);
1627 #endif
1628         MUTEX_ENTER(&conn->conn_data_lock);
1629         conn->makeCallWaiters--;
1630         if (conn->makeCallWaiters == 0)
1631             conn->flags &= ~RX_CONN_MAKECALL_WAITING;
1632         MUTEX_EXIT(&conn->conn_data_lock);
1633     }
1634     /* Client is initially in send mode */
1635     call->state = RX_STATE_ACTIVE;
1636     call->error = conn->error;
1637     if (call->error)
1638         call->mode = RX_MODE_ERROR;
1639     else
1640         call->mode = RX_MODE_SENDING;
1641
1642 #ifdef AFS_RXERRQ_ENV
1643     /* remember how many network errors the peer has when we started, so if
1644      * more errors are encountered after the call starts, we know the other endpoint won't be
1645      * responding to us */
1646     call->neterr_gen = rx_atomic_read(&conn->peer->neterrs);
1647 #endif
1648
1649     /* remember start time for call in case we have hard dead time limit */
1650     call->queueTime = queueTime;
1651     clock_GetTime(&call->startTime);
1652     call->bytesSent = 0;
1653     call->bytesRcvd = 0;
1654
1655     /* Turn on busy protocol. */
1656     rxi_KeepAliveOn(call);
1657
1658     /* Attempt MTU discovery */
1659     rxi_GrowMTUOn(call);
1660
1661     /*
1662      * We are no longer the active thread in rx_NewCall
1663      */
1664     MUTEX_ENTER(&conn->conn_data_lock);
1665     conn->flags &= ~RX_CONN_MAKECALL_ACTIVE;
1666     MUTEX_EXIT(&conn->conn_data_lock);
1667
1668     /*
1669      * Wake up anyone else who might be giving us a chance to
1670      * run (see code above that avoids resource starvation).
1671      */
1672 #ifdef  RX_ENABLE_LOCKS
1673     CV_BROADCAST(&conn->conn_call_cv);
1674 #else
1675     osi_rxWakeup(conn);
1676 #endif
1677     MUTEX_EXIT(&conn->conn_call_lock);
1678
1679 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1680     if (call->flags & (RX_CALL_TQ_BUSY | RX_CALL_TQ_CLEARME)) {
1681         osi_Panic("rx_NewCall call about to be used without an empty tq");
1682     }
1683 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1684
1685     MUTEX_EXIT(&call->lock);
1686     USERPRI;
1687
1688     dpf(("rx_NewCall(call %"AFS_PTR_FMT")\n", call));
1689     return call;
1690 }
1691
1692 static int
1693 rxi_HasActiveCalls(struct rx_connection *aconn)
1694 {
1695     int i;
1696     struct rx_call *tcall;
1697     SPLVAR;
1698
1699     NETPRI;
1700     for (i = 0; i < RX_MAXCALLS; i++) {
1701         if ((tcall = aconn->call[i])) {
1702             if ((tcall->state == RX_STATE_ACTIVE)
1703                 || (tcall->state == RX_STATE_PRECALL)) {
1704                 USERPRI;
1705                 return 1;
1706             }
1707         }
1708     }
1709     USERPRI;
1710     return 0;
1711 }
1712
1713 int
1714 rxi_GetCallNumberVector(struct rx_connection *aconn,
1715                         afs_int32 * aint32s)
1716 {
1717     int i;
1718     struct rx_call *tcall;
1719     SPLVAR;
1720
1721     NETPRI;
1722     MUTEX_ENTER(&aconn->conn_call_lock);
1723     for (i = 0; i < RX_MAXCALLS; i++) {
1724         if ((tcall = aconn->call[i]) && (tcall->state == RX_STATE_DALLY))
1725             aint32s[i] = aconn->callNumber[i] + 1;
1726         else
1727             aint32s[i] = aconn->callNumber[i];
1728     }
1729     MUTEX_EXIT(&aconn->conn_call_lock);
1730     USERPRI;
1731     return 0;
1732 }
1733
1734 int
1735 rxi_SetCallNumberVector(struct rx_connection *aconn,
1736                         afs_int32 * aint32s)
1737 {
1738     int i;
1739     struct rx_call *tcall;
1740     SPLVAR;
1741
1742     NETPRI;
1743     MUTEX_ENTER(&aconn->conn_call_lock);
1744     for (i = 0; i < RX_MAXCALLS; i++) {
1745         if ((tcall = aconn->call[i]) && (tcall->state == RX_STATE_DALLY))
1746             aconn->callNumber[i] = aint32s[i] - 1;
1747         else
1748             aconn->callNumber[i] = aint32s[i];
1749     }
1750     MUTEX_EXIT(&aconn->conn_call_lock);
1751     USERPRI;
1752     return 0;
1753 }
1754
1755 /* Advertise a new service.  A service is named locally by a UDP port
1756  * number plus a 16-bit service id.  Returns (struct rx_service *) 0
1757  * on a failure.
1758  *
1759      char *serviceName;  Name for identification purposes (e.g. the
1760                          service name might be used for probing for
1761                          statistics) */
1762 struct rx_service *
1763 rx_NewServiceHost(afs_uint32 host, u_short port, u_short serviceId,
1764                   char *serviceName, struct rx_securityClass **securityObjects,
1765                   int nSecurityObjects,
1766                   afs_int32(*serviceProc) (struct rx_call * acall))
1767 {
1768     osi_socket socket = OSI_NULLSOCKET;
1769     struct rx_service *tservice;
1770     int i;
1771     SPLVAR;
1772
1773     clock_NewTime();
1774
1775     if (serviceId == 0) {
1776         (osi_Msg
1777          "rx_NewService:  service id for service %s is not non-zero.\n",
1778          serviceName);
1779         return 0;
1780     }
1781     if (port == 0) {
1782         if (rx_port == 0) {
1783             (osi_Msg
1784              "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",
1785              serviceName);
1786             return 0;
1787         }
1788         port = rx_port;
1789         socket = rx_socket;
1790     }
1791
1792     tservice = rxi_AllocService();
1793     NETPRI;
1794
1795 #ifdef  RX_ENABLE_LOCKS
1796     MUTEX_INIT(&tservice->svc_data_lock, "svc data lock", MUTEX_DEFAULT, 0);
1797 #endif
1798
1799     for (i = 0; i < RX_MAX_SERVICES; i++) {
1800         struct rx_service *service = rx_services[i];
1801         if (service) {
1802             if (port == service->servicePort && host == service->serviceHost) {
1803                 if (service->serviceId == serviceId) {
1804                     /* The identical service has already been
1805                      * installed; if the caller was intending to
1806                      * change the security classes used by this
1807                      * service, he/she loses. */
1808                     (osi_Msg
1809                      "rx_NewService: tried to install service %s with service id %d, which is already in use for service %s\n",
1810                      serviceName, serviceId, service->serviceName);
1811                     USERPRI;
1812                     rxi_FreeService(tservice);
1813                     return service;
1814                 }
1815                 /* Different service, same port: re-use the socket
1816                  * which is bound to the same port */
1817                 socket = service->socket;
1818             }
1819         } else {
1820             if (socket == OSI_NULLSOCKET) {
1821                 /* If we don't already have a socket (from another
1822                  * service on same port) get a new one */
1823                 socket = rxi_GetHostUDPSocket(host, port);
1824                 if (socket == OSI_NULLSOCKET) {
1825                     USERPRI;
1826                     rxi_FreeService(tservice);
1827                     return 0;
1828                 }
1829             }
1830             service = tservice;
1831             service->socket = socket;
1832             service->serviceHost = host;
1833             service->servicePort = port;
1834             service->serviceId = serviceId;
1835             service->serviceName = serviceName;
1836             service->nSecurityObjects = nSecurityObjects;
1837             service->securityObjects = securityObjects;
1838             service->minProcs = 0;
1839             service->maxProcs = 1;
1840             service->idleDeadTime = 60;
1841             service->idleDeadErr = 0;
1842             service->connDeadTime = rx_connDeadTime;
1843             service->executeRequestProc = serviceProc;
1844             service->checkReach = 0;
1845             service->nSpecific = 0;
1846             service->specific = NULL;
1847             rx_services[i] = service;   /* not visible until now */
1848             USERPRI;
1849             return service;
1850         }
1851     }
1852     USERPRI;
1853     rxi_FreeService(tservice);
1854     (osi_Msg "rx_NewService: cannot support > %d services\n",
1855      RX_MAX_SERVICES);
1856     return 0;
1857 }
1858
1859 /* Set configuration options for all of a service's security objects */
1860
1861 afs_int32
1862 rx_SetSecurityConfiguration(struct rx_service *service,
1863                             rx_securityConfigVariables type,
1864                             void *value)
1865 {
1866     int i;
1867     for (i = 0; i<service->nSecurityObjects; i++) {
1868         if (service->securityObjects[i]) {
1869             RXS_SetConfiguration(service->securityObjects[i], NULL, type,
1870                                  value, NULL);
1871         }
1872     }
1873     return 0;
1874 }
1875
1876 struct rx_service *
1877 rx_NewService(u_short port, u_short serviceId, char *serviceName,
1878               struct rx_securityClass **securityObjects, int nSecurityObjects,
1879               afs_int32(*serviceProc) (struct rx_call * acall))
1880 {
1881     return rx_NewServiceHost(htonl(INADDR_ANY), port, serviceId, serviceName, securityObjects, nSecurityObjects, serviceProc);
1882 }
1883
1884 /* Generic request processing loop. This routine should be called
1885  * by the implementation dependent rx_ServerProc. If socketp is
1886  * non-null, it will be set to the file descriptor that this thread
1887  * is now listening on. If socketp is null, this routine will never
1888  * returns. */
1889 void
1890 rxi_ServerProc(int threadID, struct rx_call *newcall, osi_socket * socketp)
1891 {
1892     struct rx_call *call;
1893     afs_int32 code;
1894     struct rx_service *tservice = NULL;
1895
1896     for (;;) {
1897         if (newcall) {
1898             call = newcall;
1899             newcall = NULL;
1900         } else {
1901             call = rx_GetCall(threadID, tservice, socketp);
1902             if (socketp && *socketp != OSI_NULLSOCKET) {
1903                 /* We are now a listener thread */
1904                 return;
1905             }
1906         }
1907
1908 #ifdef  KERNEL
1909         if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1910 #ifdef RX_ENABLE_LOCKS
1911             AFS_GLOCK();
1912 #endif /* RX_ENABLE_LOCKS */
1913             afs_termState = AFSOP_STOP_AFS;
1914             afs_osi_Wakeup(&afs_termState);
1915 #ifdef RX_ENABLE_LOCKS
1916             AFS_GUNLOCK();
1917 #endif /* RX_ENABLE_LOCKS */
1918             return;
1919         }
1920 #endif
1921
1922         /* if server is restarting( typically smooth shutdown) then do not
1923          * allow any new calls.
1924          */
1925
1926         if (rx_tranquil && (call != NULL)) {
1927             SPLVAR;
1928
1929             NETPRI;
1930             MUTEX_ENTER(&call->lock);
1931
1932             rxi_CallError(call, RX_RESTARTING);
1933             rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
1934
1935             MUTEX_EXIT(&call->lock);
1936             USERPRI;
1937             continue;
1938         }
1939
1940         tservice = call->conn->service;
1941
1942         if (tservice->beforeProc)
1943             (*tservice->beforeProc) (call);
1944
1945         code = tservice->executeRequestProc(call);
1946
1947         if (tservice->afterProc)
1948             (*tservice->afterProc) (call, code);
1949
1950         rx_EndCall(call, code);
1951
1952         if (tservice->postProc)
1953             (*tservice->postProc) (code);
1954
1955         if (rx_stats_active) {
1956             MUTEX_ENTER(&rx_stats_mutex);
1957             rxi_nCalls++;
1958             MUTEX_EXIT(&rx_stats_mutex);
1959         }
1960     }
1961 }
1962
1963
1964 void
1965 rx_WakeupServerProcs(void)
1966 {
1967     struct rx_serverQueueEntry *np, *tqp;
1968     struct opr_queue *cursor;
1969     SPLVAR;
1970
1971     NETPRI;
1972     MUTEX_ENTER(&rx_serverPool_lock);
1973
1974 #ifdef RX_ENABLE_LOCKS
1975     if (rx_waitForPacket)
1976         CV_BROADCAST(&rx_waitForPacket->cv);
1977 #else /* RX_ENABLE_LOCKS */
1978     if (rx_waitForPacket)
1979         osi_rxWakeup(rx_waitForPacket);
1980 #endif /* RX_ENABLE_LOCKS */
1981     MUTEX_ENTER(&freeSQEList_lock);
1982     for (np = rx_FreeSQEList; np; np = tqp) {
1983         tqp = *(struct rx_serverQueueEntry **)np;
1984 #ifdef RX_ENABLE_LOCKS
1985         CV_BROADCAST(&np->cv);
1986 #else /* RX_ENABLE_LOCKS */
1987         osi_rxWakeup(np);
1988 #endif /* RX_ENABLE_LOCKS */
1989     }
1990     MUTEX_EXIT(&freeSQEList_lock);
1991     for (opr_queue_Scan(&rx_idleServerQueue, cursor)) {
1992         np = opr_queue_Entry(cursor, struct rx_serverQueueEntry, entry);
1993 #ifdef RX_ENABLE_LOCKS
1994         CV_BROADCAST(&np->cv);
1995 #else /* RX_ENABLE_LOCKS */
1996         osi_rxWakeup(np);
1997 #endif /* RX_ENABLE_LOCKS */
1998     }
1999     MUTEX_EXIT(&rx_serverPool_lock);
2000     USERPRI;
2001 }
2002
2003 /* meltdown:
2004  * One thing that seems to happen is that all the server threads get
2005  * tied up on some empty or slow call, and then a whole bunch of calls
2006  * arrive at once, using up the packet pool, so now there are more
2007  * empty calls.  The most critical resources here are server threads
2008  * and the free packet pool.  The "doreclaim" code seems to help in
2009  * general.  I think that eventually we arrive in this state: there
2010  * are lots of pending calls which do have all their packets present,
2011  * so they won't be reclaimed, are multi-packet calls, so they won't
2012  * be scheduled until later, and thus are tying up most of the free
2013  * packet pool for a very long time.
2014  * future options:
2015  * 1.  schedule multi-packet calls if all the packets are present.
2016  * Probably CPU-bound operation, useful to return packets to pool.
2017  * Do what if there is a full window, but the last packet isn't here?
2018  * 3.  preserve one thread which *only* runs "best" calls, otherwise
2019  * it sleeps and waits for that type of call.
2020  * 4.  Don't necessarily reserve a whole window for each thread.  In fact,
2021  * the current dataquota business is badly broken.  The quota isn't adjusted
2022  * to reflect how many packets are presently queued for a running call.
2023  * So, when we schedule a queued call with a full window of packets queued
2024  * up for it, that *should* free up a window full of packets for other 2d-class
2025  * calls to be able to use from the packet pool.  But it doesn't.
2026  *
2027  * NB.  Most of the time, this code doesn't run -- since idle server threads
2028  * sit on the idle server queue and are assigned by "...ReceivePacket" as soon
2029  * as a new call arrives.
2030  */
2031 /* Sleep until a call arrives.  Returns a pointer to the call, ready
2032  * for an rx_Read. */
2033 #ifdef RX_ENABLE_LOCKS
2034 struct rx_call *
2035 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
2036 {
2037     struct rx_serverQueueEntry *sq;
2038     struct rx_call *call = (struct rx_call *)0;
2039     struct rx_service *service = NULL;
2040
2041     MUTEX_ENTER(&freeSQEList_lock);
2042
2043     if ((sq = rx_FreeSQEList)) {
2044         rx_FreeSQEList = *(struct rx_serverQueueEntry **)sq;
2045         MUTEX_EXIT(&freeSQEList_lock);
2046     } else {                    /* otherwise allocate a new one and return that */
2047         MUTEX_EXIT(&freeSQEList_lock);
2048         sq = rxi_Alloc(sizeof(struct rx_serverQueueEntry));
2049         MUTEX_INIT(&sq->lock, "server Queue lock", MUTEX_DEFAULT, 0);
2050         CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
2051     }
2052
2053     MUTEX_ENTER(&rx_serverPool_lock);
2054     if (cur_service != NULL) {
2055         ReturnToServerPool(cur_service);
2056     }
2057     while (1) {
2058         if (!opr_queue_IsEmpty(&rx_incomingCallQueue)) {
2059             struct rx_call *tcall, *choice2 = NULL;
2060             struct opr_queue *cursor;
2061
2062             /* Scan for eligible incoming calls.  A call is not eligible
2063              * if the maximum number of calls for its service type are
2064              * already executing */
2065             /* One thread will process calls FCFS (to prevent starvation),
2066              * while the other threads may run ahead looking for calls which
2067              * have all their input data available immediately.  This helps
2068              * keep threads from blocking, waiting for data from the client. */
2069             for (opr_queue_Scan(&rx_incomingCallQueue, cursor)) {
2070                 tcall = opr_queue_Entry(cursor, struct rx_call, entry);
2071
2072                 service = tcall->conn->service;
2073                 if (!QuotaOK(service)) {
2074                     continue;
2075                 }
2076                 MUTEX_ENTER(&rx_pthread_mutex);
2077                 if (tno == rxi_fcfs_thread_num
2078                         || opr_queue_IsEnd(&rx_incomingCallQueue, cursor)) {
2079                     MUTEX_EXIT(&rx_pthread_mutex);
2080                     /* If we're the fcfs thread , then  we'll just use
2081                      * this call. If we haven't been able to find an optimal
2082                      * choice, and we're at the end of the list, then use a
2083                      * 2d choice if one has been identified.  Otherwise... */
2084                     call = (choice2 ? choice2 : tcall);
2085                     service = call->conn->service;
2086                 } else {
2087                     MUTEX_EXIT(&rx_pthread_mutex);
2088                     if (!opr_queue_IsEmpty(&tcall->rq)) {
2089                         struct rx_packet *rp;
2090                         rp = opr_queue_First(&tcall->rq, struct rx_packet,
2091                                             entry);
2092                         if (rp->header.seq == 1) {
2093                             if (!meltdown_1pkt
2094                                 || (rp->header.flags & RX_LAST_PACKET)) {
2095                                 call = tcall;
2096                             } else if (rxi_2dchoice && !choice2
2097                                        && !(tcall->flags & RX_CALL_CLEARED)
2098                                        && (tcall->rprev > rxi_HardAckRate)) {
2099                                 choice2 = tcall;
2100                             } else
2101                                 rxi_md2cnt++;
2102                         }
2103                     }
2104                 }
2105                 if (call) {
2106                     break;
2107                 } else {
2108                     ReturnToServerPool(service);
2109                 }
2110             }
2111         }
2112
2113         if (call) {
2114             opr_queue_Remove(&call->entry);
2115             MUTEX_EXIT(&rx_serverPool_lock);
2116             MUTEX_ENTER(&call->lock);
2117
2118             if (call->flags & RX_CALL_WAIT_PROC) {
2119                 call->flags &= ~RX_CALL_WAIT_PROC;
2120                 rx_atomic_dec(&rx_nWaiting);
2121             }
2122
2123             if (call->state != RX_STATE_PRECALL || call->error) {
2124                 MUTEX_EXIT(&call->lock);
2125                 MUTEX_ENTER(&rx_serverPool_lock);
2126                 ReturnToServerPool(service);
2127                 call = NULL;
2128                 continue;
2129             }
2130
2131             if (opr_queue_IsEmpty(&call->rq)
2132                 || opr_queue_First(&call->rq, struct rx_packet, entry)->header.seq != 1)
2133                 rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
2134
2135             CLEAR_CALL_QUEUE_LOCK(call);
2136             break;
2137         } else {
2138             /* If there are no eligible incoming calls, add this process
2139              * to the idle server queue, to wait for one */
2140             sq->newcall = 0;
2141             sq->tno = tno;
2142             if (socketp) {
2143                 *socketp = OSI_NULLSOCKET;
2144             }
2145             sq->socketp = socketp;
2146             opr_queue_Append(&rx_idleServerQueue, &sq->entry);
2147 #ifndef AFS_AIX41_ENV
2148             rx_waitForPacket = sq;
2149 #else
2150             rx_waitingForPacket = sq;
2151 #endif /* AFS_AIX41_ENV */
2152             do {
2153                 CV_WAIT(&sq->cv, &rx_serverPool_lock);
2154 #ifdef  KERNEL
2155                 if (afs_termState == AFSOP_STOP_RXCALLBACK) {
2156                     MUTEX_EXIT(&rx_serverPool_lock);
2157                     return (struct rx_call *)0;
2158                 }
2159 #endif
2160             } while (!(call = sq->newcall)
2161                      && !(socketp && *socketp != OSI_NULLSOCKET));
2162             MUTEX_EXIT(&rx_serverPool_lock);
2163             if (call) {
2164                 MUTEX_ENTER(&call->lock);
2165             }
2166             break;
2167         }
2168     }
2169
2170     MUTEX_ENTER(&freeSQEList_lock);
2171     *(struct rx_serverQueueEntry **)sq = rx_FreeSQEList;
2172     rx_FreeSQEList = sq;
2173     MUTEX_EXIT(&freeSQEList_lock);
2174
2175     if (call) {
2176         clock_GetTime(&call->startTime);
2177         call->state = RX_STATE_ACTIVE;
2178         call->mode = RX_MODE_RECEIVING;
2179 #ifdef RX_KERNEL_TRACE
2180         if (ICL_SETACTIVE(afs_iclSetp)) {
2181             int glockOwner = ISAFS_GLOCK();
2182             if (!glockOwner)
2183                 AFS_GLOCK();
2184             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
2185                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
2186                        call);
2187             if (!glockOwner)
2188                 AFS_GUNLOCK();
2189         }
2190 #endif
2191
2192         rxi_calltrace(RX_CALL_START, call);
2193         dpf(("rx_GetCall(port=%d, service=%d) ==> call %"AFS_PTR_FMT"\n",
2194              call->conn->service->servicePort, call->conn->service->serviceId,
2195              call));
2196
2197         MUTEX_EXIT(&call->lock);
2198         CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
2199     } else {
2200         dpf(("rx_GetCall(socketp=%p, *socketp=0x%x)\n", socketp, *socketp));
2201     }
2202
2203     return call;
2204 }
2205 #else /* RX_ENABLE_LOCKS */
2206 struct rx_call *
2207 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
2208 {
2209     struct rx_serverQueueEntry *sq;
2210     struct rx_call *call = (struct rx_call *)0, *choice2;
2211     struct rx_service *service = NULL;
2212     SPLVAR;
2213
2214     NETPRI;
2215     MUTEX_ENTER(&freeSQEList_lock);
2216
2217     if ((sq = rx_FreeSQEList)) {
2218         rx_FreeSQEList = *(struct rx_serverQueueEntry **)sq;
2219         MUTEX_EXIT(&freeSQEList_lock);
2220     } else {                    /* otherwise allocate a new one and return that */
2221         MUTEX_EXIT(&freeSQEList_lock);
2222         sq = rxi_Alloc(sizeof(struct rx_serverQueueEntry));
2223         MUTEX_INIT(&sq->lock, "server Queue lock", MUTEX_DEFAULT, 0);
2224         CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
2225     }
2226     MUTEX_ENTER(&sq->lock);
2227
2228     if (cur_service != NULL) {
2229         cur_service->nRequestsRunning--;
2230         MUTEX_ENTER(&rx_quota_mutex);
2231         if (cur_service->nRequestsRunning < cur_service->minProcs)
2232             rxi_minDeficit++;
2233         rxi_availProcs++;
2234         MUTEX_EXIT(&rx_quota_mutex);
2235     }
2236     if (!opr_queue_IsEmpty(&rx_incomingCallQueue)) {
2237         struct rx_call *tcall;
2238         struct opr_queue *cursor;
2239         /* Scan for eligible incoming calls.  A call is not eligible
2240          * if the maximum number of calls for its service type are
2241          * already executing */
2242         /* One thread will process calls FCFS (to prevent starvation),
2243          * while the other threads may run ahead looking for calls which
2244          * have all their input data available immediately.  This helps
2245          * keep threads from blocking, waiting for data from the client. */
2246         choice2 = (struct rx_call *)0;
2247         for (opr_queue_Scan(&rx_incomingCallQueue, cursor)) {
2248             tcall = opr_queue_Entry(cursor, struct rx_call, entry);
2249             service = tcall->conn->service;
2250             if (QuotaOK(service)) {
2251                 MUTEX_ENTER(&rx_pthread_mutex);
2252                 /* XXX - If tcall->entry.next is NULL, then we're no longer
2253                  * on a queue at all. This shouldn't happen. */
2254                 if (tno == rxi_fcfs_thread_num || !tcall->entry.next) {
2255                     MUTEX_EXIT(&rx_pthread_mutex);
2256                     /* If we're the fcfs thread, then  we'll just use
2257                      * this call. If we haven't been able to find an optimal
2258                      * choice, and we're at the end of the list, then use a
2259                      * 2d choice if one has been identified.  Otherwise... */
2260                     call = (choice2 ? choice2 : tcall);
2261                     service = call->conn->service;
2262                 } else {
2263                     MUTEX_EXIT(&rx_pthread_mutex);
2264                     if (!opr_queue_IsEmpty(&tcall->rq)) {
2265                         struct rx_packet *rp;
2266                         rp = opr_queue_First(&tcall->rq, struct rx_packet,
2267                                             entry);
2268                         if (rp->header.seq == 1
2269                             && (!meltdown_1pkt
2270                                 || (rp->header.flags & RX_LAST_PACKET))) {
2271                             call = tcall;
2272                         } else if (rxi_2dchoice && !choice2
2273                                    && !(tcall->flags & RX_CALL_CLEARED)
2274                                    && (tcall->rprev > rxi_HardAckRate)) {
2275                             choice2 = tcall;
2276                         } else
2277                             rxi_md2cnt++;
2278                     }
2279                 }
2280             }
2281             if (call)
2282                 break;
2283         }
2284     }
2285
2286     if (call) {
2287         opr_queue_Remove(&call->entry);
2288         /* we can't schedule a call if there's no data!!! */
2289         /* send an ack if there's no data, if we're missing the
2290          * first packet, or we're missing something between first
2291          * and last -- there's a "hole" in the incoming data. */
2292         if (opr_queue_IsEmpty(&call->rq)
2293             || opr_queue_First(&call->rq, struct rx_packet, entry)->header.seq != 1
2294             || call->rprev != opr_queue_Last(&call->rq, struct rx_packet, entry)->header.seq)
2295             rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
2296
2297         call->flags &= (~RX_CALL_WAIT_PROC);
2298         service->nRequestsRunning++;
2299         /* just started call in minProcs pool, need fewer to maintain
2300          * guarantee */
2301         MUTEX_ENTER(&rx_quota_mutex);
2302         if (service->nRequestsRunning <= service->minProcs)
2303             rxi_minDeficit--;
2304         rxi_availProcs--;
2305         MUTEX_EXIT(&rx_quota_mutex);
2306         rx_atomic_dec(&rx_nWaiting);
2307         /* MUTEX_EXIT(&call->lock); */
2308     } else {
2309         /* If there are no eligible incoming calls, add this process
2310          * to the idle server queue, to wait for one */
2311         sq->newcall = 0;
2312         if (socketp) {
2313             *socketp = OSI_NULLSOCKET;
2314         }
2315         sq->socketp = socketp;
2316         opr_queue_Append(&rx_idleServerQueue, &sq->entry);
2317         do {
2318             osi_rxSleep(sq);
2319 #ifdef  KERNEL
2320             if (afs_termState == AFSOP_STOP_RXCALLBACK) {
2321                 USERPRI;
2322                 rxi_Free(sq, sizeof(struct rx_serverQueueEntry));
2323                 return (struct rx_call *)0;
2324             }
2325 #endif
2326         } while (!(call = sq->newcall)
2327                  && !(socketp && *socketp != OSI_NULLSOCKET));
2328     }
2329     MUTEX_EXIT(&sq->lock);
2330
2331     MUTEX_ENTER(&freeSQEList_lock);
2332     *(struct rx_serverQueueEntry **)sq = rx_FreeSQEList;
2333     rx_FreeSQEList = sq;
2334     MUTEX_EXIT(&freeSQEList_lock);
2335
2336     if (call) {
2337         clock_GetTime(&call->startTime);
2338         call->state = RX_STATE_ACTIVE;
2339         call->mode = RX_MODE_RECEIVING;
2340 #ifdef RX_KERNEL_TRACE
2341         if (ICL_SETACTIVE(afs_iclSetp)) {
2342             int glockOwner = ISAFS_GLOCK();
2343             if (!glockOwner)
2344                 AFS_GLOCK();
2345             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
2346                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
2347                        call);
2348             if (!glockOwner)
2349                 AFS_GUNLOCK();
2350         }
2351 #endif
2352
2353         rxi_calltrace(RX_CALL_START, call);
2354         dpf(("rx_GetCall(port=%d, service=%d) ==> call %p\n",
2355              call->conn->service->servicePort, call->conn->service->serviceId,
2356              call));
2357     } else {
2358         dpf(("rx_GetCall(socketp=%p, *socketp=0x%x)\n", socketp, *socketp));
2359     }
2360
2361     USERPRI;
2362
2363     return call;
2364 }
2365 #endif /* RX_ENABLE_LOCKS */
2366
2367
2368
2369 /* Establish a procedure to be called when a packet arrives for a
2370  * call.  This routine will be called at most once after each call,
2371  * and will also be called if there is an error condition on the or
2372  * the call is complete.  Used by multi rx to build a selection
2373  * function which determines which of several calls is likely to be a
2374  * good one to read from.
2375  * NOTE: the way this is currently implemented it is probably only a
2376  * good idea to (1) use it immediately after a newcall (clients only)
2377  * and (2) only use it once.  Other uses currently void your warranty
2378  */
2379 void
2380 rx_SetArrivalProc(struct rx_call *call,
2381                   void (*proc) (struct rx_call * call,
2382                                         void * mh,
2383                                         int index),
2384                   void * handle, int arg)
2385 {
2386     call->arrivalProc = proc;
2387     call->arrivalProcHandle = handle;
2388     call->arrivalProcArg = arg;
2389 }
2390
2391 /* Call is finished (possibly prematurely).  Return rc to the peer, if
2392  * appropriate, and return the final error code from the conversation
2393  * to the caller */
2394
2395 afs_int32
2396 rx_EndCall(struct rx_call *call, afs_int32 rc)
2397 {
2398     struct rx_connection *conn = call->conn;
2399     afs_int32 error;
2400     SPLVAR;
2401
2402     dpf(("rx_EndCall(call %"AFS_PTR_FMT" rc %d error %d abortCode %d)\n",
2403           call, rc, call->error, call->abortCode));
2404
2405     NETPRI;
2406     MUTEX_ENTER(&call->lock);
2407
2408     if (rc == 0 && call->error == 0) {
2409         call->abortCode = 0;
2410         call->abortCount = 0;
2411     }
2412
2413     call->arrivalProc = (void (*)())0;
2414     if (rc && call->error == 0) {
2415         rxi_CallError(call, rc);
2416         call->mode = RX_MODE_ERROR;
2417         /* Send an abort message to the peer if this error code has
2418          * only just been set.  If it was set previously, assume the
2419          * peer has already been sent the error code or will request it
2420          */
2421         rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
2422     }
2423     if (conn->type == RX_SERVER_CONNECTION) {
2424         /* Make sure reply or at least dummy reply is sent */
2425         if (call->mode == RX_MODE_RECEIVING) {
2426             MUTEX_EXIT(&call->lock);
2427             rxi_WriteProc(call, 0, 0);
2428             MUTEX_ENTER(&call->lock);
2429         }
2430         if (call->mode == RX_MODE_SENDING) {
2431             MUTEX_EXIT(&call->lock);
2432             rxi_FlushWrite(call);
2433             MUTEX_ENTER(&call->lock);
2434         }
2435         rxi_calltrace(RX_CALL_END, call);
2436         /* Call goes to hold state until reply packets are acknowledged */
2437         if (call->tfirst + call->nSoftAcked < call->tnext) {
2438             call->state = RX_STATE_HOLD;
2439         } else {
2440             call->state = RX_STATE_DALLY;
2441             rxi_ClearTransmitQueue(call, 0);
2442             rxi_rto_cancel(call);
2443             rxevent_Cancel(&call->keepAliveEvent, call,
2444                            RX_CALL_REFCOUNT_ALIVE);
2445         }
2446     } else {                    /* Client connection */
2447         char dummy;
2448         /* Make sure server receives input packets, in the case where
2449          * no reply arguments are expected */
2450         if ((call->mode == RX_MODE_SENDING)
2451             || (call->mode == RX_MODE_RECEIVING && call->rnext == 1)) {
2452             MUTEX_EXIT(&call->lock);
2453             (void)rxi_ReadProc(call, &dummy, 1);
2454             MUTEX_ENTER(&call->lock);
2455         }
2456
2457         /* If we had an outstanding delayed ack, be nice to the server
2458          * and force-send it now.
2459          */
2460         if (call->delayedAckEvent) {
2461             rxevent_Cancel(&call->delayedAckEvent, call,
2462                            RX_CALL_REFCOUNT_DELAY);
2463             rxi_SendDelayedAck(NULL, call, NULL, 0);
2464         }
2465
2466         /* We need to release the call lock since it's lower than the
2467          * conn_call_lock and we don't want to hold the conn_call_lock
2468          * over the rx_ReadProc call. The conn_call_lock needs to be held
2469          * here for the case where rx_NewCall is perusing the calls on
2470          * the connection structure. We don't want to signal until
2471          * rx_NewCall is in a stable state. Otherwise, rx_NewCall may
2472          * have checked this call, found it active and by the time it
2473          * goes to sleep, will have missed the signal.
2474          */
2475         MUTEX_EXIT(&call->lock);
2476         MUTEX_ENTER(&conn->conn_call_lock);
2477         MUTEX_ENTER(&call->lock);
2478
2479         if (!(call->flags & RX_CALL_PEER_BUSY)) {
2480             conn->lastBusy[call->channel] = 0;
2481         }
2482
2483         MUTEX_ENTER(&conn->conn_data_lock);
2484         conn->flags |= RX_CONN_BUSY;
2485         if (conn->flags & RX_CONN_MAKECALL_WAITING) {
2486             MUTEX_EXIT(&conn->conn_data_lock);
2487 #ifdef  RX_ENABLE_LOCKS
2488             CV_BROADCAST(&conn->conn_call_cv);
2489 #else
2490             osi_rxWakeup(conn);
2491 #endif
2492         }
2493 #ifdef RX_ENABLE_LOCKS
2494         else {
2495             MUTEX_EXIT(&conn->conn_data_lock);
2496         }
2497 #endif /* RX_ENABLE_LOCKS */
2498         call->state = RX_STATE_DALLY;
2499     }
2500     error = call->error;
2501
2502     /* currentPacket, nLeft, and NFree must be zeroed here, because
2503      * ResetCall cannot: ResetCall may be called at splnet(), in the
2504      * kernel version, and may interrupt the macros rx_Read or
2505      * rx_Write, which run at normal priority for efficiency. */
2506     if (call->currentPacket) {
2507 #ifdef RX_TRACK_PACKETS
2508         call->currentPacket->flags &= ~RX_PKTFLAG_CP;
2509 #endif
2510         rxi_FreePacket(call->currentPacket);
2511         call->currentPacket = (struct rx_packet *)0;
2512     }
2513
2514     call->nLeft = call->nFree = call->curlen = 0;
2515
2516     /* Free any packets from the last call to ReadvProc/WritevProc */
2517 #ifdef RXDEBUG_PACKET
2518     call->iovqc -=
2519 #endif /* RXDEBUG_PACKET */
2520         rxi_FreePackets(0, &call->iovq);
2521     MUTEX_EXIT(&call->lock);
2522
2523     CALL_RELE(call, RX_CALL_REFCOUNT_BEGIN);
2524     if (conn->type == RX_CLIENT_CONNECTION) {
2525         MUTEX_ENTER(&conn->conn_data_lock);
2526         conn->flags &= ~RX_CONN_BUSY;
2527         MUTEX_EXIT(&conn->conn_data_lock);
2528         MUTEX_EXIT(&conn->conn_call_lock);
2529     }
2530     USERPRI;
2531     /*
2532      * Map errors to the local host's errno.h format.
2533      */
2534     error = ntoh_syserr_conv(error);
2535     return error;
2536 }
2537
2538 #if !defined(KERNEL)
2539
2540 /* Call this routine when shutting down a server or client (especially
2541  * clients).  This will allow Rx to gracefully garbage collect server
2542  * connections, and reduce the number of retries that a server might
2543  * make to a dead client.
2544  * This is not quite right, since some calls may still be ongoing and
2545  * we can't lock them to destroy them. */
2546 void
2547 rx_Finalize(void)
2548 {
2549     struct rx_connection **conn_ptr, **conn_end;
2550
2551     INIT_PTHREAD_LOCKS;
2552     LOCK_RX_INIT;
2553     if (rxinit_status == 1) {
2554         UNLOCK_RX_INIT;
2555         return;                 /* Already shutdown. */
2556     }
2557     rxi_DeleteCachedConnections();
2558     if (rx_connHashTable) {
2559         MUTEX_ENTER(&rx_connHashTable_lock);
2560         for (conn_ptr = &rx_connHashTable[0], conn_end =
2561              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
2562              conn_ptr++) {
2563             struct rx_connection *conn, *next;
2564             for (conn = *conn_ptr; conn; conn = next) {
2565                 next = conn->next;
2566                 if (conn->type == RX_CLIENT_CONNECTION) {
2567                     MUTEX_ENTER(&rx_refcnt_mutex);
2568                     conn->refCount++;
2569                     MUTEX_EXIT(&rx_refcnt_mutex);
2570 #ifdef RX_ENABLE_LOCKS
2571                     rxi_DestroyConnectionNoLock(conn);
2572 #else /* RX_ENABLE_LOCKS */
2573                     rxi_DestroyConnection(conn);
2574 #endif /* RX_ENABLE_LOCKS */
2575                 }
2576             }
2577         }
2578 #ifdef RX_ENABLE_LOCKS
2579         while (rx_connCleanup_list) {
2580             struct rx_connection *conn;
2581             conn = rx_connCleanup_list;
2582             rx_connCleanup_list = rx_connCleanup_list->next;
2583             MUTEX_EXIT(&rx_connHashTable_lock);
2584             rxi_CleanupConnection(conn);
2585             MUTEX_ENTER(&rx_connHashTable_lock);
2586         }
2587         MUTEX_EXIT(&rx_connHashTable_lock);
2588 #endif /* RX_ENABLE_LOCKS */
2589     }
2590     rxi_flushtrace();
2591
2592 #ifdef AFS_NT40_ENV
2593     afs_winsockCleanup();
2594 #endif
2595
2596     rxinit_status = 1;
2597     UNLOCK_RX_INIT;
2598 }
2599 #endif
2600
2601 /* if we wakeup packet waiter too often, can get in loop with two
2602     AllocSendPackets each waking each other up (from ReclaimPacket calls) */
2603 void
2604 rxi_PacketsUnWait(void)
2605 {
2606     if (!rx_waitingForPackets) {
2607         return;
2608     }
2609 #ifdef KERNEL
2610     if (rxi_OverQuota(RX_PACKET_CLASS_SEND)) {
2611         return;                 /* still over quota */
2612     }
2613 #endif /* KERNEL */
2614     rx_waitingForPackets = 0;
2615 #ifdef  RX_ENABLE_LOCKS
2616     CV_BROADCAST(&rx_waitingForPackets_cv);
2617 #else
2618     osi_rxWakeup(&rx_waitingForPackets);
2619 #endif
2620     return;
2621 }
2622
2623
2624 /* ------------------Internal interfaces------------------------- */
2625
2626 /* Return this process's service structure for the
2627  * specified socket and service */
2628 static struct rx_service *
2629 rxi_FindService(osi_socket socket, u_short serviceId)
2630 {
2631     struct rx_service **sp;
2632     for (sp = &rx_services[0]; *sp; sp++) {
2633         if ((*sp)->serviceId == serviceId && (*sp)->socket == socket)
2634             return *sp;
2635     }
2636     return 0;
2637 }
2638
2639 #ifdef RXDEBUG_PACKET
2640 #ifdef KDUMP_RX_LOCK
2641 static struct rx_call_rx_lock *rx_allCallsp = 0;
2642 #else
2643 static struct rx_call *rx_allCallsp = 0;
2644 #endif
2645 #endif /* RXDEBUG_PACKET */
2646
2647 /* Allocate a call structure, for the indicated channel of the
2648  * supplied connection.  The mode and state of the call must be set by
2649  * the caller. Returns the call with mutex locked. */
2650 static struct rx_call *
2651 rxi_NewCall(struct rx_connection *conn, int channel)
2652 {
2653     struct rx_call *call;
2654 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2655     struct rx_call *cp; /* Call pointer temp */
2656     struct opr_queue *cursor;
2657 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2658
2659     dpf(("rxi_NewCall(conn %"AFS_PTR_FMT", channel %d)\n", conn, channel));
2660
2661     /* Grab an existing call structure, or allocate a new one.
2662      * Existing call structures are assumed to have been left reset by
2663      * rxi_FreeCall */
2664     MUTEX_ENTER(&rx_freeCallQueue_lock);
2665
2666 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2667     /*
2668      * EXCEPT that the TQ might not yet be cleared out.
2669      * Skip over those with in-use TQs.
2670      */
2671     call = NULL;
2672     for (opr_queue_Scan(&rx_freeCallQueue, cursor)) {
2673         cp = opr_queue_Entry(cursor, struct rx_call, entry);
2674         if (!(cp->flags & RX_CALL_TQ_BUSY)) {
2675             call = cp;
2676             break;
2677         }
2678     }
2679     if (call) {
2680 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2681     if (!opr_queue_IsEmpty(&rx_freeCallQueue)) {
2682         call = opr_queue_First(&rx_freeCallQueue, struct rx_call, entry);
2683 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2684         opr_queue_Remove(&call->entry);
2685         if (rx_stats_active)
2686             rx_atomic_dec(&rx_stats.nFreeCallStructs);
2687         MUTEX_EXIT(&rx_freeCallQueue_lock);
2688         MUTEX_ENTER(&call->lock);
2689         CLEAR_CALL_QUEUE_LOCK(call);
2690 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2691         /* Now, if TQ wasn't cleared earlier, do it now. */
2692         rxi_WaitforTQBusy(call);
2693         if (call->flags & RX_CALL_TQ_CLEARME) {
2694             rxi_ClearTransmitQueue(call, 1);
2695             /*queue_Init(&call->tq);*/
2696         }
2697 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2698         /* Bind the call to its connection structure */
2699         call->conn = conn;
2700         rxi_ResetCall(call, 1);
2701     } else {
2702
2703         call = rxi_Alloc(sizeof(struct rx_call));
2704 #ifdef RXDEBUG_PACKET
2705         call->allNextp = rx_allCallsp;
2706         rx_allCallsp = call;
2707         call->call_id =
2708             rx_atomic_inc_and_read(&rx_stats.nCallStructs);
2709 #else /* RXDEBUG_PACKET */
2710         rx_atomic_inc(&rx_stats.nCallStructs);
2711 #endif /* RXDEBUG_PACKET */
2712
2713         MUTEX_EXIT(&rx_freeCallQueue_lock);
2714         MUTEX_INIT(&call->lock, "call lock", MUTEX_DEFAULT, NULL);
2715         MUTEX_ENTER(&call->lock);
2716         CV_INIT(&call->cv_twind, "call twind", CV_DEFAULT, 0);
2717         CV_INIT(&call->cv_rq, "call rq", CV_DEFAULT, 0);
2718         CV_INIT(&call->cv_tq, "call tq", CV_DEFAULT, 0);
2719
2720         /* Initialize once-only items */
2721         opr_queue_Init(&call->tq);
2722         opr_queue_Init(&call->rq);
2723         opr_queue_Init(&call->iovq);
2724 #ifdef RXDEBUG_PACKET
2725         call->rqc = call->tqc = call->iovqc = 0;
2726 #endif /* RXDEBUG_PACKET */
2727         /* Bind the call to its connection structure (prereq for reset) */
2728         call->conn = conn;
2729         rxi_ResetCall(call, 1);
2730     }
2731     call->channel = channel;
2732     call->callNumber = &conn->callNumber[channel];
2733     call->rwind = conn->rwind[channel];
2734     call->twind = conn->twind[channel];
2735     /* Note that the next expected call number is retained (in
2736      * conn->callNumber[i]), even if we reallocate the call structure
2737      */
2738     conn->call[channel] = call;
2739     /* if the channel's never been used (== 0), we should start at 1, otherwise
2740      * the call number is valid from the last time this channel was used */
2741     if (*call->callNumber == 0)
2742         *call->callNumber = 1;
2743
2744     return call;
2745 }
2746
2747 /* A call has been inactive long enough that so we can throw away
2748  * state, including the call structure, which is placed on the call
2749  * free list.
2750  *
2751  * call->lock amd rx_refcnt_mutex are held upon entry.
2752  * haveCTLock is set when called from rxi_ReapConnections.
2753  *
2754  * return 1 if the call is freed, 0 if not.
2755  */
2756 static int
2757 rxi_FreeCall(struct rx_call *call, int haveCTLock)
2758 {
2759     int channel = call->channel;
2760     struct rx_connection *conn = call->conn;
2761     u_char state = call->state;
2762
2763     /*
2764      * We are setting the state to RX_STATE_RESET to
2765      * ensure that no one else will attempt to use this
2766      * call once we drop the refcnt lock. We must drop
2767      * the refcnt lock before calling rxi_ResetCall
2768      * because it cannot be held across acquiring the
2769      * freepktQ lock. NewCall does the same.
2770      */
2771     call->state = RX_STATE_RESET;
2772     MUTEX_EXIT(&rx_refcnt_mutex);
2773     rxi_ResetCall(call, 0);
2774
2775     if (MUTEX_TRYENTER(&conn->conn_call_lock))
2776     {
2777         if (state == RX_STATE_DALLY || state == RX_STATE_HOLD)
2778             (*call->callNumber)++;
2779
2780         if (call->conn->call[channel] == call)
2781             call->conn->call[channel] = 0;
2782         MUTEX_EXIT(&conn->conn_call_lock);
2783     } else {
2784         /*
2785          * We couldn't obtain the conn_call_lock so we can't
2786          * disconnect the call from the connection.  Set the
2787          * call state to dally so that the call can be reused.
2788          */
2789         MUTEX_ENTER(&rx_refcnt_mutex);
2790         call->state = RX_STATE_DALLY;
2791         return 0;
2792     }
2793
2794     MUTEX_ENTER(&rx_freeCallQueue_lock);
2795     SET_CALL_QUEUE_LOCK(call, &rx_freeCallQueue_lock);
2796 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
2797     /* A call may be free even though its transmit queue is still in use.
2798      * Since we search the call list from head to tail, put busy calls at
2799      * the head of the list, and idle calls at the tail.
2800      */
2801     if (call->flags & RX_CALL_TQ_BUSY)
2802         opr_queue_Prepend(&rx_freeCallQueue, &call->entry);
2803     else
2804         opr_queue_Append(&rx_freeCallQueue, &call->entry);
2805 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2806     opr_queue_Append(&rx_freeCallQueue, &call->entry);
2807 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2808     if (rx_stats_active)
2809         rx_atomic_inc(&rx_stats.nFreeCallStructs);
2810     MUTEX_EXIT(&rx_freeCallQueue_lock);
2811
2812     /* Destroy the connection if it was previously slated for
2813      * destruction, i.e. the Rx client code previously called
2814      * rx_DestroyConnection (client connections), or
2815      * rxi_ReapConnections called the same routine (server
2816      * connections).  Only do this, however, if there are no
2817      * outstanding calls. Note that for fine grain locking, there appears
2818      * to be a deadlock in that rxi_FreeCall has a call locked and
2819      * DestroyConnectionNoLock locks each call in the conn. But note a
2820      * few lines up where we have removed this call from the conn.
2821      * If someone else destroys a connection, they either have no
2822      * call lock held or are going through this section of code.
2823      */
2824     MUTEX_ENTER(&conn->conn_data_lock);
2825     if (conn->flags & RX_CONN_DESTROY_ME && !(conn->flags & RX_CONN_MAKECALL_WAITING)) {
2826         MUTEX_ENTER(&rx_refcnt_mutex);
2827         conn->refCount++;
2828         MUTEX_EXIT(&rx_refcnt_mutex);
2829         MUTEX_EXIT(&conn->conn_data_lock);
2830 #ifdef RX_ENABLE_LOCKS
2831         if (haveCTLock)
2832             rxi_DestroyConnectionNoLock(conn);
2833         else
2834             rxi_DestroyConnection(conn);
2835 #else /* RX_ENABLE_LOCKS */
2836         rxi_DestroyConnection(conn);
2837 #endif /* RX_ENABLE_LOCKS */
2838     } else {
2839         MUTEX_EXIT(&conn->conn_data_lock);
2840     }
2841     MUTEX_ENTER(&rx_refcnt_mutex);
2842     return 1;
2843 }
2844
2845 rx_atomic_t rxi_Allocsize = RX_ATOMIC_INIT(0);
2846 rx_atomic_t rxi_Alloccnt = RX_ATOMIC_INIT(0);
2847
2848 void *
2849 rxi_Alloc(size_t size)
2850 {
2851     char *p;
2852
2853     if (rx_stats_active) {
2854         rx_atomic_add(&rxi_Allocsize, (int) size);
2855         rx_atomic_inc(&rxi_Alloccnt);
2856     }
2857
2858 p = (char *)
2859 #if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
2860   afs_osi_Alloc_NoSleep(size);
2861 #else
2862   osi_Alloc(size);
2863 #endif
2864     if (!p)
2865         osi_Panic("rxi_Alloc error");
2866     memset(p, 0, size);
2867     return p;
2868 }
2869
2870 void
2871 rxi_Free(void *addr, size_t size)
2872 {
2873     if (rx_stats_active) {
2874         rx_atomic_sub(&rxi_Allocsize, (int) size);
2875         rx_atomic_dec(&rxi_Alloccnt);
2876     }
2877     osi_Free(addr, size);
2878 }
2879
2880 void
2881 rxi_SetPeerMtu(struct rx_peer *peer, afs_uint32 host, afs_uint32 port, int mtu)
2882 {
2883     struct rx_peer **peer_ptr = NULL, **peer_end = NULL;
2884     struct rx_peer *next = NULL;
2885     int hashIndex;
2886
2887     if (!peer) {
2888         MUTEX_ENTER(&rx_peerHashTable_lock);
2889         if (port == 0) {
2890             peer_ptr = &rx_peerHashTable[0];
2891             peer_end = &rx_peerHashTable[rx_hashTableSize];
2892             next = NULL;
2893         resume:
2894             for ( ; peer_ptr < peer_end; peer_ptr++) {
2895                 if (!peer)
2896                     peer = *peer_ptr;
2897                 for ( ; peer; peer = next) {
2898                     next = peer->next;
2899                     if (host == peer->host)
2900                         break;
2901                 }
2902             }
2903         } else {
2904             hashIndex = PEER_HASH(host, port);
2905             for (peer = rx_peerHashTable[hashIndex]; peer; peer = peer->next) {
2906                 if ((peer->host == host) && (peer->port == port))
2907                     break;
2908             }
2909         }
2910     } else {
2911         MUTEX_ENTER(&rx_peerHashTable_lock);
2912     }
2913
2914     if (peer) {
2915         peer->refCount++;
2916         MUTEX_EXIT(&rx_peerHashTable_lock);
2917
2918         MUTEX_ENTER(&peer->peer_lock);
2919         /* We don't handle dropping below min, so don't */
2920         mtu = MAX(mtu, RX_MIN_PACKET_SIZE);
2921         peer->ifMTU=MIN(mtu, peer->ifMTU);
2922         peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
2923         /* if we tweaked this down, need to tune our peer MTU too */
2924         peer->MTU = MIN(peer->MTU, peer->natMTU);
2925         /* if we discovered a sub-1500 mtu, degrade */
2926         if (peer->ifMTU < OLD_MAX_PACKET_SIZE)
2927             peer->maxDgramPackets = 1;
2928         /* We no longer have valid peer packet information */
2929         if (peer->maxPacketSize-RX_IPUDP_SIZE > peer->ifMTU)
2930             peer->maxPacketSize = 0;
2931         MUTEX_EXIT(&peer->peer_lock);
2932
2933         MUTEX_ENTER(&rx_peerHashTable_lock);
2934         peer->refCount--;
2935         if (host && !port) {
2936             peer = next;
2937             /* pick up where we left off */
2938             goto resume;
2939         }
2940     }
2941     MUTEX_EXIT(&rx_peerHashTable_lock);
2942 }
2943
2944 #ifdef AFS_RXERRQ_ENV
2945 static void
2946 rxi_SetPeerDead(afs_uint32 host, afs_uint16 port)
2947 {
2948     int hashIndex = PEER_HASH(host, port);
2949     struct rx_peer *peer;
2950
2951     MUTEX_ENTER(&rx_peerHashTable_lock);
2952
2953     for (peer = rx_peerHashTable[hashIndex]; peer; peer = peer->next) {
2954         if (peer->host == host && peer->port == port) {
2955             break;
2956         }
2957     }
2958
2959     if (peer) {
2960         rx_atomic_inc(&peer->neterrs);
2961     }
2962
2963     MUTEX_EXIT(&rx_peerHashTable_lock);
2964 }
2965
2966 void
2967 rxi_ProcessNetError(struct sock_extended_err *err, afs_uint32 addr, afs_uint16 port)
2968 {
2969 # ifdef AFS_ADAPT_PMTU
2970     if (err->ee_errno == EMSGSIZE && err->ee_info >= 68) {
2971         rxi_SetPeerMtu(NULL, addr, port, err->ee_info - RX_IPUDP_SIZE);
2972         return;
2973     }
2974 # endif
2975     if (err->ee_origin == SO_EE_ORIGIN_ICMP && err->ee_type == ICMP_DEST_UNREACH) {
2976         switch (err->ee_code) {
2977         case ICMP_NET_UNREACH:
2978         case ICMP_HOST_UNREACH:
2979         case ICMP_PORT_UNREACH:
2980         case ICMP_NET_ANO:
2981         case ICMP_HOST_ANO:
2982             rxi_SetPeerDead(addr, port);
2983             break;
2984         }
2985     }
2986 }
2987 #endif /* AFS_RXERRQ_ENV */
2988
2989 /* Find the peer process represented by the supplied (host,port)
2990  * combination.  If there is no appropriate active peer structure, a
2991  * new one will be allocated and initialized
2992  * The origPeer, if set, is a pointer to a peer structure on which the
2993  * refcount will be be decremented. This is used to replace the peer
2994  * structure hanging off a connection structure */
2995 struct rx_peer *
2996 rxi_FindPeer(afs_uint32 host, u_short port,
2997              struct rx_peer *origPeer, int create)
2998 {
2999     struct rx_peer *pp;
3000     int hashIndex;
3001     hashIndex = PEER_HASH(host, port);
3002     MUTEX_ENTER(&rx_peerHashTable_lock);
3003     for (pp = rx_peerHashTable[hashIndex]; pp; pp = pp->next) {
3004         if ((pp->host == host) && (pp->port == port))
3005             break;
3006     }
3007     if (!pp) {
3008         if (create) {
3009             pp = rxi_AllocPeer();       /* This bzero's *pp */
3010             pp->host = host;    /* set here or in InitPeerParams is zero */
3011             pp->port = port;
3012 #ifdef AFS_RXERRQ_ENV
3013             rx_atomic_set(&pp->neterrs, 0);
3014 #endif
3015             MUTEX_INIT(&pp->peer_lock, "peer_lock", MUTEX_DEFAULT, 0);
3016             opr_queue_Init(&pp->rpcStats);
3017             pp->next = rx_peerHashTable[hashIndex];
3018             rx_peerHashTable[hashIndex] = pp;
3019             rxi_InitPeerParams(pp);
3020             if (rx_stats_active)
3021                 rx_atomic_inc(&rx_stats.nPeerStructs);
3022         }
3023     }
3024     if (pp && create) {
3025         pp->refCount++;
3026     }
3027     if (origPeer)
3028         origPeer->refCount--;
3029     MUTEX_EXIT(&rx_peerHashTable_lock);
3030     return pp;
3031 }
3032
3033
3034 /* Find the connection at (host, port) started at epoch, and with the
3035  * given connection id.  Creates the server connection if necessary.
3036  * The type specifies whether a client connection or a server
3037  * connection is desired.  In both cases, (host, port) specify the
3038  * peer's (host, pair) pair.  Client connections are not made
3039  * automatically by this routine.  The parameter socket gives the
3040  * socket descriptor on which the packet was received.  This is used,
3041  * in the case of server connections, to check that *new* connections
3042  * come via a valid (port, serviceId).  Finally, the securityIndex
3043  * parameter must match the existing index for the connection.  If a
3044  * server connection is created, it will be created using the supplied
3045  * index, if the index is valid for this service */
3046 static struct rx_connection *
3047 rxi_FindConnection(osi_socket socket, afs_uint32 host,
3048                    u_short port, u_short serviceId, afs_uint32 cid,
3049                    afs_uint32 epoch, int type, u_int securityIndex)
3050 {
3051     int hashindex, flag, i;
3052     struct rx_connection *conn;
3053     hashindex = CONN_HASH(host, port, cid, epoch, type);
3054     MUTEX_ENTER(&rx_connHashTable_lock);
3055     rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
3056                                                   rx_connHashTable[hashindex],
3057                                                   flag = 1);
3058     for (; conn;) {
3059         if ((conn->type == type) && ((cid & RX_CIDMASK) == conn->cid)
3060             && (epoch == conn->epoch)) {
3061             struct rx_peer *pp = conn->peer;
3062             if (securityIndex != conn->securityIndex) {
3063                 /* this isn't supposed to happen, but someone could forge a packet
3064                  * like this, and there seems to be some CM bug that makes this
3065                  * happen from time to time -- in which case, the fileserver
3066                  * asserts. */
3067                 MUTEX_EXIT(&rx_connHashTable_lock);
3068                 return (struct rx_connection *)0;
3069             }
3070             if (pp->host == host && pp->port == port)
3071                 break;
3072             if (type == RX_CLIENT_CONNECTION && pp->port == port)
3073                 break;
3074             /* So what happens when it's a callback connection? */
3075             if (                /*type == RX_CLIENT_CONNECTION && */
3076                    (conn->epoch & 0x80000000))
3077                 break;
3078         }
3079         if (!flag) {
3080             /* the connection rxLastConn that was used the last time is not the
3081              ** one we are looking for now. Hence, start searching in the hash */
3082             flag = 1;
3083             conn = rx_connHashTable[hashindex];
3084         } else
3085             conn = conn->next;
3086     }
3087     if (!conn) {
3088         struct rx_service *service;
3089         if (type == RX_CLIENT_CONNECTION) {
3090             MUTEX_EXIT(&rx_connHashTable_lock);
3091             return (struct rx_connection *)0;
3092         }
3093         service = rxi_FindService(socket, serviceId);
3094         if (!service || (securityIndex >= service->nSecurityObjects)
3095             || (service->securityObjects[securityIndex] == 0)) {
3096             MUTEX_EXIT(&rx_connHashTable_lock);
3097             return (struct rx_connection *)0;
3098         }
3099         conn = rxi_AllocConnection();   /* This bzero's the connection */
3100         MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
3101         MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
3102         CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
3103         conn->next = rx_connHashTable[hashindex];
3104         rx_connHashTable[hashindex] = conn;
3105         conn->peer = rxi_FindPeer(host, port, 0, 1);
3106         conn->type = RX_SERVER_CONNECTION;
3107         conn->lastSendTime = clock_Sec();       /* don't GC immediately */
3108         conn->epoch = epoch;
3109         conn->cid = cid & RX_CIDMASK;
3110         conn->ackRate = RX_FAST_ACK_RATE;
3111         conn->service = service;
3112         conn->serviceId = serviceId;
3113         conn->securityIndex = securityIndex;
3114         conn->securityObject = service->securityObjects[securityIndex];
3115         conn->nSpecific = 0;
3116         conn->specific = NULL;
3117         rx_SetConnDeadTime(conn, service->connDeadTime);
3118         conn->idleDeadTime = service->idleDeadTime;
3119         conn->idleDeadDetection = service->idleDeadErr ? 1 : 0;
3120         for (i = 0; i < RX_MAXCALLS; i++) {
3121             conn->twind[i] = rx_initSendWindow;
3122             conn->rwind[i] = rx_initReceiveWindow;
3123         }
3124         /* Notify security object of the new connection */
3125         RXS_NewConnection(conn->securityObject, conn);
3126         /* XXXX Connection timeout? */
3127         if (service->newConnProc)
3128             (*service->newConnProc) (conn);
3129         if (rx_stats_active)
3130             rx_atomic_inc(&rx_stats.nServerConns);
3131     }
3132
3133     MUTEX_ENTER(&rx_refcnt_mutex);
3134     conn->refCount++;
3135     MUTEX_EXIT(&rx_refcnt_mutex);
3136
3137     rxLastConn = conn;          /* store this connection as the last conn used */
3138     MUTEX_EXIT(&rx_connHashTable_lock);
3139     return conn;
3140 }
3141
3142 /**
3143  * Timeout a call on a busy call channel if appropriate.
3144  *
3145  * @param[in] call The busy call.
3146  *
3147  * @pre 'call' is marked as busy (namely,
3148  *      call->conn->lastBusy[call->channel] != 0)
3149  *
3150  * @pre call->lock is held
3151  * @pre rxi_busyChannelError is nonzero
3152  *
3153  * @note call->lock is dropped and reacquired
3154  */
3155 static void
3156 rxi_CheckBusy(struct rx_call *call)
3157 {
3158     struct rx_connection *conn = call->conn;
3159     int channel = call->channel;
3160     int freechannel = 0;
3161     int i;
3162     afs_uint32 callNumber;
3163
3164     MUTEX_EXIT(&call->lock);
3165
3166     MUTEX_ENTER(&conn->conn_call_lock);
3167     callNumber = *call->callNumber;
3168
3169     /* Are there any other call slots on this conn that we should try? Look for
3170      * slots that are empty and are either non-busy, or were marked as busy
3171      * longer than conn->secondsUntilDead seconds before this call started. */
3172
3173     for (i = 0; i < RX_MAXCALLS && !freechannel; i++) {
3174         if (i == channel) {
3175             /* only look at channels that aren't us */
3176             continue;
3177         }
3178
3179         if (conn->lastBusy[i]) {
3180             /* if this channel looked busy too recently, don't look at it */
3181             if (conn->lastBusy[i] >= call->startTime.sec) {
3182                 continue;
3183             }
3184             if (call->startTime.sec - conn->lastBusy[i] < conn->secondsUntilDead) {
3185                 continue;
3186             }
3187         }
3188
3189         if (conn->call[i]) {
3190             struct rx_call *tcall = conn->call[i];
3191             MUTEX_ENTER(&tcall->lock);
3192             if (tcall->state == RX_STATE_DALLY) {
3193                 freechannel = 1;
3194             }
3195             MUTEX_EXIT(&tcall->lock);
3196         } else {
3197             freechannel = 1;
3198         }
3199     }
3200
3201     MUTEX_ENTER(&call->lock);
3202
3203     /* Since the call->lock and conn->conn_call_lock have been released it is
3204      * possible that (1) the call may no longer be busy and/or (2) the call may
3205      * have been reused by another waiting thread. Therefore, we must confirm
3206      * that the call state has not changed when deciding whether or not to
3207      * force this application thread to retry by forcing a Timeout error. */
3208
3209     if (freechannel && *call->callNumber == callNumber &&
3210         (call->flags & RX_CALL_PEER_BUSY)) {
3211         /* Since 'freechannel' is set, there exists another channel in this
3212          * rx_conn that the application thread might be able to use. We know
3213          * that we have the correct call since callNumber is unchanged, and we
3214          * know that the call is still busy. So, set the call error state to
3215          * rxi_busyChannelError so the application can retry the request,
3216          * presumably on a less-busy call channel. */
3217
3218         rxi_CallError(call, RX_CALL_BUSY);
3219     }
3220     MUTEX_EXIT(&conn->conn_call_lock);
3221 }
3222
3223 /* There are two packet tracing routines available for testing and monitoring
3224  * Rx.  One is called just after every packet is received and the other is
3225  * called just before every packet is sent.  Received packets, have had their
3226  * headers decoded, and packets to be sent have not yet had their headers
3227  * encoded.  Both take two parameters: a pointer to the packet and a sockaddr
3228  * containing the network address.  Both can be modified.  The return value, if
3229  * non-zero, indicates that the packet should be dropped.  */
3230
3231 int (*rx_justReceived) (struct rx_packet *, struct sockaddr_in *) = 0;
3232 int (*rx_almostSent) (struct rx_packet *, struct sockaddr_in *) = 0;
3233
3234 /* A packet has been received off the interface.  Np is the packet, socket is
3235  * the socket number it was received from (useful in determining which service
3236  * this packet corresponds to), and (host, port) reflect the host,port of the
3237  * sender.  This call returns the packet to the caller if it is finished with
3238  * it, rather than de-allocating it, just as a small performance hack */
3239
3240 struct rx_packet *
3241 rxi_ReceivePacket(struct rx_packet *np, osi_socket socket,
3242                   afs_uint32 host, u_short port, int *tnop,
3243                   struct rx_call **newcallp)
3244 {
3245     struct rx_call *call;
3246     struct rx_connection *conn;
3247     int channel;
3248     afs_uint32 currentCallNumber;
3249     int type;
3250 #ifdef RXDEBUG
3251     char *packetType;
3252 #endif
3253     struct rx_packet *tnp;
3254
3255 #ifdef RXDEBUG
3256 /* We don't print out the packet until now because (1) the time may not be
3257  * accurate enough until now in the lwp implementation (rx_Listener only gets
3258  * the time after the packet is read) and (2) from a protocol point of view,
3259  * this is the first time the packet has been seen */
3260     packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
3261         ? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
3262     dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %"AFS_PTR_FMT"\n",
3263          np->header.serial, packetType, ntohl(host), ntohs(port), np->header.serviceId,
3264          np->header.epoch, np->header.cid, np->header.callNumber,
3265          np->header.seq, np->header.flags, np));
3266 #endif
3267
3268     /* Account for connectionless packets */
3269     if (rx_stats_active &&
3270         ((np->header.type == RX_PACKET_TYPE_VERSION) ||
3271          (np->header.type == RX_PACKET_TYPE_DEBUG))) {
3272         struct rx_peer *peer;
3273
3274         /* Try to look up the peer structure, but don't create one */
3275         peer = rxi_FindPeer(host, port, 0, 0);
3276
3277         /* Since this may not be associated with a connection, it may have
3278          * no refCount, meaning we could race with ReapConnections
3279          */
3280
3281         if (peer && (peer->refCount > 0)) {
3282 #ifdef AFS_RXERRQ_ENV
3283             if (rx_atomic_read(&peer->neterrs)) {
3284                 rx_atomic_set(&peer->neterrs, 0);
3285             }
3286 #endif
3287             MUTEX_ENTER(&peer->peer_lock);
3288             peer->bytesReceived += np->length;
3289             MUTEX_EXIT(&peer->peer_lock);
3290         }
3291     }
3292
3293     if (np->header.type == RX_PACKET_TYPE_VERSION) {
3294         return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
3295     }
3296
3297     if (np->header.type == RX_PACKET_TYPE_DEBUG) {
3298         return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
3299     }
3300 #ifdef RXDEBUG
3301     /* If an input tracer function is defined, call it with the packet and
3302      * network address.  Note this function may modify its arguments. */
3303     if (rx_justReceived) {
3304         struct sockaddr_in addr;
3305         int drop;
3306         addr.sin_family = AF_INET;
3307         addr.sin_port = port;
3308         addr.sin_addr.s_addr = host;
3309 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
3310         addr.sin_len = sizeof(addr);
3311 #endif /* AFS_OSF_ENV */
3312         drop = (*rx_justReceived) (np, &addr);
3313         /* drop packet if return value is non-zero */
3314         if (drop)
3315             return np;
3316         port = addr.sin_port;   /* in case fcn changed addr */
3317         host = addr.sin_addr.s_addr;
3318     }
3319 #endif
3320
3321     /* If packet was not sent by the client, then *we* must be the client */
3322     type = ((np->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED)
3323         ? RX_CLIENT_CONNECTION : RX_SERVER_CONNECTION;
3324
3325     /* Find the connection (or fabricate one, if we're the server & if
3326      * necessary) associated with this packet */
3327     conn =
3328         rxi_FindConnection(socket, host, port, np->header.serviceId,
3329                            np->header.cid, np->header.epoch, type,
3330                            np->header.securityIndex);
3331
3332     /* To avoid having 2 connections just abort at each other,
3333        don't abort an abort. */
3334     if (!conn) {
3335         if (np->header.type != RX_PACKET_TYPE_ABORT)
3336             rxi_SendRawAbort(socket, host, port, RX_INVALID_OPERATION,
3337                              np, 0);
3338         return np;
3339     }
3340
3341 #ifdef AFS_RXERRQ_ENV
3342     if (rx_atomic_read(&conn->peer->neterrs)) {
3343         rx_atomic_set(&conn->peer->neterrs, 0);
3344     }
3345 #endif
3346
3347     /* If we're doing statistics, then account for the incoming packet */
3348     if (rx_stats_active) {
3349         MUTEX_ENTER(&conn->peer->peer_lock);
3350         conn->peer->bytesReceived += np->length;
3351         MUTEX_EXIT(&conn->peer->peer_lock);
3352     }
3353
3354     /* If the connection is in an error state, send an abort packet and ignore
3355      * the incoming packet */
3356     if (conn->error) {
3357         /* Don't respond to an abort packet--we don't want loops! */
3358         MUTEX_ENTER(&conn->conn_data_lock);
3359         if (np->header.type != RX_PACKET_TYPE_ABORT)
3360             np = rxi_SendConnectionAbort(conn, np, 1, 0);
3361         putConnection(conn);
3362         MUTEX_EXIT(&conn->conn_data_lock);
3363         return np;
3364     }
3365
3366     /* Check for connection-only requests (i.e. not call specific). */
3367     if (np->header.callNumber == 0) {
3368         switch (np->header.type) {
3369         case RX_PACKET_TYPE_ABORT: {
3370             /* What if the supplied error is zero? */
3371             afs_int32 errcode = ntohl(rx_GetInt32(np, 0));
3372             dpf(("rxi_ReceivePacket ABORT rx_GetInt32 = %d\n", errcode));
3373             rxi_ConnectionError(conn, errcode);
3374             putConnection(conn);
3375             return np;
3376         }
3377         case RX_PACKET_TYPE_CHALLENGE:
3378             tnp = rxi_ReceiveChallengePacket(conn, np, 1);
3379             putConnection(conn);
3380             return tnp;
3381         case RX_PACKET_TYPE_RESPONSE:
3382             tnp = rxi_ReceiveResponsePacket(conn, np, 1);
3383             putConnection(conn);
3384             return tnp;
3385         case RX_PACKET_TYPE_PARAMS:
3386         case RX_PACKET_TYPE_PARAMS + 1:
3387         case RX_PACKET_TYPE_PARAMS + 2:
3388             /* ignore these packet types for now */
3389             putConnection(conn);
3390             return np;
3391
3392         default:
3393             /* Should not reach here, unless the peer is broken: send an
3394              * abort packet */
3395             rxi_ConnectionError(conn, RX_PROTOCOL_ERROR);
3396             MUTEX_ENTER(&conn->conn_data_lock);
3397             tnp = rxi_SendConnectionAbort(conn, np, 1, 0);
3398             putConnection(conn);
3399             MUTEX_EXIT(&conn->conn_data_lock);
3400             return tnp;
3401         }
3402     }
3403
3404     channel = np->header.cid & RX_CHANNELMASK;
3405     MUTEX_ENTER(&conn->conn_call_lock);
3406     call = conn->call[channel];
3407
3408     if (call) {
3409         MUTEX_ENTER(&call->lock);
3410         currentCallNumber = conn->callNumber[channel];
3411         MUTEX_EXIT(&conn->conn_call_lock);
3412     } else if (type == RX_SERVER_CONNECTION) {  /* No call allocated */
3413         call = conn->call[channel];
3414         if (call) {
3415             MUTEX_ENTER(&call->lock);
3416             currentCallNumber = conn->callNumber[channel];
3417             MUTEX_EXIT(&conn->conn_call_lock);
3418         } else {
3419             call = rxi_NewCall(conn, channel);  /* returns locked call */
3420             *call->callNumber = currentCallNumber = np->header.callNumber;
3421             MUTEX_EXIT(&conn->conn_call_lock);
3422 #ifdef RXDEBUG
3423             if (np->header.callNumber == 0)
3424                 dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %"AFS_PTR_FMT" len %d\n",
3425                      np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port),
3426                      np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq,
3427                      np->header.flags, np, np->length));
3428 #endif
3429             call->state = RX_STATE_PRECALL;
3430             clock_GetTime(&call->queueTime);
3431             call->bytesSent = 0;
3432             call->bytesRcvd = 0;
3433             /*
3434              * If the number of queued calls exceeds the overload
3435              * threshold then abort this call.
3436              */
3437             if ((rx_BusyThreshold > 0) &&
3438                 (rx_atomic_read(&rx_nWaiting) > rx_BusyThreshold)) {
3439                 struct rx_packet *tp;
3440
3441                 rxi_CallError(call, rx_BusyError);
3442                 tp = rxi_SendCallAbort(call, np, 1, 0);
3443                 MUTEX_EXIT(&call->lock);
3444                 putConnection(conn);
3445                 if (rx_stats_active)
3446                     rx_atomic_inc(&rx_stats.nBusies);
3447                 return tp;
3448             }
3449             rxi_KeepAliveOn(call);
3450         }
3451     } else {    /* RX_CLIENT_CONNECTION and No call allocated */
3452         /* This packet can't be for this call. If the new call address is
3453          * 0 then no call is running on this channel. If there is a call
3454          * then, since this is a client connection we're getting data for
3455          * it must be for the previous call.
3456          */
3457         MUTEX_EXIT(&conn->conn_call_lock);
3458         if (rx_stats_active)
3459             rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3460         putConnection(conn);
3461         return np;
3462     }
3463
3464     /* There is a non-NULL locked call at this point */
3465     if (type == RX_SERVER_CONNECTION) { /* We're the server */
3466         if (np->header.callNumber < currentCallNumber) {
3467             MUTEX_EXIT(&call->lock);
3468             if (rx_stats_active)
3469                 rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3470             putConnection(conn);
3471             return np;
3472         } else if (np->header.callNumber != currentCallNumber) {
3473             /* Wait until the transmit queue is idle before deciding
3474              * whether to reset the current call. Chances are that the
3475              * call will be in ether DALLY or HOLD state once the TQ_BUSY
3476              * flag is cleared.
3477              */
3478 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
3479             if (call->state == RX_STATE_ACTIVE) {
3480                 rxi_WaitforTQBusy(call);
3481                 /*
3482                  * If we entered error state while waiting,
3483                  * must call rxi_CallError to permit rxi_ResetCall
3484                  * to processed when the tqWaiter count hits zero.
3485                  */
3486                 if (call->error) {
3487                     rxi_CallError(call, call->error);
3488                     MUTEX_EXIT(&call->lock);
3489                     putConnection(conn);
3490                     return np;
3491                 }
3492             }
3493 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3494             /* If the new call cannot be taken right now send a busy and set
3495              * the error condition in this call, so that it terminates as
3496              * quickly as possible */
3497             if (call->state == RX_STATE_ACTIVE) {
3498                 struct rx_packet *tp;
3499
3500                 rxi_CallError(call, RX_CALL_DEAD);
3501                 tp = rxi_SendSpecial(call, conn, np, RX_PACKET_TYPE_BUSY,
3502                                      NULL, 0, 1);
3503                 MUTEX_EXIT(&call->lock);
3504                 putConnection(conn);
3505                 return tp;
3506             }
3507             rxi_ResetCall(call, 0);
3508             /*
3509              * The conn_call_lock is not held but no one else should be
3510              * using this call channel while we are processing this incoming
3511              * packet.  This assignment should be safe.
3512              */
3513             *call->callNumber = np->header.callNumber;
3514 #ifdef RXDEBUG
3515             if (np->header.callNumber == 0)
3516                 dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %"AFS_PTR_FMT" len %d\n",
3517                       np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port),
3518                       np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq,
3519                       np->header.flags, np, np->length));
3520 #endif
3521             call->state = RX_STATE_PRECALL;
3522             clock_GetTime(&call->queueTime);
3523             call->bytesSent = 0;
3524             call->bytesRcvd = 0;
3525             /*
3526              * If the number of queued calls exceeds the overload
3527              * threshold then abort this call.
3528              */
3529             if ((rx_BusyThreshold > 0) &&
3530                 (rx_atomic_read(&rx_nWaiting) > rx_BusyThreshold)) {
3531                 struct rx_packet *tp;
3532
3533                 rxi_CallError(call, rx_BusyError);
3534                 tp = rxi_SendCallAbort(call, np, 1, 0);
3535                 MUTEX_EXIT(&call->lock);
3536                 putConnection(conn);
3537                 if (rx_stats_active)
3538                     rx_atomic_inc(&rx_stats.nBusies);
3539                 return tp;
3540             }
3541             rxi_KeepAliveOn(call);
3542         } else {
3543             /* Continuing call; do nothing here. */
3544         }
3545     } else {                    /* we're the client */
3546         /* Ignore all incoming acknowledgements for calls in DALLY state */
3547         if ((call->state == RX_STATE_DALLY)
3548             && (np->header.type == RX_PACKET_TYPE_ACK)) {
3549             if (rx_stats_active)
3550                 rx_atomic_inc(&rx_stats.ignorePacketDally);
3551             MUTEX_EXIT(&call->lock);
3552             putConnection(conn);
3553             return np;
3554         }
3555
3556         /* Ignore anything that's not relevant to the current call.  If there
3557          * isn't a current call, then no packet is relevant. */
3558         if (np->header.callNumber != currentCallNumber) {
3559             if (rx_stats_active)
3560                 rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3561             MUTEX_EXIT(&call->lock);
3562             putConnection(conn);
3563             return np;
3564         }
3565         /* If the service security object index stamped in the packet does not
3566          * match the connection's security index, ignore the packet */
3567         if (np->header.securityIndex != conn->securityIndex) {
3568             MUTEX_EXIT(&call->lock);
3569             putConnection(conn);
3570             return np;
3571         }
3572
3573         /* If we're receiving the response, then all transmit packets are
3574          * implicitly acknowledged.  Get rid of them. */
3575         if (np->header.type == RX_PACKET_TYPE_DATA) {
3576 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3577             /* XXX Hack. Because we must release the global rx lock when
3578              * sending packets (osi_NetSend) we drop all acks while we're
3579              * traversing the tq in rxi_Start sending packets out because
3580              * packets may move to the freePacketQueue as result of being here!
3581              * So we drop these packets until we're safely out of the
3582              * traversing. Really ugly!
3583              * For fine grain RX locking, we set the acked field in the
3584              * packets and let rxi_Start remove them from the transmit queue.
3585              */
3586             if (call->flags & RX_CALL_TQ_BUSY) {
3587 #ifdef  RX_ENABLE_LOCKS
3588                 rxi_SetAcksInTransmitQueue(call);
3589 #else
3590                 putConnection(conn);
3591                 return np;      /* xmitting; drop packet */
3592 #endif
3593             } else {
3594                 rxi_ClearTransmitQueue(call, 0);
3595             }
3596 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
3597             rxi_ClearTransmitQueue(call, 0);
3598 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3599         } else {
3600             if (np->header.type == RX_PACKET_TYPE_ACK) {
3601                 /* now check to see if this is an ack packet acknowledging that the
3602                  * server actually *lost* some hard-acked data.  If this happens we
3603                  * ignore this packet, as it may indicate that the server restarted in
3604                  * the middle of a call.  It is also possible that this is an old ack
3605                  * packet.  We don't abort the connection in this case, because this
3606                  * *might* just be an old ack packet.  The right way to detect a server
3607                  * restart in the midst of a call is to notice that the server epoch
3608                  * changed, btw.  */
3609                 /* XXX I'm not sure this is exactly right, since tfirst **IS**
3610                  * XXX unacknowledged.  I think that this is off-by-one, but
3611                  * XXX I don't dare change it just yet, since it will
3612                  * XXX interact badly with the server-restart detection
3613                  * XXX code in receiveackpacket.  */
3614                 if (ntohl(rx_GetInt32(np, FIRSTACKOFFSET)) < call->tfirst) {
3615                     if (rx_stats_active)
3616                         rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3617                     MUTEX_EXIT(&call->lock);
3618                     putConnection(conn);
3619                     return np;
3620                 }
3621             }
3622         }                       /* else not a data packet */
3623     }
3624
3625     osirx_AssertMine(&call->lock, "rxi_ReceivePacket middle");
3626     /* Set remote user defined status from packet */
3627     call->remoteStatus = np->header.userStatus;
3628
3629     /* Now do packet type-specific processing */
3630     switch (np->header.type) {
3631     case RX_PACKET_TYPE_DATA:
3632         np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
3633                                    newcallp);
3634         break;
3635     case RX_PACKET_TYPE_ACK:
3636         /* Respond immediately to ack packets requesting acknowledgement
3637          * (ping packets) */
3638         if (np->header.flags & RX_REQUEST_ACK) {
3639             if (call->error)
3640                 (void)rxi_SendCallAbort(call, 0, 1, 0);
3641             else
3642                 (void)rxi_SendAck(call, 0, np->header.serial,
3643                                   RX_ACK_PING_RESPONSE, 1);
3644         }
3645         np = rxi_ReceiveAckPacket(call, np, 1);
3646         break;
3647     case RX_PACKET_TYPE_ABORT: {
3648         /* An abort packet: reset the call, passing the error up to the user. */
3649         /* What if error is zero? */
3650         /* What if the error is -1? the application will treat it as a timeout. */
3651         afs_int32 errdata = ntohl(*(afs_int32 *) rx_DataOf(np));
3652         dpf(("rxi_ReceivePacket ABORT rx_DataOf = %d\n", errdata));
3653         rxi_CallError(call, errdata);
3654         MUTEX_EXIT(&call->lock);
3655         putConnection(conn);
3656         return np;              /* xmitting; drop packet */
3657     }
3658     case RX_PACKET_TYPE_BUSY: {
3659         struct clock busyTime;
3660         clock_NewTime();
3661         clock_GetTime(&busyTime);
3662
3663         MUTEX_EXIT(&call->lock);
3664
3665         MUTEX_ENTER(&conn->conn_call_lock);
3666         MUTEX_ENTER(&call->lock);
3667         conn->lastBusy[call->channel] = busyTime.sec;
3668         call->flags |= RX_CALL_PEER_BUSY;
3669         MUTEX_EXIT(&call->lock);
3670         MUTEX_EXIT(&conn->conn_call_lock);
3671
3672         putConnection(conn);
3673         return np;
3674     }
3675
3676     case RX_PACKET_TYPE_ACKALL:
3677         /* All packets acknowledged, so we can drop all packets previously
3678          * readied for sending */
3679 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3680         /* XXX Hack. We because we can't release the global rx lock when
3681          * sending packets (osi_NetSend) we drop all ack pkts while we're
3682          * traversing the tq in rxi_Start sending packets out because
3683          * packets may move to the freePacketQueue as result of being
3684          * here! So we drop these packets until we're safely out of the
3685          * traversing. Really ugly!
3686          * For fine grain RX locking, we set the acked field in the packets
3687          * and let rxi_Start remove the packets from the transmit queue.
3688          */
3689         if (call->flags & RX_CALL_TQ_BUSY) {
3690 #ifdef  RX_ENABLE_LOCKS
3691             rxi_SetAcksInTransmitQueue(call);
3692             break;
3693 #else /* RX_ENABLE_LOCKS */
3694             MUTEX_EXIT(&call->lock);
3695             putConnection(conn);
3696             return np;          /* xmitting; drop packet */
3697 #endif /* RX_ENABLE_LOCKS */
3698         }
3699 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3700         rxi_ClearTransmitQueue(call, 0);
3701         break;
3702     default:
3703         /* Should not reach here, unless the peer is broken: send an abort
3704          * packet */
3705         rxi_CallError(call, RX_PROTOCOL_ERROR);
3706         np = rxi_SendCallAbort(call, np, 1, 0);
3707         break;
3708     };
3709     /* Note when this last legitimate packet was received, for keep-alive
3710      * processing.  Note, we delay getting the time until now in the hope that
3711      * the packet will be delivered to the user before any get time is required
3712      * (if not, then the time won't actually be re-evaluated here). */
3713     call->lastReceiveTime = clock_Sec();
3714     /* we've received a legit packet, so the channel is not busy */
3715     call->flags &= ~RX_CALL_PEER_BUSY;
3716     MUTEX_EXIT(&call->lock);
3717     putConnection(conn);
3718     return np;
3719 }
3720
3721 /* return true if this is an "interesting" connection from the point of view
3722     of someone trying to debug the system */
3723 int
3724 rxi_IsConnInteresting(struct rx_connection *aconn)
3725 {
3726     int i;
3727     struct rx_call *tcall;
3728
3729     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
3730         return 1;
3731
3732     for (i = 0; i < RX_MAXCALLS; i++) {
3733         tcall = aconn->call[i];
3734         if (tcall) {
3735             if ((tcall->state == RX_STATE_PRECALL)
3736                 || (tcall->state == RX_STATE_ACTIVE))
3737                 return 1;
3738             if ((tcall->mode == RX_MODE_SENDING)
3739                 || (tcall->mode == RX_MODE_RECEIVING))
3740                 return 1;
3741         }
3742     }
3743     return 0;
3744 }
3745
3746 #ifdef KERNEL
3747 /* if this is one of the last few packets AND it wouldn't be used by the
3748    receiving call to immediately satisfy a read request, then drop it on
3749    the floor, since accepting it might prevent a lock-holding thread from
3750    making progress in its reading. If a call has been cleared while in
3751    the precall state then ignore all subsequent packets until the call
3752    is assigned to a thread. */
3753
3754 static int
3755 TooLow(struct rx_packet *ap, struct rx_call *acall)
3756 {
3757     int rc = 0;
3758
3759     MUTEX_ENTER(&rx_quota_mutex);
3760     if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
3761          && (acall->state == RX_STATE_PRECALL))
3762         || ((rx_nFreePackets < rxi_dataQuota + 2)
3763             && !((ap->header.seq < acall->rnext + rx_initSendWindow)
3764                  && (acall->flags & RX_CALL_READER_WAIT)))) {
3765         rc = 1;
3766     }
3767     MUTEX_EXIT(&rx_quota_mutex);
3768     return rc;
3769 }
3770 #endif /* KERNEL */
3771
3772 /*!
3773  * Clear the attach wait flag on a connection and proceed.
3774  *
3775  * Any processing waiting for a connection to be attached should be
3776  * unblocked. We clear the flag and do any other needed tasks.
3777  *
3778  * @param[in] conn
3779  *      the conn to unmark waiting for attach
3780  *
3781  * @pre conn's conn_data_lock must be locked before calling this function
3782  *
3783  */
3784 static void
3785 rxi_ConnClearAttachWait(struct rx_connection *conn)
3786 {
3787     /* Indicate that rxi_CheckReachEvent is no longer running by
3788      * clearing the flag.  Must be atomic under conn_data_lock to
3789      * avoid a new call slipping by: rxi_CheckConnReach holds
3790      * conn_data_lock while checking RX_CONN_ATTACHWAIT.
3791      */
3792     conn->flags &= ~RX_CONN_ATTACHWAIT;
3793     if (conn->flags & RX_CONN_NAT_PING) {
3794         conn->flags &= ~RX_CONN_NAT_PING;
3795         rxi_ScheduleNatKeepAliveEvent(conn);
3796     }
3797 }
3798
3799 static void
3800 rxi_CheckReachEvent(struct rxevent *event, void *arg1, void *arg2, int dummy)
3801 {
3802     struct rx_connection *conn = arg1;
3803     struct rx_call *acall = arg2;
3804     struct rx_call *call = acall;
3805     struct clock when, now;
3806     int i, waiting;
3807
3808     MUTEX_ENTER(&conn->conn_data_lock);
3809
3810     if (event) {
3811         rxevent_Put(conn->checkReachEvent);
3812         conn->checkReachEvent = NULL;
3813     }
3814
3815     waiting = conn->flags & RX_CONN_ATTACHWAIT;
3816     if (event) {
3817         putConnection(conn);
3818     }
3819     MUTEX_EXIT(&conn->conn_data_lock);
3820
3821     if (waiting) {
3822         if (!call) {
3823             MUTEX_ENTER(&conn->conn_call_lock);
3824             MUTEX_ENTER(&conn->conn_data_lock);
3825             for (i = 0; i < RX_MAXCALLS; i++) {
3826                 struct rx_call *tc = conn->call[i];
3827                 if (tc && tc->state == RX_STATE_PRECALL) {
3828                     call = tc;
3829                     break;
3830                 }
3831             }
3832             if (!call)
3833                 rxi_ConnClearAttachWait(conn);
3834             MUTEX_EXIT(&conn->conn_data_lock);
3835             MUTEX_EXIT(&conn->conn_call_lock);
3836         }
3837
3838         if (call) {
3839             if (call != acall)
3840                 MUTEX_ENTER(&call->lock);
3841             rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
3842             if (call != acall)
3843                 MUTEX_EXIT(&call->lock);
3844
3845             clock_GetTime(&now);
3846             when = now;
3847             when.sec += RX_CHECKREACH_TIMEOUT;
3848             MUTEX_ENTER(&conn->conn_data_lock);
3849             if (!conn->checkReachEvent) {
3850                 MUTEX_ENTER(&rx_refcnt_mutex);
3851                 conn->refCount++;
3852                 MUTEX_EXIT(&rx_refcnt_mutex);
3853                 conn->checkReachEvent = rxevent_Post(&when, &now,
3854                                                      rxi_CheckReachEvent, conn,
3855                                                      NULL, 0);
3856             }
3857             MUTEX_EXIT(&conn->conn_data_lock);
3858         }
3859     }
3860 }
3861
3862 static int
3863 rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
3864 {
3865     struct rx_service *service = conn->service;
3866     struct rx_peer *peer = conn->peer;
3867     afs_uint32 now, lastReach;
3868
3869     if (service->checkReach == 0)
3870         return 0;
3871
3872     now = clock_Sec();
3873     MUTEX_ENTER(&peer->peer_lock);
3874     lastReach = peer->lastReachTime;
3875     MUTEX_EXIT(&peer->peer_lock);
3876     if (now - lastReach < RX_CHECKREACH_TTL)
3877         return 0;
3878
3879     MUTEX_ENTER(&conn->conn_data_lock);
3880     if (conn->flags & RX_CONN_ATTACHWAIT) {
3881         MUTEX_EXIT(&conn->conn_data_lock);
3882         return 1;
3883     }
3884     conn->flags |= RX_CONN_ATTACHWAIT;
3885     MUTEX_EXIT(&conn->conn_data_lock);
3886     if (!conn->checkReachEvent)
3887         rxi_CheckReachEvent(NULL, conn, call, 0);
3888
3889     return 1;
3890 }
3891
3892 /* try to attach call, if authentication is complete */
3893 static void
3894 TryAttach(struct rx_call *acall, osi_socket socket,
3895           int *tnop, struct rx_call **newcallp,
3896           int reachOverride)
3897 {
3898     struct rx_connection *conn = acall->conn;
3899
3900     if (conn->type == RX_SERVER_CONNECTION
3901         && acall->state == RX_STATE_PRECALL) {
3902         /* Don't attach until we have any req'd. authentication. */
3903         if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
3904             if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
3905                 rxi_AttachServerProc(acall, socket, tnop, newcallp);
3906             /* Note:  this does not necessarily succeed; there
3907              * may not any proc available
3908              */
3909         } else {
3910             rxi_ChallengeOn(acall->conn);
3911         }
3912     }
3913 }
3914
3915 /* A data packet has been received off the interface.  This packet is
3916  * appropriate to the call (the call is in the right state, etc.).  This
3917  * routine can return a packet to the caller, for re-use */
3918
3919 static struct rx_packet *
3920 rxi_ReceiveDataPacket(struct rx_call *call,
3921                       struct rx_packet *np, int istack,
3922                       osi_socket socket, afs_uint32 host, u_short port,
3923                       int *tnop, struct rx_call **newcallp)
3924 {
3925     int ackNeeded = 0;          /* 0 means no, otherwise ack_reason */
3926     int newPackets = 0;
3927     int didHardAck = 0;
3928     int haveLast = 0;
3929     afs_uint32 seq;
3930     afs_uint32 serial=0, flags=0;
3931     int isFirst;
3932     struct rx_packet *tnp;
3933     if (rx_stats_active)
3934         rx_atomic_inc(&rx_stats.dataPacketsRead);
3935
3936 #ifdef KERNEL
3937     /* If there are no packet buffers, drop this new packet, unless we can find
3938      * packet buffers from inactive calls */
3939     if (!call->error
3940         && (rxi_OverQuota(RX_PACKET_CLASS_RECEIVE) || TooLow(np, call))) {
3941         MUTEX_ENTER(&rx_freePktQ_lock);
3942         rxi_NeedMorePackets = TRUE;
3943         MUTEX_EXIT(&rx_freePktQ_lock);
3944         if (rx_stats_active)
3945             rx_atomic_inc(&rx_stats.noPacketBuffersOnRead);
3946         rxi_calltrace(RX_TRACE_DROP, call);
3947         dpf(("packet %"AFS_PTR_FMT" dropped on receipt - quota problems\n", np));
3948         /* We used to clear the receive queue here, in an attempt to free
3949          * packets. However this is unsafe if the queue has received a
3950          * soft ACK for the final packet */
3951         rxi_PostDelayedAckEvent(call, &rx_softAckDelay);
3952         return np;
3953     }
3954 #endif /* KERNEL */
3955
3956     /*
3957      * New in AFS 3.5, if the RX_JUMBO_PACKET flag is set then this
3958      * packet is one of several packets transmitted as a single
3959      * datagram. Do not send any soft or hard acks until all packets
3960      * in a jumbogram have been processed. Send negative acks right away.
3961      */
3962     for (isFirst = 1, tnp = NULL; isFirst || tnp; isFirst = 0) {
3963         /* tnp is non-null when there are more packets in the
3964          * current jumbo gram */
3965         if (tnp) {
3966             if (np)
3967                 rxi_FreePacket(np);
3968             np = tnp;
3969         }
3970
3971         seq = np->header.seq;
3972         serial = np->header.serial;
3973         flags = np->header.flags;
3974
3975         /* If the call is in an error state, send an abort message */
3976         if (call->error)
3977             return rxi_SendCallAbort(call, np, istack, 0);
3978
3979         /* The RX_JUMBO_PACKET is set in all but the last packet in each
3980          * AFS 3.5 jumbogram. */
3981         if (flags & RX_JUMBO_PACKET) {
3982             tnp = rxi_SplitJumboPacket(np, host, port, isFirst);
3983         } else {
3984             tnp = NULL;
3985         }
3986
3987         if (np->header.spare != 0) {
3988             MUTEX_ENTER(&call->conn->conn_data_lock);
3989             call->conn->flags |= RX_CONN_USING_PACKET_CKSUM;
3990             MUTEX_EXIT(&call->conn->conn_data_lock);
3991         }
3992
3993         /* The usual case is that this is the expected next packet */
3994         if (seq == call->rnext) {
3995
3996             /* Check to make sure it is not a duplicate of one already queued */
3997             if (!opr_queue_IsEmpty(&call->rq)
3998                 && opr_queue_First(&call->rq, struct rx_packet, entry)->header.seq == seq) {
3999                 if (rx_stats_active)
4000                     rx_atomic_inc(&rx_stats.dupPacketsRead);
4001                 dpf(("packet %"AFS_PTR_FMT" dropped on receipt - duplicate\n", np));
4002                 rxevent_Cancel(&call->delayedAckEvent, call,
4003                                RX_CALL_REFCOUNT_DELAY);
4004                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
4005                 ackNeeded = 0;
4006                 call->rprev = seq;
4007                 continue;
4008             }
4009
4010             /* It's the next packet. Stick it on the receive queue
4011              * for this call. Set newPackets to make sure we wake
4012              * the reader once all packets have been processed */
4013 #ifdef RX_TRACK_PACKETS
4014             np->flags |= RX_PKTFLAG_RQ;
4015 #endif
4016             opr_queue_Prepend(&call->rq, &np->entry);
4017 #ifdef RXDEBUG_PACKET
4018             call->rqc++;
4019 #endif /* RXDEBUG_PACKET */
4020             call->nSoftAcks++;
4021             np = NULL;          /* We can't use this anymore */
4022             newPackets = 1;
4023
4024             /* If an ack is requested then set a flag to make sure we
4025              * send an acknowledgement for this packet */
4026             if (flags & RX_REQUEST_ACK) {
4027                 ackNeeded = RX_ACK_REQUESTED;
4028             }
4029
4030             /* Keep track of whether we have received the last packet */
4031             if (flags & RX_LAST_PACKET) {
4032                 call->flags |= RX_CALL_HAVE_LAST;
4033                 haveLast = 1;
4034             }
4035
4036             /* Check whether we have all of the packets for this call */
4037             if (call->flags & RX_CALL_HAVE_LAST) {
4038                 afs_uint32 tseq;        /* temporary sequence number */
4039                 struct opr_queue *cursor;
4040
4041                 for (tseq = seq, opr_queue_Scan(&call->rq, cursor)) {
4042                     struct rx_packet *tp;
4043
4044                     tp = opr_queue_Entry(cursor, struct rx_packet, entry);
4045                     if (tseq != tp->header.seq)
4046                         break;
4047                     if (tp->header.flags & RX_LAST_PACKET) {
4048                         call->flags |= RX_CALL_RECEIVE_DONE;
4049                         break;
4050                     }
4051                     tseq++;
4052                 }
4053             }
4054
4055             /* Provide asynchronous notification for those who want it
4056              * (e.g. multi rx) */
4057             if (call->arrivalProc) {
4058                 (*call->arrivalProc) (call, call->arrivalProcHandle,
4059                                       call->arrivalProcArg);
4060                 call->arrivalProc = (void (*)())0;
4061             }
4062
4063             /* Update last packet received */
4064             call->rprev = seq;
4065
4066             /* If there is no server process serving this call, grab
4067              * one, if available. We only need to do this once. If a
4068              * server thread is available, this thread becomes a server
4069              * thread and the server thread becomes a listener thread. */
4070             if (isFirst) {
4071                 TryAttach(call, socket, tnop, newcallp, 0);
4072             }
4073         }
4074         /* This is not the expected next packet. */
4075         else {
4076             /* Determine whether this is a new or old packet, and if it's
4077              * a new one, whether it fits into the current receive window.
4078              * Also figure out whether the packet was delivered in sequence.
4079              * We use the prev variable to determine whether the new packet
4080              * is the successor of its immediate predecessor in the
4081              * receive queue, and the missing flag to determine whether
4082              * any of this packets predecessors are missing.  */
4083
4084             afs_uint32 prev;    /* "Previous packet" sequence number */
4085             struct opr_queue *cursor;
4086             int missing;        /* Are any predecessors missing? */
4087
4088             /* If the new packet's sequence number has been sent to the
4089              * application already, then this is a duplicate */
4090             if (seq < call->rnext) {
4091                 if (rx_stats_active)
4092                     rx_atomic_inc(&rx_stats.dupPacketsRead);
4093                 rxevent_Cancel(&call->delayedAckEvent, call,
4094                                RX_CALL_REFCOUNT_DELAY);
4095                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
4096                 ackNeeded = 0;
4097                 call->rprev = seq;
4098                 continue;
4099             }
4100
4101             /* If the sequence number is greater than what can be
4102              * accomodated by the current window, then send a negative
4103              * acknowledge and drop the packet */
4104             if ((call->rnext + call->rwind) <= seq) {
4105                 rxevent_Cancel(&call->delayedAckEvent, call,
4106                                RX_CALL_REFCOUNT_DELAY);
4107                 np = rxi_SendAck(call, np, serial, RX_ACK_EXCEEDS_WINDOW,
4108                                  istack);
4109                 ackNeeded = 0;
4110                 call->rprev = seq;
4111                 continue;
4112             }
4113
4114             /* Look for the packet in the queue of old received packets */
4115             prev = call->rnext - 1;
4116             missing = 0;
4117             for (opr_queue_Scan(&call->rq, cursor)) {
4118                 struct rx_packet *tp
4119                     = opr_queue_Entry(cursor, struct rx_packet, entry);
4120
4121                 /*Check for duplicate packet */
4122                 if (seq == tp->header.seq) {
4123                     if (rx_stats_active)
4124                         rx_atomic_inc(&rx_stats.dupPacketsRead);
4125                     rxevent_Cancel(&call->delayedAckEvent, call,
4126                                    RX_CALL_REFCOUNT_DELAY);
4127                     np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE,
4128                                      istack);
4129                     ackNeeded = 0;
4130                     call->rprev = seq;
4131                     goto nextloop;
4132                 }
4133                 /* If we find a higher sequence packet, break out and
4134                  * insert the new packet here. */
4135                 if (seq < tp->header.seq)
4136                     break;
4137                 /* Check for missing packet */
4138                 if (tp->header.seq != prev + 1) {
4139                     missing = 1;
4140                 }
4141
4142                 prev = tp->header.seq;
4143             }
4144
4145             /* Keep track of whether we have received the last packet. */
4146             if (flags & RX_LAST_PACKET) {
4147                 call->flags |= RX_CALL_HAVE_LAST;
4148             }
4149
4150             /* It's within the window: add it to the the receive queue.
4151              * tp is left by the previous loop either pointing at the
4152              * packet before which to insert the new packet, or at the
4153              * queue head if the queue is empty or the packet should be
4154              * appended. */
4155 #ifdef RX_TRACK_PACKETS
4156             np->flags |= RX_PKTFLAG_RQ;
4157 #endif
4158 #ifdef RXDEBUG_PACKET
4159             call->rqc++;
4160 #endif /* RXDEBUG_PACKET */
4161             opr_queue_InsertBefore(cursor, &np->entry);
4162             call->nSoftAcks++;
4163             np = NULL;
4164
4165             /* Check whether we have all of the packets for this call */
4166             if ((call->flags & RX_CALL_HAVE_LAST)
4167                 && !(call->flags & RX_CALL_RECEIVE_DONE)) {
4168                 afs_uint32 tseq;        /* temporary sequence number */
4169
4170                 tseq = call->rnext;
4171                 for (opr_queue_Scan(&call->rq, cursor)) {
4172                     struct rx_packet *tp
4173                          = opr_queue_Entry(cursor, struct rx_packet, entry);
4174                     if (tseq != tp->header.seq)
4175                         break;
4176                     if (tp->header.flags & RX_LAST_PACKET) {
4177                         call->flags |= RX_CALL_RECEIVE_DONE;
4178                         break;
4179                     }
4180                     tseq++;
4181                 }
4182             }
4183
4184             /* We need to send an ack of the packet is out of sequence,
4185              * or if an ack was requested by the peer. */
4186             if (seq != prev + 1 || missing) {
4187                 ackNeeded = RX_ACK_OUT_OF_SEQUENCE;
4188             } else if (flags & RX_REQUEST_ACK) {
4189                 ackNeeded = RX_ACK_REQUESTED;
4190             }
4191
4192             /* Acknowledge the last packet for each call */
4193             if (flags & RX_LAST_PACKET) {
4194                 haveLast = 1;
4195             }
4196
4197             call->rprev = seq;
4198         }
4199       nextloop:;
4200     }
4201
4202     if (newPackets) {
4203         /*
4204          * If the receiver is waiting for an iovec, fill the iovec
4205          * using the data from the receive queue */
4206         if (call->flags & RX_CALL_IOVEC_WAIT) {
4207             didHardAck = rxi_FillReadVec(call, serial);
4208             /* the call may have been aborted */
4209             if (call->error) {
4210                 return NULL;
4211             }
4212             if (didHardAck) {
4213                 ackNeeded = 0;
4214             }
4215         }
4216
4217         /* Wakeup the reader if any */
4218         if ((call->flags & RX_CALL_READER_WAIT)
4219             && (!(call->flags & RX_CALL_IOVEC_WAIT) || !(call->iovNBytes)
4220                 || (call->iovNext >= call->iovMax)
4221                 || (call->flags & RX_CALL_RECEIVE_DONE))) {
4222             call->flags &= ~RX_CALL_READER_WAIT;
4223 #ifdef  RX_ENABLE_LOCKS
4224             CV_BROADCAST(&call->cv_rq);
4225 #else
4226             osi_rxWakeup(&call->rq);
4227 #endif
4228         }
4229     }
4230
4231     /*
4232      * Send an ack when requested by the peer, or once every
4233      * rxi_SoftAckRate packets until the last packet has been
4234      * received. Always send a soft ack for the last packet in
4235      * the server's reply. */
4236     if (ackNeeded) {
4237         rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4238         np = rxi_SendAck(call, np, serial, ackNeeded, istack);
4239     } else if (call->nSoftAcks > (u_short) rxi_SoftAckRate) {
4240         rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4241         np = rxi_SendAck(call, np, serial, RX_ACK_IDLE, istack);
4242     } else if (call->nSoftAcks) {
4243         if (haveLast && !(flags & RX_CLIENT_INITIATED))
4244             rxi_PostDelayedAckEvent(call, &rx_lastAckDelay);
4245         else
4246             rxi_PostDelayedAckEvent(call, &rx_softAckDelay);
4247     } else if (call->flags & RX_CALL_RECEIVE_DONE) {
4248         rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4249     }
4250
4251     return np;
4252 }
4253
4254 static void
4255 rxi_UpdatePeerReach(struct rx_connection *conn, struct rx_call *acall)
4256 {
4257     struct rx_peer *peer = conn->peer;
4258
4259     MUTEX_ENTER(&peer->peer_lock);
4260     peer->lastReachTime = clock_Sec();
4261     MUTEX_EXIT(&peer->peer_lock);
4262
4263     MUTEX_ENTER(&conn->conn_data_lock);
4264     if (conn->flags & RX_CONN_ATTACHWAIT) {
4265         int i;
4266
4267         rxi_ConnClearAttachWait(conn);
4268         MUTEX_EXIT(&conn->conn_data_lock);
4269
4270         for (i = 0; i < RX_MAXCALLS; i++) {
4271             struct rx_call *call = conn->call[i];
4272             if (call) {
4273                 if (call != acall)
4274                     MUTEX_ENTER(&call->lock);
4275                 /* tnop can be null if newcallp is null */
4276                 TryAttach(call, (osi_socket) - 1, NULL, NULL, 1);
4277                 if (call != acall)
4278                     MUTEX_EXIT(&call->lock);
4279             }
4280         }
4281     } else
4282         MUTEX_EXIT(&conn->conn_data_lock);
4283 }
4284
4285 #if defined(RXDEBUG) && defined(AFS_NT40_ENV)
4286 static const char *
4287 rx_ack_reason(int reason)
4288 {
4289     switch (reason) {
4290     case RX_ACK_REQUESTED:
4291         return "requested";
4292     case RX_ACK_DUPLICATE:
4293         return "duplicate";
4294     case RX_ACK_OUT_OF_SEQUENCE:
4295         return "sequence";
4296     case RX_ACK_EXCEEDS_WINDOW:
4297         return "window";
4298     case RX_ACK_NOSPACE:
4299         return "nospace";
4300     case RX_ACK_PING:
4301         return "ping";
4302     case RX_ACK_PING_RESPONSE:
4303         return "response";
4304     case RX_ACK_DELAY:
4305         return "delay";
4306     case RX_ACK_IDLE:
4307         return "idle";
4308     default:
4309         return "unknown!!";
4310     }
4311 }
4312 #endif
4313
4314
4315 /* The real smarts of the whole thing.  */
4316 static struct rx_packet *
4317 rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
4318                      int istack)
4319 {
4320     struct rx_ackPacket *ap;
4321     int nAcks;
4322     struct rx_packet *tp;
4323     struct rx_connection *conn = call->conn;
4324     struct rx_peer *peer = conn->peer;
4325     struct opr_queue *cursor;
4326     struct clock now;           /* Current time, for RTT calculations */
4327     afs_uint32 first;
4328     afs_uint32 prev;
4329     afs_uint32 serial;
4330     int nbytes;
4331     int missing;
4332     int acked;
4333     int nNacked = 0;
4334     int newAckCount = 0;
4335     int maxDgramPackets = 0;    /* Set if peer supports AFS 3.5 jumbo datagrams */
4336     int pktsize = 0;            /* Set if we need to update the peer mtu */
4337     int conn_data_locked = 0;
4338
4339     if (rx_stats_active)
4340         rx_atomic_inc(&rx_stats.ackPacketsRead);
4341     ap = (struct rx_ackPacket *)rx_DataOf(np);
4342     nbytes = rx_Contiguous(np) - (int)((ap->acks) - (u_char *) ap);
4343     if (nbytes < 0)
4344         return np;              /* truncated ack packet */
4345
4346     /* depends on ack packet struct */
4347     nAcks = MIN((unsigned)nbytes, (unsigned)ap->nAcks);
4348     first = ntohl(ap->firstPacket);
4349     prev = ntohl(ap->previousPacket);
4350     serial = ntohl(ap->serial);
4351
4352     /*
4353      * Ignore ack packets received out of order while protecting
4354      * against peers that set the previousPacket field to a packet
4355      * serial number instead of a sequence number.
4356      */
4357     if (first < call->tfirst ||
4358         (first == call->tfirst && prev < call->tprev && prev < call->tfirst
4359          + call->twind)) {
4360         return np;
4361     }
4362
4363     call->tprev = prev;
4364
4365     if (np->header.flags & RX_SLOW_START_OK) {
4366         call->flags |= RX_CALL_SLOW_START_OK;
4367     }
4368
4369     if (ap->reason == RX_ACK_PING_RESPONSE)
4370         rxi_UpdatePeerReach(conn, call);
4371
4372     if (conn->lastPacketSizeSeq) {
4373         MUTEX_ENTER(&conn->conn_data_lock);
4374         conn_data_locked = 1;
4375         if ((first > conn->lastPacketSizeSeq) && (conn->lastPacketSize)) {
4376             pktsize = conn->lastPacketSize;
4377             conn->lastPacketSize = conn->lastPacketSizeSeq = 0;
4378         }
4379     }
4380     if ((ap->reason == RX_ACK_PING_RESPONSE) && (conn->lastPingSizeSer)) {
4381         if (!conn_data_locked) {
4382             MUTEX_ENTER(&conn->conn_data_lock);
4383             conn_data_locked = 1;
4384         }
4385         if ((conn->lastPingSizeSer == serial) && (conn->lastPingSize)) {
4386             /* process mtu ping ack */
4387             pktsize = conn->lastPingSize;
4388             conn->lastPingSizeSer = conn->lastPingSize = 0;
4389         }
4390     }
4391
4392     if (conn_data_locked) {
4393         MUTEX_EXIT(&conn->conn_data_lock);
4394         conn_data_locked = 0;
4395     }
4396 #ifdef RXDEBUG
4397 #ifdef AFS_NT40_ENV
4398     if (rxdebug_active) {
4399         char msg[512];
4400         size_t len;
4401
4402         len = _snprintf(msg, sizeof(msg),
4403                         "tid[%d] RACK: reason %s serial %u previous %u seq %u first %u acks %u space %u ",
4404                          GetCurrentThreadId(), rx_ack_reason(ap->reason),
4405                          ntohl(ap->serial), ntohl(ap->previousPacket),
4406                          (unsigned int)np->header.seq, ntohl(ap->firstPacket),
4407                          ap->nAcks, ntohs(ap->bufferSpace) );
4408         if (nAcks) {
4409             int offset;
4410
4411             for (offset = 0; offset < nAcks && len < sizeof(msg); offset++)
4412                 msg[len++] = (ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*');
4413         }
4414         msg[len++]='\n';
4415         msg[len] = '\0';
4416         OutputDebugString(msg);
4417     }
4418 #else /* AFS_NT40_ENV */
4419     if (rx_Log) {
4420         fprintf(rx_Log,
4421                 "RACK: reason %x previous %u seq %u serial %u first %u",
4422                 ap->reason, ntohl(ap->previousPacket),
4423                 (unsigned int)np->header.seq, (unsigned int)serial,
4424                 ntohl(ap->firstPacket));
4425         if (nAcks) {
4426             int offset;
4427             for (offset = 0; offset < nAcks; offset++)
4428                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
4429                      rx_Log);
4430         }
4431         putc('\n', rx_Log);
4432     }
4433 #endif /* AFS_NT40_ENV */
4434 #endif
4435
4436     MUTEX_ENTER(&peer->peer_lock);
4437     if (pktsize) {
4438         /*
4439          * Start somewhere. Can't assume we can send what we can receive,
4440          * but we are clearly receiving.
4441          */
4442         if (!peer->maxPacketSize)
4443             peer->maxPacketSize = RX_MIN_PACKET_SIZE+RX_IPUDP_SIZE;
4444
4445         if (pktsize > peer->maxPacketSize) {
4446             peer->maxPacketSize = pktsize;
4447             if ((pktsize-RX_IPUDP_SIZE > peer->ifMTU)) {
4448                 peer->ifMTU=pktsize-RX_IPUDP_SIZE;
4449                 peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
4450                 rxi_ScheduleGrowMTUEvent(call, 1);
4451             }
4452         }
4453     }
4454
4455     clock_GetTime(&now);
4456
4457     /* The transmit queue splits into 4 sections.
4458      *
4459      * The first section is packets which have now been acknowledged
4460      * by a window size change in the ack. These have reached the
4461      * application layer, and may be discarded. These are packets
4462      * with sequence numbers < ap->firstPacket.
4463      *
4464      * The second section is packets which have sequence numbers in
4465      * the range ap->firstPacket to ap->firstPacket + ap->nAcks. The
4466      * contents of the packet's ack array determines whether these
4467      * packets are acknowledged or not.
4468      *
4469      * The third section is packets which fall above the range
4470      * addressed in the ack packet. These have not yet been received
4471      * by the peer.
4472      *
4473      * The four section is packets which have not yet been transmitted.
4474      * These packets will have a header.serial of 0.
4475      */
4476
4477     /* First section - implicitly acknowledged packets that can be
4478      * disposed of
4479      */
4480
4481     tp = opr_queue_First(&call->tq, struct rx_packet, entry);
4482     while(!opr_queue_IsEnd(&call->tq, &tp->entry) && tp->header.seq < first) {
4483         struct rx_packet *next;
4484
4485         next = opr_queue_Next(&tp->entry, struct rx_packet, entry);
4486         call->tfirst = tp->header.seq + 1;
4487
4488         if (!(tp->flags & RX_PKTFLAG_ACKED)) {
4489             newAckCount++;
4490             rxi_ComputeRoundTripTime(tp, ap, call, peer, &now);
4491         }
4492
4493 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4494         /* XXX Hack. Because we have to release the global rx lock when sending
4495          * packets (osi_NetSend) we drop all acks while we're traversing the tq
4496          * in rxi_Start sending packets out because packets may move to the
4497          * freePacketQueue as result of being here! So we drop these packets until
4498          * we're safely out of the traversing. Really ugly!
4499          * To make it even uglier, if we're using fine grain locking, we can
4500          * set the ack bits in the packets and have rxi_Start remove the packets
4501          * when it's done transmitting.
4502          */
4503         if (call->flags & RX_CALL_TQ_BUSY) {
4504 #ifdef RX_ENABLE_LOCKS
4505             tp->flags |= RX_PKTFLAG_ACKED;
4506             call->flags |= RX_CALL_TQ_SOME_ACKED;
4507 #else /* RX_ENABLE_LOCKS */
4508             break;
4509 #endif /* RX_ENABLE_LOCKS */
4510         } else
4511 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4512         {
4513             opr_queue_Remove(&tp->entry);
4514 #ifdef RX_TRACK_PACKETS
4515             tp->flags &= ~RX_PKTFLAG_TQ;
4516 #endif
4517 #ifdef RXDEBUG_PACKET
4518             call->tqc--;
4519 #endif /* RXDEBUG_PACKET */
4520             rxi_FreePacket(tp); /* rxi_FreePacket mustn't wake up anyone, preemptively. */
4521         }
4522         tp = next;
4523     }
4524
4525     /* N.B. we don't turn off any timers here.  They'll go away by themselves, anyway */
4526
4527     /* Second section of the queue - packets for which we are receiving
4528      * soft ACKs
4529      *
4530      * Go through the explicit acks/nacks and record the results in
4531      * the waiting packets.  These are packets that can't be released
4532      * yet, even with a positive acknowledge.  This positive
4533      * acknowledge only means the packet has been received by the
4534      * peer, not that it will be retained long enough to be sent to
4535      * the peer's upper level.  In addition, reset the transmit timers
4536      * of any missing packets (those packets that must be missing
4537      * because this packet was out of sequence) */
4538
4539     call->nSoftAcked = 0;
4540     missing = 0;
4541     while (!opr_queue_IsEnd(&call->tq, &tp->entry)
4542            && tp->header.seq < first + nAcks) {
4543         /* Set the acknowledge flag per packet based on the
4544          * information in the ack packet. An acknowlegded packet can
4545          * be downgraded when the server has discarded a packet it
4546          * soacked previously, or when an ack packet is received
4547          * out of sequence. */
4548         if (ap->acks[tp->header.seq - first] == RX_ACK_TYPE_ACK) {
4549             if (!(tp->flags & RX_PKTFLAG_ACKED)) {
4550                 newAckCount++;
4551                 tp->flags |= RX_PKTFLAG_ACKED;
4552                 rxi_ComputeRoundTripTime(tp, ap, call, peer, &now);
4553             }
4554             if (missing) {
4555                 nNacked++;
4556             } else {
4557                 call->nSoftAcked++;
4558             }
4559         } else /* RX_ACK_TYPE_NACK */ {
4560             tp->flags &= ~RX_PKTFLAG_ACKED;
4561             missing = 1;
4562         }
4563
4564         tp = opr_queue_Next(&tp->entry, struct rx_packet, entry);
4565     }
4566
4567     /* We don't need to take any action with the 3rd or 4th section in the
4568      * queue - they're not addressed by the contents of this ACK packet.
4569      */
4570
4571     /* If the window has been extended by this acknowledge packet,
4572      * then wakeup a sender waiting in alloc for window space, or try
4573      * sending packets now, if he's been sitting on packets due to
4574      * lack of window space */
4575     if (call->tnext < (call->tfirst + call->twind)) {
4576 #ifdef  RX_ENABLE_LOCKS
4577         CV_SIGNAL(&call->cv_twind);
4578 #else
4579         if (call->flags & RX_CALL_WAIT_WINDOW_ALLOC) {
4580             call->flags &= ~RX_CALL_WAIT_WINDOW_ALLOC;
4581             osi_rxWakeup(&call->twind);
4582         }
4583 #endif
4584         if (call->flags & RX_CALL_WAIT_WINDOW_SEND) {
4585             call->flags &= ~RX_CALL_WAIT_WINDOW_SEND;
4586         }
4587     }
4588
4589     /* if the ack packet has a receivelen field hanging off it,
4590      * update our state */
4591     if (np->length >= rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32)) {
4592         afs_uint32 tSize;
4593
4594         /* If the ack packet has a "recommended" size that is less than
4595          * what I am using now, reduce my size to match */
4596         rx_packetread(np, rx_AckDataSize(ap->nAcks) + (int)sizeof(afs_int32),
4597                       (int)sizeof(afs_int32), &tSize);
4598         tSize = (afs_uint32) ntohl(tSize);
4599         peer->natMTU = rxi_AdjustIfMTU(MIN(tSize, peer->ifMTU));
4600
4601         /* Get the maximum packet size to send to this peer */
4602         rx_packetread(np, rx_AckDataSize(ap->nAcks), (int)sizeof(afs_int32),
4603                       &tSize);
4604         tSize = (afs_uint32) ntohl(tSize);
4605         tSize = (afs_uint32) MIN(tSize, rx_MyMaxSendSize);
4606         tSize = rxi_AdjustMaxMTU(peer->natMTU, tSize);
4607
4608         /* sanity check - peer might have restarted with different params.
4609          * If peer says "send less", dammit, send less...  Peer should never
4610          * be unable to accept packets of the size that prior AFS versions would
4611          * send without asking.  */
4612         if (peer->maxMTU != tSize) {
4613             if (peer->maxMTU > tSize) /* possible cong., maxMTU decreased */
4614                 peer->congestSeq++;
4615             peer->maxMTU = tSize;
4616             peer->MTU = MIN(tSize, peer->MTU);
4617             call->MTU = MIN(call->MTU, tSize);
4618         }
4619
4620         if (np->length == rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32)) {
4621             /* AFS 3.4a */
4622             rx_packetread(np,
4623                           rx_AckDataSize(ap->nAcks) + 2 * (int)sizeof(afs_int32),
4624                           (int)sizeof(afs_int32), &tSize);
4625             tSize = (afs_uint32) ntohl(tSize);  /* peer's receive window, if it's */
4626             if (tSize < call->twind) {  /* smaller than our send */
4627                 call->twind = tSize;    /* window, we must send less... */
4628                 call->ssthresh = MIN(call->twind, call->ssthresh);
4629                 call->conn->twind[call->channel] = call->twind;
4630             }
4631
4632             /* Only send jumbograms to 3.4a fileservers. 3.3a RX gets the
4633              * network MTU confused with the loopback MTU. Calculate the
4634              * maximum MTU here for use in the slow start code below.
4635              */
4636             /* Did peer restart with older RX version? */
4637             if (peer->maxDgramPackets > 1) {
4638                 peer->maxDgramPackets = 1;
4639             }
4640         } else if (np->length >=
4641                    rx_AckDataSize(ap->nAcks) + 4 * sizeof(afs_int32)) {
4642             /* AFS 3.5 */
4643             rx_packetread(np,
4644                           rx_AckDataSize(ap->nAcks) + 2 * (int)sizeof(afs_int32),
4645                           sizeof(afs_int32), &tSize);
4646             tSize = (afs_uint32) ntohl(tSize);
4647             /*
4648              * As of AFS 3.5 we set the send window to match the receive window.
4649              */
4650             if (tSize < call->twind) {
4651                 call->twind = tSize;
4652                 call->conn->twind[call->channel] = call->twind;
4653                 call->ssthresh = MIN(call->twind, call->ssthresh);
4654             } else if (tSize > call->twind) {
4655                 call->twind = tSize;
4656                 call->conn->twind[call->channel] = call->twind;
4657             }
4658
4659             /*
4660              * As of AFS 3.5, a jumbogram is more than one fixed size
4661              * packet transmitted in a single UDP datagram. If the remote
4662              * MTU is smaller than our local MTU then never send a datagram
4663              * larger than the natural MTU.
4664              */
4665             rx_packetread(np,
4666                           rx_AckDataSize(ap->nAcks) + 3 * (int)sizeof(afs_int32),
4667                           (int)sizeof(afs_int32), &tSize);
4668             maxDgramPackets = (afs_uint32) ntohl(tSize);
4669             maxDgramPackets = MIN(maxDgramPackets, rxi_nDgramPackets);
4670             maxDgramPackets =
4671                 MIN(maxDgramPackets, (int)(peer->ifDgramPackets));
4672             if (maxDgramPackets > 1) {
4673                 peer->maxDgramPackets = maxDgramPackets;
4674                 call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
4675             } else {
4676                 peer->maxDgramPackets = 1;
4677                 call->MTU = peer->natMTU;
4678             }
4679         } else if (peer->maxDgramPackets > 1) {
4680             /* Restarted with lower version of RX */
4681             peer->maxDgramPackets = 1;
4682         }
4683     } else if (peer->maxDgramPackets > 1
4684                || peer->maxMTU != OLD_MAX_PACKET_SIZE) {
4685         /* Restarted with lower version of RX */
4686         peer->maxMTU = OLD_MAX_PACKET_SIZE;
4687         peer->natMTU = OLD_MAX_PACKET_SIZE;
4688         peer->MTU = OLD_MAX_PACKET_SIZE;
4689         peer->maxDgramPackets = 1;
4690         peer->nDgramPackets = 1;
4691         peer->congestSeq++;
4692         call->MTU = OLD_MAX_PACKET_SIZE;
4693     }
4694
4695     if (nNacked) {
4696         /*
4697          * Calculate how many datagrams were successfully received after
4698          * the first missing packet and adjust the negative ack counter
4699          * accordingly.
4700          */
4701         call->nAcks = 0;
4702         call->nNacks++;
4703         nNacked = (nNacked + call->nDgramPackets - 1) / call->nDgramPackets;
4704         if (call->nNacks < nNacked) {
4705             call->nNacks = nNacked;
4706         }
4707     } else {
4708         call->nAcks += newAckCount;
4709         call->nNacks = 0;
4710     }
4711
4712     /* If the packet contained new acknowledgements, rather than just
4713      * being a duplicate of one we have previously seen, then we can restart
4714      * the RTT timer
4715      */
4716     if (newAckCount > 0)
4717         rxi_rto_packet_acked(call, istack);
4718
4719     if (call->flags & RX_CALL_FAST_RECOVER) {
4720         if (newAckCount == 0) {
4721             call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
4722         } else {
4723             call->flags &= ~RX_CALL_FAST_RECOVER;
4724             call->cwind = call->nextCwind;
4725             call->nextCwind = 0;
4726             call->nAcks = 0;
4727         }
4728         call->nCwindAcks = 0;
4729     } else if (nNacked && call->nNacks >= (u_short) rx_nackThreshold) {
4730         /* Three negative acks in a row trigger congestion recovery */
4731         call->flags |= RX_CALL_FAST_RECOVER;
4732         call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
4733         call->cwind =
4734             MIN((int)(call->ssthresh + rx_nackThreshold), rx_maxSendWindow);
4735         call->nDgramPackets = MAX(2, (int)call->nDgramPackets) >> 1;
4736         call->nextCwind = call->ssthresh;
4737         call->nAcks = 0;
4738         call->nNacks = 0;
4739         peer->MTU = call->MTU;
4740         peer->cwind = call->nextCwind;
4741         peer->nDgramPackets = call->nDgramPackets;
4742         peer->congestSeq++;
4743         call->congestSeq = peer->congestSeq;
4744
4745         /* Reset the resend times on the packets that were nacked
4746          * so we will retransmit as soon as the window permits
4747          */
4748
4749         acked = 0;
4750         for (opr_queue_ScanBackwards(&call->tq, cursor)) {
4751             struct rx_packet *tp =
4752                 opr_queue_Entry(cursor, struct rx_packet, entry);
4753             if (acked) {
4754                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
4755                     tp->flags &= ~RX_PKTFLAG_SENT;
4756                 }
4757             } else if (tp->flags & RX_PKTFLAG_ACKED) {
4758                 acked = 1;
4759             }
4760         }
4761     } else {
4762         /* If cwind is smaller than ssthresh, then increase
4763          * the window one packet for each ack we receive (exponential
4764          * growth).
4765          * If cwind is greater than or equal to ssthresh then increase
4766          * the congestion window by one packet for each cwind acks we
4767          * receive (linear growth).  */
4768         if (call->cwind < call->ssthresh) {
4769             call->cwind =
4770                 MIN((int)call->ssthresh, (int)(call->cwind + newAckCount));
4771             call->nCwindAcks = 0;
4772         } else {
4773             call->nCwindAcks += newAckCount;
4774             if (call->nCwindAcks >= call->cwind) {
4775                 call->nCwindAcks = 0;
4776                 call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
4777             }
4778         }
4779         /*
4780          * If we have received several acknowledgements in a row then
4781          * it is time to increase the size of our datagrams
4782          */
4783         if ((int)call->nAcks > rx_nDgramThreshold) {
4784             if (peer->maxDgramPackets > 1) {
4785                 if (call->nDgramPackets < peer->maxDgramPackets) {
4786                     call->nDgramPackets++;
4787                 }
4788                 call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
4789             } else if (call->MTU < peer->maxMTU) {
4790                 /* don't upgrade if we can't handle it */
4791                 if ((call->nDgramPackets == 1) && (call->MTU >= peer->ifMTU))
4792                     call->MTU = peer->ifMTU;
4793                 else {
4794                     call->MTU += peer->natMTU;
4795                     call->MTU = MIN(call->MTU, peer->maxMTU);
4796                 }
4797             }
4798             call->nAcks = 0;
4799         }
4800     }
4801
4802     MUTEX_EXIT(&peer->peer_lock);       /* rxi_Start will lock peer. */
4803
4804     /* Servers need to hold the call until all response packets have
4805      * been acknowledged. Soft acks are good enough since clients
4806      * are not allowed to clear their receive queues. */
4807     if (call->state == RX_STATE_HOLD
4808         && call->tfirst + call->nSoftAcked >= call->tnext) {
4809         call->state = RX_STATE_DALLY;
4810         rxi_ClearTransmitQueue(call, 0);
4811         rxevent_Cancel(&call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
4812     } else if (!opr_queue_IsEmpty(&call->tq)) {
4813         rxi_Start(call, istack);
4814     }
4815     return np;
4816 }
4817
4818 /* Received a response to a challenge packet */
4819 static struct rx_packet *
4820 rxi_ReceiveResponsePacket(struct rx_connection *conn,
4821                           struct rx_packet *np, int istack)
4822 {
4823     int error;
4824
4825     /* Ignore the packet if we're the client */
4826     if (conn->type == RX_CLIENT_CONNECTION)
4827         return np;
4828
4829     /* If already authenticated, ignore the packet (it's probably a retry) */
4830     if (RXS_CheckAuthentication(conn->securityObject, conn) == 0)
4831         return np;
4832
4833     /* Otherwise, have the security object evaluate the response packet */
4834     error = RXS_CheckResponse(conn->securityObject, conn, np);
4835     if (error) {
4836         /* If the response is invalid, reset the connection, sending
4837          * an abort to the peer */
4838 #ifndef KERNEL
4839         rxi_Delay(1);
4840 #endif
4841         rxi_ConnectionError(conn, error);
4842         MUTEX_ENTER(&conn->conn_data_lock);
4843         np = rxi_SendConnectionAbort(conn, np, istack, 0);
4844         MUTEX_EXIT(&conn->conn_data_lock);
4845         return np;
4846     } else {
4847         /* If the response is valid, any calls waiting to attach
4848          * servers can now do so */
4849         int i;
4850
4851         for (i = 0; i < RX_MAXCALLS; i++) {
4852             struct rx_call *call = conn->call[i];
4853             if (call) {
4854                 MUTEX_ENTER(&call->lock);
4855                 if (call->state == RX_STATE_PRECALL)
4856                     rxi_AttachServerProc(call, (osi_socket) - 1, NULL, NULL);
4857                 /* tnop can be null if newcallp is null */
4858                 MUTEX_EXIT(&call->lock);
4859             }
4860         }
4861
4862         /* Update the peer reachability information, just in case
4863          * some calls went into attach-wait while we were waiting
4864          * for authentication..
4865          */
4866         rxi_UpdatePeerReach(conn, NULL);
4867     }
4868     return np;
4869 }
4870
4871 /* A client has received an authentication challenge: the security
4872  * object is asked to cough up a respectable response packet to send
4873  * back to the server.  The server is responsible for retrying the
4874  * challenge if it fails to get a response. */
4875
4876 static struct rx_packet *
4877 rxi_ReceiveChallengePacket(struct rx_connection *conn,
4878                            struct rx_packet *np, int istack)
4879 {
4880     int error;
4881
4882     /* Ignore the challenge if we're the server */
4883     if (conn->type == RX_SERVER_CONNECTION)
4884         return np;
4885
4886     /* Ignore the challenge if the connection is otherwise idle; someone's
4887      * trying to use us as an oracle. */
4888     if (!rxi_HasActiveCalls(conn))
4889         return np;
4890
4891     /* Send the security object the challenge packet.  It is expected to fill
4892      * in the response. */
4893     error = RXS_GetResponse(conn->securityObject, conn, np);
4894
4895     /* If the security object is unable to return a valid response, reset the
4896      * connection and send an abort to the peer.  Otherwise send the response
4897      * packet to the peer connection. */
4898     if (error) {
4899         rxi_ConnectionError(conn, error);
4900         MUTEX_ENTER(&conn->conn_data_lock);
4901         np = rxi_SendConnectionAbort(conn, np, istack, 0);
4902         MUTEX_EXIT(&conn->conn_data_lock);
4903     } else {
4904         np = rxi_SendSpecial((struct rx_call *)0, conn, np,
4905                              RX_PACKET_TYPE_RESPONSE, NULL, -1, istack);
4906     }
4907     return np;
4908 }
4909
4910
4911 /* Find an available server process to service the current request in
4912  * the given call structure.  If one isn't available, queue up this
4913  * call so it eventually gets one */
4914 static void
4915 rxi_AttachServerProc(struct rx_call *call,
4916                      osi_socket socket, int *tnop,
4917                      struct rx_call **newcallp)
4918 {
4919     struct rx_serverQueueEntry *sq;
4920     struct rx_service *service = call->conn->service;
4921     int haveQuota = 0;
4922
4923     /* May already be attached */
4924     if (call->state == RX_STATE_ACTIVE)
4925         return;
4926
4927     MUTEX_ENTER(&rx_serverPool_lock);
4928
4929     haveQuota = QuotaOK(service);
4930     if ((!haveQuota) || opr_queue_IsEmpty(&rx_idleServerQueue)) {
4931         /* If there are no processes available to service this call,
4932          * put the call on the incoming call queue (unless it's
4933          * already on the queue).
4934          */
4935 #ifdef RX_ENABLE_LOCKS
4936         if (haveQuota)
4937             ReturnToServerPool(service);
4938 #endif /* RX_ENABLE_LOCKS */
4939
4940         if (!(call->flags & RX_CALL_WAIT_PROC)) {
4941             call->flags |= RX_CALL_WAIT_PROC;
4942             rx_atomic_inc(&rx_nWaiting);
4943             rx_atomic_inc(&rx_nWaited);
4944             rxi_calltrace(RX_CALL_ARRIVAL, call);
4945             SET_CALL_QUEUE_LOCK(call, &rx_serverPool_lock);
4946             opr_queue_Append(&rx_incomingCallQueue, &call->entry);
4947         }
4948     } else {
4949         sq = opr_queue_Last(&rx_idleServerQueue,
4950                             struct rx_serverQueueEntry, entry);
4951
4952         /* If hot threads are enabled, and both newcallp and sq->socketp
4953          * are non-null, then this thread will process the call, and the
4954          * idle server thread will start listening on this threads socket.
4955          */
4956         opr_queue_Remove(&sq->entry);
4957
4958         if (rx_enable_hot_thread && newcallp && sq->socketp) {
4959             *newcallp = call;
4960             *tnop = sq->tno;
4961             *sq->socketp = socket;
4962             clock_GetTime(&call->startTime);
4963             CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
4964         } else {
4965             sq->newcall = call;
4966         }
4967         if (call->flags & RX_CALL_WAIT_PROC) {
4968             /* Conservative:  I don't think this should happen */
4969             call->flags &= ~RX_CALL_WAIT_PROC;
4970             rx_atomic_dec(&rx_nWaiting);
4971             if (opr_queue_IsOnQueue(&call->entry)) {
4972                 opr_queue_Remove(&call->entry);
4973             }
4974         }
4975         call->state = RX_STATE_ACTIVE;
4976         call->mode = RX_MODE_RECEIVING;
4977 #ifdef RX_KERNEL_TRACE
4978         {
4979             int glockOwner = ISAFS_GLOCK();
4980             if (!glockOwner)
4981                 AFS_GLOCK();
4982             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
4983                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
4984                        call);
4985             if (!glockOwner)
4986                 AFS_GUNLOCK();
4987         }
4988 #endif
4989         if (call->flags & RX_CALL_CLEARED) {
4990             /* send an ack now to start the packet flow up again */
4991             call->flags &= ~RX_CALL_CLEARED;
4992             rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
4993         }
4994 #ifdef  RX_ENABLE_LOCKS
4995         CV_SIGNAL(&sq->cv);
4996 #else
4997         service->nRequestsRunning++;
4998         MUTEX_ENTER(&rx_quota_mutex);
4999         if (service->nRequestsRunning <= service->minProcs)
5000             rxi_minDeficit--;
5001         rxi_availProcs--;
5002         MUTEX_EXIT(&rx_quota_mutex);
5003         osi_rxWakeup(sq);
5004 #endif
5005     }
5006     MUTEX_EXIT(&rx_serverPool_lock);
5007 }
5008
5009 /* Delay the sending of an acknowledge event for a short while, while
5010  * a new call is being prepared (in the case of a client) or a reply
5011  * is being prepared (in the case of a server).  Rather than sending
5012  * an ack packet, an ACKALL packet is sent. */
5013 static void
5014 rxi_AckAll(struct rx_call *call)
5015 {
5016     rxi_SendSpecial(call, call->conn, NULL, RX_PACKET_TYPE_ACKALL,
5017                     NULL, 0, 0);
5018     call->flags |= RX_CALL_ACKALL_SENT;
5019 }
5020
5021 static void
5022 rxi_SendDelayedAck(struct rxevent *event, void *arg1, void *unused1,
5023                    int unused2)
5024 {
5025     struct rx_call *call = arg1;
5026 #ifdef RX_ENABLE_LOCKS
5027     if (event) {
5028         MUTEX_ENTER(&call->lock);
5029         if (event == call->delayedAckEvent) {
5030             rxevent_Put(call->delayedAckEvent);
5031             call->delayedAckEvent = NULL;
5032         }
5033         CALL_RELE(call, RX_CALL_REFCOUNT_DELAY);
5034     }
5035     (void)rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
5036     if (event)
5037         MUTEX_EXIT(&call->lock);
5038 #else /* RX_ENABLE_LOCKS */
5039     if (event) {
5040         rxevent_Put(call->delayedAckEvent);
5041         call->delayedAckEvent = NULL;
5042     }
5043     (void)rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
5044 #endif /* RX_ENABLE_LOCKS */
5045 }
5046
5047
5048 #ifdef RX_ENABLE_LOCKS
5049 /* Set ack in all packets in transmit queue. rxi_Start will deal with
5050  * clearing them out.
5051  */
5052 static void
5053 rxi_SetAcksInTransmitQueue(struct rx_call *call)
5054 {
5055     struct opr_queue *cursor;
5056     int someAcked = 0;
5057
5058     for (opr_queue_Scan(&call->tq, cursor)) {
5059         struct rx_packet *p
5060                 = opr_queue_Entry(cursor, struct rx_packet, entry);
5061
5062         p->flags |= RX_PKTFLAG_ACKED;
5063         someAcked = 1;
5064     }
5065
5066     if (someAcked) {
5067         call->flags |= RX_CALL_TQ_CLEARME;
5068         call->flags |= RX_CALL_TQ_SOME_ACKED;
5069     }
5070
5071     rxi_rto_cancel(call);
5072
5073     call->tfirst = call->tnext;
5074     call->nSoftAcked = 0;
5075
5076     if (call->flags & RX_CALL_FAST_RECOVER) {
5077         call->flags &= ~RX_CALL_FAST_RECOVER;
5078         call->cwind = call->nextCwind;
5079         call->nextCwind = 0;
5080     }
5081
5082     CV_SIGNAL(&call->cv_twind);
5083 }
5084 #endif /* RX_ENABLE_LOCKS */
5085
5086 /* Clear out the transmit queue for the current call (all packets have
5087  * been received by peer) */
5088 static void
5089 rxi_ClearTransmitQueue(struct rx_call *call, int force)
5090 {
5091 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5092     struct opr_queue *cursor;
5093     if (!force && (call->flags & RX_CALL_TQ_BUSY)) {
5094         int someAcked = 0;
5095         for (opr_queue_Scan(&call->tq, cursor)) {
5096             struct rx_packet *p
5097                 = opr_queue_Entry(cursor, struct rx_packet, entry);
5098
5099             p->flags |= RX_PKTFLAG_ACKED;
5100             someAcked = 1;
5101         }
5102         if (someAcked) {
5103             call->flags |= RX_CALL_TQ_CLEARME;
5104             call->flags |= RX_CALL_TQ_SOME_ACKED;
5105         }
5106     } else {
5107 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5108 #ifdef RXDEBUG_PACKET
5109         call->tqc -=
5110 #endif /* RXDEBUG_PACKET */
5111             rxi_FreePackets(0, &call->tq);
5112         rxi_WakeUpTransmitQueue(call);
5113 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5114         call->flags &= ~RX_CALL_TQ_CLEARME;
5115     }
5116 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5117
5118     rxi_rto_cancel(call);
5119     call->tfirst = call->tnext; /* implicitly acknowledge all data already sent */
5120     call->nSoftAcked = 0;
5121
5122     if (call->flags & RX_CALL_FAST_RECOVER) {
5123         call->flags &= ~RX_CALL_FAST_RECOVER;
5124         call->cwind = call->nextCwind;
5125     }
5126 #ifdef  RX_ENABLE_LOCKS
5127     CV_SIGNAL(&call->cv_twind);
5128 #else
5129     osi_rxWakeup(&call->twind);
5130 #endif
5131 }
5132
5133 static void
5134 rxi_ClearReceiveQueue(struct rx_call *call)
5135 {
5136     if (!opr_queue_IsEmpty(&call->rq)) {
5137         u_short count;
5138
5139         count = rxi_FreePackets(0, &call->rq);
5140         rx_packetReclaims += count;
5141 #ifdef RXDEBUG_PACKET
5142         call->rqc -= count;
5143         if ( call->rqc != 0 )
5144             dpf(("rxi_ClearReceiveQueue call %"AFS_PTR_FMT" rqc %u != 0\n", call, call->rqc));
5145 #endif
5146         call->flags &= ~(RX_CALL_RECEIVE_DONE | RX_CALL_HAVE_LAST);
5147     }
5148     if (call->state == RX_STATE_PRECALL) {
5149         call->flags |= RX_CALL_CLEARED;
5150     }
5151 }
5152
5153 /* Send an abort packet for the specified call */
5154 static struct rx_packet *
5155 rxi_SendCallAbort(struct rx_call *call, struct rx_packet *packet,
5156                   int istack, int force)
5157 {
5158     afs_int32 error, cerror;
5159     struct clock when, now;
5160
5161     if (!call->error)
5162         return packet;
5163
5164     switch (call->error) {
5165     case RX_CALL_IDLE:
5166     case RX_CALL_BUSY:
5167         cerror = RX_CALL_TIMEOUT;
5168         break;
5169     default:
5170         cerror = call->error;
5171     }
5172
5173     /* Clients should never delay abort messages */
5174     if (rx_IsClientConn(call->conn))
5175         force = 1;
5176
5177     if (call->abortCode != cerror) {
5178         call->abortCode = cerror;
5179         call->abortCount = 0;
5180     }
5181
5182     if (force || rxi_callAbortThreshhold == 0
5183         || call->abortCount < rxi_callAbortThreshhold) {
5184         if (call->delayedAbortEvent) {
5185             rxevent_Cancel(&call->delayedAbortEvent, call,
5186                            RX_CALL_REFCOUNT_ABORT);
5187         }
5188         error = htonl(cerror);
5189         call->abortCount++;
5190         packet =
5191             rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
5192                             (char *)&error, sizeof(error), istack);
5193     } else if (!call->delayedAbortEvent) {
5194         clock_GetTime(&now);
5195         when = now;
5196         clock_Addmsec(&when, rxi_callAbortDelay);
5197         CALL_HOLD(call, RX_CALL_REFCOUNT_ABORT);
5198         call->delayedAbortEvent =
5199             rxevent_Post(&when, &now, rxi_SendDelayedCallAbort, call, 0, 0);
5200     }
5201     return packet;
5202 }
5203
5204 /* Send an abort packet for the specified connection.  Packet is an
5205  * optional pointer to a packet that can be used to send the abort.
5206  * Once the number of abort messages reaches the threshhold, an
5207  * event is scheduled to send the abort. Setting the force flag
5208  * overrides sending delayed abort messages.
5209  *
5210  * NOTE: Called with conn_data_lock held. conn_data_lock is dropped
5211  *       to send the abort packet.
5212  */
5213 struct rx_packet *
5214 rxi_SendConnectionAbort(struct rx_connection *conn,
5215                         struct rx_packet *packet, int istack, int force)
5216 {
5217     afs_int32 error;
5218     struct clock when, now;
5219
5220     if (!conn->error)
5221         return packet;
5222
5223     /* Clients should never delay abort messages */
5224     if (rx_IsClientConn(conn))
5225         force = 1;
5226
5227     if (force || rxi_connAbortThreshhold == 0
5228         || conn->abortCount < rxi_connAbortThreshhold) {
5229
5230         rxevent_Cancel(&conn->delayedAbortEvent, NULL, 0);
5231         error = htonl(conn->error);
5232         conn->abortCount++;
5233         MUTEX_EXIT(&conn->conn_data_lock);
5234         packet =
5235             rxi_SendSpecial((struct rx_call *)0, conn, packet,
5236                             RX_PACKET_TYPE_ABORT, (char *)&error,
5237                             sizeof(error), istack);
5238         MUTEX_ENTER(&conn->conn_data_lock);
5239     } else if (!conn->delayedAbortEvent) {
5240         clock_GetTime(&now);
5241         when = now;
5242         clock_Addmsec(&when, rxi_connAbortDelay);
5243         conn->delayedAbortEvent =
5244             rxevent_Post(&when, &now, rxi_SendDelayedConnAbort, conn, NULL, 0);
5245     }
5246     return packet;
5247 }
5248
5249 /* Associate an error all of the calls owned by a connection.  Called
5250  * with error non-zero.  This is only for really fatal things, like
5251  * bad authentication responses.  The connection itself is set in
5252  * error at this point, so that future packets received will be
5253  * rejected. */
5254 void
5255 rxi_ConnectionError(struct rx_connection *conn,
5256                     afs_int32 error)
5257 {
5258     if (error) {
5259         int i;
5260
5261         dpf(("rxi_ConnectionError conn %"AFS_PTR_FMT" error %d\n", conn, error));
5262
5263         MUTEX_ENTER(&conn->conn_data_lock);
5264         rxevent_Cancel(&conn->challengeEvent, NULL, 0);
5265         rxevent_Cancel(&conn->natKeepAliveEvent, NULL, 0);
5266         if (conn->checkReachEvent) {
5267             rxevent_Cancel(&conn->checkReachEvent, NULL, 0);
5268             conn->flags &= ~(RX_CONN_ATTACHWAIT|RX_CONN_NAT_PING);
5269             putConnection(conn);
5270         }
5271         MUTEX_EXIT(&conn->conn_data_lock);
5272         for (i = 0; i < RX_MAXCALLS; i++) {
5273             struct rx_call *call = conn->call[i];
5274             if (call) {
5275                 MUTEX_ENTER(&call->lock);
5276                 rxi_CallError(call, error);
5277                 MUTEX_EXIT(&call->lock);
5278             }
5279         }
5280         conn->error = error;
5281         if (rx_stats_active)
5282             rx_atomic_inc(&rx_stats.fatalErrors);
5283     }
5284 }
5285
5286 /**
5287  * Interrupt an in-progress call with the specified error and wakeup waiters.
5288  *
5289  * @param[in] call  The call to interrupt
5290  * @param[in] error  The error code to send to the peer
5291  */
5292 void
5293 rx_InterruptCall(struct rx_call *call, afs_int32 error)
5294 {
5295     MUTEX_ENTER(&call->lock);
5296     rxi_CallError(call, error);
5297     rxi_SendCallAbort(call, NULL, 0, 1);
5298     MUTEX_EXIT(&call->lock);
5299 }
5300
5301 void
5302 rxi_CallError(struct rx_call *call, afs_int32 error)
5303 {
5304 #ifdef DEBUG
5305     osirx_AssertMine(&call->lock, "rxi_CallError");
5306 #endif
5307     dpf(("rxi_CallError call %"AFS_PTR_FMT" error %d call->error %d\n", call, error, call->error));
5308     if (call->error)
5309         error = call->error;
5310
5311 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
5312     if (!((call->flags & RX_CALL_TQ_BUSY) || (call->tqWaiters > 0))) {
5313         rxi_ResetCall(call, 0);
5314     }
5315 #else
5316     rxi_ResetCall(call, 0);
5317 #endif
5318     call->error = error;
5319 }
5320
5321 /* Reset various fields in a call structure, and wakeup waiting
5322  * processes.  Some fields aren't changed: state & mode are not
5323  * touched (these must be set by the caller), and bufptr, nLeft, and
5324  * nFree are not reset, since these fields are manipulated by
5325  * unprotected macros, and may only be reset by non-interrupting code.
5326  */
5327
5328 static void
5329 rxi_ResetCall(struct rx_call *call, int newcall)
5330 {
5331     int flags;
5332     struct rx_peer *peer;
5333     struct rx_packet *packet;
5334 #ifdef DEBUG
5335     osirx_AssertMine(&call->lock, "rxi_ResetCall");
5336 #endif
5337     dpf(("rxi_ResetCall(call %"AFS_PTR_FMT", newcall %d)\n", call, newcall));
5338
5339     /* Notify anyone who is waiting for asynchronous packet arrival */
5340     if (call->arrivalProc) {
5341         (*call->arrivalProc) (call, call->arrivalProcHandle,
5342                               call->arrivalProcArg);
5343         call->arrivalProc = (void (*)())0;
5344     }
5345
5346
5347     rxevent_Cancel(&call->growMTUEvent, call, RX_CALL_REFCOUNT_MTU);
5348
5349     if (call->delayedAbortEvent) {
5350         rxevent_Cancel(&call->delayedAbortEvent, call, RX_CALL_REFCOUNT_ABORT);
5351         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
5352         if (packet) {
5353             rxi_SendCallAbort(call, packet, 0, 1);
5354             rxi_FreePacket(packet);
5355         }
5356     }
5357
5358     /*
5359      * Update the peer with the congestion information in this call
5360      * so other calls on this connection can pick up where this call
5361      * left off. If the congestion sequence numbers don't match then
5362      * another call experienced a retransmission.
5363      */
5364     peer = call->conn->peer;
5365     MUTEX_ENTER(&peer->peer_lock);
5366     if (!newcall) {
5367         if (call->congestSeq == peer->congestSeq) {
5368             peer->cwind = MAX(peer->cwind, call->cwind);
5369             peer->MTU = MAX(peer->MTU, call->MTU);
5370             peer->nDgramPackets =
5371                 MAX(peer->nDgramPackets, call->nDgramPackets);
5372         }
5373     } else {
5374         call->abortCode = 0;
5375         call->abortCount = 0;
5376     }
5377     if (peer->maxDgramPackets > 1) {
5378         call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
5379     } else {
5380         call->MTU = peer->MTU;
5381     }
5382     call->cwind = MIN((int)peer->cwind, (int)peer->nDgramPackets);
5383     call->ssthresh = rx_maxSendWindow;
5384     call->nDgramPackets = peer->nDgramPackets;
5385     call->congestSeq = peer->congestSeq;
5386     call->rtt = peer->rtt;
5387     call->rtt_dev = peer->rtt_dev;
5388     clock_Zero(&call->rto);
5389     clock_Addmsec(&call->rto,
5390                   MAX(((call->rtt >> 3) + call->rtt_dev), rx_minPeerTimeout) + 200);
5391     MUTEX_EXIT(&peer->peer_lock);
5392
5393     flags = call->flags;
5394 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
5395     rxi_WaitforTQBusy(call);
5396 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
5397
5398     rxi_ClearTransmitQueue(call, 1);
5399     if (call->tqWaiters || (flags & RX_CALL_TQ_WAIT)) {
5400         dpf(("rcall %"AFS_PTR_FMT" has %d waiters and flags %d\n", call, call->tqWaiters, call->flags));
5401     }
5402     call->flags = 0;
5403
5404     if (!newcall && (flags & RX_CALL_PEER_BUSY)) {
5405         /* The call channel is still busy; resetting the call doesn't change
5406          * that. However, if 'newcall' is set, we are processing a call
5407          * structure that has either been recycled from the free list, or has
5408          * been newly allocated. So, RX_CALL_PEER_BUSY is not relevant if
5409          * 'newcall' is set, since it describes a completely different call
5410          * channel which we do not care about. */
5411         call->flags |= RX_CALL_PEER_BUSY;
5412     }
5413
5414     rxi_ClearReceiveQueue(call);
5415     /* why init the queue if you just emptied it? queue_Init(&call->rq); */
5416
5417
5418     call->error = 0;
5419     call->twind = call->conn->twind[call->channel];
5420     call->rwind = call->conn->rwind[call->channel];
5421     call->nSoftAcked = 0;
5422     call->nextCwind = 0;
5423     call->nAcks = 0;
5424     call->nNacks = 0;
5425     call->nCwindAcks = 0;
5426     call->nSoftAcks = 0;
5427     call->nHardAcks = 0;
5428
5429     call->tfirst = call->rnext = call->tnext = 1;
5430     call->tprev = 0;
5431     call->rprev = 0;
5432     call->lastAcked = 0;
5433     call->localStatus = call->remoteStatus = 0;
5434
5435     if (flags & RX_CALL_READER_WAIT) {
5436 #ifdef  RX_ENABLE_LOCKS
5437         CV_BROADCAST(&call->cv_rq);
5438 #else
5439         osi_rxWakeup(&call->rq);
5440 #endif
5441     }
5442     if (flags & RX_CALL_WAIT_PACKETS) {
5443         MUTEX_ENTER(&rx_freePktQ_lock);
5444         rxi_PacketsUnWait();    /* XXX */
5445         MUTEX_EXIT(&rx_freePktQ_lock);
5446     }
5447 #ifdef  RX_ENABLE_LOCKS
5448     CV_SIGNAL(&call->cv_twind);
5449 #else
5450     if (flags & RX_CALL_WAIT_WINDOW_ALLOC)
5451         osi_rxWakeup(&call->twind);
5452 #endif
5453
5454     if (flags & RX_CALL_WAIT_PROC) {
5455         rx_atomic_dec(&rx_nWaiting);
5456     }
5457 #ifdef RX_ENABLE_LOCKS
5458     /* The following ensures that we don't mess with any queue while some
5459      * other thread might also be doing so. The call_queue_lock field is
5460      * is only modified under the call lock. If the call is in the process
5461      * of being removed from a queue, the call is not locked until the
5462      * the queue lock is dropped and only then is the call_queue_lock field
5463      * zero'd out. So it's safe to lock the queue if call_queue_lock is set.
5464      * Note that any other routine which removes a call from a queue has to
5465      * obtain the queue lock before examing the queue and removing the call.
5466      */
5467     if (call->call_queue_lock) {
5468         MUTEX_ENTER(call->call_queue_lock);
5469         if (opr_queue_IsOnQueue(&call->entry)) {
5470             opr_queue_Remove(&call->entry);
5471         }
5472         MUTEX_EXIT(call->call_queue_lock);
5473         CLEAR_CALL_QUEUE_LOCK(call);
5474     }
5475 #else /* RX_ENABLE_LOCKS */
5476     if (opr_queue_IsOnQueue(&call->entry)) {
5477         opr_queue_Remove(&call->entry);
5478     }
5479 #endif /* RX_ENABLE_LOCKS */
5480
5481     rxi_KeepAliveOff(call);
5482     rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
5483 }
5484
5485 /* Send an acknowledge for the indicated packet (seq,serial) of the
5486  * indicated call, for the indicated reason (reason).  This
5487  * acknowledge will specifically acknowledge receiving the packet, and
5488  * will also specify which other packets for this call have been
5489  * received.  This routine returns the packet that was used to the
5490  * caller.  The caller is responsible for freeing it or re-using it.
5491  * This acknowledgement also returns the highest sequence number
5492  * actually read out by the higher level to the sender; the sender
5493  * promises to keep around packets that have not been read by the
5494  * higher level yet (unless, of course, the sender decides to abort
5495  * the call altogether).  Any of p, seq, serial, pflags, or reason may
5496  * be set to zero without ill effect.  That is, if they are zero, they
5497  * will not convey any information.
5498  * NOW there is a trailer field, after the ack where it will safely be
5499  * ignored by mundanes, which indicates the maximum size packet this
5500  * host can swallow.  */
5501 /*
5502     struct rx_packet *optionalPacket;  use to send ack (or null)
5503     int seq;                     Sequence number of the packet we are acking
5504     int serial;                  Serial number of the packet
5505     int pflags;                  Flags field from packet header
5506     int reason;                  Reason an acknowledge was prompted
5507 */
5508
5509 struct rx_packet *
5510 rxi_SendAck(struct rx_call *call,
5511             struct rx_packet *optionalPacket, int serial, int reason,
5512             int istack)
5513 {
5514     struct rx_ackPacket *ap;
5515     struct rx_packet *p;
5516     struct opr_queue *cursor;
5517     u_char offset = 0;
5518     afs_int32 templ;
5519     afs_uint32 padbytes = 0;
5520 #ifdef RX_ENABLE_TSFPQ
5521     struct rx_ts_info_t * rx_ts_info;
5522 #endif
5523
5524     /*
5525      * Open the receive window once a thread starts reading packets
5526      */
5527     if (call->rnext > 1) {
5528         call->conn->rwind[call->channel] = call->rwind = rx_maxReceiveWindow;
5529     }
5530
5531     /* Don't attempt to grow MTU if this is a critical ping */
5532     if (reason == RX_ACK_MTU) {
5533         /* keep track of per-call attempts, if we're over max, do in small
5534          * otherwise in larger? set a size to increment by, decrease
5535          * on failure, here?
5536          */
5537         if (call->conn->peer->maxPacketSize &&
5538             (call->conn->peer->maxPacketSize < OLD_MAX_PACKET_SIZE
5539              +RX_IPUDP_SIZE))
5540             padbytes = call->conn->peer->maxPacketSize+16;
5541         else
5542             padbytes = call->conn->peer->maxMTU + 128;
5543
5544         /* do always try a minimum size ping */
5545         padbytes = MAX(padbytes, RX_MIN_PACKET_SIZE+RX_IPUDP_SIZE+4);
5546
5547         /* subtract the ack payload */
5548         padbytes -= (rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32));
5549         reason = RX_ACK_PING;
5550     }
5551
5552     call->nHardAcks = 0;
5553     call->nSoftAcks = 0;
5554     if (call->rnext > call->lastAcked)
5555         call->lastAcked = call->rnext;
5556     p = optionalPacket;
5557
5558     if (p) {
5559         rx_computelen(p, p->length);    /* reset length, you never know */
5560     } /* where that's been...         */
5561 #ifdef RX_ENABLE_TSFPQ
5562     else {
5563         RX_TS_INFO_GET(rx_ts_info);
5564         if ((p = rx_ts_info->local_special_packet)) {
5565             rx_computelen(p, p->length);
5566         } else if ((p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL))) {
5567             rx_ts_info->local_special_packet = p;
5568         } else { /* We won't send the ack, but don't panic. */
5569             return optionalPacket;
5570         }
5571     }
5572 #else
5573     else if (!(p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL))) {
5574         /* We won't send the ack, but don't panic. */
5575         return optionalPacket;
5576     }
5577 #endif
5578
5579     templ = padbytes +
5580         rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32) -
5581         rx_GetDataSize(p);
5582     if (templ > 0) {
5583         if (rxi_AllocDataBuf(p, templ, RX_PACKET_CLASS_SPECIAL) > 0) {
5584 #ifndef RX_ENABLE_TSFPQ
5585             if (!optionalPacket)
5586                 rxi_FreePacket(p);
5587 #endif
5588             return optionalPacket;
5589         }
5590         templ = rx_AckDataSize(call->rwind) + 2 * sizeof(afs_int32);
5591         if (rx_Contiguous(p) < templ) {
5592 #ifndef RX_ENABLE_TSFPQ
5593             if (!optionalPacket)
5594                 rxi_FreePacket(p);
5595 #endif
5596             return optionalPacket;
5597         }
5598     }
5599
5600
5601     /* MTUXXX failing to send an ack is very serious.  We should */
5602     /* try as hard as possible to send even a partial ack; it's */
5603     /* better than nothing. */
5604     ap = (struct rx_ackPacket *)rx_DataOf(p);
5605     ap->bufferSpace = htonl(0); /* Something should go here, sometime */
5606     ap->reason = reason;
5607
5608     /* The skew computation used to be bogus, I think it's better now. */
5609     /* We should start paying attention to skew.    XXX  */
5610     ap->serial = htonl(serial);
5611     ap->maxSkew = 0;            /* used to be peer->inPacketSkew */
5612
5613     /*
5614      * First packet not yet forwarded to reader. When ACKALL has been
5615      * sent the peer has been told that all received packets will be
5616      * delivered to the reader.  The value 'rnext' is used internally
5617      * to refer to the next packet in the receive queue that must be
5618      * delivered to the reader.  From the perspective of the peer it
5619      * already has so report the last sequence number plus one if there
5620      * are packets in the receive queue awaiting processing.
5621      */
5622     if ((call->flags & RX_CALL_ACKALL_SENT) &&
5623         !opr_queue_IsEmpty(&call->rq)) {
5624         ap->firstPacket = htonl(opr_queue_Last(&call->rq, struct rx_packet, entry)->header.seq + 1);
5625     } else {
5626         ap->firstPacket = htonl(call->rnext);
5627
5628         ap->previousPacket = htonl(call->rprev);        /* Previous packet received */
5629
5630         /* No fear of running out of ack packet here because there can only
5631          * be at most one window full of unacknowledged packets.  The window
5632          * size must be constrained to be less than the maximum ack size,
5633          * of course.  Also, an ack should always fit into a single packet
5634          * -- it should not ever be fragmented.  */
5635         offset = 0;
5636         for (opr_queue_Scan(&call->rq, cursor)) {
5637             struct rx_packet *rqp
5638                 = opr_queue_Entry(cursor, struct rx_packet, entry);
5639
5640             if (!rqp || !call->rq.next
5641                 || (rqp->header.seq > (call->rnext + call->rwind))) {
5642 #ifndef RX_ENABLE_TSFPQ
5643                 if (!optionalPacket)
5644                     rxi_FreePacket(p);
5645 #endif
5646                 rxi_CallError(call, RX_CALL_DEAD);
5647                 return optionalPacket;
5648             }
5649
5650             while (rqp->header.seq > call->rnext + offset)
5651                 ap->acks[offset++] = RX_ACK_TYPE_NACK;
5652             ap->acks[offset++] = RX_ACK_TYPE_ACK;
5653
5654             if ((offset > (u_char) rx_maxReceiveWindow) || (offset > call->rwind)) {
5655 #ifndef RX_ENABLE_TSFPQ
5656                 if (!optionalPacket)
5657                     rxi_FreePacket(p);
5658 #endif
5659                 rxi_CallError(call, RX_CALL_DEAD);
5660                 return optionalPacket;
5661             }
5662         }
5663     }
5664
5665     ap->nAcks = offset;
5666     p->length = rx_AckDataSize(offset) + 4 * sizeof(afs_int32);
5667
5668     /* these are new for AFS 3.3 */
5669     templ = rxi_AdjustMaxMTU(call->conn->peer->ifMTU, rx_maxReceiveSize);
5670     templ = htonl(templ);
5671     rx_packetwrite(p, rx_AckDataSize(offset), sizeof(afs_int32), &templ);
5672     templ = htonl(call->conn->peer->ifMTU);
5673     rx_packetwrite(p, rx_AckDataSize(offset) + sizeof(afs_int32),
5674                    sizeof(afs_int32), &templ);
5675
5676     /* new for AFS 3.4 */
5677     templ = htonl(call->rwind);
5678     rx_packetwrite(p, rx_AckDataSize(offset) + 2 * sizeof(afs_int32),
5679                    sizeof(afs_int32), &templ);
5680
5681     /* new for AFS 3.5 */
5682     templ = htonl(call->conn->peer->ifDgramPackets);
5683     rx_packetwrite(p, rx_AckDataSize(offset) + 3 * sizeof(afs_int32),
5684                    sizeof(afs_int32), &templ);
5685
5686     p->header.serviceId = call->conn->serviceId;
5687     p->header.cid = (call->conn->cid | call->channel);
5688     p->header.callNumber = *call->callNumber;
5689     p->header.seq = 0;
5690     p->header.securityIndex = call->conn->securityIndex;
5691     p->header.epoch = call->conn->epoch;
5692     p->header.type = RX_PACKET_TYPE_ACK;
5693     p->header.flags = RX_SLOW_START_OK;
5694     if (reason == RX_ACK_PING) {
5695         p->header.flags |= RX_REQUEST_ACK;
5696         if (padbytes) {
5697             p->length = padbytes +
5698                 rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32);
5699
5700             while (padbytes--)
5701                 /* not fast but we can potentially use this if truncated
5702                  * fragments are delivered to figure out the mtu.
5703                  */
5704                 rx_packetwrite(p, rx_AckDataSize(offset) + 4 *
5705                                sizeof(afs_int32), sizeof(afs_int32),
5706                                &padbytes);
5707         }
5708     }
5709     if (call->conn->type == RX_CLIENT_CONNECTION)
5710         p->header.flags |= RX_CLIENT_INITIATED;
5711
5712 #ifdef RXDEBUG
5713 #ifdef AFS_NT40_ENV
5714     if (rxdebug_active) {
5715         char msg[512];
5716         size_t len;
5717
5718         len = _snprintf(msg, sizeof(msg),
5719                         "tid[%d] SACK: reason %s serial %u previous %u seq %u first %u acks %u space %u ",
5720                          GetCurrentThreadId(), rx_ack_reason(ap->reason),
5721                          ntohl(ap->serial), ntohl(ap->previousPacket),
5722                          (unsigned int)p->header.seq, ntohl(ap->firstPacket),
5723                          ap->nAcks, ntohs(ap->bufferSpace) );
5724         if (ap->nAcks) {
5725             int offset;
5726
5727             for (offset = 0; offset < ap->nAcks && len < sizeof(msg); offset++)
5728                 msg[len++] = (ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*');
5729         }
5730         msg[len++]='\n';
5731         msg[len] = '\0';
5732         OutputDebugString(msg);
5733     }
5734 #else /* AFS_NT40_ENV */
5735     if (rx_Log) {
5736         fprintf(rx_Log, "SACK: reason %x previous %u seq %u first %u ",
5737                 ap->reason, ntohl(ap->previousPacket),
5738                 (unsigned int)p->header.seq, ntohl(ap->firstPacket));
5739         if (ap->nAcks) {
5740             for (offset = 0; offset < ap->nAcks; offset++)
5741                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
5742                      rx_Log);
5743         }
5744         putc('\n', rx_Log);
5745     }
5746 #endif /* AFS_NT40_ENV */
5747 #endif
5748     {
5749         int i, nbytes = p->length;
5750
5751         for (i = 1; i < p->niovecs; i++) {      /* vec 0 is ALWAYS header */
5752             if (nbytes <= p->wirevec[i].iov_len) {
5753                 int savelen, saven;
5754
5755                 savelen = p->wirevec[i].iov_len;
5756                 saven = p->niovecs;
5757                 p->wirevec[i].iov_len = nbytes;
5758                 p->niovecs = i + 1;
5759                 rxi_Send(call, p, istack);
5760                 p->wirevec[i].iov_len = savelen;
5761                 p->niovecs = saven;
5762                 break;
5763             } else
5764                 nbytes -= p->wirevec[i].iov_len;
5765         }
5766     }
5767     if (rx_stats_active)
5768         rx_atomic_inc(&rx_stats.ackPacketsSent);
5769 #ifndef RX_ENABLE_TSFPQ
5770     if (!optionalPacket)
5771         rxi_FreePacket(p);
5772 #endif
5773     return optionalPacket;      /* Return packet for re-use by caller */
5774 }
5775
5776 struct xmitlist {
5777    struct rx_packet **list;
5778    int len;
5779    int resending;
5780 };
5781
5782 /* Send all of the packets in the list in single datagram */
5783 static void
5784 rxi_SendList(struct rx_call *call, struct xmitlist *xmit,
5785              int istack, int moreFlag)
5786 {
5787     int i;
5788     int requestAck = 0;
5789     int lastPacket = 0;
5790     struct clock now;
5791     struct rx_connection *conn = call->conn;
5792     struct rx_peer *peer = conn->peer;
5793
5794     MUTEX_ENTER(&peer->peer_lock);
5795     peer->nSent += xmit->len;
5796     if (xmit->resending)
5797         peer->reSends += xmit->len;
5798     MUTEX_EXIT(&peer->peer_lock);
5799
5800     if (rx_stats_active) {
5801         if (xmit->resending)
5802             rx_atomic_add(&rx_stats.dataPacketsReSent, xmit->len);
5803         else
5804             rx_atomic_add(&rx_stats.dataPacketsSent, xmit->len);
5805     }
5806
5807     clock_GetTime(&now);
5808
5809     if (xmit->list[xmit->len - 1]->header.flags & RX_LAST_PACKET) {
5810         lastPacket = 1;
5811     }
5812
5813     /* Set the packet flags and schedule the resend events */
5814     /* Only request an ack for the last packet in the list */
5815     for (i = 0; i < xmit->len; i++) {
5816         struct rx_packet *packet = xmit->list[i];
5817
5818         /* Record the time sent */
5819         packet->timeSent = now;
5820         packet->flags |= RX_PKTFLAG_SENT;
5821
5822         /* Ask for an ack on retransmitted packets,  on every other packet
5823          * if the peer doesn't support slow start. Ask for an ack on every
5824          * packet until the congestion window reaches the ack rate. */
5825         if (packet->header.serial) {
5826             requestAck = 1;
5827         } else {
5828             packet->firstSent = now;
5829             if (!lastPacket && (call->cwind <= (u_short) (conn->ackRate + 1)
5830                                 || (!(call->flags & RX_CALL_SLOW_START_OK)
5831                                     && (packet->header.seq & 1)))) {
5832                 requestAck = 1;
5833             }
5834         }
5835
5836         /* Tag this packet as not being the last in this group,
5837          * for the receiver's benefit */
5838         if (i < xmit->len - 1 || moreFlag) {
5839             packet->header.flags |= RX_MORE_PACKETS;
5840         }
5841     }
5842
5843     if (requestAck) {
5844         xmit->list[xmit->len - 1]->header.flags |= RX_REQUEST_ACK;
5845     }
5846
5847     /* Since we're about to send a data packet to the peer, it's
5848      * safe to nuke any scheduled end-of-packets ack */
5849     rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
5850
5851     MUTEX_EXIT(&call->lock);
5852     CALL_HOLD(call, RX_CALL_REFCOUNT_SEND);
5853     if (xmit->len > 1) {
5854         rxi_SendPacketList(call, conn, xmit->list, xmit->len, istack);
5855     } else {
5856         rxi_SendPacket(call, conn, xmit->list[0], istack);
5857     }
5858     MUTEX_ENTER(&call->lock);
5859     CALL_RELE(call, RX_CALL_REFCOUNT_SEND);
5860
5861     /* Tell the RTO calculation engine that we have sent a packet, and
5862      * if it was the last one */
5863     rxi_rto_packet_sent(call, lastPacket, istack);
5864
5865     /* Update last send time for this call (for keep-alive
5866      * processing), and for the connection (so that we can discover
5867      * idle connections) */
5868     conn->lastSendTime = call->lastSendTime = clock_Sec();
5869     /* Let a set of retransmits trigger an idle timeout */
5870     if (!xmit->resending)
5871         call->lastSendData = call->lastSendTime;
5872 }
5873
5874 /* When sending packets we need to follow these rules:
5875  * 1. Never send more than maxDgramPackets in a jumbogram.
5876  * 2. Never send a packet with more than two iovecs in a jumbogram.
5877  * 3. Never send a retransmitted packet in a jumbogram.
5878  * 4. Never send more than cwind/4 packets in a jumbogram
5879  * We always keep the last list we should have sent so we
5880  * can set the RX_MORE_PACKETS flags correctly.
5881  */
5882
5883 static void
5884 rxi_SendXmitList(struct rx_call *call, struct rx_packet **list, int len,
5885                  int istack)
5886 {
5887     int i;
5888     int recovery;
5889     struct xmitlist working;
5890     struct xmitlist last;
5891
5892     struct rx_peer *peer = call->conn->peer;
5893     int morePackets = 0;
5894
5895     memset(&last, 0, sizeof(struct xmitlist));
5896     working.list = &list[0];
5897     working.len = 0;
5898     working.resending = 0;
5899
5900     recovery = call->flags & RX_CALL_FAST_RECOVER;
5901
5902     for (i = 0; i < len; i++) {
5903         /* Does the current packet force us to flush the current list? */
5904         if (working.len > 0
5905             && (list[i]->header.serial || (list[i]->flags & RX_PKTFLAG_ACKED)
5906                 || list[i]->length > RX_JUMBOBUFFERSIZE)) {
5907
5908             /* This sends the 'last' list and then rolls the current working
5909              * set into the 'last' one, and resets the working set */
5910
5911             if (last.len > 0) {
5912                 rxi_SendList(call, &last, istack, 1);
5913                 /* If the call enters an error state stop sending, or if
5914                  * we entered congestion recovery mode, stop sending */
5915                 if (call->error
5916                     || (!recovery && (call->flags & RX_CALL_FAST_RECOVER)))
5917                     return;
5918             }
5919             last = working;
5920             working.len = 0;
5921             working.resending = 0;
5922             working.list = &list[i];
5923         }
5924         /* Add the current packet to the list if it hasn't been acked.
5925          * Otherwise adjust the list pointer to skip the current packet.  */
5926         if (!(list[i]->flags & RX_PKTFLAG_ACKED)) {
5927             working.len++;
5928
5929             if (list[i]->header.serial)
5930                 working.resending = 1;
5931
5932             /* Do we need to flush the list? */
5933             if (working.len >= (int)peer->maxDgramPackets
5934                 || working.len >= (int)call->nDgramPackets
5935                 || working.len >= (int)call->cwind
5936                 || list[i]->header.serial
5937                 || list[i]->length != RX_JUMBOBUFFERSIZE) {
5938                 if (last.len > 0) {
5939                     rxi_SendList(call, &last, istack, 1);
5940                     /* If the call enters an error state stop sending, or if
5941                      * we entered congestion recovery mode, stop sending */
5942                     if (call->error
5943                         || (!recovery && (call->flags & RX_CALL_FAST_RECOVER)))
5944                         return;
5945                 }
5946                 last = working;
5947                 working.len = 0;
5948                 working.resending = 0;
5949                 working.list = &list[i + 1];
5950             }
5951         } else {
5952             if (working.len != 0) {
5953                 osi_Panic("rxi_SendList error");
5954             }
5955             working.list = &list[i + 1];
5956         }
5957     }
5958
5959     /* Send the whole list when the call is in receive mode, when
5960      * the call is in eof mode, when we are in fast recovery mode,
5961      * and when we have the last packet */
5962     if ((list[len - 1]->header.flags & RX_LAST_PACKET)
5963         || call->mode == RX_MODE_RECEIVING || call->mode == RX_MODE_EOF
5964         || (call->flags & RX_CALL_FAST_RECOVER)) {
5965         /* Check for the case where the current list contains
5966          * an acked packet. Since we always send retransmissions
5967          * in a separate packet, we only need to check the first
5968          * packet in the list */
5969         if (working.len > 0 && !(working.list[0]->flags & RX_PKTFLAG_ACKED)) {
5970             morePackets = 1;
5971         }
5972         if (last.len > 0) {
5973             rxi_SendList(call, &last, istack, morePackets);
5974             /* If the call enters an error state stop sending, or if
5975              * we entered congestion recovery mode, stop sending */
5976             if (call->error
5977                 || (!recovery && (call->flags & RX_CALL_FAST_RECOVER)))
5978                 return;
5979         }
5980         if (morePackets) {
5981             rxi_SendList(call, &working, istack, 0);
5982         }
5983     } else if (last.len > 0) {
5984         rxi_SendList(call, &last, istack, 0);
5985         /* Packets which are in 'working' are not sent by this call */
5986     }
5987 }
5988
5989 /**
5990  * Check if the peer for the given call is known to be dead
5991  *
5992  * If the call's peer appears dead (it has encountered fatal network errors
5993  * since the call started) the call is killed with RX_CALL_DEAD if the call
5994  * is active. Otherwise, we do nothing.
5995  *
5996  * @param[in] call  The call to check
5997  *
5998  * @return status
5999  *  @retval 0 The call is fine, and we haven't done anything to the call
6000  *  @retval nonzero The call's peer appears dead, and the call has been
6001  *                  terminated if it was active
6002  *
6003  * @pre call->lock must be locked
6004  */
6005 static int
6006 rxi_CheckPeerDead(struct rx_call *call)
6007 {
6008 #ifdef AFS_RXERRQ_ENV
6009     int peererrs;
6010
6011     if (call->state == RX_STATE_DALLY) {
6012         return 0;
6013     }
6014
6015     peererrs = rx_atomic_read(&call->conn->peer->neterrs);
6016     if (call->neterr_gen < peererrs) {
6017         /* we have received network errors since this call started; kill
6018          * the call */
6019         if (call->state == RX_STATE_ACTIVE) {
6020             rxi_CallError(call, RX_CALL_DEAD);
6021         }
6022         return -1;
6023     }
6024     if (call->neterr_gen > peererrs) {
6025         /* someone has reset the number of peer errors; set the call error gen
6026          * so we can detect if more errors are encountered */
6027         call->neterr_gen = peererrs;
6028     }
6029 #endif
6030     return 0;
6031 }
6032
6033 static void
6034 rxi_Resend(struct rxevent *event, void *arg0, void *arg1, int istack)
6035 {
6036     struct rx_call *call = arg0;
6037     struct rx_peer *peer;
6038     struct opr_queue *cursor;
6039     struct clock maxTimeout = { 60, 0 };
6040
6041     MUTEX_ENTER(&call->lock);
6042
6043     peer = call->conn->peer;
6044
6045     /* Make sure that the event pointer is removed from the call
6046      * structure, since there is no longer a per-call retransmission
6047      * event pending. */
6048     if (event == call->resendEvent) {
6049         CALL_RELE(call, RX_CALL_REFCOUNT_RESEND);
6050         rxevent_Put(call->resendEvent);
6051         call->resendEvent = NULL;
6052     }
6053
6054     rxi_CheckPeerDead(call);
6055
6056     if (rxi_busyChannelError && (call->flags & RX_CALL_PEER_BUSY)) {
6057         rxi_CheckBusy(call);
6058     }
6059
6060     if (opr_queue_IsEmpty(&call->tq)) {
6061         /* Nothing to do. This means that we've been raced, and that an
6062          * ACK has come in between when we were triggered, and when we
6063          * actually got to run. */
6064         goto out;
6065     }
6066
6067     /* We're in loss recovery */
6068     call->flags |= RX_CALL_FAST_RECOVER;
6069
6070     /* Mark all of the pending packets in the queue as being lost */
6071     for (opr_queue_Scan(&call->tq, cursor)) {
6072         struct rx_packet *p = opr_queue_Entry(cursor, struct rx_packet, entry);
6073         if (!(p->flags & RX_PKTFLAG_ACKED))
6074             p->flags &= ~RX_PKTFLAG_SENT;
6075     }
6076
6077     /* We're resending, so we double the timeout of the call. This will be
6078      * dropped back down by the first successful ACK that we receive.
6079      *
6080      * We apply a maximum value here of 60 seconds
6081      */
6082     clock_Add(&call->rto, &call->rto);
6083     if (clock_Gt(&call->rto, &maxTimeout))
6084         call->rto = maxTimeout;
6085
6086     /* Packet loss is most likely due to congestion, so drop our window size
6087      * and start again from the beginning */
6088     if (peer->maxDgramPackets >1) {
6089         call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
6090         call->MTU = MIN(peer->natMTU, peer->maxMTU);
6091     }
6092     call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
6093     call->nDgramPackets = 1;
6094     call->cwind = 1;
6095     call->nextCwind = 1;
6096     call->nAcks = 0;
6097     call->nNacks = 0;
6098     MUTEX_ENTER(&peer->peer_lock);
6099     peer->MTU = call->MTU;
6100     peer->cwind = call->cwind;
6101     peer->nDgramPackets = 1;
6102     peer->congestSeq++;
6103     call->congestSeq = peer->congestSeq;
6104     MUTEX_EXIT(&peer->peer_lock);
6105
6106     rxi_Start(call, istack);
6107
6108 out:
6109     MUTEX_EXIT(&call->lock);
6110 }
6111
6112 /* This routine is called when new packets are readied for
6113  * transmission and when retransmission may be necessary, or when the
6114  * transmission window or burst count are favourable.  This should be
6115  * better optimized for new packets, the usual case, now that we've
6116  * got rid of queues of send packets. XXXXXXXXXXX */
6117 void
6118 rxi_Start(struct rx_call *call, int istack)
6119 {
6120     struct opr_queue *cursor;
6121 #ifdef RX_ENABLE_LOCKS
6122     struct opr_queue *store;
6123 #endif
6124     int nXmitPackets;
6125     int maxXmitPackets;
6126
6127     if (call->error) {
6128 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
6129         if (rx_stats_active)
6130             rx_atomic_inc(&rx_tq_debug.rxi_start_in_error);
6131 #endif
6132         return;
6133     }
6134
6135     if (!opr_queue_IsEmpty(&call->tq)) {        /* If we have anything to send */
6136         /* Send (or resend) any packets that need it, subject to
6137          * window restrictions and congestion burst control
6138          * restrictions.  Ask for an ack on the last packet sent in
6139          * this burst.  For now, we're relying upon the window being
6140          * considerably bigger than the largest number of packets that
6141          * are typically sent at once by one initial call to
6142          * rxi_Start.  This is probably bogus (perhaps we should ask
6143          * for an ack when we're half way through the current
6144          * window?).  Also, for non file transfer applications, this
6145          * may end up asking for an ack for every packet.  Bogus. XXXX
6146          */
6147         /*
6148          * But check whether we're here recursively, and let the other guy
6149          * do the work.
6150          */
6151 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
6152         if (!(call->flags & RX_CALL_TQ_BUSY)) {
6153             call->flags |= RX_CALL_TQ_BUSY;
6154             do {
6155 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
6156             restart:
6157 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
6158                 call->flags &= ~RX_CALL_NEED_START;
6159 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
6160                 nXmitPackets = 0;
6161                 maxXmitPackets = MIN(call->twind, call->cwind);
6162                 for (opr_queue_Scan(&call->tq, cursor)) {
6163                     struct rx_packet *p
6164                         = opr_queue_Entry(cursor, struct rx_packet, entry);
6165
6166                     if (p->flags & RX_PKTFLAG_ACKED) {
6167                         /* Since we may block, don't trust this */
6168                         if (rx_stats_active)
6169                             rx_atomic_inc(&rx_stats.ignoreAckedPacket);
6170                         continue;       /* Ignore this packet if it has been acknowledged */
6171                     }
6172
6173                     /* Turn off all flags except these ones, which are the same
6174                      * on each transmission */
6175                     p->header.flags &= RX_PRESET_FLAGS;
6176
6177                     if (p->header.seq >=
6178                         call->tfirst + MIN((int)call->twind,
6179                                            (int)(call->nSoftAcked +
6180                                                  call->cwind))) {
6181                         call->flags |= RX_CALL_WAIT_WINDOW_SEND;        /* Wait for transmit window */
6182                         /* Note: if we're waiting for more window space, we can
6183                          * still send retransmits; hence we don't return here, but
6184                          * break out to schedule a retransmit event */
6185                         dpf(("call %d waiting for window (seq %d, twind %d, nSoftAcked %d, cwind %d)\n",
6186                              *(call->callNumber), p->header.seq, call->twind, call->nSoftAcked,
6187                              call->cwind));
6188                         break;
6189                     }
6190
6191                     /* Transmit the packet if it needs to be sent. */
6192                     if (!(p->flags & RX_PKTFLAG_SENT)) {
6193                         if (nXmitPackets == maxXmitPackets) {
6194                             rxi_SendXmitList(call, call->xmitList,
6195                                              nXmitPackets, istack);
6196                             goto restart;
6197                         }
6198                         dpf(("call %d xmit packet %"AFS_PTR_FMT"\n",
6199                               *(call->callNumber), p));
6200                         call->xmitList[nXmitPackets++] = p;
6201                     }
6202                 } /* end of the queue_Scan */
6203
6204                 /* xmitList now hold pointers to all of the packets that are
6205                  * ready to send. Now we loop to send the packets */
6206                 if (nXmitPackets > 0) {
6207                     rxi_SendXmitList(call, call->xmitList, nXmitPackets,
6208                                      istack);
6209                 }
6210
6211 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
6212                 if (call->error) {
6213                     /* We went into the error state while sending packets. Now is
6214                      * the time to reset the call. This will also inform the using
6215                      * process that the call is in an error state.
6216                      */
6217                     if (rx_stats_active)
6218                         rx_atomic_inc(&rx_tq_debug.rxi_start_aborted);
6219                     call->flags &= ~RX_CALL_TQ_BUSY;
6220                     rxi_WakeUpTransmitQueue(call);
6221                     rxi_CallError(call, call->error);
6222                     return;
6223                 }
6224 #ifdef RX_ENABLE_LOCKS
6225                 if (call->flags & RX_CALL_TQ_SOME_ACKED) {
6226                     int missing;
6227                     call->flags &= ~RX_CALL_TQ_SOME_ACKED;
6228                     /* Some packets have received acks. If they all have, we can clear
6229                      * the transmit queue.
6230                      */
6231                     missing = 0;
6232                     for (opr_queue_ScanSafe(&call->tq, cursor, store)) {
6233                         struct rx_packet *p
6234                             = opr_queue_Entry(cursor, struct rx_packet, entry);
6235
6236                         if (p->header.seq < call->tfirst
6237                             && (p->flags & RX_PKTFLAG_ACKED)) {
6238                             opr_queue_Remove(&p->entry);
6239 #ifdef RX_TRACK_PACKETS
6240                             p->flags &= ~RX_PKTFLAG_TQ;
6241 #endif
6242 #ifdef RXDEBUG_PACKET
6243                             call->tqc--;
6244 #endif
6245                             rxi_FreePacket(p);
6246                         } else
6247                             missing = 1;
6248                     }
6249                     if (!missing)
6250                         call->flags |= RX_CALL_TQ_CLEARME;
6251                 }
6252 #endif /* RX_ENABLE_LOCKS */
6253                 if (call->flags & RX_CALL_TQ_CLEARME)
6254                     rxi_ClearTransmitQueue(call, 1);
6255             } while (call->flags & RX_CALL_NEED_START);
6256             /*
6257              * TQ references no longer protected by this flag; they must remain
6258              * protected by the global lock.
6259              */
6260             call->flags &= ~RX_CALL_TQ_BUSY;
6261             rxi_WakeUpTransmitQueue(call);
6262         } else {
6263             call->flags |= RX_CALL_NEED_START;
6264         }
6265 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
6266     } else {
6267         rxi_rto_cancel(call);
6268     }
6269 }
6270
6271 /* Also adjusts the keep alive parameters for the call, to reflect
6272  * that we have just sent a packet (so keep alives aren't sent
6273  * immediately) */
6274 void
6275 rxi_Send(struct rx_call *call, struct rx_packet *p,
6276          int istack)
6277 {
6278     struct rx_connection *conn = call->conn;
6279
6280     /* Stamp each packet with the user supplied status */
6281     p->header.userStatus = call->localStatus;
6282
6283     /* Allow the security object controlling this call's security to
6284      * make any last-minute changes to the packet */
6285     RXS_SendPacket(conn->securityObject, call, p);
6286
6287     /* Since we're about to send SOME sort of packet to the peer, it's
6288      * safe to nuke any scheduled end-of-packets ack */
6289     rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
6290
6291     /* Actually send the packet, filling in more connection-specific fields */
6292     MUTEX_EXIT(&call->lock);
6293     CALL_HOLD(call, RX_CALL_REFCOUNT_SEND);
6294     rxi_SendPacket(call, conn, p, istack);
6295     CALL_RELE(call, RX_CALL_REFCOUNT_SEND);
6296     MUTEX_ENTER(&call->lock);
6297
6298     /* Update last send time for this call (for keep-alive
6299      * processing), and for the connection (so that we can discover
6300      * idle connections) */
6301     if ((p->header.type != RX_PACKET_TYPE_ACK) ||
6302         (((struct rx_ackPacket *)rx_DataOf(p))->reason == RX_ACK_PING) ||
6303         (p->length <= (rx_AckDataSize(call->rwind) + 4 * sizeof(afs_int32))))
6304     {
6305         conn->lastSendTime = call->lastSendTime = clock_Sec();
6306         /* Don't count keepalive ping/acks here, so idleness can be tracked. */
6307         if ((p->header.type != RX_PACKET_TYPE_ACK) ||
6308             ((((struct rx_ackPacket *)rx_DataOf(p))->reason != RX_ACK_PING) &&
6309              (((struct rx_ackPacket *)rx_DataOf(p))->reason !=
6310               RX_ACK_PING_RESPONSE)))
6311             call->lastSendData = call->lastSendTime;
6312     }
6313 }
6314
6315 /* Check if a call needs to be destroyed.  Called by keep-alive code to ensure
6316  * that things are fine.  Also called periodically to guarantee that nothing
6317  * falls through the cracks (e.g. (error + dally) connections have keepalive
6318  * turned off.  Returns 0 if conn is well, -1 otherwise.  If otherwise, call
6319  *  may be freed!
6320  * haveCTLock Set if calling from rxi_ReapConnections
6321  */
6322 #ifdef RX_ENABLE_LOCKS
6323 static int
6324 rxi_CheckCall(struct rx_call *call, int haveCTLock)
6325 #else /* RX_ENABLE_LOCKS */
6326 static int
6327 rxi_CheckCall(struct rx_call *call)
6328 #endif                          /* RX_ENABLE_LOCKS */
6329 {
6330     struct rx_connection *conn = call->conn;
6331     afs_uint32 now;
6332     afs_uint32 deadTime, idleDeadTime = 0, hardDeadTime = 0;
6333     afs_uint32 fudgeFactor;
6334     int cerror = 0;
6335     int newmtu = 0;
6336     int idle_timeout = 0;
6337     afs_int32  clock_diff = 0;
6338
6339     if (rxi_CheckPeerDead(call)) {
6340         return -1;
6341     }
6342
6343     now = clock_Sec();
6344
6345     /* Large swings in the clock can have a significant impact on
6346      * the performance of RX call processing.  Forward clock shifts
6347      * will result in premature event triggering or timeouts.
6348      * Backward shifts can result in calls not completing until
6349      * the clock catches up with the original start clock value.
6350      *
6351      * If a backward clock shift of more than five minutes is noticed,
6352      * just fail the call.
6353      */
6354     if (now < call->lastSendTime)
6355         clock_diff = call->lastSendTime - now;
6356     if (now < call->startWait)
6357         clock_diff = MAX(clock_diff, call->startWait - now);
6358     if (now < call->lastReceiveTime)
6359         clock_diff = MAX(clock_diff, call->lastReceiveTime - now);
6360     if (clock_diff > 5 * 60)
6361     {
6362         if (call->state == RX_STATE_ACTIVE)
6363             rxi_CallError(call, RX_CALL_TIMEOUT);
6364         return -1;
6365     }
6366
6367 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
6368     if (call->flags & RX_CALL_TQ_BUSY) {
6369         /* Call is active and will be reset by rxi_Start if it's
6370          * in an error state.
6371          */
6372         return 0;
6373     }
6374 #endif
6375     /* RTT + 8*MDEV, rounded up to the next second. */
6376     fudgeFactor = (((afs_uint32) call->rtt >> 3) +
6377                    ((afs_uint32) call->rtt_dev << 1) + 1023) >> 10;
6378
6379     deadTime = conn->secondsUntilDead + fudgeFactor;
6380     /* These are computed to the second (+- 1 second).  But that's
6381      * good enough for these values, which should be a significant
6382      * number of seconds. */
6383     if (now > (call->lastReceiveTime + deadTime)) {
6384         if (call->state == RX_STATE_ACTIVE) {
6385 #ifdef AFS_ADAPT_PMTU
6386 # if defined(KERNEL) && defined(AFS_SUN5_ENV)
6387             ire_t *ire;
6388 #  if defined(AFS_SUN510_ENV) && defined(GLOBAL_NETSTACKID)
6389             netstack_t *ns = netstack_find_by_stackid(GLOBAL_NETSTACKID);
6390             ip_stack_t *ipst = ns->netstack_ip;
6391 #  endif
6392             ire = ire_cache_lookup(conn->peer->host
6393 #  if defined(AFS_SUN510_ENV) && defined(ALL_ZONES)
6394                                    , ALL_ZONES
6395 #    if defined(ICL_3_ARG) || defined(GLOBAL_NETSTACKID)
6396                                    , NULL
6397 #     if defined(GLOBAL_NETSTACKID)
6398                                    , ipst
6399 #     endif
6400 #    endif
6401 #  endif
6402                 );
6403
6404             if (ire && ire->ire_max_frag > 0)
6405                 rxi_SetPeerMtu(NULL, conn->peer->host, 0,
6406                                ire->ire_max_frag);
6407 #  if defined(GLOBAL_NETSTACKID)
6408             netstack_rele(ns);
6409 #  endif
6410 # endif
6411 #endif /* AFS_ADAPT_PMTU */
6412             cerror = RX_CALL_DEAD;
6413             goto mtuout;
6414         } else {
6415 #ifdef RX_ENABLE_LOCKS
6416             /* Cancel pending events */
6417             rxevent_Cancel(&call->delayedAckEvent, call,
6418                            RX_CALL_REFCOUNT_DELAY);
6419             rxi_rto_cancel(call);
6420             rxevent_Cancel(&call->keepAliveEvent, call,
6421                            RX_CALL_REFCOUNT_ALIVE);
6422             rxevent_Cancel(&call->growMTUEvent, call,
6423                            RX_CALL_REFCOUNT_MTU);
6424             MUTEX_ENTER(&rx_refcnt_mutex);
6425             /* if rxi_FreeCall returns 1 it has freed the call */
6426             if (call->refCount == 0 &&
6427                 rxi_FreeCall(call, haveCTLock))
6428             {
6429                 MUTEX_EXIT(&rx_refcnt_mutex);
6430                 return -2;
6431             }
6432             MUTEX_EXIT(&rx_refcnt_mutex);
6433             return -1;
6434 #else /* RX_ENABLE_LOCKS */
6435             rxi_FreeCall(call, 0);
6436             return -2;
6437 #endif /* RX_ENABLE_LOCKS */
6438         }
6439         /* Non-active calls are destroyed if they are not responding
6440          * to pings; active calls are simply flagged in error, so the
6441          * attached process can die reasonably gracefully. */
6442     }
6443
6444     if (conn->idleDeadDetection) {
6445         if (conn->idleDeadTime) {
6446             idleDeadTime = conn->idleDeadTime + fudgeFactor;
6447         }
6448
6449         if (idleDeadTime) {
6450             /* see if we have a non-activity timeout */
6451             if (call->startWait && ((call->startWait + idleDeadTime) < now) &&
6452                 (call->flags & RX_CALL_READER_WAIT)) {
6453                 if (call->state == RX_STATE_ACTIVE) {
6454                     cerror = RX_CALL_TIMEOUT;
6455                     goto mtuout;
6456                 }
6457             }
6458
6459             if (call->lastSendData && ((call->lastSendData + idleDeadTime) < now)) {
6460                 if (call->state == RX_STATE_ACTIVE) {
6461                     cerror = conn->service ? conn->service->idleDeadErr : RX_CALL_IDLE;
6462                     idle_timeout = 1;
6463                     goto mtuout;
6464                 }
6465             }
6466         }
6467     }
6468
6469     if (conn->hardDeadTime) {
6470         hardDeadTime = conn->hardDeadTime + fudgeFactor;
6471     }
6472
6473     /* see if we have a hard timeout */
6474     if (hardDeadTime
6475         && (now > (hardDeadTime + call->startTime.sec))) {
6476         if (call->state == RX_STATE_ACTIVE)
6477             rxi_CallError(call, RX_CALL_TIMEOUT);
6478         return -1;
6479     }
6480     return 0;
6481 mtuout:
6482     if (conn->msgsizeRetryErr && cerror != RX_CALL_TIMEOUT && !idle_timeout &&
6483         call->lastReceiveTime) {
6484         int oldMTU = conn->peer->ifMTU;
6485
6486         /* if we thought we could send more, perhaps things got worse */
6487         if (conn->peer->maxPacketSize > conn->lastPacketSize)
6488             /* maxpacketsize will be cleared in rxi_SetPeerMtu */
6489             newmtu = MAX(conn->peer->maxPacketSize-RX_IPUDP_SIZE,
6490                          conn->lastPacketSize-(128+RX_IPUDP_SIZE));
6491         else
6492             newmtu = conn->lastPacketSize-(128+RX_IPUDP_SIZE);
6493
6494         /* minimum capped in SetPeerMtu */
6495         rxi_SetPeerMtu(conn->peer, 0, 0, newmtu);
6496
6497         /* clean up */
6498         conn->lastPacketSize = 0;
6499
6500         /* needed so ResetCall doesn't clobber us. */
6501         call->MTU = conn->peer->ifMTU;
6502
6503         /* if we never succeeded, let the error pass out as-is */
6504         if (conn->peer->maxPacketSize && oldMTU != conn->peer->ifMTU)
6505             cerror = conn->msgsizeRetryErr;
6506
6507     }
6508     rxi_CallError(call, cerror);
6509     return -1;
6510 }
6511
6512 void
6513 rxi_NatKeepAliveEvent(struct rxevent *event, void *arg1,
6514                       void *dummy, int dummy2)
6515 {
6516     struct rx_connection *conn = arg1;
6517     struct rx_header theader;
6518     char tbuffer[1 + sizeof(struct rx_header)];
6519     struct sockaddr_in taddr;
6520     char *tp;
6521     char a[1] = { 0 };
6522     struct iovec tmpiov[2];
6523     osi_socket socket =
6524         (conn->type ==
6525          RX_CLIENT_CONNECTION ? rx_socket : conn->service->socket);
6526
6527
6528     tp = &tbuffer[sizeof(struct rx_header)];
6529     taddr.sin_family = AF_INET;
6530     taddr.sin_port = rx_PortOf(rx_PeerOf(conn));
6531     taddr.sin_addr.s_addr = rx_HostOf(rx_PeerOf(conn));
6532 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
6533     taddr.sin_len = sizeof(struct sockaddr_in);
6534 #endif
6535     memset(&theader, 0, sizeof(theader));
6536     theader.epoch = htonl(999);
6537     theader.cid = 0;
6538     theader.callNumber = 0;
6539     theader.seq = 0;
6540     theader.serial = 0;
6541     theader.type = RX_PACKET_TYPE_VERSION;
6542     theader.flags = RX_LAST_PACKET;
6543     theader.serviceId = 0;
6544
6545     memcpy(tbuffer, &theader, sizeof(theader));
6546     memcpy(tp, &a, sizeof(a));
6547     tmpiov[0].iov_base = tbuffer;
6548     tmpiov[0].iov_len = 1 + sizeof(struct rx_header);
6549
6550     osi_NetSend(socket, &taddr, tmpiov, 1, 1 + sizeof(struct rx_header), 1);
6551
6552     MUTEX_ENTER(&conn->conn_data_lock);
6553     MUTEX_ENTER(&rx_refcnt_mutex);
6554     /* Only reschedule ourselves if the connection would not be destroyed */
6555     if (conn->refCount <= 1) {
6556         rxevent_Put(conn->natKeepAliveEvent);
6557         conn->natKeepAliveEvent = NULL;
6558         MUTEX_EXIT(&rx_refcnt_mutex);
6559         MUTEX_EXIT(&conn->conn_data_lock);
6560         rx_DestroyConnection(conn); /* drop the reference for this */
6561     } else {
6562         conn->refCount--; /* drop the reference for this */
6563         MUTEX_EXIT(&rx_refcnt_mutex);
6564         rxevent_Put(conn->natKeepAliveEvent);
6565         conn->natKeepAliveEvent = NULL;
6566         rxi_ScheduleNatKeepAliveEvent(conn);
6567         MUTEX_EXIT(&conn->conn_data_lock);
6568     }
6569 }
6570
6571 static void
6572 rxi_ScheduleNatKeepAliveEvent(struct rx_connection *conn)
6573 {
6574     if (!conn->natKeepAliveEvent && conn->secondsUntilNatPing) {
6575         struct clock when, now;
6576         clock_GetTime(&now);
6577         when = now;
6578         when.sec += conn->secondsUntilNatPing;
6579         MUTEX_ENTER(&rx_refcnt_mutex);
6580         conn->refCount++; /* hold a reference for this */
6581         MUTEX_EXIT(&rx_refcnt_mutex);
6582         conn->natKeepAliveEvent =
6583             rxevent_Post(&when, &now, rxi_NatKeepAliveEvent, conn, NULL, 0);
6584     }
6585 }
6586
6587 void
6588 rx_SetConnSecondsUntilNatPing(struct rx_connection *conn, afs_int32 seconds)
6589 {
6590     MUTEX_ENTER(&conn->conn_data_lock);
6591     conn->secondsUntilNatPing = seconds;
6592     if (seconds != 0) {
6593         if (!(conn->flags & RX_CONN_ATTACHWAIT))
6594             rxi_ScheduleNatKeepAliveEvent(conn);
6595         else
6596             conn->flags |= RX_CONN_NAT_PING;
6597     }
6598     MUTEX_EXIT(&conn->conn_data_lock);
6599 }
6600
6601 /* When a call is in progress, this routine is called occasionally to
6602  * make sure that some traffic has arrived (or been sent to) the peer.
6603  * If nothing has arrived in a reasonable amount of time, the call is
6604  * declared dead; if nothing has been sent for a while, we send a
6605  * keep-alive packet (if we're actually trying to keep the call alive)
6606  */
6607 void
6608 rxi_KeepAliveEvent(struct rxevent *event, void *arg1, void *dummy,
6609                    int dummy2)
6610 {
6611     struct rx_call *call = arg1;
6612     struct rx_connection *conn;
6613     afs_uint32 now;
6614
6615     CALL_RELE(call, RX_CALL_REFCOUNT_ALIVE);
6616     MUTEX_ENTER(&call->lock);
6617
6618     if (event == call->keepAliveEvent) {
6619         rxevent_Put(call->keepAliveEvent);
6620         call->keepAliveEvent = NULL;
6621     }
6622
6623     now = clock_Sec();
6624
6625 #ifdef RX_ENABLE_LOCKS
6626     if (rxi_CheckCall(call, 0)) {
6627         MUTEX_EXIT(&call->lock);
6628         return;
6629     }
6630 #else /* RX_ENABLE_LOCKS */
6631     if (rxi_CheckCall(call))
6632         return;
6633 #endif /* RX_ENABLE_LOCKS */
6634
6635     /* Don't try to keep alive dallying calls */
6636     if (call->state == RX_STATE_DALLY) {
6637         MUTEX_EXIT(&call->lock);
6638         return;
6639     }
6640
6641     conn = call->conn;
6642     if ((now - call->lastSendTime) > conn->secondsUntilPing) {
6643         /* Don't try to send keepalives if there is unacknowledged data */
6644         /* the rexmit code should be good enough, this little hack
6645          * doesn't quite work XXX */
6646         (void)rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
6647     }
6648     rxi_ScheduleKeepAliveEvent(call);
6649     MUTEX_EXIT(&call->lock);
6650 }
6651
6652 /* Does what's on the nameplate. */
6653 void
6654 rxi_GrowMTUEvent(struct rxevent *event, void *arg1, void *dummy, int dummy2)
6655 {
6656     struct rx_call *call = arg1;
6657     struct rx_connection *conn;
6658
6659     CALL_RELE(call, RX_CALL_REFCOUNT_MTU);
6660     MUTEX_ENTER(&call->lock);
6661
6662     if (event == call->growMTUEvent) {
6663         rxevent_Put(call->growMTUEvent);
6664         call->growMTUEvent = NULL;
6665     }
6666
6667 #ifdef RX_ENABLE_LOCKS
6668     if (rxi_CheckCall(call, 0)) {
6669         MUTEX_EXIT(&call->lock);
6670         return;
6671     }
6672 #else /* RX_ENABLE_LOCKS */
6673     if (rxi_CheckCall(call))
6674         return;
6675 #endif /* RX_ENABLE_LOCKS */
6676
6677     /* Don't bother with dallying calls */
6678     if (call->state == RX_STATE_DALLY) {
6679         MUTEX_EXIT(&call->lock);
6680         return;
6681     }
6682
6683     conn = call->conn;
6684
6685     /*
6686      * keep being scheduled, just don't do anything if we're at peak,
6687      * or we're not set up to be properly handled (idle timeout required)
6688      */
6689     if ((conn->peer->maxPacketSize != 0) &&
6690         (conn->peer->natMTU < RX_MAX_PACKET_SIZE) &&
6691         conn->idleDeadDetection)
6692         (void)rxi_SendAck(call, NULL, 0, RX_ACK_MTU, 0);
6693     rxi_ScheduleGrowMTUEvent(call, 0);
6694     MUTEX_EXIT(&call->lock);
6695 }
6696
6697 static void
6698 rxi_ScheduleKeepAliveEvent(struct rx_call *call)
6699 {
6700     if (!call->keepAliveEvent) {
6701         struct clock when, now;
6702         clock_GetTime(&now);
6703         when = now;
6704         when.sec += call->conn->secondsUntilPing;
6705         CALL_HOLD(call, RX_CALL_REFCOUNT_ALIVE);
6706         call->keepAliveEvent =
6707             rxevent_Post(&when, &now, rxi_KeepAliveEvent, call, NULL, 0);
6708     }
6709 }
6710
6711 static void
6712 rxi_ScheduleGrowMTUEvent(struct rx_call *call, int secs)
6713 {
6714     if (!call->growMTUEvent) {
6715         struct clock when, now;
6716
6717         clock_GetTime(&now);
6718         when = now;
6719         if (!secs) {
6720             if (call->conn->secondsUntilPing)
6721                 secs = (6*call->conn->secondsUntilPing)-1;
6722
6723             if (call->conn->secondsUntilDead)
6724                 secs = MIN(secs, (call->conn->secondsUntilDead-1));
6725         }
6726
6727         when.sec += secs;
6728         CALL_HOLD(call, RX_CALL_REFCOUNT_MTU);
6729         call->growMTUEvent =
6730             rxevent_Post(&when, &now, rxi_GrowMTUEvent, call, NULL, 0);
6731     }
6732 }
6733
6734 /* N.B. rxi_KeepAliveOff:  is defined earlier as a macro */
6735 static void
6736 rxi_KeepAliveOn(struct rx_call *call)
6737 {
6738     /* Pretend last packet received was received now--i.e. if another
6739      * packet isn't received within the keep alive time, then the call
6740      * will die; Initialize last send time to the current time--even
6741      * if a packet hasn't been sent yet.  This will guarantee that a
6742      * keep-alive is sent within the ping time */
6743     call->lastReceiveTime = call->lastSendTime = clock_Sec();
6744     rxi_ScheduleKeepAliveEvent(call);
6745 }
6746
6747 /*
6748  * Solely in order that callers not need to include rx_call.h
6749  */
6750 void
6751 rx_KeepAliveOff(struct rx_call *call)
6752 {
6753     rxi_KeepAliveOff(call);
6754 }
6755 void
6756 rx_KeepAliveOn(struct rx_call *call)
6757 {
6758     rxi_KeepAliveOn(call);
6759 }
6760
6761 static void
6762 rxi_GrowMTUOn(struct rx_call *call)
6763 {
6764     struct rx_connection *conn = call->conn;
6765     MUTEX_ENTER(&conn->conn_data_lock);
6766     conn->lastPingSizeSer = conn->lastPingSize = 0;
6767     MUTEX_EXIT(&conn->conn_data_lock);
6768     rxi_ScheduleGrowMTUEvent(call, 1);
6769 }
6770
6771 /* This routine is called to send connection abort messages
6772  * that have been delayed to throttle looping clients. */
6773 static void
6774 rxi_SendDelayedConnAbort(struct rxevent *event, void *arg1, void *unused,
6775                          int unused2)
6776 {
6777     struct rx_connection *conn = arg1;
6778
6779     afs_int32 error;
6780     struct rx_packet *packet;
6781
6782     MUTEX_ENTER(&conn->conn_data_lock);
6783     rxevent_Put(conn->delayedAbortEvent);
6784     conn->delayedAbortEvent = NULL;
6785     error = htonl(conn->error);
6786     conn->abortCount++;
6787     MUTEX_EXIT(&conn->conn_data_lock);
6788     packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
6789     if (packet) {
6790         packet =
6791             rxi_SendSpecial((struct rx_call *)0, conn, packet,
6792                             RX_PACKET_TYPE_ABORT, (char *)&error,
6793                             sizeof(error), 0);
6794         rxi_FreePacket(packet);
6795     }
6796 }
6797
6798 /* This routine is called to send call abort messages
6799  * that have been delayed to throttle looping clients. */
6800 static void
6801 rxi_SendDelayedCallAbort(struct rxevent *event, void *arg1, void *dummy,
6802                          int dummy2)
6803 {
6804     struct rx_call *call = arg1;
6805
6806     afs_int32 error;
6807     struct rx_packet *packet;
6808
6809     MUTEX_ENTER(&call->lock);
6810     rxevent_Put(call->delayedAbortEvent);
6811     call->delayedAbortEvent = NULL;
6812     error = htonl(call->error);
6813     call->abortCount++;
6814     packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
6815     if (packet) {
6816         packet =
6817             rxi_SendSpecial(call, call->conn, packet, RX_PACKET_TYPE_ABORT,
6818                             (char *)&error, sizeof(error), 0);
6819         rxi_FreePacket(packet);
6820     }
6821     MUTEX_EXIT(&call->lock);
6822     CALL_RELE(call, RX_CALL_REFCOUNT_ABORT);
6823 }
6824
6825 /* This routine is called periodically (every RX_AUTH_REQUEST_TIMEOUT
6826  * seconds) to ask the client to authenticate itself.  The routine
6827  * issues a challenge to the client, which is obtained from the
6828  * security object associated with the connection */
6829 static void
6830 rxi_ChallengeEvent(struct rxevent *event,
6831                    void *arg0, void *arg1, int tries)
6832 {
6833     struct rx_connection *conn = arg0;
6834
6835     if (event) {
6836         rxevent_Put(conn->challengeEvent);
6837         conn->challengeEvent = NULL;
6838     }
6839
6840     if (RXS_CheckAuthentication(conn->securityObject, conn) != 0) {
6841         struct rx_packet *packet;
6842         struct clock when, now;
6843
6844         if (tries <= 0) {
6845             /* We've failed to authenticate for too long.
6846              * Reset any calls waiting for authentication;
6847              * they are all in RX_STATE_PRECALL.
6848              */
6849             int i;
6850
6851             MUTEX_ENTER(&conn->conn_call_lock);
6852             for (i = 0; i < RX_MAXCALLS; i++) {
6853                 struct rx_call *call = conn->call[i];
6854                 if (call) {
6855                     MUTEX_ENTER(&call->lock);
6856                     if (call->state == RX_STATE_PRECALL) {
6857                         rxi_CallError(call, RX_CALL_DEAD);
6858                         rxi_SendCallAbort(call, NULL, 0, 0);
6859                     }
6860                     MUTEX_EXIT(&call->lock);
6861                 }
6862             }
6863             MUTEX_EXIT(&conn->conn_call_lock);
6864             return;
6865         }
6866
6867         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
6868         if (packet) {
6869             /* If there's no packet available, do this later. */
6870             RXS_GetChallenge(conn->securityObject, conn, packet);
6871             rxi_SendSpecial((struct rx_call *)0, conn, packet,
6872                             RX_PACKET_TYPE_CHALLENGE, NULL, -1, 0);
6873             rxi_FreePacket(packet);
6874         }
6875         clock_GetTime(&now);
6876         when = now;
6877         when.sec += RX_CHALLENGE_TIMEOUT;
6878         conn->challengeEvent =
6879             rxevent_Post(&when, &now, rxi_ChallengeEvent, conn, 0,
6880                          (tries - 1));
6881     }
6882 }
6883
6884 /* Call this routine to start requesting the client to authenticate
6885  * itself.  This will continue until authentication is established,
6886  * the call times out, or an invalid response is returned.  The
6887  * security object associated with the connection is asked to create
6888  * the challenge at this time.  N.B.  rxi_ChallengeOff is a macro,
6889  * defined earlier. */
6890 static void
6891 rxi_ChallengeOn(struct rx_connection *conn)
6892 {
6893     if (!conn->challengeEvent) {
6894         RXS_CreateChallenge(conn->securityObject, conn);
6895         rxi_ChallengeEvent(NULL, conn, 0, RX_CHALLENGE_MAXTRIES);
6896     };
6897 }
6898
6899
6900 /* rxi_ComputeRoundTripTime is called with peer locked. */
6901 /* peer may be null */
6902 static void
6903 rxi_ComputeRoundTripTime(struct rx_packet *p,
6904                          struct rx_ackPacket *ack,
6905                          struct rx_call *call,
6906                          struct rx_peer *peer,
6907                          struct clock *now)
6908 {
6909     struct clock thisRtt, *sentp;
6910     int rtt_timeout;
6911     int serial;
6912
6913     /* If the ACK is delayed, then do nothing */
6914     if (ack->reason == RX_ACK_DELAY)
6915         return;
6916
6917     /* On the wire, jumbograms are a single UDP packet. We shouldn't count
6918      * their RTT multiple times, so only include the RTT of the last packet
6919      * in a jumbogram */
6920     if (p->flags & RX_JUMBO_PACKET)
6921         return;
6922
6923     /* Use the serial number to determine which transmission the ACK is for,
6924      * and set the sent time to match this. If we have no serial number, then
6925      * only use the ACK for RTT calculations if the packet has not been
6926      * retransmitted
6927      */
6928
6929     serial = ntohl(ack->serial);
6930     if (serial) {
6931         if (serial == p->header.serial) {
6932             sentp = &p->timeSent;
6933         } else if (serial == p->firstSerial) {
6934             sentp = &p->firstSent;
6935         } else if (clock_Eq(&p->timeSent, &p->firstSent)) {
6936             sentp = &p->firstSent;
6937         } else
6938             return;
6939     } else {
6940         if (clock_Eq(&p->timeSent, &p->firstSent)) {
6941             sentp = &p->firstSent;
6942         } else
6943             return;
6944     }
6945
6946     thisRtt = *now;
6947
6948     if (clock_Lt(&thisRtt, sentp))
6949         return;                 /* somebody set the clock back, don't count this time. */
6950
6951     clock_Sub(&thisRtt, sentp);
6952     dpf(("rxi_ComputeRoundTripTime(call=%d packet=%"AFS_PTR_FMT" rttp=%d.%06d sec)\n",
6953           p->header.callNumber, p, thisRtt.sec, thisRtt.usec));
6954
6955     if (clock_IsZero(&thisRtt)) {
6956         /*
6957          * The actual round trip time is shorter than the
6958          * clock_GetTime resolution.  It is most likely 1ms or 100ns.
6959          * Since we can't tell which at the moment we will assume 1ms.
6960          */
6961         thisRtt.usec = 1000;
6962     }
6963
6964     if (rx_stats_active) {
6965         MUTEX_ENTER(&rx_stats_mutex);
6966         if (clock_Lt(&thisRtt, &rx_stats.minRtt))
6967             rx_stats.minRtt = thisRtt;
6968         if (clock_Gt(&thisRtt, &rx_stats.maxRtt)) {
6969             if (thisRtt.sec > 60) {
6970                 MUTEX_EXIT(&rx_stats_mutex);
6971                 return;         /* somebody set the clock ahead */
6972             }
6973             rx_stats.maxRtt = thisRtt;
6974         }
6975         clock_Add(&rx_stats.totalRtt, &thisRtt);
6976         rx_atomic_inc(&rx_stats.nRttSamples);
6977         MUTEX_EXIT(&rx_stats_mutex);
6978     }
6979
6980     /* better rtt calculation courtesy of UMich crew (dave,larry,peter,?) */
6981
6982     /* Apply VanJacobson round-trip estimations */
6983     if (call->rtt) {
6984         int delta;
6985
6986         /*
6987          * srtt (call->rtt) is in units of one-eighth-milliseconds.
6988          * srtt is stored as fixed point with 3 bits after the binary
6989          * point (i.e., scaled by 8). The following magic is
6990          * equivalent to the smoothing algorithm in rfc793 with an
6991          * alpha of .875 (srtt' = rtt/8 + srtt*7/8 in fixed point).
6992          * srtt'*8 = rtt + srtt*7
6993          * srtt'*8 = srtt*8 + rtt - srtt
6994          * srtt' = srtt + rtt/8 - srtt/8
6995          * srtt' = srtt + (rtt - srtt)/8
6996          */
6997
6998         delta = _8THMSEC(&thisRtt) - call->rtt;
6999         call->rtt += (delta >> 3);
7000
7001         /*
7002          * We accumulate a smoothed rtt variance (actually, a smoothed
7003          * mean difference), then set the retransmit timer to smoothed
7004          * rtt + 4 times the smoothed variance (was 2x in van's original
7005          * paper, but 4x works better for me, and apparently for him as
7006          * well).
7007          * rttvar is stored as
7008          * fixed point with 2 bits after the binary point (scaled by
7009          * 4).  The following is equivalent to rfc793 smoothing with
7010          * an alpha of .75 (rttvar' = rttvar*3/4 + |delta| / 4).
7011          *   rttvar'*4 = rttvar*3 + |delta|
7012          *   rttvar'*4 = rttvar*4 + |delta| - rttvar
7013          *   rttvar' = rttvar + |delta|/4 - rttvar/4
7014          *   rttvar' = rttvar + (|delta| - rttvar)/4
7015          * This replaces rfc793's wired-in beta.
7016          * dev*4 = dev*4 + (|actual - expected| - dev)
7017          */
7018
7019         if (delta < 0)
7020             delta = -delta;
7021
7022         delta -= (call->rtt_dev << 1);
7023         call->rtt_dev += (delta >> 3);
7024     } else {
7025         /* I don't have a stored RTT so I start with this value.  Since I'm
7026          * probably just starting a call, and will be pushing more data down
7027          * this, I expect congestion to increase rapidly.  So I fudge a
7028          * little, and I set deviance to half the rtt.  In practice,
7029          * deviance tends to approach something a little less than
7030          * half the smoothed rtt. */
7031         call->rtt = _8THMSEC(&thisRtt) + 8;
7032         call->rtt_dev = call->rtt >> 2; /* rtt/2: they're scaled differently */
7033     }
7034     /* the smoothed RTT time is RTT + 4*MDEV
7035      *
7036      * We allow a user specified minimum to be set for this, to allow clamping
7037      * at a minimum value in the same way as TCP. In addition, we have to allow
7038      * for the possibility that this packet is answered by a delayed ACK, so we
7039      * add on a fixed 200ms to account for that timer expiring.
7040      */
7041
7042     rtt_timeout = MAX(((call->rtt >> 3) + call->rtt_dev),
7043                       rx_minPeerTimeout) + 200;
7044     clock_Zero(&call->rto);
7045     clock_Addmsec(&call->rto, rtt_timeout);
7046
7047     /* Update the peer, so any new calls start with our values */
7048     peer->rtt_dev = call->rtt_dev;
7049     peer->rtt = call->rtt;
7050
7051     dpf(("rxi_ComputeRoundTripTime(call=%d packet=%"AFS_PTR_FMT" rtt=%d ms, srtt=%d ms, rtt_dev=%d ms, timeout=%d.%06d sec)\n",
7052           p->header.callNumber, p, MSEC(&thisRtt), call->rtt >> 3, call->rtt_dev >> 2, (call->rto.sec), (call->rto.usec)));
7053 }
7054
7055
7056 /* Find all server connections that have not been active for a long time, and
7057  * toss them */
7058 static void
7059 rxi_ReapConnections(struct rxevent *unused, void *unused1, void *unused2,
7060                     int unused3)
7061 {
7062     struct clock now, when;
7063     clock_GetTime(&now);
7064
7065     /* Find server connection structures that haven't been used for
7066      * greater than rx_idleConnectionTime */
7067     {
7068         struct rx_connection **conn_ptr, **conn_end;
7069         int i, havecalls = 0;
7070         MUTEX_ENTER(&rx_connHashTable_lock);
7071         for (conn_ptr = &rx_connHashTable[0], conn_end =
7072              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
7073              conn_ptr++) {
7074             struct rx_connection *conn, *next;
7075             struct rx_call *call;
7076             int result;
7077
7078           rereap:
7079             for (conn = *conn_ptr; conn; conn = next) {
7080                 /* XXX -- Shouldn't the connection be locked? */
7081                 next = conn->next;
7082                 havecalls = 0;
7083                 for (i = 0; i < RX_MAXCALLS; i++) {
7084                     call = conn->call[i];
7085                     if (call) {
7086                         int code;
7087                         havecalls = 1;
7088                         code = MUTEX_TRYENTER(&call->lock);
7089                         if (!code)
7090                             continue;
7091 #ifdef RX_ENABLE_LOCKS
7092                         result = rxi_CheckCall(call, 1);
7093 #else /* RX_ENABLE_LOCKS */
7094                         result = rxi_CheckCall(call);
7095 #endif /* RX_ENABLE_LOCKS */
7096                         MUTEX_EXIT(&call->lock);
7097                         if (result == -2) {
7098                             /* If CheckCall freed the call, it might
7099                              * have destroyed  the connection as well,
7100                              * which screws up the linked lists.
7101                              */
7102                             goto rereap;
7103                         }
7104                     }
7105                 }
7106                 if (conn->type == RX_SERVER_CONNECTION) {
7107                     /* This only actually destroys the connection if
7108                      * there are no outstanding calls */
7109                     MUTEX_ENTER(&conn->conn_data_lock);
7110                     MUTEX_ENTER(&rx_refcnt_mutex);
7111                     if (!havecalls && !conn->refCount
7112                         && ((conn->lastSendTime + rx_idleConnectionTime) <
7113                             now.sec)) {
7114                         conn->refCount++;       /* it will be decr in rx_DestroyConn */
7115                         MUTEX_EXIT(&rx_refcnt_mutex);
7116                         MUTEX_EXIT(&conn->conn_data_lock);
7117 #ifdef RX_ENABLE_LOCKS
7118                         rxi_DestroyConnectionNoLock(conn);
7119 #else /* RX_ENABLE_LOCKS */
7120                         rxi_DestroyConnection(conn);
7121 #endif /* RX_ENABLE_LOCKS */
7122                     }
7123 #ifdef RX_ENABLE_LOCKS
7124                     else {
7125                         MUTEX_EXIT(&rx_refcnt_mutex);
7126                         MUTEX_EXIT(&conn->conn_data_lock);
7127                     }
7128 #endif /* RX_ENABLE_LOCKS */
7129                 }
7130             }
7131         }
7132 #ifdef RX_ENABLE_LOCKS
7133         while (rx_connCleanup_list) {
7134             struct rx_connection *conn;
7135             conn = rx_connCleanup_list;
7136             rx_connCleanup_list = rx_connCleanup_list->next;
7137             MUTEX_EXIT(&rx_connHashTable_lock);
7138             rxi_CleanupConnection(conn);
7139             MUTEX_ENTER(&rx_connHashTable_lock);
7140         }
7141         MUTEX_EXIT(&rx_connHashTable_lock);
7142 #endif /* RX_ENABLE_LOCKS */
7143     }
7144
7145     /* Find any peer structures that haven't been used (haven't had an
7146      * associated connection) for greater than rx_idlePeerTime */
7147     {
7148         struct rx_peer **peer_ptr, **peer_end;
7149         int code;
7150
7151         /*
7152          * Why do we need to hold the rx_peerHashTable_lock across
7153          * the incrementing of peer_ptr since the rx_peerHashTable
7154          * array is not changing?  We don't.
7155          *
7156          * By dropping the lock periodically we can permit other
7157          * activities to be performed while a rxi_ReapConnections
7158          * call is in progress.  The goal of reap connections
7159          * is to clean up quickly without causing large amounts
7160          * of contention.  Therefore, it is important that global
7161          * mutexes not be held for extended periods of time.
7162          */
7163         for (peer_ptr = &rx_peerHashTable[0], peer_end =
7164              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
7165              peer_ptr++) {
7166             struct rx_peer *peer, *next, *prev;
7167
7168             MUTEX_ENTER(&rx_peerHashTable_lock);
7169             for (prev = peer = *peer_ptr; peer; peer = next) {
7170                 next = peer->next;
7171                 code = MUTEX_TRYENTER(&peer->peer_lock);
7172                 if ((code) && (peer->refCount == 0)
7173                     && ((peer->idleWhen + rx_idlePeerTime) < now.sec)) {
7174                     struct opr_queue *cursor, *store;
7175                     size_t space;
7176
7177                     /*
7178                      * now know that this peer object is one to be
7179                      * removed from the hash table.  Once it is removed
7180                      * it can't be referenced by other threads.
7181                      * Lets remove it first and decrement the struct
7182                      * nPeerStructs count.
7183                      */
7184                     if (peer == *peer_ptr) {
7185                         *peer_ptr = next;
7186                         prev = next;
7187                     } else
7188                         prev->next = next;
7189
7190                     if (rx_stats_active)
7191                         rx_atomic_dec(&rx_stats.nPeerStructs);
7192
7193                     /*
7194                      * Now if we hold references on 'prev' and 'next'
7195                      * we can safely drop the rx_peerHashTable_lock
7196                      * while we destroy this 'peer' object.
7197                      */
7198                     if (next)
7199                         next->refCount++;
7200                     if (prev)
7201                         prev->refCount++;
7202                     MUTEX_EXIT(&rx_peerHashTable_lock);
7203
7204                     MUTEX_EXIT(&peer->peer_lock);
7205                     MUTEX_DESTROY(&peer->peer_lock);
7206
7207                     for (opr_queue_ScanSafe(&peer->rpcStats, cursor, store)) {
7208                         unsigned int num_funcs;
7209                         struct rx_interface_stat *rpc_stat
7210                             = opr_queue_Entry(cursor, struct rx_interface_stat,
7211                                              entry);
7212                         if (!rpc_stat)
7213                             break;
7214
7215                         opr_queue_Remove(&rpc_stat->entry);
7216                         opr_queue_Remove(&rpc_stat->entryPeers);
7217
7218                         num_funcs = rpc_stat->stats[0].func_total;
7219                         space =
7220                             sizeof(rx_interface_stat_t) +
7221                             rpc_stat->stats[0].func_total *
7222                             sizeof(rx_function_entry_v1_t);
7223
7224                         rxi_Free(rpc_stat, space);
7225
7226                         MUTEX_ENTER(&rx_rpc_stats);
7227                         rxi_rpc_peer_stat_cnt -= num_funcs;
7228                         MUTEX_EXIT(&rx_rpc_stats);
7229                     }
7230                     rxi_FreePeer(peer);
7231
7232                     /*
7233                      * Regain the rx_peerHashTable_lock and
7234                      * decrement the reference count on 'prev'
7235                      * and 'next'.
7236                      */
7237                     MUTEX_ENTER(&rx_peerHashTable_lock);
7238                     if (next)
7239                         next->refCount--;
7240                     if (prev)
7241                         prev->refCount--;
7242                 } else {
7243                     if (code) {
7244                         MUTEX_EXIT(&peer->peer_lock);
7245                     }
7246                     prev = peer;
7247                 }
7248             }
7249             MUTEX_EXIT(&rx_peerHashTable_lock);
7250         }
7251     }
7252
7253     /* THIS HACK IS A TEMPORARY HACK.  The idea is that the race condition in
7254      * rxi_AllocSendPacket, if it hits, will be handled at the next conn
7255      * GC, just below.  Really, we shouldn't have to keep moving packets from
7256      * one place to another, but instead ought to always know if we can
7257      * afford to hold onto a packet in its particular use.  */
7258     MUTEX_ENTER(&rx_freePktQ_lock);
7259     if (rx_waitingForPackets) {
7260         rx_waitingForPackets = 0;
7261 #ifdef  RX_ENABLE_LOCKS
7262         CV_BROADCAST(&rx_waitingForPackets_cv);
7263 #else
7264         osi_rxWakeup(&rx_waitingForPackets);
7265 #endif
7266     }
7267     MUTEX_EXIT(&rx_freePktQ_lock);
7268
7269     when = now;
7270     when.sec += RX_REAP_TIME;   /* Check every RX_REAP_TIME seconds */
7271     rxevent_Put(rxevent_Post(&when, &now, rxi_ReapConnections, 0, NULL, 0));
7272 }
7273
7274
7275 /* rxs_Release - This isn't strictly necessary but, since the macro name from
7276  * rx.h is sort of strange this is better.  This is called with a security
7277  * object before it is discarded.  Each connection using a security object has
7278  * its own refcount to the object so it won't actually be freed until the last
7279  * connection is destroyed.
7280  *
7281  * This is the only rxs module call.  A hold could also be written but no one
7282  * needs it. */
7283
7284 int
7285 rxs_Release(struct rx_securityClass *aobj)
7286 {
7287     return RXS_Close(aobj);
7288 }
7289
7290 void
7291 rxi_DebugInit(void)
7292 {
7293 #ifdef RXDEBUG
7294 #ifdef AFS_NT40_ENV
7295 #define TRACE_OPTION_RX_DEBUG 16
7296     HKEY parmKey;
7297     DWORD dummyLen;
7298     DWORD TraceOption;
7299     long code;
7300
7301     rxdebug_active = 0;
7302
7303     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
7304                          0, KEY_QUERY_VALUE, &parmKey);
7305     if (code != ERROR_SUCCESS)
7306         return;
7307
7308     dummyLen = sizeof(TraceOption);
7309     code = RegQueryValueEx(parmKey, "TraceOption", NULL, NULL,
7310                            (BYTE *) &TraceOption, &dummyLen);
7311     if (code == ERROR_SUCCESS) {
7312         rxdebug_active = (TraceOption & TRACE_OPTION_RX_DEBUG) ? 1 : 0;
7313     }
7314     RegCloseKey (parmKey);
7315 #endif /* AFS_NT40_ENV */
7316 #endif
7317 }
7318
7319 void
7320 rx_DebugOnOff(int on)
7321 {
7322 #ifdef RXDEBUG
7323 #ifdef AFS_NT40_ENV
7324     rxdebug_active = on;
7325 #endif
7326 #endif
7327 }
7328
7329 void
7330 rx_StatsOnOff(int on)
7331 {
7332     rx_stats_active = on;
7333 }
7334
7335
7336 /* Don't call this debugging routine directly; use dpf */
7337 void
7338 rxi_DebugPrint(char *format, ...)
7339 {
7340 #ifdef RXDEBUG
7341     va_list ap;
7342 #ifdef AFS_NT40_ENV
7343     char msg[512];
7344     char tformat[256];
7345     size_t len;
7346
7347     va_start(ap, format);
7348
7349     len = _snprintf(tformat, sizeof(tformat), "tid[%d] %s", GetCurrentThreadId(), format);
7350
7351     if (len > 0) {
7352         len = _vsnprintf(msg, sizeof(msg)-2, tformat, ap);
7353         if (len > 0)
7354             OutputDebugString(msg);
7355     }
7356     va_end(ap);
7357 #else
7358     struct clock now;
7359
7360     va_start(ap, format);
7361
7362     clock_GetTime(&now);
7363     fprintf(rx_Log, " %d.%06d:", (unsigned int)now.sec,
7364             (unsigned int)now.usec);
7365     vfprintf(rx_Log, format, ap);
7366     va_end(ap);
7367 #endif
7368 #endif
7369 }
7370
7371 #ifndef KERNEL
7372 /*
7373  * This function is used to process the rx_stats structure that is local
7374  * to a process as well as an rx_stats structure received from a remote
7375  * process (via rxdebug).  Therefore, it needs to do minimal version
7376  * checking.
7377  */
7378 void
7379 rx_PrintTheseStats(FILE * file, struct rx_statistics *s, int size,
7380                    afs_int32 freePackets, char version)
7381 {
7382     int i;
7383
7384     if (size != sizeof(struct rx_statistics)) {
7385         fprintf(file,
7386                 "Unexpected size of stats structure: was %d, expected %" AFS_SIZET_FMT "\n",
7387                 size, sizeof(struct rx_statistics));
7388     }
7389
7390     fprintf(file, "rx stats: free packets %d, allocs %d, ", (int)freePackets,
7391             s->packetRequests);
7392
7393     if (version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
7394         fprintf(file, "alloc-failures(rcv %u/%u,send %u/%u,ack %u)\n",
7395                 s->receivePktAllocFailures, s->receiveCbufPktAllocFailures,
7396                 s->sendPktAllocFailures, s->sendCbufPktAllocFailures,
7397                 s->specialPktAllocFailures);
7398     } else {
7399         fprintf(file, "alloc-failures(rcv %u,send %u,ack %u)\n",
7400                 s->receivePktAllocFailures, s->sendPktAllocFailures,
7401                 s->specialPktAllocFailures);
7402     }
7403
7404     fprintf(file,
7405             "   greedy %u, " "bogusReads %u (last from host %x), "
7406             "noPackets %u, " "noBuffers %u, " "selects %u, "
7407             "sendSelects %u\n", s->socketGreedy, s->bogusPacketOnRead,
7408             s->bogusHost, s->noPacketOnRead, s->noPacketBuffersOnRead,
7409             s->selects, s->sendSelects);
7410
7411     fprintf(file, "   packets read: ");
7412     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
7413         fprintf(file, "%s %u ", rx_packetTypes[i], s->packetsRead[i]);
7414     }
7415     fprintf(file, "\n");
7416
7417     fprintf(file,
7418             "   other read counters: data %u, " "ack %u, " "dup %u "
7419             "spurious %u " "dally %u\n", s->dataPacketsRead,
7420             s->ackPacketsRead, s->dupPacketsRead, s->spuriousPacketsRead,
7421             s->ignorePacketDally);
7422
7423     fprintf(file, "   packets sent: ");
7424     for (i = 0; i < RX_N_PACKET_TYPES; i++) {
7425         fprintf(file, "%s %u ", rx_packetTypes[i], s->packetsSent[i]);
7426     }
7427     fprintf(file, "\n");
7428
7429     fprintf(file,
7430             "   other send counters: ack %u, " "data %u (not resends), "
7431             "resends %u, " "pushed %u, " "acked&ignored %u\n",
7432             s->ackPacketsSent, s->dataPacketsSent, s->dataPacketsReSent,
7433             s->dataPacketsPushed, s->ignoreAckedPacket);
7434
7435     fprintf(file,
7436             "   \t(these should be small) sendFailed %u, " "fatalErrors %u\n",
7437             s->netSendFailures, (int)s->fatalErrors);
7438
7439     if (s->nRttSamples) {
7440         fprintf(file, "   Average rtt is %0.3f, with %d samples\n",
7441                 clock_Float(&s->totalRtt) / s->nRttSamples, s->nRttSamples);
7442
7443         fprintf(file, "   Minimum rtt is %0.3f, maximum is %0.3f\n",
7444                 clock_Float(&s->minRtt), clock_Float(&s->maxRtt));
7445     }
7446
7447     fprintf(file,
7448             "   %d server connections, " "%d client connections, "
7449             "%d peer structs, " "%d call structs, " "%d free call structs\n",
7450             s->nServerConns, s->nClientConns, s->nPeerStructs,
7451             s->nCallStructs, s->nFreeCallStructs);
7452
7453 #if     !defined(AFS_PTHREAD_ENV) && !defined(AFS_USE_GETTIMEOFDAY)
7454     fprintf(file, "   %d clock updates\n", clock_nUpdates);
7455 #endif
7456 }
7457
7458 /* for backward compatibility */
7459 void
7460 rx_PrintStats(FILE * file)
7461 {
7462     MUTEX_ENTER(&rx_stats_mutex);
7463     rx_PrintTheseStats(file, (struct rx_statistics *) &rx_stats,
7464                        sizeof(rx_stats), rx_nFreePackets,
7465                        RX_DEBUGI_VERSION);
7466     MUTEX_EXIT(&rx_stats_mutex);
7467 }
7468
7469 void
7470 rx_PrintPeerStats(FILE * file, struct rx_peer *peer)
7471 {
7472     fprintf(file, "Peer %x.%d.\n",
7473             ntohl(peer->host), (int)ntohs(peer->port));
7474
7475     fprintf(file,
7476             "   Rtt %d, " "total sent %d, " "resent %d\n",
7477             peer->rtt, peer->nSent, peer->reSends);
7478
7479     fprintf(file, "   Packet size %d\n", peer->ifMTU);
7480 }
7481 #endif
7482
7483 #if defined(AFS_PTHREAD_ENV) && defined(RXDEBUG)
7484 /*
7485  * This mutex protects the following static variables:
7486  * counter
7487  */
7488
7489 #define LOCK_RX_DEBUG MUTEX_ENTER(&rx_debug_mutex)
7490 #define UNLOCK_RX_DEBUG MUTEX_EXIT(&rx_debug_mutex)
7491 #else
7492 #define LOCK_RX_DEBUG
7493 #define UNLOCK_RX_DEBUG
7494 #endif /* AFS_PTHREAD_ENV */
7495
7496 #if defined(RXDEBUG) || defined(MAKEDEBUGCALL)
7497 static int
7498 MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
7499               u_char type, void *inputData, size_t inputLength,
7500               void *outputData, size_t outputLength)
7501 {
7502     static afs_int32 counter = 100;
7503     time_t waitTime, waitCount;
7504     struct rx_header theader;
7505     char tbuffer[1500];
7506     afs_int32 code;
7507     struct timeval tv_now, tv_wake, tv_delta;
7508     struct sockaddr_in taddr, faddr;
7509 #ifdef AFS_NT40_ENV
7510     int faddrLen;
7511 #else
7512     socklen_t faddrLen;
7513 #endif
7514     fd_set imask;
7515     char *tp;
7516
7517     waitTime = 1;
7518     waitCount = 5;
7519     LOCK_RX_DEBUG;
7520     counter++;
7521     UNLOCK_RX_DEBUG;
7522     tp = &tbuffer[sizeof(struct rx_header)];
7523     taddr.sin_family = AF_INET;
7524     taddr.sin_port = remotePort;
7525     taddr.sin_addr.s_addr = remoteAddr;
7526 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
7527     taddr.sin_len = sizeof(struct sockaddr_in);
7528 #endif
7529     while (1) {
7530         memset(&theader, 0, sizeof(theader));
7531         theader.epoch = htonl(999);
7532         theader.cid = 0;
7533         theader.callNumber = htonl(counter);
7534         theader.seq = 0;
7535         theader.serial = 0;
7536         theader.type = type;
7537         theader.flags = RX_CLIENT_INITIATED | RX_LAST_PACKET;
7538         theader.serviceId = 0;
7539
7540         memcpy(tbuffer, &theader, sizeof(theader));
7541         memcpy(tp, inputData, inputLength);
7542         code =
7543             sendto(socket, tbuffer, inputLength + sizeof(struct rx_header), 0,
7544                    (struct sockaddr *)&taddr, sizeof(struct sockaddr_in));
7545
7546         /* see if there's a packet available */
7547         gettimeofday(&tv_wake, NULL);
7548         tv_wake.tv_sec += waitTime;
7549         for (;;) {
7550             FD_ZERO(&imask);
7551             FD_SET(socket, &imask);
7552             tv_delta.tv_sec = tv_wake.tv_sec;
7553             tv_delta.tv_usec = tv_wake.tv_usec;
7554             gettimeofday(&tv_now, NULL);
7555
7556             if (tv_delta.tv_usec < tv_now.tv_usec) {
7557                 /* borrow */
7558                 tv_delta.tv_usec += 1000000;
7559                 tv_delta.tv_sec--;
7560             }
7561             tv_delta.tv_usec -= tv_now.tv_usec;
7562
7563             if (tv_delta.tv_sec < tv_now.tv_sec) {
7564                 /* time expired */
7565                 break;
7566             }
7567             tv_delta.tv_sec -= tv_now.tv_sec;
7568
7569 #ifdef AFS_NT40_ENV
7570             code = select(0, &imask, 0, 0, &tv_delta);
7571 #else /* AFS_NT40_ENV */
7572             code = select(socket + 1, &imask, 0, 0, &tv_delta);
7573 #endif /* AFS_NT40_ENV */
7574             if (code == 1 && FD_ISSET(socket, &imask)) {
7575                 /* now receive a packet */
7576                 faddrLen = sizeof(struct sockaddr_in);
7577                 code =
7578                     recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
7579                              (struct sockaddr *)&faddr, &faddrLen);
7580
7581                 if (code > 0) {
7582                     memcpy(&theader, tbuffer, sizeof(struct rx_header));
7583                     if (counter == ntohl(theader.callNumber))
7584                         goto success;
7585                     continue;
7586                 }
7587             }
7588             break;
7589         }
7590
7591         /* see if we've timed out */
7592         if (!--waitCount) {
7593             return -1;
7594         }
7595         waitTime <<= 1;
7596     }
7597
7598  success:
7599     code -= sizeof(struct rx_header);
7600     if (code > outputLength)
7601         code = outputLength;
7602     memcpy(outputData, tp, code);
7603     return code;
7604 }
7605 #endif /* RXDEBUG */
7606
7607 afs_int32
7608 rx_GetServerDebug(osi_socket socket, afs_uint32 remoteAddr,
7609                   afs_uint16 remotePort, struct rx_debugStats * stat,
7610                   afs_uint32 * supportedValues)
7611 {
7612 #if defined(RXDEBUG) || defined(MAKEDEBUGCALL)
7613     afs_int32 rc = 0;
7614     struct rx_debugIn in;
7615
7616     *supportedValues = 0;
7617     in.type = htonl(RX_DEBUGI_GETSTATS);
7618     in.index = 0;
7619
7620     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
7621                        &in, sizeof(in), stat, sizeof(*stat));
7622
7623     /*
7624      * If the call was successful, fixup the version and indicate
7625      * what contents of the stat structure are valid.
7626      * Also do net to host conversion of fields here.
7627      */
7628
7629     if (rc >= 0) {
7630         if (stat->version >= RX_DEBUGI_VERSION_W_SECSTATS) {
7631             *supportedValues |= RX_SERVER_DEBUG_SEC_STATS;
7632         }
7633         if (stat->version >= RX_DEBUGI_VERSION_W_GETALLCONN) {
7634             *supportedValues |= RX_SERVER_DEBUG_ALL_CONN;
7635         }
7636         if (stat->version >= RX_DEBUGI_VERSION_W_RXSTATS) {
7637             *supportedValues |= RX_SERVER_DEBUG_RX_STATS;
7638         }
7639         if (stat->version >= RX_DEBUGI_VERSION_W_WAITERS) {
7640             *supportedValues |= RX_SERVER_DEBUG_WAITER_CNT;
7641         }
7642         if (stat->version >= RX_DEBUGI_VERSION_W_IDLETHREADS) {
7643             *supportedValues |= RX_SERVER_DEBUG_IDLE_THREADS;
7644         }
7645         if (stat->version >= RX_DEBUGI_VERSION_W_NEWPACKETTYPES) {
7646             *supportedValues |= RX_SERVER_DEBUG_NEW_PACKETS;
7647         }
7648         if (stat->version >= RX_DEBUGI_VERSION_W_GETPEER) {
7649             *supportedValues |= RX_SERVER_DEBUG_ALL_PEER;
7650         }
7651         if (stat->version >= RX_DEBUGI_VERSION_W_WAITED) {
7652             *supportedValues |= RX_SERVER_DEBUG_WAITED_CNT;
7653         }
7654         if (stat->version >= RX_DEBUGI_VERSION_W_PACKETS) {
7655             *supportedValues |= RX_SERVER_DEBUG_PACKETS_CNT;
7656         }
7657         stat->nFreePackets = ntohl(stat->nFreePackets);
7658         stat->packetReclaims = ntohl(stat->packetReclaims);
7659         stat->callsExecuted = ntohl(stat->callsExecuted);
7660         stat->nWaiting = ntohl(stat->nWaiting);
7661         stat->idleThreads = ntohl(stat->idleThreads);
7662         stat->nWaited = ntohl(stat->nWaited);
7663         stat->nPackets = ntohl(stat->nPackets);
7664     }
7665 #else
7666     afs_int32 rc = -1;
7667 #endif
7668     return rc;
7669 }
7670
7671 afs_int32
7672 rx_GetServerStats(osi_socket socket, afs_uint32 remoteAddr,
7673                   afs_uint16 remotePort, struct rx_statistics * stat,
7674                   afs_uint32 * supportedValues)
7675 {
7676 #if defined(RXDEBUG) || defined(MAKEDEBUGCALL)
7677     afs_int32 rc = 0;
7678     struct rx_debugIn in;
7679     afs_int32 *lp = (afs_int32 *) stat;
7680     int i;
7681
7682     /*
7683      * supportedValues is currently unused, but added to allow future
7684      * versioning of this function.
7685      */
7686
7687     *supportedValues = 0;
7688     in.type = htonl(RX_DEBUGI_RXSTATS);
7689     in.index = 0;
7690     memset(stat, 0, sizeof(*stat));
7691
7692     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
7693                        &in, sizeof(in), stat, sizeof(*stat));
7694
7695     if (rc >= 0) {
7696
7697         /*
7698          * Do net to host conversion here
7699          */
7700
7701         for (i = 0; i < sizeof(*stat) / sizeof(afs_int32); i++, lp++) {
7702             *lp = ntohl(*lp);
7703         }
7704     }
7705 #else
7706     afs_int32 rc = -1;
7707 #endif
7708     return rc;
7709 }
7710
7711 afs_int32
7712 rx_GetServerVersion(osi_socket socket, afs_uint32 remoteAddr,
7713                     afs_uint16 remotePort, size_t version_length,
7714                     char *version)
7715 {
7716 #if defined(RXDEBUG) || defined(MAKEDEBUGCALL)
7717     char a[1] = { 0 };
7718     return MakeDebugCall(socket, remoteAddr, remotePort,
7719                          RX_PACKET_TYPE_VERSION, a, 1, version,
7720                          version_length);
7721 #else
7722     return -1;
7723 #endif
7724 }
7725
7726 afs_int32
7727 rx_GetServerConnections(osi_socket socket, afs_uint32 remoteAddr,
7728                         afs_uint16 remotePort, afs_int32 * nextConnection,
7729                         int allConnections, afs_uint32 debugSupportedValues,
7730                         struct rx_debugConn * conn,
7731                         afs_uint32 * supportedValues)
7732 {
7733 #if defined(RXDEBUG) || defined(MAKEDEBUGCALL)
7734     afs_int32 rc = 0;
7735     struct rx_debugIn in;
7736     int i;
7737
7738     /*
7739      * supportedValues is currently unused, but added to allow future
7740      * versioning of this function.
7741      */
7742
7743     *supportedValues = 0;
7744     if (allConnections) {
7745         in.type = htonl(RX_DEBUGI_GETALLCONN);
7746     } else {
7747         in.type = htonl(RX_DEBUGI_GETCONN);
7748     }
7749     in.index = htonl(*nextConnection);
7750     memset(conn, 0, sizeof(*conn));
7751
7752     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
7753                        &in, sizeof(in), conn, sizeof(*conn));
7754
7755     if (rc >= 0) {
7756         *nextConnection += 1;
7757
7758         /*
7759          * Convert old connection format to new structure.
7760          */
7761
7762         if (debugSupportedValues & RX_SERVER_DEBUG_OLD_CONN) {
7763             struct rx_debugConn_vL *vL = (struct rx_debugConn_vL *)conn;
7764 #define MOVEvL(a) (conn->a = vL->a)
7765
7766             /* any old or unrecognized version... */
7767             for (i = 0; i < RX_MAXCALLS; i++) {
7768                 MOVEvL(callState[i]);
7769                 MOVEvL(callMode[i]);
7770                 MOVEvL(callFlags[i]);
7771                 MOVEvL(callOther[i]);
7772             }
7773             if (debugSupportedValues & RX_SERVER_DEBUG_SEC_STATS) {
7774                 MOVEvL(secStats.type);
7775                 MOVEvL(secStats.level);
7776                 MOVEvL(secStats.flags);
7777                 MOVEvL(secStats.expires);
7778                 MOVEvL(secStats.packetsReceived);
7779                 MOVEvL(secStats.packetsSent);
7780                 MOVEvL(secStats.bytesReceived);
7781                 MOVEvL(secStats.bytesSent);
7782             }
7783         }
7784
7785         /*
7786          * Do net to host conversion here
7787          * NOTE:
7788          *    I don't convert host or port since we are most likely
7789          *    going to want these in NBO.
7790          */
7791         conn->cid = ntohl(conn->cid);
7792         conn->serial = ntohl(conn->serial);
7793         for (i = 0; i < RX_MAXCALLS; i++) {
7794             conn->callNumber[i] = ntohl(conn->callNumber[i]);
7795         }
7796         conn->error = ntohl(conn->error);
7797         conn->secStats.flags = ntohl(conn->secStats.flags);
7798         conn->secStats.expires = ntohl(conn->secStats.expires);
7799         conn->secStats.packetsReceived =
7800             ntohl(conn->secStats.packetsReceived);
7801         conn->secStats.packetsSent = ntohl(conn->secStats.packetsSent);
7802         conn->secStats.bytesReceived = ntohl(conn->secStats.bytesReceived);
7803         conn->secStats.bytesSent = ntohl(conn->secStats.bytesSent);
7804         conn->epoch = ntohl(conn->epoch);
7805         conn->natMTU = ntohl(conn->natMTU);
7806     }
7807 #else
7808     afs_int32 rc = -1;
7809 #endif
7810     return rc;
7811 }
7812
7813 afs_int32
7814 rx_GetServerPeers(osi_socket socket, afs_uint32 remoteAddr,
7815                   afs_uint16 remotePort, afs_int32 * nextPeer,
7816                   afs_uint32 debugSupportedValues, struct rx_debugPeer * peer,
7817                   afs_uint32 * supportedValues)
7818 {
7819 #if defined(RXDEBUG) || defined(MAKEDEBUGCALL)
7820     afs_int32 rc = 0;
7821     struct rx_debugIn in;
7822
7823     /*
7824      * supportedValues is currently unused, but added to allow future
7825      * versioning of this function.
7826      */
7827
7828     *supportedValues = 0;
7829     in.type = htonl(RX_DEBUGI_GETPEER);
7830     in.index = htonl(*nextPeer);
7831     memset(peer, 0, sizeof(*peer));
7832
7833     rc = MakeDebugCall(socket, remoteAddr, remotePort, RX_PACKET_TYPE_DEBUG,
7834                        &in, sizeof(in), peer, sizeof(*peer));
7835
7836     if (rc >= 0) {
7837         *nextPeer += 1;
7838
7839         /*
7840          * Do net to host conversion here
7841          * NOTE:
7842          *    I don't convert host or port since we are most likely
7843          *    going to want these in NBO.
7844          */
7845         peer->ifMTU = ntohs(peer->ifMTU);
7846         peer->idleWhen = ntohl(peer->idleWhen);
7847         peer->refCount = ntohs(peer->refCount);
7848         peer->rtt = ntohl(peer->rtt);
7849         peer->rtt_dev = ntohl(peer->rtt_dev);
7850         peer->timeout.sec = 0;
7851         peer->timeout.usec = 0;
7852         peer->nSent = ntohl(peer->nSent);
7853         peer->reSends = ntohl(peer->reSends);
7854         peer->natMTU = ntohs(peer->natMTU);
7855         peer->maxMTU = ntohs(peer->maxMTU);
7856         peer->maxDgramPackets = ntohs(peer->maxDgramPackets);
7857         peer->ifDgramPackets = ntohs(peer->ifDgramPackets);
7858         peer->MTU = ntohs(peer->MTU);
7859         peer->cwind = ntohs(peer->cwind);
7860         peer->nDgramPackets = ntohs(peer->nDgramPackets);
7861         peer->congestSeq = ntohs(peer->congestSeq);
7862         peer->bytesSent.high = ntohl(peer->bytesSent.high);
7863         peer->bytesSent.low = ntohl(peer->bytesSent.low);
7864         peer->bytesReceived.high = ntohl(peer->bytesReceived.high);
7865         peer->bytesReceived.low = ntohl(peer->bytesReceived.low);
7866     }
7867 #else
7868     afs_int32 rc = -1;
7869 #endif
7870     return rc;
7871 }
7872
7873 afs_int32
7874 rx_GetLocalPeers(afs_uint32 peerHost, afs_uint16 peerPort,
7875                 struct rx_debugPeer * peerStats)
7876 {
7877         struct rx_peer *tp;
7878         afs_int32 error = 1; /* default to "did not succeed" */
7879         afs_uint32 hashValue = PEER_HASH(peerHost, peerPort);
7880
7881         MUTEX_ENTER(&rx_peerHashTable_lock);
7882         for(tp = rx_peerHashTable[hashValue];
7883               tp != NULL; tp = tp->next) {
7884                 if (tp->host == peerHost)
7885                         break;
7886         }
7887
7888         if (tp) {
7889                 tp->refCount++;
7890                 MUTEX_EXIT(&rx_peerHashTable_lock);
7891
7892                 error = 0;
7893
7894                 MUTEX_ENTER(&tp->peer_lock);
7895                 peerStats->host = tp->host;
7896                 peerStats->port = tp->port;
7897                 peerStats->ifMTU = tp->ifMTU;
7898                 peerStats->idleWhen = tp->idleWhen;
7899                 peerStats->refCount = tp->refCount;
7900                 peerStats->burstSize = 0;
7901                 peerStats->burst = 0;
7902                 peerStats->burstWait.sec = 0;
7903                 peerStats->burstWait.usec = 0;
7904                 peerStats->rtt = tp->rtt;
7905                 peerStats->rtt_dev = tp->rtt_dev;
7906                 peerStats->timeout.sec = 0;
7907                 peerStats->timeout.usec = 0;
7908                 peerStats->nSent = tp->nSent;
7909                 peerStats->reSends = tp->reSends;
7910                 peerStats->natMTU = tp->natMTU;
7911                 peerStats->maxMTU = tp->maxMTU;
7912                 peerStats->maxDgramPackets = tp->maxDgramPackets;
7913                 peerStats->ifDgramPackets = tp->ifDgramPackets;
7914                 peerStats->MTU = tp->MTU;
7915                 peerStats->cwind = tp->cwind;
7916                 peerStats->nDgramPackets = tp->nDgramPackets;
7917                 peerStats->congestSeq = tp->congestSeq;
7918                 peerStats->bytesSent.high = tp->bytesSent >> 32;
7919                 peerStats->bytesSent.low = tp->bytesSent & MAX_AFS_UINT32;
7920                 peerStats->bytesReceived.high = tp->bytesReceived >> 32;
7921                 peerStats->bytesReceived.low
7922                                 = tp->bytesReceived & MAX_AFS_UINT32;
7923                 MUTEX_EXIT(&tp->peer_lock);
7924
7925                 MUTEX_ENTER(&rx_peerHashTable_lock);
7926                 tp->refCount--;
7927         }
7928         MUTEX_EXIT(&rx_peerHashTable_lock);
7929
7930         return error;
7931 }
7932
7933 void
7934 shutdown_rx(void)
7935 {
7936     struct rx_serverQueueEntry *np;
7937     int i, j;
7938 #ifndef KERNEL
7939     struct rx_call *call;
7940     struct rx_serverQueueEntry *sq;
7941 #endif /* KERNEL */
7942
7943     LOCK_RX_INIT;
7944     if (rxinit_status == 1) {
7945         UNLOCK_RX_INIT;
7946         return;                 /* Already shutdown. */
7947     }
7948 #ifndef KERNEL
7949     rx_port = 0;
7950 #ifndef AFS_PTHREAD_ENV
7951     FD_ZERO(&rx_selectMask);
7952 #endif /* AFS_PTHREAD_ENV */
7953     rxi_dataQuota = RX_MAX_QUOTA;
7954 #ifndef AFS_PTHREAD_ENV
7955     rxi_StopListener();
7956 #endif /* AFS_PTHREAD_ENV */
7957     shutdown_rxevent();
7958     rx_SetEpoch(0);
7959 #ifndef AFS_PTHREAD_ENV
7960 #ifndef AFS_USE_GETTIMEOFDAY
7961     clock_UnInit();
7962 #endif /* AFS_USE_GETTIMEOFDAY */
7963 #endif /* AFS_PTHREAD_ENV */
7964
7965     while (!opr_queue_IsEmpty(&rx_freeCallQueue)) {
7966         call = opr_queue_First(&rx_freeCallQueue, struct rx_call, entry);
7967         opr_queue_Remove(&call->entry);
7968         rxi_Free(call, sizeof(struct rx_call));
7969     }
7970
7971     while (!opr_queue_IsEmpty(&rx_idleServerQueue)) {
7972         sq = opr_queue_First(&rx_idleServerQueue, struct rx_serverQueueEntry,
7973                             entry);
7974         opr_queue_Remove(&sq->entry);
7975     }
7976 #endif /* KERNEL */
7977
7978     {
7979         struct rx_peer **peer_ptr, **peer_end;
7980         for (peer_ptr = &rx_peerHashTable[0], peer_end =
7981              &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
7982              peer_ptr++) {
7983             struct rx_peer *peer, *next;
7984
7985             MUTEX_ENTER(&rx_peerHashTable_lock);
7986             for (peer = *peer_ptr; peer; peer = next) {
7987                 struct opr_queue *cursor, *store;
7988                 size_t space;
7989
7990                 MUTEX_ENTER(&rx_rpc_stats);
7991                 MUTEX_ENTER(&peer->peer_lock);
7992                 for (opr_queue_ScanSafe(&peer->rpcStats, cursor, store)) {
7993                     unsigned int num_funcs;
7994                     struct rx_interface_stat *rpc_stat
7995                         = opr_queue_Entry(cursor, struct rx_interface_stat,
7996                                          entry);
7997                     if (!rpc_stat)
7998                         break;
7999                     opr_queue_Remove(&rpc_stat->entry);
8000                     opr_queue_Remove(&rpc_stat->entryPeers);
8001                     num_funcs = rpc_stat->stats[0].func_total;
8002                     space =
8003                         sizeof(rx_interface_stat_t) +
8004                         rpc_stat->stats[0].func_total *
8005                         sizeof(rx_function_entry_v1_t);
8006
8007                     rxi_Free(rpc_stat, space);
8008
8009                     /* rx_rpc_stats must be held */
8010                     rxi_rpc_peer_stat_cnt -= num_funcs;
8011                 }
8012                 MUTEX_EXIT(&peer->peer_lock);
8013                 MUTEX_EXIT(&rx_rpc_stats);
8014
8015                 next = peer->next;
8016                 rxi_FreePeer(peer);
8017                 if (rx_stats_active)
8018                     rx_atomic_dec(&rx_stats.nPeerStructs);
8019             }
8020             MUTEX_EXIT(&rx_peerHashTable_lock);
8021         }
8022     }
8023     for (i = 0; i < RX_MAX_SERVICES; i++) {
8024         if (rx_services[i])
8025             rxi_Free(rx_services[i], sizeof(*rx_services[i]));
8026     }
8027     for (i = 0; i < rx_hashTableSize; i++) {
8028         struct rx_connection *tc, *ntc;
8029         MUTEX_ENTER(&rx_connHashTable_lock);
8030         for (tc = rx_connHashTable[i]; tc; tc = ntc) {
8031             ntc = tc->next;
8032             for (j = 0; j < RX_MAXCALLS; j++) {
8033                 if (tc->call[j]) {
8034                     rxi_Free(tc->call[j], sizeof(*tc->call[j]));
8035                 }
8036             }
8037             rxi_Free(tc, sizeof(*tc));
8038         }
8039         MUTEX_EXIT(&rx_connHashTable_lock);
8040     }
8041
8042     MUTEX_ENTER(&freeSQEList_lock);
8043
8044     while ((np = rx_FreeSQEList)) {
8045         rx_FreeSQEList = *(struct rx_serverQueueEntry **)np;
8046         MUTEX_DESTROY(&np->lock);
8047         rxi_Free(np, sizeof(*np));
8048     }
8049
8050     MUTEX_EXIT(&freeSQEList_lock);
8051     MUTEX_DESTROY(&freeSQEList_lock);
8052     MUTEX_DESTROY(&rx_freeCallQueue_lock);
8053     MUTEX_DESTROY(&rx_connHashTable_lock);
8054     MUTEX_DESTROY(&rx_peerHashTable_lock);
8055     MUTEX_DESTROY(&rx_serverPool_lock);
8056
8057     osi_Free(rx_connHashTable,
8058              rx_hashTableSize * sizeof(struct rx_connection *));
8059     osi_Free(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
8060
8061     UNPIN(rx_connHashTable,
8062           rx_hashTableSize * sizeof(struct rx_connection *));
8063     UNPIN(rx_peerHashTable, rx_hashTableSize * sizeof(struct rx_peer *));
8064
8065     rxi_FreeAllPackets();
8066
8067     MUTEX_ENTER(&rx_quota_mutex);
8068     rxi_dataQuota = RX_MAX_QUOTA;
8069     rxi_availProcs = rxi_totalMin = rxi_minDeficit = 0;
8070     MUTEX_EXIT(&rx_quota_mutex);
8071     rxinit_status = 1;
8072     UNLOCK_RX_INIT;
8073 }
8074
8075 #ifdef RX_ENABLE_LOCKS
8076 void
8077 osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg)
8078 {
8079     if (!MUTEX_ISMINE(lockaddr))
8080         osi_Panic("Lock not held: %s", msg);
8081 }
8082 #endif /* RX_ENABLE_LOCKS */
8083
8084 #ifndef KERNEL
8085
8086 /*
8087  * Routines to implement connection specific data.
8088  */
8089
8090 int
8091 rx_KeyCreate(rx_destructor_t rtn)
8092 {
8093     int key;
8094     MUTEX_ENTER(&rxi_keyCreate_lock);
8095     key = rxi_keyCreate_counter++;
8096     rxi_keyCreate_destructor = (rx_destructor_t *)
8097         realloc((void *)rxi_keyCreate_destructor,
8098                 (key + 1) * sizeof(rx_destructor_t));
8099     rxi_keyCreate_destructor[key] = rtn;
8100     MUTEX_EXIT(&rxi_keyCreate_lock);
8101     return key;
8102 }
8103
8104 void
8105 rx_SetSpecific(struct rx_connection *conn, int key, void *ptr)
8106 {
8107     int i;
8108     MUTEX_ENTER(&conn->conn_data_lock);
8109     if (!conn->specific) {
8110         conn->specific = malloc((key + 1) * sizeof(void *));
8111         for (i = 0; i < key; i++)
8112             conn->specific[i] = NULL;
8113         conn->nSpecific = key + 1;
8114         conn->specific[key] = ptr;
8115     } else if (key >= conn->nSpecific) {
8116         conn->specific = (void **)
8117             realloc(conn->specific, (key + 1) * sizeof(void *));
8118         for (i = conn->nSpecific; i < key; i++)
8119             conn->specific[i] = NULL;
8120         conn->nSpecific = key + 1;
8121         conn->specific[key] = ptr;
8122     } else {
8123         if (conn->specific[key] && rxi_keyCreate_destructor[key])
8124             (*rxi_keyCreate_destructor[key]) (conn->specific[key]);
8125         conn->specific[key] = ptr;
8126     }
8127     MUTEX_EXIT(&conn->conn_data_lock);
8128 }
8129
8130 void
8131 rx_SetServiceSpecific(struct rx_service *svc, int key, void *ptr)
8132 {
8133     int i;
8134     MUTEX_ENTER(&svc->svc_data_lock);
8135     if (!svc->specific) {
8136         svc->specific = malloc((key + 1) * sizeof(void *));
8137         for (i = 0; i < key; i++)
8138             svc->specific[i] = NULL;
8139         svc->nSpecific = key + 1;
8140         svc->specific[key] = ptr;
8141     } else if (key >= svc->nSpecific) {
8142         svc->specific = (void **)
8143             realloc(svc->specific, (key + 1) * sizeof(void *));
8144         for (i = svc->nSpecific; i < key; i++)
8145             svc->specific[i] = NULL;
8146         svc->nSpecific = key + 1;
8147         svc->specific[key] = ptr;
8148     } else {
8149         if (svc->specific[key] && rxi_keyCreate_destructor[key])
8150             (*rxi_keyCreate_destructor[key]) (svc->specific[key]);
8151         svc->specific[key] = ptr;
8152     }
8153     MUTEX_EXIT(&svc->svc_data_lock);
8154 }
8155
8156 void *
8157 rx_GetSpecific(struct rx_connection *conn, int key)
8158 {
8159     void *ptr;
8160     MUTEX_ENTER(&conn->conn_data_lock);
8161     if (key >= conn->nSpecific)
8162         ptr = NULL;
8163     else
8164         ptr = conn->specific[key];
8165     MUTEX_EXIT(&conn->conn_data_lock);
8166     return ptr;
8167 }
8168
8169 void *
8170 rx_GetServiceSpecific(struct rx_service *svc, int key)
8171 {
8172     void *ptr;
8173     MUTEX_ENTER(&svc->svc_data_lock);
8174     if (key >= svc->nSpecific)
8175         ptr = NULL;
8176     else
8177         ptr = svc->specific[key];
8178     MUTEX_EXIT(&svc->svc_data_lock);
8179     return ptr;
8180 }
8181
8182
8183 #endif /* !KERNEL */
8184
8185 /*
8186  * processStats is a queue used to store the statistics for the local
8187  * process.  Its contents are similar to the contents of the rpcStats
8188  * queue on a rx_peer structure, but the actual data stored within
8189  * this queue contains totals across the lifetime of the process (assuming
8190  * the stats have not been reset) - unlike the per peer structures
8191  * which can come and go based upon the peer lifetime.
8192  */
8193
8194 static struct opr_queue processStats = { &processStats, &processStats };
8195
8196 /*
8197  * peerStats is a queue used to store the statistics for all peer structs.
8198  * Its contents are the union of all the peer rpcStats queues.
8199  */
8200
8201 static struct opr_queue peerStats = { &peerStats, &peerStats };
8202
8203 /*
8204  * rxi_monitor_processStats is used to turn process wide stat collection
8205  * on and off
8206  */
8207
8208 static int rxi_monitor_processStats = 0;
8209
8210 /*
8211  * rxi_monitor_peerStats is used to turn per peer stat collection on and off
8212  */
8213
8214 static int rxi_monitor_peerStats = 0;
8215
8216
8217 void
8218 rxi_ClearRPCOpStat(rx_function_entry_v1_p rpc_stat)
8219 {
8220     rpc_stat->invocations = 0;
8221     rpc_stat->bytes_sent = 0;
8222     rpc_stat->bytes_rcvd = 0;
8223     rpc_stat->queue_time_sum.sec = 0;
8224     rpc_stat->queue_time_sum.usec = 0;
8225     rpc_stat->queue_time_sum_sqr.sec = 0;
8226     rpc_stat->queue_time_sum_sqr.usec = 0;
8227     rpc_stat->queue_time_min.sec = 9999999;
8228     rpc_stat->queue_time_min.usec = 9999999;
8229     rpc_stat->queue_time_max.sec = 0;
8230     rpc_stat->queue_time_max.usec = 0;
8231     rpc_stat->execution_time_sum.sec = 0;
8232     rpc_stat->execution_time_sum.usec = 0;
8233     rpc_stat->execution_time_sum_sqr.sec = 0;
8234     rpc_stat->execution_time_sum_sqr.usec = 0;
8235     rpc_stat->execution_time_min.sec = 9999999;
8236     rpc_stat->execution_time_min.usec = 9999999;
8237     rpc_stat->execution_time_max.sec = 0;
8238     rpc_stat->execution_time_max.usec = 0;
8239 }
8240
8241 /*!
8242  * Given all of the information for a particular rpc
8243  * call, find or create (if requested) the stat structure for the rpc.
8244  *
8245  * @param stats
8246  *      the queue of stats that will be updated with the new value
8247  *
8248  * @param rxInterface
8249  *      a unique number that identifies the rpc interface
8250  *
8251  * @param totalFunc
8252  *      the total number of functions in this interface. this is only
8253  *      required if create is true
8254  *
8255  * @param isServer
8256  *      if true, this invocation was made to a server
8257  *
8258  * @param remoteHost
8259  *      the ip address of the remote host. this is only required if create
8260  *      and addToPeerList are true
8261  *
8262  * @param remotePort
8263  *      the port of the remote host. this is only required if create
8264  *      and addToPeerList are true
8265  *
8266  * @param addToPeerList
8267  *      if != 0, add newly created stat to the global peer list
8268  *
8269  * @param counter
8270  *      if a new stats structure is allocated, the counter will
8271  *      be updated with the new number of allocated stat structures.
8272  *      only required if create is true
8273  *
8274  * @param create
8275  *      if no stats structure exists, allocate one
8276  *
8277  */
8278
8279 static rx_interface_stat_p
8280 rxi_FindRpcStat(struct opr_queue *stats, afs_uint32 rxInterface,
8281                 afs_uint32 totalFunc, int isServer, afs_uint32 remoteHost,
8282                 afs_uint32 remotePort, int addToPeerList,
8283                 unsigned int *counter, int create)
8284 {
8285     rx_interface_stat_p rpc_stat = NULL;
8286     struct opr_queue *cursor;
8287
8288     /*
8289      * See if there's already a structure for this interface
8290      */
8291
8292     for (opr_queue_Scan(stats, cursor)) {
8293         rpc_stat = opr_queue_Entry(cursor, struct rx_interface_stat, entry);
8294
8295         if ((rpc_stat->stats[0].interfaceId == rxInterface)
8296             && (rpc_stat->stats[0].remote_is_server == isServer))
8297             break;
8298     }
8299
8300     /* if they didn't ask us to create, we're done */
8301     if (!create) {
8302         if (opr_queue_IsEnd(stats, cursor))
8303             return NULL;
8304         else
8305             return rpc_stat;
8306     }
8307
8308     /* can't proceed without these */
8309     if (!totalFunc || !counter)
8310         return NULL;
8311
8312     /*
8313      * Didn't find a match so allocate a new structure and add it to the
8314      * queue.
8315      */
8316
8317     if (opr_queue_IsEnd(stats, cursor) || (rpc_stat == NULL)
8318         || (rpc_stat->stats[0].interfaceId != rxInterface)
8319         || (rpc_stat->stats[0].remote_is_server != isServer)) {
8320         int i;
8321         size_t space;
8322
8323         space =
8324             sizeof(rx_interface_stat_t) +
8325             totalFunc * sizeof(rx_function_entry_v1_t);
8326
8327         rpc_stat = rxi_Alloc(space);
8328         if (rpc_stat == NULL)
8329             return NULL;
8330
8331         *counter += totalFunc;
8332         for (i = 0; i < totalFunc; i++) {
8333             rxi_ClearRPCOpStat(&(rpc_stat->stats[i]));
8334             rpc_stat->stats[i].remote_peer = remoteHost;
8335             rpc_stat->stats[i].remote_port = remotePort;
8336             rpc_stat->stats[i].remote_is_server = isServer;
8337             rpc_stat->stats[i].interfaceId = rxInterface;
8338             rpc_stat->stats[i].func_total = totalFunc;
8339             rpc_stat->stats[i].func_index = i;
8340         }
8341         opr_queue_Prepend(stats, &rpc_stat->entry);
8342         if (addToPeerList) {
8343             opr_queue_Prepend(&peerStats, &rpc_stat->entryPeers);
8344         }
8345     }
8346     return rpc_stat;
8347 }
8348
8349 void
8350 rx_ClearProcessRPCStats(afs_int32 rxInterface)
8351 {
8352     rx_interface_stat_p rpc_stat;
8353     int totalFunc, i;
8354
8355     if (rxInterface == -1)
8356         return;
8357
8358     MUTEX_ENTER(&rx_rpc_stats);
8359     rpc_stat = rxi_FindRpcStat(&processStats, rxInterface, 0, 0,
8360                                0, 0, 0, 0, 0);
8361     if (rpc_stat) {
8362         totalFunc = rpc_stat->stats[0].func_total;
8363         for (i = 0; i < totalFunc; i++)
8364             rxi_ClearRPCOpStat(&(rpc_stat->stats[i]));
8365     }
8366     MUTEX_EXIT(&rx_rpc_stats);
8367     return;
8368 }
8369
8370 void
8371 rx_ClearPeerRPCStats(afs_int32 rxInterface, afs_uint32 peerHost, afs_uint16 peerPort)
8372 {
8373     rx_interface_stat_p rpc_stat;
8374     int totalFunc, i;
8375     struct rx_peer * peer;
8376
8377     if (rxInterface == -1)
8378         return;
8379
8380     peer = rxi_FindPeer(peerHost, peerPort, 0, 0);
8381     if (!peer)
8382         return;
8383
8384     MUTEX_ENTER(&rx_rpc_stats);
8385     rpc_stat = rxi_FindRpcStat(&peer->rpcStats, rxInterface, 0, 1,
8386                                0, 0, 0, 0, 0);
8387     if (rpc_stat) {
8388         totalFunc = rpc_stat->stats[0].func_total;
8389         for (i = 0; i < totalFunc; i++)
8390             rxi_ClearRPCOpStat(&(rpc_stat->stats[i]));
8391     }
8392     MUTEX_EXIT(&rx_rpc_stats);
8393     return;
8394 }
8395
8396 void *
8397 rx_CopyProcessRPCStats(afs_uint64 op)
8398 {
8399     rx_interface_stat_p rpc_stat;
8400     rx_function_entry_v1_p rpcop_stat =
8401         rxi_Alloc(sizeof(rx_function_entry_v1_t));
8402     int currentFunc = (op & MAX_AFS_UINT32);
8403     afs_int32 rxInterface = (op >> 32);
8404
8405     if (!rxi_monitor_processStats)
8406         return NULL;
8407
8408     if (rxInterface == -1)
8409         return NULL;
8410
8411     if (rpcop_stat == NULL)
8412         return NULL;
8413
8414     MUTEX_ENTER(&rx_rpc_stats);
8415     rpc_stat = rxi_FindRpcStat(&processStats, rxInterface, 0, 0,
8416                                0, 0, 0, 0, 0);
8417     if (rpc_stat)
8418         memcpy(rpcop_stat, &(rpc_stat->stats[currentFunc]),
8419                sizeof(rx_function_entry_v1_t));
8420     MUTEX_EXIT(&rx_rpc_stats);
8421     if (!rpc_stat) {
8422         rxi_Free(rpcop_stat, sizeof(rx_function_entry_v1_t));
8423         return NULL;
8424     }
8425     return rpcop_stat;
8426 }
8427
8428 void *
8429 rx_CopyPeerRPCStats(afs_uint64 op, afs_uint32 peerHost, afs_uint16 peerPort)
8430 {
8431     rx_interface_stat_p rpc_stat;
8432     rx_function_entry_v1_p rpcop_stat =
8433         rxi_Alloc(sizeof(rx_function_entry_v1_t));
8434     int currentFunc = (op & MAX_AFS_UINT32);
8435     afs_int32 rxInterface = (op >> 32);
8436     struct rx_peer *peer;
8437
8438     if (!rxi_monitor_peerStats)
8439         return NULL;
8440
8441     if (rxInterface == -1)
8442         return NULL;
8443
8444     if (rpcop_stat == NULL)
8445         return NULL;
8446
8447     peer = rxi_FindPeer(peerHost, peerPort, 0, 0);
8448     if (!peer)
8449         return NULL;
8450
8451     MUTEX_ENTER(&rx_rpc_stats);
8452     rpc_stat = rxi_FindRpcStat(&peer->rpcStats, rxInterface, 0, 1,
8453                                0, 0, 0, 0, 0);
8454     if (rpc_stat)
8455         memcpy(rpcop_stat, &(rpc_stat->stats[currentFunc]),
8456                sizeof(rx_function_entry_v1_t));
8457     MUTEX_EXIT(&rx_rpc_stats);
8458     if (!rpc_stat) {
8459         rxi_Free(rpcop_stat, sizeof(rx_function_entry_v1_t));
8460         return NULL;
8461     }
8462     return rpcop_stat;
8463 }
8464
8465 void
8466 rx_ReleaseRPCStats(void *stats)
8467 {
8468     if (stats)
8469         rxi_Free(stats, sizeof(rx_function_entry_v1_t));
8470 }
8471
8472 /*!
8473  * Given all of the information for a particular rpc
8474  * call, create (if needed) and update the stat totals for the rpc.
8475  *
8476  * @param stats
8477  *      the queue of stats that will be updated with the new value
8478  *
8479  * @param rxInterface
8480  *      a unique number that identifies the rpc interface
8481  *
8482  * @param currentFunc
8483  *      the index of the function being invoked
8484  *
8485  * @param totalFunc
8486  *      the total number of functions in this interface
8487  *
8488  * @param queueTime
8489  *      the amount of time this function waited for a thread
8490  *
8491  * @param execTime
8492  *      the amount of time this function invocation took to execute
8493  *
8494  * @param bytesSent
8495  *      the number bytes sent by this invocation
8496  *
8497  * @param bytesRcvd
8498  *      the number bytes received by this invocation
8499  *
8500  * @param isServer
8501  *      if true, this invocation was made to a server
8502  *
8503  * @param remoteHost
8504  *      the ip address of the remote host
8505  *
8506  * @param remotePort
8507  *      the port of the remote host
8508  *
8509  * @param addToPeerList
8510  *      if != 0, add newly created stat to the global peer list
8511  *
8512  * @param counter
8513  *      if a new stats structure is allocated, the counter will
8514  *      be updated with the new number of allocated stat structures
8515  *
8516  */
8517
8518 static int
8519 rxi_AddRpcStat(struct opr_queue *stats, afs_uint32 rxInterface,
8520                afs_uint32 currentFunc, afs_uint32 totalFunc,
8521                struct clock *queueTime, struct clock *execTime,
8522                afs_uint64 bytesSent, afs_uint64 bytesRcvd, int isServer,
8523                afs_uint32 remoteHost, afs_uint32 remotePort,
8524                int addToPeerList, unsigned int *counter)
8525 {
8526     int rc = 0;
8527     rx_interface_stat_p rpc_stat;
8528
8529     rpc_stat = rxi_FindRpcStat(stats, rxInterface, totalFunc, isServer,
8530                                remoteHost, remotePort, addToPeerList, counter,
8531                                1);
8532     if (!rpc_stat) {
8533         rc = -1;
8534         goto fail;
8535     }
8536
8537     /*
8538      * Increment the stats for this function
8539      */
8540
8541     rpc_stat->stats[currentFunc].invocations++;
8542     rpc_stat->stats[currentFunc].bytes_sent += bytesSent;
8543     rpc_stat->stats[currentFunc].bytes_rcvd += bytesRcvd;
8544     clock_Add(&rpc_stat->stats[currentFunc].queue_time_sum, queueTime);
8545     clock_AddSq(&rpc_stat->stats[currentFunc].queue_time_sum_sqr, queueTime);
8546     if (clock_Lt(queueTime, &rpc_stat->stats[currentFunc].queue_time_min)) {
8547         rpc_stat->stats[currentFunc].queue_time_min = *queueTime;
8548     }
8549     if (clock_Gt(queueTime, &rpc_stat->stats[currentFunc].queue_time_max)) {
8550         rpc_stat->stats[currentFunc].queue_time_max = *queueTime;
8551     }
8552     clock_Add(&rpc_stat->stats[currentFunc].execution_time_sum, execTime);
8553     clock_AddSq(&rpc_stat->stats[currentFunc].execution_time_sum_sqr,
8554                 execTime);
8555     if (clock_Lt(execTime, &rpc_stat->stats[currentFunc].execution_time_min)) {
8556         rpc_stat->stats[currentFunc].execution_time_min = *execTime;
8557     }
8558     if (clock_Gt(execTime, &rpc_stat->stats[currentFunc].execution_time_max)) {
8559         rpc_stat->stats[currentFunc].execution_time_max = *execTime;
8560     }
8561
8562   fail:
8563     return rc;
8564 }
8565
8566 void
8567 rxi_IncrementTimeAndCount(struct rx_peer *peer, afs_uint32 rxInterface,
8568                           afs_uint32 currentFunc, afs_uint32 totalFunc,
8569                           struct clock *queueTime, struct clock *execTime,
8570                           afs_uint64 bytesSent, afs_uint64 bytesRcvd,
8571                           int isServer)
8572 {
8573
8574     if (!(rxi_monitor_peerStats || rxi_monitor_processStats))
8575         return;
8576
8577     MUTEX_ENTER(&rx_rpc_stats);
8578
8579     if (rxi_monitor_peerStats) {
8580         MUTEX_ENTER(&peer->peer_lock);
8581         rxi_AddRpcStat(&peer->rpcStats, rxInterface, currentFunc, totalFunc,
8582                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
8583                        peer->host, peer->port, 1, &rxi_rpc_peer_stat_cnt);
8584         MUTEX_EXIT(&peer->peer_lock);
8585     }
8586
8587     if (rxi_monitor_processStats) {
8588         rxi_AddRpcStat(&processStats, rxInterface, currentFunc, totalFunc,
8589                        queueTime, execTime, bytesSent, bytesRcvd, isServer,
8590                        0xffffffff, 0xffffffff, 0, &rxi_rpc_process_stat_cnt);
8591     }
8592
8593     MUTEX_EXIT(&rx_rpc_stats);
8594 }
8595
8596 /*!
8597  * Increment the times and count for a particular rpc function.
8598  *
8599  * Traditionally this call was invoked from rxgen stubs. Modern stubs
8600  * call rx_RecordCallStatistics instead, so the public version of this
8601  * function is left purely for legacy callers.
8602  *
8603  * @param peer
8604  *      The peer who invoked the rpc
8605  *
8606  * @param rxInterface
8607  *      A unique number that identifies the rpc interface
8608  *
8609  * @param currentFunc
8610  *      The index of the function being invoked
8611  *
8612  * @param totalFunc
8613  *      The total number of functions in this interface
8614  *
8615  * @param queueTime
8616  *      The amount of time this function waited for a thread
8617  *
8618  * @param execTime
8619  *      The amount of time this function invocation took to execute
8620  *
8621  * @param bytesSent
8622  *      The number bytes sent by this invocation
8623  *
8624  * @param bytesRcvd
8625  *      The number bytes received by this invocation
8626  *
8627  * @param isServer
8628  *      If true, this invocation was made to a server
8629  *
8630  */
8631 void
8632 rx_IncrementTimeAndCount(struct rx_peer *peer, afs_uint32 rxInterface,
8633                          afs_uint32 currentFunc, afs_uint32 totalFunc,
8634                          struct clock *queueTime, struct clock *execTime,
8635                          afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd,
8636                          int isServer)
8637 {
8638     afs_uint64 sent64;
8639     afs_uint64 rcvd64;
8640
8641     sent64 = ((afs_uint64)bytesSent->high << 32) + bytesSent->low;
8642     rcvd64 = ((afs_uint64)bytesRcvd->high << 32) + bytesRcvd->low;
8643
8644     rxi_IncrementTimeAndCount(peer, rxInterface, currentFunc, totalFunc,
8645                               queueTime, execTime, sent64, rcvd64,
8646                               isServer);
8647 }
8648
8649
8650
8651 /*
8652  * rx_MarshallProcessRPCStats - marshall an array of rpc statistics
8653  *
8654  * PARAMETERS
8655  *
8656  * IN callerVersion - the rpc stat version of the caller.
8657  *
8658  * IN count - the number of entries to marshall.
8659  *
8660  * IN stats - pointer to stats to be marshalled.
8661  *
8662  * OUT ptr - Where to store the marshalled data.
8663  *
8664  * RETURN CODES
8665  *
8666  * Returns void.
8667  */
8668 void
8669 rx_MarshallProcessRPCStats(afs_uint32 callerVersion, int count,
8670                            rx_function_entry_v1_t * stats, afs_uint32 ** ptrP)
8671 {
8672     int i;
8673     afs_uint32 *ptr;
8674
8675     /*
8676      * We only support the first version
8677      */
8678     for (ptr = *ptrP, i = 0; i < count; i++, stats++) {
8679         *(ptr++) = stats->remote_peer;
8680         *(ptr++) = stats->remote_port;
8681         *(ptr++) = stats->remote_is_server;
8682         *(ptr++) = stats->interfaceId;
8683         *(ptr++) = stats->func_total;
8684         *(ptr++) = stats->func_index;
8685         *(ptr++) = stats->invocations >> 32;
8686         *(ptr++) = stats->invocations & MAX_AFS_UINT32;
8687         *(ptr++) = stats->bytes_sent >> 32;
8688         *(ptr++) = stats->bytes_sent & MAX_AFS_UINT32;
8689         *(ptr++) = stats->bytes_rcvd >> 32;
8690         *(ptr++) = stats->bytes_rcvd & MAX_AFS_UINT32;
8691         *(ptr++) = stats->queue_time_sum.sec;
8692         *(ptr++) = stats->queue_time_sum.usec;
8693         *(ptr++) = stats->queue_time_sum_sqr.sec;
8694         *(ptr++) = stats->queue_time_sum_sqr.usec;
8695         *(ptr++) = stats->queue_time_min.sec;
8696         *(ptr++) = stats->queue_time_min.usec;
8697         *(ptr++) = stats->queue_time_max.sec;
8698         *(ptr++) = stats->queue_time_max.usec;
8699         *(ptr++) = stats->execution_time_sum.sec;
8700         *(ptr++) = stats->execution_time_sum.usec;
8701         *(ptr++) = stats->execution_time_sum_sqr.sec;
8702         *(ptr++) = stats->execution_time_sum_sqr.usec;
8703         *(ptr++) = stats->execution_time_min.sec;
8704         *(ptr++) = stats->execution_time_min.usec;
8705         *(ptr++) = stats->execution_time_max.sec;
8706         *(ptr++) = stats->execution_time_max.usec;
8707     }
8708     *ptrP = ptr;
8709 }
8710
8711 /*
8712  * rx_RetrieveProcessRPCStats - retrieve all of the rpc statistics for
8713  * this process
8714  *
8715  * PARAMETERS
8716  *
8717  * IN callerVersion - the rpc stat version of the caller
8718  *
8719  * OUT myVersion - the rpc stat version of this function
8720  *
8721  * OUT clock_sec - local time seconds
8722  *
8723  * OUT clock_usec - local time microseconds
8724  *
8725  * OUT allocSize - the number of bytes allocated to contain stats
8726  *
8727  * OUT statCount - the number stats retrieved from this process.
8728  *
8729  * OUT stats - the actual stats retrieved from this process.
8730  *
8731  * RETURN CODES
8732  *
8733  * Returns void.  If successful, stats will != NULL.
8734  */
8735
8736 int
8737 rx_RetrieveProcessRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
8738                            afs_uint32 * clock_sec, afs_uint32 * clock_usec,
8739                            size_t * allocSize, afs_uint32 * statCount,
8740                            afs_uint32 ** stats)
8741 {
8742     size_t space = 0;
8743     afs_uint32 *ptr;
8744     struct clock now;
8745     int rc = 0;
8746
8747     *stats = 0;
8748     *allocSize = 0;
8749     *statCount = 0;
8750     *myVersion = RX_STATS_RETRIEVAL_VERSION;
8751
8752     /*
8753      * Check to see if stats are enabled
8754      */
8755
8756     MUTEX_ENTER(&rx_rpc_stats);
8757     if (!rxi_monitor_processStats) {
8758         MUTEX_EXIT(&rx_rpc_stats);
8759         return rc;
8760     }
8761
8762     clock_GetTime(&now);
8763     *clock_sec = now.sec;
8764     *clock_usec = now.usec;
8765
8766     /*
8767      * Allocate the space based upon the caller version
8768      *
8769      * If the client is at an older version than we are,
8770      * we return the statistic data in the older data format, but
8771      * we still return our version number so the client knows we
8772      * are maintaining more data than it can retrieve.
8773      */
8774
8775     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
8776         space = rxi_rpc_process_stat_cnt * sizeof(rx_function_entry_v1_t);
8777         *statCount = rxi_rpc_process_stat_cnt;
8778     } else {
8779         /*
8780          * This can't happen yet, but in the future version changes
8781          * can be handled by adding additional code here
8782          */
8783     }
8784
8785     if (space > (size_t) 0) {
8786         *allocSize = space;
8787         ptr = *stats = rxi_Alloc(space);
8788
8789         if (ptr != NULL) {
8790             struct opr_queue *cursor;
8791
8792             for (opr_queue_Scan(&processStats, cursor)) {
8793                 struct rx_interface_stat *rpc_stat =
8794                     opr_queue_Entry(cursor, struct rx_interface_stat, entry);
8795                 /*
8796                  * Copy the data based upon the caller version
8797                  */
8798                 rx_MarshallProcessRPCStats(callerVersion,
8799                                            rpc_stat->stats[0].func_total,
8800                                            rpc_stat->stats, &ptr);
8801             }
8802         } else {
8803             rc = ENOMEM;
8804         }
8805     }
8806     MUTEX_EXIT(&rx_rpc_stats);
8807     return rc;
8808 }
8809
8810 /*
8811  * rx_RetrievePeerRPCStats - retrieve all of the rpc statistics for the peers
8812  *
8813  * PARAMETERS
8814  *
8815  * IN callerVersion - the rpc stat version of the caller
8816  *
8817  * OUT myVersion - the rpc stat version of this function
8818  *
8819  * OUT clock_sec - local time seconds
8820  *
8821  * OUT clock_usec - local time microseconds
8822  *
8823  * OUT allocSize - the number of bytes allocated to contain stats
8824  *
8825  * OUT statCount - the number of stats retrieved from the individual
8826  * peer structures.
8827  *
8828  * OUT stats - the actual stats retrieved from the individual peer structures.
8829  *
8830  * RETURN CODES
8831  *
8832  * Returns void.  If successful, stats will != NULL.
8833  */
8834
8835 int
8836 rx_RetrievePeerRPCStats(afs_uint32 callerVersion, afs_uint32 * myVersion,
8837                         afs_uint32 * clock_sec, afs_uint32 * clock_usec,
8838                         size_t * allocSize, afs_uint32 * statCount,
8839                         afs_uint32 ** stats)
8840 {
8841     size_t space = 0;
8842     afs_uint32 *ptr;
8843     struct clock now;
8844     int rc = 0;
8845
8846     *stats = 0;
8847     *statCount = 0;
8848     *allocSize = 0;
8849     *myVersion = RX_STATS_RETRIEVAL_VERSION;
8850
8851     /*
8852      * Check to see if stats are enabled
8853      */
8854
8855     MUTEX_ENTER(&rx_rpc_stats);
8856     if (!rxi_monitor_peerStats) {
8857         MUTEX_EXIT(&rx_rpc_stats);
8858         return rc;
8859     }
8860
8861     clock_GetTime(&now);
8862     *clock_sec = now.sec;
8863     *clock_usec = now.usec;
8864
8865     /*
8866      * Allocate the space based upon the caller version
8867      *
8868      * If the client is at an older version than we are,
8869      * we return the statistic data in the older data format, but
8870      * we still return our version number so the client knows we
8871      * are maintaining more data than it can retrieve.
8872      */
8873
8874     if (callerVersion >= RX_STATS_RETRIEVAL_FIRST_EDITION) {
8875         space = rxi_rpc_peer_stat_cnt * sizeof(rx_function_entry_v1_t);
8876         *statCount = rxi_rpc_peer_stat_cnt;
8877     } else {
8878         /*
8879          * This can't happen yet, but in the future version changes
8880          * can be handled by adding additional code here
8881          */
8882     }
8883
8884     if (space > (size_t) 0) {
8885         *allocSize = space;
8886         ptr = *stats = rxi_Alloc(space);
8887
8888         if (ptr != NULL) {
8889             struct opr_queue *cursor;
8890
8891             for (opr_queue_Scan(&peerStats, cursor)) {
8892                 struct rx_interface_stat *rpc_stat
8893                     = opr_queue_Entry(cursor, struct rx_interface_stat,
8894                                      entryPeers);
8895
8896                 /*
8897                  * Copy the data based upon the caller version
8898                  */
8899                 rx_MarshallProcessRPCStats(callerVersion,
8900                                            rpc_stat->stats[0].func_total,
8901                                            rpc_stat->stats, &ptr);
8902             }
8903         } else {
8904             rc = ENOMEM;
8905         }
8906     }
8907     MUTEX_EXIT(&rx_rpc_stats);
8908     return rc;
8909 }
8910
8911 /*
8912  * rx_FreeRPCStats - free memory allocated by
8913  *                   rx_RetrieveProcessRPCStats and rx_RetrievePeerRPCStats
8914  *
8915  * PARAMETERS
8916  *
8917  * IN stats - stats previously returned by rx_RetrieveProcessRPCStats or
8918  * rx_RetrievePeerRPCStats
8919  *
8920  * IN allocSize - the number of bytes in stats.
8921  *
8922  * RETURN CODES
8923  *
8924  * Returns void.
8925  */
8926
8927 void
8928 rx_FreeRPCStats(afs_uint32 * stats, size_t allocSize)
8929 {
8930     rxi_Free(stats, allocSize);
8931 }
8932
8933 /*
8934  * rx_queryProcessRPCStats - see if process rpc stat collection is
8935  * currently enabled.
8936  *
8937  * PARAMETERS
8938  *
8939  * RETURN CODES
8940  *
8941  * Returns 0 if stats are not enabled != 0 otherwise
8942  */
8943
8944 int
8945 rx_queryProcessRPCStats(void)
8946 {
8947     int rc;
8948     MUTEX_ENTER(&rx_rpc_stats);
8949     rc = rxi_monitor_processStats;
8950     MUTEX_EXIT(&rx_rpc_stats);
8951     return rc;
8952 }
8953
8954 /*
8955  * rx_queryPeerRPCStats - see if peer stat collection is currently enabled.
8956  *
8957  * PARAMETERS
8958  *
8959  * RETURN CODES
8960  *
8961  * Returns 0 if stats are not enabled != 0 otherwise
8962  */
8963
8964 int
8965 rx_queryPeerRPCStats(void)
8966 {
8967     int rc;
8968     MUTEX_ENTER(&rx_rpc_stats);
8969     rc = rxi_monitor_peerStats;
8970     MUTEX_EXIT(&rx_rpc_stats);
8971     return rc;
8972 }
8973
8974 /*
8975  * rx_enableProcessRPCStats - begin rpc stat collection for entire process
8976  *
8977  * PARAMETERS
8978  *
8979  * RETURN CODES
8980  *
8981  * Returns void.
8982  */
8983
8984 void
8985 rx_enableProcessRPCStats(void)
8986 {
8987     MUTEX_ENTER(&rx_rpc_stats);
8988     rx_enable_stats = 1;
8989     rxi_monitor_processStats = 1;
8990     MUTEX_EXIT(&rx_rpc_stats);
8991 }
8992
8993 /*
8994  * rx_enablePeerRPCStats - begin rpc stat collection per peer structure
8995  *
8996  * PARAMETERS
8997  *
8998  * RETURN CODES
8999  *
9000  * Returns void.
9001  */
9002
9003 void
9004 rx_enablePeerRPCStats(void)
9005 {
9006     MUTEX_ENTER(&rx_rpc_stats);
9007     rx_enable_stats = 1;
9008     rxi_monitor_peerStats = 1;
9009     MUTEX_EXIT(&rx_rpc_stats);
9010 }
9011
9012 /*
9013  * rx_disableProcessRPCStats - stop rpc stat collection for entire process
9014  *
9015  * PARAMETERS
9016  *
9017  * RETURN CODES
9018  *
9019  * Returns void.
9020  */
9021
9022 void
9023 rx_disableProcessRPCStats(void)
9024 {
9025     struct opr_queue *cursor, *store;
9026     size_t space;
9027
9028     MUTEX_ENTER(&rx_rpc_stats);
9029
9030     /*
9031      * Turn off process statistics and if peer stats is also off, turn
9032      * off everything
9033      */
9034
9035     rxi_monitor_processStats = 0;
9036     if (rxi_monitor_peerStats == 0) {
9037         rx_enable_stats = 0;
9038     }
9039
9040     for (opr_queue_ScanSafe(&processStats, cursor, store)) {
9041         unsigned int num_funcs = 0;
9042         struct rx_interface_stat *rpc_stat
9043             = opr_queue_Entry(cursor, struct rx_interface_stat, entry);
9044
9045         opr_queue_Remove(&rpc_stat->entry);
9046
9047         num_funcs = rpc_stat->stats[0].func_total;
9048         space =
9049             sizeof(rx_interface_stat_t) +
9050             rpc_stat->stats[0].func_total * sizeof(rx_function_entry_v1_t);
9051
9052         rxi_Free(rpc_stat, space);
9053         rxi_rpc_process_stat_cnt -= num_funcs;
9054     }
9055     MUTEX_EXIT(&rx_rpc_stats);
9056 }
9057
9058 /*
9059  * rx_disablePeerRPCStats - stop rpc stat collection for peers
9060  *
9061  * PARAMETERS
9062  *
9063  * RETURN CODES
9064  *
9065  * Returns void.
9066  */
9067
9068 void
9069 rx_disablePeerRPCStats(void)
9070 {
9071     struct rx_peer **peer_ptr, **peer_end;
9072     int code;
9073
9074     /*
9075      * Turn off peer statistics and if process stats is also off, turn
9076      * off everything
9077      */
9078
9079     rxi_monitor_peerStats = 0;
9080     if (rxi_monitor_processStats == 0) {
9081         rx_enable_stats = 0;
9082     }
9083
9084     for (peer_ptr = &rx_peerHashTable[0], peer_end =
9085          &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
9086          peer_ptr++) {
9087         struct rx_peer *peer, *next, *prev;
9088
9089         MUTEX_ENTER(&rx_peerHashTable_lock);
9090         MUTEX_ENTER(&rx_rpc_stats);
9091         for (prev = peer = *peer_ptr; peer; peer = next) {
9092             next = peer->next;
9093             code = MUTEX_TRYENTER(&peer->peer_lock);
9094             if (code) {
9095                 size_t space;
9096                 struct opr_queue *cursor, *store;
9097
9098                 if (prev == *peer_ptr) {
9099                     *peer_ptr = next;
9100                     prev = next;
9101                 } else
9102                     prev->next = next;
9103
9104                 if (next)
9105                     next->refCount++;
9106                 if (prev)
9107                     prev->refCount++;
9108                 peer->refCount++;
9109                 MUTEX_EXIT(&rx_peerHashTable_lock);
9110
9111                 for (opr_queue_ScanSafe(&peer->rpcStats, cursor, store)) {
9112                     unsigned int num_funcs = 0;
9113                     struct rx_interface_stat *rpc_stat
9114                         = opr_queue_Entry(cursor, struct rx_interface_stat,
9115                                          entry);
9116
9117                     opr_queue_Remove(&rpc_stat->entry);
9118                     opr_queue_Remove(&rpc_stat->entryPeers);
9119                     num_funcs = rpc_stat->stats[0].func_total;
9120                     space =
9121                         sizeof(rx_interface_stat_t) +
9122                         rpc_stat->stats[0].func_total *
9123                         sizeof(rx_function_entry_v1_t);
9124
9125                     rxi_Free(rpc_stat, space);
9126                     rxi_rpc_peer_stat_cnt -= num_funcs;
9127                 }
9128                 MUTEX_EXIT(&peer->peer_lock);
9129
9130                 MUTEX_ENTER(&rx_peerHashTable_lock);
9131                 if (next)
9132                     next->refCount--;
9133                 if (prev)
9134                     prev->refCount--;
9135                 peer->refCount--;
9136             } else {
9137                 prev = peer;
9138             }
9139         }
9140         MUTEX_EXIT(&rx_rpc_stats);
9141         MUTEX_EXIT(&rx_peerHashTable_lock);
9142     }
9143 }
9144
9145 /*
9146  * rx_clearProcessRPCStats - clear the contents of the rpc stats according
9147  * to clearFlag
9148  *
9149  * PARAMETERS
9150  *
9151  * IN clearFlag - flag indicating which stats to clear
9152  *
9153  * RETURN CODES
9154  *
9155  * Returns void.
9156  */
9157
9158 void
9159 rx_clearProcessRPCStats(afs_uint32 clearFlag)
9160 {
9161     struct opr_queue *cursor;
9162
9163     MUTEX_ENTER(&rx_rpc_stats);
9164
9165     for (opr_queue_Scan(&processStats, cursor)) {
9166         unsigned int num_funcs = 0, i;
9167         struct rx_interface_stat *rpc_stat
9168              = opr_queue_Entry(rpc_stat, struct rx_interface_stat, entry);
9169
9170         num_funcs = rpc_stat->stats[0].func_total;
9171         for (i = 0; i < num_funcs; i++) {
9172             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
9173                 rpc_stat->stats[i].invocations = 0;
9174             }
9175             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
9176                 rpc_stat->stats[i].bytes_sent = 0;
9177             }
9178             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
9179                 rpc_stat->stats[i].bytes_rcvd = 0;
9180             }
9181             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
9182                 rpc_stat->stats[i].queue_time_sum.sec = 0;
9183                 rpc_stat->stats[i].queue_time_sum.usec = 0;
9184             }
9185             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
9186                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
9187                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
9188             }
9189             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
9190                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
9191                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
9192             }
9193             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
9194                 rpc_stat->stats[i].queue_time_max.sec = 0;
9195                 rpc_stat->stats[i].queue_time_max.usec = 0;
9196             }
9197             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
9198                 rpc_stat->stats[i].execution_time_sum.sec = 0;
9199                 rpc_stat->stats[i].execution_time_sum.usec = 0;
9200             }
9201             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
9202                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
9203                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
9204             }
9205             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
9206                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
9207                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
9208             }
9209             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
9210                 rpc_stat->stats[i].execution_time_max.sec = 0;
9211                 rpc_stat->stats[i].execution_time_max.usec = 0;
9212             }
9213         }
9214     }
9215
9216     MUTEX_EXIT(&rx_rpc_stats);
9217 }
9218
9219 /*
9220  * rx_clearPeerRPCStats - clear the contents of the rpc stats according
9221  * to clearFlag
9222  *
9223  * PARAMETERS
9224  *
9225  * IN clearFlag - flag indicating which stats to clear
9226  *
9227  * RETURN CODES
9228  *
9229  * Returns void.
9230  */
9231
9232 void
9233 rx_clearPeerRPCStats(afs_uint32 clearFlag)
9234 {
9235     struct opr_queue *cursor;
9236
9237     MUTEX_ENTER(&rx_rpc_stats);
9238
9239     for (opr_queue_Scan(&peerStats, cursor)) {
9240         unsigned int num_funcs, i;
9241         struct rx_interface_stat *rpc_stat
9242             = opr_queue_Entry(cursor, struct rx_interface_stat, entryPeers);
9243
9244         num_funcs = rpc_stat->stats[0].func_total;
9245         for (i = 0; i < num_funcs; i++) {
9246             if (clearFlag & AFS_RX_STATS_CLEAR_INVOCATIONS) {
9247                 rpc_stat->stats[i].invocations = 0;
9248             }
9249             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_SENT) {
9250                 rpc_stat->stats[i].bytes_sent = 0;
9251             }
9252             if (clearFlag & AFS_RX_STATS_CLEAR_BYTES_RCVD) {
9253                 rpc_stat->stats[i].bytes_rcvd = 0;
9254             }
9255             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM) {
9256                 rpc_stat->stats[i].queue_time_sum.sec = 0;
9257                 rpc_stat->stats[i].queue_time_sum.usec = 0;
9258             }
9259             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE) {
9260                 rpc_stat->stats[i].queue_time_sum_sqr.sec = 0;
9261                 rpc_stat->stats[i].queue_time_sum_sqr.usec = 0;
9262             }
9263             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN) {
9264                 rpc_stat->stats[i].queue_time_min.sec = 9999999;
9265                 rpc_stat->stats[i].queue_time_min.usec = 9999999;
9266             }
9267             if (clearFlag & AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX) {
9268                 rpc_stat->stats[i].queue_time_max.sec = 0;
9269                 rpc_stat->stats[i].queue_time_max.usec = 0;
9270             }
9271             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SUM) {
9272                 rpc_stat->stats[i].execution_time_sum.sec = 0;
9273                 rpc_stat->stats[i].execution_time_sum.usec = 0;
9274             }
9275             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE) {
9276                 rpc_stat->stats[i].execution_time_sum_sqr.sec = 0;
9277                 rpc_stat->stats[i].execution_time_sum_sqr.usec = 0;
9278             }
9279             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MIN) {
9280                 rpc_stat->stats[i].execution_time_min.sec = 9999999;
9281                 rpc_stat->stats[i].execution_time_min.usec = 9999999;
9282             }
9283             if (clearFlag & AFS_RX_STATS_CLEAR_EXEC_TIME_MAX) {
9284                 rpc_stat->stats[i].execution_time_max.sec = 0;
9285                 rpc_stat->stats[i].execution_time_max.usec = 0;
9286             }
9287         }
9288     }
9289
9290     MUTEX_EXIT(&rx_rpc_stats);
9291 }
9292
9293 /*
9294  * rxi_rxstat_userok points to a routine that returns 1 if the caller
9295  * is authorized to enable/disable/clear RX statistics.
9296  */
9297 static int (*rxi_rxstat_userok) (struct rx_call * call) = NULL;
9298
9299 void
9300 rx_SetRxStatUserOk(int (*proc) (struct rx_call * call))
9301 {
9302     rxi_rxstat_userok = proc;
9303 }
9304
9305 int
9306 rx_RxStatUserOk(struct rx_call *call)
9307 {
9308     if (!rxi_rxstat_userok)
9309         return 0;
9310     return rxi_rxstat_userok(call);
9311 }
9312
9313 #ifdef AFS_NT40_ENV
9314 /*
9315  * DllMain() -- Entry-point function called by the DllMainCRTStartup()
9316  *     function in the MSVC runtime DLL (msvcrt.dll).
9317  *
9318  *     Note: the system serializes calls to this function.
9319  */
9320 BOOL WINAPI
9321 DllMain(HINSTANCE dllInstHandle,        /* instance handle for this DLL module */
9322         DWORD reason,                   /* reason function is being called */
9323         LPVOID reserved)                /* reserved for future use */
9324 {
9325     switch (reason) {
9326     case DLL_PROCESS_ATTACH:
9327         /* library is being attached to a process */
9328         INIT_PTHREAD_LOCKS;
9329         return TRUE;
9330
9331     case DLL_PROCESS_DETACH:
9332         return TRUE;
9333
9334     default:
9335         return FALSE;
9336     }
9337 }
9338 #endif /* AFS_NT40_ENV */
9339
9340 #ifndef KERNEL
9341 int rx_DumpCalls(FILE *outputFile, char *cookie)
9342 {
9343 #ifdef RXDEBUG_PACKET
9344 #ifdef KDUMP_RX_LOCK
9345     struct rx_call_rx_lock *c;
9346 #else
9347     struct rx_call *c;
9348 #endif
9349 #ifdef AFS_NT40_ENV
9350     int zilch;
9351     char output[2048];
9352 #define RXDPRINTF sprintf
9353 #define RXDPRINTOUT output
9354 #else
9355 #define RXDPRINTF fprintf
9356 #define RXDPRINTOUT outputFile
9357 #endif
9358
9359     RXDPRINTF(RXDPRINTOUT, "%s - Start dumping all Rx Calls - count=%u\r\n", cookie, rx_stats.nCallStructs);
9360 #ifdef AFS_NT40_ENV
9361     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
9362 #endif
9363
9364     for (c = rx_allCallsp; c; c = c->allNextp) {
9365         u_short rqc, tqc, iovqc;
9366
9367         MUTEX_ENTER(&c->lock);
9368         rqc = opr_queue_Count(&c->rq);
9369         tqc = opr_queue_Count(&c->tq);
9370         iovqc = opr_queue_Count(&c->iovq);
9371
9372         RXDPRINTF(RXDPRINTOUT, "%s - call=0x%p, id=%u, state=%u, mode=%u, conn=%p, epoch=%u, cid=%u, callNum=%u, connFlags=0x%x, flags=0x%x, "
9373                 "rqc=%u,%u, tqc=%u,%u, iovqc=%u,%u, "
9374                 "lstatus=%u, rstatus=%u, error=%d, timeout=%u, "
9375                 "resendEvent=%d, timeoutEvt=%d, keepAliveEvt=%d, delayedAckEvt=%d, delayedAbortEvt=%d, abortCode=%d, abortCount=%d, "
9376                 "lastSendTime=%u, lastRecvTime=%u, lastSendData=%u"
9377 #ifdef RX_ENABLE_LOCKS
9378                 ", refCount=%u"
9379 #endif
9380 #ifdef RX_REFCOUNT_CHECK
9381                 ", refCountBegin=%u, refCountResend=%u, refCountDelay=%u, "
9382                 "refCountAlive=%u, refCountPacket=%u, refCountSend=%u, refCountAckAll=%u, refCountAbort=%u"
9383 #endif
9384                 "\r\n",
9385                 cookie, c, c->call_id, (afs_uint32)c->state, (afs_uint32)c->mode, c->conn, c->conn?c->conn->epoch:0, c->conn?c->conn->cid:0,
9386                 c->callNumber?*c->callNumber:0, c->conn?c->conn->flags:0, c->flags,
9387                 (afs_uint32)c->rqc, (afs_uint32)rqc, (afs_uint32)c->tqc, (afs_uint32)tqc, (afs_uint32)c->iovqc, (afs_uint32)iovqc,
9388                 (afs_uint32)c->localStatus, (afs_uint32)c->remoteStatus, c->error, c->timeout,
9389                 c->resendEvent?1:0, c->timeoutEvent?1:0, c->keepAliveEvent?1:0, c->delayedAckEvent?1:0, c->delayedAbortEvent?1:0,
9390                 c->abortCode, c->abortCount, c->lastSendTime, c->lastReceiveTime, c->lastSendData
9391 #ifdef RX_ENABLE_LOCKS
9392                 , (afs_uint32)c->refCount
9393 #endif
9394 #ifdef RX_REFCOUNT_CHECK
9395                 , c->refCDebug[0],c->refCDebug[1],c->refCDebug[2],c->refCDebug[3],c->refCDebug[4],c->refCDebug[5],c->refCDebug[6],c->refCDebug[7]
9396 #endif
9397                 );
9398         MUTEX_EXIT(&c->lock);
9399
9400 #ifdef AFS_NT40_ENV
9401         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
9402 #endif
9403     }
9404     RXDPRINTF(RXDPRINTOUT, "%s - End dumping all Rx Calls\r\n", cookie);
9405 #ifdef AFS_NT40_ENV
9406     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
9407 #endif
9408 #endif /* RXDEBUG_PACKET */
9409     return 0;
9410 }
9411 #endif