rx-flag-all-packets-20080925
[openafs.git] / src / rx / rx.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /* RX:  Extended Remote Procedure Call */
11
12 #include <afsconfig.h>
13 #ifdef  KERNEL
14 #include "afs/param.h"
15 #else
16 #include <afs/param.h>
17 #endif
18
19 RCSID
20     ("$Header$");
21
22 #ifdef KERNEL
23 #include "afs/sysincludes.h"
24 #include "afsincludes.h"
25 #ifndef UKERNEL
26 #include "h/types.h"
27 #include "h/time.h"
28 #include "h/stat.h"
29 #ifdef  AFS_OSF_ENV
30 #include <net/net_globals.h>
31 #endif /* AFS_OSF_ENV */
32 #ifdef AFS_LINUX20_ENV
33 #include "h/socket.h"
34 #endif
35 #include "netinet/in.h"
36 #ifdef AFS_SUN57_ENV
37 #include "inet/common.h"
38 #include "inet/ip.h"
39 #include "inet/ip_ire.h"
40 #endif
41 #include "afs/afs_args.h"
42 #include "afs/afs_osi.h"
43 #ifdef RX_KERNEL_TRACE
44 #include "rx_kcommon.h"
45 #endif
46 #if     (defined(AFS_AUX_ENV) || defined(AFS_AIX_ENV))
47 #include "h/systm.h"
48 #endif
49 #ifdef RXDEBUG
50 #undef RXDEBUG                  /* turn off debugging */
51 #endif /* RXDEBUG */
52 #if defined(AFS_SGI_ENV)
53 #include "sys/debug.h"
54 #endif
55 #include "afsint.h"
56 #ifdef  AFS_OSF_ENV
57 #undef kmem_alloc
58 #undef kmem_free
59 #undef mem_alloc
60 #undef mem_free
61 #undef register
62 #endif /* AFS_OSF_ENV */
63 #else /* !UKERNEL */
64 #include "afs/sysincludes.h"
65 #include "afsincludes.h"
66 #endif /* !UKERNEL */
67 #include "afs/lock.h"
68 #include "rx_kmutex.h"
69 #include "rx_kernel.h"
70 #include "rx_clock.h"
71 #include "rx_queue.h"
72 #include "rx.h"
73 #include "rx_globals.h"
74 #include "rx_trace.h"
75 #define AFSOP_STOP_RXCALLBACK   210     /* Stop CALLBACK process */
76 #define AFSOP_STOP_AFS          211     /* Stop AFS process */
77 #define AFSOP_STOP_BKG          212     /* Stop BKG process */
78 #include "afsint.h"
79 extern afs_int32 afs_termState;
80 #ifdef AFS_AIX41_ENV
81 #include "sys/lockl.h"
82 #include "sys/lock_def.h"
83 #endif /* AFS_AIX41_ENV */
84 # include "rxgen_consts.h"
85 #else /* KERNEL */
86 # include <sys/types.h>
87 # include <string.h>
88 # include <stdarg.h>
89 # include <errno.h>
90 #ifdef AFS_NT40_ENV
91 # include <stdlib.h>
92 # include <fcntl.h>
93 # include <afs/afsutil.h>
94 # include <WINNT\afsreg.h>
95 #else
96 # include <sys/socket.h>
97 # include <sys/file.h>
98 # include <netdb.h>
99 # include <sys/stat.h>
100 # include <netinet/in.h>
101 # include <sys/time.h>
102 #endif
103 # include "rx.h"
104 # include "rx_user.h"
105 # include "rx_clock.h"
106 # include "rx_queue.h"
107 # include "rx_globals.h"
108 # include "rx_trace.h"
109 # include <afs/rxgen_consts.h>
110 #endif /* KERNEL */
111
112 #ifndef KERNEL
113 #ifdef AFS_PTHREAD_ENV
114 #ifndef AFS_NT40_ENV
115 int (*registerProgram) (pid_t, char *) = 0;
116 int (*swapNameProgram) (pid_t, const char *, char *) = 0;
117 #endif
118 #else
119 int (*registerProgram) (PROCESS, char *) = 0;
120 int (*swapNameProgram) (PROCESS, const char *, char *) = 0;
121 #endif
122 #endif
123
124 /* Local static routines */
125 static void rxi_DestroyConnectionNoLock(register struct rx_connection *conn);
126 #ifdef RX_ENABLE_LOCKS
127 static void rxi_SetAcksInTransmitQueue(register struct rx_call *call);
128 #endif
129
130 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
131 struct rx_tq_debug {
132     afs_int32 rxi_start_aborted;        /* rxi_start awoke after rxi_Send in error. */
133     afs_int32 rxi_start_in_error;
134 } rx_tq_debug;
135 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
136
137 /*
138  * rxi_rpc_peer_stat_cnt counts the total number of peer stat structures
139  * currently allocated within rx.  This number is used to allocate the
140  * memory required to return the statistics when queried.
141  */
142
143 static unsigned int rxi_rpc_peer_stat_cnt;
144
145 /*
146  * rxi_rpc_process_stat_cnt counts the total number of local process stat
147  * structures currently allocated within rx.  The number is used to allocate
148  * the memory required to return the statistics when queried.
149  */
150
151 static unsigned int rxi_rpc_process_stat_cnt;
152
153 #if !defined(offsetof)
154 #include <stddef.h>             /* for definition of offsetof() */
155 #endif
156
157 #ifdef AFS_PTHREAD_ENV
158 #include <assert.h>
159
160 /*
161  * Use procedural initialization of mutexes/condition variables
162  * to ease NT porting
163  */
164
165 extern pthread_mutex_t rx_stats_mutex;
166 extern pthread_mutex_t des_init_mutex;
167 extern pthread_mutex_t des_random_mutex;
168 extern pthread_mutex_t rx_clock_mutex;
169 extern pthread_mutex_t rxi_connCacheMutex;
170 extern pthread_mutex_t rx_event_mutex;
171 extern pthread_mutex_t osi_malloc_mutex;
172 extern pthread_mutex_t event_handler_mutex;
173 extern pthread_mutex_t listener_mutex;
174 extern pthread_mutex_t rx_if_init_mutex;
175 extern pthread_mutex_t rx_if_mutex;
176 extern pthread_mutex_t rxkad_client_uid_mutex;
177 extern pthread_mutex_t rxkad_random_mutex;
178
179 extern pthread_cond_t rx_event_handler_cond;
180 extern pthread_cond_t rx_listener_cond;
181
182 static pthread_mutex_t epoch_mutex;
183 static pthread_mutex_t rx_init_mutex;
184 static pthread_mutex_t rx_debug_mutex;
185 static pthread_mutex_t rx_rpc_stats;
186
187 static void
188 rxi_InitPthread(void)
189 {
190     assert(pthread_mutex_init(&rx_clock_mutex, (const pthread_mutexattr_t *)0)
191            == 0);
192     assert(pthread_mutex_init(&rx_stats_mutex, (const pthread_mutexattr_t *)0)
193            == 0);
194     assert(pthread_mutex_init
195            (&rxi_connCacheMutex, (const pthread_mutexattr_t *)0) == 0);
196     assert(pthread_mutex_init(&rx_init_mutex, (const pthread_mutexattr_t *)0)
197            == 0);
198     assert(pthread_mutex_init(&epoch_mutex, (const pthread_mutexattr_t *)0) ==
199            0);
200     assert(pthread_mutex_init(&rx_event_mutex, (const pthread_mutexattr_t *)0)
201            == 0);
202     assert(pthread_mutex_init(&des_init_mutex, (const pthread_mutexattr_t *)0)
203            == 0);
204     assert(pthread_mutex_init
205            (&des_random_mutex, (const pthread_mutexattr_t *)0) == 0);
206     assert(pthread_mutex_init
207            (&osi_malloc_mutex, (const pthread_mutexattr_t *)0) == 0);
208     assert(pthread_mutex_init
209            (&event_handler_mutex, (const pthread_mutexattr_t *)0) == 0);
210     assert(pthread_mutex_init(&listener_mutex, (const pthread_mutexattr_t *)0)
211            == 0);
212     assert(pthread_mutex_init
213            (&rx_if_init_mutex, (const pthread_mutexattr_t *)0) == 0);
214     assert(pthread_mutex_init(&rx_if_mutex, (const pthread_mutexattr_t *)0) ==
215            0);
216     assert(pthread_mutex_init
217            (&rxkad_client_uid_mutex, (const pthread_mutexattr_t *)0) == 0);
218     assert(pthread_mutex_init
219            (&rxkad_random_mutex, (const pthread_mutexattr_t *)0) == 0);
220     assert(pthread_mutex_init(&rx_debug_mutex, (const pthread_mutexattr_t *)0)
221            == 0);
222
223     assert(pthread_cond_init
224            (&rx_event_handler_cond, (const pthread_condattr_t *)0) == 0);
225     assert(pthread_cond_init(&rx_listener_cond, (const pthread_condattr_t *)0)
226            == 0);
227     assert(pthread_key_create(&rx_thread_id_key, NULL) == 0);
228     assert(pthread_key_create(&rx_ts_info_key, NULL) == 0);
229  
230     rxkad_global_stats_init();
231
232     MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
233     MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
234 #ifdef  RX_ENABLE_LOCKS
235 #ifdef RX_LOCKS_DB
236     rxdb_init();
237 #endif /* RX_LOCKS_DB */
238     MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
239     MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock", MUTEX_DEFAULT,
240                0);
241     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
242             0);
243     MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
244                0);
245     MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
246                0);
247     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
248     MUTEX_INIT(&rxi_keyCreate_lock, "rxi_keyCreate_lock", MUTEX_DEFAULT, 0);
249 #endif /* RX_ENABLE_LOCKS */
250 }
251
252 pthread_once_t rx_once_init = PTHREAD_ONCE_INIT;
253 #define INIT_PTHREAD_LOCKS \
254 assert(pthread_once(&rx_once_init, rxi_InitPthread)==0)
255 /*
256  * The rx_stats_mutex mutex protects the following global variables:
257  * rxi_dataQuota
258  * rxi_minDeficit
259  * rxi_availProcs
260  * rxi_totalMin
261  * rxi_lowConnRefCount
262  * rxi_lowPeerRefCount
263  * rxi_nCalls
264  * rxi_Alloccnt
265  * rxi_Allocsize
266  * rx_nFreePackets
267  * rx_tq_debug
268  * rx_stats
269  */
270 #else
271 #define INIT_PTHREAD_LOCKS
272 #endif
273
274
275 /* Variables for handling the minProcs implementation.  availProcs gives the
276  * number of threads available in the pool at this moment (not counting dudes
277  * executing right now).  totalMin gives the total number of procs required
278  * for handling all minProcs requests.  minDeficit is a dynamic variable
279  * tracking the # of procs required to satisfy all of the remaining minProcs
280  * demands.
281  * For fine grain locking to work, the quota check and the reservation of
282  * a server thread has to come while rxi_availProcs and rxi_minDeficit
283  * are locked. To this end, the code has been modified under #ifdef
284  * RX_ENABLE_LOCKS so that quota checks and reservation occur at the
285  * same time. A new function, ReturnToServerPool() returns the allocation.
286  * 
287  * A call can be on several queue's (but only one at a time). When
288  * rxi_ResetCall wants to remove the call from a queue, it has to ensure
289  * that no one else is touching the queue. To this end, we store the address
290  * of the queue lock in the call structure (under the call lock) when we
291  * put the call on a queue, and we clear the call_queue_lock when the
292  * call is removed from a queue (once the call lock has been obtained).
293  * This allows rxi_ResetCall to safely synchronize with others wishing
294  * to manipulate the queue.
295  */
296
297 #if defined(RX_ENABLE_LOCKS) && defined(KERNEL)
298 static afs_kmutex_t rx_rpc_stats;
299 void rxi_StartUnlocked(struct rxevent *event, void *call,
300                        void *arg1, int istack);
301 #endif
302
303 /* We keep a "last conn pointer" in rxi_FindConnection. The odds are 
304 ** pretty good that the next packet coming in is from the same connection 
305 ** as the last packet, since we're send multiple packets in a transmit window.
306 */
307 struct rx_connection *rxLastConn = 0;
308
309 #ifdef RX_ENABLE_LOCKS
310 /* The locking hierarchy for rx fine grain locking is composed of these
311  * tiers:
312  *
313  * rx_connHashTable_lock - synchronizes conn creation, rx_connHashTable access
314  * conn_call_lock - used to synchonize rx_EndCall and rx_NewCall
315  * call->lock - locks call data fields.
316  * These are independent of each other:
317  *      rx_freeCallQueue_lock
318  *      rxi_keyCreate_lock
319  * rx_serverPool_lock
320  * freeSQEList_lock
321  *
322  * serverQueueEntry->lock
323  * rx_rpc_stats
324  * rx_peerHashTable_lock - locked under rx_connHashTable_lock
325  * peer->lock - locks peer data fields.
326  * conn_data_lock - that more than one thread is not updating a conn data
327  *                  field at the same time.
328  * rx_freePktQ_lock
329  *
330  * lowest level:
331  *      multi_handle->lock
332  *      rxevent_lock
333  *      rx_stats_mutex
334  *
335  * Do we need a lock to protect the peer field in the conn structure?
336  *      conn->peer was previously a constant for all intents and so has no
337  *      lock protecting this field. The multihomed client delta introduced
338  *      a RX code change : change the peer field in the connection structure
339  *      to that remote inetrface from which the last packet for this
340  *      connection was sent out. This may become an issue if further changes
341  *      are made.
342  */
343 #define SET_CALL_QUEUE_LOCK(C, L) (C)->call_queue_lock = (L)
344 #define CLEAR_CALL_QUEUE_LOCK(C) (C)->call_queue_lock = NULL
345 #ifdef RX_LOCKS_DB
346 /* rxdb_fileID is used to identify the lock location, along with line#. */
347 static int rxdb_fileID = RXDB_FILE_RX;
348 #endif /* RX_LOCKS_DB */
349 #else /* RX_ENABLE_LOCKS */
350 #define SET_CALL_QUEUE_LOCK(C, L)
351 #define CLEAR_CALL_QUEUE_LOCK(C)
352 #endif /* RX_ENABLE_LOCKS */
353 struct rx_serverQueueEntry *rx_waitForPacket = 0;
354 struct rx_serverQueueEntry *rx_waitingForPacket = 0;
355
356 /* ------------Exported Interfaces------------- */
357
358 /* This function allows rxkad to set the epoch to a suitably random number
359  * which rx_NewConnection will use in the future.  The principle purpose is to
360  * get rxnull connections to use the same epoch as the rxkad connections do, at
361  * least once the first rxkad connection is established.  This is important now
362  * that the host/port addresses aren't used in FindConnection: the uniqueness
363  * of epoch/cid matters and the start time won't do. */
364
365 #ifdef AFS_PTHREAD_ENV
366 /*
367  * This mutex protects the following global variables:
368  * rx_epoch
369  */
370
371 #define LOCK_EPOCH assert(pthread_mutex_lock(&epoch_mutex)==0)
372 #define UNLOCK_EPOCH assert(pthread_mutex_unlock(&epoch_mutex)==0)
373 #else
374 #define LOCK_EPOCH
375 #define UNLOCK_EPOCH
376 #endif /* AFS_PTHREAD_ENV */
377
378 void
379 rx_SetEpoch(afs_uint32 epoch)
380 {
381     LOCK_EPOCH;
382     rx_epoch = epoch;
383     UNLOCK_EPOCH;
384 }
385
386 /* Initialize rx.  A port number may be mentioned, in which case this
387  * becomes the default port number for any service installed later.
388  * If 0 is provided for the port number, a random port will be chosen
389  * by the kernel.  Whether this will ever overlap anything in
390  * /etc/services is anybody's guess...  Returns 0 on success, -1 on
391  * error. */
392 #ifndef AFS_NT40_ENV
393 static
394 #endif
395 int rxinit_status = 1;
396 #ifdef AFS_PTHREAD_ENV
397 /*
398  * This mutex protects the following global variables:
399  * rxinit_status
400  */
401
402 #define LOCK_RX_INIT assert(pthread_mutex_lock(&rx_init_mutex)==0)
403 #define UNLOCK_RX_INIT assert(pthread_mutex_unlock(&rx_init_mutex)==0)
404 #else
405 #define LOCK_RX_INIT
406 #define UNLOCK_RX_INIT
407 #endif
408
409 int
410 rx_InitHost(u_int host, u_int port)
411 {
412 #ifdef KERNEL
413     osi_timeval_t tv;
414 #else /* KERNEL */
415     struct timeval tv;
416 #endif /* KERNEL */
417     char *htable, *ptable;
418     int tmp_status;
419     
420     SPLVAR;
421     
422     INIT_PTHREAD_LOCKS;
423     LOCK_RX_INIT;
424     if (rxinit_status == 0) {
425         tmp_status = rxinit_status;
426         UNLOCK_RX_INIT;
427         return tmp_status;      /* Already started; return previous error code. */
428     }
429 #ifdef RXDEBUG
430     rxi_DebugInit();
431 #endif
432 #ifdef AFS_NT40_ENV
433     if (afs_winsockInit() < 0)
434         return -1;
435 #endif
436     
437 #ifndef KERNEL
438     /*
439      * Initialize anything necessary to provide a non-premptive threading
440      * environment.
441      */
442     rxi_InitializeThreadSupport();
443 #endif
444     
445     /* Allocate and initialize a socket for client and perhaps server
446      * connections. */
447     
448     rx_socket = rxi_GetHostUDPSocket(host, (u_short) port);
449     if (rx_socket == OSI_NULLSOCKET) {
450         UNLOCK_RX_INIT;
451         return RX_ADDRINUSE;
452     }
453 #if defined(RX_ENABLE_LOCKS) && defined(KERNEL)
454 #ifdef RX_LOCKS_DB
455     rxdb_init();
456 #endif /* RX_LOCKS_DB */
457     MUTEX_INIT(&rx_stats_mutex, "rx_stats_mutex", MUTEX_DEFAULT, 0);
458     MUTEX_INIT(&rx_rpc_stats, "rx_rpc_stats", MUTEX_DEFAULT, 0);
459     MUTEX_INIT(&rx_freePktQ_lock, "rx_freePktQ_lock", MUTEX_DEFAULT, 0);
460     MUTEX_INIT(&freeSQEList_lock, "freeSQEList lock", MUTEX_DEFAULT, 0);
461     MUTEX_INIT(&rx_freeCallQueue_lock, "rx_freeCallQueue_lock", MUTEX_DEFAULT,
462                0);
463     CV_INIT(&rx_waitingForPackets_cv, "rx_waitingForPackets_cv", CV_DEFAULT,
464             0);
465     MUTEX_INIT(&rx_peerHashTable_lock, "rx_peerHashTable_lock", MUTEX_DEFAULT,
466                0);
467     MUTEX_INIT(&rx_connHashTable_lock, "rx_connHashTable_lock", MUTEX_DEFAULT,
468                0);
469     MUTEX_INIT(&rx_serverPool_lock, "rx_serverPool_lock", MUTEX_DEFAULT, 0);
470 #if defined(AFS_HPUX110_ENV)
471     if (!uniprocessor)
472         rx_sleepLock = alloc_spinlock(LAST_HELD_ORDER - 10, "rx_sleepLock");
473 #endif /* AFS_HPUX110_ENV */
474 #endif /* RX_ENABLE_LOCKS && KERNEL */
475
476     rxi_nCalls = 0;
477     rx_connDeadTime = 12;
478     rx_tranquil = 0;            /* reset flag */
479     memset((char *)&rx_stats, 0, sizeof(struct rx_statistics));
480     htable = (char *)
481         osi_Alloc(rx_hashTableSize * sizeof(struct rx_connection *));
482     PIN(htable, rx_hashTableSize * sizeof(struct rx_connection *));     /* XXXXX */
483     memset(htable, 0, rx_hashTableSize * sizeof(struct rx_connection *));
484     ptable = (char *)osi_Alloc(rx_hashTableSize * sizeof(struct rx_peer *));
485     PIN(ptable, rx_hashTableSize * sizeof(struct rx_peer *));   /* XXXXX */
486     memset(ptable, 0, rx_hashTableSize * sizeof(struct rx_peer *));
487
488     /* Malloc up a bunch of packets & buffers */
489     rx_nFreePackets = 0;
490     queue_Init(&rx_freePacketQueue);
491     rxi_NeedMorePackets = FALSE;
492 #ifdef RX_ENABLE_TSFPQ
493     rx_nPackets = 0;    /* in TSFPQ version, rx_nPackets is managed by rxi_MorePackets* */
494     rxi_MorePacketsTSFPQ(rx_extraPackets + RX_MAX_QUOTA + 2, RX_TS_FPQ_FLUSH_GLOBAL, 0);
495 #else /* RX_ENABLE_TSFPQ */
496     rx_nPackets = rx_extraPackets + RX_MAX_QUOTA + 2;   /* fudge */
497     rxi_MorePackets(rx_nPackets);
498 #endif /* RX_ENABLE_TSFPQ */
499     rx_CheckPackets();
500
501     NETPRI;
502
503     clock_Init();
504
505 #if defined(AFS_NT40_ENV) && !defined(AFS_PTHREAD_ENV)
506     tv.tv_sec = clock_now.sec;
507     tv.tv_usec = clock_now.usec;
508     srand((unsigned int)tv.tv_usec);
509 #else
510     osi_GetTime(&tv);
511 #endif
512     if (port) {
513         rx_port = port;
514     } else {
515 #if defined(KERNEL) && !defined(UKERNEL)
516         /* Really, this should never happen in a real kernel */
517         rx_port = 0;
518 #else
519         struct sockaddr_in addr;
520 #ifdef AFS_NT40_ENV
521         int addrlen = sizeof(addr);
522 #else
523         socklen_t addrlen = sizeof(addr);
524 #endif
525         if (getsockname((int)rx_socket, (struct sockaddr *)&addr, &addrlen)) {
526             rx_Finalize();
527             return -1;
528         }
529         rx_port = addr.sin_port;
530 #endif
531     }
532     rx_stats.minRtt.sec = 9999999;
533 #ifdef  KERNEL
534     rx_SetEpoch(tv.tv_sec | 0x80000000);
535 #else
536     rx_SetEpoch(tv.tv_sec);     /* Start time of this package, rxkad
537                                  * will provide a randomer value. */
538 #endif
539     MUTEX_ENTER(&rx_stats_mutex);
540     rxi_dataQuota += rx_extraQuota;     /* + extra pkts caller asked to rsrv */
541     MUTEX_EXIT(&rx_stats_mutex);
542     /* *Slightly* random start time for the cid.  This is just to help
543      * out with the hashing function at the peer */
544     rx_nextCid = ((tv.tv_sec ^ tv.tv_usec) << RX_CIDSHIFT);
545     rx_connHashTable = (struct rx_connection **)htable;
546     rx_peerHashTable = (struct rx_peer **)ptable;
547
548     rx_lastAckDelay.sec = 0;
549     rx_lastAckDelay.usec = 400000;      /* 400 milliseconds */
550     rx_hardAckDelay.sec = 0;
551     rx_hardAckDelay.usec = 100000;      /* 100 milliseconds */
552     rx_softAckDelay.sec = 0;
553     rx_softAckDelay.usec = 100000;      /* 100 milliseconds */
554
555     rxevent_Init(20, rxi_ReScheduleEvents);
556
557     /* Initialize various global queues */
558     queue_Init(&rx_idleServerQueue);
559     queue_Init(&rx_incomingCallQueue);
560     queue_Init(&rx_freeCallQueue);
561
562 #if defined(AFS_NT40_ENV) && !defined(KERNEL)
563     /* Initialize our list of usable IP addresses. */
564     rx_GetIFInfo();
565 #endif
566
567     /* Start listener process (exact function is dependent on the
568      * implementation environment--kernel or user space) */
569     rxi_StartListener();
570
571     USERPRI;
572     tmp_status = rxinit_status = 0;
573     UNLOCK_RX_INIT;
574     return tmp_status;
575 }
576
577 int
578 rx_Init(u_int port)
579 {
580     return rx_InitHost(htonl(INADDR_ANY), port);
581 }
582
583 /* called with unincremented nRequestsRunning to see if it is OK to start
584  * a new thread in this service.  Could be "no" for two reasons: over the
585  * max quota, or would prevent others from reaching their min quota.
586  */
587 #ifdef RX_ENABLE_LOCKS
588 /* This verion of QuotaOK reserves quota if it's ok while the
589  * rx_serverPool_lock is held.  Return quota using ReturnToServerPool().
590  */
591 static int
592 QuotaOK(register struct rx_service *aservice)
593 {
594     /* check if over max quota */
595     if (aservice->nRequestsRunning >= aservice->maxProcs) {
596         return 0;
597     }
598
599     /* under min quota, we're OK */
600     /* otherwise, can use only if there are enough to allow everyone
601      * to go to their min quota after this guy starts.
602      */
603     MUTEX_ENTER(&rx_stats_mutex);
604     if ((aservice->nRequestsRunning < aservice->minProcs)
605         || (rxi_availProcs > rxi_minDeficit)) {
606         aservice->nRequestsRunning++;
607         /* just started call in minProcs pool, need fewer to maintain
608          * guarantee */
609         if (aservice->nRequestsRunning <= aservice->minProcs)
610             rxi_minDeficit--;
611         rxi_availProcs--;
612         MUTEX_EXIT(&rx_stats_mutex);
613         return 1;
614     }
615     MUTEX_EXIT(&rx_stats_mutex);
616
617     return 0;
618 }
619
620 static void
621 ReturnToServerPool(register struct rx_service *aservice)
622 {
623     aservice->nRequestsRunning--;
624     MUTEX_ENTER(&rx_stats_mutex);
625     if (aservice->nRequestsRunning < aservice->minProcs)
626         rxi_minDeficit++;
627     rxi_availProcs++;
628     MUTEX_EXIT(&rx_stats_mutex);
629 }
630
631 #else /* RX_ENABLE_LOCKS */
632 static int
633 QuotaOK(register struct rx_service *aservice)
634 {
635     int rc = 0;
636     /* under min quota, we're OK */
637     if (aservice->nRequestsRunning < aservice->minProcs)
638         return 1;
639
640     /* check if over max quota */
641     if (aservice->nRequestsRunning >= aservice->maxProcs)
642         return 0;
643
644     /* otherwise, can use only if there are enough to allow everyone
645      * to go to their min quota after this guy starts.
646      */
647     if (rxi_availProcs > rxi_minDeficit)
648         rc = 1;
649     return rc;
650 }
651 #endif /* RX_ENABLE_LOCKS */
652
653 #ifndef KERNEL
654 /* Called by rx_StartServer to start up lwp's to service calls.
655    NExistingProcs gives the number of procs already existing, and which
656    therefore needn't be created. */
657 void
658 rxi_StartServerProcs(int nExistingProcs)
659 {
660     register struct rx_service *service;
661     register int i;
662     int maxdiff = 0;
663     int nProcs = 0;
664
665     /* For each service, reserve N processes, where N is the "minimum"
666      * number of processes that MUST be able to execute a request in parallel,
667      * at any time, for that process.  Also compute the maximum difference
668      * between any service's maximum number of processes that can run
669      * (i.e. the maximum number that ever will be run, and a guarantee
670      * that this number will run if other services aren't running), and its
671      * minimum number.  The result is the extra number of processes that
672      * we need in order to provide the latter guarantee */
673     for (i = 0; i < RX_MAX_SERVICES; i++) {
674         int diff;
675         service = rx_services[i];
676         if (service == (struct rx_service *)0)
677             break;
678         nProcs += service->minProcs;
679         diff = service->maxProcs - service->minProcs;
680         if (diff > maxdiff)
681             maxdiff = diff;
682     }
683     nProcs += maxdiff;          /* Extra processes needed to allow max number requested to run in any given service, under good conditions */
684     nProcs -= nExistingProcs;   /* Subtract the number of procs that were previously created for use as server procs */
685     for (i = 0; i < nProcs; i++) {
686         rxi_StartServerProc(rx_ServerProc, rx_stackSize);
687     }
688 }
689 #endif /* KERNEL */
690
691 #ifdef AFS_NT40_ENV
692 /* This routine is only required on Windows */
693 void
694 rx_StartClientThread(void)
695 {
696 #ifdef AFS_PTHREAD_ENV
697     pthread_t pid;
698     pid = pthread_self();
699 #endif /* AFS_PTHREAD_ENV */
700 }
701 #endif /* AFS_NT40_ENV */
702
703 /* This routine must be called if any services are exported.  If the
704  * donateMe flag is set, the calling process is donated to the server
705  * process pool */
706 void
707 rx_StartServer(int donateMe)
708 {
709     register struct rx_service *service;
710     register int i;
711     SPLVAR;
712     clock_NewTime();
713
714     NETPRI;
715     /* Start server processes, if necessary (exact function is dependent
716      * on the implementation environment--kernel or user space).  DonateMe
717      * will be 1 if there is 1 pre-existing proc, i.e. this one.  In this
718      * case, one less new proc will be created rx_StartServerProcs.
719      */
720     rxi_StartServerProcs(donateMe);
721
722     /* count up the # of threads in minProcs, and add set the min deficit to
723      * be that value, too.
724      */
725     for (i = 0; i < RX_MAX_SERVICES; i++) {
726         service = rx_services[i];
727         if (service == (struct rx_service *)0)
728             break;
729         MUTEX_ENTER(&rx_stats_mutex);
730         rxi_totalMin += service->minProcs;
731         /* below works even if a thread is running, since minDeficit would
732          * still have been decremented and later re-incremented.
733          */
734         rxi_minDeficit += service->minProcs;
735         MUTEX_EXIT(&rx_stats_mutex);
736     }
737
738     /* Turn on reaping of idle server connections */
739     rxi_ReapConnections(NULL, NULL, NULL);
740
741     USERPRI;
742
743     if (donateMe) {
744 #ifndef AFS_NT40_ENV
745 #ifndef KERNEL
746         char name[32];
747         static int nProcs;
748 #ifdef AFS_PTHREAD_ENV
749         pid_t pid;
750         pid = (pid_t) pthread_self();
751 #else /* AFS_PTHREAD_ENV */
752         PROCESS pid;
753         LWP_CurrentProcess(&pid);
754 #endif /* AFS_PTHREAD_ENV */
755
756         sprintf(name, "srv_%d", ++nProcs);
757         if (registerProgram)
758             (*registerProgram) (pid, name);
759 #endif /* KERNEL */
760 #endif /* AFS_NT40_ENV */
761         rx_ServerProc(NULL);    /* Never returns */
762     }
763 #ifdef RX_ENABLE_TSFPQ
764     /* no use leaving packets around in this thread's local queue if
765      * it isn't getting donated to the server thread pool. 
766      */
767     rxi_FlushLocalPacketsTSFPQ();
768 #endif /* RX_ENABLE_TSFPQ */
769     return;
770 }
771
772 /* Create a new client connection to the specified service, using the
773  * specified security object to implement the security model for this
774  * connection. */
775 struct rx_connection *
776 rx_NewConnection(register afs_uint32 shost, u_short sport, u_short sservice,
777                  register struct rx_securityClass *securityObject,
778                  int serviceSecurityIndex)
779 {
780     int hashindex, i;
781     afs_int32 cid, cix, nclones;
782     register struct rx_connection *conn, *tconn, *ptconn;
783
784     SPLVAR;
785
786     clock_NewTime();
787     dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", ntohl(shost), ntohs(sport), sservice, securityObject, serviceSecurityIndex));
788
789         conn = tconn = 0;
790         nclones = rx_max_clones_per_connection;
791
792     /* Vasilsi said: "NETPRI protects Cid and Alloc", but can this be true in
793      * the case of kmem_alloc? */
794
795     NETPRI;
796     MUTEX_ENTER(&rx_connHashTable_lock);
797
798     /* send in the clones */
799     for(cix = 0; cix <= nclones; ++cix) {
800           
801           ptconn = tconn;
802           tconn = rxi_AllocConnection();
803           tconn->type = RX_CLIENT_CONNECTION;
804           tconn->epoch = rx_epoch;
805           tconn->peer = rxi_FindPeer(shost, sport, 0, 1);
806           tconn->serviceId = sservice;
807           tconn->securityObject = securityObject;
808           tconn->securityData = (void *) 0;
809           tconn->securityIndex = serviceSecurityIndex;
810           tconn->ackRate = RX_FAST_ACK_RATE;
811           tconn->nSpecific = 0;
812           tconn->specific = NULL;
813           tconn->challengeEvent = NULL;
814           tconn->delayedAbortEvent = NULL;
815           tconn->abortCount = 0;
816           tconn->error = 0;
817     for (i = 0; i < RX_MAXCALLS; i++) {
818         tconn->twind[i] = rx_initSendWindow;
819         tconn->rwind[i] = rx_initReceiveWindow;
820     }
821           tconn->parent = 0;
822           tconn->next_clone = 0;
823           tconn->nclones = nclones;
824           rx_SetConnDeadTime(tconn, rx_connDeadTime);
825                 
826           if(cix == 0) {
827                 conn = tconn;
828           } else {
829                 tconn->flags |= RX_CLONED_CONNECTION;
830                 tconn->parent = conn;
831                 ptconn->next_clone = tconn;
832           }
833
834           /* generic connection setup */
835 #ifdef  RX_ENABLE_LOCKS
836           MUTEX_INIT(&tconn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
837           MUTEX_INIT(&tconn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
838           CV_INIT(&tconn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
839 #endif
840           cid = (rx_nextCid += RX_MAXCALLS);
841           tconn->cid = cid;
842           RXS_NewConnection(securityObject, tconn);
843           hashindex =
844                 CONN_HASH(shost, sport, tconn->cid, tconn->epoch, 
845                                   RX_CLIENT_CONNECTION);
846           tconn->refCount++; /* no lock required since only this thread knows */
847           tconn->next = rx_connHashTable[hashindex];
848           rx_connHashTable[hashindex] = tconn;
849           rx_MutexIncrement(rx_stats.nClientConns, rx_stats_mutex);     
850     }
851     
852     MUTEX_EXIT(&rx_connHashTable_lock);
853     USERPRI;
854     return conn;
855 }
856
857 void
858 rx_SetConnDeadTime(register struct rx_connection *conn, register int seconds)
859 {
860   /* The idea is to set the dead time to a value that allows several
861    * keepalives to be dropped without timing out the connection. */
862   struct rx_connection *tconn;
863   tconn = conn;
864   do {
865         tconn->secondsUntilDead = MAX(seconds, 6);
866         tconn->secondsUntilPing = tconn->secondsUntilDead / 6;
867   } while(tconn->next_clone && (tconn = tconn->next_clone));
868 }
869
870 int rxi_lowPeerRefCount = 0;
871 int rxi_lowConnRefCount = 0;
872
873 /*
874  * Cleanup a connection that was destroyed in rxi_DestroyConnectioNoLock.
875  * NOTE: must not be called with rx_connHashTable_lock held.
876  */
877 void
878 rxi_CleanupConnection(struct rx_connection *conn)
879 {
880     /* Notify the service exporter, if requested, that this connection
881      * is being destroyed */
882     if (conn->type == RX_SERVER_CONNECTION && conn->service->destroyConnProc)
883         (*conn->service->destroyConnProc) (conn);
884
885     /* Notify the security module that this connection is being destroyed */
886     RXS_DestroyConnection(conn->securityObject, conn);
887
888     /* If this is the last connection using the rx_peer struct, set its
889      * idle time to now. rxi_ReapConnections will reap it if it's still
890      * idle (refCount == 0) after rx_idlePeerTime (60 seconds) have passed.
891      */
892     MUTEX_ENTER(&rx_peerHashTable_lock);
893     if (conn->peer->refCount < 2) {
894         conn->peer->idleWhen = clock_Sec();
895         if (conn->peer->refCount < 1) {
896             conn->peer->refCount = 1;
897             MUTEX_ENTER(&rx_stats_mutex);
898             rxi_lowPeerRefCount++;
899             MUTEX_EXIT(&rx_stats_mutex);
900         }
901     }
902     conn->peer->refCount--;
903     MUTEX_EXIT(&rx_peerHashTable_lock);
904
905     if (conn->type == RX_SERVER_CONNECTION)
906         rx_MutexDecrement(rx_stats.nServerConns, rx_stats_mutex);
907     else
908         rx_MutexDecrement(rx_stats.nClientConns, rx_stats_mutex);
909 #ifndef KERNEL
910     if (conn->specific) {
911         int i;
912         for (i = 0; i < conn->nSpecific; i++) {
913             if (conn->specific[i] && rxi_keyCreate_destructor[i])
914                 (*rxi_keyCreate_destructor[i]) (conn->specific[i]);
915             conn->specific[i] = NULL;
916         }
917         free(conn->specific);
918     }
919     conn->specific = NULL;
920     conn->nSpecific = 0;
921 #endif /* !KERNEL */
922
923     MUTEX_DESTROY(&conn->conn_call_lock);
924     MUTEX_DESTROY(&conn->conn_data_lock);
925     CV_DESTROY(&conn->conn_call_cv);
926
927     rxi_FreeConnection(conn);
928 }
929
930 /* Destroy the specified connection */
931 void
932 rxi_DestroyConnection(register struct rx_connection *conn)
933 {
934   register struct rx_connection *tconn, *dtconn;
935
936   MUTEX_ENTER(&rx_connHashTable_lock);
937   
938   if(!(conn->flags & RX_CLONED_CONNECTION)) {
939         tconn = conn->next_clone;
940         conn->next_clone = 0; /* once */
941         do {
942           if(tconn) {
943                 dtconn = tconn;
944                 tconn = tconn->next_clone;
945                 rxi_DestroyConnectionNoLock(dtconn);
946                 /* destroyed? */
947                 if (dtconn == rx_connCleanup_list) {
948                   rx_connCleanup_list = rx_connCleanup_list->next;
949                   MUTEX_EXIT(&rx_connHashTable_lock);
950                   /* rxi_CleanupConnection will free tconn */   
951                   rxi_CleanupConnection(dtconn);
952                   MUTEX_ENTER(&rx_connHashTable_lock);
953                   (conn->nclones)--;
954                 }
955           }
956         } while(tconn);
957   }
958
959   rxi_DestroyConnectionNoLock(conn);
960   /* conn should be at the head of the cleanup list */
961   if (conn == rx_connCleanup_list) {
962         rx_connCleanup_list = rx_connCleanup_list->next;
963         MUTEX_EXIT(&rx_connHashTable_lock);
964         rxi_CleanupConnection(conn);
965   }
966 #ifdef RX_ENABLE_LOCKS
967   else {
968         MUTEX_EXIT(&rx_connHashTable_lock);
969   }
970 #endif /* RX_ENABLE_LOCKS */
971 }
972
973 static void
974 rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
975 {
976     register struct rx_connection **conn_ptr;
977     register int havecalls = 0;
978     struct rx_packet *packet;
979     int i;
980     SPLVAR;
981
982     clock_NewTime();
983
984     NETPRI;
985     MUTEX_ENTER(&conn->conn_data_lock);
986     if (conn->refCount > 0)
987         conn->refCount--;
988     else {
989         MUTEX_ENTER(&rx_stats_mutex);
990         rxi_lowConnRefCount++;
991         MUTEX_EXIT(&rx_stats_mutex);
992     }
993
994     if ((conn->refCount > 0) || (conn->flags & RX_CONN_BUSY)) {
995         /* Busy; wait till the last guy before proceeding */
996         MUTEX_EXIT(&conn->conn_data_lock);
997         USERPRI;
998         return;
999     }
1000
1001     /* If the client previously called rx_NewCall, but it is still
1002      * waiting, treat this as a running call, and wait to destroy the
1003      * connection later when the call completes. */
1004     if ((conn->type == RX_CLIENT_CONNECTION)
1005         && (conn->flags & RX_CONN_MAKECALL_WAITING)) {
1006         conn->flags |= RX_CONN_DESTROY_ME;
1007         MUTEX_EXIT(&conn->conn_data_lock);
1008         USERPRI;
1009         return;
1010     }
1011     MUTEX_EXIT(&conn->conn_data_lock);
1012
1013     /* Check for extant references to this connection */
1014     for (i = 0; i < RX_MAXCALLS; i++) {
1015         register struct rx_call *call = conn->call[i];
1016         if (call) {
1017             havecalls = 1;
1018             if (conn->type == RX_CLIENT_CONNECTION) {
1019                 MUTEX_ENTER(&call->lock);
1020                 if (call->delayedAckEvent) {
1021                     /* Push the final acknowledgment out now--there
1022                      * won't be a subsequent call to acknowledge the
1023                      * last reply packets */
1024                     rxevent_Cancel(call->delayedAckEvent, call,
1025                                    RX_CALL_REFCOUNT_DELAY);
1026                     if (call->state == RX_STATE_PRECALL
1027                         || call->state == RX_STATE_ACTIVE) {
1028                         rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
1029                     } else {
1030                         rxi_AckAll(NULL, call, 0);
1031                     }
1032                 }
1033                 MUTEX_EXIT(&call->lock);
1034             }
1035         }
1036     }
1037 #ifdef RX_ENABLE_LOCKS
1038     if (!havecalls) {
1039         if (MUTEX_TRYENTER(&conn->conn_data_lock)) {
1040             MUTEX_EXIT(&conn->conn_data_lock);
1041         } else {
1042             /* Someone is accessing a packet right now. */
1043             havecalls = 1;
1044         }
1045     }
1046 #endif /* RX_ENABLE_LOCKS */
1047
1048     if (havecalls) {
1049         /* Don't destroy the connection if there are any call
1050          * structures still in use */
1051         MUTEX_ENTER(&conn->conn_data_lock);
1052         conn->flags |= RX_CONN_DESTROY_ME;
1053         MUTEX_EXIT(&conn->conn_data_lock);
1054         USERPRI;
1055         return;
1056     }
1057
1058     if (conn->delayedAbortEvent) {
1059         rxevent_Cancel(conn->delayedAbortEvent, (struct rx_call *)0, 0);
1060         packet = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
1061         if (packet) {
1062             MUTEX_ENTER(&conn->conn_data_lock);
1063             rxi_SendConnectionAbort(conn, packet, 0, 1);
1064             MUTEX_EXIT(&conn->conn_data_lock);
1065             rxi_FreePacket(packet);
1066         }
1067     }
1068
1069     /* Remove from connection hash table before proceeding */
1070     conn_ptr =
1071         &rx_connHashTable[CONN_HASH
1072                           (peer->host, peer->port, conn->cid, conn->epoch,
1073                            conn->type)];
1074     for (; *conn_ptr; conn_ptr = &(*conn_ptr)->next) {
1075         if (*conn_ptr == conn) {
1076             *conn_ptr = conn->next;
1077             break;
1078         }
1079     }
1080     /* if the conn that we are destroying was the last connection, then we
1081      * clear rxLastConn as well */
1082     if (rxLastConn == conn)
1083         rxLastConn = 0;
1084
1085     /* Make sure the connection is completely reset before deleting it. */
1086     /* get rid of pending events that could zap us later */
1087     if (conn->challengeEvent)
1088         rxevent_Cancel(conn->challengeEvent, (struct rx_call *)0, 0);
1089     if (conn->checkReachEvent)
1090         rxevent_Cancel(conn->checkReachEvent, (struct rx_call *)0, 0);
1091
1092     /* Add the connection to the list of destroyed connections that
1093      * need to be cleaned up. This is necessary to avoid deadlocks
1094      * in the routines we call to inform others that this connection is
1095      * being destroyed. */
1096     conn->next = rx_connCleanup_list;
1097     rx_connCleanup_list = conn;
1098 }
1099
1100 /* Externally available version */
1101 void
1102 rx_DestroyConnection(register struct rx_connection *conn)
1103 {
1104     SPLVAR;
1105
1106     NETPRI;
1107     rxi_DestroyConnection(conn);
1108     USERPRI;
1109 }
1110
1111 void
1112 rx_GetConnection(register struct rx_connection *conn)
1113 {
1114     SPLVAR;
1115
1116     NETPRI;
1117     MUTEX_ENTER(&conn->conn_data_lock);
1118     conn->refCount++;
1119     MUTEX_EXIT(&conn->conn_data_lock);
1120     USERPRI;
1121 }
1122
1123 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1124 /* Wait for the transmit queue to no longer be busy. 
1125  * requires the call->lock to be held */
1126 static void rxi_WaitforTQBusy(struct rx_call *call) {
1127     while (call->flags & RX_CALL_TQ_BUSY) {
1128         call->flags |= RX_CALL_TQ_WAIT;
1129         call->tqWaiters++;
1130 #ifdef RX_ENABLE_LOCKS
1131         osirx_AssertMine(&call->lock, "rxi_WaitforTQ lock");
1132         CV_WAIT(&call->cv_tq, &call->lock);
1133 #else /* RX_ENABLE_LOCKS */
1134         osi_rxSleep(&call->tq);
1135 #endif /* RX_ENABLE_LOCKS */
1136         call->tqWaiters--;
1137         if (call->tqWaiters == 0) {
1138             call->flags &= ~RX_CALL_TQ_WAIT;
1139         }
1140     }
1141 }
1142 #endif
1143
1144 /* Start a new rx remote procedure call, on the specified connection.
1145  * If wait is set to 1, wait for a free call channel; otherwise return
1146  * 0.  Maxtime gives the maximum number of seconds this call may take,
1147  * after rx_NewCall returns.  After this time interval, a call to any
1148  * of rx_SendData, rx_ReadData, etc. will fail with RX_CALL_TIMEOUT.
1149  * For fine grain locking, we hold the conn_call_lock in order to 
1150  * to ensure that we don't get signalle after we found a call in an active
1151  * state and before we go to sleep.
1152  */
1153 struct rx_call *
1154 rx_NewCall(register struct rx_connection *conn)
1155 {
1156     register int i;
1157     register struct rx_call *call;
1158         register struct rx_connection *tconn;
1159     struct clock queueTime;
1160     SPLVAR;
1161
1162     clock_NewTime();
1163     dpf(("rx_NewCall(conn %x)\n", conn));
1164
1165     NETPRI;
1166     clock_GetTime(&queueTime);
1167     MUTEX_ENTER(&conn->conn_call_lock);
1168
1169     /*
1170      * Check if there are others waiting for a new call.
1171      * If so, let them go first to avoid starving them.
1172      * This is a fairly simple scheme, and might not be
1173      * a complete solution for large numbers of waiters.
1174      * 
1175      * makeCallWaiters keeps track of the number of 
1176      * threads waiting to make calls and the 
1177      * RX_CONN_MAKECALL_WAITING flag bit is used to 
1178      * indicate that there are indeed calls waiting.
1179      * The flag is set when the waiter is incremented.
1180      * It is only cleared in rx_EndCall when 
1181      * makeCallWaiters is 0.  This prevents us from 
1182      * accidently destroying the connection while it
1183      * is potentially about to be used.
1184      */
1185     MUTEX_ENTER(&conn->conn_data_lock);
1186     if (conn->makeCallWaiters) {
1187         conn->flags |= RX_CONN_MAKECALL_WAITING;
1188         conn->makeCallWaiters++;
1189         MUTEX_EXIT(&conn->conn_data_lock);
1190
1191 #ifdef  RX_ENABLE_LOCKS
1192         CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
1193 #else
1194         osi_rxSleep(conn);
1195 #endif
1196         MUTEX_ENTER(&conn->conn_data_lock);
1197         conn->makeCallWaiters--;
1198     } 
1199     MUTEX_EXIT(&conn->conn_data_lock);
1200
1201         /* search for next free call on this connection or 
1202          * its clones, if any */
1203     for (;;) {
1204                 tconn = conn;
1205                 do {
1206                         for (i = 0; i < RX_MAXCALLS; i++) {
1207                                 call = tconn->call[i];
1208                                 if (call) {
1209                                         MUTEX_ENTER(&call->lock);
1210                                         if (call->state == RX_STATE_DALLY) {
1211                                                 rxi_ResetCall(call, 0);
1212                                                 (*call->callNumber)++;
1213                                                 goto f_call;
1214                                         }
1215                                         MUTEX_EXIT(&call->lock);
1216                                 } else {
1217                                         call = rxi_NewCall(tconn, i);
1218                                         goto f_call;
1219                                 }
1220                         } /* for i < RX_MAXCALLS */
1221                 } while (tconn->next_clone && (tconn = tconn->next_clone));
1222
1223         f_call:
1224
1225                 if (i < RX_MAXCALLS) {
1226                         break;
1227                 }
1228
1229                 /* to be here, all available calls for this connection (and all
1230                  * its clones) must be in use */
1231
1232                 MUTEX_ENTER(&conn->conn_data_lock);
1233                 conn->flags |= RX_CONN_MAKECALL_WAITING;
1234                 conn->makeCallWaiters++;
1235                 MUTEX_EXIT(&conn->conn_data_lock);
1236
1237 #ifdef  RX_ENABLE_LOCKS
1238                 CV_WAIT(&conn->conn_call_cv, &conn->conn_call_lock);
1239 #else
1240                 osi_rxSleep(conn);
1241 #endif
1242                 MUTEX_ENTER(&conn->conn_data_lock);
1243                 conn->makeCallWaiters--;
1244                 MUTEX_EXIT(&conn->conn_data_lock);
1245     } /* for ;; */
1246     /*
1247      * Wake up anyone else who might be giving us a chance to
1248      * run (see code above that avoids resource starvation).
1249      */
1250 #ifdef  RX_ENABLE_LOCKS
1251     CV_BROADCAST(&conn->conn_call_cv);
1252 #else
1253     osi_rxWakeup(conn);
1254 #endif
1255
1256     CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
1257
1258     /* Client is initially in send mode */
1259     call->state = RX_STATE_ACTIVE;
1260     call->error = conn->error;
1261     if (call->error)
1262         call->mode = RX_MODE_ERROR;
1263     else
1264         call->mode = RX_MODE_SENDING;
1265     
1266     /* remember start time for call in case we have hard dead time limit */
1267     call->queueTime = queueTime;
1268     clock_GetTime(&call->startTime);
1269     hzero(call->bytesSent);
1270     hzero(call->bytesRcvd);
1271
1272     /* Turn on busy protocol. */
1273     rxi_KeepAliveOn(call);
1274
1275     MUTEX_EXIT(&call->lock);
1276     MUTEX_EXIT(&conn->conn_call_lock);
1277     USERPRI;
1278
1279 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1280     /* Now, if TQ wasn't cleared earlier, do it now. */
1281     MUTEX_ENTER(&call->lock);
1282     rxi_WaitforTQBusy(call);
1283     if (call->flags & RX_CALL_TQ_CLEARME) {
1284         rxi_ClearTransmitQueue(call, 1);
1285         queue_Init(&call->tq);
1286     }
1287     MUTEX_EXIT(&call->lock);
1288 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1289
1290     dpf(("rx_NewCall(call %x)\n", call));
1291     return call;
1292 }
1293
1294 int
1295 rxi_HasActiveCalls(register struct rx_connection *aconn)
1296 {
1297     register int i;
1298     register struct rx_call *tcall;
1299     SPLVAR;
1300
1301     NETPRI;
1302     for (i = 0; i < RX_MAXCALLS; i++) {
1303         if ((tcall = aconn->call[i])) {
1304             if ((tcall->state == RX_STATE_ACTIVE)
1305                 || (tcall->state == RX_STATE_PRECALL)) {
1306                 USERPRI;
1307                 return 1;
1308             }
1309         }
1310     }
1311     USERPRI;
1312     return 0;
1313 }
1314
1315 int
1316 rxi_GetCallNumberVector(register struct rx_connection *aconn,
1317                         register afs_int32 * aint32s)
1318 {
1319     register int i;
1320     register struct rx_call *tcall;
1321     SPLVAR;
1322
1323     NETPRI;
1324     for (i = 0; i < RX_MAXCALLS; i++) {
1325         if ((tcall = aconn->call[i]) && (tcall->state == RX_STATE_DALLY))
1326             aint32s[i] = aconn->callNumber[i] + 1;
1327         else
1328             aint32s[i] = aconn->callNumber[i];
1329     }
1330     USERPRI;
1331     return 0;
1332 }
1333
1334 int
1335 rxi_SetCallNumberVector(register struct rx_connection *aconn,
1336                         register afs_int32 * aint32s)
1337 {
1338     register int i;
1339     register struct rx_call *tcall;
1340     SPLVAR;
1341
1342     NETPRI;
1343     for (i = 0; i < RX_MAXCALLS; i++) {
1344         if ((tcall = aconn->call[i]) && (tcall->state == RX_STATE_DALLY))
1345             aconn->callNumber[i] = aint32s[i] - 1;
1346         else
1347             aconn->callNumber[i] = aint32s[i];
1348     }
1349     USERPRI;
1350     return 0;
1351 }
1352
1353 /* Advertise a new service.  A service is named locally by a UDP port
1354  * number plus a 16-bit service id.  Returns (struct rx_service *) 0
1355  * on a failure. 
1356  *
1357      char *serviceName;  Name for identification purposes (e.g. the
1358                          service name might be used for probing for
1359                          statistics) */
1360 struct rx_service *
1361 rx_NewServiceHost(afs_uint32 host, u_short port, u_short serviceId, 
1362                   char *serviceName, struct rx_securityClass **securityObjects,
1363                   int nSecurityObjects, 
1364                   afs_int32(*serviceProc) (struct rx_call * acall))
1365 {
1366     osi_socket socket = OSI_NULLSOCKET;
1367     register struct rx_service *tservice;
1368     register int i;
1369     SPLVAR;
1370
1371     clock_NewTime();
1372
1373     if (serviceId == 0) {
1374         (osi_Msg
1375          "rx_NewService:  service id for service %s is not non-zero.\n",
1376          serviceName);
1377         return 0;
1378     }
1379     if (port == 0) {
1380         if (rx_port == 0) {
1381             (osi_Msg
1382              "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",
1383              serviceName);
1384             return 0;
1385         }
1386         port = rx_port;
1387         socket = rx_socket;
1388     }
1389
1390     tservice = rxi_AllocService();
1391     NETPRI;
1392     for (i = 0; i < RX_MAX_SERVICES; i++) {
1393         register struct rx_service *service = rx_services[i];
1394         if (service) {
1395             if (port == service->servicePort && host == service->serviceHost) {
1396                 if (service->serviceId == serviceId) {
1397                     /* The identical service has already been
1398                      * installed; if the caller was intending to
1399                      * change the security classes used by this
1400                      * service, he/she loses. */
1401                     (osi_Msg
1402                      "rx_NewService: tried to install service %s with service id %d, which is already in use for service %s\n",
1403                      serviceName, serviceId, service->serviceName);
1404                     USERPRI;
1405                     rxi_FreeService(tservice);
1406                     return service;
1407                 }
1408                 /* Different service, same port: re-use the socket
1409                  * which is bound to the same port */
1410                 socket = service->socket;
1411             }
1412         } else {
1413             if (socket == OSI_NULLSOCKET) {
1414                 /* If we don't already have a socket (from another
1415                  * service on same port) get a new one */
1416                 socket = rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
1417                 if (socket == OSI_NULLSOCKET) {
1418                     USERPRI;
1419                     rxi_FreeService(tservice);
1420                     return 0;
1421                 }
1422             }
1423             service = tservice;
1424             service->socket = socket;
1425             service->serviceHost = host;
1426             service->servicePort = port;
1427             service->serviceId = serviceId;
1428             service->serviceName = serviceName;
1429             service->nSecurityObjects = nSecurityObjects;
1430             service->securityObjects = securityObjects;
1431             service->minProcs = 0;
1432             service->maxProcs = 1;
1433             service->idleDeadTime = 60;
1434             service->idleDeadErr = 0;
1435             service->connDeadTime = rx_connDeadTime;
1436             service->executeRequestProc = serviceProc;
1437             service->checkReach = 0;
1438             rx_services[i] = service;   /* not visible until now */
1439             USERPRI;
1440             return service;
1441         }
1442     }
1443     USERPRI;
1444     rxi_FreeService(tservice);
1445     (osi_Msg "rx_NewService: cannot support > %d services\n",
1446      RX_MAX_SERVICES);
1447     return 0;
1448 }
1449
1450 /* Set configuration options for all of a service's security objects */
1451
1452 afs_int32 
1453 rx_SetSecurityConfiguration(struct rx_service *service, 
1454                             rx_securityConfigVariables type,
1455                             void *value)
1456 {
1457     int i;
1458     for (i = 0; i<service->nSecurityObjects; i++) {
1459         if (service->securityObjects[i]) {
1460             RXS_SetConfiguration(service->securityObjects[i], NULL, type, 
1461                                  value, NULL);
1462         }
1463     }
1464     return 0;
1465 }
1466
1467 struct rx_service *
1468 rx_NewService(u_short port, u_short serviceId, char *serviceName,
1469               struct rx_securityClass **securityObjects, int nSecurityObjects,
1470               afs_int32(*serviceProc) (struct rx_call * acall))
1471 {
1472     return rx_NewServiceHost(htonl(INADDR_ANY), port, serviceId, serviceName, securityObjects, nSecurityObjects, serviceProc);
1473 }
1474
1475 /* Generic request processing loop. This routine should be called
1476  * by the implementation dependent rx_ServerProc. If socketp is
1477  * non-null, it will be set to the file descriptor that this thread
1478  * is now listening on. If socketp is null, this routine will never
1479  * returns. */
1480 void
1481 rxi_ServerProc(int threadID, struct rx_call *newcall, osi_socket * socketp)
1482 {
1483     register struct rx_call *call;
1484     register afs_int32 code;
1485     register struct rx_service *tservice = NULL;
1486
1487     for (;;) {
1488         if (newcall) {
1489             call = newcall;
1490             newcall = NULL;
1491         } else {
1492             call = rx_GetCall(threadID, tservice, socketp);
1493             if (socketp && *socketp != OSI_NULLSOCKET) {
1494                 /* We are now a listener thread */
1495                 return;
1496             }
1497         }
1498
1499         /* if server is restarting( typically smooth shutdown) then do not
1500          * allow any new calls.
1501          */
1502
1503         if (rx_tranquil && (call != NULL)) {
1504             SPLVAR;
1505
1506             NETPRI;
1507             MUTEX_ENTER(&call->lock);
1508
1509             rxi_CallError(call, RX_RESTARTING);
1510             rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
1511
1512             MUTEX_EXIT(&call->lock);
1513             USERPRI;
1514         }
1515 #ifdef  KERNEL
1516         if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1517 #ifdef RX_ENABLE_LOCKS
1518             AFS_GLOCK();
1519 #endif /* RX_ENABLE_LOCKS */
1520             afs_termState = AFSOP_STOP_AFS;
1521             afs_osi_Wakeup(&afs_termState);
1522 #ifdef RX_ENABLE_LOCKS
1523             AFS_GUNLOCK();
1524 #endif /* RX_ENABLE_LOCKS */
1525             return;
1526         }
1527 #endif
1528
1529         tservice = call->conn->service;
1530
1531         if (tservice->beforeProc)
1532             (*tservice->beforeProc) (call);
1533
1534         code = call->conn->service->executeRequestProc(call);
1535
1536         if (tservice->afterProc)
1537             (*tservice->afterProc) (call, code);
1538
1539         rx_EndCall(call, code);
1540         MUTEX_ENTER(&rx_stats_mutex);
1541         rxi_nCalls++;
1542         MUTEX_EXIT(&rx_stats_mutex);
1543     }
1544 }
1545
1546
1547 void
1548 rx_WakeupServerProcs(void)
1549 {
1550     struct rx_serverQueueEntry *np, *tqp;
1551     SPLVAR;
1552
1553     NETPRI;
1554     MUTEX_ENTER(&rx_serverPool_lock);
1555
1556 #ifdef RX_ENABLE_LOCKS
1557     if (rx_waitForPacket)
1558         CV_BROADCAST(&rx_waitForPacket->cv);
1559 #else /* RX_ENABLE_LOCKS */
1560     if (rx_waitForPacket)
1561         osi_rxWakeup(rx_waitForPacket);
1562 #endif /* RX_ENABLE_LOCKS */
1563     MUTEX_ENTER(&freeSQEList_lock);
1564     for (np = rx_FreeSQEList; np; np = tqp) {
1565         tqp = *(struct rx_serverQueueEntry **)np;
1566 #ifdef RX_ENABLE_LOCKS
1567         CV_BROADCAST(&np->cv);
1568 #else /* RX_ENABLE_LOCKS */
1569         osi_rxWakeup(np);
1570 #endif /* RX_ENABLE_LOCKS */
1571     }
1572     MUTEX_EXIT(&freeSQEList_lock);
1573     for (queue_Scan(&rx_idleServerQueue, np, tqp, rx_serverQueueEntry)) {
1574 #ifdef RX_ENABLE_LOCKS
1575         CV_BROADCAST(&np->cv);
1576 #else /* RX_ENABLE_LOCKS */
1577         osi_rxWakeup(np);
1578 #endif /* RX_ENABLE_LOCKS */
1579     }
1580     MUTEX_EXIT(&rx_serverPool_lock);
1581     USERPRI;
1582 }
1583
1584 /* meltdown:
1585  * One thing that seems to happen is that all the server threads get
1586  * tied up on some empty or slow call, and then a whole bunch of calls
1587  * arrive at once, using up the packet pool, so now there are more 
1588  * empty calls.  The most critical resources here are server threads
1589  * and the free packet pool.  The "doreclaim" code seems to help in
1590  * general.  I think that eventually we arrive in this state: there
1591  * are lots of pending calls which do have all their packets present,
1592  * so they won't be reclaimed, are multi-packet calls, so they won't
1593  * be scheduled until later, and thus are tying up most of the free 
1594  * packet pool for a very long time.
1595  * future options:
1596  * 1.  schedule multi-packet calls if all the packets are present.  
1597  * Probably CPU-bound operation, useful to return packets to pool. 
1598  * Do what if there is a full window, but the last packet isn't here?
1599  * 3.  preserve one thread which *only* runs "best" calls, otherwise
1600  * it sleeps and waits for that type of call.
1601  * 4.  Don't necessarily reserve a whole window for each thread.  In fact, 
1602  * the current dataquota business is badly broken.  The quota isn't adjusted
1603  * to reflect how many packets are presently queued for a running call.
1604  * So, when we schedule a queued call with a full window of packets queued
1605  * up for it, that *should* free up a window full of packets for other 2d-class
1606  * calls to be able to use from the packet pool.  But it doesn't.
1607  *
1608  * NB.  Most of the time, this code doesn't run -- since idle server threads
1609  * sit on the idle server queue and are assigned by "...ReceivePacket" as soon
1610  * as a new call arrives.
1611  */
1612 /* Sleep until a call arrives.  Returns a pointer to the call, ready
1613  * for an rx_Read. */
1614 #ifdef RX_ENABLE_LOCKS
1615 struct rx_call *
1616 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
1617 {
1618     struct rx_serverQueueEntry *sq;
1619     register struct rx_call *call = (struct rx_call *)0;
1620     struct rx_service *service = NULL;
1621     SPLVAR;
1622
1623     MUTEX_ENTER(&freeSQEList_lock);
1624
1625     if ((sq = rx_FreeSQEList)) {
1626         rx_FreeSQEList = *(struct rx_serverQueueEntry **)sq;
1627         MUTEX_EXIT(&freeSQEList_lock);
1628     } else {                    /* otherwise allocate a new one and return that */
1629         MUTEX_EXIT(&freeSQEList_lock);
1630         sq = (struct rx_serverQueueEntry *)
1631             rxi_Alloc(sizeof(struct rx_serverQueueEntry));
1632         MUTEX_INIT(&sq->lock, "server Queue lock", MUTEX_DEFAULT, 0);
1633         CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
1634     }
1635
1636     MUTEX_ENTER(&rx_serverPool_lock);
1637     if (cur_service != NULL) {
1638         ReturnToServerPool(cur_service);
1639     }
1640     while (1) {
1641         if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
1642             register struct rx_call *tcall, *ncall, *choice2 = NULL;
1643
1644             /* Scan for eligible incoming calls.  A call is not eligible
1645              * if the maximum number of calls for its service type are
1646              * already executing */
1647             /* One thread will process calls FCFS (to prevent starvation),
1648              * while the other threads may run ahead looking for calls which
1649              * have all their input data available immediately.  This helps 
1650              * keep threads from blocking, waiting for data from the client. */
1651             for (queue_Scan(&rx_incomingCallQueue, tcall, ncall, rx_call)) {
1652                 service = tcall->conn->service;
1653                 if (!QuotaOK(service)) {
1654                     continue;
1655                 }
1656                 if (tno == rxi_fcfs_thread_num
1657                     || !tcall->queue_item_header.next) {
1658                     /* If we're the fcfs thread , then  we'll just use 
1659                      * this call. If we haven't been able to find an optimal 
1660                      * choice, and we're at the end of the list, then use a 
1661                      * 2d choice if one has been identified.  Otherwise... */
1662                     call = (choice2 ? choice2 : tcall);
1663                     service = call->conn->service;
1664                 } else if (!queue_IsEmpty(&tcall->rq)) {
1665                     struct rx_packet *rp;
1666                     rp = queue_First(&tcall->rq, rx_packet);
1667                     if (rp->header.seq == 1) {
1668                         if (!meltdown_1pkt
1669                             || (rp->header.flags & RX_LAST_PACKET)) {
1670                             call = tcall;
1671                         } else if (rxi_2dchoice && !choice2
1672                                    && !(tcall->flags & RX_CALL_CLEARED)
1673                                    && (tcall->rprev > rxi_HardAckRate)) {
1674                             choice2 = tcall;
1675                         } else
1676                             rxi_md2cnt++;
1677                     }
1678                 }
1679                 if (call) {
1680                     break;
1681                 } else {
1682                     ReturnToServerPool(service);
1683                 }
1684             }
1685         }
1686
1687         if (call) {
1688             queue_Remove(call);
1689             MUTEX_EXIT(&rx_serverPool_lock);
1690             MUTEX_ENTER(&call->lock);
1691
1692             if (call->flags & RX_CALL_WAIT_PROC) {
1693                 call->flags &= ~RX_CALL_WAIT_PROC;
1694                 MUTEX_ENTER(&rx_stats_mutex);
1695                 rx_nWaiting--;
1696                 MUTEX_EXIT(&rx_stats_mutex);
1697             }
1698
1699             if (call->state != RX_STATE_PRECALL || call->error) {
1700                 MUTEX_EXIT(&call->lock);
1701                 MUTEX_ENTER(&rx_serverPool_lock);
1702                 ReturnToServerPool(service);
1703                 call = NULL;
1704                 continue;
1705             }
1706
1707             if (queue_IsEmpty(&call->rq)
1708                 || queue_First(&call->rq, rx_packet)->header.seq != 1)
1709                 rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
1710
1711             CLEAR_CALL_QUEUE_LOCK(call);
1712             break;
1713         } else {
1714             /* If there are no eligible incoming calls, add this process
1715              * to the idle server queue, to wait for one */
1716             sq->newcall = 0;
1717             sq->tno = tno;
1718             if (socketp) {
1719                 *socketp = OSI_NULLSOCKET;
1720             }
1721             sq->socketp = socketp;
1722             queue_Append(&rx_idleServerQueue, sq);
1723 #ifndef AFS_AIX41_ENV
1724             rx_waitForPacket = sq;
1725 #else
1726             rx_waitingForPacket = sq;
1727 #endif /* AFS_AIX41_ENV */
1728             do {
1729                 CV_WAIT(&sq->cv, &rx_serverPool_lock);
1730 #ifdef  KERNEL
1731                 if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1732                     MUTEX_EXIT(&rx_serverPool_lock);
1733                     return (struct rx_call *)0;
1734                 }
1735 #endif
1736             } while (!(call = sq->newcall)
1737                      && !(socketp && *socketp != OSI_NULLSOCKET));
1738             MUTEX_EXIT(&rx_serverPool_lock);
1739             if (call) {
1740                 MUTEX_ENTER(&call->lock);
1741             }
1742             break;
1743         }
1744     }
1745
1746     MUTEX_ENTER(&freeSQEList_lock);
1747     *(struct rx_serverQueueEntry **)sq = rx_FreeSQEList;
1748     rx_FreeSQEList = sq;
1749     MUTEX_EXIT(&freeSQEList_lock);
1750
1751     if (call) {
1752         clock_GetTime(&call->startTime);
1753         call->state = RX_STATE_ACTIVE;
1754         call->mode = RX_MODE_RECEIVING;
1755 #ifdef RX_KERNEL_TRACE
1756         if (ICL_SETACTIVE(afs_iclSetp)) {
1757             int glockOwner = ISAFS_GLOCK();
1758             if (!glockOwner)
1759                 AFS_GLOCK();
1760             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
1761                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
1762                        call);
1763             if (!glockOwner)
1764                 AFS_GUNLOCK();
1765         }
1766 #endif
1767
1768         rxi_calltrace(RX_CALL_START, call);
1769         dpf(("rx_GetCall(port=%d, service=%d) ==> call %x\n",
1770              call->conn->service->servicePort, call->conn->service->serviceId,
1771              call));
1772
1773         CALL_HOLD(call, RX_CALL_REFCOUNT_BEGIN);
1774         MUTEX_EXIT(&call->lock);
1775     } else {
1776         dpf(("rx_GetCall(socketp=0x%x, *socketp=0x%x)\n", socketp, *socketp));
1777     }
1778
1779     return call;
1780 }
1781 #else /* RX_ENABLE_LOCKS */
1782 struct rx_call *
1783 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
1784 {
1785     struct rx_serverQueueEntry *sq;
1786     register struct rx_call *call = (struct rx_call *)0, *choice2;
1787     struct rx_service *service = NULL;
1788     SPLVAR;
1789
1790     NETPRI;
1791     MUTEX_ENTER(&freeSQEList_lock);
1792
1793     if ((sq = rx_FreeSQEList)) {
1794         rx_FreeSQEList = *(struct rx_serverQueueEntry **)sq;
1795         MUTEX_EXIT(&freeSQEList_lock);
1796     } else {                    /* otherwise allocate a new one and return that */
1797         MUTEX_EXIT(&freeSQEList_lock);
1798         sq = (struct rx_serverQueueEntry *)
1799             rxi_Alloc(sizeof(struct rx_serverQueueEntry));
1800         MUTEX_INIT(&sq->lock, "server Queue lock", MUTEX_DEFAULT, 0);
1801         CV_INIT(&sq->cv, "server Queue lock", CV_DEFAULT, 0);
1802     }
1803     MUTEX_ENTER(&sq->lock);
1804
1805     if (cur_service != NULL) {
1806         cur_service->nRequestsRunning--;
1807         if (cur_service->nRequestsRunning < cur_service->minProcs)
1808             rxi_minDeficit++;
1809         rxi_availProcs++;
1810     }
1811     if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
1812         register struct rx_call *tcall, *ncall;
1813         /* Scan for eligible incoming calls.  A call is not eligible
1814          * if the maximum number of calls for its service type are
1815          * already executing */
1816         /* One thread will process calls FCFS (to prevent starvation),
1817          * while the other threads may run ahead looking for calls which
1818          * have all their input data available immediately.  This helps 
1819          * keep threads from blocking, waiting for data from the client. */
1820         choice2 = (struct rx_call *)0;
1821         for (queue_Scan(&rx_incomingCallQueue, tcall, ncall, rx_call)) {
1822             service = tcall->conn->service;
1823             if (QuotaOK(service)) {
1824                 if (tno == rxi_fcfs_thread_num
1825                     || !tcall->queue_item_header.next) {
1826                     /* If we're the fcfs thread, then  we'll just use 
1827                      * this call. If we haven't been able to find an optimal 
1828                      * choice, and we're at the end of the list, then use a 
1829                      * 2d choice if one has been identified.  Otherwise... */
1830                     call = (choice2 ? choice2 : tcall);
1831                     service = call->conn->service;
1832                 } else if (!queue_IsEmpty(&tcall->rq)) {
1833                     struct rx_packet *rp;
1834                     rp = queue_First(&tcall->rq, rx_packet);
1835                     if (rp->header.seq == 1
1836                         && (!meltdown_1pkt
1837                             || (rp->header.flags & RX_LAST_PACKET))) {
1838                         call = tcall;
1839                     } else if (rxi_2dchoice && !choice2
1840                                && !(tcall->flags & RX_CALL_CLEARED)
1841                                && (tcall->rprev > rxi_HardAckRate)) {
1842                         choice2 = tcall;
1843                     } else
1844                         rxi_md2cnt++;
1845                 }
1846             }
1847             if (call)
1848                 break;
1849         }
1850     }
1851
1852     if (call) {
1853         queue_Remove(call);
1854         /* we can't schedule a call if there's no data!!! */
1855         /* send an ack if there's no data, if we're missing the
1856          * first packet, or we're missing something between first 
1857          * and last -- there's a "hole" in the incoming data. */
1858         if (queue_IsEmpty(&call->rq)
1859             || queue_First(&call->rq, rx_packet)->header.seq != 1
1860             || call->rprev != queue_Last(&call->rq, rx_packet)->header.seq)
1861             rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
1862
1863         call->flags &= (~RX_CALL_WAIT_PROC);
1864         service->nRequestsRunning++;
1865         /* just started call in minProcs pool, need fewer to maintain
1866          * guarantee */
1867         if (service->nRequestsRunning <= service->minProcs)
1868             rxi_minDeficit--;
1869         rxi_availProcs--;
1870         rx_nWaiting--;
1871         /* MUTEX_EXIT(&call->lock); */
1872     } else {
1873         /* If there are no eligible incoming calls, add this process
1874          * to the idle server queue, to wait for one */
1875         sq->newcall = 0;
1876         if (socketp) {
1877             *socketp = OSI_NULLSOCKET;
1878         }
1879         sq->socketp = socketp;
1880         queue_Append(&rx_idleServerQueue, sq);
1881         do {
1882             osi_rxSleep(sq);
1883 #ifdef  KERNEL
1884             if (afs_termState == AFSOP_STOP_RXCALLBACK) {
1885                 USERPRI;
1886                 rxi_Free(sq, sizeof(struct rx_serverQueueEntry));
1887                 return (struct rx_call *)0;
1888             }
1889 #endif
1890         } while (!(call = sq->newcall)
1891                  && !(socketp && *socketp != OSI_NULLSOCKET));
1892     }
1893     MUTEX_EXIT(&sq->lock);
1894
1895     MUTEX_ENTER(&freeSQEList_lock);
1896     *(struct rx_serverQueueEntry **)sq = rx_FreeSQEList;
1897     rx_FreeSQEList = sq;
1898     MUTEX_EXIT(&freeSQEList_lock);
1899
1900     if (call) {
1901         clock_GetTime(&call->startTime);
1902         call->state = RX_STATE_ACTIVE;
1903         call->mode = RX_MODE_RECEIVING;
1904 #ifdef RX_KERNEL_TRACE
1905         if (ICL_SETACTIVE(afs_iclSetp)) {
1906             int glockOwner = ISAFS_GLOCK();
1907             if (!glockOwner)
1908                 AFS_GLOCK();
1909             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
1910                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
1911                        call);
1912             if (!glockOwner)
1913                 AFS_GUNLOCK();
1914         }
1915 #endif
1916
1917         rxi_calltrace(RX_CALL_START, call);
1918         dpf(("rx_GetCall(port=%d, service=%d) ==> call %x\n",
1919              call->conn->service->servicePort, call->conn->service->serviceId,
1920              call));
1921     } else {
1922         dpf(("rx_GetCall(socketp=0x%x, *socketp=0x%x)\n", socketp, *socketp));
1923     }
1924
1925     USERPRI;
1926
1927     return call;
1928 }
1929 #endif /* RX_ENABLE_LOCKS */
1930
1931
1932
1933 /* Establish a procedure to be called when a packet arrives for a
1934  * call.  This routine will be called at most once after each call,
1935  * and will also be called if there is an error condition on the or
1936  * the call is complete.  Used by multi rx to build a selection
1937  * function which determines which of several calls is likely to be a
1938  * good one to read from.  
1939  * NOTE: the way this is currently implemented it is probably only a
1940  * good idea to (1) use it immediately after a newcall (clients only)
1941  * and (2) only use it once.  Other uses currently void your warranty
1942  */
1943 void
1944 rx_SetArrivalProc(register struct rx_call *call,
1945                   register void (*proc) (register struct rx_call * call,
1946                                         register void * mh,
1947                                         register int index),
1948                   register void * handle, register int arg)
1949 {
1950     call->arrivalProc = proc;
1951     call->arrivalProcHandle = handle;
1952     call->arrivalProcArg = arg;
1953 }
1954
1955 /* Call is finished (possibly prematurely).  Return rc to the peer, if
1956  * appropriate, and return the final error code from the conversation
1957  * to the caller */
1958
1959 afs_int32
1960 rx_EndCall(register struct rx_call *call, afs_int32 rc)
1961 {
1962     register struct rx_connection *conn = call->conn;
1963     register struct rx_service *service;
1964     afs_int32 error;
1965     SPLVAR;
1966
1967
1968
1969     dpf(("rx_EndCall(call %x rc %d error %d abortCode %d)\n", call, rc, call->error, call->abortCode));
1970
1971     NETPRI;
1972     MUTEX_ENTER(&call->lock);
1973
1974     if (rc == 0 && call->error == 0) {
1975         call->abortCode = 0;
1976         call->abortCount = 0;
1977     }
1978
1979     call->arrivalProc = (void (*)())0;
1980     if (rc && call->error == 0) {
1981         rxi_CallError(call, rc);
1982         /* Send an abort message to the peer if this error code has
1983          * only just been set.  If it was set previously, assume the
1984          * peer has already been sent the error code or will request it 
1985          */
1986         rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
1987     }
1988     if (conn->type == RX_SERVER_CONNECTION) {
1989         /* Make sure reply or at least dummy reply is sent */
1990         if (call->mode == RX_MODE_RECEIVING) {
1991             rxi_WriteProc(call, 0, 0);
1992         }
1993         if (call->mode == RX_MODE_SENDING) {
1994             rxi_FlushWrite(call);
1995         }
1996         service = conn->service;
1997         rxi_calltrace(RX_CALL_END, call);
1998         /* Call goes to hold state until reply packets are acknowledged */
1999         if (call->tfirst + call->nSoftAcked < call->tnext) {
2000             call->state = RX_STATE_HOLD;
2001         } else {
2002             call->state = RX_STATE_DALLY;
2003             rxi_ClearTransmitQueue(call, 0);
2004             rxevent_Cancel(call->resendEvent, call, RX_CALL_REFCOUNT_RESEND);
2005             rxevent_Cancel(call->keepAliveEvent, call,
2006                            RX_CALL_REFCOUNT_ALIVE);
2007         }
2008     } else {                    /* Client connection */
2009         char dummy;
2010         /* Make sure server receives input packets, in the case where
2011          * no reply arguments are expected */
2012         if ((call->mode == RX_MODE_SENDING)
2013             || (call->mode == RX_MODE_RECEIVING && call->rnext == 1)) {
2014             (void)rxi_ReadProc(call, &dummy, 1);
2015         }
2016
2017         /* If we had an outstanding delayed ack, be nice to the server
2018          * and force-send it now.
2019          */
2020         if (call->delayedAckEvent) {
2021             rxevent_Cancel(call->delayedAckEvent, call,
2022                            RX_CALL_REFCOUNT_DELAY);
2023             call->delayedAckEvent = NULL;
2024             rxi_SendDelayedAck(NULL, call, NULL);
2025         }
2026
2027         /* We need to release the call lock since it's lower than the
2028          * conn_call_lock and we don't want to hold the conn_call_lock
2029          * over the rx_ReadProc call. The conn_call_lock needs to be held
2030          * here for the case where rx_NewCall is perusing the calls on
2031          * the connection structure. We don't want to signal until
2032          * rx_NewCall is in a stable state. Otherwise, rx_NewCall may
2033          * have checked this call, found it active and by the time it
2034          * goes to sleep, will have missed the signal.
2035          *
2036          * Do not clear the RX_CONN_MAKECALL_WAITING flag as long as
2037          * there are threads waiting to use the conn object.
2038          */
2039         MUTEX_EXIT(&call->lock);
2040         MUTEX_ENTER(&conn->conn_call_lock);
2041         MUTEX_ENTER(&call->lock);
2042         MUTEX_ENTER(&conn->conn_data_lock);
2043         conn->flags |= RX_CONN_BUSY;
2044         if (conn->flags & RX_CONN_MAKECALL_WAITING) {
2045             if (conn->makeCallWaiters == 0)
2046                 conn->flags &= (~RX_CONN_MAKECALL_WAITING);
2047             MUTEX_EXIT(&conn->conn_data_lock);
2048 #ifdef  RX_ENABLE_LOCKS
2049             CV_BROADCAST(&conn->conn_call_cv);
2050 #else
2051             osi_rxWakeup(conn);
2052 #endif
2053         }
2054 #ifdef RX_ENABLE_LOCKS
2055         else {
2056             MUTEX_EXIT(&conn->conn_data_lock);
2057         }
2058 #endif /* RX_ENABLE_LOCKS */
2059         call->state = RX_STATE_DALLY;
2060     }
2061     error = call->error;
2062
2063     /* currentPacket, nLeft, and NFree must be zeroed here, because
2064      * ResetCall cannot: ResetCall may be called at splnet(), in the
2065      * kernel version, and may interrupt the macros rx_Read or
2066      * rx_Write, which run at normal priority for efficiency. */
2067     if (call->currentPacket) {
2068         call->currentPacket->flags &= ~RX_PKTFLAG_CP;
2069         rxi_FreePacket(call->currentPacket);
2070         call->currentPacket = (struct rx_packet *)0;
2071     }
2072         
2073     call->nLeft = call->nFree = call->curlen = 0;
2074
2075     /* Free any packets from the last call to ReadvProc/WritevProc */
2076     rxi_FreePackets(0, &call->iovq);
2077
2078     CALL_RELE(call, RX_CALL_REFCOUNT_BEGIN);
2079     MUTEX_EXIT(&call->lock);
2080     if (conn->type == RX_CLIENT_CONNECTION) {
2081         MUTEX_EXIT(&conn->conn_call_lock);
2082         conn->flags &= ~RX_CONN_BUSY;
2083     }
2084     USERPRI;
2085     /*
2086      * Map errors to the local host's errno.h format.
2087      */
2088     error = ntoh_syserr_conv(error);
2089     return error;
2090 }
2091
2092 #if !defined(KERNEL)
2093
2094 /* Call this routine when shutting down a server or client (especially
2095  * clients).  This will allow Rx to gracefully garbage collect server
2096  * connections, and reduce the number of retries that a server might
2097  * make to a dead client.
2098  * This is not quite right, since some calls may still be ongoing and
2099  * we can't lock them to destroy them. */
2100 void
2101 rx_Finalize(void)
2102 {
2103     register struct rx_connection **conn_ptr, **conn_end;
2104
2105     INIT_PTHREAD_LOCKS;
2106     LOCK_RX_INIT;
2107     if (rxinit_status == 1) {
2108         UNLOCK_RX_INIT;
2109         return;                 /* Already shutdown. */
2110     }
2111     rxi_DeleteCachedConnections();
2112     if (rx_connHashTable) {
2113         MUTEX_ENTER(&rx_connHashTable_lock);
2114         for (conn_ptr = &rx_connHashTable[0], conn_end =
2115              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
2116              conn_ptr++) {
2117             struct rx_connection *conn, *next;
2118             for (conn = *conn_ptr; conn; conn = next) {
2119                 next = conn->next;
2120                 if (conn->type == RX_CLIENT_CONNECTION) {
2121                     /* MUTEX_ENTER(&conn->conn_data_lock); when used in kernel */
2122                     conn->refCount++;
2123                     /* MUTEX_EXIT(&conn->conn_data_lock); when used in kernel */
2124 #ifdef RX_ENABLE_LOCKS
2125                     rxi_DestroyConnectionNoLock(conn);
2126 #else /* RX_ENABLE_LOCKS */
2127                     rxi_DestroyConnection(conn);
2128 #endif /* RX_ENABLE_LOCKS */
2129                 }
2130             }
2131         }
2132 #ifdef RX_ENABLE_LOCKS
2133         while (rx_connCleanup_list) {
2134             struct rx_connection *conn;
2135             conn = rx_connCleanup_list;
2136             rx_connCleanup_list = rx_connCleanup_list->next;
2137             MUTEX_EXIT(&rx_connHashTable_lock);
2138             rxi_CleanupConnection(conn);
2139             MUTEX_ENTER(&rx_connHashTable_lock);
2140         }
2141         MUTEX_EXIT(&rx_connHashTable_lock);
2142 #endif /* RX_ENABLE_LOCKS */
2143     }
2144     rxi_flushtrace();
2145
2146 #ifdef AFS_NT40_ENV
2147     afs_winsockCleanup();
2148 #endif
2149
2150     rxinit_status = 1;
2151     UNLOCK_RX_INIT;
2152 }
2153 #endif
2154
2155 /* if we wakeup packet waiter too often, can get in loop with two
2156     AllocSendPackets each waking each other up (from ReclaimPacket calls) */
2157 void
2158 rxi_PacketsUnWait(void)
2159 {
2160     if (!rx_waitingForPackets) {
2161         return;
2162     }
2163 #ifdef KERNEL
2164     if (rxi_OverQuota(RX_PACKET_CLASS_SEND)) {
2165         return;                 /* still over quota */
2166     }
2167 #endif /* KERNEL */
2168     rx_waitingForPackets = 0;
2169 #ifdef  RX_ENABLE_LOCKS
2170     CV_BROADCAST(&rx_waitingForPackets_cv);
2171 #else
2172     osi_rxWakeup(&rx_waitingForPackets);
2173 #endif
2174     return;
2175 }
2176
2177
2178 /* ------------------Internal interfaces------------------------- */
2179
2180 /* Return this process's service structure for the
2181  * specified socket and service */
2182 struct rx_service *
2183 rxi_FindService(register osi_socket socket, register u_short serviceId)
2184 {
2185     register struct rx_service **sp;
2186     for (sp = &rx_services[0]; *sp; sp++) {
2187         if ((*sp)->serviceId == serviceId && (*sp)->socket == socket)
2188             return *sp;
2189     }
2190     return 0;
2191 }
2192
2193 /* Allocate a call structure, for the indicated channel of the
2194  * supplied connection.  The mode and state of the call must be set by
2195  * the caller. Returns the call with mutex locked. */
2196 struct rx_call *
2197 rxi_NewCall(register struct rx_connection *conn, register int channel)
2198 {
2199     register struct rx_call *call;
2200 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2201     register struct rx_call *cp;        /* Call pointer temp */
2202     register struct rx_call *nxp;       /* Next call pointer, for queue_Scan */
2203 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2204
2205     dpf(("rxi_NewCall(conn %x, channel %d)\n", conn, channel));
2206
2207     /* Grab an existing call structure, or allocate a new one.
2208      * Existing call structures are assumed to have been left reset by
2209      * rxi_FreeCall */
2210     MUTEX_ENTER(&rx_freeCallQueue_lock);
2211
2212 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2213     /*
2214      * EXCEPT that the TQ might not yet be cleared out.
2215      * Skip over those with in-use TQs.
2216      */
2217     call = NULL;
2218     for (queue_Scan(&rx_freeCallQueue, cp, nxp, rx_call)) {
2219         if (!(cp->flags & RX_CALL_TQ_BUSY)) {
2220             call = cp;
2221             break;
2222         }
2223     }
2224     if (call) {
2225 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2226     if (queue_IsNotEmpty(&rx_freeCallQueue)) {
2227         call = queue_First(&rx_freeCallQueue, rx_call);
2228 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2229         queue_Remove(call);
2230         rx_MutexDecrement(rx_stats.nFreeCallStructs, rx_stats_mutex);
2231         MUTEX_EXIT(&rx_freeCallQueue_lock);
2232         MUTEX_ENTER(&call->lock);
2233         CLEAR_CALL_QUEUE_LOCK(call);
2234 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2235         /* Now, if TQ wasn't cleared earlier, do it now. */
2236         if (call->flags & RX_CALL_TQ_CLEARME) {
2237             rxi_ClearTransmitQueue(call, 1);
2238             queue_Init(&call->tq);
2239         }
2240 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2241         /* Bind the call to its connection structure */
2242         call->conn = conn;
2243         rxi_ResetCall(call, 1);
2244     } else {
2245
2246         call = (struct rx_call *)rxi_Alloc(sizeof(struct rx_call));
2247
2248         MUTEX_EXIT(&rx_freeCallQueue_lock);
2249         MUTEX_INIT(&call->lock, "call lock", MUTEX_DEFAULT, NULL);
2250         MUTEX_ENTER(&call->lock);
2251         CV_INIT(&call->cv_twind, "call twind", CV_DEFAULT, 0);
2252         CV_INIT(&call->cv_rq, "call rq", CV_DEFAULT, 0);
2253         CV_INIT(&call->cv_tq, "call tq", CV_DEFAULT, 0);
2254
2255         rx_MutexIncrement(rx_stats.nFreeCallStructs, rx_stats_mutex);
2256         /* Initialize once-only items */
2257         queue_Init(&call->tq);
2258         queue_Init(&call->rq);
2259         queue_Init(&call->iovq);
2260         /* Bind the call to its connection structure (prereq for reset) */
2261         call->conn = conn;
2262         rxi_ResetCall(call, 1);
2263     }
2264     call->channel = channel;
2265     call->callNumber = &conn->callNumber[channel];
2266     call->rwind = conn->rwind[channel];
2267     call->twind = conn->twind[channel];
2268     /* Note that the next expected call number is retained (in
2269      * conn->callNumber[i]), even if we reallocate the call structure
2270      */
2271     conn->call[channel] = call;
2272     /* if the channel's never been used (== 0), we should start at 1, otherwise
2273      * the call number is valid from the last time this channel was used */
2274     if (*call->callNumber == 0)
2275         *call->callNumber = 1;
2276
2277     return call;
2278 }
2279
2280 /* A call has been inactive long enough that so we can throw away
2281  * state, including the call structure, which is placed on the call
2282  * free list.
2283  * Call is locked upon entry.
2284  * haveCTLock set if called from rxi_ReapConnections
2285  */
2286 #ifdef RX_ENABLE_LOCKS
2287 void
2288 rxi_FreeCall(register struct rx_call *call, int haveCTLock)
2289 #else /* RX_ENABLE_LOCKS */
2290 void
2291 rxi_FreeCall(register struct rx_call *call)
2292 #endif                          /* RX_ENABLE_LOCKS */
2293 {
2294     register int channel = call->channel;
2295     register struct rx_connection *conn = call->conn;
2296
2297
2298     if (call->state == RX_STATE_DALLY || call->state == RX_STATE_HOLD)
2299         (*call->callNumber)++;
2300     rxi_ResetCall(call, 0);
2301     call->conn->call[channel] = (struct rx_call *)0;
2302
2303     MUTEX_ENTER(&rx_freeCallQueue_lock);
2304     SET_CALL_QUEUE_LOCK(call, &rx_freeCallQueue_lock);
2305 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
2306     /* A call may be free even though its transmit queue is still in use.
2307      * Since we search the call list from head to tail, put busy calls at
2308      * the head of the list, and idle calls at the tail.
2309      */
2310     if (call->flags & RX_CALL_TQ_BUSY)
2311         queue_Prepend(&rx_freeCallQueue, call);
2312     else
2313         queue_Append(&rx_freeCallQueue, call);
2314 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2315     queue_Append(&rx_freeCallQueue, call);
2316 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2317     rx_MutexIncrement(rx_stats.nFreeCallStructs, rx_stats_mutex);
2318     MUTEX_EXIT(&rx_freeCallQueue_lock);
2319
2320     /* Destroy the connection if it was previously slated for
2321      * destruction, i.e. the Rx client code previously called
2322      * rx_DestroyConnection (client connections), or
2323      * rxi_ReapConnections called the same routine (server
2324      * connections).  Only do this, however, if there are no
2325      * outstanding calls. Note that for fine grain locking, there appears
2326      * to be a deadlock in that rxi_FreeCall has a call locked and
2327      * DestroyConnectionNoLock locks each call in the conn. But note a
2328      * few lines up where we have removed this call from the conn.
2329      * If someone else destroys a connection, they either have no
2330      * call lock held or are going through this section of code.
2331      */
2332     if (conn->flags & RX_CONN_DESTROY_ME && !(conn->flags & RX_CONN_MAKECALL_WAITING)) {
2333         MUTEX_ENTER(&conn->conn_data_lock);
2334         conn->refCount++;
2335         MUTEX_EXIT(&conn->conn_data_lock);
2336 #ifdef RX_ENABLE_LOCKS
2337         if (haveCTLock)
2338             rxi_DestroyConnectionNoLock(conn);
2339         else
2340             rxi_DestroyConnection(conn);
2341 #else /* RX_ENABLE_LOCKS */
2342         rxi_DestroyConnection(conn);
2343 #endif /* RX_ENABLE_LOCKS */
2344     }
2345 }
2346
2347 afs_int32 rxi_Alloccnt = 0, rxi_Allocsize = 0;
2348 char *
2349 rxi_Alloc(register size_t size)
2350 {
2351     register char *p;
2352
2353     rx_MutexAdd1Increment2(rxi_Allocsize, (afs_int32)size, rxi_Alloccnt, rx_stats_mutex);
2354
2355 p = (char *)
2356 #if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
2357   afs_osi_Alloc_NoSleep(size);
2358 #else
2359   osi_Alloc(size);
2360 #endif
2361     if (!p)
2362         osi_Panic("rxi_Alloc error");
2363     memset(p, 0, size);
2364     return p;
2365 }
2366
2367 void
2368 rxi_Free(void *addr, register size_t size)
2369 {
2370     rx_MutexAdd1Decrement2(rxi_Allocsize, -(afs_int32)size, rxi_Alloccnt, rx_stats_mutex);
2371     osi_Free(addr, size);
2372 }
2373
2374 void 
2375 rxi_SetPeerMtu(register afs_uint32 host, register afs_uint32 port, int mtu)
2376 {
2377     struct rx_peer **peer_ptr, **peer_end;
2378     int hashIndex;
2379
2380     MUTEX_ENTER(&rx_peerHashTable_lock);
2381     if (port == 0) {
2382        for (peer_ptr = &rx_peerHashTable[0], peer_end =
2383                 &rx_peerHashTable[rx_hashTableSize]; peer_ptr < peer_end;
2384             peer_ptr++) {
2385            struct rx_peer *peer, *next;
2386            for (peer = *peer_ptr; peer; peer = next) {
2387                next = peer->next;
2388                if (host == peer->host) {
2389                    MUTEX_ENTER(&peer->peer_lock);
2390                    peer->ifMTU=MIN(mtu, peer->ifMTU);
2391                    peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
2392                    MUTEX_EXIT(&peer->peer_lock);
2393                }
2394            }
2395        }
2396     } else {
2397        struct rx_peer *peer;
2398        hashIndex = PEER_HASH(host, port);
2399        for (peer = rx_peerHashTable[hashIndex]; peer; peer = peer->next) {
2400            if ((peer->host == host) && (peer->port == port)) {
2401                MUTEX_ENTER(&peer->peer_lock);
2402                peer->ifMTU=MIN(mtu, peer->ifMTU);
2403                peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
2404                MUTEX_EXIT(&peer->peer_lock);
2405            }
2406        }
2407     }
2408     MUTEX_EXIT(&rx_peerHashTable_lock);
2409 }
2410
2411 /* Find the peer process represented by the supplied (host,port)
2412  * combination.  If there is no appropriate active peer structure, a
2413  * new one will be allocated and initialized 
2414  * The origPeer, if set, is a pointer to a peer structure on which the
2415  * refcount will be be decremented. This is used to replace the peer
2416  * structure hanging off a connection structure */
2417 struct rx_peer *
2418 rxi_FindPeer(register afs_uint32 host, register u_short port,
2419              struct rx_peer *origPeer, int create)
2420 {
2421     register struct rx_peer *pp;
2422     int hashIndex;
2423     hashIndex = PEER_HASH(host, port);
2424     MUTEX_ENTER(&rx_peerHashTable_lock);
2425     for (pp = rx_peerHashTable[hashIndex]; pp; pp = pp->next) {
2426         if ((pp->host == host) && (pp->port == port))
2427             break;
2428     }
2429     if (!pp) {
2430         if (create) {
2431             pp = rxi_AllocPeer();       /* This bzero's *pp */
2432             pp->host = host;    /* set here or in InitPeerParams is zero */
2433             pp->port = port;
2434             MUTEX_INIT(&pp->peer_lock, "peer_lock", MUTEX_DEFAULT, 0);
2435             queue_Init(&pp->congestionQueue);
2436             queue_Init(&pp->rpcStats);
2437             pp->next = rx_peerHashTable[hashIndex];
2438             rx_peerHashTable[hashIndex] = pp;
2439             rxi_InitPeerParams(pp);
2440             rx_MutexIncrement(rx_stats.nPeerStructs, rx_stats_mutex);
2441         }
2442     }
2443     if (pp && create) {
2444         pp->refCount++;
2445     }
2446     if (origPeer)
2447         origPeer->refCount--;
2448     MUTEX_EXIT(&rx_peerHashTable_lock);
2449     return pp;
2450 }
2451
2452
2453 /* Find the connection at (host, port) started at epoch, and with the
2454  * given connection id.  Creates the server connection if necessary.
2455  * The type specifies whether a client connection or a server
2456  * connection is desired.  In both cases, (host, port) specify the
2457  * peer's (host, pair) pair.  Client connections are not made
2458  * automatically by this routine.  The parameter socket gives the
2459  * socket descriptor on which the packet was received.  This is used,
2460  * in the case of server connections, to check that *new* connections
2461  * come via a valid (port, serviceId).  Finally, the securityIndex
2462  * parameter must match the existing index for the connection.  If a
2463  * server connection is created, it will be created using the supplied
2464  * index, if the index is valid for this service */
2465 struct rx_connection *
2466 rxi_FindConnection(osi_socket socket, register afs_int32 host,
2467                    register u_short port, u_short serviceId, afs_uint32 cid,
2468                    afs_uint32 epoch, int type, u_int securityIndex)
2469 {
2470     int hashindex, flag, i;
2471     register struct rx_connection *conn;
2472     hashindex = CONN_HASH(host, port, cid, epoch, type);
2473     MUTEX_ENTER(&rx_connHashTable_lock);
2474     rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
2475                                                   rx_connHashTable[hashindex],
2476                                                   flag = 1);
2477     for (; conn;) {
2478         if ((conn->type == type) && ((cid & RX_CIDMASK) == conn->cid)
2479             && (epoch == conn->epoch)) {
2480             register struct rx_peer *pp = conn->peer;
2481             if (securityIndex != conn->securityIndex) {
2482                 /* this isn't supposed to happen, but someone could forge a packet
2483                  * like this, and there seems to be some CM bug that makes this
2484                  * happen from time to time -- in which case, the fileserver
2485                  * asserts. */
2486                 MUTEX_EXIT(&rx_connHashTable_lock);
2487                 return (struct rx_connection *)0;
2488             }
2489             if (pp->host == host && pp->port == port)
2490                 break;
2491             if (type == RX_CLIENT_CONNECTION && pp->port == port)
2492                 break;
2493             /* So what happens when it's a callback connection? */
2494             if (                /*type == RX_CLIENT_CONNECTION && */
2495                    (conn->epoch & 0x80000000))
2496                 break;
2497         }
2498         if (!flag) {
2499             /* the connection rxLastConn that was used the last time is not the
2500              ** one we are looking for now. Hence, start searching in the hash */
2501             flag = 1;
2502             conn = rx_connHashTable[hashindex];
2503         } else
2504             conn = conn->next;
2505     }
2506     if (!conn) {
2507         struct rx_service *service;
2508         if (type == RX_CLIENT_CONNECTION) {
2509             MUTEX_EXIT(&rx_connHashTable_lock);
2510             return (struct rx_connection *)0;
2511         }
2512         service = rxi_FindService(socket, serviceId);
2513         if (!service || (securityIndex >= service->nSecurityObjects)
2514             || (service->securityObjects[securityIndex] == 0)) {
2515             MUTEX_EXIT(&rx_connHashTable_lock);
2516             return (struct rx_connection *)0;
2517         }
2518         conn = rxi_AllocConnection();   /* This bzero's the connection */
2519         MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
2520         MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
2521         CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
2522         conn->next = rx_connHashTable[hashindex];
2523         rx_connHashTable[hashindex] = conn;
2524         conn->peer = rxi_FindPeer(host, port, 0, 1);
2525         conn->type = RX_SERVER_CONNECTION;
2526         conn->lastSendTime = clock_Sec();       /* don't GC immediately */
2527         conn->epoch = epoch;
2528         conn->cid = cid & RX_CIDMASK;
2529         /* conn->serial = conn->lastSerial = 0; */
2530         /* conn->timeout = 0; */
2531         conn->ackRate = RX_FAST_ACK_RATE;
2532         conn->service = service;
2533         conn->serviceId = serviceId;
2534         conn->securityIndex = securityIndex;
2535         conn->securityObject = service->securityObjects[securityIndex];
2536         conn->nSpecific = 0;
2537         conn->specific = NULL;
2538         rx_SetConnDeadTime(conn, service->connDeadTime);
2539         rx_SetConnIdleDeadTime(conn, service->idleDeadTime);
2540         rx_SetServerConnIdleDeadErr(conn, service->idleDeadErr);
2541         for (i = 0; i < RX_MAXCALLS; i++) {
2542             conn->twind[i] = rx_initSendWindow;
2543             conn->rwind[i] = rx_initReceiveWindow;
2544         }
2545         /* Notify security object of the new connection */
2546         RXS_NewConnection(conn->securityObject, conn);
2547         /* XXXX Connection timeout? */
2548         if (service->newConnProc)
2549             (*service->newConnProc) (conn);
2550         rx_MutexIncrement(rx_stats.nServerConns, rx_stats_mutex);
2551     }
2552
2553     MUTEX_ENTER(&conn->conn_data_lock);
2554     conn->refCount++;
2555     MUTEX_EXIT(&conn->conn_data_lock);
2556
2557     rxLastConn = conn;          /* store this connection as the last conn used */
2558     MUTEX_EXIT(&rx_connHashTable_lock);
2559     return conn;
2560 }
2561
2562 /* There are two packet tracing routines available for testing and monitoring
2563  * Rx.  One is called just after every packet is received and the other is
2564  * called just before every packet is sent.  Received packets, have had their
2565  * headers decoded, and packets to be sent have not yet had their headers
2566  * encoded.  Both take two parameters: a pointer to the packet and a sockaddr
2567  * containing the network address.  Both can be modified.  The return value, if
2568  * non-zero, indicates that the packet should be dropped.  */
2569
2570 int (*rx_justReceived) (struct rx_packet *, struct sockaddr_in *) = 0;
2571 int (*rx_almostSent) (struct rx_packet *, struct sockaddr_in *) = 0;
2572
2573 /* A packet has been received off the interface.  Np is the packet, socket is
2574  * the socket number it was received from (useful in determining which service
2575  * this packet corresponds to), and (host, port) reflect the host,port of the
2576  * sender.  This call returns the packet to the caller if it is finished with
2577  * it, rather than de-allocating it, just as a small performance hack */
2578
2579 struct rx_packet *
2580 rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
2581                   afs_uint32 host, u_short port, int *tnop,
2582                   struct rx_call **newcallp)
2583 {
2584     register struct rx_call *call;
2585     register struct rx_connection *conn;
2586     int channel;
2587     afs_uint32 currentCallNumber;
2588     int type;
2589     int skew;
2590 #ifdef RXDEBUG
2591     char *packetType;
2592 #endif
2593     struct rx_packet *tnp;
2594
2595 #ifdef RXDEBUG
2596 /* We don't print out the packet until now because (1) the time may not be
2597  * accurate enough until now in the lwp implementation (rx_Listener only gets
2598  * the time after the packet is read) and (2) from a protocol point of view,
2599  * this is the first time the packet has been seen */
2600     packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
2601         ? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
2602     dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %x",
2603          np->header.serial, packetType, ntohl(host), ntohs(port), np->header.serviceId,
2604          np->header.epoch, np->header.cid, np->header.callNumber,
2605          np->header.seq, np->header.flags, np));
2606 #endif
2607
2608     if (np->header.type == RX_PACKET_TYPE_VERSION) {
2609         return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
2610     }
2611
2612     if (np->header.type == RX_PACKET_TYPE_DEBUG) {
2613         return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
2614     }
2615 #ifdef RXDEBUG
2616     /* If an input tracer function is defined, call it with the packet and
2617      * network address.  Note this function may modify its arguments. */
2618     if (rx_justReceived) {
2619         struct sockaddr_in addr;
2620         int drop;
2621         addr.sin_family = AF_INET;
2622         addr.sin_port = port;
2623         addr.sin_addr.s_addr = host;
2624 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
2625         addr.sin_len = sizeof(addr);
2626 #endif /* AFS_OSF_ENV */
2627         drop = (*rx_justReceived) (np, &addr);
2628         /* drop packet if return value is non-zero */
2629         if (drop)
2630             return np;
2631         port = addr.sin_port;   /* in case fcn changed addr */
2632         host = addr.sin_addr.s_addr;
2633     }
2634 #endif
2635
2636     /* If packet was not sent by the client, then *we* must be the client */
2637     type = ((np->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED)
2638         ? RX_CLIENT_CONNECTION : RX_SERVER_CONNECTION;
2639
2640     /* Find the connection (or fabricate one, if we're the server & if
2641      * necessary) associated with this packet */
2642     conn =
2643         rxi_FindConnection(socket, host, port, np->header.serviceId,
2644                            np->header.cid, np->header.epoch, type,
2645                            np->header.securityIndex);
2646
2647     if (!conn) {
2648         /* If no connection found or fabricated, just ignore the packet.
2649          * (An argument could be made for sending an abort packet for
2650          * the conn) */
2651         return np;
2652     }
2653
2654     MUTEX_ENTER(&conn->conn_data_lock);
2655     if (conn->maxSerial < np->header.serial)
2656         conn->maxSerial = np->header.serial;
2657     MUTEX_EXIT(&conn->conn_data_lock);
2658
2659     /* If the connection is in an error state, send an abort packet and ignore
2660      * the incoming packet */
2661     if (conn->error) {
2662         /* Don't respond to an abort packet--we don't want loops! */
2663         MUTEX_ENTER(&conn->conn_data_lock);
2664         if (np->header.type != RX_PACKET_TYPE_ABORT)
2665             np = rxi_SendConnectionAbort(conn, np, 1, 0);
2666         conn->refCount--;
2667         MUTEX_EXIT(&conn->conn_data_lock);
2668         return np;
2669     }
2670
2671     /* Check for connection-only requests (i.e. not call specific). */
2672     if (np->header.callNumber == 0) {
2673         switch (np->header.type) {
2674         case RX_PACKET_TYPE_ABORT: {
2675             /* What if the supplied error is zero? */
2676             afs_int32 errcode = ntohl(rx_GetInt32(np, 0));
2677             dpf(("rxi_ReceivePacket ABORT rx_GetInt32 = %d", errcode));
2678             rxi_ConnectionError(conn, errcode);
2679             MUTEX_ENTER(&conn->conn_data_lock);
2680             conn->refCount--;
2681             MUTEX_EXIT(&conn->conn_data_lock);
2682             return np;
2683         }
2684         case RX_PACKET_TYPE_CHALLENGE:
2685             tnp = rxi_ReceiveChallengePacket(conn, np, 1);
2686             MUTEX_ENTER(&conn->conn_data_lock);
2687             conn->refCount--;
2688             MUTEX_EXIT(&conn->conn_data_lock);
2689             return tnp;
2690         case RX_PACKET_TYPE_RESPONSE:
2691             tnp = rxi_ReceiveResponsePacket(conn, np, 1);
2692             MUTEX_ENTER(&conn->conn_data_lock);
2693             conn->refCount--;
2694             MUTEX_EXIT(&conn->conn_data_lock);
2695             return tnp;
2696         case RX_PACKET_TYPE_PARAMS:
2697         case RX_PACKET_TYPE_PARAMS + 1:
2698         case RX_PACKET_TYPE_PARAMS + 2:
2699             /* ignore these packet types for now */
2700             MUTEX_ENTER(&conn->conn_data_lock);
2701             conn->refCount--;
2702             MUTEX_EXIT(&conn->conn_data_lock);
2703             return np;
2704
2705
2706         default:
2707             /* Should not reach here, unless the peer is broken: send an
2708              * abort packet */
2709             rxi_ConnectionError(conn, RX_PROTOCOL_ERROR);
2710             MUTEX_ENTER(&conn->conn_data_lock);
2711             tnp = rxi_SendConnectionAbort(conn, np, 1, 0);
2712             conn->refCount--;
2713             MUTEX_EXIT(&conn->conn_data_lock);
2714             return tnp;
2715         }
2716     }
2717
2718     channel = np->header.cid & RX_CHANNELMASK;
2719     call = conn->call[channel];
2720 #ifdef  RX_ENABLE_LOCKS
2721     if (call)
2722         MUTEX_ENTER(&call->lock);
2723     /* Test to see if call struct is still attached to conn. */
2724     if (call != conn->call[channel]) {
2725         if (call)
2726             MUTEX_EXIT(&call->lock);
2727         if (type == RX_SERVER_CONNECTION) {
2728             call = conn->call[channel];
2729             /* If we started with no call attached and there is one now,
2730              * another thread is also running this routine and has gotten
2731              * the connection channel. We should drop this packet in the tests
2732              * below. If there was a call on this connection and it's now
2733              * gone, then we'll be making a new call below.
2734              * If there was previously a call and it's now different then
2735              * the old call was freed and another thread running this routine
2736              * has created a call on this channel. One of these two threads
2737              * has a packet for the old call and the code below handles those
2738              * cases.
2739              */
2740             if (call)
2741                 MUTEX_ENTER(&call->lock);
2742         } else {
2743             /* This packet can't be for this call. If the new call address is
2744              * 0 then no call is running on this channel. If there is a call
2745              * then, since this is a client connection we're getting data for
2746              * it must be for the previous call.
2747              */
2748             rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
2749             MUTEX_ENTER(&conn->conn_data_lock);
2750             conn->refCount--;
2751             MUTEX_EXIT(&conn->conn_data_lock);
2752             return np;
2753         }
2754     }
2755 #endif
2756     currentCallNumber = conn->callNumber[channel];
2757
2758     if (type == RX_SERVER_CONNECTION) { /* We're the server */
2759         if (np->header.callNumber < currentCallNumber) {
2760             rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
2761 #ifdef  RX_ENABLE_LOCKS
2762             if (call)
2763                 MUTEX_EXIT(&call->lock);
2764 #endif
2765             MUTEX_ENTER(&conn->conn_data_lock);
2766             conn->refCount--;
2767             MUTEX_EXIT(&conn->conn_data_lock);
2768             return np;
2769         }
2770         if (!call) {
2771             MUTEX_ENTER(&conn->conn_call_lock);
2772             call = rxi_NewCall(conn, channel);
2773             MUTEX_EXIT(&conn->conn_call_lock);
2774             *call->callNumber = np->header.callNumber;
2775             if (np->header.callNumber == 0) 
2776                 dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
2777
2778             call->state = RX_STATE_PRECALL;
2779             clock_GetTime(&call->queueTime);
2780             hzero(call->bytesSent);
2781             hzero(call->bytesRcvd);
2782             /*
2783              * If the number of queued calls exceeds the overload
2784              * threshold then abort this call.
2785              */
2786             if ((rx_BusyThreshold > 0) && (rx_nWaiting > rx_BusyThreshold)) {
2787                 struct rx_packet *tp;
2788                 
2789                 rxi_CallError(call, rx_BusyError);
2790                 tp = rxi_SendCallAbort(call, np, 1, 0);
2791                 MUTEX_EXIT(&call->lock);
2792                 MUTEX_ENTER(&conn->conn_data_lock);
2793                 conn->refCount--;
2794                 MUTEX_EXIT(&conn->conn_data_lock);
2795                 rx_MutexIncrement(rx_stats.nBusies, rx_stats_mutex);
2796                 return tp;
2797             }
2798             rxi_KeepAliveOn(call);
2799         } else if (np->header.callNumber != currentCallNumber) {
2800             /* Wait until the transmit queue is idle before deciding
2801              * whether to reset the current call. Chances are that the
2802              * call will be in ether DALLY or HOLD state once the TQ_BUSY
2803              * flag is cleared.
2804              */
2805 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
2806             while ((call->state == RX_STATE_ACTIVE)
2807                    && (call->flags & RX_CALL_TQ_BUSY)) {
2808                 call->flags |= RX_CALL_TQ_WAIT;
2809                 call->tqWaiters++;
2810 #ifdef RX_ENABLE_LOCKS
2811                 osirx_AssertMine(&call->lock, "rxi_Start lock3");
2812                 CV_WAIT(&call->cv_tq, &call->lock);
2813 #else /* RX_ENABLE_LOCKS */
2814                 osi_rxSleep(&call->tq);
2815 #endif /* RX_ENABLE_LOCKS */
2816                 call->tqWaiters--;
2817                 if (call->tqWaiters == 0)
2818                     call->flags &= ~RX_CALL_TQ_WAIT;
2819             }
2820 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2821             /* If the new call cannot be taken right now send a busy and set
2822              * the error condition in this call, so that it terminates as
2823              * quickly as possible */
2824             if (call->state == RX_STATE_ACTIVE) {
2825                 struct rx_packet *tp;
2826
2827                 rxi_CallError(call, RX_CALL_DEAD);
2828                 tp = rxi_SendSpecial(call, conn, np, RX_PACKET_TYPE_BUSY,
2829                                      NULL, 0, 1);
2830                 MUTEX_EXIT(&call->lock);
2831                 MUTEX_ENTER(&conn->conn_data_lock);
2832                 conn->refCount--;
2833                 MUTEX_EXIT(&conn->conn_data_lock);
2834                 return tp;
2835             }
2836             rxi_ResetCall(call, 0);
2837             *call->callNumber = np->header.callNumber;
2838             if (np->header.callNumber == 0) 
2839                 dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
2840
2841             call->state = RX_STATE_PRECALL;
2842             clock_GetTime(&call->queueTime);
2843             hzero(call->bytesSent);
2844             hzero(call->bytesRcvd);
2845             /*
2846              * If the number of queued calls exceeds the overload
2847              * threshold then abort this call.
2848              */
2849             if ((rx_BusyThreshold > 0) && (rx_nWaiting > rx_BusyThreshold)) {
2850                 struct rx_packet *tp;
2851
2852                 rxi_CallError(call, rx_BusyError);
2853                 tp = rxi_SendCallAbort(call, np, 1, 0);
2854                 MUTEX_EXIT(&call->lock);
2855                 MUTEX_ENTER(&conn->conn_data_lock);
2856                 conn->refCount--;
2857                 MUTEX_EXIT(&conn->conn_data_lock);
2858                 rx_MutexIncrement(rx_stats.nBusies, rx_stats_mutex);
2859                 return tp;
2860             }
2861             rxi_KeepAliveOn(call);
2862         } else {
2863             /* Continuing call; do nothing here. */
2864         }
2865     } else {                    /* we're the client */
2866         /* Ignore all incoming acknowledgements for calls in DALLY state */
2867         if (call && (call->state == RX_STATE_DALLY)
2868             && (np->header.type == RX_PACKET_TYPE_ACK)) {
2869             rx_MutexIncrement(rx_stats.ignorePacketDally, rx_stats_mutex);
2870 #ifdef  RX_ENABLE_LOCKS
2871             if (call) {
2872                 MUTEX_EXIT(&call->lock);
2873             }
2874 #endif
2875             MUTEX_ENTER(&conn->conn_data_lock);
2876             conn->refCount--;
2877             MUTEX_EXIT(&conn->conn_data_lock);
2878             return np;
2879         }
2880
2881         /* Ignore anything that's not relevant to the current call.  If there
2882          * isn't a current call, then no packet is relevant. */
2883         if (!call || (np->header.callNumber != currentCallNumber)) {
2884             rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
2885 #ifdef  RX_ENABLE_LOCKS
2886             if (call) {
2887                 MUTEX_EXIT(&call->lock);
2888             }
2889 #endif
2890             MUTEX_ENTER(&conn->conn_data_lock);
2891             conn->refCount--;
2892             MUTEX_EXIT(&conn->conn_data_lock);
2893             return np;
2894         }
2895         /* If the service security object index stamped in the packet does not
2896          * match the connection's security index, ignore the packet */
2897         if (np->header.securityIndex != conn->securityIndex) {
2898 #ifdef  RX_ENABLE_LOCKS
2899             MUTEX_EXIT(&call->lock);
2900 #endif
2901             MUTEX_ENTER(&conn->conn_data_lock);
2902             conn->refCount--;
2903             MUTEX_EXIT(&conn->conn_data_lock);
2904             return np;
2905         }
2906
2907         /* If we're receiving the response, then all transmit packets are
2908          * implicitly acknowledged.  Get rid of them. */
2909         if (np->header.type == RX_PACKET_TYPE_DATA) {
2910 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
2911             /* XXX Hack. Because we must release the global rx lock when
2912              * sending packets (osi_NetSend) we drop all acks while we're
2913              * traversing the tq in rxi_Start sending packets out because
2914              * packets may move to the freePacketQueue as result of being here!
2915              * So we drop these packets until we're safely out of the
2916              * traversing. Really ugly! 
2917              * For fine grain RX locking, we set the acked field in the
2918              * packets and let rxi_Start remove them from the transmit queue.
2919              */
2920             if (call->flags & RX_CALL_TQ_BUSY) {
2921 #ifdef  RX_ENABLE_LOCKS
2922                 rxi_SetAcksInTransmitQueue(call);
2923 #else
2924                 conn->refCount--;
2925                 return np;      /* xmitting; drop packet */
2926 #endif
2927             } else {
2928                 rxi_ClearTransmitQueue(call, 0);
2929             }
2930 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
2931             rxi_ClearTransmitQueue(call, 0);
2932 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
2933         } else {
2934             if (np->header.type == RX_PACKET_TYPE_ACK) {
2935                 /* now check to see if this is an ack packet acknowledging that the
2936                  * server actually *lost* some hard-acked data.  If this happens we
2937                  * ignore this packet, as it may indicate that the server restarted in
2938                  * the middle of a call.  It is also possible that this is an old ack
2939                  * packet.  We don't abort the connection in this case, because this
2940                  * *might* just be an old ack packet.  The right way to detect a server
2941                  * restart in the midst of a call is to notice that the server epoch
2942                  * changed, btw.  */
2943                 /* XXX I'm not sure this is exactly right, since tfirst **IS**
2944                  * XXX unacknowledged.  I think that this is off-by-one, but
2945                  * XXX I don't dare change it just yet, since it will
2946                  * XXX interact badly with the server-restart detection 
2947                  * XXX code in receiveackpacket.  */
2948                 if (ntohl(rx_GetInt32(np, FIRSTACKOFFSET)) < call->tfirst) {
2949                     rx_MutexIncrement(rx_stats.spuriousPacketsRead, rx_stats_mutex);
2950                     MUTEX_EXIT(&call->lock);
2951                     MUTEX_ENTER(&conn->conn_data_lock);
2952                     conn->refCount--;
2953                     MUTEX_EXIT(&conn->conn_data_lock);
2954                     return np;
2955                 }
2956             }
2957         }                       /* else not a data packet */
2958     }
2959
2960     osirx_AssertMine(&call->lock, "rxi_ReceivePacket middle");
2961     /* Set remote user defined status from packet */
2962     call->remoteStatus = np->header.userStatus;
2963
2964     /* Note the gap between the expected next packet and the actual
2965      * packet that arrived, when the new packet has a smaller serial number
2966      * than expected.  Rioses frequently reorder packets all by themselves,
2967      * so this will be quite important with very large window sizes.
2968      * Skew is checked against 0 here to avoid any dependence on the type of
2969      * inPacketSkew (which may be unsigned).  In C, -1 > (unsigned) 0 is always
2970      * true! 
2971      * The inPacketSkew should be a smoothed running value, not just a maximum.  MTUXXX
2972      * see CalculateRoundTripTime for an example of how to keep smoothed values.
2973      * I think using a beta of 1/8 is probably appropriate.  93.04.21
2974      */
2975     MUTEX_ENTER(&conn->conn_data_lock);
2976     skew = conn->lastSerial - np->header.serial;
2977     conn->lastSerial = np->header.serial;
2978     MUTEX_EXIT(&conn->conn_data_lock);
2979     if (skew > 0) {
2980         register struct rx_peer *peer;
2981         peer = conn->peer;
2982         if (skew > peer->inPacketSkew) {
2983             dpf(("*** In skew changed from %d to %d\n", peer->inPacketSkew,
2984                  skew));
2985             peer->inPacketSkew = skew;
2986         }
2987     }
2988
2989     /* Now do packet type-specific processing */
2990     switch (np->header.type) {
2991     case RX_PACKET_TYPE_DATA:
2992         np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
2993                                    newcallp);
2994         break;
2995     case RX_PACKET_TYPE_ACK:
2996         /* Respond immediately to ack packets requesting acknowledgement
2997          * (ping packets) */
2998         if (np->header.flags & RX_REQUEST_ACK) {
2999             if (call->error)
3000                 (void)rxi_SendCallAbort(call, 0, 1, 0);
3001             else
3002                 (void)rxi_SendAck(call, 0, np->header.serial,
3003                                   RX_ACK_PING_RESPONSE, 1);
3004         }
3005         np = rxi_ReceiveAckPacket(call, np, 1);
3006         break;
3007     case RX_PACKET_TYPE_ABORT: {
3008         /* An abort packet: reset the call, passing the error up to the user. */
3009         /* What if error is zero? */
3010         /* What if the error is -1? the application will treat it as a timeout. */
3011         afs_int32 errdata = ntohl(*(afs_int32 *) rx_DataOf(np));
3012         dpf(("rxi_ReceivePacket ABORT rx_DataOf = %d", errdata));
3013         rxi_CallError(call, errdata);
3014         MUTEX_EXIT(&call->lock);
3015         MUTEX_ENTER(&conn->conn_data_lock);
3016         conn->refCount--;
3017         MUTEX_EXIT(&conn->conn_data_lock);
3018         return np;              /* xmitting; drop packet */
3019     }
3020     case RX_PACKET_TYPE_BUSY:
3021         /* XXXX */
3022         break;
3023     case RX_PACKET_TYPE_ACKALL:
3024         /* All packets acknowledged, so we can drop all packets previously
3025          * readied for sending */
3026 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3027         /* XXX Hack. We because we can't release the global rx lock when
3028          * sending packets (osi_NetSend) we drop all ack pkts while we're
3029          * traversing the tq in rxi_Start sending packets out because
3030          * packets may move to the freePacketQueue as result of being
3031          * here! So we drop these packets until we're safely out of the
3032          * traversing. Really ugly! 
3033          * For fine grain RX locking, we set the acked field in the packets
3034          * and let rxi_Start remove the packets from the transmit queue.
3035          */
3036         if (call->flags & RX_CALL_TQ_BUSY) {
3037 #ifdef  RX_ENABLE_LOCKS
3038             rxi_SetAcksInTransmitQueue(call);
3039             break;
3040 #else /* RX_ENABLE_LOCKS */
3041             MUTEX_EXIT(&call->lock);
3042             MUTEX_ENTER(&conn->conn_data_lock);
3043             conn->refCount--;
3044             MUTEX_EXIT(&conn->conn_data_lock);
3045             return np;          /* xmitting; drop packet */
3046 #endif /* RX_ENABLE_LOCKS */
3047         }
3048 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3049         rxi_ClearTransmitQueue(call, 0);
3050         rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
3051         break;
3052     default:
3053         /* Should not reach here, unless the peer is broken: send an abort
3054          * packet */
3055         rxi_CallError(call, RX_PROTOCOL_ERROR);
3056         np = rxi_SendCallAbort(call, np, 1, 0);
3057         break;
3058     };
3059     /* Note when this last legitimate packet was received, for keep-alive
3060      * processing.  Note, we delay getting the time until now in the hope that
3061      * the packet will be delivered to the user before any get time is required
3062      * (if not, then the time won't actually be re-evaluated here). */
3063     call->lastReceiveTime = clock_Sec();
3064     MUTEX_EXIT(&call->lock);
3065     MUTEX_ENTER(&conn->conn_data_lock);
3066     conn->refCount--;
3067     MUTEX_EXIT(&conn->conn_data_lock);
3068     return np;
3069 }
3070
3071 /* return true if this is an "interesting" connection from the point of view
3072     of someone trying to debug the system */
3073 int
3074 rxi_IsConnInteresting(struct rx_connection *aconn)
3075 {
3076     register int i;
3077     register struct rx_call *tcall;
3078
3079     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
3080         return 1;
3081     for (i = 0; i < RX_MAXCALLS; i++) {
3082         tcall = aconn->call[i];
3083         if (tcall) {
3084             if ((tcall->state == RX_STATE_PRECALL)
3085                 || (tcall->state == RX_STATE_ACTIVE))
3086                 return 1;
3087             if ((tcall->mode == RX_MODE_SENDING)
3088                 || (tcall->mode == RX_MODE_RECEIVING))
3089                 return 1;
3090         }
3091     }
3092     return 0;
3093 }
3094
3095 #ifdef KERNEL
3096 /* if this is one of the last few packets AND it wouldn't be used by the
3097    receiving call to immediately satisfy a read request, then drop it on
3098    the floor, since accepting it might prevent a lock-holding thread from
3099    making progress in its reading. If a call has been cleared while in
3100    the precall state then ignore all subsequent packets until the call
3101    is assigned to a thread. */
3102
3103 static int
3104 TooLow(struct rx_packet *ap, struct rx_call *acall)
3105 {
3106     int rc = 0;
3107     MUTEX_ENTER(&rx_stats_mutex);
3108     if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
3109          && (acall->state == RX_STATE_PRECALL))
3110         || ((rx_nFreePackets < rxi_dataQuota + 2)
3111             && !((ap->header.seq < acall->rnext + rx_initSendWindow)
3112                  && (acall->flags & RX_CALL_READER_WAIT)))) {
3113         rc = 1;
3114     }
3115     MUTEX_EXIT(&rx_stats_mutex);
3116     return rc;
3117 }
3118 #endif /* KERNEL */
3119
3120 static void
3121 rxi_CheckReachEvent(struct rxevent *event, void *arg1, void *arg2)
3122 {
3123     struct rx_connection *conn = arg1;
3124     struct rx_call *acall = arg2;
3125     struct rx_call *call = acall;
3126     struct clock when, now;
3127     int i, waiting;
3128
3129     MUTEX_ENTER(&conn->conn_data_lock);
3130     conn->checkReachEvent = NULL;
3131     waiting = conn->flags & RX_CONN_ATTACHWAIT;
3132     if (event)
3133         conn->refCount--;
3134     MUTEX_EXIT(&conn->conn_data_lock);
3135
3136     if (waiting) {
3137         if (!call) {
3138             MUTEX_ENTER(&conn->conn_call_lock);
3139             MUTEX_ENTER(&conn->conn_data_lock);
3140             for (i = 0; i < RX_MAXCALLS; i++) {
3141                 struct rx_call *tc = conn->call[i];
3142                 if (tc && tc->state == RX_STATE_PRECALL) {
3143                     call = tc;
3144                     break;
3145                 }
3146             }
3147             if (!call)
3148                 /* Indicate that rxi_CheckReachEvent is no longer running by
3149                  * clearing the flag.  Must be atomic under conn_data_lock to
3150                  * avoid a new call slipping by: rxi_CheckConnReach holds
3151                  * conn_data_lock while checking RX_CONN_ATTACHWAIT.
3152                  */
3153                 conn->flags &= ~RX_CONN_ATTACHWAIT;
3154             MUTEX_EXIT(&conn->conn_data_lock);
3155             MUTEX_EXIT(&conn->conn_call_lock);
3156         }
3157
3158         if (call) {
3159             if (call != acall)
3160                 MUTEX_ENTER(&call->lock);
3161             rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
3162             if (call != acall)
3163                 MUTEX_EXIT(&call->lock);
3164
3165             clock_GetTime(&now);
3166             when = now;
3167             when.sec += RX_CHECKREACH_TIMEOUT;
3168             MUTEX_ENTER(&conn->conn_data_lock);
3169             if (!conn->checkReachEvent) {
3170                 conn->refCount++;
3171                 conn->checkReachEvent =
3172                     rxevent_PostNow(&when, &now, rxi_CheckReachEvent, conn, 
3173                                     NULL);
3174             }
3175             MUTEX_EXIT(&conn->conn_data_lock);
3176         }
3177     }
3178 }
3179
3180 static int
3181 rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
3182 {
3183     struct rx_service *service = conn->service;
3184     struct rx_peer *peer = conn->peer;
3185     afs_uint32 now, lastReach;
3186
3187     if (service->checkReach == 0)
3188         return 0;
3189
3190     now = clock_Sec();
3191     MUTEX_ENTER(&peer->peer_lock);
3192     lastReach = peer->lastReachTime;
3193     MUTEX_EXIT(&peer->peer_lock);
3194     if (now - lastReach < RX_CHECKREACH_TTL)
3195         return 0;
3196
3197     MUTEX_ENTER(&conn->conn_data_lock);
3198     if (conn->flags & RX_CONN_ATTACHWAIT) {
3199         MUTEX_EXIT(&conn->conn_data_lock);
3200         return 1;
3201     }
3202     conn->flags |= RX_CONN_ATTACHWAIT;
3203     MUTEX_EXIT(&conn->conn_data_lock);
3204     if (!conn->checkReachEvent)
3205         rxi_CheckReachEvent(NULL, conn, call);
3206
3207     return 1;
3208 }
3209
3210 /* try to attach call, if authentication is complete */
3211 static void
3212 TryAttach(register struct rx_call *acall, register osi_socket socket,
3213           register int *tnop, register struct rx_call **newcallp,
3214           int reachOverride)
3215 {
3216     struct rx_connection *conn = acall->conn;
3217
3218     if (conn->type == RX_SERVER_CONNECTION
3219         && acall->state == RX_STATE_PRECALL) {
3220         /* Don't attach until we have any req'd. authentication. */
3221         if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
3222             if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
3223                 rxi_AttachServerProc(acall, socket, tnop, newcallp);
3224             /* Note:  this does not necessarily succeed; there
3225              * may not any proc available
3226              */
3227         } else {
3228             rxi_ChallengeOn(acall->conn);
3229         }
3230     }
3231 }
3232
3233 /* A data packet has been received off the interface.  This packet is
3234  * appropriate to the call (the call is in the right state, etc.).  This
3235  * routine can return a packet to the caller, for re-use */
3236
3237 struct rx_packet *
3238 rxi_ReceiveDataPacket(register struct rx_call *call,
3239                       register struct rx_packet *np, int istack,
3240                       osi_socket socket, afs_uint32 host, u_short port,
3241                       int *tnop, struct rx_call **newcallp)
3242 {
3243     int ackNeeded = 0;          /* 0 means no, otherwise ack_reason */
3244     int newPackets = 0;
3245     int didHardAck = 0;
3246     int haveLast = 0;
3247     afs_uint32 seq, serial, flags;
3248     int isFirst;
3249     struct rx_packet *tnp;
3250     struct clock when, now;
3251     rx_MutexIncrement(rx_stats.dataPacketsRead, rx_stats_mutex);
3252
3253 #ifdef KERNEL
3254     /* If there are no packet buffers, drop this new packet, unless we can find
3255      * packet buffers from inactive calls */
3256     if (!call->error
3257         && (rxi_OverQuota(RX_PACKET_CLASS_RECEIVE) || TooLow(np, call))) {
3258         MUTEX_ENTER(&rx_freePktQ_lock);
3259         rxi_NeedMorePackets = TRUE;
3260         MUTEX_EXIT(&rx_freePktQ_lock);
3261         rx_MutexIncrement(rx_stats.noPacketBuffersOnRead, rx_stats_mutex);
3262         call->rprev = np->header.serial;
3263         rxi_calltrace(RX_TRACE_DROP, call);
3264         dpf(("packet %x dropped on receipt - quota problems", np));
3265         if (rxi_doreclaim)
3266             rxi_ClearReceiveQueue(call);
3267         clock_GetTime(&now);
3268         when = now;
3269         clock_Add(&when, &rx_softAckDelay);
3270         if (!call->delayedAckEvent
3271             || clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
3272             rxevent_Cancel(call->delayedAckEvent, call,
3273                            RX_CALL_REFCOUNT_DELAY);
3274             CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
3275             call->delayedAckEvent =
3276                 rxevent_PostNow(&when, &now, rxi_SendDelayedAck, call, 0);
3277         }
3278         /* we've damaged this call already, might as well do it in. */
3279         return np;
3280     }
3281 #endif /* KERNEL */
3282
3283     /*
3284      * New in AFS 3.5, if the RX_JUMBO_PACKET flag is set then this
3285      * packet is one of several packets transmitted as a single
3286      * datagram. Do not send any soft or hard acks until all packets
3287      * in a jumbogram have been processed. Send negative acks right away.
3288      */
3289     for (isFirst = 1, tnp = NULL; isFirst || tnp; isFirst = 0) {
3290         /* tnp is non-null when there are more packets in the
3291          * current jumbo gram */
3292         if (tnp) {
3293             if (np)
3294                 rxi_FreePacket(np);
3295             np = tnp;
3296         }
3297
3298         seq = np->header.seq;
3299         serial = np->header.serial;
3300         flags = np->header.flags;
3301
3302         /* If the call is in an error state, send an abort message */
3303         if (call->error)
3304             return rxi_SendCallAbort(call, np, istack, 0);
3305
3306         /* The RX_JUMBO_PACKET is set in all but the last packet in each
3307          * AFS 3.5 jumbogram. */
3308         if (flags & RX_JUMBO_PACKET) {
3309             tnp = rxi_SplitJumboPacket(np, host, port, isFirst);
3310         } else {
3311             tnp = NULL;
3312         }
3313
3314         if (np->header.spare != 0) {
3315             MUTEX_ENTER(&call->conn->conn_data_lock);
3316             call->conn->flags |= RX_CONN_USING_PACKET_CKSUM;
3317             MUTEX_EXIT(&call->conn->conn_data_lock);
3318         }
3319
3320         /* The usual case is that this is the expected next packet */
3321         if (seq == call->rnext) {
3322
3323             /* Check to make sure it is not a duplicate of one already queued */
3324             if (queue_IsNotEmpty(&call->rq)
3325                 && queue_First(&call->rq, rx_packet)->header.seq == seq) {
3326                 rx_MutexIncrement(rx_stats.dupPacketsRead, rx_stats_mutex);
3327                 dpf(("packet %x dropped on receipt - duplicate", np));
3328                 rxevent_Cancel(call->delayedAckEvent, call,
3329                                RX_CALL_REFCOUNT_DELAY);
3330                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3331                 ackNeeded = 0;
3332                 call->rprev = seq;
3333                 continue;
3334             }
3335
3336             /* It's the next packet. Stick it on the receive queue
3337              * for this call. Set newPackets to make sure we wake
3338              * the reader once all packets have been processed */
3339             np->flags |= RX_PKTFLAG_RQ;
3340             queue_Prepend(&call->rq, np);
3341             call->nSoftAcks++;
3342             np = NULL;          /* We can't use this anymore */
3343             newPackets = 1;
3344
3345             /* If an ack is requested then set a flag to make sure we
3346              * send an acknowledgement for this packet */
3347             if (flags & RX_REQUEST_ACK) {
3348                 ackNeeded = RX_ACK_REQUESTED;
3349             }
3350
3351             /* Keep track of whether we have received the last packet */
3352             if (flags & RX_LAST_PACKET) {
3353                 call->flags |= RX_CALL_HAVE_LAST;
3354                 haveLast = 1;
3355             }
3356
3357             /* Check whether we have all of the packets for this call */
3358             if (call->flags & RX_CALL_HAVE_LAST) {
3359                 afs_uint32 tseq;        /* temporary sequence number */
3360                 struct rx_packet *tp;   /* Temporary packet pointer */
3361                 struct rx_packet *nxp;  /* Next pointer, for queue_Scan */
3362
3363                 for (tseq = seq, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3364                     if (tseq != tp->header.seq)
3365                         break;
3366                     if (tp->header.flags & RX_LAST_PACKET) {
3367                         call->flags |= RX_CALL_RECEIVE_DONE;
3368                         break;
3369                     }
3370                     tseq++;
3371                 }
3372             }
3373
3374             /* Provide asynchronous notification for those who want it
3375              * (e.g. multi rx) */
3376             if (call->arrivalProc) {
3377                 (*call->arrivalProc) (call, call->arrivalProcHandle,
3378                                       call->arrivalProcArg);
3379                 call->arrivalProc = (void (*)())0;
3380             }
3381
3382             /* Update last packet received */
3383             call->rprev = seq;
3384
3385             /* If there is no server process serving this call, grab
3386              * one, if available. We only need to do this once. If a
3387              * server thread is available, this thread becomes a server
3388              * thread and the server thread becomes a listener thread. */
3389             if (isFirst) {
3390                 TryAttach(call, socket, tnop, newcallp, 0);
3391             }
3392         }
3393         /* This is not the expected next packet. */
3394         else {
3395             /* Determine whether this is a new or old packet, and if it's
3396              * a new one, whether it fits into the current receive window.
3397              * Also figure out whether the packet was delivered in sequence.
3398              * We use the prev variable to determine whether the new packet
3399              * is the successor of its immediate predecessor in the
3400              * receive queue, and the missing flag to determine whether
3401              * any of this packets predecessors are missing.  */
3402
3403             afs_uint32 prev;    /* "Previous packet" sequence number */
3404             struct rx_packet *tp;       /* Temporary packet pointer */
3405             struct rx_packet *nxp;      /* Next pointer, for queue_Scan */
3406             int missing;        /* Are any predecessors missing? */
3407
3408             /* If the new packet's sequence number has been sent to the
3409              * application already, then this is a duplicate */
3410             if (seq < call->rnext) {
3411                 rx_MutexIncrement(rx_stats.dupPacketsRead, rx_stats_mutex);
3412                 rxevent_Cancel(call->delayedAckEvent, call,
3413                                RX_CALL_REFCOUNT_DELAY);
3414                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3415                 ackNeeded = 0;
3416                 call->rprev = seq;
3417                 continue;
3418             }
3419
3420             /* If the sequence number is greater than what can be
3421              * accomodated by the current window, then send a negative
3422              * acknowledge and drop the packet */
3423             if ((call->rnext + call->rwind) <= seq) {
3424                 rxevent_Cancel(call->delayedAckEvent, call,
3425                                RX_CALL_REFCOUNT_DELAY);
3426                 np = rxi_SendAck(call, np, serial, RX_ACK_EXCEEDS_WINDOW,
3427                                  istack);
3428                 ackNeeded = 0;
3429                 call->rprev = seq;
3430                 continue;
3431             }
3432
3433             /* Look for the packet in the queue of old received packets */
3434             for (prev = call->rnext - 1, missing =
3435                  0, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3436                 /*Check for duplicate packet */
3437                 if (seq == tp->header.seq) {
3438                     rx_MutexIncrement(rx_stats.dupPacketsRead, rx_stats_mutex);
3439                     rxevent_Cancel(call->delayedAckEvent, call,
3440                                    RX_CALL_REFCOUNT_DELAY);
3441                     np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE,
3442                                      istack);
3443                     ackNeeded = 0;
3444                     call->rprev = seq;
3445                     goto nextloop;
3446                 }
3447                 /* If we find a higher sequence packet, break out and
3448                  * insert the new packet here. */
3449                 if (seq < tp->header.seq)
3450                     break;
3451                 /* Check for missing packet */
3452                 if (tp->header.seq != prev + 1) {
3453                     missing = 1;
3454                 }
3455
3456                 prev = tp->header.seq;
3457             }
3458
3459             /* Keep track of whether we have received the last packet. */
3460             if (flags & RX_LAST_PACKET) {
3461                 call->flags |= RX_CALL_HAVE_LAST;
3462             }
3463
3464             /* It's within the window: add it to the the receive queue.
3465              * tp is left by the previous loop either pointing at the
3466              * packet before which to insert the new packet, or at the
3467              * queue head if the queue is empty or the packet should be
3468              * appended. */
3469             queue_InsertBefore(tp, np);
3470             call->nSoftAcks++;
3471             np = NULL;
3472
3473             /* Check whether we have all of the packets for this call */
3474             if ((call->flags & RX_CALL_HAVE_LAST)
3475                 && !(call->flags & RX_CALL_RECEIVE_DONE)) {
3476                 afs_uint32 tseq;        /* temporary sequence number */
3477
3478                 for (tseq =
3479                      call->rnext, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3480                     if (tseq != tp->header.seq)
3481                         break;
3482                     if (tp->header.flags & RX_LAST_PACKET) {
3483                         call->flags |= RX_CALL_RECEIVE_DONE;
3484                         break;
3485                     }
3486                     tseq++;
3487                 }
3488             }
3489
3490             /* We need to send an ack of the packet is out of sequence, 
3491              * or if an ack was requested by the peer. */
3492             if (seq != prev + 1 || missing) {
3493                 ackNeeded = RX_ACK_OUT_OF_SEQUENCE;
3494             } else if (flags & RX_REQUEST_ACK) {
3495                 ackNeeded = RX_ACK_REQUESTED;
3496             }
3497
3498             /* Acknowledge the last packet for each call */
3499             if (flags & RX_LAST_PACKET) {
3500                 haveLast = 1;
3501             }
3502
3503             call->rprev = seq;
3504         }
3505       nextloop:;
3506     }
3507
3508     if (newPackets) {
3509         /*
3510          * If the receiver is waiting for an iovec, fill the iovec
3511          * using the data from the receive queue */
3512         if (call->flags & RX_CALL_IOVEC_WAIT) {
3513             didHardAck = rxi_FillReadVec(call, serial);
3514             /* the call may have been aborted */
3515             if (call->error) {
3516                 return NULL;
3517             }
3518             if (didHardAck) {
3519                 ackNeeded = 0;
3520             }
3521         }
3522
3523         /* Wakeup the reader if any */
3524         if ((call->flags & RX_CALL_READER_WAIT)
3525             && (!(call->flags & RX_CALL_IOVEC_WAIT) || !(call->iovNBytes)
3526                 || (call->iovNext >= call->iovMax)
3527                 || (call->flags & RX_CALL_RECEIVE_DONE))) {
3528             call->flags &= ~RX_CALL_READER_WAIT;
3529 #ifdef  RX_ENABLE_LOCKS
3530             CV_BROADCAST(&call->cv_rq);
3531 #else
3532             osi_rxWakeup(&call->rq);
3533 #endif
3534         }
3535     }
3536
3537     /*
3538      * Send an ack when requested by the peer, or once every
3539      * rxi_SoftAckRate packets until the last packet has been
3540      * received. Always send a soft ack for the last packet in
3541      * the server's reply. */
3542     if (ackNeeded) {
3543         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3544         np = rxi_SendAck(call, np, serial, ackNeeded, istack);
3545     } else if (call->nSoftAcks > (u_short) rxi_SoftAckRate) {
3546         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3547         np = rxi_SendAck(call, np, serial, RX_ACK_IDLE, istack);
3548     } else if (call->nSoftAcks) {
3549         clock_GetTime(&now);
3550         when = now;
3551         if (haveLast && !(flags & RX_CLIENT_INITIATED)) {
3552             clock_Add(&when, &rx_lastAckDelay);
3553         } else {
3554             clock_Add(&when, &rx_softAckDelay);
3555         }
3556         if (!call->delayedAckEvent
3557             || clock_Gt(&call->delayedAckEvent->eventTime, &when)) {
3558             rxevent_Cancel(call->delayedAckEvent, call,
3559                            RX_CALL_REFCOUNT_DELAY);
3560             CALL_HOLD(call, RX_CALL_REFCOUNT_DELAY);
3561             call->delayedAckEvent =
3562                 rxevent_PostNow(&when, &now, rxi_SendDelayedAck, call, 0);
3563         }
3564     } else if (call->flags & RX_CALL_RECEIVE_DONE) {
3565         rxevent_Cancel(call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
3566     }
3567
3568     return np;
3569 }
3570
3571 #ifdef  ADAPT_WINDOW
3572 static void rxi_ComputeRate();
3573 #endif
3574
3575 static void
3576 rxi_UpdatePeerReach(struct rx_connection *conn, struct rx_call *acall)
3577 {
3578     struct rx_peer *peer = conn->peer;
3579
3580     MUTEX_ENTER(&peer->peer_lock);
3581     peer->lastReachTime = clock_Sec();
3582     MUTEX_EXIT(&peer->peer_lock);
3583
3584     MUTEX_ENTER(&conn->conn_data_lock);
3585     if (conn->flags & RX_CONN_ATTACHWAIT) {
3586         int i;
3587
3588         conn->flags &= ~RX_CONN_ATTACHWAIT;
3589         MUTEX_EXIT(&conn->conn_data_lock);
3590
3591         for (i = 0; i < RX_MAXCALLS; i++) {
3592             struct rx_call *call = conn->call[i];
3593             if (call) {
3594                 if (call != acall)
3595                     MUTEX_ENTER(&call->lock);
3596                 /* tnop can be null if newcallp is null */
3597                 TryAttach(call, (osi_socket) - 1, NULL, NULL, 1);
3598                 if (call != acall)
3599                     MUTEX_EXIT(&call->lock);
3600             }
3601         }
3602     } else
3603         MUTEX_EXIT(&conn->conn_data_lock);
3604 }
3605
3606 static const char *
3607 rx_ack_reason(int reason)
3608 {
3609     switch (reason) {
3610     case RX_ACK_REQUESTED:
3611         return "requested";
3612     case RX_ACK_DUPLICATE:
3613         return "duplicate";
3614     case RX_ACK_OUT_OF_SEQUENCE:
3615         return "sequence";
3616     case RX_ACK_EXCEEDS_WINDOW:
3617         return "window";
3618     case RX_ACK_NOSPACE:
3619         return "nospace";
3620     case RX_ACK_PING:
3621         return "ping";
3622     case RX_ACK_PING_RESPONSE:
3623         return "response";
3624     case RX_ACK_DELAY:
3625         return "delay";
3626     case RX_ACK_IDLE:
3627         return "idle";
3628     default:
3629         return "unknown!!";
3630     }
3631 }
3632
3633
3634 /* rxi_ComputePeerNetStats
3635  *
3636  * Called exclusively by rxi_ReceiveAckPacket to compute network link
3637  * estimates (like RTT and throughput) based on ack packets.  Caller
3638  * must ensure that the packet in question is the right one (i.e.
3639  * serial number matches).
3640  */
3641 static void
3642 rxi_ComputePeerNetStats(struct rx_call *call, struct rx_packet *p,
3643                         struct rx_ackPacket *ap, struct rx_packet *np)
3644 {
3645     struct rx_peer *peer = call->conn->peer;
3646
3647     /* Use RTT if not delayed by client. */
3648     if (ap->reason != RX_ACK_DELAY)
3649         rxi_ComputeRoundTripTime(p, &p->timeSent, peer);
3650 #ifdef ADAPT_WINDOW
3651     rxi_ComputeRate(peer, call, p, np, ap->reason);
3652 #endif
3653 }
3654
3655 /* The real smarts of the whole thing.  */
3656 struct rx_packet *
3657 rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
3658                      int istack)
3659 {
3660     struct rx_ackPacket *ap;
3661     int nAcks;
3662     register struct rx_packet *tp;
3663     register struct rx_packet *nxp;     /* Next packet pointer for queue_Scan */
3664     register struct rx_connection *conn = call->conn;
3665     struct rx_peer *peer = conn->peer;
3666     afs_uint32 first;
3667     afs_uint32 serial;
3668     /* because there are CM's that are bogus, sending weird values for this. */
3669     afs_uint32 skew = 0;
3670     int nbytes;
3671     int missing;
3672     int acked;
3673     int nNacked = 0;
3674     int newAckCount = 0;
3675     u_short maxMTU = 0;         /* Set if peer supports AFS 3.4a jumbo datagrams */
3676     int maxDgramPackets = 0;    /* Set if peer supports AFS 3.5 jumbo datagrams */
3677
3678     rx_MutexIncrement(rx_stats.ackPacketsRead, rx_stats_mutex);
3679     ap = (struct rx_ackPacket *)rx_DataOf(np);
3680     nbytes = rx_Contiguous(np) - (int)((ap->acks) - (u_char *) ap);
3681     if (nbytes < 0)
3682         return np;              /* truncated ack packet */
3683
3684     /* depends on ack packet struct */
3685     nAcks = MIN((unsigned)nbytes, (unsigned)ap->nAcks);
3686     first = ntohl(ap->firstPacket);
3687     serial = ntohl(ap->serial);
3688     /* temporarily disabled -- needs to degrade over time 
3689      * skew = ntohs(ap->maxSkew); */
3690
3691     /* Ignore ack packets received out of order */
3692     if (first < call->tfirst) {
3693         return np;
3694     }
3695
3696     if (np->header.flags & RX_SLOW_START_OK) {
3697         call->flags |= RX_CALL_SLOW_START_OK;
3698     }
3699
3700     if (ap->reason == RX_ACK_PING_RESPONSE)
3701         rxi_UpdatePeerReach(conn, call);
3702
3703 #ifdef RXDEBUG
3704 #ifdef AFS_NT40_ENV
3705     if (rxdebug_active) {
3706         char msg[512];
3707         size_t len;
3708
3709         len = _snprintf(msg, sizeof(msg),
3710                         "tid[%d] RACK: reason %s serial %u previous %u seq %u skew %d first %u acks %u space %u ",
3711                          GetCurrentThreadId(), rx_ack_reason(ap->reason), 
3712                          ntohl(ap->serial), ntohl(ap->previousPacket),
3713                          (unsigned int)np->header.seq, (unsigned int)skew, 
3714                          ntohl(ap->firstPacket), ap->nAcks, ntohs(ap->bufferSpace) );
3715         if (nAcks) {
3716             int offset;
3717
3718             for (offset = 0; offset < nAcks && len < sizeof(msg); offset++) 
3719                 msg[len++] = (ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*');
3720         }
3721         msg[len++]='\n';
3722         msg[len] = '\0';
3723         OutputDebugString(msg);
3724     }
3725 #else /* AFS_NT40_ENV */
3726     if (rx_Log) {
3727         fprintf(rx_Log,
3728                 "RACK: reason %x previous %u seq %u serial %u skew %d first %u",
3729                 ap->reason, ntohl(ap->previousPacket),
3730                 (unsigned int)np->header.seq, (unsigned int)serial,
3731                 (unsigned int)skew, ntohl(ap->firstPacket));
3732         if (nAcks) {
3733             int offset;
3734             for (offset = 0; offset < nAcks; offset++)
3735                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
3736                      rx_Log);
3737         }
3738         putc('\n', rx_Log);
3739     }
3740 #endif /* AFS_NT40_ENV */
3741 #endif
3742
3743     /* Update the outgoing packet skew value to the latest value of
3744      * the peer's incoming packet skew value.  The ack packet, of
3745      * course, could arrive out of order, but that won't affect things
3746      * much */
3747     MUTEX_ENTER(&peer->peer_lock);
3748     peer->outPacketSkew = skew;
3749
3750     /* Check for packets that no longer need to be transmitted, and
3751      * discard them.  This only applies to packets positively
3752      * acknowledged as having been sent to the peer's upper level.
3753      * All other packets must be retained.  So only packets with
3754      * sequence numbers < ap->firstPacket are candidates. */
3755     for (queue_Scan(&call->tq, tp, nxp, rx_packet)) {
3756         if (tp->header.seq >= first)
3757             break;
3758         call->tfirst = tp->header.seq + 1;
3759         if (serial
3760             && (tp->header.serial == serial || tp->firstSerial == serial))
3761             rxi_ComputePeerNetStats(call, tp, ap, np);
3762         if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3763             newAckCount++;
3764         }
3765 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3766         /* XXX Hack. Because we have to release the global rx lock when sending
3767          * packets (osi_NetSend) we drop all acks while we're traversing the tq
3768          * in rxi_Start sending packets out because packets may move to the
3769          * freePacketQueue as result of being here! So we drop these packets until
3770          * we're safely out of the traversing. Really ugly! 
3771          * To make it even uglier, if we're using fine grain locking, we can
3772          * set the ack bits in the packets and have rxi_Start remove the packets
3773          * when it's done transmitting.
3774          */
3775         if (call->flags & RX_CALL_TQ_BUSY) {
3776 #ifdef RX_ENABLE_LOCKS
3777             tp->flags |= RX_PKTFLAG_ACKED;
3778             call->flags |= RX_CALL_TQ_SOME_ACKED;
3779 #else /* RX_ENABLE_LOCKS */
3780             break;
3781 #endif /* RX_ENABLE_LOCKS */
3782         } else
3783 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3784         {
3785             queue_Remove(tp);
3786             tp->flags &= ~RX_PKTFLAG_TQ;
3787             rxi_FreePacket(tp); /* rxi_FreePacket mustn't wake up anyone, preemptively. */
3788         }
3789     }
3790
3791 #ifdef ADAPT_WINDOW
3792     /* Give rate detector a chance to respond to ping requests */
3793     if (ap->reason == RX_ACK_PING_RESPONSE) {
3794         rxi_ComputeRate(peer, call, 0, np, ap->reason);
3795     }
3796 #endif
3797
3798     /* N.B. we don't turn off any timers here.  They'll go away by themselves, anyway */
3799
3800     /* Now go through explicit acks/nacks and record the results in
3801      * the waiting packets.  These are packets that can't be released
3802      * yet, even with a positive acknowledge.  This positive
3803      * acknowledge only means the packet has been received by the
3804      * peer, not that it will be retained long enough to be sent to
3805      * the peer's upper level.  In addition, reset the transmit timers
3806      * of any missing packets (those packets that must be missing
3807      * because this packet was out of sequence) */
3808
3809     call->nSoftAcked = 0;
3810     for (missing = 0, queue_Scan(&call->tq, tp, nxp, rx_packet)) {
3811         /* Update round trip time if the ack was stimulated on receipt
3812          * of this packet */
3813 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
3814 #ifdef RX_ENABLE_LOCKS
3815         if (tp->header.seq >= first)
3816 #endif /* RX_ENABLE_LOCKS */
3817 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3818             if (serial
3819                 && (tp->header.serial == serial || tp->firstSerial == serial))
3820                 rxi_ComputePeerNetStats(call, tp, ap, np);
3821
3822         /* Set the acknowledge flag per packet based on the
3823          * information in the ack packet. An acknowlegded packet can
3824          * be downgraded when the server has discarded a packet it
3825          * soacked previously, or when an ack packet is received
3826          * out of sequence. */
3827         if (tp->header.seq < first) {
3828             /* Implicit ack information */
3829             if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3830                 newAckCount++;
3831             }
3832             tp->flags |= RX_PKTFLAG_ACKED;
3833         } else if (tp->header.seq < first + nAcks) {
3834             /* Explicit ack information:  set it in the packet appropriately */
3835             if (ap->acks[tp->header.seq - first] == RX_ACK_TYPE_ACK) {
3836                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
3837                     newAckCount++;
3838                     tp->flags |= RX_PKTFLAG_ACKED;
3839                 }
3840                 if (missing) {
3841                     nNacked++;
3842                 } else {
3843                     call->nSoftAcked++;
3844                 }
3845             } else /* RX_ACK_TYPE_NACK */ {
3846                 tp->flags &= ~RX_PKTFLAG_ACKED;
3847                 missing = 1;
3848             }
3849         } else {
3850             tp->flags &= ~RX_PKTFLAG_ACKED;
3851             missing = 1;
3852         }
3853
3854         /* If packet isn't yet acked, and it has been transmitted at least 
3855          * once, reset retransmit time using latest timeout 
3856          * ie, this should readjust the retransmit timer for all outstanding 
3857          * packets...  So we don't just retransmit when we should know better*/
3858
3859         if (!(tp->flags & RX_PKTFLAG_ACKED) && !clock_IsZero(&tp->retryTime)) {
3860             tp->retryTime = tp->timeSent;
3861             clock_Add(&tp->retryTime, &peer->timeout);
3862             /* shift by eight because one quarter-sec ~ 256 milliseconds */
3863             clock_Addmsec(&(tp->retryTime), ((afs_uint32) tp->backoff) << 8);
3864         }
3865     }
3866
3867     /* If the window has been extended by this acknowledge packet,
3868      * then wakeup a sender waiting in alloc for window space, or try
3869      * sending packets now, if he's been sitting on packets due to
3870      * lack of window space */
3871     if (call->tnext < (call->tfirst + call->twind)) {
3872 #ifdef  RX_ENABLE_LOCKS
3873         CV_SIGNAL(&call->cv_twind);
3874 #else
3875         if (call->flags & RX_CALL_WAIT_WINDOW_ALLOC) {
3876             call->flags &= ~RX_CALL_WAIT_WINDOW_ALLOC;
3877             osi_rxWakeup(&call->twind);
3878         }
3879 #endif
3880         if (call->flags & RX_CALL_WAIT_WINDOW_SEND) {
3881             call->flags &= ~RX_CALL_WAIT_WINDOW_SEND;
3882         }
3883     }
3884
3885     /* if the ack packet has a receivelen field hanging off it,
3886      * update our state */
3887     if (np->length >= rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32)) {
3888         afs_uint32 tSize;
3889
3890         /* If the ack packet has a "recommended" size that is less than 
3891          * what I am using now, reduce my size to match */
3892         rx_packetread(np, rx_AckDataSize(ap->nAcks) + sizeof(afs_int32),
3893                       (int)sizeof(afs_int32), &tSize);
3894         tSize = (afs_uint32) ntohl(tSize);
3895         peer->natMTU = rxi_AdjustIfMTU(MIN(tSize, peer->ifMTU));
3896
3897         /* Get the maximum packet size to send to this peer */
3898         rx_packetread(np, rx_AckDataSize(ap->nAcks), (int)sizeof(afs_int32),
3899                       &tSize);
3900         tSize = (afs_uint32) ntohl(tSize);
3901         tSize = (afs_uint32) MIN(tSize, rx_MyMaxSendSize);
3902         tSize = rxi_AdjustMaxMTU(peer->natMTU, tSize);
3903
3904         /* sanity check - peer might have restarted with different params.
3905          * If peer says "send less", dammit, send less...  Peer should never 
3906          * be unable to accept packets of the size that prior AFS versions would
3907          * send without asking.  */
3908         if (peer->maxMTU != tSize) {
3909             if (peer->maxMTU > tSize) /* possible cong., maxMTU decreased */
3910                 peer->congestSeq++;
3911             peer->maxMTU = tSize;
3912             peer->MTU = MIN(tSize, peer->MTU);
3913             call->MTU = MIN(call->MTU, tSize);
3914         }
3915
3916         if (np->length == rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32)) {
3917             /* AFS 3.4a */
3918             rx_packetread(np,
3919                           rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
3920                           (int)sizeof(afs_int32), &tSize);
3921             tSize = (afs_uint32) ntohl(tSize);  /* peer's receive window, if it's */
3922             if (tSize < call->twind) {  /* smaller than our send */
3923                 call->twind = tSize;    /* window, we must send less... */
3924                 call->ssthresh = MIN(call->twind, call->ssthresh);
3925                 call->conn->twind[call->channel] = call->twind;
3926             }
3927
3928             /* Only send jumbograms to 3.4a fileservers. 3.3a RX gets the
3929              * network MTU confused with the loopback MTU. Calculate the
3930              * maximum MTU here for use in the slow start code below.
3931              */
3932             maxMTU = peer->maxMTU;
3933             /* Did peer restart with older RX version? */
3934             if (peer->maxDgramPackets > 1) {
3935                 peer->maxDgramPackets = 1;
3936             }
3937         } else if (np->length >=
3938                    rx_AckDataSize(ap->nAcks) + 4 * sizeof(afs_int32)) {
3939             /* AFS 3.5 */
3940             rx_packetread(np,
3941                           rx_AckDataSize(ap->nAcks) + 2 * sizeof(afs_int32),
3942                           sizeof(afs_int32), &tSize);
3943             tSize = (afs_uint32) ntohl(tSize);
3944             /*
3945              * As of AFS 3.5 we set the send window to match the receive window. 
3946              */
3947             if (tSize < call->twind) {
3948                 call->twind = tSize;
3949                 call->conn->twind[call->channel] = call->twind;
3950                 call->ssthresh = MIN(call->twind, call->ssthresh);
3951             } else if (tSize > call->twind) {
3952                 call->twind = tSize;
3953                 call->conn->twind[call->channel] = call->twind;
3954             }
3955
3956             /*
3957              * As of AFS 3.5, a jumbogram is more than one fixed size
3958              * packet transmitted in a single UDP datagram. If the remote
3959              * MTU is smaller than our local MTU then never send a datagram
3960              * larger than the natural MTU.
3961              */
3962             rx_packetread(np,
3963                           rx_AckDataSize(ap->nAcks) + 3 * sizeof(afs_int32),
3964                           sizeof(afs_int32), &tSize);
3965             maxDgramPackets = (afs_uint32) ntohl(tSize);
3966             maxDgramPackets = MIN(maxDgramPackets, rxi_nDgramPackets);
3967             maxDgramPackets = MIN(maxDgramPackets, peer->ifDgramPackets);
3968             if (peer->natMTU < peer->ifMTU)
3969                 maxDgramPackets = MIN(maxDgramPackets, rxi_AdjustDgramPackets(1, peer->natMTU));
3970             if (maxDgramPackets > 1) {
3971                 peer->maxDgramPackets = maxDgramPackets;
3972                 call->MTU = RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE;
3973             } else {
3974                 peer->maxDgramPackets = 1;
3975                 call->MTU = peer->natMTU;
3976             }
3977         } else if (peer->maxDgramPackets > 1) {
3978             /* Restarted with lower version of RX */
3979             peer->maxDgramPackets = 1;
3980         }
3981     } else if (peer->maxDgramPackets > 1
3982                || peer->maxMTU != OLD_MAX_PACKET_SIZE) {
3983         /* Restarted with lower version of RX */
3984         peer->maxMTU = OLD_MAX_PACKET_SIZE;
3985         peer->natMTU = OLD_MAX_PACKET_SIZE;
3986         peer->MTU = OLD_MAX_PACKET_SIZE;
3987         peer->maxDgramPackets = 1;
3988         peer->nDgramPackets = 1;
3989         peer->congestSeq++;
3990         call->MTU = OLD_MAX_PACKET_SIZE;
3991     }
3992
3993     if (nNacked) {
3994         /*
3995          * Calculate how many datagrams were successfully received after
3996          * the first missing packet and adjust the negative ack counter
3997          * accordingly.
3998          */
3999         call->nAcks = 0;
4000         call->nNacks++;
4001         nNacked = (nNacked + call->nDgramPackets - 1) / call->nDgramPackets;
4002         if (call->nNacks < nNacked) {
4003             call->nNacks = nNacked;
4004         }
4005     } else {
4006         call->nAcks += newAckCount;
4007         call->nNacks = 0;
4008     }
4009
4010     if (call->flags & RX_CALL_FAST_RECOVER) {
4011         if (nNacked) {
4012             call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
4013         } else {
4014             call->flags &= ~RX_CALL_FAST_RECOVER;
4015             call->cwind = call->nextCwind;
4016             call->nextCwind = 0;
4017             call->nAcks = 0;
4018         }
4019         call->nCwindAcks = 0;
4020     } else if (nNacked && call->nNacks >= (u_short) rx_nackThreshold) {
4021         /* Three negative acks in a row trigger congestion recovery */
4022 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4023         MUTEX_EXIT(&peer->peer_lock);
4024         if (call->flags & RX_CALL_FAST_RECOVER_WAIT) {
4025             /* someone else is waiting to start recovery */
4026             return np;
4027         }
4028         call->flags |= RX_CALL_FAST_RECOVER_WAIT;
4029         rxi_WaitforTQBusy(call);
4030         MUTEX_ENTER(&peer->peer_lock);
4031 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
4032         call->flags &= ~RX_CALL_FAST_RECOVER_WAIT;
4033         call->flags |= RX_CALL_FAST_RECOVER;
4034         call->ssthresh = MAX(4, MIN((int)call->cwind, (int)call->twind)) >> 1;
4035         call->cwind =
4036             MIN((int)(call->ssthresh + rx_nackThreshold), rx_maxSendWindow);
4037         call->nDgramPackets = MAX(2, (int)call->nDgramPackets) >> 1;
4038         call->nextCwind = call->ssthresh;
4039         call->nAcks = 0;
4040         call->nNacks = 0;
4041         peer->MTU = call->MTU;
4042         peer->cwind = call->nextCwind;
4043         peer->nDgramPackets = call->nDgramPackets;
4044         peer->congestSeq++;
4045         call->congestSeq = peer->congestSeq;
4046         /* Reset the resend times on the packets that were nacked
4047          * so we will retransmit as soon as the window permits*/
4048         for (acked = 0, queue_ScanBackwards(&call->tq, tp, nxp, rx_packet)) {
4049             if (acked) {
4050                 if (!(tp->flags & RX_PKTFLAG_ACKED)) {
4051                     clock_Zero(&tp->retryTime);
4052                 }
4053             } else if (tp->flags & RX_PKTFLAG_ACKED) {
4054                 acked = 1;
4055             }
4056         }
4057     } else {
4058         /* If cwind is smaller than ssthresh, then increase
4059          * the window one packet for each ack we receive (exponential
4060          * growth).
4061          * If cwind is greater than or equal to ssthresh then increase
4062          * the congestion window by one packet for each cwind acks we
4063          * receive (linear growth).  */
4064         if (call->cwind < call->ssthresh) {
4065             call->cwind =
4066                 MIN((int)call->ssthresh, (int)(call->cwind + newAckCount));
4067             call->nCwindAcks = 0;
4068         } else {
4069             call->nCwindAcks += newAckCount;
4070             if (call->nCwindAcks >= call->cwind) {
4071                 call->nCwindAcks = 0;
4072                 call->cwind = MIN((int)(call->cwind + 1), rx_maxSendWindow);
4073             }
4074         }
4075         /*
4076          * If we have received several acknowledgements in a row then
4077          * it is time to increase the size of our datagrams
4078          */
4079         if ((int)call->nAcks > rx_nDgramThreshold) {
4080             if (peer->maxDgramPackets > 1) {
4081                 if (call->nDgramPackets < peer->maxDgramPackets) {
4082                     call->nDgramPackets++;
4083                 }
4084                 call->MTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE;
4085             } else if (call->MTU < peer->maxMTU) {
4086                 call->MTU += peer->natMTU;
4087                 call->MTU = MIN(call->MTU, peer->maxMTU);
4088             }
4089             call->nAcks = 0;
4090         }
4091     }
4092
4093     MUTEX_EXIT(&peer->peer_lock);       /* rxi_Start will lock peer. */
4094
4095     /* Servers need to hold the call until all response packets have
4096      * been acknowledged. Soft acks are good enough since clients
4097      * are not allowed to clear their receive queues. */
4098     if (call->state == RX_STATE_HOLD
4099         && call->tfirst + call->nSoftAcked >= call->tnext) {
4100         call->state = RX_STATE_DALLY;
4101         rxi_ClearTransmitQueue(call, 0);
4102         rxevent_Cancel(call->keepAliveEvent, call, RX_CALL_REFCOUNT_ALIVE);
4103     } else if (!queue_IsEmpty(&call->tq)) {
4104         rxi_Start(0, call, 0, istack);
4105     }
4106     return np;
4107 }
4108
4109 /* Received a response to a challenge packet */
4110 struct rx_packet *
4111 rxi_ReceiveResponsePacket(register struct rx_connection *conn,
4112                           register struct rx_packet *np, int istack)
4113 {
4114     int error;
4115
4116     /* Ignore the packet if we're the client */
4117     if (conn->type == RX_CLIENT_CONNECTION)
4118         return np;
4119