2 * Copyright 2000, International Business Machines Corporation and others.
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
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.
27 #include "rx_kmutex.h"
28 #include "rx_kernel.h"
29 #if defined (AFS_OBSD_ENV) && !defined (MLEN)
32 #include "netinet/in.h"
33 #include "sys/socket.h"
35 # include <sys/types.h>
38 #ifdef AFS_PTHREAD_ENV
39 # include "rx_pthread.h"
50 # include <netinet/in.h>
51 # include <sys/socket.h>
55 #include <opr/queue.h>
63 /* These items are part of the new RX API. They're living in this section
64 * for now, to keep them separate from everything else... */
70 /* Connection management */
72 extern afs_uint32
rx_GetConnectionEpoch(struct rx_connection
*conn
);
73 extern afs_uint32
rx_GetConnectionId(struct rx_connection
*conn
);
74 extern void *rx_GetSecurityData(struct rx_connection
*conn
);
75 extern void rx_SetSecurityData(struct rx_connection
*conn
, void *data
);
76 extern int rx_IsUsingPktCksum(struct rx_connection
*conn
);
77 extern void rx_SetSecurityHeaderSize(struct rx_connection
*conn
, afs_uint32 size
);
78 extern afs_uint32
rx_GetSecurityHeaderSize(struct rx_connection
*conn
);
79 extern void rx_SetSecurityMaxTrailerSize(struct rx_connection
*conn
, afs_uint32 size
);
80 extern afs_uint32
rx_GetSecurityMaxTrailerSize(struct rx_connection
*conn
);
81 extern void rx_SetMsgsizeRetryErr(struct rx_connection
*conn
, int err
);
82 extern int rx_IsServerConn(struct rx_connection
*conn
);
83 extern int rx_IsClientConn(struct rx_connection
*conn
);
84 extern struct rx_securityClass
*rx_SecurityObjectOf(const struct rx_connection
*);
85 extern struct rx_peer
*rx_PeerOf(struct rx_connection
*);
86 extern u_short
rx_ServiceIdOf(struct rx_connection
*);
87 extern int rx_SecurityClassOf(struct rx_connection
*);
88 extern struct rx_service
*rx_ServiceOf(struct rx_connection
*);
89 extern int rx_ConnError(struct rx_connection
*);
92 extern struct rx_connection
*rx_ConnectionOf(struct rx_call
*call
);
93 extern int rx_Error(struct rx_call
*call
);
94 extern int rx_GetRemoteStatus(struct rx_call
*call
);
95 extern void rx_SetLocalStatus(struct rx_call
*call
, int status
);
96 extern int rx_GetCallAbortCode(struct rx_call
*call
);
97 extern void rx_SetCallAbortCode(struct rx_call
*call
, int code
);
99 extern void rx_RecordCallStatistics(struct rx_call
*call
,
100 unsigned int rxInterface
,
101 unsigned int currentFunc
,
102 unsigned int totalFunc
,
105 extern void rx_GetCallStatus(struct rx_call
*call
,
107 afs_int32
*transmitNext
,
109 int *lastReceiveTime
);
110 /* Peer management */
111 extern afs_uint32
rx_HostOf(struct rx_peer
*peer
);
112 extern u_short
rx_PortOf(struct rx_peer
*peer
);
116 /* Packet classes, for rx_AllocPacket and rx_packetQuota */
117 #define RX_PACKET_CLASS_RECEIVE 0
118 #define RX_PACKET_CLASS_SEND 1
119 #define RX_PACKET_CLASS_SPECIAL 2
120 #define RX_PACKET_CLASS_RECV_CBUF 3
121 #define RX_PACKET_CLASS_SEND_CBUF 4
123 #define RX_N_PACKET_CLASSES 5 /* Must agree with above list */
125 #define RX_PACKET_TYPES {"data", "ack", "busy", "abort", "ackall", "challenge", "response", "debug", "params", "unused", "unused", "unused", "version"}
126 #define RX_N_PACKET_TYPES 13 /* Must agree with above list;
128 * WARNING: if this number ever
129 * grows past 13, rxdebug packets
130 * will need to be modified */
133 /* For most Unixes, maximum elements in an iovec is 16 */
134 #define RX_MAXIOVECS 16 /* limit for ReadvProc/WritevProc */
135 #define RX_MAXWVECS (RX_MAXIOVECS-1) /* need one iovec for packet header */
139 /* Call flags, states and modes are exposed by the debug interface */
140 #ifndef KDUMP_RX_LOCK
141 /* Major call states */
142 #define RX_STATE_NOTINIT 0 /* Call structure has never been initialized */
143 #define RX_STATE_PRECALL 1 /* Server-only: call is not in progress, but packets have arrived */
144 #define RX_STATE_ACTIVE 2 /* An active call; a process is dealing with this call */
145 #define RX_STATE_DALLY 3 /* Dallying after process is done with call */
146 #define RX_STATE_HOLD 4 /* Waiting for acks on reply data packets */
147 #define RX_STATE_RESET 5 /* Call is being reset */
149 /* Call modes: the modes of a call in RX_STATE_ACTIVE state (process attached) */
150 #define RX_MODE_SENDING 1 /* Sending or ready to send */
151 #define RX_MODE_RECEIVING 2 /* Receiving or ready to receive */
152 #define RX_MODE_ERROR 3 /* Something in error for current conversation */
153 #define RX_MODE_EOF 4 /* Server has flushed (or client has read) last reply packet */
156 #define RX_CALL_READER_WAIT 1 /* Reader is waiting for next packet */
157 #define RX_CALL_WAIT_WINDOW_ALLOC 2 /* Sender is waiting for window to allocate buffers */
158 #define RX_CALL_WAIT_WINDOW_SEND 4 /* Sender is waiting for window to send buffers */
159 #define RX_CALL_WAIT_PACKETS 8 /* Sender is waiting for packet buffers */
160 #define RX_CALL_WAIT_PROC 16 /* Waiting for a process to be assigned */
161 #define RX_CALL_RECEIVE_DONE 32 /* All packets received on this call */
162 #define RX_CALL_CLEARED 64 /* Receive queue cleared in precall state */
163 #define RX_CALL_TQ_BUSY 128 /* Call's Xmit Queue is busy; don't modify */
164 #define RX_CALL_TQ_CLEARME 256 /* Need to clear this call's TQ later */
165 #define RX_CALL_TQ_SOME_ACKED 512 /* rxi_Start needs to discard ack'd packets. */
166 #define RX_CALL_TQ_WAIT 1024 /* Reader is waiting for TQ_BUSY to be reset */
167 #define RX_CALL_FAST_RECOVER 2048 /* call is doing congestion recovery */
168 /* 4096 was RX_CALL_FAST_RECOVER_WAIT */
169 #define RX_CALL_SLOW_START_OK 8192 /* receiver acks every other packet */
170 #define RX_CALL_IOVEC_WAIT 16384 /* waiting thread is using an iovec */
171 #define RX_CALL_HAVE_LAST 32768 /* Last packet has been received */
172 #define RX_CALL_NEED_START 0x10000 /* tells rxi_Start to start again */
173 /* 0x20000 was RX_CALL_PEER_BUSY */
174 #define RX_CALL_ACKALL_SENT 0x40000 /* ACKALL has been sent on the call */
175 #define RX_CALL_FLUSH 0x80000 /* Transmit queue should be flushed to peer */
179 /* Configurable parameters */
180 #define RX_IDLE_DEAD_TIME 60 /* default idle dead time */
181 #define RX_MAX_SERVICES 20 /* Maximum number of services that may be installed */
182 #if defined(KERNEL) && defined(AFS_AIX51_ENV) && defined(__64__)
183 #define RX_DEFAULT_STACK_SIZE 24000
185 #define RX_DEFAULT_STACK_SIZE 16000 /* Default process stack size; overriden by rx_SetStackSize */
188 /* This parameter should not normally be changed */
189 #define RX_PROCESS_PRIORITY LWP_NORMAL_PRIORITY
191 #define ADDRSPERSITE 16
193 #ifndef KDUMP_RX_LOCK
194 /* Bottom n-bits of the Call Identifier give the call number */
195 #define RX_MAXCALLS 4 /* Power of 2; max async calls per connection */
196 #define RX_CIDSHIFT 2 /* Log2(RX_MAXCALLS) */
197 #define RX_CHANNELMASK (RX_MAXCALLS-1)
198 #define RX_CIDMASK (~RX_CHANNELMASK)
199 #endif /* !KDUMP_RX_LOCK */
202 typedef void (*rx_destructor_t
) (void *);
203 int rx_KeyCreate(rx_destructor_t
);
204 osi_socket
rxi_GetHostUDPSocket(u_int host
, u_short port
);
205 osi_socket
rxi_GetUDPSocket(u_short port
);
209 int ntoh_syserr_conv(int error
);
212 #define RX_DONTWAIT 0
214 #define rx_GetLocalStatus(call, status) ((call)->localStatus)
218 rx_IsLoopbackAddr(afs_uint32 addr
)
220 return ((addr
& 0xffff0000) == 0x7f000000);
224 * Macros callable by the user to further define attributes of a
225 * service. Must be called before rx_StartServer
228 /* Set the service stack size. This currently just sets the stack
229 * size for all processes to be the maximum seen, so far */
230 #define rx_SetStackSize(service, stackSize) \
231 rx_stackSize = (((stackSize) > rx_stackSize)? stackSize: rx_stackSize)
233 /* Set minimum number of processes guaranteed to be available for this
234 * service at all times */
235 #define rx_SetMinProcs(service, min) ((service)->minProcs = (min))
237 /* Set maximum number of processes that will be made available to this
238 * service (also a guarantee that this number will be made available
239 * if there is no competition) */
240 #define rx_SetMaxProcs(service, max) ((service)->maxProcs = (max))
242 /* Define a procedure to be called just before a server connection is destroyed */
243 #define rx_SetDestroyConnProc(service,proc) ((service)->destroyConnProc = (proc))
245 /* Define procedure to set service dead time */
246 #define rx_SetIdleDeadTime(service,time) ((service)->idleDeadTime = (time))
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)
256 /* Define a procedure to be called when a server connection is created */
257 #define rx_SetNewConnProc(service, proc) ((service)->newConnProc = (proc))
259 /* NOTE: We'll probably redefine the following three routines, again, sometime. */
261 /* Set the connection dead time for any connections created for this service (server only) */
262 #define rx_SetServiceDeadTime(service, seconds) ((service)->secondsUntilDead = (seconds))
264 /* Enable or disable asymmetric client checking for a service */
265 #define rx_SetCheckReach(service, x) ((service)->checkReach = (x))
267 /* Set the overload threshold and the overload error */
268 #define rx_SetBusyThreshold(threshold, code) (rx_BusyThreshold=(threshold),rx_BusyError=(code))
270 /* If this flag is set,no new requests are processed by rx, all new requests are
271 returned with an error code of RX_CALL_DEAD ( transient error ) */
272 #define rx_SetRxTranquil() (rx_tranquil = 1)
273 #define rx_ClearRxTranquil() (rx_tranquil = 0)
275 /* Set the threshold and time to delay aborts for consecutive errors */
276 #define rx_SetCallAbortThreshold(A) (rxi_callAbortThreshhold = (A))
277 #define rx_SetCallAbortDelay(A) (rxi_callAbortDelay = (A))
278 #define rx_SetConnAbortThreshold(A) (rxi_connAbortThreshhold = (A))
279 #define rx_SetConnAbortDelay(A) (rxi_connAbortDelay = (A))
283 #define cpspace(call) ((call)->curlen)
284 #define cppos(call) ((call)->curpos)
286 #define rx_Read(call, buf, nbytes) rx_ReadProc(call, buf, nbytes)
287 #define rx_Read32(call, value) rx_ReadProc32(call, value)
288 #define rx_Readv(call, iov, nio, maxio, nbytes) \
289 rx_ReadvProc(call, iov, nio, maxio, nbytes)
290 #define rx_Write(call, buf, nbytes) rx_WriteProc(call, buf, nbytes)
291 #define rx_Write32(call, value) rx_WriteProc32(call, value)
292 #define rx_Writev(call, iov, nio, nbytes) \
293 rx_WritevProc(call, iov, nio, nbytes)
295 /* This is the maximum size data packet that can be sent on this connection, accounting for security module-specific overheads. */
296 #define rx_MaxUserDataSize(call) ((call)->MTU - RX_HEADER_SIZE - (call)->conn->securityHeaderSize - (call)->conn->securityMaxTrailerSize)
298 /* Macros to turn the hot thread feature on and off. Enabling hot threads
299 * allows the listener thread to trade places with an idle worker thread,
300 * which moves the context switch from listener to worker out of the
303 #define rx_EnableHotThread() (rx_enable_hot_thread = 1)
304 #define rx_DisableHotThread() (rx_enable_hot_thread = 0)
306 #define rx_PutConnection(conn) rx_DestroyConnection(conn)
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
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
329 u_short serviceId
; /* Service number */
330 afs_uint32 serviceHost
; /* IP address for this service */
331 u_short servicePort
; /* UDP port for this service */
332 char *serviceName
; /* Name of the service */
333 osi_socket socket
; /* socket structure or file descriptor */
334 u_short nRequestsRunning
; /* Number of requests currently in progress */
335 u_short nSecurityObjects
; /* Number of entries in security objects array */
336 struct rx_securityClass
**securityObjects
; /* Array of security class objects */
337 afs_int32(*executeRequestProc
) (struct rx_call
* acall
); /* Routine to call when an rpc request is received */
338 void (*destroyConnProc
) (struct rx_connection
* tcon
); /* Routine to call when a server connection is destroyed */
339 void (*newConnProc
) (struct rx_connection
* tcon
); /* Routine to call when a server connection is created */
340 void (*beforeProc
) (struct rx_call
* acall
); /* routine to call before a call is executed */
341 void (*afterProc
) (struct rx_call
* acall
, afs_int32 code
); /* routine to call after a call is executed */
342 void (*postProc
) (afs_int32 code
); /* routine to call after the call has ended */
343 u_short maxProcs
; /* Maximum procs to be used for this service */
344 u_short minProcs
; /* Minimum # of requests guaranteed executable simultaneously */
345 u_short connDeadTime
; /* Seconds until a client of this service will be declared dead, if it is not responding */
346 u_short idleDeadTime
; /* Time a server will wait for I/O to start up again */
347 u_char checkReach
; /* Check for asymmetric clients? */
348 int nSpecific
; /* number entries in specific data */
349 void **specific
; /* pointer to connection specific data */
350 #ifdef RX_ENABLE_LOCKS
351 afs_kmutex_t svc_data_lock
; /* protect specific data */
356 #endif /* KDUMP_RX_LOCK */
358 #ifndef KDUMP_RX_LOCK
359 /* Flag bits for connection structure */
360 #define RX_CONN_MAKECALL_WAITING 1 /* rx_NewCall is waiting for a channel */
361 #define RX_CONN_DESTROY_ME 2 /* Destroy *client* connection after last call */
362 #define RX_CONN_USING_PACKET_CKSUM 4 /* non-zero header.spare field seen */
363 #define RX_CONN_KNOW_WINDOW 8 /* window size negotiation works */
364 #define RX_CONN_RESET 16 /* connection is reset, remove */
365 #define RX_CONN_BUSY 32 /* connection is busy; don't delete */
366 #define RX_CONN_ATTACHWAIT 64 /* attach waiting for peer->lastReach */
367 #define RX_CONN_MAKECALL_ACTIVE 128 /* a thread is actively in rx_NewCall */
368 #define RX_CONN_NAT_PING 256 /* nat ping requested */
370 /* Type of connection, client or server */
371 #define RX_CLIENT_CONNECTION 0
372 #define RX_SERVER_CONNECTION 1
373 #endif /* !KDUMP_RX_LOCK */
375 /* Maximum number of acknowledgements in an acknowledge packet */
376 #define RX_MAXACKS 255
378 #ifndef KDUMP_RX_LOCK
380 /* The structure of the data portion of an acknowledge packet: An acknowledge
381 * packet is in network byte order at all times. An acknowledgement is always
382 * prompted for a specific reason by a specific incoming packet. This reason
383 * is reported in "reason" and the packet's sequence number in the packet
384 * header.seq. In addition to this information, all of the current
385 * acknowledgement information about this call is placed in the packet.
386 * "FirstPacket" is the sequence number of the first packet represented in an
387 * array of bytes, "acks", containing acknowledgement information for a number
388 * of consecutive packets. All packets prior to FirstPacket are implicitly
389 * acknowledged: the sender need no longer be concerned about them. Packets
390 * from firstPacket+nAcks and on are not acknowledged. Packets in the range
391 * [firstPacket,firstPacket+nAcks) are each acknowledged explicitly. The
392 * acknowledgement may be RX_NACK if the packet is not (currently) at the
393 * receiver (it may have never been received, or received and then later
394 * dropped), or it may be RX_ACK if the packet is queued up waiting to be read
395 * by the upper level software. RX_ACK does not imply that the packet may not
396 * be dropped before it is read; it does imply that the sender should stop
397 * retransmitting the packet until notified otherwise. The field
398 * previousPacket identifies the previous packet received by the peer. This
399 * was used in a previous version of this software, and could be used in the
400 * future. The serial number in the data part of the ack packet corresponds to
401 * the serial number oof the packet which prompted the acknowledge. Any
402 * packets which are explicitly not acknowledged, and which were last
403 * transmitted with a serial number less than the provided serial number,
404 * should be retransmitted immediately. Actually, this is slightly inaccurate:
405 * packets are not necessarily received in order. When packets are habitually
406 * transmitted out of order, this is allowed for in the retransmission
407 * algorithm by introducing the notion of maximum packet skew: the degree of
408 * out-of-orderness of the packets received on the wire. This number is
409 * communicated from the receiver to the sender in ack packets. */
411 struct rx_ackPacket
{
412 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. */
413 u_short maxSkew
; /* Maximum difference between serial# of packet acknowledged and highest packet yet received */
414 afs_uint32 firstPacket
; /* The first packet in the list of acknowledged packets */
415 afs_uint32 previousPacket
; /* The previous packet number received (obsolete?) */
416 afs_uint32 serial
; /* Serial number of the packet which prompted the acknowledge */
417 u_char reason
; /* Reason for the acknowledge of ackPacket, defined below */
418 u_char nAcks
; /* Number of acknowledgements */
419 u_char acks
[RX_MAXACKS
]; /* Up to RX_MAXACKS packet acknowledgements, defined below */
420 /* 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) */
423 #define FIRSTACKOFFSET 4
425 /* Reason for acknowledge message */
426 #define RX_ACK_REQUESTED 1 /* Peer requested an ack on this packet */
427 #define RX_ACK_DUPLICATE 2 /* Duplicate packet */
428 #define RX_ACK_OUT_OF_SEQUENCE 3 /* Packet out of sequence */
429 #define RX_ACK_EXCEEDS_WINDOW 4 /* Packet sequence number higher than window; discarded */
430 #define RX_ACK_NOSPACE 5 /* No buffer space at all */
431 #define RX_ACK_PING 6 /* This is a keep-alive ack */
432 #define RX_ACK_PING_RESPONSE 7 /* Ack'ing because we were pinged */
433 #define RX_ACK_DELAY 8 /* Ack generated since nothing has happened since receiving packet */
434 #define RX_ACK_IDLE 9 /* Similar to RX_ACK_DELAY, but can
435 * be used to compute RTT */
436 #define RX_ACK_MTU -1 /* will be rewritten to ACK_PING */
438 /* Packet acknowledgement type */
439 #define RX_ACK_TYPE_NACK 0 /* I Don't have this packet */
440 #define RX_ACK_TYPE_ACK 1 /* I have this packet, although I may discard it later */
442 /* The packet size transmitted for an acknowledge is adjusted to reflect the actual size of the acks array. This macro defines the size */
443 #define rx_AckDataSize(nAcks) (3 + nAcks + offsetof(struct rx_ackPacket, acks[0]))
445 #define RX_CHALLENGE_TIMEOUT 2 /* Number of seconds before another authentication request packet is generated */
446 #define RX_CHALLENGE_MAXTRIES 50 /* Max # of times we resend challenge */
447 #define RX_CHECKREACH_TIMEOUT 2 /* Number of seconds before another ping is generated */
448 #define RX_CHECKREACH_TTL 60 /* Re-check reachability this often */
451 * rx_GetNetworkError 'origin' constants. These define the meaning of the
452 * 'type' and 'code' values returned by rx_GetNetworkError.
455 /* Used for ICMP errors; the type and code are the ICMP type and code,
457 #define RX_NETWORK_ERROR_ORIGIN_ICMP (0)
460 * RX error codes. RX uses error codes from -1 to -64 and -100.
461 * Rxgen uses other error codes < -64 (see src/rxgen/rpc_errors.h);
462 * user programs are expected to return positive error codes
465 /* Something bad happened to the connection; temporary loss of communication */
466 #define RX_CALL_DEAD (-1)
469 * An invalid operation, such as a client attempting to send data
470 * after having received the beginning of a reply from the server.
472 #define RX_INVALID_OPERATION (-2)
474 /* An optional timeout per call may be specified */
475 #define RX_CALL_TIMEOUT (-3)
477 /* End of data on a read. Not currently in use. */
480 /* Some sort of low-level protocol error. */
481 #define RX_PROTOCOL_ERROR (-5)
484 * Generic user abort code; used when no more specific error code needs to be
485 * communicated. For example, multi rx clients use this code to abort a multi-
488 #define RX_USER_ABORT (-6)
490 /* Port already in use (from rx_Init). This error is never sent on the wire. */
491 #define RX_ADDRINUSE (-7)
493 /* EMSGSIZE returned from network. Packet too big, must fragment */
494 #define RX_MSGSIZE (-8)
496 /* The value -9 was previously used for RX_CALL_IDLE but is now free for
499 /* The value -10 was previously used for RX_CALL_BUSY but is now free for
502 /* transient failure detected ( possibly the server is restarting ) */
503 /* this should be equal to VRESTARTING ( util/errors.h ) for old clients to work */
504 #define RX_RESTARTING (-100)
507 RX_SECIDX_NULL
= 0, /** rxnull, no security. */
508 RX_SECIDX_VAB
= 1, /** vice tokens with bcrypt. Unused. */
509 RX_SECIDX_KAD
= 2, /** kerberos/DES. */
510 RX_SECIDX_KAE
= 3, /** rxkad, but always encrypt. */
511 RX_SECIDX_GK
= 4, /** rxgk, RFC 3961 crypto. */
512 RX_SECIDX_K5
= 5, /** kerberos 5 tickets as tokens. */
516 * We use an enum for the symbol definitions but have no need for a typedef
517 * because the enum is at least as wide as 'int' and these have to fit into
518 * a field of type 'char'. Direct assigment will do the right thing if the
519 * enum value fits into that type.
527 struct rx_securityObjectStats
{
528 char type
; /* An RX_SECTYPE_* value */
530 char sparec
[10]; /* force correct alignment */
531 afs_int32 flags
; /* 1=>unalloc, 2=>auth, 4=>expired */
533 afs_uint32 packetsReceived
;
534 afs_uint32 packetsSent
;
535 afs_uint32 bytesReceived
;
536 afs_uint32 bytesSent
;
541 /* Configuration settings */
543 /* Enum for storing configuration variables which can be set via the
544 * SetConfiguration method in the rx_securityClass, below
548 RXS_CONFIG_FLAGS
/* afs_uint32 set of bitwise flags */
549 } rx_securityConfigVariables
;
551 /* For the RXS_CONFIG_FLAGS, the following bit values are defined */
553 /* Disable the principal name contains dot check in rxkad */
554 #define RXS_CONFIG_FLAGS_DISABLE_DOTCHECK 0x01
556 /* XXXX (rewrite this description) A security class object contains a set of
557 * procedures and some private data to implement a security model for rx
558 * connections. These routines are called by rx as appropriate. Rx knows
559 * nothing about the internal details of any particular security model, or
560 * about security state. Rx does maintain state per connection on behalf of
561 * the security class. Each security class implementation is also expected to
562 * provide routines to create these objects. Rx provides a basic routine to
563 * allocate one of these objects; this routine must be called by the class. */
564 struct rx_securityClass
{
565 struct rx_securityOps
{
566 int (*op_Close
) (struct rx_securityClass
* aobj
);
567 int (*op_NewConnection
) (struct rx_securityClass
* aobj
,
568 struct rx_connection
* aconn
);
569 int (*op_PreparePacket
) (struct rx_securityClass
* aobj
,
570 struct rx_call
* acall
,
571 struct rx_packet
* apacket
);
572 int (*op_SendPacket
) (struct rx_securityClass
* aobj
,
573 struct rx_call
* acall
,
574 struct rx_packet
* apacket
);
575 int (*op_CheckAuthentication
) (struct rx_securityClass
* aobj
,
576 struct rx_connection
* aconn
);
577 int (*op_CreateChallenge
) (struct rx_securityClass
* aobj
,
578 struct rx_connection
* aconn
);
579 int (*op_GetChallenge
) (struct rx_securityClass
* aobj
,
580 struct rx_connection
* aconn
,
581 struct rx_packet
* apacket
);
582 int (*op_GetResponse
) (struct rx_securityClass
* aobj
,
583 struct rx_connection
* aconn
,
584 struct rx_packet
* apacket
);
585 int (*op_CheckResponse
) (struct rx_securityClass
* aobj
,
586 struct rx_connection
* aconn
,
587 struct rx_packet
* apacket
);
588 int (*op_CheckPacket
) (struct rx_securityClass
* aobj
,
589 struct rx_call
* acall
,
590 struct rx_packet
* apacket
);
591 int (*op_DestroyConnection
) (struct rx_securityClass
* aobj
,
592 struct rx_connection
* aconn
);
593 int (*op_GetStats
) (struct rx_securityClass
* aobj
,
594 struct rx_connection
* aconn
,
595 struct rx_securityObjectStats
* astats
);
596 int (*op_SetConfiguration
) (struct rx_securityClass
* aobj
,
597 struct rx_connection
* aconn
,
598 rx_securityConfigVariables atype
,
600 void ** acurrentValue
);
601 int (*op_Spare2
) (void);
602 int (*op_Spare3
) (void);
608 #define RXS_OP(obj,op,args) ((obj && (obj->ops->op_ ## op)) ? (*(obj)->ops->op_ ## op)args : 0)
610 #define RXS_Close(obj) RXS_OP(obj,Close,(obj))
611 #define RXS_NewConnection(obj,conn) RXS_OP(obj,NewConnection,(obj,conn))
612 #define RXS_PreparePacket(obj,call,packet) RXS_OP(obj,PreparePacket,(obj,call,packet))
613 #define RXS_SendPacket(obj,call,packet) RXS_OP(obj,SendPacket,(obj,call,packet))
614 #define RXS_CheckAuthentication(obj,conn) RXS_OP(obj,CheckAuthentication,(obj,conn))
615 #define RXS_CreateChallenge(obj,conn) RXS_OP(obj,CreateChallenge,(obj,conn))
616 #define RXS_GetChallenge(obj,conn,packet) RXS_OP(obj,GetChallenge,(obj,conn,packet))
617 #define RXS_GetResponse(obj,conn,packet) RXS_OP(obj,GetResponse,(obj,conn,packet))
618 #define RXS_CheckResponse(obj,conn,packet) RXS_OP(obj,CheckResponse,(obj,conn,packet))
619 #define RXS_CheckPacket(obj,call,packet) RXS_OP(obj,CheckPacket,(obj,call,packet))
620 #define RXS_DestroyConnection(obj,conn) RXS_OP(obj,DestroyConnection,(obj,conn))
621 #define RXS_GetStats(obj,conn,stats) RXS_OP(obj,GetStats,(obj,conn,stats))
622 #define RXS_SetConfiguration(obj, conn, type, value, currentValue) RXS_OP(obj, SetConfiguration,(obj,conn,type,value,currentValue))
626 /* Structure for keeping rx statistics. Note that this structure is returned
627 * by rxdebug, so, for compatibility reasons, new fields should be appended (or
628 * spares used), the rxdebug protocol checked, if necessary, and the PrintStats
629 * code should be updated as well.
631 * Clearly we assume that ntohl will work on these structures so sizeof(int)
632 * must equal sizeof(afs_int32). */
634 struct rx_statistics
{ /* General rx statistics */
635 int packetRequests
; /* Number of packet allocation requests */
636 int receivePktAllocFailures
;
637 int sendPktAllocFailures
;
638 int specialPktAllocFailures
;
639 int socketGreedy
; /* Whether SO_GREEDY succeeded */
640 int bogusPacketOnRead
; /* Number of inappropriately short packets received */
641 int bogusHost
; /* Host address from bogus packets */
642 int noPacketOnRead
; /* Number of read packets attempted when there was actually no packet to read off the wire */
643 int noPacketBuffersOnRead
; /* Number of dropped data packets due to lack of packet buffers */
644 int selects
; /* Number of selects waiting for packet or timeout */
645 int sendSelects
; /* Number of selects forced when sending packet */
646 int packetsRead
[RX_N_PACKET_TYPES
]; /* Total number of packets read, per type */
647 int dataPacketsRead
; /* Number of unique data packets read off the wire */
648 int ackPacketsRead
; /* Number of ack packets read */
649 int dupPacketsRead
; /* Number of duplicate data packets read */
650 int spuriousPacketsRead
; /* Number of inappropriate data packets */
651 int packetsSent
[RX_N_PACKET_TYPES
]; /* Number of rxi_Sends: packets sent over the wire, per type */
652 int ackPacketsSent
; /* Number of acks sent */
653 int pingPacketsSent
; /* Total number of ping packets sent */
654 int abortPacketsSent
; /* Total number of aborts */
655 int busyPacketsSent
; /* Total number of busies sent received */
656 int dataPacketsSent
; /* Number of unique data packets sent */
657 int dataPacketsReSent
; /* Number of retransmissions */
658 int dataPacketsPushed
; /* Number of retransmissions pushed early by a NACK */
659 int ignoreAckedPacket
; /* Number of packets with acked flag, on rxi_Start */
660 struct clock totalRtt
; /* Total round trip time measured (use to compute average) */
661 struct clock minRtt
; /* Minimum round trip time measured */
662 struct clock maxRtt
; /* Maximum round trip time measured */
663 int nRttSamples
; /* Total number of round trip samples */
664 int nServerConns
; /* Total number of server connections */
665 int nClientConns
; /* Total number of client connections */
666 int nPeerStructs
; /* Total number of peer structures */
667 int nCallStructs
; /* Total number of call structures allocated */
668 int nFreeCallStructs
; /* Total number of previously allocated free call structures */
670 afs_int32 fatalErrors
;
671 int ignorePacketDally
; /* packets dropped because call is in dally state */
672 int receiveCbufPktAllocFailures
;
673 int sendCbufPktAllocFailures
;
678 /* structures for debug input and output packets */
680 /* debug input types */
686 /* Invalid rx debug package type */
687 #define RX_DEBUGI_BADTYPE (-8)
689 #define RX_DEBUGI_VERSION_MINIMUM ('L') /* earliest real version */
690 #define RX_DEBUGI_VERSION ('S') /* Latest version */
691 /* first version w/ secStats */
692 #define RX_DEBUGI_VERSION_W_SECSTATS ('L')
693 /* version M is first supporting GETALLCONN and RXSTATS type */
694 #define RX_DEBUGI_VERSION_W_GETALLCONN ('M')
695 #define RX_DEBUGI_VERSION_W_RXSTATS ('M')
696 /* last version with unaligned debugConn */
697 #define RX_DEBUGI_VERSION_W_UNALIGNED_CONN ('L')
698 #define RX_DEBUGI_VERSION_W_WAITERS ('N')
699 #define RX_DEBUGI_VERSION_W_IDLETHREADS ('O')
700 #define RX_DEBUGI_VERSION_W_NEWPACKETTYPES ('P')
701 #define RX_DEBUGI_VERSION_W_GETPEER ('Q')
702 #define RX_DEBUGI_VERSION_W_WAITED ('R')
703 #define RX_DEBUGI_VERSION_W_PACKETS ('S')
705 #define RX_DEBUGI_GETSTATS 1 /* get basic rx stats */
706 #define RX_DEBUGI_GETCONN 2 /* get connection info */
707 #define RX_DEBUGI_GETALLCONN 3 /* get even uninteresting conns */
708 #define RX_DEBUGI_RXSTATS 4 /* get all rx stats */
709 #define RX_DEBUGI_GETPEER 5 /* get all peer structs */
711 struct rx_debugStats
{
712 afs_int32 nFreePackets
;
713 afs_int32 packetReclaims
;
714 afs_int32 callsExecuted
;
715 char waitingForPackets
;
720 afs_int32 idleThreads
; /* Number of server threads that are idle */
726 struct rx_debugConn_vL
{
730 afs_int32 callNumber
[RX_MAXCALLS
];
736 char callState
[RX_MAXCALLS
];
737 char callMode
[RX_MAXCALLS
];
738 char callFlags
[RX_MAXCALLS
];
739 char callOther
[RX_MAXCALLS
];
740 /* old style getconn stops here */
741 struct rx_securityObjectStats secStats
;
742 afs_int32 sparel
[10];
745 struct rx_debugConn
{
749 afs_int32 callNumber
[RX_MAXCALLS
];
755 char sparec
[3]; /* force correct alignment */
756 char callState
[RX_MAXCALLS
];
757 char callMode
[RX_MAXCALLS
];
758 char callFlags
[RX_MAXCALLS
];
759 char callOther
[RX_MAXCALLS
];
760 /* old style getconn stops here */
761 struct rx_securityObjectStats secStats
;
767 struct rx_debugPeer
{
775 struct clock burstWait
;
778 struct clock timeout
;
781 afs_int32 inPacketSkew
;
782 afs_int32 outPacketSkew
;
786 u_short maxDgramPackets
;
787 u_short ifDgramPackets
;
790 u_short nDgramPackets
;
792 afs_hyper_t bytesSent
;
793 afs_hyper_t bytesReceived
;
794 afs_int32 sparel
[10];
797 #define RX_OTHER_IN 1 /* packets avail in in queue */
798 #define RX_OTHER_OUT 2 /* packets avail in out queue */
800 #define RX_SERVER_DEBUG_SEC_STATS 0x1
801 #define RX_SERVER_DEBUG_ALL_CONN 0x2
802 #define RX_SERVER_DEBUG_RX_STATS 0x4
803 #define RX_SERVER_DEBUG_WAITER_CNT 0x8
804 #define RX_SERVER_DEBUG_IDLE_THREADS 0x10
805 #define RX_SERVER_DEBUG_OLD_CONN 0x20
806 #define RX_SERVER_DEBUG_NEW_PACKETS 0x40
807 #define RX_SERVER_DEBUG_ALL_PEER 0x80
808 #define RX_SERVER_DEBUG_WAITED_CNT 0x100
809 #define RX_SERVER_DEBUG_PACKETS_CNT 0x200
811 #define AFS_RX_STATS_CLEAR_ALL 0xffffffff
812 #define AFS_RX_STATS_CLEAR_INVOCATIONS 0x1
813 #define AFS_RX_STATS_CLEAR_BYTES_SENT 0x2
814 #define AFS_RX_STATS_CLEAR_BYTES_RCVD 0x4
815 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM 0x8
816 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE 0x10
817 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN 0x20
818 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX 0x40
819 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SUM 0x80
820 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE 0x100
821 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MIN 0x200
822 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MAX 0x400
824 typedef struct rx_function_entry_v1
{
825 afs_uint32 remote_peer
;
826 afs_uint32 remote_port
;
827 afs_uint32 remote_is_server
;
828 afs_uint32 interfaceId
;
829 afs_uint32 func_total
;
830 afs_uint32 func_index
;
831 afs_uint64 invocations
;
832 afs_uint64 bytes_sent
;
833 afs_uint64 bytes_rcvd
;
834 struct clock queue_time_sum
;
835 struct clock queue_time_sum_sqr
;
836 struct clock queue_time_min
;
837 struct clock queue_time_max
;
838 struct clock execution_time_sum
;
839 struct clock execution_time_sum_sqr
;
840 struct clock execution_time_min
;
841 struct clock execution_time_max
;
842 } rx_function_entry_v1_t
, *rx_function_entry_v1_p
;
845 * If you need to change rx_function_entry, you should probably create a brand
846 * new structure. Keeping the old structure will allow backwards compatibility
847 * with old clients (even if it is only used to calculate allocation size).
848 * If you do change the size or the format, you'll need to bump
849 * RX_STATS_RETRIEVAL_VERSION. This allows some primitive form
850 * of versioning a la rxdebug.
853 #define RX_STATS_RETRIEVAL_VERSION 1 /* latest version */
854 #define RX_STATS_RETRIEVAL_FIRST_EDITION 1 /* first implementation */
856 typedef struct rx_interface_stat
{
857 struct opr_queue entry
;
858 struct opr_queue entryPeers
;
859 rx_function_entry_v1_t stats
[1]; /* make sure this is aligned correctly */
860 } rx_interface_stat_t
, *rx_interface_stat_p
;
862 #define RX_STATS_SERVICE_ID 409
865 extern int rx_DumpCalls(FILE *outputFile
, char *cookie
);
868 #endif /* _RX_ End of rx.h */
871 #include "rx/rx_prototypes.h"
873 #include "rx_prototypes.h"
876 static_inline afs_uint32
877 RPCOpStat_Peer(void *blob
) {
878 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
879 return rpcop_stat
->remote_peer
;
882 static_inline afs_uint32
883 RPCOpStat_Port(void *blob
) {
884 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
885 return rpcop_stat
->remote_port
;
888 static_inline afs_uint32
889 RPCOpStat_IsServer(void *blob
) {
890 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
891 return rpcop_stat
->remote_is_server
;
894 static_inline afs_uint32
895 RPCOpStat_InterfaceId(void *blob
) {
896 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
897 return rpcop_stat
->interfaceId
;
900 static_inline afs_uint32
901 RPCOpStat_NumFuncs(void *blob
) {
902 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
903 return rpcop_stat
->func_total
;
906 static_inline afs_uint32
907 RPCOpStat_CurFunc(void *blob
) {
908 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
909 return rpcop_stat
->func_index
;
912 static_inline
struct clock
*
913 RPCOpStat_QTimeSum(void *blob
) {
914 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
915 return &(rpcop_stat
->queue_time_sum
);
918 static_inline
struct clock
*
919 RPCOpStat_QTimeSumSqr(void *blob
) {
920 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
921 return &(rpcop_stat
->queue_time_sum_sqr
);
924 static_inline
struct clock
*
925 RPCOpStat_QTimeSumMin(void *blob
) {
926 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
927 return &(rpcop_stat
->queue_time_min
);
930 static_inline
struct clock
*
931 RPCOpStat_QTimeSumMax(void *blob
) {
932 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
933 return &(rpcop_stat
->queue_time_max
);
936 static_inline
struct clock
*
937 RPCOpStat_ExecTimeSum(void *blob
) {
938 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
939 return &(rpcop_stat
->execution_time_sum
);
942 static_inline
struct clock
*
943 RPCOpStat_ExecTimeSumSqr(void *blob
) {
944 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
945 return &(rpcop_stat
->execution_time_sum_sqr
);
948 static_inline
struct clock
*
949 RPCOpStat_ExecTimeSumMin(void *blob
) {
950 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
951 return &(rpcop_stat
->execution_time_min
);
954 static_inline
struct clock
*
955 RPCOpStat_ExecTimeSumMax(void *blob
) {
956 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
957 return &(rpcop_stat
->execution_time_max
);
960 static_inline afs_uint64
961 RPCOpStat_NumCalls(void *blob
) {
962 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
963 return rpcop_stat
->invocations
;
966 static_inline afs_uint64
967 RPCOpStat_BytesSent(void *blob
) {
968 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
969 return rpcop_stat
->bytes_sent
;
972 static_inline afs_uint64
973 RPCOpStat_BytesRcvd(void *blob
) {
974 rx_function_entry_v1_p rpcop_stat
= (rx_function_entry_v1_p
)blob
;
975 return rpcop_stat
->bytes_rcvd
;
977 #endif /* !KDUMP_RX_LOCK */