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