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