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