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