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