addb64cff460d6bc5a7c1f5725492ed8e98b54a2
[openafs.git] / src / rx / rx.h
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 #ifdef KDUMP_RX_LOCK
11 /* kdump for SGI needs MP and SP versions of rx_serverQueueEntry,
12  * rx_peer, rx_connection and rx_call structs. rx.h gets included a
13  * second time to pick up mp_ versions of those structs. Currently
14  * the affected struct's have #ifdef's in them for the second pass.
15  * This should change once we start using only ANSI compilers.
16  * Actually, kdump does not use rx_serverQueueEntry, but I'm including
17  * it for completeness.
18  */
19 #undef _RX_
20 #endif
21
22 #ifndef _RX_
23 #define _RX_
24
25 #ifndef KDUMP_RX_LOCK
26 /* Substitute VOID (char) for void, because some compilers are confused by void
27  * in some situations */
28 #ifndef AFS_NT40_ENV
29 #define VOID    char
30 #endif
31
32 #ifdef  KERNEL
33 #include "../rx/rx_kmutex.h"
34 #include "../rx/rx_kernel.h"
35 #include "../rx/rx_clock.h"
36 #include "../rx/rx_event.h"
37 #include "../rx/rx_queue.h"
38 #include "../rx/rx_packet.h"
39 #include "../rx/rx_misc.h"
40 #include "../netinet/in.h"
41 #else /* KERNEL */
42 # include <sys/types.h>
43 # include <stdio.h>
44 #ifdef AFS_PTHREAD_ENV
45 # include <rx/rx_pthread.h>
46 #else
47 # include "rx_lwp.h"
48 #endif
49 #ifdef AFS_NT40_ENV
50 #include <malloc.h>
51 #endif
52 # include "rx_user.h"
53 # include "rx_clock.h"
54 # include "rx_event.h"
55 # include "rx_packet.h"
56 # include "rx_misc.h"
57 #ifndef AFS_NT40_ENV
58 # include <netinet/in.h>
59 #endif
60 #endif /* KERNEL */
61
62
63 /* Configurable parameters */
64 #define RX_IDLE_DEAD_TIME       60      /* default idle dead time */
65 #define RX_MAX_SERVICES         20      /* Maximum number of services that may be installed */
66 #define RX_DEFAULT_STACK_SIZE   16000   /* Default process stack size; overriden by rx_SetStackSize */
67
68 /* This parameter should not normally be changed */
69 #define RX_PROCESS_PRIORITY     LWP_NORMAL_PRIORITY
70
71 /* backoff is fixed point binary.  Ie, units of 1/4 seconds */
72 #define MAXBACKOFF 0x1F
73
74 #define ADDRSPERSITE 16
75
76 /* Exported interfaces XXXX clean this up:  not all of these are exported*/
77 int rx_Init();
78 struct rx_service *rx_NewService();
79 struct rx_connection *rx_NewConnection();
80 struct rx_call *rx_NewCall();
81 struct rx_call *rx_GetCall();  /* Not normally used, but not obsolete */
82 afs_int32 rx_EndCall();
83 int rx_AllocPackets();
84 void rx_FreePackets();
85 int rx_WriteProc();
86 int rx_WritevProc();
87 int rx_WriteProc32();
88 int rx_WritevAlloc();
89 int rx_ReadProc();
90 int rx_ReadvProc();
91 int rx_ReadProc32();
92 void rx_FlushWrite();
93 void rxi_DeleteCachedConnections();
94 void rxi_DestroyConnection();
95 void rxi_CleanupConnection();
96 int rxi_Listen();
97 int rxi_WriteProc();
98 int rxi_WritevProc();
99 int rxi_WritevAlloc();
100 int rxi_ReadProc();
101 int rxi_ReadvProc();
102 int rxi_FillReadVec();
103 void rxi_FlushWrite();
104 int rxi_getAllAddrMaskMtu();
105 int rx_getAllAddr();
106 void rxi_FreePacket();
107 void rxi_FreePacketNoLock();
108 int rxi_AllocDataBuf();
109 void rxi_RestoreDataBufs();
110 void rxi_Sleep();
111 void rxi_InitializeThreadSupport();
112 int rxi_Recvmsg();
113 int rxi_Sendmsg();
114 int rxi_IsConnInteresting();
115 afs_int32 rx_SlowReadPacket();
116 afs_int32 rx_SlowWritePacket();
117 afs_int32 rx_SlowGetInt32();
118 void rxi_StopListener();
119 void rxi_InitPeerParams();
120 void rxi_FreeAllPackets();
121 void rxi_SendPacketList();
122 void rxi_SendPacket();
123 void rxi_MorePackets();
124 void rxi_MorePacketsNoLock();
125 void rxi_PacketsUnWait();
126 void rx_CheckPackets();
127 void rxi_Wakeup();
128 void rx_PrintStats();
129 void rx_PrintPeerStats();
130 void rx_SetArrivalProc();
131 void rx_Finalize();
132 void rx_GetIFInfo();
133 void shutdown_rxevent();
134 int clock_UnInit();
135 void rxi_Delay(int);
136 #ifndef KERNEL
137 typedef void (*rx_destructor_t)(void *);
138 int rx_KeyCreate(rx_destructor_t);
139 void *rx_GetSpecific(struct rx_connection *conn, int key);
140 void rx_SetSpecific(struct rx_connection *conn, int key, void *ptr);
141 osi_socket rxi_GetUDPSocket(u_short port);
142 #endif /* KERNEL */
143 int ntoh_syserr_conv(int error);
144
145 #define RX_WAIT     1
146 #define RX_DONTWAIT 0
147
148 #define rx_ConnectionOf(call)           ((call)->conn)
149 #define rx_PeerOf(conn)                 ((conn)->peer)
150 #define rx_HostOf(peer)                 ((peer)->host)
151 #define rx_PortOf(peer)                 ((peer)->port)
152 #define rx_SetLocalStatus(call, status) ((call)->localStatus = (status))
153 #define rx_GetLocalStatus(call, status) ((call)->localStatus)
154 #define rx_GetRemoteStatus(call)        ((call)->remoteStatus)
155 #define rx_Error(call)                  ((call)->error)
156 #define rx_ConnError(conn)              ((conn)->error)
157 #define rx_IsServerConn(conn)           ((conn)->type == RX_SERVER_CONNECTION)
158 #define rx_IsClientConn(conn)           ((conn)->type == RX_CLIENT_CONNECTION)
159 /* Don't use these; use the IsServerConn style */
160 #define rx_ServerConn(conn)             ((conn)->type == RX_SERVER_CONNECTION)
161 #define rx_ClientConn(conn)             ((conn)->type == RX_CLIENT_CONNECTION)
162 #define rx_IsUsingPktCksum(conn)        ((conn)->flags & RX_CONN_USING_PACKET_CKSUM)
163 #define rx_ServiceIdOf(conn)            ((conn)->serviceId)
164 #define rx_SecurityClassOf(conn)        ((conn)->securityIndex)
165 #define rx_SecurityObjectOf(conn)       ((conn)->securityObject)
166
167 /*******************
168  * Macros callable by the user to further define attributes of a
169  * service.  Must be called before rx_StartServer
170  */
171
172 /* Set the service stack size.  This currently just sets the stack
173  * size for all processes to be the maximum seen, so far */
174 #define rx_SetStackSize(service, stackSize) \
175   rx_stackSize = (((stackSize) > rx_stackSize)? stackSize: rx_stackSize)
176
177 /* Set minimum number of processes guaranteed to be available for this
178  * service at all times */
179 #define rx_SetMinProcs(service, min) ((service)->minProcs = (min))
180
181 /* Set maximum number of processes that will be made available to this
182  * service (also a guarantee that this number will be made available
183  * if there is no competition) */
184 #define rx_SetMaxProcs(service, max) ((service)->maxProcs = (max))
185
186 /* Define a procedure to be called just before a server connection is destroyed */
187 #define rx_SetDestroyConnProc(service,proc) ((service)->destroyConnProc = (proc))
188
189 /* Define procedure to set service dead time */
190 #define rx_SetIdleDeadTime(service,time) ((service)->idleDeadTime = (time))
191
192 /* Define procedures for getting and setting before and after execute-request procs */
193 #define rx_SetAfterProc(service,proc) ((service)->afterProc = (proc))
194 #define rx_SetBeforeProc(service,proc) ((service)->beforeProc = (proc))
195 #define rx_GetAfterProc(service) ((service)->afterProc)
196 #define rx_GetBeforeProc(service) ((service)->beforeProc)
197
198 /* Define a procedure to be called when a server connection is created */
199 #define rx_SetNewConnProc(service, proc) ((service)->newConnProc = (proc))
200
201 /* NOTE:  We'll probably redefine the following three routines, again, sometime. */
202
203 /* Set the connection dead time for any connections created for this service (server only) */
204 #define rx_SetServiceDeadTime(service, seconds) ((service)->secondsUntilDead = (seconds))
205
206 /* Set connection dead time, for a specific client or server connection */
207 extern void rx_SetConnDeadTime();
208
209 /* Set connection hard timeout for a connection */
210 #define rx_SetConnHardDeadTime(conn, seconds) ((conn)->hardDeadTime = (seconds))
211
212 /* Set the overload threshold and the overload error */
213 #define rx_SetBusyThreshold(threshold, code) (rx_BusyThreshold=(threshold),rx_BusyError=(code))
214
215 /* If this flag is set,no new requests are processed by rx, all new requests are
216 returned with an error code of RX_CALL_DEAD ( transient error ) */
217 #define rx_SetRxTranquil()              (rx_tranquil = 1)
218 #define rx_ClearRxTranquil()            (rx_tranquil = 0)
219
220 /* Set the threshold and time to delay aborts for consecutive errors */
221 #define rx_SetCallAbortThreshold(A) (rxi_callAbortThreshhold = (A))
222 #define rx_SetCallAbortDelay(A) (rxi_callAbortDelay = (A))
223 #define rx_SetConnAbortThreshold(A) (rxi_connAbortThreshhold = (A))
224 #define rx_SetConnAbortDelay(A) (rxi_connAbortDelay = (A))
225
226 #define cpspace(call) ((call)->curlen)
227 #define cppos(call) ((call)->curpos)
228
229 #define rx_Read(call, buf, nbytes)   rx_ReadProc(call, buf, nbytes)
230 #define rx_Read32(call, value)   rx_ReadProc32(call, value)
231 #define rx_Readv(call, iov, nio, maxio, nbytes) \
232    rx_ReadvProc(call, iov, nio, maxio, nbytes)
233 #define rx_Write(call, buf, nbytes) rx_WriteProc(call, buf, nbytes)
234 #define rx_Write32(call, value) rx_WriteProc32(call, value)
235 #define rx_Writev(call, iov, nio, nbytes) \
236    rx_WritevProc(call, iov, nio, nbytes)
237
238 /* This is the maximum size data packet that can be sent on this connection, accounting for security module-specific overheads. */
239 #define rx_MaxUserDataSize(call)                ((call)->MTU - RX_HEADER_SIZE - (call)->conn->securityHeaderSize - (call)->conn->securityMaxTrailerSize)
240
241 /* Macros to turn the hot thread feature on and off. Enabling hot threads
242  * allows the listener thread to trade places with an idle worker thread,
243  * which moves the context switch from listener to worker out of the
244  * critical path.
245  */
246 #define rx_EnableHotThread()            (rx_enable_hot_thread = 1)
247 #define rx_DisableHotThread()           (rx_enable_hot_thread = 0)
248
249 struct rx_securityObjectStats {
250     char type;                          /* 0:unk 1:null,2:vab 3:kad */
251     char level;
252     char sparec[10];                    /* force correct alignment */
253     afs_int32 flags;                            /* 1=>unalloc, 2=>auth, 4=>expired */
254     afs_uint32 expires;
255     afs_uint32 packetsReceived;
256     afs_uint32 packetsSent;
257     afs_uint32 bytesReceived;
258     afs_uint32 bytesSent;
259     short spares[4];
260     afs_int32 sparel[8];
261 };
262
263 /* XXXX (rewrite this description) A security class object contains a set of
264  * procedures and some private data to implement a security model for rx
265  * connections.  These routines are called by rx as appropriate.  Rx knows
266  * nothing about the internal details of any particular security model, or
267  * about security state.  Rx does maintain state per connection on behalf of
268  * the security class.  Each security class implementation is also expected to
269  * provide routines to create these objects.  Rx provides a basic routine to
270  * allocate one of these objects; this routine must be called by the class. */
271 struct rx_securityClass {
272     struct rx_securityOps {
273         int (*op_Close)(/* obj */);
274         int (*op_NewConnection)(/* obj, conn */);
275         int (*op_PreparePacket)(/* obj, call, packet */);
276         int (*op_SendPacket)(/*obj, call, packet */);
277         int (*op_CheckAuthentication)(/*obj,conn*/);
278         int (*op_CreateChallenge)(/*obj,conn*/);
279         int (*op_GetChallenge)(/*obj,conn,packet*/);
280         int (*op_GetResponse)(/*obj,conn,packet*/);
281         int (*op_CheckResponse)(/*obj,conn,packet*/);
282         int (*op_CheckPacket) (/*obj,call,packet*/);
283         int (*op_DestroyConnection)(/*obj, conn*/);
284         int (*op_GetStats)(/*obj, conn, stats*/);
285         int (*op_Spare1)();
286         int (*op_Spare2)();
287         int (*op_Spare3)();
288     } *ops;
289     VOID *privateData;
290     int refCount;
291 };
292
293 #define RXS_OP(obj,op,args) ((obj->ops->op_ ## op) ? (*(obj)->ops->op_ ## op)args : 0)
294
295 #define RXS_Close(obj) RXS_OP(obj,Close,(obj))
296 #define RXS_NewConnection(obj,conn) RXS_OP(obj,NewConnection,(obj,conn))
297 #define RXS_PreparePacket(obj,call,packet) RXS_OP(obj,PreparePacket,(obj,call,packet))
298 #define RXS_SendPacket(obj,call,packet) RXS_OP(obj,SendPacket,(obj,call,packet))
299 #define RXS_CheckAuthentication(obj,conn) RXS_OP(obj,CheckAuthentication,(obj,conn))
300 #define RXS_CreateChallenge(obj,conn) RXS_OP(obj,CreateChallenge,(obj,conn))
301 #define RXS_GetChallenge(obj,conn,packet) RXS_OP(obj,GetChallenge,(obj,conn,packet))
302 #define RXS_GetResponse(obj,conn,packet) RXS_OP(obj,GetResponse,(obj,conn,packet))
303 #define RXS_CheckResponse(obj,conn,packet) RXS_OP(obj,CheckResponse,(obj,conn,packet))
304 #define RXS_CheckPacket(obj,call,packet) RXS_OP(obj,CheckPacket,(obj,call,packet))
305 #define RXS_DestroyConnection(obj,conn) RXS_OP(obj,DestroyConnection,(obj,conn))
306 #define RXS_GetStats(obj,conn,stats) RXS_OP(obj,GetStats,(obj,conn,stats))
307
308 /* A service is installed by rx_NewService, and specifies a service type that
309  * is exported by this process.  Incoming calls are stamped with the service
310  * type, and must match an installed service for the call to be accepted.
311  * Each service exported has a (port,serviceId) pair to uniquely identify it.
312  * It is also named:  this is intended to allow a remote statistics gathering
313  * program to retrieve per service statistics without having to know the local
314  * service id's.  Each service has a number of
315  */
316
317 /* security objects (instances of security classes) which implement
318  * various types of end-to-end security protocols for connections made
319  * to this service.  Finally, there are two parameters controlling the
320  * number of requests which may be executed in parallel by this
321  * service: minProcs is the number of requests to this service which
322  * are guaranteed to be able to run in parallel at any time; maxProcs
323  * has two meanings: it limits the total number of requests which may
324  * execute in parallel and it also guarantees that that many requests
325  * may be handled in parallel if no other service is handling any
326  * requests. */
327
328 struct rx_service {
329     u_short serviceId;              /* Service number */
330     u_short servicePort;            /* UDP port for this service */
331     char *serviceName;              /* Name of the service */
332     osi_socket socket;              /* socket structure or file descriptor */
333     u_short nRequestsRunning;       /* Number of requests currently in progress */
334     u_short nSecurityObjects;       /* Number of entries in security objects array */
335     struct rx_securityClass **securityObjects;  /* Array of security class objects */
336     afs_int32 (*executeRequestProc)();   /* Routine to call when an rpc request is received */
337     VOID (*destroyConnProc)();      /* Routine to call when a server connection is destroyed */
338     VOID (*newConnProc)();          /* Routine to call when a server connection is created */
339     VOID (*beforeProc)();           /* routine to call before a call is executed */
340     VOID (*afterProc)();            /* routine to call after a call is executed */
341     u_short maxProcs;               /* Maximum procs to be used for this service */
342     u_short minProcs;               /* Minimum # of requests guaranteed executable simultaneously */
343     u_short connDeadTime;                   /* Seconds until a client of this service will be declared dead, if it is not responding */
344     u_short idleDeadTime;                   /* Time a server will wait for I/O to start up again */
345 };
346
347 #endif /* KDUMP_RX_LOCK */
348
349 /* A server puts itself on an idle queue for a service using an
350  * instance of the following structure.  When a call arrives, the call
351  * structure pointer is placed in "newcall", the routine to execute to
352  * service the request is placed in executeRequestProc, and the
353  * process is woken up.  The queue entry's address is used for the
354  * sleep/wakeup. If socketp is non-null, then this thread is willing
355  * to become a listener thread. A thread sets *socketp to -1 before
356  * sleeping. If *socketp is not -1 when the thread awakes, it is now
357  * the listener thread for *socketp. When socketp is non-null, tno
358  * contains the server's threadID, which is used to make decitions in GetCall.
359  */
360 #ifdef KDUMP_RX_LOCK
361 struct rx_serverQueueEntry_rx_lock {
362 #else
363 struct rx_serverQueueEntry {
364 #endif
365     struct rx_queue queueItemHeader;
366 #ifdef KDUMP_RX_LOCK
367     struct rx_call_rx_lock *newcall;
368 #else
369     struct rx_call *newcall;
370 #endif
371 #ifdef  RX_ENABLE_LOCKS
372     afs_kmutex_t lock;
373     afs_kcondvar_t cv;
374 #endif
375     int tno;
376     osi_socket *socketp;
377 };
378
379 #ifndef KDUMP_RX_LOCK
380 /* Bottom n-bits of the Call Identifier give the call number */
381 #define RX_MAXCALLS 4   /* Power of 2; max async calls per connection */
382 #define RX_CIDSHIFT 2   /* Log2(RX_MAXCALLS) */
383 #define RX_CHANNELMASK (RX_MAXCALLS-1)
384 #define RX_CIDMASK  (~RX_CHANNELMASK)
385 #endif /* !KDUMP_RX_LOCK */
386
387 /* A peer refers to a peer process, specified by a (host,port) pair.  There may be more than one peer on a given host. */
388 #ifdef KDUMP_RX_LOCK
389 struct rx_peer_rx_lock {
390     struct rx_peer_rx_lock *next; /* Next in hash conflict or free list */
391 #else
392 struct rx_peer {
393     struct rx_peer *next;           /* Next in hash conflict or free list */
394 #endif
395 #ifdef RX_ENABLE_LOCKS
396     afs_kmutex_t peer_lock;                 /* Lock peer */
397 #endif /* RX_ENABLE_LOCKS */
398     afs_uint32 host;                /* Remote IP address, in net byte order */
399     u_short port;                   /* Remote UDP port, in net byte order */
400
401     /* interface mtu probably used for this host  -  includes RX Header */
402     u_short ifMTU;                  /* doesn't include IP header */
403
404     /* For garbage collection */
405     afs_uint32 idleWhen;                    /* When the refcountwent to zero */
406     short refCount;                 /* Reference count for this structure */
407
408     /* Congestion control parameters */
409     u_char burstSize;               /* Reinitialization size for the burst parameter */
410     u_char burst;                   /* Number of packets that can be transmitted right now, without pausing */
411     struct clock burstWait;         /* Delay until new burst is allowed */
412     struct rx_queue congestionQueue;   /* Calls that are waiting for non-zero burst value */
413     int rtt;                        /* Round trip time, measured in milliseconds/8 */
414     int rtt_dev;                    /* rtt smoothed error, in milliseconds/4 */
415     struct clock timeout;           /* Current retransmission delay */
416     int nSent;                      /* Total number of distinct data packets sent, not including retransmissions */
417     int reSends;                    /* Total number of retransmissions for this peer, since this structure was created */
418
419 /* Skew: if a packet is received N packets later than expected (based
420  * on packet serial numbers), then we define it to have a skew of N.
421  * The maximum skew values allow us to decide when a packet hasn't
422  * been received yet because it is out-of-order, as opposed to when it
423  * is likely to have been dropped. */
424     afs_uint32 inPacketSkew;        /* Maximum skew on incoming packets */
425     afs_uint32 outPacketSkew;     /* Peer-reported max skew on our sent packets */
426     int       rateFlag;       /* Flag for rate testing (-no 0yes +decrement) */
427
428     /* the "natural" MTU, excluding IP,UDP headers, is negotiated by the endpoints */
429     u_short natMTU;         
430     u_short maxMTU;         
431     /* negotiated maximum number of packets to send in a single datagram. */
432     u_short maxDgramPackets;
433     /* local maximum number of packets to send in a single datagram. */
434     u_short ifDgramPackets;
435     /*
436      * MTU, cwind, and nDgramPackets are used to initialize
437      * slow start parameters for new calls. These values are set whenever a
438      * call sends a retransmission and at the end of each call.
439      * congestSeq is incremented each time the congestion parameters are
440      * changed by a call recovering from a dropped packet. A call used
441      * MAX when updating congestion parameters if it started with the
442      * current congestion sequence number, otherwise it uses MIN.
443      */
444     u_short MTU;                /* MTU for AFS 3.4a jumboGrams */
445     u_short cwind;              /* congestion window */
446     u_short nDgramPackets;      /* number packets per AFS 3.5 jumbogram */
447     u_short congestSeq;         /* Changed when a call retransmits */
448     afs_hyper_t bytesSent;      /* Number of bytes sent to this peer */
449     afs_hyper_t bytesReceived;  /* Number of bytes received from this peer */
450     struct rx_queue rpcStats;   /* rpc statistic list */
451 };
452
453 /* A connection is an authenticated communication path, allowing 
454    limited multiple asynchronous conversations. */
455 #ifdef KDUMP_RX_LOCK
456 struct rx_connection_rx_lock {
457     struct rx_connection_rx_lock *next; /*  on hash chain _or_ free list */
458     struct rx_peer_rx_lock *peer;
459 #else
460 struct rx_connection {
461     struct rx_connection *next;     /*  on hash chain _or_ free list */
462     struct rx_peer *peer;
463 #endif
464 #ifdef  RX_ENABLE_LOCKS
465     afs_kmutex_t conn_call_lock;        /* locks conn_call_cv */
466     afs_kcondvar_t conn_call_cv;
467     afs_kmutex_t conn_data_lock;        /* locks packet data */
468 #endif
469     afs_uint32 epoch;     /* Process start time of client side of connection */
470     afs_uint32 cid;         /* Connection id (call channel is bottom bits) */
471     afs_int32 error;        /* If this connection is in error, this is it */
472 #ifdef KDUMP_RX_LOCK
473     struct rx_call_rx_lock *call[RX_MAXCALLS];
474 #else
475     struct rx_call *call[RX_MAXCALLS];
476 #endif
477     afs_uint32 callNumber[RX_MAXCALLS]; /* Current call numbers */
478     afs_uint32 serial;              /* Next outgoing packet serial number */
479     afs_uint32 lastSerial;          /* # of last packet received, for computing skew */
480     afs_int32 maxSerial;           /* largest serial number seen on incoming packets */
481 /*    afs_int32 maxPacketSize;    max packet size should be per-connection since */
482          /* peer process could be restarted on us. Includes RX Header.       */
483     struct rxevent *challengeEvent; /* Scheduled when the server is challenging a     */
484     struct rxevent *delayedAbortEvent; /* Scheduled to throttle looping client */
485     int         abortCount;         /* count of abort messages sent */
486                                     /* client-- to retransmit the challenge */
487     struct rx_service *service;     /* used by servers only */
488     u_short serviceId;              /* To stamp on requests (clients only) */
489     u_short refCount;               /* Reference count */
490     u_char flags;                   /* Defined below */
491     u_char type;                    /* Type of connection, defined below */
492     u_char secondsUntilPing;        /* how often to ping for each active call */
493     u_char securityIndex;           /* corresponds to the security class of the */
494                                     /* securityObject for this conn */
495     struct rx_securityClass *securityObject; /* Security object for this connection */
496     VOID *securityData;             /* Private data for this conn's security class */
497     u_short securityHeaderSize;     /* Length of security module's packet header data */
498     u_short securityMaxTrailerSize; /* Length of security module's packet trailer data */
499
500     int timeout;                    /* Overall timeout per call (seconds) for this conn */
501     int lastSendTime;               /* Last send time for this connection */
502     u_short secondsUntilDead;       /* Maximum silence from peer before RX_CALL_DEAD */
503     u_short hardDeadTime;           /* hard max for call execution */
504     u_char ackRate;                 /* how many packets between ack requests */
505     int nSpecific;                  /* number entries in specific data */
506     void **specific;                /* pointer to connection specific data */
507 };
508
509 #ifndef KDUMP_RX_LOCK
510 /* Flag bits for connection structure */
511 #define RX_CONN_MAKECALL_WAITING    1   /* rx_MakeCall is waiting for a channel */
512 #define RX_CONN_DESTROY_ME          2   /* Destroy *client* connection after last call */
513 #define RX_CONN_USING_PACKET_CKSUM  4   /* non-zero header.spare field seen */
514 #define RX_CONN_KNOW_WINDOW         8   /* window size negotiation works */
515 #define RX_CONN_RESET              16   /* connection is reset, remove */
516 #define RX_CONN_BUSY               32   /* connection is busy; don't delete */
517
518 /* Type of connection, client or server */
519 #define RX_CLIENT_CONNECTION    0
520 #define RX_SERVER_CONNECTION    1
521 #endif /* !KDUMP_RX_LOCK */
522
523 /* Call structure:  only instantiated for active calls and dallying server calls.  The permanent call state (i.e. the call number as well as state shared with other calls associated with this connection) is maintained in the connection structure. */
524 #ifdef KDUMP_RX_LOCK
525 struct rx_call_rx_lock {
526 #else
527 struct rx_call {
528 #endif
529     struct rx_queue queue_item_header; /* Call can be on various queues (one-at-a-time) */
530     struct rx_queue tq;             /* Transmit packet queue */
531     struct rx_queue rq;             /* Receive packet queue */
532     /*
533      * The following fields are accessed while the call is unlocked.
534      * These fields are used by the caller/server thread to marshall
535      * and unmarshall RPC data. The only time they may be changed by
536      * other threads is when the RX_CALL_IOVEC_WAIT flag is set. 
537      * 
538      * NOTE: Be sure that these fields start and end on a double
539      *       word boundary. Otherwise threads that are changing
540      *       adjacent fields will cause problems.
541      */
542     struct rx_queue iovq;           /* readv/writev packet queue */
543     u_short nLeft;                  /* Number bytes left in first receive packet */
544     u_short curvec;                 /* current iovec in currentPacket */
545     u_short curlen;                 /* bytes remaining in curvec */
546     u_short nFree;                  /* Number bytes free in last send packet */
547     struct rx_packet *currentPacket;/* Current packet being assembled or being read */
548     char *curpos;                   /* current position in curvec */
549     /*
550      * End of fields accessed with call unlocked
551      */
552     u_char channel;                 /* Index of call, within connection */
553     u_char state;                   /* Current call state as defined below */
554     u_char mode;                    /* Current mode of a call in ACTIVE state */
555 #ifdef  RX_ENABLE_LOCKS
556     afs_kmutex_t lock;              /* lock covers data as well as mutexes. */
557     afs_kmutex_t *call_queue_lock;  /* points to lock for queue we're on,
558                                        if any. */
559     afs_kcondvar_t cv_twind;
560     afs_kcondvar_t cv_rq;
561     afs_kcondvar_t cv_tq;
562 #endif
563 #ifdef KDUMP_RX_LOCK
564     struct rx_connection_rx_lock *conn; /* Parent connection for call */
565 #else
566     struct rx_connection *conn;     /* Parent connection for this call */
567 #endif
568     afs_uint32 *callNumber;         /* Pointer to call number field within connection */
569     afs_uint32 flags;               /* Some random flags */
570     u_char localStatus;             /* Local user status sent out of band */
571     u_char remoteStatus;            /* Remote user status received out of band */ 
572     afs_int32 error;                        /* Error condition for this call */
573     afs_uint32 timeout;             /* High level timeout for this call */
574     afs_uint32 rnext;               /* Next sequence number expected to be read by rx_ReadData */
575     afs_uint32 rprev;               /* Previous packet received; used for deciding what the next packet to be received should be, in order to decide whether a negative acknowledge should be sent */
576     afs_uint32 rwind;               /* The receive window:  the peer must not send packets with sequence numbers >= rnext+rwind */
577     afs_uint32 tfirst;              /* First unacknowledged transmit packet number */
578     afs_uint32 tnext;               /* Next transmit sequence number to use */
579     u_short twind;                  /* The transmit window:  we cannot assign a sequence number to a packet >= tfirst + twind */
580     u_short cwind;                  /* The congestion window */
581     u_short nSoftAcked;             /* Number soft acked transmit packets */
582     u_short nextCwind;              /* The congestion window after recovery */
583     u_short nCwindAcks;             /* Number acks received at current cwind */
584     u_short ssthresh;               /* The slow start threshold */
585     u_short nDgramPackets;          /* Packets per AFS 3.5 jumbogram */
586     u_short nAcks;                  /* The number of consecttive acks */
587     u_short nNacks;                 /* Number packets acked that follow the
588                                      * first negatively acked packet */
589     u_short nSoftAcks;              /* The number of delayed soft acks */
590     u_short nHardAcks;              /* The number of delayed hard acks */
591     u_short congestSeq;             /* Peer's congestion sequence counter */
592     struct rxevent *resendEvent;    /* If this is non-Null, there is a retransmission event pending */
593     struct rxevent *timeoutEvent;   /* If this is non-Null, then there is an overall timeout for this call */
594     struct rxevent *keepAliveEvent;   /* Scheduled periodically in active calls to keep call alive */
595     struct rxevent *delayedAckEvent;  /* Scheduled after all packets are received to send an ack if a reply or new call is not generated soon */
596     struct rxevent *delayedAbortEvent; /* Scheduled to throttle looping client */
597     int         abortCode;          /* error code from last RPC */
598     int         abortCount;         /* number of times last error was sent */
599     u_int       lastSendTime;               /* Last time a packet was sent on this call */
600     u_int lastReceiveTime;          /* Last time a packet was received for this call */
601     VOID (*arrivalProc)();          /* Procedure to call when reply is received */
602     VOID *arrivalProcHandle;        /* Handle to pass to replyFunc */
603     VOID *arrivalProcArg;           /* Additional arg to pass to reply Proc */
604     afs_uint32 lastAcked;           /* last packet "hard" acked by receiver */
605     afs_uint32 startWait;           /* time server began waiting for input data/send quota */
606     struct clock traceWait;         /* time server began waiting for input data/send quota */
607     struct clock traceStart;        /* time the call started running */
608     u_short MTU;                    /* size of packets currently sending */
609 #ifdef RX_ENABLE_LOCKS
610     short refCount;                 /* Used to keep calls from disappearring
611                                        when we get them from a queue. */
612 #endif /* RX_ENABLE_LOCKS */
613 /* Call refcount modifiers */
614 #define RX_CALL_REFCOUNT_BEGIN  0 /* GetCall/NewCall/EndCall */
615 #define RX_CALL_REFCOUNT_RESEND 1 /* resend event */
616 #define RX_CALL_REFCOUNT_DELAY  2 /* delayed ack */
617 #define RX_CALL_REFCOUNT_ALIVE  3 /* keep alive event */
618 #define RX_CALL_REFCOUNT_PACKET 4 /* waiting for packets. */
619 #define RX_CALL_REFCOUNT_SEND   5 /* rxi_Send */
620 #define RX_CALL_REFCOUNT_ACKALL 6 /* rxi_AckAll */
621 #define RX_CALL_REFCOUNT_ABORT  7 /* delayed abort */
622 #define RX_CALL_REFCOUNT_MAX    8 /* array size. */
623 #ifdef RX_REFCOUNT_CHECK
624     short refCDebug[RX_CALL_REFCOUNT_MAX];
625 #endif  /* RX_REFCOUNT_CHECK */
626     int iovNBytes;              /* byte count for current iovec */
627     int iovMax;                 /* number elements in current iovec */
628     int iovNext;                /* next entry in current iovec */
629     struct iovec *iov;          /* current iovec */
630     struct clock queueTime;     /* time call was queued */
631     struct clock startTime;     /* time call was started */
632     afs_hyper_t bytesSent;      /* Number bytes sent */
633     afs_hyper_t bytesRcvd;      /* Number bytes received */
634 };
635
636 #ifndef KDUMP_RX_LOCK
637 /* Major call states */
638 #define RX_STATE_NOTINIT  0    /* Call structure has never been initialized */
639 #define RX_STATE_PRECALL  1    /* Server-only:  call is not in progress, but packets have arrived */
640 #define RX_STATE_ACTIVE   2    /* An active call; a process is dealing with this call */
641 #define RX_STATE_DALLY    3    /* Dallying after process is done with call */
642 #define RX_STATE_HOLD     4    /* Waiting for acks on reply data packets */
643
644 /* Call modes:  the modes of a call in RX_STATE_ACTIVE state (process attached) */
645 #define RX_MODE_SENDING   1    /* Sending or ready to send */
646 #define RX_MODE_RECEIVING 2    /* Receiving or ready to receive */
647 #define RX_MODE_ERROR     3    /* Something in error for current conversation */
648 #define RX_MODE_EOF       4    /* Server has flushed (or client has read) last reply packet */
649
650 /* Flags */
651 #define RX_CALL_READER_WAIT        1   /* Reader is waiting for next packet */
652 #define RX_CALL_WAIT_WINDOW_ALLOC  2   /* Sender is waiting for window to allocate buffers */
653 #define RX_CALL_WAIT_WINDOW_SEND   4   /* Sender is waiting for window to send buffers */
654 #define RX_CALL_WAIT_PACKETS       8   /* Sender is waiting for packet buffers */
655 #define RX_CALL_WAIT_PROC         16   /* Waiting for a process to be assigned */
656 #define RX_CALL_RECEIVE_DONE      32   /* All packets received on this call */
657 #define RX_CALL_CLEARED           64   /* Receive queue cleared in precall state */
658 #define RX_CALL_TQ_BUSY          128  /* Call's Xmit Queue is busy; don't modify */
659 #define RX_CALL_TQ_CLEARME       256  /* Need to clear this call's TQ later */
660 #define RX_CALL_TQ_SOME_ACKED    512  /* rxi_Start needs to discard ack'd packets. */
661 #define RX_CALL_TQ_WAIT         1024  /* Reader is waiting for TQ_BUSY to be reset */
662 #define RX_CALL_FAST_RECOVER    2048 /* call is doing congestion recovery */
663 #define RX_CALL_FAST_RECOVER_WAIT 4096 /* thread is waiting to start recovery */
664 #define RX_CALL_SLOW_START_OK   8192  /* receiver acks every other packet */
665 #define RX_CALL_IOVEC_WAIT      16384 /* waiting thread is using an iovec */
666 #define RX_CALL_HAVE_LAST       32768 /* Last packet has been received */
667 #define RX_CALL_NEED_START      0x10000 /* tells rxi_Start to start again */
668
669 /* Maximum number of acknowledgements in an acknowledge packet */
670 #define RX_MAXACKS          255
671
672 /* The structure of the data portion of an acknowledge packet: An acknowledge
673  * packet is in network byte order at all times.  An acknowledgement is always
674  * prompted for a specific reason by a specific incoming packet.  This reason
675  * is reported in "reason" and the packet's sequence number in the packet
676  * header.seq.  In addition to this information, all of the current
677  * acknowledgement information about this call is placed in the packet.
678  * "FirstPacket" is the sequence number of the first packet represented in an
679  * array of bytes, "acks", containing acknowledgement information for a number
680  * of consecutive packets.  All packets prior to FirstPacket are implicitly
681  * acknowledged: the sender need no longer be concerned about them.  Packets
682  * from firstPacket+nAcks and on are not acknowledged.  Packets in the range
683  * [firstPacket,firstPacket+nAcks) are each acknowledged explicitly.  The
684  * acknowledgement may be RX_NACK if the packet is not (currently) at the
685  * receiver (it may have never been received, or received and then later
686  * dropped), or it may be RX_ACK if the packet is queued up waiting to be read
687  * by the upper level software.  RX_ACK does not imply that the packet may not
688  * be dropped before it is read; it does imply that the sender should stop
689  * retransmitting the packet until notified otherwise.  The field
690  * previousPacket identifies the previous packet received by the peer.  This
691  * was used in a previous version of this software, and could be used in the
692  * future.  The serial number in the data part of the ack packet corresponds to
693  * the serial number oof the packet which prompted the acknowledge.  Any
694  * packets which are explicitly not acknowledged, and which were last
695  * transmitted with a serial number less than the provided serial number,
696  * should be retransmitted immediately.  Actually, this is slightly inaccurate:
697  * packets are not necessarily received in order.  When packets are habitually
698  * transmitted out of order, this is allowed for in the retransmission
699  * algorithm by introducing the notion of maximum packet skew: the degree of
700  * out-of-orderness of the packets received on the wire.  This number is
701  * communicated from the receiver to the sender in ack packets. */
702
703 struct rx_ackPacket {
704     u_short bufferSpace;    /* Number of packet buffers available.  That is:  the number of buffers that the sender of the ack packet is willing to provide for data, on this or subsequent calls.  Lying is permissable. */
705     u_short maxSkew;        /* Maximum difference between serial# of packet acknowledged and highest packet yet received */
706     afs_uint32  firstPacket;    /* The first packet in the list of acknowledged packets */
707     afs_uint32  previousPacket; /* The previous packet number received (obsolete?) */
708     afs_uint32  serial;     /* Serial number of the packet which prompted the acknowledge */
709     u_char  reason;         /* Reason for the acknowledge of ackPacket, defined below */
710     u_char  nAcks;          /* Number of acknowledgements */
711     u_char  acks[RX_MAXACKS]; /* Up to RX_MAXACKS packet acknowledgements, defined below */
712     /* Packets <firstPacket are implicitly acknowledged and may be discarded by the sender.  Packets >= firstPacket+nAcks are implicitly NOT acknowledged.  No packets with sequence numbers >= firstPacket should be discarded by the sender (they may thrown out at any time by the receiver) */
713 };
714
715 #define FIRSTACKOFFSET 4
716
717 /* Reason for acknowledge message */
718 #define RX_ACK_REQUESTED        1   /* Peer requested an ack on this packet */
719 #define RX_ACK_DUPLICATE        2   /* Duplicate packet */
720 #define RX_ACK_OUT_OF_SEQUENCE  3   /* Packet out of sequence */
721 #define RX_ACK_EXCEEDS_WINDOW   4   /* Packet sequence number higher than window; discarded */
722 #define RX_ACK_NOSPACE          5   /* No buffer space at all */
723 #define RX_ACK_PING             6   /* This is a keep-alive ack */
724 #define RX_ACK_PING_RESPONSE    7   /* Ack'ing because we were pinged */
725 #define RX_ACK_DELAY            8   /* Ack generated since nothing has happened since receiving packet */
726 #define RX_ACK_IDLE             9   /* Similar to RX_ACK_DELAY, but can 
727                                               be */
728
729 /* Packet acknowledgement type */ 
730 #define RX_ACK_TYPE_NACK        0   /* I Don't have this packet */
731 #define RX_ACK_TYPE_ACK         1   /* I have this packet, although I may discard it later */
732
733 /* The packet size transmitted for an acknowledge is adjusted to reflect the actual size of the acks array.  This macro defines the size */
734 #define rx_AckDataSize(nAcks) (sizeof(struct rx_ackPacket) - RX_MAXACKS + (nAcks))
735
736 #define RX_CHALLENGE_TIMEOUT    2   /* Number of seconds before another authentication request packet is generated */
737
738 /* RX error codes.  RX uses error codes from -1 to -64.  Rxgen may use other error codes < -64; user programs are expected to return positive error codes */
739
740 /* Something bad happened to the connection; temporary loss of communication */
741 #define RX_CALL_DEAD                (-1)
742
743 /* An invalid operation, such as a client attempting to send data after having received the beginning of a reply from the server */
744 #define RX_INVALID_OPERATION        (-2)
745
746 /* An optional timeout per call may be specified */
747 #define RX_CALL_TIMEOUT             (-3)
748
749 /* End of data on a read */
750 #define RX_EOF                      (-4)
751
752 /* Some sort of low-level protocol error */
753 #define RX_PROTOCOL_ERROR           (-5)
754
755 /* Generic user abort code; used when no more specific error code needs to be communicated.  For example, multi rx clients use this code to abort a multi rx call */
756 #define RX_USER_ABORT               (-6)
757
758 /* Port already in use (from rx_Init) */
759 #define RX_ADDRINUSE                (-7)
760
761 /* EMSGSIZE returned from network.  Packet too big, must fragment */
762 #define RX_MSGSIZE                  (-8)
763
764 /* transient failure detected ( possibly the server is restarting ) */
765 /* this shud be equal to VRESTARTING ( util/errors.h ) for old clients to work */
766 #define RX_RESTARTING               (-100) 
767
768 /* Structure for keeping rx statistics.  Note that this structure is returned
769  * by rxdebug, so, for compatibility reasons, new fields should be appended (or
770  * spares used), the rxdebug protocol checked, if necessary, and the PrintStats
771  * code should be updated as well.
772  *
773  * Clearly we assume that ntohl will work on these structures so sizeof(int)
774  * must equal sizeof(afs_int32). */
775
776 struct rx_stats {                       /* General rx statistics */
777     int packetRequests;     /* Number of packet allocation requests */
778     int receivePktAllocFailures;
779     int sendPktAllocFailures;
780     int specialPktAllocFailures;
781     int socketGreedy;       /* Whether SO_GREEDY succeeded */
782     int bogusPacketOnRead;  /* Number of inappropriately short packets received */
783     int bogusHost;          /* Host address from bogus packets */
784     int noPacketOnRead;     /* Number of read packets attempted when there was actually no packet to read off the wire */
785     int noPacketBuffersOnRead; /* Number of dropped data packets due to lack of packet buffers */
786     int selects;            /* Number of selects waiting for packet or timeout */
787     int sendSelects;        /* Number of selects forced when sending packet */
788     int packetsRead[RX_N_PACKET_TYPES]; /* Total number of packets read, per type */
789     int dataPacketsRead;    /* Number of unique data packets read off the wire */
790     int ackPacketsRead;     /* Number of ack packets read */
791     int dupPacketsRead;     /* Number of duplicate data packets read */     
792     int spuriousPacketsRead;/* Number of inappropriate data packets */
793     int packetsSent[RX_N_PACKET_TYPES]; /* Number of rxi_Sends: packets sent over the wire, per type */
794     int ackPacketsSent;     /* Number of acks sent */
795     int pingPacketsSent;    /* Total number of ping packets sent */
796     int abortPacketsSent;   /* Total number of aborts */
797     int busyPacketsSent;    /* Total number of busies sent received */
798     int dataPacketsSent;    /* Number of unique data packets sent */
799     int dataPacketsReSent;  /* Number of retransmissions */
800     int dataPacketsPushed;  /* Number of retransmissions pushed early by a NACK */
801     int ignoreAckedPacket;  /* Number of packets with acked flag, on rxi_Start */
802     struct clock totalRtt;  /* Total round trip time measured (use to compute average) */
803     struct clock minRtt;    /* Minimum round trip time measured */
804     struct clock maxRtt;    /* Maximum round trip time measured */
805     int nRttSamples;        /* Total number of round trip samples */
806     int nServerConns;       /* Total number of server connections */
807     int nClientConns;       /* Total number of client connections */
808     int nPeerStructs;       /* Total number of peer structures */
809     int nCallStructs;       /* Total number of call structures allocated */
810     int nFreeCallStructs;   /* Total number of previously allocated free call structures */
811     int netSendFailures;
812     afs_int32 fatalErrors;
813     int ignorePacketDally;  /* packets dropped because call is in dally state */
814     int receiveCbufPktAllocFailures;
815     int sendCbufPktAllocFailures;
816     int spares[5];
817 };
818
819 /* structures for debug input and output packets */
820
821 /* debug input types */
822 struct rx_debugIn {
823     afs_int32 type;
824     afs_int32 index;
825 };
826
827 /* Invalid rx debug package type */
828 #define RX_DEBUGI_BADTYPE     (-8)
829
830 #define RX_DEBUGI_VERSION_MINIMUM ('L') /* earliest real version */
831 #define RX_DEBUGI_VERSION     ('Q')     /* Latest version */
832     /* first version w/ secStats */
833 #define RX_DEBUGI_VERSION_W_SECSTATS ('L')
834     /* version M is first supporting GETALLCONN and RXSTATS type */
835 #define RX_DEBUGI_VERSION_W_GETALLCONN ('M')
836 #define RX_DEBUGI_VERSION_W_RXSTATS ('M')
837     /* last version with unaligned debugConn */
838 #define RX_DEBUGI_VERSION_W_UNALIGNED_CONN ('L')
839 #define RX_DEBUGI_VERSION_W_WAITERS ('N')
840 #define RX_DEBUGI_VERSION_W_IDLETHREADS ('O')
841 #define RX_DEBUGI_VERSION_W_NEWPACKETTYPES ('P')
842 #define RX_DEBUGI_VERSION_W_GETPEER ('Q')
843
844 #define RX_DEBUGI_GETSTATS      1       /* get basic rx stats */
845 #define RX_DEBUGI_GETCONN       2       /* get connection info */
846 #define RX_DEBUGI_GETALLCONN    3       /* get even uninteresting conns */
847 #define RX_DEBUGI_RXSTATS       4       /* get all rx stats */
848 #define RX_DEBUGI_GETPEER       5       /* get all peer structs */
849
850 struct rx_debugStats {
851     afs_int32 nFreePackets;
852     afs_int32 packetReclaims;
853     afs_int32 callsExecuted;
854     char waitingForPackets;
855     char usedFDs;
856     char version;
857     char spare1;
858     afs_int32 nWaiting;
859     afs_int32 idleThreads;          /* Number of server threads that are idle */
860     afs_int32 spare2[8];
861 };
862
863 struct rx_debugConn_vL {
864     afs_int32 host;
865     afs_int32 cid;
866     afs_int32 serial;
867     afs_int32 callNumber[RX_MAXCALLS];
868     afs_int32 error;
869     short port;
870     char flags;
871     char type;
872     char securityIndex;
873     char callState[RX_MAXCALLS];
874     char callMode[RX_MAXCALLS];
875     char callFlags[RX_MAXCALLS];
876     char callOther[RX_MAXCALLS];
877     /* old style getconn stops here */
878     struct rx_securityObjectStats secStats;
879     afs_int32 sparel[10];
880 };
881
882 struct rx_debugConn {
883     afs_int32 host;
884     afs_int32 cid;
885     afs_int32 serial;
886     afs_int32 callNumber[RX_MAXCALLS];
887     afs_int32 error;
888     short port;
889     char flags;
890     char type;
891     char securityIndex;
892     char sparec[3];                     /* force correct alignment */
893     char callState[RX_MAXCALLS];
894     char callMode[RX_MAXCALLS];
895     char callFlags[RX_MAXCALLS];
896     char callOther[RX_MAXCALLS];
897     /* old style getconn stops here */
898     struct rx_securityObjectStats secStats;
899     afs_int32 epoch;
900     afs_int32 natMTU;
901     afs_int32 sparel[9];
902 };
903
904 struct rx_debugPeer {
905     afs_uint32 host;
906     u_short port;
907     u_short ifMTU;
908     afs_uint32 idleWhen;
909     short refCount;
910     u_char burstSize;
911     u_char burst;
912     struct clock burstWait;
913     afs_int32 rtt;
914     afs_int32 rtt_dev;
915     struct clock timeout;
916     afs_int32 nSent;
917     afs_int32 reSends;
918     afs_int32 inPacketSkew;
919     afs_int32 outPacketSkew;
920     afs_int32 rateFlag;
921     u_short natMTU;
922     u_short maxMTU;
923     u_short maxDgramPackets;
924     u_short ifDgramPackets;
925     u_short MTU;
926     u_short cwind;
927     u_short nDgramPackets;
928     u_short congestSeq;
929     afs_hyper_t bytesSent;
930     afs_hyper_t bytesReceived;
931     afs_int32 sparel[10];
932 };
933
934 #define RX_OTHER_IN     1       /* packets avail in in queue */
935 #define RX_OTHER_OUT    2       /* packets avail in out queue */
936
937
938
939 /* Only include this once, even when re-loading for kdump. */
940 #ifndef _CALL_REF_DEFINED_
941 #define _CALL_REF_DEFINED_
942
943 #ifdef RX_ENABLE_LOCKS
944 #ifdef RX_REFCOUNT_CHECK
945 /* RX_REFCOUNT_CHECK is used to test for call refcount leaks by event
946  * type.
947  */
948 extern int rx_callHoldType;
949 #define CALL_HOLD(call, type) do { \
950                                  call->refCount++; \
951                                  call->refCDebug[type]++; \
952                                  if (call->refCDebug[type] > 50)  {\
953                                      rx_callHoldType = type; \
954                                      osi_Panic("Huge call refCount"); \
955                                                                } \
956                              } while (0)
957 #define CALL_RELE(call, type) do { \
958                                  call->refCount--; \
959                                  call->refCDebug[type]--; \
960                                  if (call->refCDebug[type] > 50) {\
961                                      rx_callHoldType = type; \
962                                      osi_Panic("Negative call refCount"); \
963                                                               } \
964                              } while (0)
965 #else /* RX_REFCOUNT_CHECK */
966 #define CALL_HOLD(call, type)    call->refCount++
967 #define CALL_RELE(call, type)    call->refCount--
968 #endif  /* RX_REFCOUNT_CHECK */
969
970 #else /* RX_ENABLE_LOCKS */
971 #define CALL_HOLD(call, type)
972 #define CALL_RELE(call, type)
973 #endif /* RX_ENABLE_LOCKS */
974
975 #endif /* _CALL_REF_DEFINED_ */
976
977 struct rx_connection *rx_GetCachedConnection(
978   unsigned int remoteAddr,
979   unsigned short port,
980   unsigned short service,
981   struct rx_securityClass *securityObject,
982   int securityIndex
983 );
984
985 void rx_ReleaseCachedConnection(
986   struct rx_connection *conn
987 );
988
989 #define RX_SERVER_DEBUG_SEC_STATS               0x1
990 #define RX_SERVER_DEBUG_ALL_CONN                0x2
991 #define RX_SERVER_DEBUG_RX_STATS                0x4
992 #define RX_SERVER_DEBUG_WAITER_CNT              0x8
993 #define RX_SERVER_DEBUG_IDLE_THREADS            0x10
994 #define RX_SERVER_DEBUG_OLD_CONN                0x20
995 #define RX_SERVER_DEBUG_NEW_PACKETS             0x40
996 #define RX_SERVER_DEBUG_ALL_PEER                0x80
997
998 afs_int32 rx_GetServerDebug(
999   int socket,
1000   afs_uint32 remoteAddr,
1001   afs_uint16 remotePort,
1002   struct rx_debugStats *stat,
1003   afs_uint32 *supportedValues
1004 );
1005
1006 afs_int32 rx_GetServerStats(
1007   int socket,
1008   afs_uint32 remoteAddr,
1009   afs_uint16 remotePort,
1010   struct rx_stats *stat,
1011   afs_uint32 *supportedValues
1012 );
1013
1014 afs_int32 rx_GetServerVersion(
1015   int socket,
1016   afs_uint32 remoteAddr,
1017   afs_uint16 remotePort,
1018   size_t version_length,
1019   char *version
1020 );
1021
1022 afs_int32 rx_GetServerConnections(
1023   int socket,
1024   afs_uint32 remoteAddr,
1025   afs_uint16 remotePort,
1026   afs_int32 *nextConnection,
1027   int allConnections,
1028   afs_uint32 debugSupportedValues,
1029   struct rx_debugConn *conn,
1030   afs_uint32 *supportedValues
1031 );
1032
1033 afs_int32 rx_GetServerPeers(
1034   int socket,
1035   afs_uint32 remoteAddr,
1036   afs_uint16 remotePort,
1037   afs_int32 *nextPeer,
1038   afs_uint32 debugSupportedValues,
1039   struct rx_debugPeer *peer,
1040   afs_uint32 *supportedValues
1041 );
1042
1043 #define AFS_RX_STATS_CLEAR_ALL                  0xffffffff
1044 #define AFS_RX_STATS_CLEAR_INVOCATIONS          0x1
1045 #define AFS_RX_STATS_CLEAR_BYTES_SENT           0x2
1046 #define AFS_RX_STATS_CLEAR_BYTES_RCVD           0x4
1047 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM       0x8
1048 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE    0x10
1049 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN       0x20
1050 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX       0x40
1051 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SUM        0x80
1052 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE     0x100
1053 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MIN        0x200
1054 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MAX        0x400
1055
1056 typedef struct rx_function_entry_v1 {
1057   afs_uint32 remote_peer;
1058   afs_uint32 remote_port;
1059   afs_uint32 remote_is_server;
1060   afs_uint32 interfaceId;
1061   afs_uint32 func_total;
1062   afs_uint32 func_index;
1063   afs_hyper_t invocations;
1064   afs_hyper_t bytes_sent;
1065   afs_hyper_t bytes_rcvd;
1066   struct clock queue_time_sum;
1067   struct clock queue_time_sum_sqr;
1068   struct clock queue_time_min;
1069   struct clock queue_time_max;
1070   struct clock execution_time_sum;
1071   struct clock execution_time_sum_sqr;
1072   struct clock execution_time_min;
1073   struct clock execution_time_max;
1074 } rx_function_entry_v1_t, *rx_function_entry_v1_p;
1075
1076 /*
1077  * If you need to change rx_function_entry, you should probably create a brand
1078  * new structure.  Keeping the old structure will allow backwards compatibility
1079  * with old clients (even if it is only used to calculate allocation size).
1080  * If you do change the size or the format, you'll need to bump
1081  * RX_STATS_RETRIEVAL_VERSION.  This allows some primitive form
1082  * of versioning a la rxdebug.
1083  */
1084
1085 #define RX_STATS_RETRIEVAL_VERSION 1            /* latest version */
1086 #define RX_STATS_RETRIEVAL_FIRST_EDITION 1      /* first implementation */
1087
1088 typedef struct rx_interface_stat {
1089   struct rx_queue queue_header;
1090   struct rx_queue all_peers;
1091   rx_function_entry_v1_t stats[1]; /* make sure this is aligned correctly */
1092 } rx_interface_stat_t, *rx_interface_stat_p;
1093
1094 void rx_IncrementTimeAndCount(
1095   struct rx_peer *peer,
1096   afs_uint32 rxInterface,
1097   afs_uint32 currentFunc,
1098   afs_uint32 totalFunc,
1099   struct clock *queueTime,
1100   struct clock *execTime,
1101   afs_hyper_t *bytesSent,
1102   afs_hyper_t *bytesRcvd,
1103   int isServer
1104 );
1105
1106 int rx_RetrieveProcessRPCStats(
1107   afs_uint32 callerVersion,
1108   afs_uint32 *myVersion,
1109   afs_uint32 *clock_sec,
1110   afs_uint32 *clock_usec,
1111   size_t *allocSize,
1112   afs_uint32 *statCount,
1113   afs_uint32 **stats
1114 );
1115
1116 int rx_RetrievePeerRPCStats(
1117   afs_uint32 callerVersion,
1118   afs_uint32 *myVersion,
1119   afs_uint32 *clock_sec,
1120   afs_uint32 *clock_usec,
1121   size_t *allocSize,
1122   afs_uint32 *statCount,
1123   afs_uint32 **stats
1124 );
1125
1126 void rx_FreeRPCStats(
1127   afs_uint32 *stats,
1128   size_t allocSize
1129 );
1130
1131 int rx_queryProcessRPCStats();
1132
1133 int rx_queryPeerRPCStats();
1134
1135 void rx_enableProcessRPCStats();
1136
1137 void rx_enablePeerRPCStats();
1138
1139 void rx_disableProcessRPCStats();
1140
1141 void rx_disablePeerRPCStats();
1142
1143 void rx_clearProcessRPCStats(
1144   afs_uint32 clearFlag
1145 );
1146
1147 void rx_clearPeerRPCStats(
1148   afs_uint32 clearFlag
1149 );
1150
1151 void rx_SetRxStatUserOk(
1152   int (*proc)(struct rx_call *call)
1153 );
1154
1155 int rx_RxStatUserOk(
1156   struct rx_call *call
1157 );
1158
1159
1160 #define RX_STATS_SERVICE_ID 409
1161
1162 #endif /* _RX_   End of rx.h */
1163
1164 #endif /* !KDUMP_RX_LOCK */