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