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