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