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