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>
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... */
69 /* Connection management */
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_SetMsgsizeRetryErr(struct rx_connection *conn, int err);
83 extern int rx_IsServerConn(struct rx_connection *conn);
84 extern int rx_IsClientConn(struct rx_connection *conn);
85 extern struct rx_securityClass *rx_SecurityObjectOf(const struct rx_connection *);
86 extern struct rx_peer *rx_PeerOf(struct rx_connection *);
87 extern u_short rx_ServiceIdOf(struct rx_connection *);
88 extern int rx_SecurityClassOf(struct rx_connection *);
89 extern struct rx_service *rx_ServiceOf(struct rx_connection *);
90 extern int rx_ConnError(struct rx_connection *);
93 extern struct rx_connection *rx_ConnectionOf(struct rx_call *call);
94 extern int rx_Error(struct rx_call *call);
95 extern int rx_GetRemoteStatus(struct rx_call *call);
96 extern void rx_SetLocalStatus(struct rx_call *call, int status);
97 extern int rx_GetCallAbortCode(struct rx_call *call);
98 extern void rx_SetCallAbortCode(struct rx_call *call, int code);
100 extern void rx_RecordCallStatistics(struct rx_call *call,
101 unsigned int rxInterface,
102 unsigned int currentFunc,
103 unsigned int totalFunc,
106 /* Peer management */
107 extern afs_uint32 rx_HostOf(struct rx_peer *peer);
108 extern u_short rx_PortOf(struct rx_peer *peer);
112 /* Packet classes, for rx_AllocPacket and rx_packetQuota */
113 #define RX_PACKET_CLASS_RECEIVE 0
114 #define RX_PACKET_CLASS_SEND 1
115 #define RX_PACKET_CLASS_SPECIAL 2
116 #define RX_PACKET_CLASS_RECV_CBUF 3
117 #define RX_PACKET_CLASS_SEND_CBUF 4
119 #define RX_N_PACKET_CLASSES 5 /* Must agree with above list */
121 #define RX_PACKET_TYPES {"data", "ack", "busy", "abort", "ackall", "challenge", "response", "debug", "params", "unused", "unused", "unused", "version"}
122 #define RX_N_PACKET_TYPES 13 /* Must agree with above list;
124 * WARNING: if this number ever
125 * grows past 13, rxdebug packets
126 * will need to be modified */
129 /* For most Unixes, maximum elements in an iovec is 16 */
130 #define RX_MAXIOVECS 16 /* limit for ReadvProc/WritevProc */
131 #define RX_MAXWVECS (RX_MAXIOVECS-1) /* need one iovec for packet header */
135 /* Call flags, states and modes are exposed by the debug interface */
136 #ifndef KDUMP_RX_LOCK
137 /* Major call states */
138 #define RX_STATE_NOTINIT 0 /* Call structure has never been initialized */
139 #define RX_STATE_PRECALL 1 /* Server-only: call is not in progress, but packets have arrived */
140 #define RX_STATE_ACTIVE 2 /* An active call; a process is dealing with this call */
141 #define RX_STATE_DALLY 3 /* Dallying after process is done with call */
142 #define RX_STATE_HOLD 4 /* Waiting for acks on reply data packets */
143 #define RX_STATE_RESET 5 /* Call is being reset */
145 /* Call modes: the modes of a call in RX_STATE_ACTIVE state (process attached) */
146 #define RX_MODE_SENDING 1 /* Sending or ready to send */
147 #define RX_MODE_RECEIVING 2 /* Receiving or ready to receive */
148 #define RX_MODE_ERROR 3 /* Something in error for current conversation */
149 #define RX_MODE_EOF 4 /* Server has flushed (or client has read) last reply packet */
152 #define RX_CALL_READER_WAIT 1 /* Reader is waiting for next packet */
153 #define RX_CALL_WAIT_WINDOW_ALLOC 2 /* Sender is waiting for window to allocate buffers */
154 #define RX_CALL_WAIT_WINDOW_SEND 4 /* Sender is waiting for window to send buffers */
155 #define RX_CALL_WAIT_PACKETS 8 /* Sender is waiting for packet buffers */
156 #define RX_CALL_WAIT_PROC 16 /* Waiting for a process to be assigned */
157 #define RX_CALL_RECEIVE_DONE 32 /* All packets received on this call */
158 #define RX_CALL_CLEARED 64 /* Receive queue cleared in precall state */
159 #define RX_CALL_TQ_BUSY 128 /* Call's Xmit Queue is busy; don't modify */
160 #define RX_CALL_TQ_CLEARME 256 /* Need to clear this call's TQ later */
161 #define RX_CALL_TQ_SOME_ACKED 512 /* rxi_Start needs to discard ack'd packets. */
162 #define RX_CALL_TQ_WAIT 1024 /* Reader is waiting for TQ_BUSY to be reset */
163 #define RX_CALL_FAST_RECOVER 2048 /* call is doing congestion recovery */
164 /* 4096 was RX_CALL_FAST_RECOVER_WAIT */
165 #define RX_CALL_SLOW_START_OK 8192 /* receiver acks every other packet */
166 #define RX_CALL_IOVEC_WAIT 16384 /* waiting thread is using an iovec */
167 #define RX_CALL_HAVE_LAST 32768 /* Last packet has been received */
168 #define RX_CALL_NEED_START 0x10000 /* tells rxi_Start to start again */
169 #define RX_CALL_PEER_BUSY 0x20000 /* the last packet we received on this call was a
170 * BUSY packet; i.e. the channel for this call is busy */
171 #define RX_CALL_ACKALL_SENT 0x40000 /* ACKALL has been sent on the call */
176 /* Configurable parameters */
177 #define RX_IDLE_DEAD_TIME 60 /* default idle dead time */
178 #define RX_MAX_SERVICES 20 /* Maximum number of services that may be installed */
179 #if defined(KERNEL) && defined(AFS_AIX51_ENV) && defined(__64__)
180 #define RX_DEFAULT_STACK_SIZE 24000
182 #define RX_DEFAULT_STACK_SIZE 16000 /* Default process stack size; overriden by rx_SetStackSize */
185 /* This parameter should not normally be changed */
186 #define RX_PROCESS_PRIORITY LWP_NORMAL_PRIORITY
188 #define ADDRSPERSITE 16
190 #ifndef KDUMP_RX_LOCK
191 /* Bottom n-bits of the Call Identifier give the call number */
192 #define RX_MAXCALLS 4 /* Power of 2; max async calls per connection */
193 #define RX_CIDSHIFT 2 /* Log2(RX_MAXCALLS) */
194 #define RX_CHANNELMASK (RX_MAXCALLS-1)
195 #define RX_CIDMASK (~RX_CHANNELMASK)
196 #endif /* !KDUMP_RX_LOCK */
199 typedef void (*rx_destructor_t) (void *);
200 int rx_KeyCreate(rx_destructor_t);
201 osi_socket rxi_GetHostUDPSocket(u_int host, u_short port);
202 osi_socket rxi_GetUDPSocket(u_short port);
206 int ntoh_syserr_conv(int error);
209 #define RX_DONTWAIT 0
211 #define rx_GetLocalStatus(call, status) ((call)->localStatus)
215 rx_IsLoopbackAddr(afs_uint32 addr)
217 return ((addr & 0xffff0000) == 0x7f000000);
221 * Macros callable by the user to further define attributes of a
222 * service. Must be called before rx_StartServer
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)
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))
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))
239 /* Define a procedure to be called just before a server connection is destroyed */
240 #define rx_SetDestroyConnProc(service,proc) ((service)->destroyConnProc = (proc))
242 /* Define procedure to set service dead time */
243 #define rx_SetIdleDeadTime(service,time) ((service)->idleDeadTime = (time))
246 * Define error to return in server connections when failing to answer.
247 * (server only) For example, AFS viced sends VNOSERVICE.
249 #define rx_SetServerIdleDeadErr(service,err) ((service)->idleDeadErr = (err))
251 /* Define procedures for getting and setting before and after execute-request procs */
252 #define rx_SetAfterProc(service,proc) ((service)->afterProc = (proc))
253 #define rx_SetBeforeProc(service,proc) ((service)->beforeProc = (proc))
254 #define rx_GetAfterProc(service) ((service)->afterProc)
255 #define rx_GetBeforeProc(service) ((service)->beforeProc)
256 #define rx_SetPostProc(service,proc) ((service)->postProc = (proc))
257 #define rx_GetPostProc(service) ((service)->postProc)
259 /* Define a procedure to be called when a server connection is created */
260 #define rx_SetNewConnProc(service, proc) ((service)->newConnProc = (proc))
262 /* NOTE: We'll probably redefine the following three routines, again, sometime. */
264 /* Set the connection dead time for any connections created for this service (server only) */
265 #define rx_SetServiceDeadTime(service, seconds) ((service)->secondsUntilDead = (seconds))
267 /* Enable or disable asymmetric client checking for a service */
268 #define rx_SetCheckReach(service, x) ((service)->checkReach = (x))
270 /* Set the overload threshold and the overload error */
271 #define rx_SetBusyThreshold(threshold, code) (rx_BusyThreshold=(threshold),rx_BusyError=(code))
273 /* If this flag is set,no new requests are processed by rx, all new requests are
274 returned with an error code of RX_CALL_DEAD ( transient error ) */
275 #define rx_SetRxTranquil() (rx_tranquil = 1)
276 #define rx_ClearRxTranquil() (rx_tranquil = 0)
278 /* Set the threshold and time to delay aborts for consecutive errors */
279 #define rx_SetCallAbortThreshold(A) (rxi_callAbortThreshhold = (A))
280 #define rx_SetCallAbortDelay(A) (rxi_callAbortDelay = (A))
281 #define rx_SetConnAbortThreshold(A) (rxi_connAbortThreshhold = (A))
282 #define rx_SetConnAbortDelay(A) (rxi_connAbortDelay = (A))
286 #define cpspace(call) ((call)->curlen)
287 #define cppos(call) ((call)->curpos)
289 #define rx_Read(call, buf, nbytes) rx_ReadProc(call, buf, nbytes)
290 #define rx_Read32(call, value) rx_ReadProc32(call, value)
291 #define rx_Readv(call, iov, nio, maxio, nbytes) \
292 rx_ReadvProc(call, iov, nio, maxio, nbytes)
293 #define rx_Write(call, buf, nbytes) rx_WriteProc(call, buf, nbytes)
294 #define rx_Write32(call, value) rx_WriteProc32(call, value)
295 #define rx_Writev(call, iov, nio, nbytes) \
296 rx_WritevProc(call, iov, nio, nbytes)
298 /* This is the maximum size data packet that can be sent on this connection, accounting for security module-specific overheads. */
299 #define rx_MaxUserDataSize(call) ((call)->MTU - RX_HEADER_SIZE - (call)->conn->securityHeaderSize - (call)->conn->securityMaxTrailerSize)
301 /* Macros to turn the hot thread feature on and off. Enabling hot threads
302 * allows the listener thread to trade places with an idle worker thread,
303 * which moves the context switch from listener to worker out of the
306 #define rx_EnableHotThread() (rx_enable_hot_thread = 1)
307 #define rx_DisableHotThread() (rx_enable_hot_thread = 0)
309 #define rx_PutConnection(conn) rx_DestroyConnection(conn)
311 /* A service is installed by rx_NewService, and specifies a service type that
312 * is exported by this process. Incoming calls are stamped with the service
313 * type, and must match an installed service for the call to be accepted.
314 * Each service exported has a (port,serviceId) pair to uniquely identify it.
315 * It is also named: this is intended to allow a remote statistics gathering
316 * program to retrieve per service statistics without having to know the local
317 * service id's. Each service has a number of
320 /* security objects (instances of security classes) which implement
321 * various types of end-to-end security protocols for connections made
322 * to this service. Finally, there are two parameters controlling the
323 * number of requests which may be executed in parallel by this
324 * service: minProcs is the number of requests to this service which
325 * are guaranteed to be able to run in parallel at any time; maxProcs
326 * has two meanings: it limits the total number of requests which may
327 * execute in parallel and it also guarantees that that many requests
328 * may be handled in parallel if no other service is handling any
332 u_short serviceId; /* Service number */
333 afs_uint32 serviceHost; /* IP address for this service */
334 u_short servicePort; /* UDP port for this service */
335 char *serviceName; /* Name of the service */
336 osi_socket socket; /* socket structure or file descriptor */
337 u_short nRequestsRunning; /* Number of requests currently in progress */
338 u_short nSecurityObjects; /* Number of entries in security objects array */
339 struct rx_securityClass **securityObjects; /* Array of security class objects */
340 afs_int32(*executeRequestProc) (struct rx_call * acall); /* Routine to call when an rpc request is received */
341 void (*destroyConnProc) (struct rx_connection * tcon); /* Routine to call when a server connection is destroyed */
342 void (*newConnProc) (struct rx_connection * tcon); /* Routine to call when a server connection is created */
343 void (*beforeProc) (struct rx_call * acall); /* routine to call before a call is executed */
344 void (*afterProc) (struct rx_call * acall, afs_int32 code); /* routine to call after a call is executed */
345 void (*postProc) (afs_int32 code); /* routine to call after the call has ended */
346 u_short maxProcs; /* Maximum procs to be used for this service */
347 u_short minProcs; /* Minimum # of requests guaranteed executable simultaneously */
348 u_short connDeadTime; /* Seconds until a client of this service will be declared dead, if it is not responding */
349 u_short idleDeadTime; /* Time a server will wait for I/O to start up again */
350 u_char checkReach; /* Check for asymmetric clients? */
351 afs_int32 idleDeadErr;
352 int nSpecific; /* number entries in specific data */
353 void **specific; /* pointer to connection specific data */
354 #ifdef RX_ENABLE_LOCKS
355 afs_kmutex_t svc_data_lock; /* protect specific data */
360 #endif /* KDUMP_RX_LOCK */
362 /* A server puts itself on an idle queue for a service using an
363 * instance of the following structure. When a call arrives, the call
364 * structure pointer is placed in "newcall", the routine to execute to
365 * service the request is placed in executeRequestProc, and the
366 * process is woken up. The queue entry's address is used for the
367 * sleep/wakeup. If socketp is non-null, then this thread is willing
368 * to become a listener thread. A thread sets *socketp to -1 before
369 * sleeping. If *socketp is not -1 when the thread awakes, it is now
370 * the listener thread for *socketp. When socketp is non-null, tno
371 * contains the server's threadID, which is used to make decitions in GetCall.
374 struct rx_serverQueueEntry_rx_lock {
376 struct rx_serverQueueEntry {
378 struct rx_queue queueItemHeader;
380 struct rx_call_rx_lock *newcall;
382 struct rx_call *newcall;
384 #ifdef RX_ENABLE_LOCKS
392 #ifndef KDUMP_RX_LOCK
393 /* Flag bits for connection structure */
394 #define RX_CONN_MAKECALL_WAITING 1 /* rx_NewCall is waiting for a channel */
395 #define RX_CONN_DESTROY_ME 2 /* Destroy *client* connection after last call */
396 #define RX_CONN_USING_PACKET_CKSUM 4 /* non-zero header.spare field seen */
397 #define RX_CONN_KNOW_WINDOW 8 /* window size negotiation works */
398 #define RX_CONN_RESET 16 /* connection is reset, remove */
399 #define RX_CONN_BUSY 32 /* connection is busy; don't delete */
400 #define RX_CONN_ATTACHWAIT 64 /* attach waiting for peer->lastReach */
401 #define RX_CONN_MAKECALL_ACTIVE 128 /* a thread is actively in rx_NewCall */
402 #define RX_CONN_NAT_PING 256 /* nat ping requested */
404 /* Type of connection, client or server */
405 #define RX_CLIENT_CONNECTION 0
406 #define RX_SERVER_CONNECTION 1
407 #endif /* !KDUMP_RX_LOCK */
409 /* Maximum number of acknowledgements in an acknowledge packet */
410 #define RX_MAXACKS 255
412 #ifndef KDUMP_RX_LOCK
414 /* The structure of the data portion of an acknowledge packet: An acknowledge
415 * packet is in network byte order at all times. An acknowledgement is always
416 * prompted for a specific reason by a specific incoming packet. This reason
417 * is reported in "reason" and the packet's sequence number in the packet
418 * header.seq. In addition to this information, all of the current
419 * acknowledgement information about this call is placed in the packet.
420 * "FirstPacket" is the sequence number of the first packet represented in an
421 * array of bytes, "acks", containing acknowledgement information for a number
422 * of consecutive packets. All packets prior to FirstPacket are implicitly
423 * acknowledged: the sender need no longer be concerned about them. Packets
424 * from firstPacket+nAcks and on are not acknowledged. Packets in the range
425 * [firstPacket,firstPacket+nAcks) are each acknowledged explicitly. The
426 * acknowledgement may be RX_NACK if the packet is not (currently) at the
427 * receiver (it may have never been received, or received and then later
428 * dropped), or it may be RX_ACK if the packet is queued up waiting to be read
429 * by the upper level software. RX_ACK does not imply that the packet may not
430 * be dropped before it is read; it does imply that the sender should stop
431 * retransmitting the packet until notified otherwise. The field
432 * previousPacket identifies the previous packet received by the peer. This
433 * was used in a previous version of this software, and could be used in the
434 * future. The serial number in the data part of the ack packet corresponds to
435 * the serial number oof the packet which prompted the acknowledge. Any
436 * packets which are explicitly not acknowledged, and which were last
437 * transmitted with a serial number less than the provided serial number,
438 * should be retransmitted immediately. Actually, this is slightly inaccurate:
439 * packets are not necessarily received in order. When packets are habitually
440 * transmitted out of order, this is allowed for in the retransmission
441 * algorithm by introducing the notion of maximum packet skew: the degree of
442 * out-of-orderness of the packets received on the wire. This number is
443 * communicated from the receiver to the sender in ack packets. */
445 struct rx_ackPacket {
446 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. */
447 u_short maxSkew; /* Maximum difference between serial# of packet acknowledged and highest packet yet received */
448 afs_uint32 firstPacket; /* The first packet in the list of acknowledged packets */
449 afs_uint32 previousPacket; /* The previous packet number received (obsolete?) */
450 afs_uint32 serial; /* Serial number of the packet which prompted the acknowledge */
451 u_char reason; /* Reason for the acknowledge of ackPacket, defined below */
452 u_char nAcks; /* Number of acknowledgements */
453 u_char acks[RX_MAXACKS]; /* Up to RX_MAXACKS packet acknowledgements, defined below */
454 /* 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) */
457 #define FIRSTACKOFFSET 4
459 /* Reason for acknowledge message */
460 #define RX_ACK_REQUESTED 1 /* Peer requested an ack on this packet */
461 #define RX_ACK_DUPLICATE 2 /* Duplicate packet */
462 #define RX_ACK_OUT_OF_SEQUENCE 3 /* Packet out of sequence */
463 #define RX_ACK_EXCEEDS_WINDOW 4 /* Packet sequence number higher than window; discarded */
464 #define RX_ACK_NOSPACE 5 /* No buffer space at all */
465 #define RX_ACK_PING 6 /* This is a keep-alive ack */
466 #define RX_ACK_PING_RESPONSE 7 /* Ack'ing because we were pinged */
467 #define RX_ACK_DELAY 8 /* Ack generated since nothing has happened since receiving packet */
468 #define RX_ACK_IDLE 9 /* Similar to RX_ACK_DELAY, but can
469 * be used to compute RTT */
470 #define RX_ACK_MTU -1 /* will be rewritten to ACK_PING */
472 /* Packet acknowledgement type */
473 #define RX_ACK_TYPE_NACK 0 /* I Don't have this packet */
474 #define RX_ACK_TYPE_ACK 1 /* I have this packet, although I may discard it later */
476 /* The packet size transmitted for an acknowledge is adjusted to reflect the actual size of the acks array. This macro defines the size */
477 #define rx_AckDataSize(nAcks) (3 + nAcks + offsetof(struct rx_ackPacket, acks[0]))
479 #define RX_CHALLENGE_TIMEOUT 2 /* Number of seconds before another authentication request packet is generated */
480 #define RX_CHALLENGE_MAXTRIES 50 /* Max # of times we resend challenge */
481 #define RX_CHECKREACH_TIMEOUT 2 /* Number of seconds before another ping is generated */
482 #define RX_CHECKREACH_TTL 60 /* Re-check reachability this often */
485 * RX error codes. RX uses error codes from -1 to -64 and -100.
486 * Rxgen uses other error codes < -64 (see src/rxgen/rpc_errors.h);
487 * user programs are expected to return positive error codes
490 /* Something bad happened to the connection; temporary loss of communication */
491 #define RX_CALL_DEAD (-1)
494 * An invalid operation, such as a client attempting to send data
495 * after having received the beginning of a reply from the server.
497 #define RX_INVALID_OPERATION (-2)
499 /* An optional timeout per call may be specified */
500 #define RX_CALL_TIMEOUT (-3)
502 /* End of data on a read. Not currently in use. */
505 /* Some sort of low-level protocol error. */
506 #define RX_PROTOCOL_ERROR (-5)
509 * Generic user abort code; used when no more specific error code needs to be
510 * communicated. For example, multi rx clients use this code to abort a multi-
513 #define RX_USER_ABORT (-6)
515 /* Port already in use (from rx_Init). This error is never sent on the wire. */
516 #define RX_ADDRINUSE (-7)
518 /* EMSGSIZE returned from network. Packet too big, must fragment */
519 #define RX_MSGSIZE (-8)
522 * Idle dead timeout error. This error is never sent on the wire.
523 * rxi_SendCallAbort() translates RX_CALL_IDLE to RX_CALL_TIMEOUT.
525 #define RX_CALL_IDLE (-9)
528 * Busy call channel error. This error is never sent on the wire.
529 * rxi_SendCallAbort() translates RX_CALL_BUSY to RX_CALL_TIMEOUT.
531 #define RX_CALL_BUSY (-10)
533 /* transient failure detected ( possibly the server is restarting ) */
534 /* this should be equal to VRESTARTING ( util/errors.h ) for old clients to work */
535 #define RX_RESTARTING (-100)
544 struct rx_securityObjectStats {
545 char type; /* 0:unk 1:null,2:vab 3:kad */
547 char sparec[10]; /* force correct alignment */
548 afs_int32 flags; /* 1=>unalloc, 2=>auth, 4=>expired */
550 afs_uint32 packetsReceived;
551 afs_uint32 packetsSent;
552 afs_uint32 bytesReceived;
553 afs_uint32 bytesSent;
558 /* Configuration settings */
560 /* Enum for storing configuration variables which can be set via the
561 * SetConfiguration method in the rx_securityClass, below
565 RXS_CONFIG_FLAGS /* afs_uint32 set of bitwise flags */
566 } rx_securityConfigVariables;
568 /* For the RXS_CONFIG_FLAGS, the following bit values are defined */
570 /* Disable the principal name contains dot check in rxkad */
571 #define RXS_CONFIG_FLAGS_DISABLE_DOTCHECK 0x01
573 /* XXXX (rewrite this description) A security class object contains a set of
574 * procedures and some private data to implement a security model for rx
575 * connections. These routines are called by rx as appropriate. Rx knows
576 * nothing about the internal details of any particular security model, or
577 * about security state. Rx does maintain state per connection on behalf of
578 * the security class. Each security class implementation is also expected to
579 * provide routines to create these objects. Rx provides a basic routine to
580 * allocate one of these objects; this routine must be called by the class. */
581 struct rx_securityClass {
582 struct rx_securityOps {
583 int (*op_Close) (struct rx_securityClass * aobj);
584 int (*op_NewConnection) (struct rx_securityClass * aobj,
585 struct rx_connection * aconn);
586 int (*op_PreparePacket) (struct rx_securityClass * aobj,
587 struct rx_call * acall,
588 struct rx_packet * apacket);
589 int (*op_SendPacket) (struct rx_securityClass * aobj,
590 struct rx_call * acall,
591 struct rx_packet * apacket);
592 int (*op_CheckAuthentication) (struct rx_securityClass * aobj,
593 struct rx_connection * aconn);
594 int (*op_CreateChallenge) (struct rx_securityClass * aobj,
595 struct rx_connection * aconn);
596 int (*op_GetChallenge) (struct rx_securityClass * aobj,
597 struct rx_connection * aconn,
598 struct rx_packet * apacket);
599 int (*op_GetResponse) (struct rx_securityClass * aobj,
600 struct rx_connection * aconn,
601 struct rx_packet * apacket);
602 int (*op_CheckResponse) (struct rx_securityClass * aobj,
603 struct rx_connection * aconn,
604 struct rx_packet * apacket);
605 int (*op_CheckPacket) (struct rx_securityClass * aobj,
606 struct rx_call * acall,
607 struct rx_packet * apacket);
608 int (*op_DestroyConnection) (struct rx_securityClass * aobj,
609 struct rx_connection * aconn);
610 int (*op_GetStats) (struct rx_securityClass * aobj,
611 struct rx_connection * aconn,
612 struct rx_securityObjectStats * astats);
613 int (*op_SetConfiguration) (struct rx_securityClass * aobj,
614 struct rx_connection * aconn,
615 rx_securityConfigVariables atype,
617 void ** acurrentValue);
618 int (*op_Spare2) (void);
619 int (*op_Spare3) (void);
625 #define RXS_OP(obj,op,args) ((obj && (obj->ops->op_ ## op)) ? (*(obj)->ops->op_ ## op)args : 0)
627 #define RXS_Close(obj) RXS_OP(obj,Close,(obj))
628 #define RXS_NewConnection(obj,conn) RXS_OP(obj,NewConnection,(obj,conn))
629 #define RXS_PreparePacket(obj,call,packet) RXS_OP(obj,PreparePacket,(obj,call,packet))
630 #define RXS_SendPacket(obj,call,packet) RXS_OP(obj,SendPacket,(obj,call,packet))
631 #define RXS_CheckAuthentication(obj,conn) RXS_OP(obj,CheckAuthentication,(obj,conn))
632 #define RXS_CreateChallenge(obj,conn) RXS_OP(obj,CreateChallenge,(obj,conn))
633 #define RXS_GetChallenge(obj,conn,packet) RXS_OP(obj,GetChallenge,(obj,conn,packet))
634 #define RXS_GetResponse(obj,conn,packet) RXS_OP(obj,GetResponse,(obj,conn,packet))
635 #define RXS_CheckResponse(obj,conn,packet) RXS_OP(obj,CheckResponse,(obj,conn,packet))
636 #define RXS_CheckPacket(obj,call,packet) RXS_OP(obj,CheckPacket,(obj,call,packet))
637 #define RXS_DestroyConnection(obj,conn) RXS_OP(obj,DestroyConnection,(obj,conn))
638 #define RXS_GetStats(obj,conn,stats) RXS_OP(obj,GetStats,(obj,conn,stats))
639 #define RXS_SetConfiguration(obj, conn, type, value, currentValue) RXS_OP(obj, SetConfiguration,(obj,conn,type,value,currentValue))
643 /* Structure for keeping rx statistics. Note that this structure is returned
644 * by rxdebug, so, for compatibility reasons, new fields should be appended (or
645 * spares used), the rxdebug protocol checked, if necessary, and the PrintStats
646 * code should be updated as well.
648 * Clearly we assume that ntohl will work on these structures so sizeof(int)
649 * must equal sizeof(afs_int32). */
651 struct rx_statistics { /* General rx statistics */
652 int packetRequests; /* Number of packet allocation requests */
653 int receivePktAllocFailures;
654 int sendPktAllocFailures;
655 int specialPktAllocFailures;
656 int socketGreedy; /* Whether SO_GREEDY succeeded */
657 int bogusPacketOnRead; /* Number of inappropriately short packets received */
658 int bogusHost; /* Host address from bogus packets */
659 int noPacketOnRead; /* Number of read packets attempted when there was actually no packet to read off the wire */
660 int noPacketBuffersOnRead; /* Number of dropped data packets due to lack of packet buffers */
661 int selects; /* Number of selects waiting for packet or timeout */
662 int sendSelects; /* Number of selects forced when sending packet */
663 int packetsRead[RX_N_PACKET_TYPES]; /* Total number of packets read, per type */
664 int dataPacketsRead; /* Number of unique data packets read off the wire */
665 int ackPacketsRead; /* Number of ack packets read */
666 int dupPacketsRead; /* Number of duplicate data packets read */
667 int spuriousPacketsRead; /* Number of inappropriate data packets */
668 int packetsSent[RX_N_PACKET_TYPES]; /* Number of rxi_Sends: packets sent over the wire, per type */
669 int ackPacketsSent; /* Number of acks sent */
670 int pingPacketsSent; /* Total number of ping packets sent */
671 int abortPacketsSent; /* Total number of aborts */
672 int busyPacketsSent; /* Total number of busies sent received */
673 int dataPacketsSent; /* Number of unique data packets sent */
674 int dataPacketsReSent; /* Number of retransmissions */
675 int dataPacketsPushed; /* Number of retransmissions pushed early by a NACK */
676 int ignoreAckedPacket; /* Number of packets with acked flag, on rxi_Start */
677 struct clock totalRtt; /* Total round trip time measured (use to compute average) */
678 struct clock minRtt; /* Minimum round trip time measured */
679 struct clock maxRtt; /* Maximum round trip time measured */
680 int nRttSamples; /* Total number of round trip samples */
681 int nServerConns; /* Total number of server connections */
682 int nClientConns; /* Total number of client connections */
683 int nPeerStructs; /* Total number of peer structures */
684 int nCallStructs; /* Total number of call structures allocated */
685 int nFreeCallStructs; /* Total number of previously allocated free call structures */
687 afs_int32 fatalErrors;
688 int ignorePacketDally; /* packets dropped because call is in dally state */
689 int receiveCbufPktAllocFailures;
690 int sendCbufPktAllocFailures;
695 /* structures for debug input and output packets */
697 /* debug input types */
703 /* Invalid rx debug package type */
704 #define RX_DEBUGI_BADTYPE (-8)
706 #define RX_DEBUGI_VERSION_MINIMUM ('L') /* earliest real version */
707 #define RX_DEBUGI_VERSION ('S') /* Latest version */
708 /* first version w/ secStats */
709 #define RX_DEBUGI_VERSION_W_SECSTATS ('L')
710 /* version M is first supporting GETALLCONN and RXSTATS type */
711 #define RX_DEBUGI_VERSION_W_GETALLCONN ('M')
712 #define RX_DEBUGI_VERSION_W_RXSTATS ('M')
713 /* last version with unaligned debugConn */
714 #define RX_DEBUGI_VERSION_W_UNALIGNED_CONN ('L')
715 #define RX_DEBUGI_VERSION_W_WAITERS ('N')
716 #define RX_DEBUGI_VERSION_W_IDLETHREADS ('O')
717 #define RX_DEBUGI_VERSION_W_NEWPACKETTYPES ('P')
718 #define RX_DEBUGI_VERSION_W_GETPEER ('Q')
719 #define RX_DEBUGI_VERSION_W_WAITED ('R')
720 #define RX_DEBUGI_VERSION_W_PACKETS ('S')
722 #define RX_DEBUGI_GETSTATS 1 /* get basic rx stats */
723 #define RX_DEBUGI_GETCONN 2 /* get connection info */
724 #define RX_DEBUGI_GETALLCONN 3 /* get even uninteresting conns */
725 #define RX_DEBUGI_RXSTATS 4 /* get all rx stats */
726 #define RX_DEBUGI_GETPEER 5 /* get all peer structs */
728 struct rx_debugStats {
729 afs_int32 nFreePackets;
730 afs_int32 packetReclaims;
731 afs_int32 callsExecuted;
732 char waitingForPackets;
737 afs_int32 idleThreads; /* Number of server threads that are idle */
743 struct rx_debugConn_vL {
747 afs_int32 callNumber[RX_MAXCALLS];
753 char callState[RX_MAXCALLS];
754 char callMode[RX_MAXCALLS];
755 char callFlags[RX_MAXCALLS];
756 char callOther[RX_MAXCALLS];
757 /* old style getconn stops here */
758 struct rx_securityObjectStats secStats;
759 afs_int32 sparel[10];
762 struct rx_debugConn {
766 afs_int32 callNumber[RX_MAXCALLS];
772 char sparec[3]; /* force correct alignment */
773 char callState[RX_MAXCALLS];
774 char callMode[RX_MAXCALLS];
775 char callFlags[RX_MAXCALLS];
776 char callOther[RX_MAXCALLS];
777 /* old style getconn stops here */
778 struct rx_securityObjectStats secStats;
784 struct rx_debugPeer {
792 struct clock burstWait;
795 struct clock timeout;
798 afs_int32 inPacketSkew;
799 afs_int32 outPacketSkew;
803 u_short maxDgramPackets;
804 u_short ifDgramPackets;
807 u_short nDgramPackets;
809 afs_hyper_t bytesSent;
810 afs_hyper_t bytesReceived;
811 afs_int32 sparel[10];
814 #define RX_OTHER_IN 1 /* packets avail in in queue */
815 #define RX_OTHER_OUT 2 /* packets avail in out queue */
817 #define RX_SERVER_DEBUG_SEC_STATS 0x1
818 #define RX_SERVER_DEBUG_ALL_CONN 0x2
819 #define RX_SERVER_DEBUG_RX_STATS 0x4
820 #define RX_SERVER_DEBUG_WAITER_CNT 0x8
821 #define RX_SERVER_DEBUG_IDLE_THREADS 0x10
822 #define RX_SERVER_DEBUG_OLD_CONN 0x20
823 #define RX_SERVER_DEBUG_NEW_PACKETS 0x40
824 #define RX_SERVER_DEBUG_ALL_PEER 0x80
825 #define RX_SERVER_DEBUG_WAITED_CNT 0x100
826 #define RX_SERVER_DEBUG_PACKETS_CNT 0x200
828 #define AFS_RX_STATS_CLEAR_ALL 0xffffffff
829 #define AFS_RX_STATS_CLEAR_INVOCATIONS 0x1
830 #define AFS_RX_STATS_CLEAR_BYTES_SENT 0x2
831 #define AFS_RX_STATS_CLEAR_BYTES_RCVD 0x4
832 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SUM 0x8
833 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_SQUARE 0x10
834 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MIN 0x20
835 #define AFS_RX_STATS_CLEAR_QUEUE_TIME_MAX 0x40
836 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SUM 0x80
837 #define AFS_RX_STATS_CLEAR_EXEC_TIME_SQUARE 0x100
838 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MIN 0x200
839 #define AFS_RX_STATS_CLEAR_EXEC_TIME_MAX 0x400
841 typedef struct rx_function_entry_v1 {
842 afs_uint32 remote_peer;
843 afs_uint32 remote_port;
844 afs_uint32 remote_is_server;
845 afs_uint32 interfaceId;
846 afs_uint32 func_total;
847 afs_uint32 func_index;
848 afs_uint64 invocations;
849 afs_uint64 bytes_sent;
850 afs_uint64 bytes_rcvd;
851 struct clock queue_time_sum;
852 struct clock queue_time_sum_sqr;
853 struct clock queue_time_min;
854 struct clock queue_time_max;
855 struct clock execution_time_sum;
856 struct clock execution_time_sum_sqr;
857 struct clock execution_time_min;
858 struct clock execution_time_max;
859 } rx_function_entry_v1_t, *rx_function_entry_v1_p;
862 * If you need to change rx_function_entry, you should probably create a brand
863 * new structure. Keeping the old structure will allow backwards compatibility
864 * with old clients (even if it is only used to calculate allocation size).
865 * If you do change the size or the format, you'll need to bump
866 * RX_STATS_RETRIEVAL_VERSION. This allows some primitive form
867 * of versioning a la rxdebug.
870 #define RX_STATS_RETRIEVAL_VERSION 1 /* latest version */
871 #define RX_STATS_RETRIEVAL_FIRST_EDITION 1 /* first implementation */
873 typedef struct rx_interface_stat {
874 struct rx_queue queue_header;
875 struct rx_queue all_peers;
876 rx_function_entry_v1_t stats[1]; /* make sure this is aligned correctly */
877 } rx_interface_stat_t, *rx_interface_stat_p;
879 #define RX_STATS_SERVICE_ID 409
882 extern int rx_DumpCalls(FILE *outputFile, char *cookie);
885 #endif /* _RX_ End of rx.h */
888 #include "rx/rx_prototypes.h"
890 #include "rx_prototypes.h"
893 static_inline afs_uint32
894 RPCOpStat_Peer(void *blob) {
895 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
896 return rpcop_stat->remote_peer;
899 static_inline afs_uint32
900 RPCOpStat_Port(void *blob) {
901 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
902 return rpcop_stat->remote_port;
905 static_inline afs_uint32
906 RPCOpStat_IsServer(void *blob) {
907 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
908 return rpcop_stat->remote_is_server;
911 static_inline afs_uint32
912 RPCOpStat_InterfaceId(void *blob) {
913 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
914 return rpcop_stat->interfaceId;
917 static_inline afs_uint32
918 RPCOpStat_NumFuncs(void *blob) {
919 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
920 return rpcop_stat->func_total;
923 static_inline afs_uint32
924 RPCOpStat_CurFunc(void *blob) {
925 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
926 return rpcop_stat->func_index;
929 static_inline struct clock *
930 RPCOpStat_QTimeSum(void *blob) {
931 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
932 return &(rpcop_stat->queue_time_sum);
935 static_inline struct clock *
936 RPCOpStat_QTimeSumSqr(void *blob) {
937 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
938 return &(rpcop_stat->queue_time_sum_sqr);
941 static_inline struct clock *
942 RPCOpStat_QTimeSumMin(void *blob) {
943 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
944 return &(rpcop_stat->queue_time_min);
947 static_inline struct clock *
948 RPCOpStat_QTimeSumMax(void *blob) {
949 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
950 return &(rpcop_stat->queue_time_max);
953 static_inline struct clock *
954 RPCOpStat_ExecTimeSum(void *blob) {
955 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
956 return &(rpcop_stat->execution_time_sum);
959 static_inline struct clock *
960 RPCOpStat_ExecTimeSumSqr(void *blob) {
961 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
962 return &(rpcop_stat->execution_time_sum_sqr);
965 static_inline struct clock *
966 RPCOpStat_ExecTimeSumMin(void *blob) {
967 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
968 return &(rpcop_stat->execution_time_min);
971 static_inline struct clock *
972 RPCOpStat_ExecTimeSumMax(void *blob) {
973 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
974 return &(rpcop_stat->execution_time_max);
977 static_inline afs_uint64
978 RPCOpStat_NumCalls(void *blob) {
979 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
980 return rpcop_stat->invocations;
983 static_inline afs_uint64
984 RPCOpStat_BytesSent(void *blob) {
985 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
986 return rpcop_stat->bytes_sent;
989 static_inline afs_uint64
990 RPCOpStat_BytesRcvd(void *blob) {
991 rx_function_entry_v1_p rpcop_stat = (rx_function_entry_v1_p)blob;
992 return rpcop_stat->bytes_rcvd;
994 #endif /* !KDUMP_RX_LOCK */