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