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