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