122 lines
3.2 KiB
C
Executable File
122 lines
3.2 KiB
C
Executable File
/*
|
|
* rpcsock.h Declarations for the RPC call interface.
|
|
*
|
|
* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
|
|
*/
|
|
|
|
|
|
#ifndef _LINUX_RPCSOCK_H
|
|
#define _LINUX_RPCSOCK_H
|
|
|
|
/*
|
|
* The rpcsock code maintains an estimate on the maximum number of out-
|
|
* standing RPC requests, using the congestion avoidance implemented in
|
|
* 44BSD. This is basically the Van Jacobson slow start algorithm: If a
|
|
* retransmit occurs, the congestion window is halved; otherwise, it is
|
|
* incremented by 1/cwnd when a reply is received and a full number of
|
|
* requests are outstanding.
|
|
*
|
|
* Upper procedures may check whether a request would block waiting for
|
|
* a free RPC slot by using the RPC_CONGESTED() macro.
|
|
*
|
|
* Note: on machines with low memory we should probably use a smaller
|
|
* MAXREQS value: At 32 outstanding reqs with 8 megs of RAM, fragment
|
|
* reassembly will frequently run out of memory.
|
|
*/
|
|
#define RPC_MAXREQS 32
|
|
#define RPC_CWNDSCALE 256
|
|
#define RPC_MAXCWND (RPC_MAXREQS * RPC_CWNDSCALE)
|
|
/* #define RPC_INITCWND (RPC_MAXCWND / 2) */
|
|
#define RPC_INITCWND RPC_CWNDSCALE
|
|
#define RPC_CONGESTED(rsock) ((rsock)->cong >= (rsock)->cwnd)
|
|
|
|
/* RPC reply header size: xid, direction, status, accept_status (verifier
|
|
* size computed separately)
|
|
*/
|
|
#define RPC_HDRSIZE (4 * 4)
|
|
|
|
/*
|
|
* This describes a timeout strategy
|
|
*/
|
|
struct rpc_timeout {
|
|
unsigned long to_initval,
|
|
to_maxval,
|
|
to_increment;
|
|
int to_retries;
|
|
char to_exponential;
|
|
};
|
|
|
|
/*
|
|
* This describes a complete RPC request
|
|
*/
|
|
struct rpc_ioreq {
|
|
struct rpc_wait * rq_slot;
|
|
struct sockaddr * rq_addr;
|
|
int rq_alen;
|
|
struct iovec rq_svec[UIO_FASTIOV];
|
|
unsigned int rq_snr;
|
|
unsigned long rq_slen;
|
|
struct iovec rq_rvec[UIO_FASTIOV];
|
|
unsigned int rq_rnr;
|
|
unsigned long rq_rlen;
|
|
};
|
|
|
|
/*
|
|
* This is the callback handler for async RPC.
|
|
*/
|
|
struct rpc_wait;
|
|
typedef void (*rpc_callback_fn_t)(int, struct rpc_wait *, void *);
|
|
|
|
/*
|
|
* Wait information. This struct defines all the state of an RPC
|
|
* request currently in flight.
|
|
*/
|
|
struct rpc_wait {
|
|
struct rpc_sock * w_sock;
|
|
struct rpc_wait * w_prev;
|
|
struct rpc_wait * w_next;
|
|
struct rpc_ioreq * w_req;
|
|
int w_result;
|
|
wait_queue_head_t w_wait;
|
|
rpc_callback_fn_t w_handler;
|
|
void * w_cdata;
|
|
char w_queued;
|
|
char w_gotit;
|
|
__u32 w_xid;
|
|
};
|
|
|
|
struct rpc_sock {
|
|
struct file * file;
|
|
struct socket * sock;
|
|
struct sock * inet;
|
|
struct rpc_wait waiting[RPC_MAXREQS];
|
|
unsigned long cong;
|
|
unsigned long cwnd;
|
|
struct rpc_wait * pending;
|
|
struct rpc_wait * free;
|
|
wait_queue_head_t backlog;
|
|
wait_queue_head_t shutwait;
|
|
int shutdown;
|
|
};
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
/* rpc_call: Call synchronously */
|
|
int rpc_call(struct rpc_sock *, struct rpc_ioreq *,
|
|
struct rpc_timeout *);
|
|
/* These implement asynch calls for nfsiod: Process calls rpc_reserve and
|
|
* rpc_transmits, then passes the request to nfsiod, which collects the
|
|
* results via rpc_doio
|
|
*/
|
|
int rpc_reserve(struct rpc_sock *, struct rpc_ioreq *, int);
|
|
void rpc_release(struct rpc_sock *, struct rpc_ioreq *);
|
|
int rpc_transmit(struct rpc_sock *, struct rpc_ioreq *);
|
|
int rpc_doio(struct rpc_sock *, struct rpc_ioreq *,
|
|
struct rpc_timeout *, int);
|
|
struct rpc_sock * rpc_makesock(struct file *);
|
|
int rpc_closesock(struct rpc_sock *);
|
|
|
|
#endif /* __KERNEL__*/
|
|
|
|
#endif /* _LINUX_RPCSOCK_H */
|