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