home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / sunrpc / xprt.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  9.6 KB  |  336 lines
  1. /*
  2.  *  linux/include/linux/sunrpc/xprt.h
  3.  *
  4.  *  Declarations for the RPC transport interface.
  5.  *
  6.  *  Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9. #ifndef _LINUX_SUNRPC_XPRT_H
  10. #define _LINUX_SUNRPC_XPRT_H
  11.  
  12. #include <linux/uio.h>
  13. #include <linux/socket.h>
  14. #include <linux/in.h>
  15. #include <linux/kref.h>
  16. #include <linux/sunrpc/sched.h>
  17. #include <linux/sunrpc/xdr.h>
  18. #include <linux/sunrpc/msg_prot.h>
  19.  
  20. #ifdef __KERNEL__
  21.  
  22. #define RPC_MIN_SLOT_TABLE    (2U)
  23. #define RPC_DEF_SLOT_TABLE    (16U)
  24. #define RPC_MAX_SLOT_TABLE    (128U)
  25.  
  26. /*
  27.  * This describes a timeout strategy
  28.  */
  29. struct rpc_timeout {
  30.     unsigned long        to_initval,        /* initial timeout */
  31.                 to_maxval,        /* max timeout */
  32.                 to_increment;        /* if !exponential */
  33.     unsigned int        to_retries;        /* max # of retries */
  34.     unsigned char        to_exponential;
  35. };
  36.  
  37. enum rpc_display_format_t {
  38.     RPC_DISPLAY_ADDR = 0,
  39.     RPC_DISPLAY_PORT,
  40.     RPC_DISPLAY_PROTO,
  41.     RPC_DISPLAY_ALL,
  42.     RPC_DISPLAY_HEX_ADDR,
  43.     RPC_DISPLAY_HEX_PORT,
  44.     RPC_DISPLAY_UNIVERSAL_ADDR,
  45.     RPC_DISPLAY_NETID,
  46.     RPC_DISPLAY_MAX,
  47. };
  48.  
  49. struct rpc_task;
  50. struct rpc_xprt;
  51. struct seq_file;
  52.  
  53. /*
  54.  * This describes a complete RPC request
  55.  */
  56. struct rpc_rqst {
  57.     /*
  58.      * This is the user-visible part
  59.      */
  60.     struct rpc_xprt *    rq_xprt;        /* RPC client */
  61.     struct xdr_buf        rq_snd_buf;        /* send buffer */
  62.     struct xdr_buf        rq_rcv_buf;        /* recv buffer */
  63.  
  64.     /*
  65.      * This is the private part
  66.      */
  67.     struct rpc_task *    rq_task;    /* RPC task data */
  68.     __be32            rq_xid;        /* request XID */
  69.     int            rq_cong;    /* has incremented xprt->cong */
  70.     int            rq_received;    /* receive completed */
  71.     u32            rq_seqno;    /* gss seq no. used on req. */
  72.     int            rq_enc_pages_num;
  73.     struct page        **rq_enc_pages;    /* scratch pages for use by
  74.                            gss privacy code */
  75.     void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
  76.     struct list_head    rq_list;
  77.  
  78.     __u32 *            rq_buffer;    /* XDR encode buffer */
  79.     size_t            rq_bufsize,
  80.                 rq_callsize,
  81.                 rq_rcvsize;
  82.  
  83.     struct xdr_buf        rq_private_buf;        /* The receive buffer
  84.                              * used in the softirq.
  85.                              */
  86.     unsigned long        rq_majortimeo;    /* major timeout alarm */
  87.     unsigned long        rq_timeout;    /* Current timeout value */
  88.     unsigned int        rq_retries;    /* # of retries */
  89.     unsigned int        rq_connect_cookie;
  90.                         /* A cookie used to track the
  91.                            state of the transport
  92.                            connection */
  93.     
  94.     /*
  95.      * Partial send handling
  96.      */
  97.     u32            rq_bytes_sent;    /* Bytes we have sent */
  98.  
  99.     unsigned long        rq_xtime;    /* when transmitted */
  100.     int            rq_ntrans;
  101. };
  102. #define rq_svec            rq_snd_buf.head
  103. #define rq_slen            rq_snd_buf.len
  104.  
  105. struct rpc_xprt_ops {
  106.     void        (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
  107.     int        (*reserve_xprt)(struct rpc_task *task);
  108.     void        (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
  109.     void        (*rpcbind)(struct rpc_task *task);
  110.     void        (*set_port)(struct rpc_xprt *xprt, unsigned short port);
  111.     void        (*connect)(struct rpc_task *task);
  112.     void *        (*buf_alloc)(struct rpc_task *task, size_t size);
  113.     void        (*buf_free)(void *buffer);
  114.     int        (*send_request)(struct rpc_task *task);
  115.     void        (*set_retrans_timeout)(struct rpc_task *task);
  116.     void        (*timer)(struct rpc_task *task);
  117.     void        (*release_request)(struct rpc_task *task);
  118.     void        (*close)(struct rpc_xprt *xprt);
  119.     void        (*destroy)(struct rpc_xprt *xprt);
  120.     void        (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
  121. };
  122.  
  123. struct rpc_xprt {
  124.     struct kref        kref;        /* Reference count */
  125.     struct rpc_xprt_ops *    ops;        /* transport methods */
  126.  
  127.     const struct rpc_timeout *timeout;    /* timeout parms */
  128.     struct sockaddr_storage    addr;        /* server address */
  129.     size_t            addrlen;    /* size of server address */
  130.     int            prot;        /* IP protocol */
  131.  
  132.     unsigned long        cong;        /* current congestion */
  133.     unsigned long        cwnd;        /* congestion window */
  134.  
  135.     size_t            max_payload;    /* largest RPC payload size,
  136.                            in bytes */
  137.     unsigned int        tsh_size;    /* size of transport specific
  138.                            header */
  139.  
  140.     struct rpc_wait_queue    binding;    /* requests waiting on rpcbind */
  141.     struct rpc_wait_queue    sending;    /* requests waiting to send */
  142.     struct rpc_wait_queue    resend;        /* requests waiting to resend */
  143.     struct rpc_wait_queue    pending;    /* requests in flight */
  144.     struct rpc_wait_queue    backlog;    /* waiting for slot */
  145.     struct list_head    free;        /* free slots */
  146.     struct rpc_rqst *    slot;        /* slot table storage */
  147.     unsigned int        max_reqs;    /* total slots */
  148.     unsigned long        state;        /* transport state */
  149.     unsigned char        shutdown   : 1,    /* being shut down */
  150.                 resvport   : 1; /* use a reserved port */
  151.     unsigned int        bind_index;    /* bind function index */
  152.  
  153.     /*
  154.      * Connection of transports
  155.      */
  156.     unsigned long        connect_timeout,
  157.                 bind_timeout,
  158.                 reestablish_timeout;
  159.     unsigned int        connect_cookie;    /* A cookie that gets bumped
  160.                            every time the transport
  161.                            is reconnected */
  162.  
  163.     /*
  164.      * Disconnection of idle transports
  165.      */
  166.     struct work_struct    task_cleanup;
  167.     struct timer_list    timer;
  168.     unsigned long        last_used,
  169.                 idle_timeout;
  170.  
  171.     /*
  172.      * Send stuff
  173.      */
  174.     spinlock_t        transport_lock;    /* lock transport info */
  175.     spinlock_t        reserve_lock;    /* lock slot table */
  176.     u32            xid;        /* Next XID value to use */
  177.     struct rpc_task *    snd_task;    /* Task blocked in send */
  178.     struct list_head    recv;
  179.  
  180.     struct {
  181.         unsigned long        bind_count,    /* total number of binds */
  182.                     connect_count,    /* total number of connects */
  183.                     connect_start,    /* connect start timestamp */
  184.                     connect_time,    /* jiffies waiting for connect */
  185.                     sends,        /* how many complete requests */
  186.                     recvs,        /* how many complete requests */
  187.                     bad_xids;    /* lookup_rqst didn't find XID */
  188.  
  189.         unsigned long long    req_u,        /* average requests on the wire */
  190.                     bklog_u;    /* backlog queue utilization */
  191.     } stat;
  192.  
  193.     const char        *address_strings[RPC_DISPLAY_MAX];
  194. };
  195.  
  196. struct xprt_create {
  197.     int            ident;        /* XPRT_TRANSPORT identifier */
  198.     struct sockaddr *    srcaddr;    /* optional local address */
  199.     struct sockaddr *    dstaddr;    /* remote peer address */
  200.     size_t            addrlen;
  201. };
  202.  
  203. struct xprt_class {
  204.     struct list_head    list;
  205.     int            ident;        /* XPRT_TRANSPORT identifier */
  206.     struct rpc_xprt *    (*setup)(struct xprt_create *);
  207.     struct module        *owner;
  208.     char            name[32];
  209. };
  210.  
  211. /*
  212.  * Generic internal transport functions
  213.  */
  214. struct rpc_xprt        *xprt_create_transport(struct xprt_create *args);
  215. void            xprt_connect(struct rpc_task *task);
  216. void            xprt_reserve(struct rpc_task *task);
  217. int            xprt_reserve_xprt(struct rpc_task *task);
  218. int            xprt_reserve_xprt_cong(struct rpc_task *task);
  219. int            xprt_prepare_transmit(struct rpc_task *task);
  220. void            xprt_transmit(struct rpc_task *task);
  221. void            xprt_end_transmit(struct rpc_task *task);
  222. int            xprt_adjust_timeout(struct rpc_rqst *req);
  223. void            xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
  224. void            xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
  225. void            xprt_release(struct rpc_task *task);
  226. struct rpc_xprt *    xprt_get(struct rpc_xprt *xprt);
  227. void            xprt_put(struct rpc_xprt *xprt);
  228.  
  229. static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
  230. {
  231.     return p + xprt->tsh_size;
  232. }
  233.  
  234. /*
  235.  * Transport switch helper functions
  236.  */
  237. int            xprt_register_transport(struct xprt_class *type);
  238. int            xprt_unregister_transport(struct xprt_class *type);
  239. void            xprt_set_retrans_timeout_def(struct rpc_task *task);
  240. void            xprt_set_retrans_timeout_rtt(struct rpc_task *task);
  241. void            xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
  242. void            xprt_wait_for_buffer_space(struct rpc_task *task, rpc_action action);
  243. void            xprt_write_space(struct rpc_xprt *xprt);
  244. void            xprt_update_rtt(struct rpc_task *task);
  245. void            xprt_adjust_cwnd(struct rpc_task *task, int result);
  246. struct rpc_rqst *    xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
  247. void            xprt_complete_rqst(struct rpc_task *task, int copied);
  248. void            xprt_release_rqst_cong(struct rpc_task *task);
  249. void            xprt_disconnect_done(struct rpc_xprt *xprt);
  250. void            xprt_force_disconnect(struct rpc_xprt *xprt);
  251. void            xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
  252.  
  253. /*
  254.  * Reserved bit positions in xprt->state
  255.  */
  256. #define XPRT_LOCKED        (0)
  257. #define XPRT_CONNECTED        (1)
  258. #define XPRT_CONNECTING        (2)
  259. #define XPRT_CLOSE_WAIT        (3)
  260. #define XPRT_BOUND        (4)
  261. #define XPRT_BINDING        (5)
  262. #define XPRT_CLOSING        (6)
  263.  
  264. static inline void xprt_set_connected(struct rpc_xprt *xprt)
  265. {
  266.     set_bit(XPRT_CONNECTED, &xprt->state);
  267. }
  268.  
  269. static inline void xprt_clear_connected(struct rpc_xprt *xprt)
  270. {
  271.     clear_bit(XPRT_CONNECTED, &xprt->state);
  272. }
  273.  
  274. static inline int xprt_connected(struct rpc_xprt *xprt)
  275. {
  276.     return test_bit(XPRT_CONNECTED, &xprt->state);
  277. }
  278.  
  279. static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt)
  280. {
  281.     return test_and_set_bit(XPRT_CONNECTED, &xprt->state);
  282. }
  283.  
  284. static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt)
  285. {
  286.     return test_and_clear_bit(XPRT_CONNECTED, &xprt->state);
  287. }
  288.  
  289. static inline void xprt_clear_connecting(struct rpc_xprt *xprt)
  290. {
  291.     smp_mb__before_clear_bit();
  292.     clear_bit(XPRT_CONNECTING, &xprt->state);
  293.     smp_mb__after_clear_bit();
  294. }
  295.  
  296. static inline int xprt_connecting(struct rpc_xprt *xprt)
  297. {
  298.     return test_bit(XPRT_CONNECTING, &xprt->state);
  299. }
  300.  
  301. static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt)
  302. {
  303.     return test_and_set_bit(XPRT_CONNECTING, &xprt->state);
  304. }
  305.  
  306. static inline void xprt_set_bound(struct rpc_xprt *xprt)
  307. {
  308.     test_and_set_bit(XPRT_BOUND, &xprt->state);
  309. }
  310.  
  311. static inline int xprt_bound(struct rpc_xprt *xprt)
  312. {
  313.     return test_bit(XPRT_BOUND, &xprt->state);
  314. }
  315.  
  316. static inline void xprt_clear_bound(struct rpc_xprt *xprt)
  317. {
  318.     clear_bit(XPRT_BOUND, &xprt->state);
  319. }
  320.  
  321. static inline void xprt_clear_binding(struct rpc_xprt *xprt)
  322. {
  323.     smp_mb__before_clear_bit();
  324.     clear_bit(XPRT_BINDING, &xprt->state);
  325.     smp_mb__after_clear_bit();
  326. }
  327.  
  328. static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
  329. {
  330.     return test_and_set_bit(XPRT_BINDING, &xprt->state);
  331. }
  332.  
  333. #endif /* __KERNEL__*/
  334.  
  335. #endif /* _LINUX_SUNRPC_XPRT_H */
  336.