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