f24fe2f1af06978005073be3a05735734613276d
[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     call->bytesSent = 0;
1632     call->bytesRcvd = 0;
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     /* Account for connectionless packets */
3189     if (rx_stats_active &&
3190         ((np->header.type == RX_PACKET_TYPE_VERSION) ||
3191          (np->header.type == RX_PACKET_TYPE_DEBUG))) {
3192         struct rx_peer *peer;
3193
3194         /* Try to look up the peer structure, but don't create one */
3195         peer = rxi_FindPeer(host, port, 0, 0);
3196
3197         /* Since this may not be associated with a connection, it may have
3198          * no refCount, meaning we could race with ReapConnections
3199          */
3200
3201         if (peer && (peer->refCount > 0)) {
3202             MUTEX_ENTER(&peer->peer_lock);
3203             peer->bytesReceived += np->length;
3204             MUTEX_EXIT(&peer->peer_lock);
3205         }
3206     }
3207
3208     if (np->header.type == RX_PACKET_TYPE_VERSION) {
3209         return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
3210     }
3211
3212     if (np->header.type == RX_PACKET_TYPE_DEBUG) {
3213         return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
3214     }
3215 #ifdef RXDEBUG
3216     /* If an input tracer function is defined, call it with the packet and
3217      * network address.  Note this function may modify its arguments. */
3218     if (rx_justReceived) {
3219         struct sockaddr_in addr;
3220         int drop;
3221         addr.sin_family = AF_INET;
3222         addr.sin_port = port;
3223         addr.sin_addr.s_addr = host;
3224 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
3225         addr.sin_len = sizeof(addr);
3226 #endif /* AFS_OSF_ENV */
3227         drop = (*rx_justReceived) (np, &addr);
3228         /* drop packet if return value is non-zero */
3229         if (drop)
3230             return np;
3231         port = addr.sin_port;   /* in case fcn changed addr */
3232         host = addr.sin_addr.s_addr;
3233     }
3234 #endif
3235
3236     /* If packet was not sent by the client, then *we* must be the client */
3237     type = ((np->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED)
3238         ? RX_CLIENT_CONNECTION : RX_SERVER_CONNECTION;
3239
3240     /* Find the connection (or fabricate one, if we're the server & if
3241      * necessary) associated with this packet */
3242     conn =
3243         rxi_FindConnection(socket, host, port, np->header.serviceId,
3244                            np->header.cid, np->header.epoch, type,
3245                            np->header.securityIndex);
3246
3247     if (!conn) {
3248         /* If no connection found or fabricated, just ignore the packet.
3249          * (An argument could be made for sending an abort packet for
3250          * the conn) */
3251         return np;
3252     }
3253
3254     /* If we're doing statistics, then account for the incoming packet */
3255     if (rx_stats_active) {
3256         MUTEX_ENTER(&conn->peer->peer_lock);
3257         conn->peer->bytesReceived += np->length;
3258         MUTEX_EXIT(&conn->peer->peer_lock);
3259     }
3260
3261     /* If the connection is in an error state, send an abort packet and ignore
3262      * the incoming packet */
3263     if (conn->error) {
3264         /* Don't respond to an abort packet--we don't want loops! */
3265         MUTEX_ENTER(&conn->conn_data_lock);
3266         if (np->header.type != RX_PACKET_TYPE_ABORT)
3267             np = rxi_SendConnectionAbort(conn, np, 1, 0);
3268         putConnection(conn);
3269         MUTEX_EXIT(&conn->conn_data_lock);
3270         return np;
3271     }
3272
3273     /* Check for connection-only requests (i.e. not call specific). */
3274     if (np->header.callNumber == 0) {
3275         switch (np->header.type) {
3276         case RX_PACKET_TYPE_ABORT: {
3277             /* What if the supplied error is zero? */
3278             afs_int32 errcode = ntohl(rx_GetInt32(np, 0));
3279             dpf(("rxi_ReceivePacket ABORT rx_GetInt32 = %d\n", errcode));
3280             rxi_ConnectionError(conn, errcode);
3281             putConnection(conn);
3282             return np;
3283         }
3284         case RX_PACKET_TYPE_CHALLENGE:
3285             tnp = rxi_ReceiveChallengePacket(conn, np, 1);
3286             putConnection(conn);
3287             return tnp;
3288         case RX_PACKET_TYPE_RESPONSE:
3289             tnp = rxi_ReceiveResponsePacket(conn, np, 1);
3290             putConnection(conn);
3291             return tnp;
3292         case RX_PACKET_TYPE_PARAMS:
3293         case RX_PACKET_TYPE_PARAMS + 1:
3294         case RX_PACKET_TYPE_PARAMS + 2:
3295             /* ignore these packet types for now */
3296             putConnection(conn);
3297             return np;
3298
3299         default:
3300             /* Should not reach here, unless the peer is broken: send an
3301              * abort packet */
3302             rxi_ConnectionError(conn, RX_PROTOCOL_ERROR);
3303             MUTEX_ENTER(&conn->conn_data_lock);
3304             tnp = rxi_SendConnectionAbort(conn, np, 1, 0);
3305             putConnection(conn);
3306             MUTEX_EXIT(&conn->conn_data_lock);
3307             return tnp;
3308         }
3309     }
3310
3311     channel = np->header.cid & RX_CHANNELMASK;
3312     MUTEX_ENTER(&conn->conn_call_lock);
3313     call = conn->call[channel];
3314
3315     if (call) {
3316         MUTEX_ENTER(&call->lock);
3317         currentCallNumber = conn->callNumber[channel];
3318         MUTEX_EXIT(&conn->conn_call_lock);
3319     } else if (type == RX_SERVER_CONNECTION) {  /* No call allocated */
3320         call = conn->call[channel];
3321         if (call) {
3322             MUTEX_ENTER(&call->lock);
3323             currentCallNumber = conn->callNumber[channel];
3324             MUTEX_EXIT(&conn->conn_call_lock);
3325         } else {
3326             call = rxi_NewCall(conn, channel);  /* returns locked call */
3327             *call->callNumber = currentCallNumber = np->header.callNumber;
3328             MUTEX_EXIT(&conn->conn_call_lock);
3329 #ifdef RXDEBUG
3330             if (np->header.callNumber == 0)
3331                 dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %"AFS_PTR_FMT" len %d\n",
3332                      np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port),
3333                      np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq,
3334                      np->header.flags, np, np->length));
3335 #endif
3336             call->state = RX_STATE_PRECALL;
3337             clock_GetTime(&call->queueTime);
3338             call->bytesSent = 0;
3339             call->bytesRcvd = 0;
3340             /*
3341              * If the number of queued calls exceeds the overload
3342              * threshold then abort this call.
3343              */
3344             if ((rx_BusyThreshold > 0) &&
3345                 (rx_atomic_read(&rx_nWaiting) > rx_BusyThreshold)) {
3346                 struct rx_packet *tp;
3347
3348                 rxi_CallError(call, rx_BusyError);
3349                 tp = rxi_SendCallAbort(call, np, 1, 0);
3350                 MUTEX_EXIT(&call->lock);
3351                 putConnection(conn);
3352                 if (rx_stats_active)
3353                     rx_atomic_inc(&rx_stats.nBusies);
3354                 return tp;
3355             }
3356             rxi_KeepAliveOn(call);
3357         }
3358     } else {    /* RX_CLIENT_CONNECTION and No call allocated */
3359         /* This packet can't be for this call. If the new call address is
3360          * 0 then no call is running on this channel. If there is a call
3361          * then, since this is a client connection we're getting data for
3362          * it must be for the previous call.
3363          */
3364         MUTEX_EXIT(&conn->conn_call_lock);
3365         if (rx_stats_active)
3366             rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3367         putConnection(conn);
3368         return np;
3369     }
3370
3371     /* There is a non-NULL locked call at this point */
3372     if (type == RX_SERVER_CONNECTION) { /* We're the server */
3373         if (np->header.callNumber < currentCallNumber) {
3374             MUTEX_EXIT(&call->lock);
3375             if (rx_stats_active)
3376                 rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3377             putConnection(conn);
3378             return np;
3379         } else if (np->header.callNumber != currentCallNumber) {
3380             /* Wait until the transmit queue is idle before deciding
3381              * whether to reset the current call. Chances are that the
3382              * call will be in ether DALLY or HOLD state once the TQ_BUSY
3383              * flag is cleared.
3384              */
3385 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
3386             if (call->state == RX_STATE_ACTIVE) {
3387                 rxi_WaitforTQBusy(call);
3388                 /*
3389                  * If we entered error state while waiting,
3390                  * must call rxi_CallError to permit rxi_ResetCall
3391                  * to processed when the tqWaiter count hits zero.
3392                  */
3393                 if (call->error) {
3394                     rxi_CallError(call, call->error);
3395                     MUTEX_EXIT(&call->lock);
3396                     putConnection(conn);
3397                     return np;
3398                 }
3399             }
3400 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3401             /* If the new call cannot be taken right now send a busy and set
3402              * the error condition in this call, so that it terminates as
3403              * quickly as possible */
3404             if (call->state == RX_STATE_ACTIVE) {
3405                 struct rx_packet *tp;
3406
3407                 rxi_CallError(call, RX_CALL_DEAD);
3408                 tp = rxi_SendSpecial(call, conn, np, RX_PACKET_TYPE_BUSY,
3409                                      NULL, 0, 1);
3410                 MUTEX_EXIT(&call->lock);
3411                 putConnection(conn);
3412                 return tp;
3413             }
3414             rxi_ResetCall(call, 0);
3415             /*
3416              * The conn_call_lock is not held but no one else should be
3417              * using this call channel while we are processing this incoming
3418              * packet.  This assignment should be safe.
3419              */
3420             *call->callNumber = np->header.callNumber;
3421 #ifdef RXDEBUG
3422             if (np->header.callNumber == 0)
3423                 dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %"AFS_PTR_FMT" len %d\n",
3424                       np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port),
3425                       np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq,
3426                       np->header.flags, np, np->length));
3427 #endif
3428             call->state = RX_STATE_PRECALL;
3429             clock_GetTime(&call->queueTime);
3430             call->bytesSent = 0;
3431             call->bytesRcvd = 0;
3432             /*
3433              * If the number of queued calls exceeds the overload
3434              * threshold then abort this call.
3435              */
3436             if ((rx_BusyThreshold > 0) &&
3437                 (rx_atomic_read(&rx_nWaiting) > rx_BusyThreshold)) {
3438                 struct rx_packet *tp;
3439
3440                 rxi_CallError(call, rx_BusyError);
3441                 tp = rxi_SendCallAbort(call, np, 1, 0);
3442                 MUTEX_EXIT(&call->lock);
3443                 putConnection(conn);
3444                 if (rx_stats_active)
3445                     rx_atomic_inc(&rx_stats.nBusies);
3446                 return tp;
3447             }
3448             rxi_KeepAliveOn(call);
3449         } else {
3450             /* Continuing call; do nothing here. */
3451         }
3452     } else {                    /* we're the client */
3453         /* Ignore all incoming acknowledgements for calls in DALLY state */
3454         if ((call->state == RX_STATE_DALLY)
3455             && (np->header.type == RX_PACKET_TYPE_ACK)) {
3456             if (rx_stats_active)
3457                 rx_atomic_inc(&rx_stats.ignorePacketDally);
3458             MUTEX_EXIT(&call->lock);
3459             putConnection(conn);
3460             return np;
3461         }
3462
3463         /* Ignore anything that's not relevant to the current call.  If there
3464          * isn't a current call, then no packet is relevant. */
3465         if (np->header.callNumber != currentCallNumber) {
3466             if (rx_stats_active)
3467                 rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3468             MUTEX_EXIT(&call->lock);
3469             putConnection(conn);
3470             return np;
3471         }
3472         /* If the service security object index stamped in the packet does not
3473          * match the connection's security index, ignore the packet */
3474         if (np->header.securityIndex != conn->securityIndex) {
3475             MUTEX_EXIT(&call->lock);
3476             putConnection(conn);
3477             return np;
3478         }
3479
3480         /* If we're receiving the response, then all transmit packets are
3481          * implicitly acknowledged.  Get rid of them. */
3482         if (np->header.type == RX_PACKET_TYPE_DATA) {
3483 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3484             /* XXX Hack. Because we must release the global rx lock when
3485              * sending packets (osi_NetSend) we drop all acks while we're
3486              * traversing the tq in rxi_Start sending packets out because
3487              * packets may move to the freePacketQueue as result of being here!
3488              * So we drop these packets until we're safely out of the
3489              * traversing. Really ugly!
3490              * For fine grain RX locking, we set the acked field in the
3491              * packets and let rxi_Start remove them from the transmit queue.
3492              */
3493             if (call->flags & RX_CALL_TQ_BUSY) {
3494 #ifdef  RX_ENABLE_LOCKS
3495                 rxi_SetAcksInTransmitQueue(call);
3496 #else
3497                 putConnection(conn);
3498                 return np;      /* xmitting; drop packet */
3499 #endif
3500             } else {
3501                 rxi_ClearTransmitQueue(call, 0);
3502             }
3503 #else /* AFS_GLOBAL_RXLOCK_KERNEL */
3504             rxi_ClearTransmitQueue(call, 0);
3505 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3506         } else {
3507             if (np->header.type == RX_PACKET_TYPE_ACK) {
3508                 /* now check to see if this is an ack packet acknowledging that the
3509                  * server actually *lost* some hard-acked data.  If this happens we
3510                  * ignore this packet, as it may indicate that the server restarted in
3511                  * the middle of a call.  It is also possible that this is an old ack
3512                  * packet.  We don't abort the connection in this case, because this
3513                  * *might* just be an old ack packet.  The right way to detect a server
3514                  * restart in the midst of a call is to notice that the server epoch
3515                  * changed, btw.  */
3516                 /* XXX I'm not sure this is exactly right, since tfirst **IS**
3517                  * XXX unacknowledged.  I think that this is off-by-one, but
3518                  * XXX I don't dare change it just yet, since it will
3519                  * XXX interact badly with the server-restart detection
3520                  * XXX code in receiveackpacket.  */
3521                 if (ntohl(rx_GetInt32(np, FIRSTACKOFFSET)) < call->tfirst) {
3522                     if (rx_stats_active)
3523                         rx_atomic_inc(&rx_stats.spuriousPacketsRead);
3524                     MUTEX_EXIT(&call->lock);
3525                     putConnection(conn);
3526                     return np;
3527                 }
3528             }
3529         }                       /* else not a data packet */
3530     }
3531
3532     osirx_AssertMine(&call->lock, "rxi_ReceivePacket middle");
3533     /* Set remote user defined status from packet */
3534     call->remoteStatus = np->header.userStatus;
3535
3536     /* Now do packet type-specific processing */
3537     switch (np->header.type) {
3538     case RX_PACKET_TYPE_DATA:
3539         np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
3540                                    newcallp);
3541         break;
3542     case RX_PACKET_TYPE_ACK:
3543         /* Respond immediately to ack packets requesting acknowledgement
3544          * (ping packets) */
3545         if (np->header.flags & RX_REQUEST_ACK) {
3546             if (call->error)
3547                 (void)rxi_SendCallAbort(call, 0, 1, 0);
3548             else
3549                 (void)rxi_SendAck(call, 0, np->header.serial,
3550                                   RX_ACK_PING_RESPONSE, 1);
3551         }
3552         np = rxi_ReceiveAckPacket(call, np, 1);
3553         break;
3554     case RX_PACKET_TYPE_ABORT: {
3555         /* An abort packet: reset the call, passing the error up to the user. */
3556         /* What if error is zero? */
3557         /* What if the error is -1? the application will treat it as a timeout. */
3558         afs_int32 errdata = ntohl(*(afs_int32 *) rx_DataOf(np));
3559         dpf(("rxi_ReceivePacket ABORT rx_DataOf = %d\n", errdata));
3560         rxi_CallError(call, errdata);
3561         MUTEX_EXIT(&call->lock);
3562         putConnection(conn);
3563         return np;              /* xmitting; drop packet */
3564     }
3565     case RX_PACKET_TYPE_BUSY: {
3566         struct clock busyTime;
3567         clock_NewTime();
3568         clock_GetTime(&busyTime);
3569
3570         MUTEX_EXIT(&call->lock);
3571
3572         MUTEX_ENTER(&conn->conn_call_lock);
3573         MUTEX_ENTER(&call->lock);
3574         conn->lastBusy[call->channel] = busyTime.sec;
3575         call->flags |= RX_CALL_PEER_BUSY;
3576         MUTEX_EXIT(&call->lock);
3577         MUTEX_EXIT(&conn->conn_call_lock);
3578
3579         putConnection(conn);
3580         return np;
3581     }
3582
3583     case RX_PACKET_TYPE_ACKALL:
3584         /* All packets acknowledged, so we can drop all packets previously
3585          * readied for sending */
3586 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
3587         /* XXX Hack. We because we can't release the global rx lock when
3588          * sending packets (osi_NetSend) we drop all ack pkts while we're
3589          * traversing the tq in rxi_Start sending packets out because
3590          * packets may move to the freePacketQueue as result of being
3591          * here! So we drop these packets until we're safely out of the
3592          * traversing. Really ugly!
3593          * For fine grain RX locking, we set the acked field in the packets
3594          * and let rxi_Start remove the packets from the transmit queue.
3595          */
3596         if (call->flags & RX_CALL_TQ_BUSY) {
3597 #ifdef  RX_ENABLE_LOCKS
3598             rxi_SetAcksInTransmitQueue(call);
3599             break;
3600 #else /* RX_ENABLE_LOCKS */
3601             MUTEX_EXIT(&call->lock);
3602             putConnection(conn);
3603             return np;          /* xmitting; drop packet */
3604 #endif /* RX_ENABLE_LOCKS */
3605         }
3606 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
3607         rxi_ClearTransmitQueue(call, 0);
3608         break;
3609     default:
3610         /* Should not reach here, unless the peer is broken: send an abort
3611          * packet */
3612         rxi_CallError(call, RX_PROTOCOL_ERROR);
3613         np = rxi_SendCallAbort(call, np, 1, 0);
3614         break;
3615     };
3616     /* Note when this last legitimate packet was received, for keep-alive
3617      * processing.  Note, we delay getting the time until now in the hope that
3618      * the packet will be delivered to the user before any get time is required
3619      * (if not, then the time won't actually be re-evaluated here). */
3620     call->lastReceiveTime = clock_Sec();
3621     /* we've received a legit packet, so the channel is not busy */
3622     call->flags &= ~RX_CALL_PEER_BUSY;
3623     MUTEX_EXIT(&call->lock);
3624     putConnection(conn);
3625     return np;
3626 }
3627
3628 /* return true if this is an "interesting" connection from the point of view
3629     of someone trying to debug the system */
3630 int
3631 rxi_IsConnInteresting(struct rx_connection *aconn)
3632 {
3633     int i;
3634     struct rx_call *tcall;
3635
3636     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
3637         return 1;
3638
3639     for (i = 0; i < RX_MAXCALLS; i++) {
3640         tcall = aconn->call[i];
3641         if (tcall) {
3642             if ((tcall->state == RX_STATE_PRECALL)
3643                 || (tcall->state == RX_STATE_ACTIVE))
3644                 return 1;
3645             if ((tcall->mode == RX_MODE_SENDING)
3646                 || (tcall->mode == RX_MODE_RECEIVING))
3647                 return 1;
3648         }
3649     }
3650     return 0;
3651 }
3652
3653 #ifdef KERNEL
3654 /* if this is one of the last few packets AND it wouldn't be used by the
3655    receiving call to immediately satisfy a read request, then drop it on
3656    the floor, since accepting it might prevent a lock-holding thread from
3657    making progress in its reading. If a call has been cleared while in
3658    the precall state then ignore all subsequent packets until the call
3659    is assigned to a thread. */
3660
3661 static int
3662 TooLow(struct rx_packet *ap, struct rx_call *acall)
3663 {
3664     int rc = 0;
3665
3666     MUTEX_ENTER(&rx_quota_mutex);
3667     if (((ap->header.seq != 1) && (acall->flags & RX_CALL_CLEARED)
3668          && (acall->state == RX_STATE_PRECALL))
3669         || ((rx_nFreePackets < rxi_dataQuota + 2)
3670             && !((ap->header.seq < acall->rnext + rx_initSendWindow)
3671                  && (acall->flags & RX_CALL_READER_WAIT)))) {
3672         rc = 1;
3673     }
3674     MUTEX_EXIT(&rx_quota_mutex);
3675     return rc;
3676 }
3677 #endif /* KERNEL */
3678
3679 /*!
3680  * Clear the attach wait flag on a connection and proceed.
3681  *
3682  * Any processing waiting for a connection to be attached should be
3683  * unblocked. We clear the flag and do any other needed tasks.
3684  *
3685  * @param[in] conn
3686  *      the conn to unmark waiting for attach
3687  *
3688  * @pre conn's conn_data_lock must be locked before calling this function
3689  *
3690  */
3691 static void
3692 rxi_ConnClearAttachWait(struct rx_connection *conn)
3693 {
3694     /* Indicate that rxi_CheckReachEvent is no longer running by
3695      * clearing the flag.  Must be atomic under conn_data_lock to
3696      * avoid a new call slipping by: rxi_CheckConnReach holds
3697      * conn_data_lock while checking RX_CONN_ATTACHWAIT.
3698      */
3699     conn->flags &= ~RX_CONN_ATTACHWAIT;
3700     if (conn->flags & RX_CONN_NAT_PING) {
3701         conn->flags &= ~RX_CONN_NAT_PING;
3702         rxi_ScheduleNatKeepAliveEvent(conn);
3703     }
3704 }
3705
3706 static void
3707 rxi_CheckReachEvent(struct rxevent *event, void *arg1, void *arg2, int dummy)
3708 {
3709     struct rx_connection *conn = arg1;
3710     struct rx_call *acall = arg2;
3711     struct rx_call *call = acall;
3712     struct clock when, now;
3713     int i, waiting;
3714
3715     MUTEX_ENTER(&conn->conn_data_lock);
3716
3717     if (event) {
3718         rxevent_Put(conn->checkReachEvent);
3719         conn->checkReachEvent = NULL;
3720     }
3721
3722     waiting = conn->flags & RX_CONN_ATTACHWAIT;
3723     if (event) {
3724         putConnection(conn);
3725     }
3726     MUTEX_EXIT(&conn->conn_data_lock);
3727
3728     if (waiting) {
3729         if (!call) {
3730             MUTEX_ENTER(&conn->conn_call_lock);
3731             MUTEX_ENTER(&conn->conn_data_lock);
3732             for (i = 0; i < RX_MAXCALLS; i++) {
3733                 struct rx_call *tc = conn->call[i];
3734                 if (tc && tc->state == RX_STATE_PRECALL) {
3735                     call = tc;
3736                     break;
3737                 }
3738             }
3739             if (!call)
3740                 rxi_ConnClearAttachWait(conn);
3741             MUTEX_EXIT(&conn->conn_data_lock);
3742             MUTEX_EXIT(&conn->conn_call_lock);
3743         }
3744
3745         if (call) {
3746             if (call != acall)
3747                 MUTEX_ENTER(&call->lock);
3748             rxi_SendAck(call, NULL, 0, RX_ACK_PING, 0);
3749             if (call != acall)
3750                 MUTEX_EXIT(&call->lock);
3751
3752             clock_GetTime(&now);
3753             when = now;
3754             when.sec += RX_CHECKREACH_TIMEOUT;
3755             MUTEX_ENTER(&conn->conn_data_lock);
3756             if (!conn->checkReachEvent) {
3757                 MUTEX_ENTER(&rx_refcnt_mutex);
3758                 conn->refCount++;
3759                 MUTEX_EXIT(&rx_refcnt_mutex);
3760                 conn->checkReachEvent = rxevent_Post(&when, &now,
3761                                                      rxi_CheckReachEvent, conn,
3762                                                      NULL, 0);
3763             }
3764             MUTEX_EXIT(&conn->conn_data_lock);
3765         }
3766     }
3767 }
3768
3769 static int
3770 rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
3771 {
3772     struct rx_service *service = conn->service;
3773     struct rx_peer *peer = conn->peer;
3774     afs_uint32 now, lastReach;
3775
3776     if (service->checkReach == 0)
3777         return 0;
3778
3779     now = clock_Sec();
3780     MUTEX_ENTER(&peer->peer_lock);
3781     lastReach = peer->lastReachTime;
3782     MUTEX_EXIT(&peer->peer_lock);
3783     if (now - lastReach < RX_CHECKREACH_TTL)
3784         return 0;
3785
3786     MUTEX_ENTER(&conn->conn_data_lock);
3787     if (conn->flags & RX_CONN_ATTACHWAIT) {
3788         MUTEX_EXIT(&conn->conn_data_lock);
3789         return 1;
3790     }
3791     conn->flags |= RX_CONN_ATTACHWAIT;
3792     MUTEX_EXIT(&conn->conn_data_lock);
3793     if (!conn->checkReachEvent)
3794         rxi_CheckReachEvent(NULL, conn, call, 0);
3795
3796     return 1;
3797 }
3798
3799 /* try to attach call, if authentication is complete */
3800 static void
3801 TryAttach(struct rx_call *acall, osi_socket socket,
3802           int *tnop, struct rx_call **newcallp,
3803           int reachOverride)
3804 {
3805     struct rx_connection *conn = acall->conn;
3806
3807     if (conn->type == RX_SERVER_CONNECTION
3808         && acall->state == RX_STATE_PRECALL) {
3809         /* Don't attach until we have any req'd. authentication. */
3810         if (RXS_CheckAuthentication(conn->securityObject, conn) == 0) {
3811             if (reachOverride || rxi_CheckConnReach(conn, acall) == 0)
3812                 rxi_AttachServerProc(acall, socket, tnop, newcallp);
3813             /* Note:  this does not necessarily succeed; there
3814              * may not any proc available
3815              */
3816         } else {
3817             rxi_ChallengeOn(acall->conn);
3818         }
3819     }
3820 }
3821
3822 /* A data packet has been received off the interface.  This packet is
3823  * appropriate to the call (the call is in the right state, etc.).  This
3824  * routine can return a packet to the caller, for re-use */
3825
3826 static struct rx_packet *
3827 rxi_ReceiveDataPacket(struct rx_call *call,
3828                       struct rx_packet *np, int istack,
3829                       osi_socket socket, afs_uint32 host, u_short port,
3830                       int *tnop, struct rx_call **newcallp)
3831 {
3832     int ackNeeded = 0;          /* 0 means no, otherwise ack_reason */
3833     int newPackets = 0;
3834     int didHardAck = 0;
3835     int haveLast = 0;
3836     afs_uint32 seq;
3837     afs_uint32 serial=0, flags=0;
3838     int isFirst;
3839     struct rx_packet *tnp;
3840     if (rx_stats_active)
3841         rx_atomic_inc(&rx_stats.dataPacketsRead);
3842
3843 #ifdef KERNEL
3844     /* If there are no packet buffers, drop this new packet, unless we can find
3845      * packet buffers from inactive calls */
3846     if (!call->error
3847         && (rxi_OverQuota(RX_PACKET_CLASS_RECEIVE) || TooLow(np, call))) {
3848         MUTEX_ENTER(&rx_freePktQ_lock);
3849         rxi_NeedMorePackets = TRUE;
3850         MUTEX_EXIT(&rx_freePktQ_lock);
3851         if (rx_stats_active)
3852             rx_atomic_inc(&rx_stats.noPacketBuffersOnRead);
3853         call->rprev = np->header.serial;
3854         rxi_calltrace(RX_TRACE_DROP, call);
3855         dpf(("packet %"AFS_PTR_FMT" dropped on receipt - quota problems\n", np));
3856         /* We used to clear the receive queue here, in an attempt to free
3857          * packets. However this is unsafe if the queue has received a
3858          * soft ACK for the final packet */
3859         rxi_PostDelayedAckEvent(call, &rx_softAckDelay);
3860
3861         /* we've damaged this call already, might as well do it in. */
3862         return np;
3863     }
3864 #endif /* KERNEL */
3865
3866     /*
3867      * New in AFS 3.5, if the RX_JUMBO_PACKET flag is set then this
3868      * packet is one of several packets transmitted as a single
3869      * datagram. Do not send any soft or hard acks until all packets
3870      * in a jumbogram have been processed. Send negative acks right away.
3871      */
3872     for (isFirst = 1, tnp = NULL; isFirst || tnp; isFirst = 0) {
3873         /* tnp is non-null when there are more packets in the
3874          * current jumbo gram */
3875         if (tnp) {
3876             if (np)
3877                 rxi_FreePacket(np);
3878             np = tnp;
3879         }
3880
3881         seq = np->header.seq;
3882         serial = np->header.serial;
3883         flags = np->header.flags;
3884
3885         /* If the call is in an error state, send an abort message */
3886         if (call->error)
3887             return rxi_SendCallAbort(call, np, istack, 0);
3888
3889         /* The RX_JUMBO_PACKET is set in all but the last packet in each
3890          * AFS 3.5 jumbogram. */
3891         if (flags & RX_JUMBO_PACKET) {
3892             tnp = rxi_SplitJumboPacket(np, host, port, isFirst);
3893         } else {
3894             tnp = NULL;
3895         }
3896
3897         if (np->header.spare != 0) {
3898             MUTEX_ENTER(&call->conn->conn_data_lock);
3899             call->conn->flags |= RX_CONN_USING_PACKET_CKSUM;
3900             MUTEX_EXIT(&call->conn->conn_data_lock);
3901         }
3902
3903         /* The usual case is that this is the expected next packet */
3904         if (seq == call->rnext) {
3905
3906             /* Check to make sure it is not a duplicate of one already queued */
3907             if (queue_IsNotEmpty(&call->rq)
3908                 && queue_First(&call->rq, rx_packet)->header.seq == seq) {
3909                 if (rx_stats_active)
3910                     rx_atomic_inc(&rx_stats.dupPacketsRead);
3911                 dpf(("packet %"AFS_PTR_FMT" dropped on receipt - duplicate\n", np));
3912                 rxevent_Cancel(&call->delayedAckEvent, call,
3913                                RX_CALL_REFCOUNT_DELAY);
3914                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
3915                 ackNeeded = 0;
3916                 call->rprev = seq;
3917                 continue;
3918             }
3919
3920             /* It's the next packet. Stick it on the receive queue
3921              * for this call. Set newPackets to make sure we wake
3922              * the reader once all packets have been processed */
3923 #ifdef RX_TRACK_PACKETS
3924             np->flags |= RX_PKTFLAG_RQ;
3925 #endif
3926             queue_Prepend(&call->rq, np);
3927 #ifdef RXDEBUG_PACKET
3928             call->rqc++;
3929 #endif /* RXDEBUG_PACKET */
3930             call->nSoftAcks++;
3931             np = NULL;          /* We can't use this anymore */
3932             newPackets = 1;
3933
3934             /* If an ack is requested then set a flag to make sure we
3935              * send an acknowledgement for this packet */
3936             if (flags & RX_REQUEST_ACK) {
3937                 ackNeeded = RX_ACK_REQUESTED;
3938             }
3939
3940             /* Keep track of whether we have received the last packet */
3941             if (flags & RX_LAST_PACKET) {
3942                 call->flags |= RX_CALL_HAVE_LAST;
3943                 haveLast = 1;
3944             }
3945
3946             /* Check whether we have all of the packets for this call */
3947             if (call->flags & RX_CALL_HAVE_LAST) {
3948                 afs_uint32 tseq;        /* temporary sequence number */
3949                 struct rx_packet *tp;   /* Temporary packet pointer */
3950                 struct rx_packet *nxp;  /* Next pointer, for queue_Scan */
3951
3952                 for (tseq = seq, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
3953                     if (tseq != tp->header.seq)
3954                         break;
3955                     if (tp->header.flags & RX_LAST_PACKET) {
3956                         call->flags |= RX_CALL_RECEIVE_DONE;
3957                         break;
3958                     }
3959                     tseq++;
3960                 }
3961             }
3962
3963             /* Provide asynchronous notification for those who want it
3964              * (e.g. multi rx) */
3965             if (call->arrivalProc) {
3966                 (*call->arrivalProc) (call, call->arrivalProcHandle,
3967                                       call->arrivalProcArg);
3968                 call->arrivalProc = (void (*)())0;
3969             }
3970
3971             /* Update last packet received */
3972             call->rprev = seq;
3973
3974             /* If there is no server process serving this call, grab
3975              * one, if available. We only need to do this once. If a
3976              * server thread is available, this thread becomes a server
3977              * thread and the server thread becomes a listener thread. */
3978             if (isFirst) {
3979                 TryAttach(call, socket, tnop, newcallp, 0);
3980             }
3981         }
3982         /* This is not the expected next packet. */
3983         else {
3984             /* Determine whether this is a new or old packet, and if it's
3985              * a new one, whether it fits into the current receive window.
3986              * Also figure out whether the packet was delivered in sequence.
3987              * We use the prev variable to determine whether the new packet
3988              * is the successor of its immediate predecessor in the
3989              * receive queue, and the missing flag to determine whether
3990              * any of this packets predecessors are missing.  */
3991
3992             afs_uint32 prev;    /* "Previous packet" sequence number */
3993             struct rx_packet *tp;       /* Temporary packet pointer */
3994             struct rx_packet *nxp;      /* Next pointer, for queue_Scan */
3995             int missing;        /* Are any predecessors missing? */
3996
3997             /* If the new packet's sequence number has been sent to the
3998              * application already, then this is a duplicate */
3999             if (seq < call->rnext) {
4000                 if (rx_stats_active)
4001                     rx_atomic_inc(&rx_stats.dupPacketsRead);
4002                 rxevent_Cancel(&call->delayedAckEvent, call,
4003                                RX_CALL_REFCOUNT_DELAY);
4004                 np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE, istack);
4005                 ackNeeded = 0;
4006                 call->rprev = seq;
4007                 continue;
4008             }
4009
4010             /* If the sequence number is greater than what can be
4011              * accomodated by the current window, then send a negative
4012              * acknowledge and drop the packet */
4013             if ((call->rnext + call->rwind) <= seq) {
4014                 rxevent_Cancel(&call->delayedAckEvent, call,
4015                                RX_CALL_REFCOUNT_DELAY);
4016                 np = rxi_SendAck(call, np, serial, RX_ACK_EXCEEDS_WINDOW,
4017                                  istack);
4018                 ackNeeded = 0;
4019                 call->rprev = seq;
4020                 continue;
4021             }
4022
4023             /* Look for the packet in the queue of old received packets */
4024             for (prev = call->rnext - 1, missing =
4025                  0, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
4026                 /*Check for duplicate packet */
4027                 if (seq == tp->header.seq) {
4028                     if (rx_stats_active)
4029                         rx_atomic_inc(&rx_stats.dupPacketsRead);
4030                     rxevent_Cancel(&call->delayedAckEvent, call,
4031                                    RX_CALL_REFCOUNT_DELAY);
4032                     np = rxi_SendAck(call, np, serial, RX_ACK_DUPLICATE,
4033                                      istack);
4034                     ackNeeded = 0;
4035                     call->rprev = seq;
4036                     goto nextloop;
4037                 }
4038                 /* If we find a higher sequence packet, break out and
4039                  * insert the new packet here. */
4040                 if (seq < tp->header.seq)
4041                     break;
4042                 /* Check for missing packet */
4043                 if (tp->header.seq != prev + 1) {
4044                     missing = 1;
4045                 }
4046
4047                 prev = tp->header.seq;
4048             }
4049
4050             /* Keep track of whether we have received the last packet. */
4051             if (flags & RX_LAST_PACKET) {
4052                 call->flags |= RX_CALL_HAVE_LAST;
4053             }
4054
4055             /* It's within the window: add it to the the receive queue.
4056              * tp is left by the previous loop either pointing at the
4057              * packet before which to insert the new packet, or at the
4058              * queue head if the queue is empty or the packet should be
4059              * appended. */
4060 #ifdef RX_TRACK_PACKETS
4061             np->flags |= RX_PKTFLAG_RQ;
4062 #endif
4063 #ifdef RXDEBUG_PACKET
4064             call->rqc++;
4065 #endif /* RXDEBUG_PACKET */
4066             queue_InsertBefore(tp, np);
4067             call->nSoftAcks++;
4068             np = NULL;
4069
4070             /* Check whether we have all of the packets for this call */
4071             if ((call->flags & RX_CALL_HAVE_LAST)
4072                 && !(call->flags & RX_CALL_RECEIVE_DONE)) {
4073                 afs_uint32 tseq;        /* temporary sequence number */
4074
4075                 for (tseq =
4076                      call->rnext, queue_Scan(&call->rq, tp, nxp, rx_packet)) {
4077                     if (tseq != tp->header.seq)
4078                         break;
4079                     if (tp->header.flags & RX_LAST_PACKET) {
4080                         call->flags |= RX_CALL_RECEIVE_DONE;
4081                         break;
4082                     }
4083                     tseq++;
4084                 }
4085             }
4086
4087             /* We need to send an ack of the packet is out of sequence,
4088              * or if an ack was requested by the peer. */
4089             if (seq != prev + 1 || missing) {
4090                 ackNeeded = RX_ACK_OUT_OF_SEQUENCE;
4091             } else if (flags & RX_REQUEST_ACK) {
4092                 ackNeeded = RX_ACK_REQUESTED;
4093             }
4094
4095             /* Acknowledge the last packet for each call */
4096             if (flags & RX_LAST_PACKET) {
4097                 haveLast = 1;
4098             }
4099
4100             call->rprev = seq;
4101         }
4102       nextloop:;
4103     }
4104
4105     if (newPackets) {
4106         /*
4107          * If the receiver is waiting for an iovec, fill the iovec
4108          * using the data from the receive queue */
4109         if (call->flags & RX_CALL_IOVEC_WAIT) {
4110             didHardAck = rxi_FillReadVec(call, serial);
4111             /* the call may have been aborted */
4112             if (call->error) {
4113                 return NULL;
4114             }
4115             if (didHardAck) {
4116                 ackNeeded = 0;
4117             }
4118         }
4119
4120         /* Wakeup the reader if any */
4121         if ((call->flags & RX_CALL_READER_WAIT)
4122             && (!(call->flags & RX_CALL_IOVEC_WAIT) || !(call->iovNBytes)
4123                 || (call->iovNext >= call->iovMax)
4124                 || (call->flags & RX_CALL_RECEIVE_DONE))) {
4125             call->flags &= ~RX_CALL_READER_WAIT;
4126 #ifdef  RX_ENABLE_LOCKS
4127             CV_BROADCAST(&call->cv_rq);
4128 #else
4129             osi_rxWakeup(&call->rq);
4130 #endif
4131         }
4132     }
4133
4134     /*
4135      * Send an ack when requested by the peer, or once every
4136      * rxi_SoftAckRate packets until the last packet has been
4137      * received. Always send a soft ack for the last packet in
4138      * the server's reply. */
4139     if (ackNeeded) {
4140         rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4141         np = rxi_SendAck(call, np, serial, ackNeeded, istack);
4142     } else if (call->nSoftAcks > (u_short) rxi_SoftAckRate) {
4143         rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4144         np = rxi_SendAck(call, np, serial, RX_ACK_IDLE, istack);
4145     } else if (call->nSoftAcks) {
4146         if (haveLast && !(flags & RX_CLIENT_INITIATED))
4147             rxi_PostDelayedAckEvent(call, &rx_lastAckDelay);
4148         else
4149             rxi_PostDelayedAckEvent(call, &rx_softAckDelay);
4150     } else if (call->flags & RX_CALL_RECEIVE_DONE) {
4151         rxevent_Cancel(&call->delayedAckEvent, call, RX_CALL_REFCOUNT_DELAY);
4152     }
4153
4154     return np;
4155 }
4156
4157 static void
4158 rxi_UpdatePeerReach(struct rx_connection *conn, struct rx_call *acall)
4159 {
4160     struct rx_peer *peer = conn->peer;
4161
4162     MUTEX_ENTER(&peer->peer_lock);
4163     peer->lastReachTime = clock_Sec();
4164     MUTEX_EXIT(&peer->peer_lock);
4165
4166     MUTEX_ENTER(&conn->conn_data_lock);
4167     if (conn->flags & RX_CONN_ATTACHWAIT) {
4168         int i;
4169
4170         rxi_ConnClearAttachWait(conn);
4171         MUTEX_EXIT(&conn->conn_data_lock);
4172
4173         for (i = 0; i < RX_MAXCALLS; i++) {
4174             struct rx_call *call = conn->call[i];
4175             if (call) {
4176                 if (call != acall)
4177                     MUTEX_ENTER(&call->lock);
4178                 /* tnop can be null if newcallp is null */
4179                 TryAttach(call, (osi_socket) - 1, NULL, NULL, 1);
4180                 if (call != acall)
4181                     MUTEX_EXIT(&call->lock);
4182             }
4183         }
4184     } else
4185         MUTEX_EXIT(&conn->conn_data_lock);
4186 }
4187
4188 #if defined(RXDEBUG) && defined(AFS_NT40_ENV)
4189 static const char *
4190 rx_ack_reason(int reason)
4191 {
4192     switch (reason) {
4193     case RX_ACK_REQUESTED:
4194         return "requested";
4195     case RX_ACK_DUPLICATE:
4196         return "duplicate";
4197     case RX_ACK_OUT_OF_SEQUENCE:
4198         return "sequence";
4199     case RX_ACK_EXCEEDS_WINDOW:
4200         return "window";
4201     case RX_ACK_NOSPACE:
4202         return "nospace";
4203     case RX_ACK_PING:
4204         return "ping";
4205     case RX_ACK_PING_RESPONSE:
4206         return "response";
4207     case RX_ACK_DELAY:
4208         return "delay";
4209     case RX_ACK_IDLE:
4210         return "idle";
4211     default:
4212         return "unknown!!";
4213     }
4214 }
4215 #endif
4216
4217
4218 /* The real smarts of the whole thing.  */
4219 static struct rx_packet *
4220 rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
4221                      int istack)
4222 {
4223     struct rx_ackPacket *ap;
4224     int nAcks;
4225     struct rx_packet *tp;
4226     struct rx_packet *nxp;      /* Next packet pointer for queue_Scan */
4227     struct rx_connection *conn = call->conn;
4228     struct rx_peer *peer = conn->peer;
4229     struct clock now;           /* Current time, for RTT calculations */
4230     afs_uint32 first;
4231     afs_uint32 prev;
4232     afs_uint32 serial;
4233     int nbytes;
4234     int missing;
4235     int acked;
4236     int nNacked = 0;
4237     int newAckCount = 0;
4238     int maxDgramPackets = 0;    /* Set if peer supports AFS 3.5 jumbo datagrams */
4239     int pktsize = 0;            /* Set if we need to update the peer mtu */
4240     int conn_data_locked = 0;
4241
4242     if (rx_stats_active)
4243         rx_atomic_inc(&rx_stats.ackPacketsRead);
4244     ap = (struct rx_ackPacket *)rx_DataOf(np);
4245     nbytes = rx_Contiguous(np) - (int)((ap->acks) - (u_char *) ap);
4246     if (nbytes < 0)
4247         return np;              /* truncated ack packet */
4248
4249     /* depends on ack packet struct */
4250     nAcks = MIN((unsigned)nbytes, (unsigned)ap->nAcks);
4251     first = ntohl(ap->firstPacket);
4252     prev = ntohl(ap->previousPacket);
4253     serial = ntohl(ap->serial);
4254
4255     /* Ignore ack packets received out of order */
4256     if (first < call->tfirst ||
4257         (first == call->tfirst && prev < call->tprev)) {
4258         return np;
4259     }
4260
4261     call->tprev = prev;
4262
4263     if (np->header.flags & RX_SLOW_START_OK) {
4264         call->flags |= RX_CALL_SLOW_START_OK;
4265     }
4266
4267     if (ap->reason == RX_ACK_PING_RESPONSE)
4268         rxi_UpdatePeerReach(conn, call);
4269
4270     if (conn->lastPacketSizeSeq) {
4271         MUTEX_ENTER(&conn->conn_data_lock);
4272         conn_data_locked = 1;
4273         if ((first > conn->lastPacketSizeSeq) && (conn->lastPacketSize)) {
4274             pktsize = conn->lastPacketSize;
4275             conn->lastPacketSize = conn->lastPacketSizeSeq = 0;
4276         }
4277     }
4278     if ((ap->reason == RX_ACK_PING_RESPONSE) && (conn->lastPingSizeSer)) {
4279         if (!conn_data_locked) {
4280             MUTEX_ENTER(&conn->conn_data_lock);
4281             conn_data_locked = 1;
4282         }
4283         if ((conn->lastPingSizeSer == serial) && (conn->lastPingSize)) {
4284             /* process mtu ping ack */
4285             pktsize = conn->lastPingSize;
4286             conn->lastPingSizeSer = conn->lastPingSize = 0;
4287         }
4288     }
4289
4290     if (conn_data_locked) {
4291         MUTEX_EXIT(&conn->conn_data_lock);
4292         conn_data_locked = 0;
4293     }
4294 #ifdef RXDEBUG
4295 #ifdef AFS_NT40_ENV
4296     if (rxdebug_active) {
4297         char msg[512];
4298         size_t len;
4299
4300         len = _snprintf(msg, sizeof(msg),
4301                         "tid[%d] RACK: reason %s serial %u previous %u seq %u first %u acks %u space %u ",
4302                          GetCurrentThreadId(), rx_ack_reason(ap->reason),
4303                          ntohl(ap->serial), ntohl(ap->previousPacket),
4304                          (unsigned int)np->header.seq, ntohl(ap->firstPacket),
4305                          ap->nAcks, ntohs(ap->bufferSpace) );
4306         if (nAcks) {
4307             int offset;
4308
4309             for (offset = 0; offset < nAcks && len < sizeof(msg); offset++)
4310                 msg[len++] = (ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*');
4311         }
4312         msg[len++]='\n';
4313         msg[len] = '\0';
4314         OutputDebugString(msg);
4315     }
4316 #else /* AFS_NT40_ENV */
4317     if (rx_Log) {
4318         fprintf(rx_Log,
4319                 "RACK: reason %x previous %u seq %u serial %u first %u",
4320                 ap->reason, ntohl(ap->previousPacket),
4321                 (unsigned int)np->header.seq, (unsigned int)serial,
4322                 ntohl(ap->firstPacket));
4323         if (nAcks) {
4324             int offset;
4325             for (offset = 0; offset < nAcks; offset++)
4326                 putc(ap->acks[offset] == RX_ACK_TYPE_NACK ? '-' : '*',
4327                      rx_Log);
4328         }
4329         putc('\n', rx_Log);
4330     }
4331 #endif /* AFS_NT40_ENV */
4332 #endif
4333
4334     MUTEX_ENTER(&peer->peer_lock);
4335     if (pktsize) {
4336         /*
4337          * Start somewhere. Can't assume we can send what we can receive,
4338          * but we are clearly receiving.
4339          */
4340         if (!peer->maxPacketSize)
4341             peer->maxPacketSize = RX_MIN_PACKET_SIZE+RX_IPUDP_SIZE;
4342
4343         if (pktsize > peer->maxPacketSize) {
4344             peer->maxPacketSize = pktsize;
4345             if ((pktsize-RX_IPUDP_SIZE > peer->ifMTU)) {
4346                 peer->ifMTU=pktsize-RX_IPUDP_SIZE;
4347                 peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
4348                 rxi_ScheduleGrowMTUEvent(call, 1);
4349             }
4350         }
4351     }
4352
4353     clock_GetTime(&now);
4354
4355     /* The transmit queue splits into 4 sections.
4356      *
4357      * The first section is packets which have now been acknowledged
4358      * by a window size change in the ack. These have reached the
4359      * application layer, and may be discarded. These are packets
4360      * with sequence numbers < ap->firstPacket.
4361      *
4362      * The second section is packets which have sequence numbers in
4363      * the range ap->firstPacket to ap->firstPacket + ap->nAcks. The
4364      * contents of the packet's ack array determines whether these
4365      * packets are acknowledged or not.
4366      *
4367      * The third section is packets which fall above the range
4368      * addressed in the ack packet. These have not yet been received
4369      * by the peer.
4370      *
4371      * The four section is packets which have not yet been transmitted.
4372      * These packets will have a header.serial of 0.
4373      */
4374
4375     /* First section - implicitly acknowledged packets that can be
4376      * disposed of
4377      */
4378
4379     tp = queue_First(&call->tq, rx_packet);
4380     while(!queue_IsEnd(&call->tq, tp) && tp->header.seq < first) {
4381         struct rx_packet *next;
4382
4383         next = queue_Next(tp, rx_packet);
4384         call->tfirst = tp->header.seq + 1;
4385
4386         if (!(tp->flags & RX_PKTFLAG_ACKED)) {
4387             newAckCount++;
4388             rxi_ComputeRoundTripTime(tp, ap, call, peer, &now);
4389         }
4390
4391 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
4392         /* XXX Hack. Because we have to release the global rx lock when sending
4393          * packets (osi_NetSend) we drop all acks while we're traversing the tq
4394          * in rxi_Start sending packets out because packets may move to the
4395          * freePacketQueue as result of being here! So we drop these packets until
4396          * we're safely out of the traversing. Really ugly!
4397