afs: release the packets used by rx on shutdown
[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             MUTEX_EXIT(&call->lock);
2375             rxi_FlushWrite(call);
2376             MUTEX_ENTER(&call->lock);
2377         }
2378         rxi_calltrace(RX_CALL_END, call);
2379         /* Call goes to hold state until reply packets are acknowledged */
2380         if (call->tfirst + call->nSoftAcked < call->tnext) {
2381             call->state = RX_STATE_HOLD;
2382         } else {
2383             call->state = RX_STATE_DALLY;
2384             rxi_ClearTransmitQueue(call, 0);
2385             rxi_rto_cancel(call);
2386             rxi_CancelKeepAliveEvent(call);
2387         }
2388     } else {                    /* Client connection */
2389         char dummy;
2390         /* Make sure server receives input packets, in the case where
2391          * no reply arguments are expected */
2392
2393         if ((call->app.mode == RX_MODE_SENDING)
2394             || (call->app.mode == RX_MODE_RECEIVING && call->rnext == 1)) {
2395             MUTEX_EXIT(&call->lock);
2396             (void)rxi_ReadProc(call, &dummy, 1);
2397             MUTEX_ENTER(&call->lock);
2398         }
2399
2400         /* If we had an outstanding delayed ack, be nice to the server
2401          * and force-send it now.
2402          */
2403         if (call->delayedAckEvent) {
2404             rxi_CancelDelayedAckEvent(call);
2405             rxi_SendDelayedAck(NULL, call, NULL, 0);
2406         }
2407
2408         /* We need to release the call lock since it's lower than the
2409          * conn_call_lock and we don't want to hold the conn_call_lock
2410          * over the rx_ReadProc call. The conn_call_lock needs to be held
2411          * here for the case where rx_NewCall is perusing the calls on
2412          * the connection structure. We don't want to signal until
2413          * rx_NewCall is in a stable state. Otherwise, rx_NewCall may
2414          * have checked this call, found it active and by the time it
2415          * goes to sleep, will have missed the signal.
2416          */
2417         MUTEX_EXIT(&call->lock);
2418         MUTEX_ENTER(&conn->conn_call_lock);
2419         MUTEX_ENTER(&call->lock);
2420
2421         if (!call->error) {
2422             /* While there are some circumstances where a call with an error is
2423              * obviously not on a "busy" channel, be conservative (clearing
2424              * lastBusy is just best-effort to possibly speed up rx_NewCall).
2425              * The call channel is definitely not busy if we just successfully
2426              * completed a call on it. */
2427             conn->lastBusy[call->channel] = 0;
2428
2429         } else if (call->error == RX_CALL_TIMEOUT) {
2430             /* The call is still probably running on the server side, so try to
2431              * avoid this call channel in the future. */
2432             conn->lastBusy[call->channel] = clock_Sec();
2433         }
2434
2435         MUTEX_ENTER(&conn->conn_data_lock);
2436         conn->flags |= RX_CONN_BUSY;
2437         if (conn->flags & RX_CONN_MAKECALL_WAITING) {
2438             MUTEX_EXIT(&conn->conn_data_lock);
2439 #ifdef  RX_ENABLE_LOCKS
2440             CV_BROADCAST(&conn->conn_call_cv);
2441 #else
2442             osi_rxWakeup(conn);
2443 #endif
2444         }
2445 #ifdef RX_ENABLE_LOCKS
2446         else {
2447             MUTEX_EXIT(&conn->conn_data_lock);
2448         }
2449 #endif /* RX_ENABLE_LOCKS */
2450         call->state = RX_STATE_DALLY;
2451     }
2452     error = call->error;
2453
2454     /* currentPacket, nLeft, and NFree must be zeroed here, because
2455      * ResetCall cannot: ResetCall may be called at splnet(), in the
2456      * kernel version, and may interrupt the macros rx_Read or
2457      * rx_Write, which run at normal priority for efficiency. */
2458     if (call->app.currentPacket) {
2459 #ifdef RX_TRACK_PACKETS
2460         call->app.currentPacket->flags &= ~RX_PKTFLAG_CP;
2461 #endif
2462         rxi_FreePacket(call->app.currentPacket);
2463         call->app.currentPacket = (struct rx_packet *)0;
2464     }
2465
2466     call->app.nLeft = call->app.nFree = call->app.curlen = 0;
2467
2468     /* Free any packets from the last call to ReadvProc/WritevProc */
2469 #ifdef RXDEBUG_PACKET
2470     call->iovqc -=
2471 #endif /* RXDEBUG_PACKET */
2472         rxi_FreePackets(0, &call->app.iovq);
2473     MUTEX_EXIT(&call->lock);
2474
2475     CALL_RELE(call, RX_CALL_REFCOUNT_BEGIN);
2476     if (conn->type == RX_CLIENT_CONNECTION) {
2477         MUTEX_ENTER(&conn->conn_data_lock);
2478         conn->flags &= ~RX_CONN_BUSY;
2479         MUTEX_EXIT(&conn->conn_data_lock);
2480         MUTEX_EXIT(&conn->conn_call_lock);
2481     }
2482     USERPRI;
2483     /*
2484      * Map errors to the local host's errno.h format.
2485      */
2486     error = ntoh_syserr_conv(error);
2487
2488     /* If the caller said the call failed with some error, we had better
2489      * return an error code. */
2490     osi_Assert(!rc || error);
2491     return error;
2492 }
2493
2494 #if !defined(KERNEL)
2495
2496 /* Call this routine when shutting down a server or client (especially
2497  * clients).  This will allow Rx to gracefully garbage collect server
2498  * connections, and reduce the number of retries that a server might
2499  * make to a dead client.
2500  * This is not quite right, since some calls may still be ongoing and
2501  * we can't lock them to destroy them. */
2502 void
2503 rx_Finalize(void)
2504 {
2505     struct rx_connection **conn_ptr, **conn_end;
2506
2507     INIT_PTHREAD_LOCKS;
2508     if (rx_atomic_test_and_set_bit(&rxinit_status, 0))
2509         return;                 /* Already shutdown. */
2510
2511     rxi_DeleteCachedConnections();
2512     if (rx_connHashTable) {
2513         MUTEX_ENTER(&rx_connHashTable_lock);
2514         for (conn_ptr = &rx_connHashTable[0], conn_end =
2515              &rx_connHashTable[rx_hashTableSize]; conn_ptr < conn_end;
2516              conn_ptr++) {
2517             struct rx_connection *conn, *next;
2518             for (conn = *conn_ptr; conn; conn = next) {
2519                 next = conn->next;
2520                 if (conn->type == RX_CLIENT_CONNECTION) {
2521                     MUTEX_ENTER(&rx_refcnt_mutex);
2522                     conn->refCount++;
2523                     MUTEX_EXIT(&rx_refcnt_mutex);
2524 #ifdef RX_ENABLE_LOCKS
2525                     rxi_DestroyConnectionNoLock(conn);
2526 #else /* RX_ENABLE_LOCKS */
2527                     rxi_DestroyConnection(conn);
2528 #endif /* RX_ENABLE_LOCKS */
2529                 }
2530             }
2531         }
2532 #ifdef RX_ENABLE_LOCKS
2533         while (rx_connCleanup_list) {
2534             struct rx_connection *conn;
2535             conn = rx_connCleanup_list;
2536             rx_connCleanup_list = rx_connCleanup_list->next;
2537             MUTEX_EXIT(&rx_connHashTable_lock);
2538             rxi_CleanupConnection(conn);
2539             MUTEX_ENTER(&rx_connHashTable_lock);
2540         }
2541         MUTEX_EXIT(&rx_connHashTable_lock);
2542 #endif /* RX_ENABLE_LOCKS */
2543     }
2544     rxi_flushtrace();
2545
2546 #ifdef AFS_NT40_ENV
2547     afs_winsockCleanup();
2548 #endif
2549
2550 }
2551 #endif
2552
2553 /* if we wakeup packet waiter too often, can get in loop with two
2554     AllocSendPackets each waking each other up (from ReclaimPacket calls) */
2555 void
2556 rxi_PacketsUnWait(void)
2557 {
2558     if (!rx_waitingForPackets) {
2559         return;
2560     }
2561 #ifdef KERNEL
2562     if (rxi_OverQuota(RX_PACKET_CLASS_SEND)) {
2563         return;                 /* still over quota */
2564     }
2565 #endif /* KERNEL */
2566     rx_waitingForPackets = 0;
2567 #ifdef  RX_ENABLE_LOCKS
2568     CV_BROADCAST(&rx_waitingForPackets_cv);
2569 #else
2570     osi_rxWakeup(&rx_waitingForPackets);
2571 #endif
2572     return;
2573 }
2574
2575
2576 /* ------------------Internal interfaces------------------------- */
2577
2578 /* Return this process's service structure for the
2579  * specified socket and service */
2580 static struct rx_service *
2581 rxi_FindService(osi_socket socket, u_short serviceId)
2582 {
2583     struct rx_service **sp;
2584     for (sp = &rx_services[0]; *sp; sp++) {
2585         if ((*sp)->serviceId == serviceId && (*sp)->socket == socket)
2586             return *sp;
2587     }
2588     return 0;
2589 }
2590
2591 #ifdef RXDEBUG_PACKET
2592 #ifdef KDUMP_RX_LOCK
2593 static struct rx_call_rx_lock *rx_allCallsp = 0;
2594 #else
2595 static struct rx_call *rx_allCallsp = 0;
2596 #endif
2597 #endif /* RXDEBUG_PACKET */
2598
2599 /* Allocate a call structure, for the indicated channel of the
2600  * supplied connection.  The mode and state of the call must be set by
2601  * the caller. Returns the call with mutex locked. */
2602 static struct rx_call *
2603 rxi_NewCall(struct rx_connection *conn, int channel)
2604 {
2605     struct rx_call *call;
2606 #ifdef RX_ENABLE_LOCKS
2607     struct rx_call *cp; /* Call pointer temp */
2608     struct opr_queue *cursor;
2609 #endif
2610
2611     dpf(("rxi_NewCall(conn %"AFS_PTR_FMT", channel %d)\n", conn, channel));
2612
2613     /* Grab an existing call structure, or allocate a new one.
2614      * Existing call structures are assumed to have been left reset by
2615      * rxi_FreeCall */
2616     MUTEX_ENTER(&rx_freeCallQueue_lock);
2617
2618 #ifdef RX_ENABLE_LOCKS
2619     /*
2620      * EXCEPT that the TQ might not yet be cleared out.
2621      * Skip over those with in-use TQs.
2622      */
2623     call = NULL;
2624     for (opr_queue_Scan(&rx_freeCallQueue, cursor)) {
2625         cp = opr_queue_Entry(cursor, struct rx_call, entry);
2626         if (!(cp->flags & RX_CALL_TQ_BUSY)) {
2627             call = cp;
2628             break;
2629         }
2630     }
2631     if (call) {
2632 #else /* RX_ENABLE_LOCKS */
2633     if (!opr_queue_IsEmpty(&rx_freeCallQueue)) {
2634         call = opr_queue_First(&rx_freeCallQueue, struct rx_call, entry);
2635 #endif /* RX_ENABLE_LOCKS */
2636         opr_queue_Remove(&call->entry);
2637         if (rx_stats_active)
2638             rx_atomic_dec(&rx_stats.nFreeCallStructs);
2639         MUTEX_EXIT(&rx_freeCallQueue_lock);
2640         MUTEX_ENTER(&call->lock);
2641         CLEAR_CALL_QUEUE_LOCK(call);
2642 #ifdef RX_ENABLE_LOCKS
2643         /* Now, if TQ wasn't cleared earlier, do it now. */
2644         rxi_WaitforTQBusy(call);
2645         if (call->flags & RX_CALL_TQ_CLEARME) {
2646             rxi_ClearTransmitQueue(call, 1);
2647             /*queue_Init(&call->tq);*/
2648         }
2649 #endif /* RX_ENABLE_LOCKS */
2650         /* Bind the call to its connection structure */
2651         call->conn = conn;
2652         rxi_ResetCall(call, 1);
2653     } else {
2654
2655         call = rxi_Alloc(sizeof(struct rx_call));
2656 #ifdef RXDEBUG_PACKET
2657         call->allNextp = rx_allCallsp;
2658         rx_allCallsp = call;
2659         call->call_id =
2660             rx_atomic_inc_and_read(&rx_stats.nCallStructs);
2661 #else /* RXDEBUG_PACKET */
2662         rx_atomic_inc(&rx_stats.nCallStructs);
2663 #endif /* RXDEBUG_PACKET */
2664
2665         MUTEX_EXIT(&rx_freeCallQueue_lock);
2666         MUTEX_INIT(&call->lock, "call lock", MUTEX_DEFAULT, NULL);
2667         MUTEX_ENTER(&call->lock);
2668         CV_INIT(&call->cv_twind, "call twind", CV_DEFAULT, 0);
2669         CV_INIT(&call->cv_rq, "call rq", CV_DEFAULT, 0);
2670         CV_INIT(&call->cv_tq, "call tq", CV_DEFAULT, 0);
2671
2672         /* Initialize once-only items */
2673         opr_queue_Init(&call->tq);
2674         opr_queue_Init(&call->rq);
2675         opr_queue_Init(&call->app.iovq);
2676 #ifdef RXDEBUG_PACKET
2677         call->rqc = call->tqc = call->iovqc = 0;
2678 #endif /* RXDEBUG_PACKET */
2679         /* Bind the call to its connection structure (prereq for reset) */
2680         call->conn = conn;
2681         rxi_ResetCall(call, 1);
2682     }
2683     call->channel = channel;
2684     call->callNumber = &conn->callNumber[channel];
2685     call->rwind = conn->rwind[channel];
2686     call->twind = conn->twind[channel];
2687     /* Note that the next expected call number is retained (in
2688      * conn->callNumber[i]), even if we reallocate the call structure
2689      */
2690     conn->call[channel] = call;
2691     /* if the channel's never been used (== 0), we should start at 1, otherwise
2692      * the call number is valid from the last time this channel was used */
2693     if (*call->callNumber == 0)
2694         *call->callNumber = 1;
2695
2696     return call;
2697 }
2698
2699 /* A call has been inactive long enough that so we can throw away
2700  * state, including the call structure, which is placed on the call
2701  * free list.
2702  *
2703  * call->lock amd rx_refcnt_mutex are held upon entry.
2704  * haveCTLock is set when called from rxi_ReapConnections.
2705  *
2706  * return 1 if the call is freed, 0 if not.
2707  */
2708 static int
2709 rxi_FreeCall(struct rx_call *call, int haveCTLock)
2710 {
2711     int channel = call->channel;
2712     struct rx_connection *conn = call->conn;
2713     u_char state = call->state;
2714
2715     /*
2716      * We are setting the state to RX_STATE_RESET to
2717      * ensure that no one else will attempt to use this
2718      * call once we drop the refcnt lock. We must drop
2719      * the refcnt lock before calling rxi_ResetCall
2720      * because it cannot be held across acquiring the
2721      * freepktQ lock. NewCall does the same.
2722      */
2723     call->state = RX_STATE_RESET;
2724     MUTEX_EXIT(&rx_refcnt_mutex);
2725     rxi_ResetCall(call, 0);
2726
2727     if (MUTEX_TRYENTER(&conn->conn_call_lock))
2728     {
2729         if (state == RX_STATE_DALLY || state == RX_STATE_HOLD)
2730             (*call->callNumber)++;
2731
2732         if (call->conn->call[channel] == call)
2733             call->conn->call[channel] = 0;
2734         MUTEX_EXIT(&conn->conn_call_lock);
2735     } else {
2736         /*
2737          * We couldn't obtain the conn_call_lock so we can't
2738          * disconnect the call from the connection.  Set the
2739          * call state to dally so that the call can be reused.
2740          */
2741         MUTEX_ENTER(&rx_refcnt_mutex);
2742         call->state = RX_STATE_DALLY;
2743         return 0;
2744     }
2745
2746     MUTEX_ENTER(&rx_freeCallQueue_lock);
2747     SET_CALL_QUEUE_LOCK(call, &rx_freeCallQueue_lock);
2748 #ifdef RX_ENABLE_LOCKS
2749     /* A call may be free even though its transmit queue is still in use.
2750      * Since we search the call list from head to tail, put busy calls at
2751      * the head of the list, and idle calls at the tail.
2752      */
2753     if (call->flags & RX_CALL_TQ_BUSY)
2754         opr_queue_Prepend(&rx_freeCallQueue, &call->entry);
2755     else
2756         opr_queue_Append(&rx_freeCallQueue, &call->entry);
2757 #else /* RX_ENABLE_LOCKS */
2758     opr_queue_Append(&rx_freeCallQueue, &call->entry);
2759 #endif /* RX_ENABLE_LOCKS */
2760     if (rx_stats_active)
2761         rx_atomic_inc(&rx_stats.nFreeCallStructs);
2762     MUTEX_EXIT(&rx_freeCallQueue_lock);
2763
2764     /* Destroy the connection if it was previously slated for
2765      * destruction, i.e. the Rx client code previously called
2766      * rx_DestroyConnection (client connections), or
2767      * rxi_ReapConnections called the same routine (server
2768      * connections).  Only do this, however, if there are no
2769      * outstanding calls. Note that for fine grain locking, there appears
2770      * to be a deadlock in that rxi_FreeCall has a call locked and
2771      * DestroyConnectionNoLock locks each call in the conn. But note a
2772      * few lines up where we have removed this call from the conn.
2773      * If someone else destroys a connection, they either have no
2774      * call lock held or are going through this section of code.
2775      */
2776     MUTEX_ENTER(&conn->conn_data_lock);
2777     if (conn->flags & RX_CONN_DESTROY_ME && !(conn->flags & RX_CONN_MAKECALL_WAITING)) {
2778         MUTEX_ENTER(&rx_refcnt_mutex);
2779         conn->refCount++;
2780         MUTEX_EXIT(&rx_refcnt_mutex);
2781         MUTEX_EXIT(&conn->conn_data_lock);
2782 #ifdef RX_ENABLE_LOCKS
2783         if (haveCTLock)
2784             rxi_DestroyConnectionNoLock(conn);
2785         else
2786             rxi_DestroyConnection(conn);
2787 #else /* RX_ENABLE_LOCKS */
2788         rxi_DestroyConnection(conn);
2789 #endif /* RX_ENABLE_LOCKS */
2790     } else {
2791         MUTEX_EXIT(&conn->conn_data_lock);
2792     }
2793     MUTEX_ENTER(&rx_refcnt_mutex);
2794     return 1;
2795 }
2796
2797 rx_atomic_t rxi_Allocsize = RX_ATOMIC_INIT(0);
2798 rx_atomic_t rxi_Alloccnt = RX_ATOMIC_INIT(0);
2799
2800 void *
2801 rxi_Alloc(size_t size)
2802 {
2803     char *p;
2804
2805     if (rx_stats_active) {
2806         rx_atomic_add(&rxi_Allocsize, (int) size);
2807         rx_atomic_inc(&rxi_Alloccnt);
2808     }
2809
2810 p = (char *)
2811 #if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
2812   afs_osi_Alloc_NoSleep(size);
2813 #else
2814   osi_Alloc(size);
2815 #endif
2816     if (!p)
2817         osi_Panic("rxi_Alloc error");
2818     memset(p, 0, size);
2819     return p;
2820 }
2821
2822 void
2823 rxi_Free(void *addr, size_t size)
2824 {
2825     if (rx_stats_active) {
2826         rx_atomic_sub(&rxi_Allocsize, (int) size);
2827         rx_atomic_dec(&rxi_Alloccnt);
2828     }
2829     osi_Free(addr, size);
2830 }
2831
2832 void
2833 rxi_SetPeerMtu(struct rx_peer *peer, afs_uint32 host, afs_uint32 port, int mtu)
2834 {
2835     struct rx_peer **peer_ptr = NULL, **peer_end = NULL;
2836     struct rx_peer *next = NULL;
2837     int hashIndex;
2838
2839     if (!peer) {
2840         MUTEX_ENTER(&rx_peerHashTable_lock);
2841         if (port == 0) {
2842             peer_ptr = &rx_peerHashTable[0];
2843             peer_end = &rx_peerHashTable[rx_hashTableSize];
2844             next = NULL;
2845         resume:
2846             for ( ; peer_ptr < peer_end; peer_ptr++) {
2847                 if (!peer)
2848                     peer = *peer_ptr;
2849                 for ( ; peer; peer = next) {
2850                     next = peer->next;
2851                     if (host == peer->host)
2852                         break;
2853                 }
2854             }
2855         } else {
2856             hashIndex = PEER_HASH(host, port);
2857             for (peer = rx_peerHashTable[hashIndex]; peer; peer = peer->next) {
2858                 if ((peer->host == host) && (peer->port == port))
2859                     break;
2860             }
2861         }
2862     } else {
2863         MUTEX_ENTER(&rx_peerHashTable_lock);
2864     }
2865
2866     if (peer) {
2867         peer->refCount++;
2868         MUTEX_EXIT(&rx_peerHashTable_lock);
2869
2870         MUTEX_ENTER(&peer->peer_lock);
2871         /* We don't handle dropping below min, so don't */
2872         mtu = MAX(mtu, RX_MIN_PACKET_SIZE);
2873         peer->ifMTU=MIN(mtu, peer->ifMTU);
2874         peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
2875         /* if we tweaked this down, need to tune our peer MTU too */
2876         peer->MTU = MIN(peer->MTU, peer->natMTU);
2877         /* if we discovered a sub-1500 mtu, degrade */
2878         if (peer->ifMTU < OLD_MAX_PACKET_SIZE)
2879             peer->maxDgramPackets = 1;
2880         /* We no longer have valid peer packet information */
2881         if (peer->maxPacketSize + RX_HEADER_SIZE > peer->ifMTU)
2882             peer->maxPacketSize = 0;
2883         MUTEX_EXIT(&peer->peer_lock);
2884
2885         MUTEX_ENTER(&rx_peerHashTable_lock);
2886         peer->refCount--;
2887         if (host && !port) {
2888             peer = next;
2889             /* pick up where we left off */
2890             goto resume;
2891         }
2892     }
2893     MUTEX_EXIT(&rx_peerHashTable_lock);
2894 }
2895
2896 #ifdef AFS_RXERRQ_ENV
2897 static void
2898 rxi_SetPeerDead(struct sock_extended_err *err, afs_uint32 host, afs_uint16 port)
2899 {
2900     int hashIndex = PEER_HASH(host, port);
2901     struct rx_peer *peer;
2902
2903     MUTEX_ENTER(&rx_peerHashTable_lock);
2904
2905     for (peer = rx_peerHashTable[hashIndex]; peer; peer = peer->next) {
2906         if (peer->host == host && peer->port == port) {
2907             peer->refCount++;
2908             break;
2909         }
2910     }
2911
2912     MUTEX_EXIT(&rx_peerHashTable_lock);
2913
2914     if (peer) {
2915         rx_atomic_inc(&peer->neterrs);
2916         MUTEX_ENTER(&peer->peer_lock);
2917         peer->last_err_origin = RX_NETWORK_ERROR_ORIGIN_ICMP;
2918         peer->last_err_type = err->ee_type;
2919         peer->last_err_code = err->ee_code;
2920         MUTEX_EXIT(&peer->peer_lock);
2921
2922         MUTEX_ENTER(&rx_peerHashTable_lock);
2923         peer->refCount--;
2924         MUTEX_EXIT(&rx_peerHashTable_lock);
2925     }
2926 }
2927
2928 void
2929 rxi_ProcessNetError(struct sock_extended_err *err, afs_uint32 addr, afs_uint16 port)
2930 {
2931 # ifdef AFS_ADAPT_PMTU
2932     if (err->ee_errno == EMSGSIZE && err->ee_info >= 68) {
2933         rxi_SetPeerMtu(NULL, addr, port, err->ee_info - RX_IPUDP_SIZE);
2934         return;
2935     }
2936 # endif
2937     if (err->ee_origin == SO_EE_ORIGIN_ICMP && err->ee_type == ICMP_DEST_UNREACH) {
2938         switch (err->ee_code) {
2939         case ICMP_NET_UNREACH:
2940         case ICMP_HOST_UNREACH:
2941         case ICMP_PORT_UNREACH:
2942         case ICMP_NET_ANO:
2943         case ICMP_HOST_ANO:
2944             rxi_SetPeerDead(err, addr, port);
2945             break;
2946         }
2947     }
2948 }
2949
2950 static const char *
2951 rxi_TranslateICMP(int type, int code)
2952 {
2953     switch (type) {
2954     case ICMP_DEST_UNREACH:
2955         switch (code) {
2956         case ICMP_NET_UNREACH:
2957             return "Destination Net Unreachable";
2958         case ICMP_HOST_UNREACH:
2959             return "Destination Host Unreachable";
2960         case ICMP_PROT_UNREACH:
2961             return "Destination Protocol Unreachable";
2962         case ICMP_PORT_UNREACH:
2963             return "Destination Port Unreachable";
2964         case ICMP_NET_ANO:
2965             return "Destination Net Prohibited";
2966         case ICMP_HOST_ANO:
2967             return "Destination Host Prohibited";
2968         }
2969         break;
2970     }
2971     return NULL;
2972 }
2973 #endif /* AFS_RXERRQ_ENV */
2974
2975 /**
2976  * Get the last network error for a connection
2977  *
2978  * A "network error" here means an error retrieved from ICMP, or some other
2979  * mechanism outside of Rx that informs us of errors in network reachability.
2980  *
2981  * If a peer associated with the given Rx connection has received a network
2982  * error recently, this function allows the caller to know what error
2983  * specifically occurred. This can be useful to know, since e.g. ICMP errors
2984  * can cause calls to that peer to be quickly aborted. So, this function can
2985  * help see why a call was aborted due to network errors.
2986  *
2987  * If we have received traffic from a peer since the last network error, we
2988  * treat that peer as if we had not received an network error for it.
2989  *
2990  * @param[in] conn  The Rx connection to examine
2991  * @param[out] err_origin  The origin of the last network error (e.g. ICMP);
2992  *                         one of the RX_NETWORK_ERROR_ORIGIN_* constants
2993  * @param[out] err_type  The type of the last error
2994  * @param[out] err_code  The code of the last error
2995  * @param[out] msg  Human-readable error message, if applicable; NULL otherwise
2996  *
2997  * @return If we have an error
2998  *  @retval -1 No error to get; 'out' params are undefined
2999  *  @retval 0 We have an error; 'out' params contain the last error
3000  */
3001 int
3002 rx_GetNetworkError(struct rx_connection *conn, int *err_origin, int *err_type,
3003                    int *err_code, const char **msg)
3004 {
3005 #ifdef AFS_RXERRQ_ENV
3006     struct rx_peer *peer = conn->peer;
3007     if (rx_atomic_read(&peer->neterrs)) {
3008         MUTEX_ENTER(&peer->peer_lock);
3009         *err_origin = peer->last_err_origin;
3010         *err_type = peer->last_err_type;
3011         *err_code = peer->last_err_code;
3012         MUTEX_EXIT(&peer->peer_lock);
3013
3014         *msg = NULL;
3015         if (*err_origin == RX_NETWORK_ERROR_ORIGIN_ICMP) {
3016             *msg = rxi_TranslateICMP(*err_type, *err_code);
3017         }
3018
3019         return 0;
3020     }
3021 #endif
3022     return -1;
3023 }
3024
3025 /* Find the peer process represented by the supplied (host,port)
3026  * combination.  If there is no appropriate active peer structure, a
3027  * new one will be allocated and initialized
3028  */
3029 struct rx_peer *
3030 rxi_FindPeer(afs_uint32 host, u_short port, int create)
3031 {
3032     struct rx_peer *pp;
3033     int hashIndex;
3034     hashIndex = PEER_HASH(host, port);
3035     MUTEX_ENTER(&rx_peerHashTable_lock);
3036     for (pp = rx_peerHashTable[hashIndex]; pp; pp = pp->next) {
3037         if ((pp->host == host) && (pp->port == port))
3038             break;
3039     }
3040     if (!pp) {
3041         if (create) {
3042             pp = rxi_AllocPeer();       /* This bzero's *pp */
3043             pp->host = host;    /* set here or in InitPeerParams is zero */
3044             pp->port = port;
3045 #ifdef AFS_RXERRQ_ENV
3046             rx_atomic_set(&pp->neterrs, 0);
3047 #endif
3048             MUTEX_INIT(&pp->peer_lock, "peer_lock", MUTEX_DEFAULT, 0);
3049             opr_queue_Init(&pp->rpcStats);
3050             pp->next = rx_peerHashTable[hashIndex];
3051             rx_peerHashTable[hashIndex] = pp;
3052             rxi_InitPeerParams(pp);
3053             if (rx_stats_active)
3054                 rx_atomic_inc(&rx_stats.nPeerStructs);
3055         }
3056     }
3057     if (pp && create) {
3058         pp->refCount++;
3059     }
3060     MUTEX_EXIT(&rx_peerHashTable_lock);
3061     return pp;
3062 }
3063
3064
3065 /* Find the connection at (host, port) started at epoch, and with the
3066  * given connection id.  Creates the server connection if necessary.
3067  * The type specifies whether a client connection or a server
3068  * connection is desired.  In both cases, (host, port) specify the
3069  * peer's (host, pair) pair.  Client connections are not made
3070  * automatically by this routine.  The parameter socket gives the
3071  * socket descriptor on which the packet was received.  This is used,
3072  * in the case of server connections, to check that *new* connections
3073  * come via a valid (port, serviceId).  Finally, the securityIndex
3074  * parameter must match the existing index for the connection.  If a
3075  * server connection is created, it will be created using the supplied
3076  * index, if the index is valid for this service */
3077 static struct rx_connection *
3078 rxi_FindConnection(osi_socket socket, afs_uint32 host,
3079                    u_short port, u_short serviceId, afs_uint32 cid,
3080                    afs_uint32 epoch, int type, u_int securityIndex,
3081                    int *unknownService)
3082 {
3083     int hashindex, flag, i;
3084     struct rx_connection *conn;
3085     *unknownService = 0;
3086     hashindex = CONN_HASH(host, port, cid, epoch, type);
3087     MUTEX_ENTER(&rx_connHashTable_lock);
3088     rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
3089                                                   rx_connHashTable[hashindex],
3090                                                   flag = 1);
3091     for (; conn;) {
3092         if ((conn->type == type) && ((cid & RX_CIDMASK) == conn->cid)
3093             && (epoch == conn->epoch)) {
3094             struct rx_peer *pp = conn->peer;
3095             if (securityIndex != conn->securityIndex) {
3096                 /* this isn't supposed to happen, but someone could forge a packet
3097                  * like this, and there seems to be some CM bug that makes this
3098                  * happen from time to time -- in which case, the fileserver
3099                  * asserts. */
3100                 MUTEX_EXIT(&rx_connHashTable_lock);
3101                 return (struct rx_connection *)0;
3102             }
3103             if (pp->host == host && pp->port == port)
3104                 break;
3105             if (type == RX_CLIENT_CONNECTION && pp->port == port)
3106                 break;
3107             /* So what happens when it's a callback connection? */
3108             if (                /*type == RX_CLIENT_CONNECTION && */
3109                    (conn->epoch & 0x80000000))
3110                 break;
3111         }
3112         if (!flag) {
3113             /* the connection rxLastConn that was used the last time is not the
3114              ** one we are looking for now. Hence, start searching in the hash */
3115             flag = 1;
3116             conn = rx_connHashTable[hashindex];
3117         } else
3118             conn = conn->next;
3119     }
3120     if (!conn) {
3121         struct rx_service *service;
3122         if (type == RX_CLIENT_CONNECTION) {
3123             MUTEX_EXIT(&rx_connHashTable_lock);
3124             return (struct rx_connection *)0;
3125         }
3126         service = rxi_FindService(socket, serviceId);
3127         if (!service || (securityIndex >= service->nSecurityObjects)
3128             || (service->securityObjects[securityIndex] == 0)) {
3129             MUTEX_EXIT(&rx_connHashTable_lock);
3130             *unknownService = 1;
3131             return (struct rx_connection *)0;
3132         }
3133         conn = rxi_AllocConnection();   /* This bzero's the connection */
3134         MUTEX_INIT(&conn->conn_call_lock, "conn call lock", MUTEX_DEFAULT, 0);
3135         MUTEX_INIT(&conn->conn_data_lock, "conn data lock", MUTEX_DEFAULT, 0);
3136         CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
3137         conn->next = rx_connHashTable[hashindex];
3138         rx_connHashTable[hashindex] = conn;
3139         conn->peer = rxi_FindPeer(host, port, 1);
3140         conn->type = RX_SERVER_CONNECTION;
3141         conn->lastSendTime = clock_Sec();       /* don't GC immediately */
3142         conn->epoch = epoch;
3143         conn->cid = cid & RX_CIDMASK;
3144         conn->ackRate = RX_FAST_ACK_RATE;
3145         conn->service = service;
3146         conn->serviceId = serviceId;
3147         conn->securityIndex = securityIndex;
3148         conn->securityObject = service->securityObjects[securityIndex];
3149         conn->nSpecific = 0;
3150         conn->specific = NULL;
3151         rx_SetConnDeadTime(conn, service->connDeadTime);
3152         rx_SetConnIdleDeadTime(conn, service->idleDeadTime);
3153         for (i = 0; i < RX_MAXCALLS; i++) {
3154             conn->twind[i] = rx_initSendWindow;
3155             conn->rwind[i] = rx_initReceiveWindow;
3156         }
3157         /* Notify security object of the new connection */
3158         RXS_NewConnection(conn->securityObject, conn);
3159         /* XXXX Connection timeout? */
3160         if (service->newConnProc)
3161             (*service->newConnProc) (conn);
3162         if (rx_stats_active)
3163             rx_atomic_inc(&rx_stats.nServerConns);
3164     }
3165
3166     MUTEX_ENTER(&rx_refcnt_mutex);
3167     conn->refCount++;
3168     MUTEX_EXIT(&rx_refcnt_mutex);
3169
3170     rxLastConn = conn;          /* store this connection as the last conn used */
3171     MUTEX_EXIT(&rx_connHashTable_lock);
3172     return conn;
3173 }
3174
3175 /*!
3176  * Abort the call if the server is over the busy threshold. This
3177  * can be used without requiring a call structure be initialised,
3178  * or connected to a particular channel
3179  */
3180 static_inline int
3181 rxi_AbortIfServerBusy(osi_socket socket, struct rx_connection *conn,
3182                       struct rx_packet *np)
3183 {
3184     if ((rx_BusyThreshold > 0) &&
3185         (rx_atomic_read(&rx_nWaiting) > rx_BusyThreshold)) {
3186         rxi_SendRawAbort(socket, conn->peer->host, conn->peer->port,
3187                          rx_BusyError, np, 0);
3188         if (rx_stats_active)
3189             rx_atomic_inc(&rx_stats.nBusies);
3190         return 1;
3191     }
3192
3193     return 0;
3194 }
3195
3196 static_inline struct rx_call *
3197 rxi_ReceiveClientCall(struct rx_packet *np, struct rx_connection *conn)
3198 {
3199     int channel;
3200     struct rx_call *call;
3201
3202     channel = np->header.cid & RX_CHANNELMASK;
3203     MUTEX_ENTER(&conn->conn_call_lock);
3204     call = conn->call[channel];
3205     if (np->header.type == RX_PACKET_TYPE_BUSY) {
3206         conn->lastBusy[channel] = clock_Sec();
3207     }
3208     if (!call || conn->callNumber[channel] != np->header.callNumber) {
3209         MUTEX_EXIT(&conn->conn_call_lock);
3210         if (rx_stats_active)
3211             rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3212         return NULL;
3213     }
3214
3215     MUTEX_ENTER(&call->lock);
3216     MUTEX_EXIT(&conn->conn_call_lock);
3217
3218     if ((call->state == RX_STATE_DALLY)
3219         && np->header.type == RX_PACKET_TYPE_ACK) {
3220         if (rx_stats_active)
3221             rx_atomic_inc(&rx_stats.ignorePacketDally);
3222         MUTEX_EXIT(&call->lock);
3223         return NULL;
3224     }
3225
3226     return call;
3227 }
3228
3229 static_inline struct rx_call *
3230 rxi_ReceiveServerCall(osi_socket socket, struct rx_packet *np,
3231                       struct rx_connection *conn)
3232 {
3233     int channel;
3234     struct rx_call *call;
3235
3236     channel = np->header.cid & RX_CHANNELMASK;
3237     MUTEX_ENTER(&conn->conn_call_lock);
3238     call = conn->call[channel];
3239
3240     if (!call) {
3241         if (rxi_AbortIfServerBusy(socket, conn, np)) {
3242             MUTEX_EXIT(&conn->conn_call_lock);
3243             return NULL;
3244         }
3245
3246         call = rxi_NewCall(conn, channel);  /* returns locked call */
3247         *call->callNumber = np->header.callNumber;
3248         MUTEX_EXIT(&conn->conn_call_lock);
3249
3250         call->state = RX_STATE_PRECALL;
3251         clock_GetTime(&call->queueTime);
3252         call->app.bytesSent = 0;
3253         call->app.bytesRcvd = 0;
3254         rxi_KeepAliveOn(call);
3255
3256         return call;
3257     }
3258
3259     if (np->header.callNumber == conn->callNumber[channel]) {
3260         MUTEX_ENTER(&call->lock);
3261         MUTEX_EXIT(&conn->conn_call_lock);
3262         return call;
3263     }
3264
3265     if (np->header.callNumber < conn->callNumber[channel]) {
3266         MUTEX_EXIT(&conn->conn_call_lock);
3267         if (rx_stats_active)
3268             rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3269         return NULL;
3270     }
3271
3272     MUTEX_ENTER(&call->lock);
3273     MUTEX_EXIT(&conn->conn_call_lock);
3274
3275     /* Wait until the transmit queue is idle before deciding
3276      * whether to reset the current call. Chances are that the
3277      * call will be in ether DALLY or HOLD state once the TQ_BUSY
3278      * flag is cleared.
3279      */
3280 #ifdef RX_ENABLE_LOCKS
3281     if (call->state == RX_STATE_ACTIVE && !call->error) {
3282         rxi_WaitforTQBusy(call);
3283         /* If we entered error state while waiting,
3284          * must call rxi_CallError to permit rxi_ResetCall
3285          * to processed when the tqWaiter count hits zero.
3286          */
3287         if (call->error) {
3288             rxi_CallError(call, call->error);
3289             MUTEX_EXIT(&call->lock);
3290             return NULL;
3291         }
3292     }
3293 #endif /* RX_ENABLE_LOCKS */
3294     /* If the new call cannot be taken right now send a busy and set
3295      * the error condition in this call, so that it terminates as
3296      * quickly as possible */
3297     if (call->state == RX_STATE_ACTIVE) {
3298         rxi_CallError(call, RX_CALL_DEAD);
3299         rxi_SendSpecial(call, conn, NULL, RX_PACKET_TYPE_BUSY,
3300                         NULL, 0, 1);
3301         MUTEX_EXIT(&call->lock);
3302         return NULL;
3303     }
3304
3305     if (rxi_AbortIfServerBusy(socket, conn, np)) {
3306         MUTEX_EXIT(&call->lock);
3307         return NULL;
3308     }
3309
3310     rxi_ResetCall(call, 0);
3311     /* The conn_call_lock is not held but no one else should be
3312      * using this call channel while we are processing this incoming
3313      * packet.  This assignment should be safe.
3314      */
3315     *call->callNumber = np->header.callNumber;
3316     call->state = RX_STATE_PRECALL;
3317     clock_GetTime(&call->queueTime);
3318     call->app.bytesSent = 0;
3319     call->app.bytesRcvd = 0;
3320     rxi_KeepAliveOn(call);
3321
3322     return call;
3323 }
3324
3325
3326 /* There are two packet tracing routines available for testing and monitoring
3327  * Rx.  One is called just after every packet is received and the other is
3328  * called just before every packet is sent.  Received packets, have had their
3329  * headers decoded, and packets to be sent have not yet had their headers
3330  * encoded.  Both take two parameters: a pointer to the packet and a sockaddr
3331  * containing the network address.  Both can be modified.  The return value, if
3332  * non-zero, indicates that the packet should be dropped.  */
3333
3334 int (*rx_justReceived) (struct rx_packet *, struct sockaddr_in *) = 0;
3335 int (*rx_almostSent) (struct rx_packet *, struct sockaddr_in *) = 0;
3336
3337 /* A packet has been received off the interface.  Np is the packet, socket is
3338  * the socket number it was received from (useful in determining which service
3339  * this packet corresponds to), and (host, port) reflect the host,port of the
3340  * sender.  This call returns the packet to the caller if it is finished with
3341  * it, rather than de-allocating it, just as a small performance hack */
3342
3343 struct rx_packet *
3344 rxi_ReceivePacket(struct rx_packet *np, osi_socket socket,
3345                   afs_uint32 host, u_short port, int *tnop,
3346                   struct rx_call **newcallp)
3347 {
3348     struct rx_call *call;
3349     struct rx_connection *conn;
3350     int type;
3351     int unknownService = 0;
3352 #ifdef RXDEBUG
3353     char *packetType;
3354 #endif
3355     struct rx_packet *tnp;
3356
3357 #ifdef RXDEBUG
3358 /* We don't print out the packet until now because (1) the time may not be
3359  * accurate enough until now in the lwp implementation (rx_Listener only gets
3360  * the time after the packet is read) and (2) from a protocol point of view,
3361  * this is the first time the packet has been seen */
3362     packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
3363         ? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
3364     dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %"AFS_PTR_FMT"\n",
3365          np->header.serial, packetType, ntohl(host), ntohs(port), np->header.serviceId,
3366          np->header.epoch, np->header.cid, np->header.callNumber,
3367          np->header.seq, np->header.flags, np));
3368 #endif
3369
3370     /* Account for connectionless packets */
3371     if (rx_stats_active &&
3372         ((np->header.type == RX_PACKET_TYPE_VERSION) ||
3373          (np->header.type == RX_PACKET_TYPE_DEBUG))) {
3374         struct rx_peer *peer;
3375
3376         /* Try to look up the peer structure, but don't create one */
3377         peer = rxi_FindPeer(host, port, 0);
3378
3379         /* Since this may not be associated with a connection, it may have
3380          * no refCount, meaning we could race with ReapConnections
3381          */
3382
3383         if (peer && (peer->refCount > 0)) {
3384 #ifdef AFS_RXERRQ_ENV
3385             if (rx_atomic_read(&peer->neterrs)) {
3386                 rx_atomic_set(&peer->neterrs, 0);
3387             }
3388 #endif
3389             MUTEX_ENTER(&peer->peer_lock);
3390             peer->bytesReceived += np->length;
3391             MUTEX_EXIT(&peer->peer_lock);
3392         }
3393     }
3394
3395     if (np->header.type == RX_PACKET_TYPE_VERSION) {
3396         return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
3397     }
3398
3399     if (np->header.type == RX_PACKET_TYPE_DEBUG) {
3400         return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
3401     }
3402 #ifdef RXDEBUG
3403     /* If an input tracer function is defined, call it with the packet and
3404      * network address.  Note this function may modify its arguments. */
3405     if (rx_justReceived) {
3406         struct sockaddr_in addr;
3407         int drop;
3408         addr.sin_family = AF_INET;
3409         addr.sin_port = port;
3410         addr.sin_addr.s_addr = host;
3411         memset(&addr.sin_zero, 0, sizeof(addr.sin_zero));
3412 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
3413         addr.sin_len = sizeof(addr);
3414 #endif /* AFS_OSF_ENV */
3415         drop = (*rx_justReceived) (np, &addr);
3416         /* drop packet if return value is non-zero */
3417         if (drop)
3418             return np;
3419         port = addr.sin_port;   /* in case fcn changed addr */
3420         host = addr.sin_addr.s_addr;
3421     }
3422 #endif
3423
3424     /* If packet was not sent by the client, then *we* must be the client */
3425     type = ((np->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED)
3426         ? RX_CLIENT_CONNECTION : RX_SERVER_CONNECTION;
3427
3428     /* Find the connection (or fabricate one, if we're the server & if
3429      * necessary) associated with this packet */
3430     conn =
3431         rxi_FindConnection(socket, host, port, np->header.serviceId,
3432                            np->header.cid, np->header.epoch, type,
3433                            np->header.securityIndex, &unknownService);
3434
3435     /* To avoid having 2 connections just abort at each other,
3436        don't abort an abort. */
3437     if (!conn) {
3438         if (unknownService && (np->header.type != RX_PACKET_TYPE_ABORT))
3439             rxi_SendRawAbort(socket, host, port, RX_INVALID_OPERATION,
3440                              np, 0);
3441         return np;
3442     }
3443
3444 #ifdef AFS_RXERRQ_ENV
3445     if (rx_atomic_read(&conn->peer->neterrs)) {
3446         rx_atomic_set(&conn->peer->neterrs, 0);
3447     }
3448 #endif
3449
3450     /* If we're doing statistics, then account for the incoming packet */
3451     if (rx_stats_active) {
3452         MUTEX_ENTER(&conn->peer->peer_lock);
3453         conn->peer->bytesReceived += np->length;
3454         MUTEX_EXIT(&conn->peer->peer_lock);
3455     }
3456
3457     /* If the connection is in an error state, send an abort packet and ignore
3458      * the incoming packet */
3459     if (conn->error) {
3460         /* Don't respond to an abort packet--we don't want loops! */
3461         MUTEX_ENTER(&conn->conn_data_lock);
3462         if (np->header.type != RX_PACKET_TYPE_ABORT)
3463             np = rxi_SendConnectionAbort(conn, np, 1, 0);
3464         putConnection(conn);
3465         MUTEX_EXIT(&conn->conn_data_lock);
3466         return np;
3467     }
3468
3469     /* Check for connection-only requests (i.e. not call specific). */
3470     if (np->header.callNumber == 0) {
3471         switch (np->header.type) {
3472         case RX_PACKET_TYPE_ABORT: {
3473             /* What if the supplied error is zero? */
3474             afs_int32 errcode = ntohl(rx_GetInt32(np, 0));
3475             dpf(("rxi_ReceivePacket ABORT rx_GetInt32 = %d\n", errcode));
3476             rxi_ConnectionError(conn, errcode);
3477             putConnection(conn);
3478             return np;
3479         }
3480         case RX_PACKET_TYPE_CHALLENGE:
3481             tnp = rxi_ReceiveChallengePacket(conn, np, 1);
3482             putConnection(conn);
3483             return tnp;
3484         case RX_PACKET_TYPE_RESPONSE:
3485             tnp = rxi_ReceiveResponsePacket(conn, np, 1);
3486             putConnection(conn);
3487             return tnp;
3488         case RX_PACKET_TYPE_PARAMS:
3489         case RX_PACKET_TYPE_PARAMS + 1:
3490         case RX_PACKET_TYPE_PARAMS + 2:
3491             /* ignore these packet types for now */
3492             putConnection(conn);
3493             return np;
3494
3495         default:
3496             /* Should not reach here, unless the peer is broken: send an
3497              * abort packet */
3498             rxi_ConnectionError(conn, RX_PROTOCOL_ERROR);
3499             MUTEX_ENTER(&conn->conn_data_lock);
3500             tnp = rxi_SendConnectionAbort(conn, np, 1, 0);
3501             putConnection(conn);
3502             MUTEX_EXIT(&conn->conn_data_lock);
3503             return tnp;
3504         }
3505     }
3506
3507     if (type == RX_SERVER_CONNECTION)
3508         call = rxi_ReceiveServerCall(socket, np, conn);
3509     else
3510         call = rxi_ReceiveClientCall(np, conn);
3511
3512     if (call == NULL) {
3513         putConnection(conn);
3514         return np;
3515     }
3516
3517     MUTEX_ASSERT(&call->lock);
3518     /* Set remote user defined status from packet */
3519     call->remoteStatus = np->header.userStatus;
3520
3521     /* Now do packet type-specific processing */
3522     switch (np->header.type) {
3523     case RX_PACKET_TYPE_DATA:
3524         /* If we're a client, and receiving a response, then all the packets
3525          * we transmitted packets are implicitly acknowledged. */
3526         if (type == RX_CLIENT_CONNECTION && !opr_queue_IsEmpty(&call->tq))
3527             rxi_AckAllInTransmitQueue(call);
3528
3529         np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
3530                                    newcallp);
3531         break;
3532     case RX_PACKET_TYPE_ACK:
3533         /* Respond immediately to ack packets requesting acknowledgement
3534          * (ping packets) */
3535         if (np->header.flags & RX_REQUEST_ACK) {
3536             if (call->error)
3537                 (void)rxi_SendCallAbort(call, 0, 1, 0);
3538             else
3539                 (void)rxi_SendAck(call, 0, np->header.serial,
3540                                   RX_ACK_PING_RESPONSE, 1);
3541         }
3542         np = rxi_ReceiveAckPacket(call, np, 1);
3543         break;
3544     case RX_PACKET_TYPE_ABORT: {
3545         /* An abort packet: reset the call, passing the error up to the user. */
3546         /* What if error is zero? */
3547         /* What if the error is -1? the application will treat it as a timeout. */
3548         afs_int32 errdata = ntohl(*(afs_int32 *) rx_DataOf(np));
3549         dpf(("rxi_ReceivePacket ABORT rx_DataOf = %d\n", errdata));
3550         rxi_CallError(call, errdata);
3551         MUTEX_EXIT(&call->lock);
3552         putConnection(conn);
3553         return np;              /* xmitting; drop packet */
3554     }
3555     case RX_PACKET_TYPE_BUSY:
3556         /* Mostly ignore BUSY packets. We will update lastReceiveTime below,
3557          * so we don't think the endpoint is completely dead, but otherwise
3558          * just act as if we never saw anything. If all we get are BUSY packets
3559          * back, then we will eventually error out with RX_CALL_TIMEOUT if the
3560          * connection is configured with idle/hard timeouts. */
3561         break;
3562
3563     case RX_PACKET_TYPE_ACKALL:
3564         /* All packets acknowledged, so we can drop all packets previously
3565          * readied for sending */
3566         rxi_AckAllInTransmitQueue(call);
3567         break;
3568     default:
3569         /* Should not reach here, unless the peer is broken: send an abort
3570          * packet */
3571         rxi_CallError(call, RX_PROTOCOL_ERROR);
3572         np = rxi_SendCallAbort(call, np, 1, 0);
3573         break;
3574     };
3575     /* Note when this last legitimate packet was received, for keep-alive
3576      * processing.  Note, we delay getting the time until now in the hope that
3577      * the packet will be delivered to the user before any get time is required
3578      * (if not, then the time won't actually be re-evaluated here). */
3579     call->lastReceiveTime = clock_Sec();
3580     MUTEX_EXIT(&call->lock);
3581     putConnection(conn);
3582     return np;
3583 }
3584
3585 /* return true if this is an "interesting" connection from the point of view
3586     of someone trying to debug the system */
3587 int
3588 rxi_IsConnInteresting(struct rx_connection *aconn)
3589 {
3590     int i;
3591     struct rx_call *tcall;
3592
3593     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
3594         return 1;
3595
3596     for (i = 0; i < RX_MAXCALLS; i++) {
3597         tcall = aconn->call[i];
3598         if (tcall) {
3599             if ((tcall->state == RX_STATE_PRECALL)
3600                 || (tcall->state == RX_STATE_ACTIVE))
3601                 return 1;
3602             if ((tcall->app.mode == RX_MODE_SENDING)
3603                 || (tcall->app.mode == RX_MODE_RECEIVING))
3604                 return 1;
3605         }
3606     }
3607     return 0;
3608 }
3609
3610 #ifdef KERNEL
3611 /* if this is one of the last few packets AND it wouldn't be used by the
3612    receiving call to immediately satisfy a read request, then drop it on
3613    the floor, since accepting it might prevent a lock-holding thread from
3614    making progress in its reading. If a call has been cleared while in
3615    the precall state then ignore all subsequent packets until the call
3616    is assigned to a thread. */
3617
3618 static int
3619 TooLow(struct rx_packet *ap, struct rx_call *acall)
3620 {
3621     int rc = 0;
3622
3623     MUTEX_ENTER(&rx_quota_mutex);
3624     if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
3625          && (acall->state == RX_STATE_PRECALL))
3626         || ((rx_nFreePackets < rxi_dataQuota + 2)
3627             && !((ap->header.seq < acall->rnext + rx_initSendWindow)
3628                  && (acall->flags & RX_CALL_READER_WAIT)))) {
3629         rc = 1;
3630     }
3631     MUTEX_EXIT(&rx_quota_mutex);
3632     return rc;
3633 }
3634 #endif /* KERNEL */
3635
3636 /*!
3637  * Clear the attach wait flag on a connection and proceed.
3638  *
3639  * Any processing waiting for a connection to be attached should be
3640  * unblocked. We clear the flag and do any other needed tasks.
3641  *
3642  * @param[in] conn
3643  *      the conn to unmark waiting for attach
3644  *
3645  * @pre conn's conn_data_lock must be locked before calling this function
3646  *
3647  */
3648 static void
3649 rxi_ConnClearAttachWait(struct rx_connection *conn)
3650 {
3651     /* Indicate that rxi_CheckReachEvent is no longer running by
3652      * clearing the flag.  Must be atomic under conn_data_lock to
3653      * avoid a new call slipping by: rxi_CheckConnReach holds
3654      * conn_data_lock while checking RX_CONN_ATTACHWAIT.
3655      */
3656     conn->flags &= ~RX_CONN_ATTACHWAIT;
3657     if (conn->flags & RX_CONN_NAT_PING) {
3658         conn->flags &= ~RX_CONN_NAT_PING;
3659         rxi_ScheduleNatKeepAliveEvent(conn);
3660     }
3661 }
3662
3663 static void
3664 rxi_CheckReachEvent(struct rxevent *event, void *arg1, void *arg2, int dummy)
3665 {
3666     struct rx_connection *conn = arg1;
3667     struct rx_call *acall = arg2;
3668     struct rx_call *call = acall;
3669     struct clock when, now;
3670     int i, waiting;
3671
3672     MUTEX_ENTER(&conn->conn_data_lock);
3673
3674     if (event)
3675         rxevent_Put(&conn->checkReachEvent);
3676
3677     waiting = conn->flags & RX_CONN_ATTACHWAIT;
3678     if (event) {
3679         putConnection(conn);
3680     }
3681     MUTEX_EXIT(&conn->conn_data_lock);
3682
3683     if (waiting) {
3684         if (!call) {
3685             MUTEX_ENTER(&conn->conn_call_lock);
3686             MUTEX_ENTER(&conn->conn_data_lock);
3687             for (i = 0; i < RX_MAXCALLS; i++) {
3688                 struct rx_call *tc = conn->call[i];
3689                 if (tc && tc->state == RX_STATE_PRECALL) {
3690                     call = tc;
3691                     break;
3692                 }
3693             }
3694             if (!call)
3695                 rxi_ConnClearAttachWait(conn);
3696             MUTEX_EXIT(&conn->conn_data_lock);
3697             MUTEX_EXIT(&conn->conn_call_lock);
3698         }
3699
3700         if (call) {
3701             if (call != acall)
3702                 MUTEX_ENTER(&call->lock);
3703             rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
3704             if (call != acall)
3705                 MUTEX_EXIT(&call->lock);
3706
3707             clock_GetTime(&now);
3708             when = now;
3709             when.sec += RX_CHECKREACH_TIMEOUT;
3710             MUTEX_ENTER(&conn->conn_data_lock);
3711             if (!conn->checkReachEvent) {
3712                 MUTEX_ENTER(&rx_refcnt_mutex);
3713                 conn->refCount++;
3714                 MUTEX_EXIT(&rx_refcnt_mutex);
3715                 conn->checkReachEvent = rxevent_Post(&when, &now,
3716                                                      rxi_CheckReachEvent, conn,
3717                                                      NULL, 0);
3718             }
3719             MUTEX_EXIT(&conn->conn_data_lock);
3720         }
3721     }
3722 }
3723
3724 static int
3725 rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
3726 {
3727     struct rx_service *service = conn->service;
3728     struct rx_peer *peer = conn->peer;
3729     afs_uint32 now, lastReach;
3730
3731     if (service->checkReach == 0)
3732         return 0;
3733
3734     now = clock_Sec();
3735     MUTEX_ENTER(&peer->peer_lock);
3736     lastReach = peer->lastReachTime;
3737     MUTEX_EXIT(&peer->peer_lock);
3738     if (now - lastReach < RX_CHECKREACH_TTL)
3739         return 0;
3740
3741     MUTEX_ENTER(&conn->conn_data_lock);
3742     if (conn->flags & RX_CONN_ATTACHWAIT) {
3743         MUTEX_EXIT(&conn->conn_data_lock);
3744         return 1;
3745     }
3746     conn->flags |= RX_CONN_ATTACHWAIT;
3747     MUTEX_EXIT(&conn->conn_data_lock);
3748     if (!conn->checkReachEvent)
3749         rxi_CheckReachEvent(NULL, conn, call, 0);
3750
3751     return 1;
3752 }
3753
3754 /* try to attach call, if authentication is complete */
3755 static void
3756 TryAttach(struct rx_call *acall, osi_socket socket,
3757           int *tnop, struct rx_call **newcallp,
3758           int reachOverride)
3759 {
3760     struct rx_connection *conn = acall->conn;
3761
3762     if (conn->type == RX_SERVER_CONNECTION
3763         && acall->state == RX_STATE_PRECALL) {
3764         /* Don't attach until we have any req'd. authentication. */
3765         if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
3766             if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
3767                 rxi_AttachServerProc(acall, socket, tnop, newcallp);
3768             /* Note:  this does not necessarily succeed; there
3769              * may not any proc available
3770              */
3771         } else {
3772             rxi_ChallengeOn(acall->conn);
3773         }
3774     }