8572834d33d47f757b64c58e042d44ccbdbbf41f
[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 #ifdef  KERNEL
27 #include "rx_kmutex.h"
28 #include "rx_kernel.h"
29 #if defined (AFS_OBSD_ENV) && !defined (MLEN)
30 #include "sys/mbuf.h"
31 #endif
32 #include "netinet/in.h"
33 #include "sys/socket.h"
34 #else /* KERNEL */
35 # include <sys/types.h>
36 # include <stdio.h>
37 # include <string.h>
38 #ifdef AFS_PTHREAD_ENV
39 # include "rx_pthread.h"
40 #else
41 # include "rx_lwp.h"
42 #endif
43 #ifdef AFS_NT40_ENV
44 #include <malloc.h>
45 #include <winsock2.h>
46 #include <ws2tcpip.h>
47 #endif
48 # include "rx_user.h"
49 #ifndef AFS_NT40_ENV
50 # include <netinet/in.h>
51 # include <sys/socket.h>
52 #endif
53 #endif /* KERNEL */
54
55 #include "rx_queue.h"
56 #include "rx_clock.h"
57 #include "rx_event.h"
58 #include "rx_misc.h"
59 #include "rx_null.h"
60 #include "rx_multi.h"
61
62 /* These items are part of the new RX API. They're living in this section
63  * for now, to keep them separate from everything else... */
64
65 struct rx_connection;
66 struct rx_call;
67 struct rx_packet;
68
69 /* Connection management */
70
71 extern void rx_SetConnectionEpoch(struct rx_connection *conn, int epoch);
72 extern int  rx_GetConnectionEpoch(struct rx_connection *conn);
73 extern void rx_SetConnectionId(struct rx_connection *conn, int id);
74 extern int  rx_GetConnectionId(struct rx_connection *conn);
75 extern void *rx_GetSecurityData(struct rx_connection *conn);
76 extern void  rx_SetSecurityData(struct rx_connection *conn, void *data);
77 extern int  rx_IsUsingPktCksum(struct rx_connection *conn);
78 extern void rx_SetSecurityHeaderSize(struct rx_connection *conn, int size);
79 extern int  rx_GetSecurityHeaderSize(struct rx_connection *conn);
80 extern void rx_SetSecurityMaxTrailerSize(struct rx_connection *conn, int size);
81 extern int  rx_GetSecurityMaxTrailerSize(struct rx_connection *conn);
82 extern void rx_SetServerConnIdleDeadErr(struct rx_connection *conn, int err);
83 extern void rx_SetMsgsizeRetryErr(struct rx_connection *conn, int err);
84 extern int  rx_IsServerConn(struct rx_connection *conn);
85 extern int  rx_IsClientConn(struct rx_connection *conn);
86 extern struct rx_securityClass *rx_SecurityObjectOf(const struct rx_connection *);
87 extern struct rx_peer *rx_PeerOf(struct rx_connection *);
88 extern u_short rx_ServiceIdOf(struct rx_connection *);
89 extern int rx_SecurityClassOf(struct rx_connection *);
90 extern struct rx_service *rx_ServiceOf(struct rx_connection *);
91 extern int rx_ConnError(struct rx_connection *);
92
93 /* Call management */
94 extern struct rx_connection *rx_ConnectionOf(struct rx_call *call);
95 extern int rx_Error(struct rx_call *call);
96 extern int rx_GetRemoteStatus(struct rx_call *call);
97 extern void rx_SetLocalStatus(struct rx_call *call, int status);
98 extern int rx_GetCallAbortCode(struct rx_call *call);
99 extern void rx_SetCallAbortCode(struct rx_call *call, int code);
100
101 extern void rx_RecordCallStatistics(struct rx_call *call,
102                                     unsigned int rxInterface,
103                                     unsigned int currentFunc,
104                                     unsigned int totalFunc,
105                                     int isServer);
106
107
108 /* Packets */
109
110 /* Packet classes, for rx_AllocPacket and rx_packetQuota */
111 #define RX_PACKET_CLASS_RECEIVE     0
112 #define RX_PACKET_CLASS_SEND        1
113 #define RX_PACKET_CLASS_SPECIAL     2
114 #define RX_PACKET_CLASS_RECV_CBUF   3
115 #define RX_PACKET_CLASS_SEND_CBUF   4
116
117 #define RX_N_PACKET_CLASSES         5   /* Must agree with above list */
118
119 #define RX_PACKET_TYPES     {"data", "ack", "busy", "abort", "ackall", "challenge", "response", "debug", "params", "unused", "unused", "unused", "version"}
120 #define RX_N_PACKET_TYPES           13  /* Must agree with above list;
121                                          * counts 0
122                                          * WARNING: if this number ever
123                                          * grows past 13, rxdebug packets
124                                          * will need to be modified */
125
126
127 /* For most Unixes, maximum elements in an iovec is 16 */
128 #define RX_MAXIOVECS 16                 /* limit for ReadvProc/WritevProc */
129 #define RX_MAXWVECS (RX_MAXIOVECS-1)    /* need one iovec for packet header */
130
131 /* Debugging */
132
133 /* Call flags, states and modes are exposed by the debug interface */
134 #ifndef KDUMP_RX_LOCK
135 /* Major call states */
136 #define RX_STATE_NOTINIT  0     /* Call structure has never been initialized */
137 #define RX_STATE_PRECALL  1     /* Server-only:  call is not in progress, but packets have arrived */
138 #define RX_STATE_ACTIVE   2     /* An active call; a process is dealing with this call */
139 #define RX_STATE_DALLY    3     /* Dallying after process is done with call */
140 #define RX_STATE_HOLD     4     /* Waiting for acks on reply data packets */
141 #define RX_STATE_RESET    5     /* Call is being reset */
142
143 /* Call modes:  the modes of a call in RX_STATE_ACTIVE state (process attached) */
144 #define RX_MODE_SENDING   1     /* Sending or ready to send */
145 #define RX_MODE_RECEIVING 2     /* Receiving or ready to receive */
146 #define RX_MODE_ERROR     3     /* Something in error for current conversation */
147 #define RX_MODE_EOF       4     /* Server has flushed (or client has read) last reply packet */
148
149 /* Flags */
150 #define RX_CALL_READER_WAIT        1    /* Reader is waiting for next packet */
151 #define RX_CALL_WAIT_WINDOW_ALLOC  2    /* Sender is waiting for window to allocate buffers */
152 #define RX_CALL_WAIT_WINDOW_SEND   4    /* Sender is waiting for window to send buffers */
153 #define RX_CALL_WAIT_PACKETS       8    /* Sender is waiting for packet buffers */
154 #define RX_CALL_WAIT_PROC         16    /* Waiting for a process to be assigned */
155 #define RX_CALL_RECEIVE_DONE      32    /* All packets received on this call */
156 #define RX_CALL_CLEARED           64    /* Receive queue cleared in precall state */
157 #define RX_CALL_TQ_BUSY          128    /* Call's Xmit Queue is busy; don't modify */
158 #define RX_CALL_TQ_CLEARME       256    /* Need to clear this call's TQ later */
159 #define RX_CALL_TQ_SOME_ACKED    512    /* rxi_Start needs to discard ack'd packets. */
160 #define RX_CALL_TQ_WAIT         1024    /* Reader is waiting for TQ_BUSY to be reset */
161 #define RX_CALL_FAST_RECOVER    2048    /* call is doing congestion recovery */
162 /* 4096 was RX_CALL_FAST_RECOVER_WAIT */
163 #define RX_CALL_SLOW_START_OK   8192    /* receiver acks every other packet */
164 #define RX_CALL_IOVEC_WAIT      16384   /* waiting thread is using an iovec */
165 #define RX_CALL_HAVE_LAST       32768   /* Last packet has been received */
166 #define RX_CALL_NEED_START      0x10000 /* tells rxi_Start to start again */
167 #define RX_CALL_PEER_BUSY       0x20000 /* the last packet we received on this call was a
168                                          * BUSY packet; i.e. the channel for this call is busy */
169 #define RX_CALL_ACKALL_SENT     0x40000 /* ACKALL has been sent on the call */
170
171 #endif
172
173
174 /* Configurable parameters */
175 #define RX_IDLE_DEAD_TIME       60      /* default idle dead time */
176 #define RX_MAX_SERVICES         20      /* Maximum number of services that may be installed */
177 #if defined(KERNEL) && defined(AFS_AIX51_ENV) && defined(__64__)
178 #define RX_DEFAULT_STACK_SIZE   24000
179 #else
180 #define RX_DEFAULT_STACK_SIZE   16000   /* Default process stack size; overriden by rx_SetStackSize */
181 #endif
182
183 /* This parameter should not normally be changed */
184 #define RX_PROCESS_PRIORITY     LWP_NORMAL_PRIORITY
185
186 #define ADDRSPERSITE 16
187
188 #ifndef KDUMP_RX_LOCK
189 /* Bottom n-bits of the Call Identifier give the call number */
190 #define RX_MAXCALLS 4           /* Power of 2; max async calls per connection */
191 #define RX_CIDSHIFT 2           /* Log2(RX_MAXCALLS) */
192 #define RX_CHANNELMASK (RX_MAXCALLS-1)
193 #define RX_CIDMASK  (~RX_CHANNELMASK)
194 #endif /* !KDUMP_RX_LOCK */
195
196 #ifndef KERNEL
197 typedef void (*rx_destructor_t) (void *);
198 int rx_KeyCreate(rx_destructor_t);
199 osi_socket rxi_GetHostUDPSocket(u_int host, u_short port);
200 osi_socket rxi_GetUDPSocket(u_short port);
201 #endif /* KERNEL */
202
203
204 int ntoh_syserr_conv(int error);
205
206 #define RX_WAIT     1
207 #define RX_DONTWAIT 0
208
209 #define rx_HostOf(peer)                 ((peer)->host)
210 #define rx_PortOf(peer)                 ((peer)->port)
211 #define rx_GetLocalStatus(call, status) ((call)->localStatus)
212
213
214 static_inline int
215 rx_IsLoopbackAddr(afs_uint32 addr)
216 {
217     return ((addr & 0xffff0000) == 0x7f000000);
218 }
219
220 /*******************
221  * Macros callable by the user to further define attributes of a
222  * service.  Must be called before rx_StartServer
223  */
224
225 /* Set the service stack size.  This currently just sets the stack
226  * size for all processes to be the maximum seen, so far */
227 #define rx_SetStackSize(service, stackSize) \
228   rx_stackSize = (((stackSize) > rx_stackSize)? stackSize: rx_stackSize)
229
230 /* Set minimum number of processes guaranteed to be available for this
231  * service at all times */
232 #define rx_SetMinProcs(service, min) ((service)->minProcs = (min))
233
234 /* Set maximum number of processes that will be made available to this
235  * service (also a guarantee that this number will be made available
236  * if there is no competition) */
237 #define rx_SetMaxProcs(service, max) ((service)->maxProcs = (max))
238
239 /* Define a procedure to be called just before a server connection is destroyed */
240 #define rx_SetDestroyConnProc(service,proc) ((service)->destroyConnProc = (proc))
241
242 /* Define procedure to set service dead time */
243 #define rx_SetIdleDeadTime(service,time) ((service)->idleDeadTime = (time))
244
245 /* Define error to return in server connections when failing to answer */
246 #define rx_SetServerIdleDeadErr(service,err) ((service)->idleDeadErr = (err))
247
248 /* Define procedures for getting and setting before and after execute-request procs */
249 #define rx_SetAfterProc(service,proc) ((service)->afterProc = (proc))
250 #define rx_SetBeforeProc(service,proc) ((service)->beforeProc = (proc))
251 #define rx_GetAfterProc(service) ((service)->afterProc)
252 #define rx_GetBeforeProc(service) ((service)->beforeProc)
253 #define rx_SetPostProc(service,proc) ((service)->postProc = (proc))
254 #define rx_GetPostProc(service) ((service)->postProc)
255
256 /* Define a procedure to be called when a server connection is created */
257 #define rx_SetNewConnProc(service, proc) ((service)->newConnProc = (proc))
258
259 /* NOTE:  We'll probably redefine the following three routines, again, sometime. */
260
261 /* Set the connection dead time for any connections created for this service (server only) */
262 #define rx_SetServiceDeadTime(service, seconds) ((service)->secondsUntilDead = (seconds))
263
264 /* Enable or disable asymmetric client checking for a service */
265 #define rx_SetCheckReach(service, x) ((service)->checkReach = (x))
266
267
268 /* Set the overload threshold and the overload error */
269 #define rx_SetBusyThreshold(threshold, code) (rx_BusyThreshold=(threshold),rx_BusyError=(code))
270
271 /* If this flag is set,no new requests are processed by rx, all new requests are
272 returned with an error code of RX_CALL_DEAD ( transient error ) */
273 #define rx_SetRxTranquil()              (rx_tranquil = 1)
274 #define rx_ClearRxTranquil()            (rx_tranquil = 0)
275
276 /* Set the threshold and time to delay aborts for consecutive errors */
277 #define rx_SetCallAbortThreshold(A) (rxi_callAbortThreshhold = (A))
278 #define rx_SetCallAbortDelay(A) (rxi_callAbortDelay = (A))
279 #define rx_SetConnAbortThreshold(A) (rxi_connAbortThreshhold = (A))
280 #define rx_SetConnAbortDelay(A) (rxi_connAbortDelay = (A))
281
282
283
284 #define cpspace(call) ((call)->curlen)
285 #define cppos(call) ((call)->curpos)
286
287 #define rx_Read(call, buf, nbytes)   rx_ReadProc(call, buf, nbytes)
288 #define rx_Read32(call, value)   rx_ReadProc32(call, value)
289 #define rx_Readv(call, iov, nio, maxio, nbytes) \
290    rx_ReadvProc(call, iov, nio, maxio, nbytes)
291 #define rx_Write(call, buf, nbytes) rx_WriteProc(call, buf, nbytes)
292 #define rx_Write32(call, value) rx_WriteProc32(call, value)
293 #define rx_Writev(call, iov, nio, nbytes) \
294    rx_WritevProc(call, iov, nio, nbytes)
295
296 /* This is the maximum size data packet that can be sent on this connection, accounting for security module-specific overheads. */
297 #define rx_MaxUserDataSize(call)                ((call)->MTU - RX_HEADER_SIZE - (call)->conn->securityHeaderSize - (call)->conn->securityMaxTrailerSize)
298
299 /* Macros to turn the hot thread feature on and off. Enabling hot threads
300  * allows the listener thread to trade places with an idle worker thread,
301  * which moves the context switch from listener to worker out of the
302  * critical path.
303  */
304 #define rx_EnableHotThread()            (rx_enable_hot_thread = 1)
305 #define rx_DisableHotThread()           (rx_enable_hot_thread = 0)
306
307 #define rx_PutConnection(conn) rx_DestroyConnection(conn)
308
309 /* A service is installed by rx_NewService, and specifies a service type that
310  * is exported by this process.  Incoming calls are stamped with the service
311  * type, and must match an installed service for the call to be accepted.
312  * Each service exported has a (port,serviceId) pair to uniquely identify it.
313  * It is also named:  this is intended to allow a remote statistics gathering
314  * program to retrieve per service statistics without having to know the local
315  * service id's.  Each service has a number of
316  */
317
318 /* security objects (instances of security classes) which implement
319  * various types of end-to-end security protocols for connections made
320  * to this service.  Finally, there are two parameters controlling the
321  * number of requests which may be executed in parallel by this
322  * service: minProcs is the number of requests to this service which
323  * are guaranteed to be able to run in parallel at any time; maxProcs
324  * has two meanings: it limits the total number of requests which may
325  * execute in parallel and it also guarantees that that many requests
326  * may be handled in parallel if no other service is handling any
327  * requests. */
328
329 struct rx_service {
330     u_short serviceId;          /* Service number */
331     afs_uint32 serviceHost;     /* IP address for this service */
332     u_short servicePort;        /* UDP port for this service */
333     char *serviceName;          /* Name of the service */
334     osi_socket socket;          /* socket structure or file descriptor */
335     u_short nRequestsRunning;   /* Number of requests currently in progress */
336     u_short nSecurityObjects;   /* Number of entries in security objects array */
337     struct rx_securityClass **securityObjects;  /* Array of security class objects */
338       afs_int32(*executeRequestProc) (struct rx_call * acall);  /* Routine to call when an rpc request is received */
339     void (*destroyConnProc) (struct rx_connection * tcon);      /* Routine to call when a server connection is destroyed */
340     void (*newConnProc) (struct rx_connection * tcon);  /* Routine to call when a server connection is created */
341     void (*beforeProc) (struct rx_call * acall);        /* routine to call before a call is executed */
342     void (*afterProc) (struct rx_call * acall, afs_int32 code); /* routine to call after a call is executed */
343     void (*postProc) (afs_int32 code);  /* routine to call after the call has ended */
344     u_short maxProcs;           /* Maximum procs to be used for this service */
345     u_short minProcs;           /* Minimum # of requests guaranteed executable simultaneously */
346     u_short connDeadTime;       /* Seconds until a client of this service will be declared dead, if it is not responding */
347     u_short idleDeadTime;       /* Time a server will wait for I/O to start up again */
348     u_char checkReach;          /* Check for asymmetric clients? */
349     afs_int32 idleDeadErr;
350     int nSpecific;              /* number entries in specific data */
351     void **specific;            /* pointer to connection specific data */
352 #ifdef  RX_ENABLE_LOCKS
353     afs_kmutex_t svc_data_lock; /* protect specific data */
354 #endif
355
356 };
357
358 #endif /* KDUMP_RX_LOCK */
359
360 /* A server puts itself on an idle queue for a service using an
361  * instance of the following structure.  When a call arrives, the call
362  * structure pointer is placed in "newcall", the routine to execute to
363  * service the request is placed in executeRequestProc, and the
364  * process is woken up.  The queue entry's address is used for the
365  * sleep/wakeup. If socketp is non-null, then this thread is willing
366  * to become a listener thread. A thread sets *socketp to -1 before
367  * sleeping. If *socketp is not -1 when the thread awakes, it is now
368  * the listener thread for *socketp. When socketp is non-null, tno
369  * contains the server's threadID, which is used to make decitions in GetCall.
370  */
371 #ifdef KDUMP_RX_LOCK
372 struct rx_serverQueueEntry_rx_lock {
373 #else
374 struct rx_serverQueueEntry {
375 #endif
376     struct rx_queue queueItemHeader;
377 #ifdef KDUMP_RX_LOCK
378     struct rx_call_rx_lock *newcall;
379 #else
380     struct rx_call *newcall;
381 #endif
382 #ifdef  RX_ENABLE_LOCKS
383     afs_kmutex_t lock;
384     afs_kcondvar_t cv;
385 #endif
386     int tno;
387     osi_socket *socketp;
388 };
389
390
391 /* A peer refers to a peer process, specified by a (host,port) pair.  There may be more than one peer on a given host. */
392 #ifdef KDUMP_RX_LOCK
393 struct rx_peer_rx_lock {
394     struct rx_peer_rx_lock *next;       /* Next in hash conflict or free list */
395 #else
396 struct rx_peer {
397     struct rx_peer *next;       /* Next in hash conflict or free list */
398 #endif
399 #ifdef RX_ENABLE_LOCKS
400     afs_kmutex_t peer_lock;     /* Lock peer */
401 #endif                          /* RX_ENABLE_LOCKS */
402     afs_uint32 host;            /* Remote IP address, in net byte order */
403     u_short port;               /* Remote UDP port, in net byte order */
404
405     /* interface mtu probably used for this host  -  includes RX Header */
406     u_short ifMTU;              /* doesn't include IP header */
407
408     /* For garbage collection */
409     afs_uint32 idleWhen;        /* When the refcountwent to zero */
410     afs_int32 refCount;         /* Reference count for this structure (rx_peerHashTable_lock) */
411
412     /* Congestion control parameters */
413     u_char burstSize;           /* Reinitialization size for the burst parameter */
414     u_char burst;               /* Number of packets that can be transmitted right now, without pausing */
415     struct clock burstWait;     /* Delay until new burst is allowed */
416     struct rx_queue congestionQueue;    /* Calls that are waiting for non-zero burst value */
417     int rtt;                    /* Smoothed round trip time, measured in milliseconds/8 */
418     int rtt_dev;                /* Smoothed rtt mean difference, in milliseconds/4 */
419     int nSent;                  /* Total number of distinct data packets sent, not including retransmissions */
420     int reSends;                /* Total number of retransmissions for this peer, since this structure was created */
421
422 /* Skew: if a packet is received N packets later than expected (based
423  * on packet serial numbers), then we define it to have a skew of N.
424  * The maximum skew values allow us to decide when a packet hasn't
425  * been received yet because it is out-of-order, as opposed to when it
426  * is likely to have been dropped. */
427     afs_uint32 inPacketSkew;    /* Maximum skew on incoming packets */
428     afs_uint32 outPacketSkew;   /* Peer-reported max skew on our sent packets */
429
430     /* the "natural" MTU, excluding IP,UDP headers, is negotiated by the endpoints */
431     u_short natMTU;
432     u_short maxMTU;
433     /* negotiated maximum number of packets to send in a single datagram. */
434     u_short maxDgramPackets;
435     /* local maximum number of packets to send in a single datagram. */
436     u_short ifDgramPackets;
437     /*
438      * MTU, cwind, and nDgramPackets are used to initialize
439      * slow start parameters for new calls. These values are set whenever a
440      * call sends a retransmission and at the end of each call.
441      * congestSeq is incremented each time the congestion parameters are
442      * changed by a call recovering from a dropped packet. A call used
443      * MAX when updating congestion parameters if it started with the
444      * current congestion sequence number, otherwise it uses MIN.
445      */
446     u_short MTU;                /* MTU for AFS 3.4a jumboGrams */
447     u_short cwind;              /* congestion window */
448     u_short nDgramPackets;      /* number packets per AFS 3.5 jumbogram */
449     u_short congestSeq;         /* Changed when a call retransmits */
450     afs_hyper_t bytesSent;      /* Number of bytes sent to this peer */
451     afs_hyper_t bytesReceived;  /* Number of bytes received from this peer */
452     struct rx_queue rpcStats;   /* rpc statistic list */
453     int lastReachTime;          /* Last time we verified reachability */
454     afs_int32 maxPacketSize;    /* peer packetsize hint */
455 };
456
457 #ifndef KDUMP_RX_LOCK
458 /* Flag bits for connection structure */
459 #define RX_CONN_MAKECALL_WAITING    1   /* rx_NewCall is waiting for a channel */
460 #define RX_CONN_DESTROY_ME          2   /* Destroy *client* connection after last call */
461 #define RX_CONN_USING_PACKET_CKSUM  4   /* non-zero header.spare field seen */
462 #define RX_CONN_KNOW_WINDOW         8   /* window size negotiation works */
463 #define RX_CONN_RESET              16   /* connection is reset, remove */
464 #define RX_CONN_BUSY               32   /* connection is busy; don't delete */
465 #define RX_CONN_ATTACHWAIT         64   /* attach waiting for peer->lastReach */
466 #define RX_CONN_MAKECALL_ACTIVE   128   /* a thread is actively in rx_NewCall */
467 #define RX_CONN_NAT_PING          256   /* nat ping requested */
468
469 /* Type of connection, client or server */
470 #define RX_CLIENT_CONNECTION    0
471 #define RX_SERVER_CONNECTION    1
472 #endif /* !KDUMP_RX_LOCK */
473
474 /* Maximum number of acknowledgements in an acknowledge packet */
475 #define RX_MAXACKS          255
476
477 #ifndef KDUMP_RX_LOCK
478
479 /* The structure of the data portion of an acknowledge packet: An acknowledge
480  * packet is in network byte order at all times.  An acknowledgement is always
481  * prompted for a specific reason by a specific incoming packet.  This reason
482  * is reported in "reason" and the packet's sequence number in the packet
483  * header.seq.  In addition to this information, all of the current
484  * acknowledgement information about this call is placed in the packet.
485  * "FirstPacket" is the sequence number of the first packet represented in an
486  * array of bytes, "acks", containing acknowledgement information for a number
487  * of consecutive packets.  All packets prior to FirstPacket are implicitly
488  * acknowledged: the sender need no longer be concerned about them.  Packets
489  * from firstPacket+nAcks and on are not acknowledged.  Packets in the range
490  * [firstPacket,firstPacket+nAcks) are each acknowledged explicitly.  The
491  * acknowledgement may be RX_NACK if the packet is not (currently) at the
492  * receiver (it may have never been received, or received and then later
493  * dropped), or it may be RX_ACK if the packet is queued up waiting to be read
494  * by the upper level software.  RX_ACK does not imply that the packet may not
495  * be dropped before it is read; it does imply that the sender should stop
496  * retransmitting the packet until notified otherwise.  The field
497  * previousPacket identifies the previous packet received by the peer.  This
498  * was used in a previous version of this software, and could be used in the
499  * future.  The serial number in the data part of the ack packet corresponds to
500  * the serial number oof the packet which prompted the acknowledge.  Any
501  * packets which are explicitly not acknowledged, and which were last
502  * transmitted with a serial number less than the provided serial number,
503  * should be retransmitted immediately.  Actually, this is slightly inaccurate:
504  * packets are not necessarily received in order.  When packets are habitually
505  * transmitted out of order, this is allowed for in the retransmission
506  * algorithm by introducing the notion of maximum packet skew: the degree of
507  * out-of-orderness of the packets received on the wire.  This number is
508  * communicated from the receiver to the sender in ack packets. */
509
510 struct rx_ackPacket {
511     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. */
512     u_short maxSkew;            /* Maximum difference between serial# of packet acknowledged and highest packet yet received */
513     afs_uint32 firstPacket;     /* The first packet in the list of acknowledged packets */
514     afs_uint32 previousPacket;  /* The previous packet number received (obsolete?) */
515     afs_uint32 serial;          /* Serial number of the packet which prompted the acknowledge */
516     u_char reason;              /* Reason for the acknowledge of ackPacket, defined below */
517     u_char nAcks;               /* Number of acknowledgements */
518     u_char acks[RX_MAXACKS];    /* Up to RX_MAXACKS packet acknowledgements, defined below */
519     /* 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) */
520 };
521
522 #define FIRSTACKOFFSET 4
523
524 /* Reason for acknowledge message */
525 #define RX_ACK_REQUESTED        1       /* Peer requested an ack on this packet */
526 #define RX_ACK_DUPLICATE        2       /* Duplicate packet */
527 #define RX_ACK_OUT_OF_SEQUENCE  3       /* Packet out of sequence */
528 #define RX_ACK_EXCEEDS_WINDOW   4       /* Packet sequence number higher than window; discarded */
529 #define RX_ACK_NOSPACE          5       /* No buffer space at all */
530 #define RX_ACK_PING             6       /* This is a keep-alive ack */
531 #define RX_ACK_PING_RESPONSE    7       /* Ack'ing because we were pinged */
532 #define RX_ACK_DELAY            8       /* Ack generated since nothing has happened since receiving packet */
533 #define RX_ACK_IDLE             9       /* Similar to RX_ACK_DELAY, but can
534                                          * be used to compute RTT */
535 #define RX_ACK_MTU             -1       /* will be rewritten to ACK_PING */
536
537 /* Packet acknowledgement type */
538 #define RX_ACK_TYPE_NACK        0       /* I Don't have this packet */
539 #define RX_ACK_TYPE_ACK         1       /* I have this packet, although I may discard it later */
540
541 /* The packet size transmitted for an acknowledge is adjusted to reflect the actual size of the acks array.  This macro defines the size */
542 #define rx_AckDataSize(nAcks) (3 + nAcks + offsetof(struct rx_ackPacket, acks[0]))
543
544 #define RX_CHALLENGE_TIMEOUT    2       /* Number of seconds before another authentication request packet is generated */
545 #define RX_CHALLENGE_MAXTRIES   50      /* Max # of times we resend challenge */
546 #define RX_CHECKREACH_TIMEOUT   2       /* Number of seconds before another ping is generated */
547 #define RX_CHECKREACH_TTL       60      /* Re-check reachability this often */
548
549 /* 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 */
550
551 /* Something bad happened to the connection; temporary loss of communication */
552 #define RX_CALL_DEAD                (-1)
553
554 /* An invalid operation, such as a client attempting to send data after having received the beginning of a reply from the server */
555 #define RX_INVALID_OPERATION        (-2)
556
557 /* An optional timeout per call may be specified */
558 #define RX_CALL_TIMEOUT             (-3)
559
560 /* End of data on a read */
561 #define RX_EOF                      (-4)
562
563 /* Some sort of low-level protocol error */
564 #define RX_PROTOCOL_ERROR           (-5)
565
566 /* 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 */
567 #define RX_USER_ABORT               (-6)
568
569 /* Port already in use (from rx_Init) */
570 #define RX_ADDRINUSE                (-7)
571
572 /* EMSGSIZE returned from network.  Packet too big, must fragment */
573 #define RX_MSGSIZE                  (-8)
574
575 /* transient failure detected ( possibly the server is restarting ) */
576 /* this shud be equal to VRESTARTING ( util/errors.h ) for old clients to work */
577 #define RX_RESTARTING               (-100)
578
579 typedef enum {
580     RX_SECIDX_NULL = 0,
581     RX_SECIDX_KAD  = 2,
582     RX_SECIDX_GK   = 4,
583     RX_SECIDX_K5   = 5,
584 } rx_securityIndex;
585
586 struct rx_securityObjectStats {
587     char type;                  /* 0:unk 1:null,2:vab 3:kad */
588     char level;
589     char sparec[10];            /* force correct alignment */
590     afs_int32 flags;            /* 1=>unalloc, 2=>auth, 4=>expired */
591     afs_uint32 expires;
592     afs_uint32 packetsReceived;
593     afs_uint32 packetsSent;
594     afs_uint32 bytesReceived;
595     afs_uint32 bytesSent;
596     short spares[4];
597     afs_int32 sparel[8];
598 };
599
600 /* Configuration settings */
601
602 /* Enum for storing configuration variables which can be set via the
603  * SetConfiguration method in the rx_securityClass, below
604  */
605
606 typedef enum {
607      RXS_CONFIG_FLAGS /* afs_uint32 set of bitwise flags */
608 } rx_securityConfigVariables;
609
610 /* For the RXS_CONFIG_FLAGS, the following bit values are defined */
611
612 /* Disable the principal name contains dot check in rxkad */
613 #define RXS_CONFIG_FLAGS_DISABLE_DOTCHECK       0x01
614
615 /* XXXX (rewrite this description) A security class object contains a set of
616  * procedures and some private data to implement a security model for rx
617  * connections.  These routines are called by rx as appropriate.  Rx knows
618  * nothing about the internal details of any particular security model, or
619  * about security state.  Rx does maintain state per connection on behalf of
620  * the security class.  Each security class implementation is also expected to
621  * provide routines to create these objects.  Rx provides a basic routine to
622  * allocate one of these objects; this routine must be called by the class. */
623 struct rx_securityClass {
624     struct rx_securityOps {
625         int (*op_Close) (struct rx_securityClass * aobj);
626         int (*op_NewConnection) (struct rx_securityClass * aobj,
627                                  struct rx_connection * aconn);
628         int (*op_PreparePacket) (struct rx_securityClass * aobj,
629                                  struct rx_call * acall,
630                                  struct rx_packet * apacket);
631         int (*op_SendPacket) (struct rx_securityClass * aobj,
632                               struct rx_call * acall,
633                               struct rx_packet * apacket);
634         int (*op_CheckAuthentication) (struct rx_securityClass * aobj,
635                                        struct rx_connection * aconn);
636         int (*op_CreateChallenge) (struct rx_securityClass * aobj,
637                                    struct rx_connection * aconn);
638         int (*op_GetChallenge) (struct rx_securityClass * aobj,
639                                 struct rx_connection * aconn,
640                                 struct rx_packet * apacket);
641         int (*op_GetResponse) (struct rx_securityClass * aobj,
642                                struct rx_connection * aconn,
643                                struct rx_packet * apacket);
644         int (*op_CheckResponse) (struct rx_securityClass * aobj,
645                                  struct rx_connection * aconn,
646                                  struct rx_packet * apacket);
647         int (*op_CheckPacket) (struct rx_securityClass * aobj,
648                                struct rx_call * acall,
649                                struct rx_packet * apacket);
650         int (*op_DestroyConnection) (struct rx_securityClass * aobj,
651                                      struct rx_connection * aconn);
652         int (*op_GetStats) (struct rx_securityClass * aobj,
653                             struct rx_connection * aconn,
654                             struct rx_securityObjectStats * astats);
655         int (*op_SetConfiguration) (struct rx_securityClass * aobj,
656                                     struct rx_connection * aconn,
657                                     rx_securityConfigVariables atype,
658                                     void * avalue,
659                                     void ** acurrentValue);
660         int (*op_Spare2) (void);
661         int (*op_Spare3) (void);
662     } *ops;
663     void *privateData;
664     int refCount;
665 };
666
667 #define RXS_OP(obj,op,args) ((obj && (obj->ops->op_ ## op)) ? (*(obj)->ops->op_ ## op)args : 0)
668
669 #define RXS_Close(obj) RXS_OP(obj,Close,(obj))
670 #define RXS_NewConnection(obj,conn) RXS_OP(obj,NewConnection,(obj,conn))
671 #define RXS_PreparePacket(obj,call,packet) RXS_OP(obj,PreparePacket,(obj,call,packet))
672 #define RXS_SendPacket(obj,call,packet) RXS_OP(obj,SendPacket,(obj,call,packet))
673 #define RXS_CheckAuthentication(obj,conn) RXS_OP(obj,CheckAuthentication,(obj,conn))
674 #define RXS_CreateChallenge(obj,conn) RXS_OP(obj,CreateChallenge,(obj,conn))
675 #define RXS_GetChallenge(obj,conn,packet) RXS_OP(obj,GetChallenge,(obj,conn,packet))
676 #define RXS_GetResponse(obj,conn,packet) RXS_OP(obj,GetResponse,(obj,conn,packet))
677 #define RXS_CheckResponse(obj,conn,packet) RXS_OP(obj,CheckResponse,(obj,conn,packet))
678 #define RXS_CheckPacket(obj,call,packet) RXS_OP(obj,CheckPacket,(obj,call,packet))
679 #define RXS_DestroyConnection(obj,conn) RXS_OP(obj,DestroyConnection,(obj,conn))
680 #define RXS_GetStats(obj,conn,stats) RXS_OP(obj,GetStats,(obj,conn,stats))
681 #define RXS_SetConfiguration(obj, conn, type, value, currentValue) RXS_OP(obj, SetConfiguration,(obj,conn,type,value,currentValue))
682
683
684
685 /* Structure for keeping rx statistics.  Note that this structure is returned
686  * by rxdebug, so, for compatibility reasons, new fields should be appended (or
687  * spares used), the rxdebug protocol checked, if necessary, and the PrintStats
688  * code should be updated as well.
689  *
690  * Clearly we assume that ntohl will work on these structures so sizeof(int)
691  * must equal sizeof(afs_int32). */
692
693 struct rx_statistics {          /* General rx statistics */
694     int packetRequests;         /* Number of packet allocation requests */
695     int receivePktAllocFailures;
696     int sendPktAllocFailures;
697     int specialPktAllocFailures;
698     int socketGreedy;           /* Whether SO_GREEDY succeeded */
699     int bogusPacketOnRead;      /* Number of inappropriately short packets received */
700     int bogusHost;              /* Host address from bogus packets */
701     int noPacketOnRead;         /* Number of read packets attempted when there was actually no packet to read off the wire */
702     int noPacketBuffersOnRead;  /* Number of dropped data packets due to lack of packet buffers */
703     int selects;                /* Number of selects waiting for packet or timeout */
704     int sendSelects;            /* Number of selects forced when sending packet */
705     int packetsRead[RX_N_PACKET_TYPES]; /* Total number of packets read, per type */
706     int dataPacketsRead;        /* Number of unique data packets read off the wire */
707     int ackPacketsRead;         /* Number of ack packets read */
708     int dupPacketsRead;         /* Number of duplicate data packets read */
709     int spuriousPacketsRead;    /* Number of inappropriate data packets */
710     int packetsSent[RX_N_PACKET_TYPES]; /* Number of rxi_Sends: packets sent over the wire, per type */
711     int ackPacketsSent;         /* Number of acks sent */
712     int pingPacketsSent;        /* Total number of ping packets sent */
713     int abortPacketsSent;       /* Total number of aborts */
714     int busyPacketsSent;        /* Total number of busies sent received */
715     int dataPacketsSent;        /* Number of unique data packets sent */
716     int dataPacketsReSent;      /* Number of retransmissions */
717     int dataPacketsPushed;      /* Number of retransmissions pushed early by a NACK */
718     int ignoreAckedPacket;      /* Number of packets with acked flag, on rxi_Start */
719     struct clock totalRtt;      /* Total round trip time measured (use to compute average) */
720     struct clock minRtt;        /* Minimum round trip time measured */
721     struct clock maxRtt;        /* Maximum round trip time measured */
722     int nRttSamples;            /* Total number of round trip samples */
723     int nServerConns;           /* Total number of server connections */
724     int nClientConns;           /* Total number of client connections */
725     int nPeerStructs;           /* Total number of peer structures */
726     int nCallStructs;           /* Total number of call structures allocated */
727     int nFreeCallStructs;       /* Total number of previously allocated free call structures */
728     int netSendFailures;
729     afs_int32 fatalErrors;
730     int ignorePacketDally;      /* packets dropped because call is in dally state */
731     int receiveCbufPktAllocFailures;
732     int sendCbufPktAllocFailures;
733     int nBusies;
734     int spares[4];
735 };
736
737 /* structures for debug input and output packets */
738
739 /* debug input types */
740 struct rx_debugIn {
741     afs_int32 type;
742     afs_int32 index;
743 };
744
745 /* Invalid rx debug package type */
746 #define RX_DEBUGI_BADTYPE     (-8)
747
748 #define RX_DEBUGI_VERSION_MINIMUM ('L') /* earliest real version */
749 #define RX_DEBUGI_VERSION     ('S')    /* Latest version */
750     /* first version w/ secStats */
751 #define RX_DEBUGI_VERSION_W_SECSTATS ('L')
752     /* version M is first supporting GETALLCONN and RXSTATS type */
753 #define RX_DEBUGI_VERSION_W_GETALLCONN ('M')
754 #define RX_DEBUGI_VERSION_W_RXSTATS ('M')
755     /* last version with unaligned debugConn */
756 #define RX_DEBUGI_VERSION_W_UNALIGNED_CONN ('L')
757 #define RX_DEBUGI_VERSION_W_WAITERS ('N')
758 #define RX_DEBUGI_VERSION_W_IDLETHREADS ('O')
759 #define RX_DEBUGI_VERSION_W_NEWPACKETTYPES ('P')
760 #define RX_DEBUGI_VERSION_W_GETPEER ('Q')
761 #define RX_DEBUGI_VERSION_W_WAITED ('R')
762 #define RX_DEBUGI_VERSION_W_PACKETS ('S')
763
764 #define RX_DEBUGI_GETSTATS      1       /* get basic rx stats */
765 #define RX_DEBUGI_GETCONN       2       /* get connection info */
766 #define RX_DEBUGI_GETALLCONN    3       /* get even uninteresting conns */
767 #define RX_DEBUGI_RXSTATS       4       /* get all rx stats */
768 #define RX_DEBUGI_GETPEER       5       /* get all peer structs */
769
770 struct rx_debugStats {
771     afs_int32 nFreePackets;
772     afs_int32 packetReclaims;
773     afs_int32 callsExecuted;
774     char waitingForPackets;
775     char usedFDs;
776     char version;
777     char spare1;
778     afs_int32 nWaiting;
779     afs_int32 idleThreads;      /* Number of server threads that are idle */
780     afs_int32 nWaited;
781     afs_int32 nPackets;
782     afs_int32 spare2[6];
783 };
784
785 struct rx_debugConn_vL {
786     afs_uint32 host;
787     afs_int32 cid;
788     afs_int32 serial;
789     afs_int32 callNumber[RX_MAXCALLS];
790     afs_int32 error;
791     short port;
792     char flags;
793     char type;
794     char securityIndex;
795     char callState[RX_MAXCALLS];
796     char callMode[RX_MAXCALLS];
797     char callFlags[RX_MAXCALLS];
798     char callOther[RX_MAXCALLS];
799     /* old style getconn stops here */
800     struct rx_securityObjectStats secStats;
801     afs_int32 sparel[10];
802 };
803
804 struct rx_debugConn {
805     afs_uint32 host;
806     afs_int32 cid;
807     afs_int32 serial;
808     afs_int32 callNumber[RX_MAXCALLS];
809     afs_int32 error;
810     short port;
811     char flags;
812     char type;
813     char securityIndex;
814     char sparec[3];             /* force correct alignment */
815     char callState[RX_MAXCALLS];
816     char callMode[RX_MAXCALLS];
817     char callFlags[RX_MAXCALLS];
818     char callOther[RX_MAXCALLS];
819     /* old style getconn stops here */
820     struct rx_securityObjectStats secStats;
821     afs_int32 epoch;
822     afs_int32 natMTU;
823     afs_int32 sparel[9];
824 };
825
826 struct rx_debugPeer {
827     afs_uint32 host;
828     u_short port;
829     u_short ifMTU;
830     afs_uint32 idleWhen;
831     short refCount;
832     u_char burstSize;
833     u_char burst;
834     struct clock burstWait;
835     afs_int32 rtt;
836     afs_int32 rtt_dev;
837     struct clock timeout;
838     afs_int32 nSent;
839     afs_int32 reSends;
840     afs_int32 inPacketSkew;
841     afs_int32 outPacketSkew;
842     afs_int32 rateFlag;
843     u_short natMTU;
844     u_short maxMTU;
845     u_short maxDgramPackets;
846     u_short ifDgramPackets;
847     u_short MTU;
848     u_short cwind;
849     u_short nDgramPackets;
850     u_short congestSeq;
851     afs_hyper_t bytesSent;
852     afs_hyper_t bytesReceived;
853     afs_int32 sparel[10];
854 };
855
856 #define RX_OTHER_IN     1       /* packets avail in in queue */
857 #define RX_OTHER_OUT    2       /* packets avail in out queue */
858
859 #define RX_SERVER_DEBUG_SEC_STATS               0x1
860 #define RX_SERVER_DEBUG_ALL_CONN                0x2
861 #define RX_SERVER_DEBUG_RX_STATS                0x4
862 #define RX_SERVER_DEBUG_WAITER_CNT              0x8
863 #define RX_SERVER_DEBUG_IDLE_THREADS            0x10
864 #define RX_SERVER_DEBUG_OLD_CONN                0x20
865 #define RX_SERVER_DEBUG_NEW_PACKETS             0x40
866 #define RX_SERVER_DEBUG_ALL_PEER                0x80
867 #define RX_SERVER_DEBUG_WAITED_CNT              0x100
868 #define RX_SERVER_DEBUG_PACKETS_CNT              0x200
869
870 #define AFS_RX_STATS_CLEAR_ALL                  0xffffffff
871 #define AFS_RX_STATS_CLEAR_INVOCATIONS          0x1
872 #define AFS_RX_STATS_CLEAR_BYTES_SENT           0x2
873 #define AFS_RX_STATS_CLEAR_BYTES_RCVD           0x4
874 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM       0x8
875 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE    0x10
876 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN       0x20
877 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX       0x40
878 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SUM        0x80
879 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE     0x100
880 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MIN        0x200
881 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MAX        0x400
882
883 typedef struct rx_function_entry_v1 {
884     afs_uint32 remote_peer;
885     afs_uint32 remote_port;
886     afs_uint32 remote_is_server;
887     afs_uint32 interfaceId;
888     afs_uint32 func_total;
889     afs_uint32 func_index;
890     afs_hyper_t invocations;
891     afs_hyper_t bytes_sent;
892     afs_hyper_t bytes_rcvd;
893     struct clock queue_time_sum;
894     struct clock queue_time_sum_sqr;
895     struct clock queue_time_min;
896     struct clock queue_time_max;
897     struct clock execution_time_sum;
898     struct clock execution_time_sum_sqr;
899     struct clock execution_time_min;
900     struct clock execution_time_max;
901 } rx_function_entry_v1_t, *rx_function_entry_v1_p;
902
903 /*
904  * If you need to change rx_function_entry, you should probably create a brand
905  * new structure.  Keeping the old structure will allow backwards compatibility
906  * with old clients (even if it is only used to calculate allocation size).
907  * If you do change the size or the format, you'll need to bump
908  * RX_STATS_RETRIEVAL_VERSION.  This allows some primitive form
909  * of versioning a la rxdebug.
910  */
911
912 #define RX_STATS_RETRIEVAL_VERSION 1    /* latest version */
913 #define RX_STATS_RETRIEVAL_FIRST_EDITION 1      /* first implementation */
914
915 typedef struct rx_interface_stat {
916     struct rx_queue queue_header;
917     struct rx_queue all_peers;
918     rx_function_entry_v1_t stats[1];    /* make sure this is aligned correctly */
919 } rx_interface_stat_t, *rx_interface_stat_p;
920
921 #define RX_STATS_SERVICE_ID 409
922
923 #ifdef AFS_NT40_ENV
924 extern int rx_DumpCalls(FILE *outputFile, char *cookie);
925 #endif
926
927 #endif /* _RX_   End of rx.h */
928
929 #ifdef  KERNEL
930 #include "rx/rx_prototypes.h"
931 #else
932 #include "rx_prototypes.h"
933 #endif
934
935 #endif /* !KDUMP_RX_LOCK */